1Alien::Build(3)       User Contributed Perl Documentation      Alien::Build(3)
2
3
4

NAME

6       Alien::Build - Build external dependencies for use in CPAN
7

VERSION

9       version 2.38
10

SYNOPSIS

12        my $build = Alien::Build->load('./alienfile');
13        $build->load_requires('configure');
14        $build->set_prefix('/usr/local');
15        $build->set_stage('/foo/mystage');  # needs to be absolute
16        $build->load_requires($build->install_type);
17        $build->download;
18        $build->build;
19        # files are now in /foo/mystage, it is your job (or
20        # ExtUtils::MakeMaker, Module::Build, etc) to copy
21        # those files into /usr/local
22

DESCRIPTION

24       This module provides tools for building external (non-CPAN)
25       dependencies for CPAN.  It is mainly designed to be used at install
26       time of a CPAN client, and work closely with Alien::Base which is used
27       at runtime.
28
29       This is the detailed documentation for the Alien::Build class.  If you
30       are starting out you probably want to do so from one of these
31       documents:
32
33       Alien::Build::Manual::Alien
34           A broad overview of "Alien-Build" and its ecosystem.
35
36       Alien::Build::Manual::AlienUser
37           For users of an "Alien::libfoo" that is implemented using
38           Alien::Base.  (The developer of "Alien::libfoo" should provide the
39           documentation necessary, but if not, this is the place to start).
40
41       Alien::Build::Manual::AlienAuthor
42           If you are writing your own Alien based on Alien::Build and
43           Alien::Base.
44
45       Alien::Build::Manual::FAQ
46           If you have a common question that has already been answered, like
47           "How do I use alienfile with some build system".
48
49       Alien::Build::Manual::PluginAuthor
50           This is for the brave souls who want to write plugins that will
51           work with Alien::Build + alienfile.
52
53       Note that you will not usually create a Alien::Build instance directly,
54       but rather be using a thin installer layer, such as Alien::Build::MM
55       (for use with ExtUtils::MakeMaker) or Alien::Build::MB (for use with
56       Module::Build).  One of the goals of this project is to remain
57       installer agnostic.
58

CONSTRUCTORS

60   new
61        my $build = Alien::Build->new;
62
63       This creates a new empty instance of Alien::Build.  Normally you will
64       want to use "load" below to create an instance of Alien::Build from an
65       alienfile recipe.
66
67   load
68        my $build = Alien::Build->load($alienfile);
69
70       This creates an Alien::Build instance with the given alienfile recipe.
71
72   resume
73        my $build = Alien::Build->resume($alienfile, $root);
74
75       Load a checkpointed Alien::Build instance.  You will need the original
76       alienfile and the build root (usually "_alien"), and a build that had
77       been properly checkpointed using the "checkpoint" method below.
78

PROPERTIES

