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.47
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, %options);
508
509       Fetch a resource using the fetch hook.  Returns the same hash structure
510       described below in the hook documentation.
511
512       [version 2.39]
513
514       As of Alien::Build 2.39, these options are supported:
515
516       http_headers
517            my $res = $build->fetch($url, http_headers => [ $key1 => $value1, $key2 => $value 2, ... ]);
518
519           Set the HTTP request headers on all outgoing HTTP requests.  Note
520           that not all protocols or fetch plugins support setting request
521           headers, but the ones that do not should issue a warning if you try
522           to set request headers and they are not supported.
523
524   decode
525        my $decoded_res = $build->decode($res);
526
527       Decode the HTML or file listing returned by "fetch".  Returns the same
528       hash structure described below in the hook documentation.
529
530   prefer
531        my $sorted_res = $build->prefer($res);
532
533       Filter and sort candidates.  The preferred candidate will be returned
534       first in the list.  The worst candidate will be returned last.  Returns
535       the same hash structure described below in the hook documentation.
536
537   extract
538        my $dir = $build->extract;
539        my $dir = $build->extract($archive);
540
541       Extracts the given archive into a fresh directory.  This is normally
542       called internally to Alien::Build, and for normal usage is not needed
543       from a plugin or alienfile.
544
545   build
546        $build->build;
547
548       Run the build step.  It is expected that "probe" and "download" have
549       already been performed.  What it actually does depends on the type of
550       install:
551
552       share
553           The source is extracted, and built as determined by the alienfile
554           recipe.  If there is a "gather_share" that will be executed last.
555
556       system
557           The "gather_system" hook will be executed.
558
559   test
560        $build->test;
561
562       Run the test phase
563
564   clean_install
565        $build->clean_install
566
567       Clean files from the final install location.  The default
568       implementation removes all files recursively except for the "_alien"
569       directory.  This is helpful when you have an old install with files
570       that may break the new build.
571
572       For a non-share install this doesn't do anything.
573
574   system
575        $build->system($command);
576        $build->system($command, @args);
577
578       Interpolates the command and arguments and run the results using the
579       Perl "system" command.
580
581   log
582        $build->log($message);
583
584       Send a message to the log.  By default this prints to "STDOUT".
585
586   meta
587        my $meta = Alien::Build->meta;
588        my $meta = $build->meta;
589
590       Returns the meta object for your Alien::Build class or instance.  The
591       meta object is a way to manipulate the recipe, and so any changes to
592       the meta object should be made before the "probe", "download" or
593       "build" steps.
594

META METHODS

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

ENVIRONMENT

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

SUPPORT

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

SEE ALSO

764       Alien::Build::Manual::AlienAuthor, Alien::Build::Manual::AlienUser,
765       Alien::Build::Manual::Contributing, Alien::Build::Manual::FAQ,
766       Alien::Build::Manual::PluginAuthor
767
768       alienfile, Alien::Build::MM, Alien::Build::Plugin, Alien::Base, Alien
769

THANKS

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

AUTHOR

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