80       There are three main properties for Alien::Build.  There are a number
81       of properties documented here with a specific usage.  Note that these
82       properties may need to be serialized into something primitive like JSON
83       that does not support: regular expressions, code references of blessed
84       objects.
85
86       If you are writing a plugin (Alien::Build::Plugin) you should use a
87       prefix like "plugin_name" (where name is the name of your plugin) so
88       that it does not interfere with other plugin or future versions of
89       Alien::Build.  For example, if you were writing
90       "Alien::Build::Plugin::Fetch::NewProtocol", please use the prefix
91       "plugin_fetch_newprotocol":
92
93        sub init
94        {
95          my($self, $meta) = @_;
96
97          $meta->prop( plugin_fetch_newprotocol_foo => 'some value' );
98
99          $meta->register_hook(
100            some_hook => sub {
101              my($build) = @_;
102              $build->install_prop->{plugin_fetch_newprotocol_bar} = 'some other value';
103              $build->runtime_prop->{plugin_fetch_newprotocol_baz} = 'and another value';
104            }
105          );
106        }
107
108       If you are writing a alienfile recipe please use the prefix "my_":
109
110        use alienfile;
111
112        meta_prop->{my_foo} = 'some value';
113
114        probe sub {
115          my($build) = @_;
116          $build->install_prop->{my_bar} = 'some other value';
117          $build->install_prop->{my_baz} = 'and another value';
118        };
119
120       Any property may be used from a command:
121
122        probe [ 'some command %{.meta.plugin_fetch_newprotocol_foo}' ];
123        probe [ 'some command %{.install.plugin_fetch_newprotocol_bar}' ];
124        probe [ 'some command %{.runtime.plugin_fetch_newprotocol_baz}' ];
125        probe [ 'some command %{.meta.my_foo}' ];
126        probe [ 'some command %{.install.my_bar}' ];
127        probe [ 'some command %{.runtime.my_baz}' ];
128
129   meta_prop
130        my $href = $build->meta_prop;
131        my $href = Alien::Build->meta_prop;
132
133       Meta properties have to do with the recipe itself, and not any
134       particular instance that probes or builds that recipe.  Meta properties
135       can be changed from within an alienfile using the "meta_prop"
136       directive, or from a plugin from its "init" method (though should NOT
137       be modified from any hooks registered within that "init" method).  This
138       is not strictly enforced, but if you do not follow this rule your
139       recipe will likely be broken.
140
141       arch
142           This is a hint to an installer like Alien::Build::MM or
143           Alien::Build::MB, that the library or tool contains architecture
144           dependent files and so should be stored in an architecture
145           dependent location.  If not specified by your alienfile then it
146           will be set to true.
147
148       destdir
149           Use the "DESTDIR" environment variable to stage your install before
150           copying the files into "blib".  This is the preferred method of
151           installing libraries because it improves reliability.  This
152           technique is supported by "autoconf" and others.
153
154       destdir_filter
155           Regular expression for the files that should be copied from the
156           "DESTDIR" into the stage directory.  If not defined, then all files
157           will be copied.
158
159       destdir_ffi_filter
160           Same as "destdir_filter" except applies to "build_ffi" instead of
161           "build".
162
163       env Environment variables to override during the build stage.
164
165       env_interpolate
166           Environment variable values will be interpolated with helpers.
167           Example:
168
169            meta->prop->{env_interpolate} = 1;
170            meta->prop->{env}->{PERL} = '%{perl}';
171
172       local_source
173           Set to true if source code package is available locally.  (that is
174           not fetched over the internet).  This is computed by default based
175           on the "start_url" property.  Can be set by an alienfile or plugin.
176
177       platform
178           Hash reference.  Contains information about the platform beyond
179           just $^O.
180
181           compiler_type
182               Refers to the type of flags that the compiler accepts.  May be
183               expanded in the future, but for now, will be one of:
184
185               microsoft
186                   On Windows when using Microsoft Visual C++
187
188               unix
189                   Virtually everything else, including gcc on windows.
190
191               The main difference is that with Visual C++ "-LIBPATH" should
192               be used instead of "-L", and static libraries should have the
193               ".LIB" suffix instead of ".a".
194
195           system_type
196               $^O is frequently good enough to make platform specific logic
197               in your alienfile, this handles the case when $^O can cover
198               platforms that provide multiple environments that Perl might
199               run under.  The main example is windows, but others may be
200               added in the future.
201
202               unix
203               vms
204               windows-activestate
205               windows-microsoft
206               windows-mingw
207               windows-strawberry
208               windows-unknown
209
210               Note that "cygwin" and "msys" are considered "unix" even though
211               they run on windows!
212
213       out_of_source
214           Build in a different directory from the where the source code is
215           stored.  In autoconf this is referred to as a "VPATH" build.
216           Everyone else calls this an "out-of-source" build.  When this
217           property is true, instead of extracting to the source build root,
218           the downloaded source will be extracted to an source extraction
219           directory and the source build root will be empty.  You can use the
220           "extract" install property to get the location of the extracted
221           source.
222
223       network
224           True if a network fetch is available.  This should NOT be set by an
225           alienfile or plugin.  This is computed based on the
226           "ALIEN_INSTALL_NETWORK" environment variables.
227
228       start_url
229           The default or start URL used by fetch plugins.
230
231   install_prop
232        my $href = $build->install_prop;
233
234       Install properties are used during the install phase (either under
235       "share" or "system" install).  They are remembered for the entire
236       install phase, but not kept around during the runtime phase.  Thus they
237       cannot be accessed from your Alien::Base based module.
238
239       autoconf_prefix
240           The prefix as understood by autoconf.  This is only different on
241           Windows Where MSYS is used and paths like "C:/foo" are  represented
242           as "/C/foo" which are understood by the MSYS tools, but not by
243           Perl.  You should only use this if you are using
244           Alien::Build::Plugin::Autoconf in your alienfile.
245
246       download
247           The location of the downloaded archive (tar.gz, or similar) or
248           directory.
249
250       env Environment variables to override during the build stage.
251
252       extract
253           The location of the last source extraction.  For a "out-of-source"
254           build (see the "out_of_source" meta property above), this will only
255           be set once.  For other types of builds, the source code may be
256           extracted multiple times, and thus this property may change.
257
258       old Hash containing information on a previously installed Alien of the
259           same name, if available.  This may be useful in cases where you
260           want to reuse the previous install if it is still sufficient.
261
262           prefix
263               The prefix for the previous install.  Versions prior to 1.42
264               unfortunately had this in typo form of "preifx".
265
266           runtime
267               The runtime properties from the previous install.
268
269       patch
270           Directory with patches.
271
272       prefix
273           The install time prefix.  Under a "destdir" install this is the
274           same as the runtime or final install location.  Under a
275           non-"destdir" install this is the "stage" directory (usually the
276           appropriate share directory under "blib").
277
278       root
279           The build root directory.  This will be an absolute path.  It is
280           the absolute form of "./_alien" by default.
281
282       stage
283           The stage directory where files will be copied.  This is usually
284           the root of the blib share directory.
285
286       system_probe_class
287           After the probe step this property may contain the plugin class
288           that performed the system probe.  It shouldn't be filled in
289           directly by the plugin (instead if should use the hook property
290           "probe_class", see below).  This is optional, and not all probe
291           plugins will provide this information.
292
293       system_probe_instance_id
294           After the probe step this property may contain the plugin instance
295           id that performed the system probe.  It shouldn't be filled in
296           directly by the plugin (instead if should use the hook property
297           "probe_instance_id", see below).  This is optional, and not all
298           probe plugins will provide this information.
299
300   plugin_instance_prop
301        my $href = $build->plugin_instance_prop($plugin);
302
303       This returns the private plugin instance properties for a given plugin.
304       This method should usually only be called internally by plugins
305       themselves to keep track of internal state.  Because the content can be
306       used arbitrarily by the owning plugin because it is private to the
307       plugin, and thus is not part of the Alien::Build spec.
308
309   runtime_prop
310        my $href = $build->runtime_prop;
311
312       Runtime properties are used during the install and runtime phases
313       (either under "share" or "system" install).  This should include
314       anything that you will need to know to use the library or tool during
315       runtime, and shouldn't include anything that is no longer relevant once
316       the install process is complete.
317
318       alien_build_version
319           The version of Alien::Build used to install the library or tool.
320
321       alt Alternate configurations.  If the alienized package has multiple
322           libraries this could be used to store the different compiler or
323           linker flags for each library.
324
325       cflags
326           The compiler flags
327
328       cflags_static
329           The static compiler flags
330
331       command
332           The command name for tools where the name my differ from platform
333           to platform.  For example, the GNU version of make is usually
334           "make" in Linux and "gmake" on FreeBSD.
335
336       ffi_name
337           The name DLL or shared object "name" to use when searching for
338           dynamic libraries at runtime.  This is passed into FFI::CheckLib,
339           so if your library is something like "libarchive.so" or
340           "archive.dll" you would set this to "archive".  This may be a
341           string or an array of strings.
342
343       ffi_checklib
344           This property contains two sub properties:
345
346           share
347                $build->runtime_prop->{ffi_checklib}->{share} = [ ... ];
348
349               Array of additional FFI::CheckLib flags to pass in to
350               "find_lib" for a "share" install.
351
352           system
353               Array of additional FFI::CheckLib flags to pass in to
354               "find_lib" for a "system" install.
355
356               Among other things, useful for specifying the
357               "try_linker_script" flag:
358
359                $build->runtime_prop->{ffi_checklib}->{system} = [ try_linker_script => 1 ];
360
361       install_type
362           The install type.  Is one of:
363
364           system
365               For when the library or tool is provided by the operating
366               system, can be detected by Alien::Build, and is considered
367               satisfactory by the "alienfile" recipe.
368
369           share
370               For when a system install is not possible, the library source
371               will be downloaded from the internet or retrieved in another
372               appropriate fashion and built.
373
374       libs
375           The library flags
376
377       libs_static
378           The static library flags
379
380       perl_module_version
381           The version of the Perl module used to install the alien (if
382           available).  For example if Alien::curl is installing "libcurl"
383           this would be the version of Alien::curl used during the install
384           step.
385
386       prefix
387           The final install root.  This is usually they share directory.
388
389       version
390           The version of the library or tool
391
392   hook_prop
393        my $href = $build->hook_prop;
394
395       Hook properties are for the currently running (if any) hook.  They are
396       used only during the execution of each hook and are discarded after.
397       If no hook is currently running then "hook_prop" will return "undef".
398
399       name
400           The name of the currently running hook.
401
402       version (probe)
403           Probe and PkgConfig plugins may set this property indicating the
404           version of the alienized package.  Not all plugins and
405           configurations may be able to provide this.
406
407       probe_class (probe)
408           Probe and PkgConfig plugins may set this property indicating the
409           plugin class that made the probe.  If the probe results in a system
410           install this will be propagated to "system_probe_class" for later
411           use.
412
413       probe_instance_id (probe)
414           Probe and PkgConfig plugins may set this property indicating the
415           plugin instance id that made the probe.  If the probe results in a
416           system install this will be propagated to
417           "system_probe_instance_id" for later use.
418

METHODS

420   checkpoint
421        $build->checkpoint;
422
423       Save any install or runtime properties so that they can be reloaded on
424       a subsequent run in a separate process.  This is useful if your build
425       needs to be done in multiple stages from a "Makefile", such as with
426       ExtUtils::MakeMaker.  Once checkpointed you can use the "resume"
427       constructor (documented above) to resume the probe/build/install]
428       process.
429
430   root
431        my $dir = $build->root;
432
433       This is just a shortcut for:
434
435        my $root = $build->install_prop->{root};
436
437       Except that it will be created if it does not already exist.
438
439   install_type
440        my $type = $build->install_type;
441
442       This will return the install type.  (See the like named install
443       property above for details).  This method will call "probe" if it has
444       not already been called.
445
446   set_prefix
447        $build->set_prefix($prefix);
448
449       Set the final (unstaged) prefix.  This is normally only called by
450       Alien::Build::MM and similar modules.  It is not intended for use from
451       plugins or from an alienfile.
452
453   set_stage
454        $build->set_stage($dir);
455
456       Sets the stage directory.  This is normally only called by
457       Alien::Build::MM and similar modules.  It is not intended for use from
458       plugins or from an alienfile.
459
460   requires
461        my $hash = $build->requires($phase);
462
463       Returns a hash reference of the modules required for the given phase.
464       Phases include:
465
466       configure
467           These modules must already be available when the alienfile is read.
468
469       any These modules are used during either a "system" or "share" install.
470
471       share
472           These modules are used during the build phase of a "share" install.
473
474       system
475           These modules are used during the build phase of a "system"
476           install.
477
478   load_requires
479        $build->load_requires($phase);
480
481       This loads the appropriate modules for the given phase (see "requires"
482       above for a description of the phases).
483
484   probe
485        my $install_type = $build->probe;
486
487       Attempts to determine if the operating system has the library or tool
488       already installed.  If so, then the string "system" will be returned
489       and a system install will be performed.  If not, then the string
490       "share" will be installed and the tool or library will be downloaded
491       and built from source.
492
493       If the environment variable "ALIEN_INSTALL_TYPE" is set, then that will
494       force a specific type of install.  If the detection logic cannot
495       accommodate the install type requested then it will fail with an
496       exception.
497
498   download
499        $build->download;
500
501       Download the source, usually as a tarball, usually from the internet.
502
503       Under a "system" install this does not do anything.
504
505   fetch
506        my $res = $build->fetch;
507        my $res = $build->fetch($url);
508
509       Fetch a resource using the fetch hook.  Returns the same hash structure
510       described below in the hook documentation.
511
512   decode
513        my $decoded_res = $build->decode($res);
514
515       Decode the HTML or file listing returned by "fetch".  Returns the same
516       hash structure described below in the hook documentation.
517
518   prefer
519        my $sorted_res = $build->prefer($res);
520
521       Filter and sort candidates.  The preferred candidate will be returned
522       first in the list.  The worst candidate will be returned last.  Returns
523       the same hash structure described below in the hook documentation.
524
525   extract
526        my $dir = $build->extract;
527        my $dir = $build->extract($archive);
528
529       Extracts the given archive into a fresh directory.  This is normally
530       called internally to Alien::Build, and for normal usage is not needed
531       from a plugin or alienfile.
532
533   build
534        $build->build;
535
536       Run the build step.  It is expected that "probe" and "download" have
537       already been performed.  What it actually does depends on the type of
538       install:
539
540       share
541           The source is extracted, and built as determined by the alienfile
542           recipe.  If there is a "gather_share" that will be executed last.
543
544       system
545           The "gather_system" hook will be executed.
546
547   test
548        $build->test;
549
550       Run the test phase
551
552   clean_install
553        $build->clean_install
554
555       Clean files from the final install location.  The default
556       implementation removes all files recursively except for the "_alien"
557       directory.  This is helpful when you have an old install with files
558       that may break the new build.
559
560       For a non-share install this doesn't do anything.
561
562   system
563        $build->system($command);
564        $build->system($command, @args);
565
566       Interpolates the command and arguments and run the results using the
567       Perl "system" command.
568
569   log
570        $build->log($message);
571
572       Send a message to the log.  By default this prints to "STDOUT".
573
574   meta
575        my $meta = Alien::Build->meta;
576        my $meta = $build->meta;
577
578       Returns the meta object for your Alien::Build class or instance.  The
579       meta object is a way to manipulate the recipe, and so any changes to
580       the meta object should be made before the "probe", "download" or
581       "build" steps.
582

META METHODS

584   prop
585        my $href = $build->meta->prop;
586
587       Meta properties.  This is the same as calling "meta_prop" on the class
588       or Alien::Build instance.
589
590   add_requires
591        Alien::Build->meta->add_requires($phase, $module => $version, ...);
592
593       Add the requirement to the given phase.  Phase should be one of:
594
595       configure
596       any
597       share
598       system
599
600   interpolator
601        my $interpolator = $build->meta->interpolator;
602        my $interpolator = Alien::Build->interpolator;
603
604       Returns the Alien::Build::Interpolate instance for the Alien::Build
605       class.
606
607   has_hook
608        my $bool = $build->meta->has_hook($name);
609        my $bool = Alien::Build->has_hook($name);
610
611       Returns if there is a usable hook registered with the given name.
612
613   register_hook
614        $build->meta->register_hook($name, $instructions);
615        Alien::Build->meta->register_hook($name, $instructions);
616
617       Register a hook with the given name.  $instruction should be either a
618       code reference, or a command sequence, which is an array reference.
619
620   default_hook
621        $build->meta->default_hook($name, $instructions);
622        Alien::Build->meta->default_hook($name, $instructions);
623
624       Register a default hook, which will be used if the alienfile does not
625       register its own hook with that name.
626
627   around_hook
628        $build->meta->around_hook($hook, $code);
629        Alien::Build->meta->around_hook($name, $code);
630
631       Wrap the given hook with a code reference.  This is similar to a Moose
632       method modifier, except that it wraps around the given hook instead of
633       a method.  For example, this will add a probe system requirement:
634
635        $build->meta->around_hook(
636          probe => sub {
637            my $orig = shift;
638            my $build = shift;
639            my $type = $orig->($build, @_);
640            return $type unless $type eq 'system';
641            # also require a configuration file
642            if(-f '/etc/foo.conf')
643            {
644              return 'system';
645            }
646            else
647            {
648              return 'share';
649            }
650          },
651        );
652
653   apply_plugin
654        Alien::Build->meta->apply_plugin($name);
655        Alien::Build->meta->apply_plugin($name, @args);
656
657       Apply the given plugin with the given arguments.
658

ENVIRONMENT

660       Alien::Build responds to these environment variables:
661
662       ALIEN_INSTALL_NETWORK
663           If set to true (the default), then network fetch will be allowed.
664           If set to false, then network fetch will not be allowed.
665
666           What constitutes a local vs. network fetch is determined based on
667           the "start_url" and "local_source" meta properties.  An alienfile
668           or plugin "could" override this detection (possibly
669           inappropriately), so this variable is not a substitute for properly
670           auditing of Perl modules for environments that require that.
671
672       ALIEN_INSTALL_TYPE
673           If set to "share" or "system", it will override the system
674           detection logic.  If set to "default", it will use the default
675           setting for the alienfile.  The behavior of other values is
676           undefined.
677
678           Although the recommended way for a consumer to use an Alien::Base
679           based Alien is to declare it as a static configure and build-time
680           dependency, some consumers may prefer to fallback on using an Alien
681           only when the consumer itself cannot detect the necessary package.
682           In some cases the consumer may want the user to opt-in to using an
683           Alien before requiring it.
684
685           To keep the interface consistent among Aliens, the consumer of the
686           fallback opt-in Alien may fallback on the Alien if the environment
687           variable "ALIEN_INSTALL_TYPE" is set to any value. The rationale is
688           that by setting this environment variable the user is aware that
689           Alien modules may be installed and have indicated consent.  The
690           actual implementation of this, by its nature would have to be in
691           the consuming CPAN module.
692
693       ALIEN_BUILD_LOG
694           The default log class used.  See Alien::Build::Log and
695           Alien::Build::Log::Default.
696
697       ALIEN_BUILD_RC
698           Perl source file which can override some global defaults for
699           Alien::Build, by, for example, setting preload and postload
700           plugins.
701
702       ALIEN_BUILD_PKG_CONFIG
703           Override the logic in Alien::Build::Plugin::PkgConfig::Negotiate
704           which chooses the best "pkg-config" plugin.
705
706       ALIEN_BUILD_PRELOAD
707           semicolon separated list of plugins to automatically load before
708           parsing your alienfile.
709
710       ALIEN_BUILD_POSTLOAD
711           semicolon separated list of plugins to automatically load after
712           parsing your alienfile.
713
714       DESTDIR
715           This environment variable will be manipulated during a destdir
716           install.
717
718       PKG_CONFIG
719           This environment variable can be used to override the program name
720           for "pkg-config" when using the command line plugin:
721           Alien::Build::Plugin::PkgConfig::CommandLine.
722
723       ftp_proxy, all_proxy
724           If these environment variables are set, it may influence the
725           Download negotiation plugin
726           Alien::Build::Plugin::Downaload::Negotiate.  Other proxy variables
727           may be used by some Fetch plugins, if they support it.
728

SUPPORT

730       The intent of the "Alien-Build" team is to support as best as possible
731       all Perls from 5.8.4 to the latest production version.  So long as they
732       are also supported by the Perl toolchain.
733
734       Please feel encouraged to report issues that you encounter to the
735       project GitHub Issue tracker:
736
737       <https://github.com/PerlAlien/Alien-Build/issues>
738
739       Better if you can fix the issue yourself, please feel encouraged to
740       open pull-request on the project GitHub:
741
742       <https://github.com/PerlAlien/Alien-Build/pulls>
743
744       If you are confounded and have questions, join us on the "#native"
745       channel on irc.perl.org.  The "Alien-Build" developers frequent this
746       channel and can probably help point you in the right direction.  If you
747       don't have an IRC client handy, you can use this web interface:
748
749       <https://chat.mibbit.com/?channel=%23native&server=irc.perl.org>
750

SEE ALSO

752       Alien::Build::Manual::AlienAuthor, Alien::Build::Manual::AlienUser,
753       Alien::Build::Manual::Contributing, Alien::Build::Manual::FAQ,
754       Alien::Build::Manual::PluginAuthor
755
756       alienfile, Alien::Build::MM, Alien::Build::Plugin, Alien::Base, Alien
757

THANKS

759       Alien::Base was originally written by Joel Berger, the rest of this
760       project would not have been possible without him getting the project
761       started.  Thanks to his support I have been able to augment the
762       original Alien::Base system with a reliable set of tools (Alien::Build,
763       alienfile, Test::Alien), which make up this toolset.
764
765       The original Alien::Base is still copyright (c) 2012-2020 Joel Berger.
766       It has the same license as the rest of the Alien::Build and related
767       tools distributed as "Alien-Build".  Joel Berger thanked a number of
768       people who helped in in the development of Alien::Base, in the
769       documentation for that module.
770
771       I would also like to acknowledge the other members of the PerlAlien
772       github organization, Zakariyya Mughal (sivoais, ZMUGHAL) and mohawk
773       (ETJ).  Also important in the early development of Alien::Build were
774       the early adopters Chase Whitener (genio, CAPOEIRAB, author of
775       Alien::libuv), William N. Braswell, Jr (willthechill, WBRASWELL, author
776       of Alien::JPCRE2 and Alien::PCRE2) and Ahmad Fatoum (a3f, ATHREEF,
777       author of Alien::libudev and Alien::LibUSB).
778
779       The Alien ecosystem owes a debt to Dan Book, who goes by Grinnz on IRC,
780       for answering question about how to use Alien::Build and friends.
781

AUTHOR

783       Author: Graham Ollis <plicease@cpan.org>
784
785       Contributors:
786
787       Diab Jerius (DJERIUS)
788
789       Roy Storey (KIWIROY)
790
791       Ilya Pavlov
792
793       David Mertens (run4flat)
794
795       Mark Nunberg (mordy, mnunberg)
796
797       Christian Walde (Mithaldu)
798
799       Brian Wightman (MidLifeXis)
800
801       Zaki Mughal (zmughal)
802
803       mohawk (mohawk2, ETJ)
804
805       Vikas N Kumar (vikasnkumar)
806
807       Flavio Poletti (polettix)
808
809       Salvador Fandiño (salva)
810
811       Gianni Ceccarelli (dakkar)
812
813       Pavel Shaydo (zwon, trinitum)
814
815       Kang-min Liu (劉康民, gugod)
816
817       Nicholas Shipp (nshp)
818
819       Juan Julián Merelo Guervós (JJ)
820
821       Joel Berger (JBERGER)
822
823       Petr Pisar (ppisar)
824
825       Lance Wicks (LANCEW)
826
827       Ahmad Fatoum (a3f, ATHREEF)
828
829       José Joaquín Atria (JJATRIA)
830
831       Duke Leto (LETO)
832
833       Shoichi Kaji (SKAJI)
834
835       Shawn Laffan (SLAFFAN)
836
837       Paul Evans (leonerd, PEVANS)
838
839       Håkon Hægland (hakonhagland, HAKONH)
840
842       This software is copyright (c) 2011-2020 by Graham Ollis.
843
844       This is free software; you can redistribute it and/or modify it under
845       the same terms as the Perl 5 programming language system itself.
846
847
848
849perl v5.32.0                      2021-01-12                   Alien::Build(3)
Impressum