view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

    unshift @PATH, Alien::patch->bin_dir;
    my $result = system("cd $src_dir && patch $patch_flags -i ../CMakeLists.txt.patch");
    die "FATAL: can't patch geos\n" if $result != 0;

    print "Going to generate Makefile\n";
    my $CFLAGS = $ENV{CFLAGS} // '-O2 -fPIC';
    local $ENV{CFLAGS} = $ENV{CXXFLAGS} = $CFLAGS;

    my $cmake_flags = join(" ", '-G "Unix Makefiles"', "-DCMAKE_CXX_FLAGS=\"$CFLAGS\"", "-DCMAKE_C_FLAGS=\"$CFLAGS\"",
        qw/
        -DGEOS_ENABLE_TESTS=off
        -DGEOS_ENABLE_INLINE=off

 view release on metacpan or  search on metacpan

t/generated_app.t  view on Meta::CPAN

  $escaped_path = qq{"$escaped_path"};
}

$ENV{PERL_MM_OPT} = "INSTALL_BASE=$escaped_path";

if ($ENV{MAKEFLAGS}) {
    $ENV{MAKEFLAGS} =~ s/PREFIX=[^\s]+//;
    $ENV{MAKEFLAGS} =~ s/INSTALL_BASE=[^\s]+//;
}

my $dir = tempdir(CLEANUP => 1);
my $devnull = devnull;

 view release on metacpan or  search on metacpan

builder/MyBuilder.pm  view on Meta::CPAN

sub ACTION_build {
    my $self = shift;
    $self->ACTION_ppport_h() unless -e 'ppport.h';
    unless (-f "$LIBZSTD_DIR/libzstd.a") {
        local $ENV{CFLAGS} = '-DZSTD_MULTITHREAD -DZSTD_LEGACY_MULTITHREADED_API -O3 -fPIC';
        my $make = 'make';
        $make = 'gmake' if $^O =~ /bsd$/ && $^O !~ /gnukfreebsd$/;
        $self->do_system($make => '-C', $LIBZSTD_DIR, 'libzstd.a');
    }
    $self->SUPER::ACTION_build();

 view release on metacpan or  search on metacpan

builder/MyBuilder.pm  view on Meta::CPAN

sub ACTION_build {
    my $self = shift;
    $self->ACTION_ppport_h() unless -e 'ppport.h';
    unless (-f "$LIBZSTD_DIR/libzstd.a") {
        local $ENV{CFLAGS} = '-DZSTD_MULTITHREAD -DZSTD_LEGACY_MULTITHREADED_API -O3 -fPIC';
        my $make = 'make';
        $make = 'gmake' if $^O =~ /bsd$/ && $^O !~ /gnukfreebsd$/;
        $self->do_system($make => '-C', $LIBZSTD_DIR, 'libzstd.a');
    }
    $self->SUPER::ACTION_build();

 view release on metacpan or  search on metacpan

PLCB_ConfUtil.pm  view on Meta::CPAN

    print $fh Dumper($h);
}

sub env_from_tmpflags {
    my $confhash = do "$TEMPFILE";
    $ENV{CFLAGS} .= ' ' . $confhash->{CFLAGS} . ' ' . $Config{ccflags};
    $ENV{CFLAGS} .= ' -I' . File::Spec->catfile(__DIR__, 'xs');
    $ENV{LDFLAGS}= "";
#    $ENV{LDFLAGS}  .= ' ' .  $confhash->{LDFLAGS};

#    printf("CFLAGS: %s\nLDFLAGS=%s\n", $ENV{CFLAGS}, $ENV{LDFLAGS});
}

1;

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

my @DEFINES;
if (grep { $_ eq '--very-verbose' } @ARGV) {
    push @DEFINES, '-DVERY_VERBOSE';
}

my @CCFLAGS = split(' ', $ENV{CCFLAGS} || '');
my @LDFLAGS = split(' ', $ENV{LDFLAGS} || '');
my @INCLUDES;
my @LIBPATHS;

if ($^O eq 'darwin') {
    if (! exists $ENV{USE_MACPORTS}) {

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

    $ver1 ||= $1 if $Config{gccversion} =~ /Clang ([0-9]+)\./i; # gccversion='FreeBSD Clang 13.0.0 (git@github.com:llvm/llvm-project.git llvmorg-13.0.0-0-gd7b669b3a303)' or 'OpenBSD Clang 13.0.0'
    $mycflags .= " -DLTC_AES_NI" if $ver1 > 4; # target attributes are supported since gcc-4.9
  }

  #FIX: this is particularly useful for Debian https://github.com/DCIT/perl-CryptX/pull/39
  $mycflags .= " $ENV{CFLAGS} "   if $ENV{CFLAGS};
  $mycflags .= " $ENV{CPPFLAGS} " if $ENV{CPPFLAGS};

  #### remove all lto hacks - https://github.com/DCIT/perl-CryptX/issues/70
  ## #FIX: gcc with -flto is a trouble maker see https://github.com/DCIT/perl-CryptX/issues/32
  ## #FIX: another issue with "-flto=auto" see https://github.com/DCIT/perl-CryptX/pull/66
  ## $mycflags =~ s/\s-flto\S+\s/ /g; # -flto -flto=auto -flto=jobserver -flto=N ...

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

 * db_login6: fix dbp ingrements for strings and integers
 * db_login/charset: copy only SV content
 * rework populating of DPB
 * db_login6, gfix: abort if DPB length doesn't match projected
 * mark all copied/mangled files for embedded as such
 * add $ENV{CFLAGS} to CCFLAGS
 * fix a format string warning on 32-bit CPUs
 * Fix comment about MS platform requirement.
 * avoid using warn(char*)
0.80 [2011-10-03]
[Details: https://github.com/mariuz/perl-dbd-firebird/commits/release0.80]

 view release on metacpan or  search on metacpan

tools/timezone/update-timezones.pl  view on Meta::CPAN

    die "Did not retrieve anything from elsie"
        unless $olson_version;

    print "Running make...\n";
    if ($^O eq 'darwin') {
        if ($ENV{CPPFLAGS}) {
            $ENV{CPPFLAGS} .= ' -DSTD_INSPIRED';
        } else {
            $ENV{CPPFLAGS} = ' -DSTD_INSPIRED';
        }
    }
        
    system( 'make' )
        and die "Cannot run make: $!";

 view release on metacpan or  search on metacpan

t/lib/Helper.pm  view on Meta::CPAN

use Config;

# Microsoft nmake outputs a copyright message that
# messes up the output checks, but we can work around
# this by setting the -nologo option using MAKEFLAGS
$ENV{MAKEFLAGS} = join(' ', 'nologo', ($ENV{MAKEFLAGS} // ())) if $Config{make} eq 'nmake';

sub run_makemaker {
    my $tzil = shift;

    my $exception;

 view release on metacpan or  search on metacpan

bin/enc2xs  view on Meta::CPAN

   #$erep = join('',map(chr(hex($_)),@byte));
   $erep = $attr{'subchar'}; 
   $erep =~ s/^\s+//; $erep =~ s/\s+$//;
  }
 print "Reading $name ($cs)\n"
   unless defined $ENV{MAKEFLAGS}
      and $ENV{MAKEFLAGS} =~ /\b(s|silent|quiet)\b/;
 my $nfb = 0;
 my $hfb = 0;
 while (<$fh>)
  {
   s/#.*$//;

 view release on metacpan or  search on metacpan

lib/Env/ShellWords.pm  view on Meta::CPAN

 # same thing with import interface:
 use Env::ShellWords qw( @CFLAGS @LDFLAGS );

 # usage:
 $ENV{CFLAGS} = '-DBAR=1';
 unshift @CFLAGS, '-I/foo/include';
 push @CFLAGS, '-DFOO=Define With Spaces';
 
 # now:
 # $ENV{CFLAGS} = '-I/foo/include -DBAR=1 -DFOO=Define\\ With\\ Spaces';
 
 unshift @LDFLAGS, '-L/foo/lib';
 push @LDFLAGS, '-lfoo';

=head1 DESCRIPTION

 view release on metacpan or  search on metacpan

lib/ExtUtils/CBuilder/Base.pm  view on Meta::CPAN

  while (my ($k,$v) = each %Config) {
    $self->{config}{$k} = $v unless exists $self->{config}{$k};
  }
  $self->{config}{cc} = $ENV{CC} if defined $ENV{CC};
  $self->{config}{ccflags} = join(" ", $self->{config}{ccflags}, $ENV{CFLAGS})
     if defined $ENV{CFLAGS};
  $self->{config}{cxx} = $ENV{CXX} if defined $ENV{CXX};
  $self->{config}{cxxflags} = $ENV{CXXFLAGS} if defined $ENV{CXXFLAGS};
  $self->{config}{ld} = $ENV{LD} if defined $ENV{LD};
  $self->{config}{ldflags} = join(" ", $self->{config}{ldflags}, $ENV{LDFLAGS})
     if defined $ENV{LDFLAGS};

  unless ( exists $self->{config}{cxx} ) {

    my ($ccbase, $ccpath, $ccsfx ) = fileparse($self->{config}{cc}, qr/\.[^.]*/);

 view release on metacpan or  search on metacpan

lib/ExtUtils/Install.pm  view on Meta::CPAN

my $INSTALL_ROOT = $ENV{PERL_INSTALL_ROOT};
my $INSTALL_QUIET = $ENV{PERL_INSTALL_QUIET};
$INSTALL_QUIET = 1
  if (!exists $ENV{PERL_INSTALL_QUIET} and
      defined $ENV{MAKEFLAGS} and
      $ENV{MAKEFLAGS} =~ /\b(s|silent|quiet)\b/);

my $Curdir = File::Spec->curdir;

sub _estr(@) {
    return join "\n",'!' x 72,@_,'!' x 72,'';

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

    libtomcrypt/src/misc/zeromem.c
);
$mycflags = " $Config{ccflags} $Config{cccdlflags} $Config{optimize} "; # keep leading + trailing spaces

#FIX: this is particularly useful for Debian https://github.com/DCIT/perl-CryptX/pull/39
$mycflags .= " $ENV{CFLAGS} "   if $ENV{CFLAGS};
$mycflags .= " $ENV{CPPFLAGS} " if $ENV{CPPFLAGS};

#### remove all lto hacks - https://github.com/DCIT/perl-CryptX/issues/70
## #FIX: gcc with -flto is a trouble maker see https://github.com/DCIT/perl-CryptX/issues/32
## #FIX: another issue with "-flto=auto" see https://github.com/DCIT/perl-CryptX/pull/66
## $mycflags =~ s/\s-flto\S+\s/ /g; # -flto -flto=auto -flto=jobserver -flto=N ...

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

for my $module (sort keys %$objects) {
    my $add = $module;
    $add =~ s/:/_/g;
    my $LD = $Config{ld};
    $LD .= ' '.$ENV{CFLAGS} if $ENV{CFLAGS};
    $LD .= ' '.$ENV{LDFLAGS} if $ENV{LDFLAGS};
    my $OPTIMIZE = '';
    $OPTIMIZE .= ' '.$ENV{CFLAGS} if $ENV{CFLAGS};
    $OPTIMIZE .= ' '.$ENV{CPPFLAGS} if $ENV{CFLAGS};
    
    my %PM = ( 'lib/Geo/GDAL.pm' => '$(INST_LIBDIR)/GDAL.pm',
               'lib/Geo/OGR.pm' => '$(INST_LIBDIR)/OGR.pm',
               'lib/Geo/OSR.pm' => '$(INST_LIBDIR)/OSR.pm',
               'lib/Geo/GDAL/Const.pm' => '$(INST_LIBDIR)/GDAL/Const.pm' );

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

      }

      $ENV{MAKE}     = $Config{make};
      $ENV{SHELL}    = $Config{sh};
      $ENV{CC}       = $Config{cc};
      $ENV{CPPFLAGS} = "$Config{cppflags} -I$Config{archlibexp}/CORE";
      $ENV{CFLAGS}   = $Config{ccflags};
      $ENV{LDFLAGS}  = "$Config{ldflags} $Config{ccdlflags}";
      $ENV{LINKER}   = $Config{ld}; # nonstandard
      $ENV{LIBS}     = "-L$Config{archlibexp}/CORE -L$Config{privlibexp} -lperl $Config{perllibs}";

      system $ENV{SHELL}, -c => "./configure --prefix \Q$Config{prefixexp}\E"
         and exit $? >> 8;

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

my @tests = map { glob $_ } 't/*.t', 't/*/*.t';
my $module = 'Image::CCV';
(my $main_file = "lib/$module.pm" ) =~ s!::!/!g;
(my $distbase = $module) =~ s!::!-!g;

my $ccflags = $ENV{CCFLAGS}
            || $Config::Config{ ccflags }
            ;

# TODO: Add command line switches in addition to %ENV and %Config
#       Thanks to Devel::CheckLib, LIBS= and INC= already exist

 view release on metacpan or  search on metacpan

lib/Inline/C.pm  view on Meta::CPAN

}
sub make {
    my ($o) = @_;
    my $make = $o->{ILSM}{MAKE} || $Config::Config{make}
        or croak "Can't locate your make binary";
    local $ENV{MAKEFLAGS} = $ENV{MAKEFLAGS} =~ s/(--jobserver-fds=[\d,]+)//
        if $ENV{MAKEFLAGS};
    $o->system_call("$make", 'out.make');
}
sub make_install {
    my ($o) = @_;
    my $make = $o->{ILSM}{MAKE} || $Config::Config{make}
        or croak "Can't locate your make binary";
    if ($ENV{MAKEFLAGS}) { # Avoid uninitialized warnings
        local $ENV{MAKEFLAGS} = $ENV{MAKEFLAGS} =~
            s/(--jobserver-fds=[\d,]+)//;
    }
    $o->system_call("$make pure_install", 'out.make_install');
}
sub cleanup {

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

my $CFLAGS = ccopts();
my $LDFLAGS = ldopts();
chomp($CFLAGS,$LDFLAGS);

my $cmd = "cd $jabberdir; ./bootstrap;  libtoolize --force && aclocal $ENV{ACLOCAL_FLAGS} && autoheader && automake --include-deps --add-missing && autoconf; CFLAGS=\'$CFLAGS $ENV{CFLAGS}\' LDFLAGS=\'$LDFLAGS $ENV{LDFLAGS}\' ./configure $conf && make...
#my $cmd = "cd $jabberdir; CFLAGS=\'$CFLAGS $ENV{CFLAGS}\' LDFLAGS=\'$LDFLAGS $ENV{LDFLAGS}\' ./configure $conf && make";

# now for the big kick off
warn "\n\nExecuting $cmd\n  To build jabberd.\n";
system("$cmd");
die "jabberd2 build failed!\n" unless -x $jabberdir."/sm/sm";

 view release on metacpan or  search on metacpan

buildlib/KinoSearch/Build.pm  view on Meta::CPAN

BEGIN { unshift @PATH, curdir() }

sub extra_ccflags {
    my $self = shift;
    my $extra_ccflags = defined $ENV{CFLAGS} ? "$ENV{CFLAGS} " : "";
    my $gcc_version 
        = $ENV{REAL_GCC_VERSION}
        || $self->config('gccversion')
        || undef;
    if ( defined $gcc_version ) {

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

WriteMakefile(
	NAME            => 'Logger::Fq',
	VERSION_FROM    => 'Fq.pm',
	OBJECT          => 'logger-fq.o',
	LIBS            => "$ENV{LDFLAGS} -lfq",
	OPTIMIZE        => $ENV{'OPTIMIZE'},
	PREREQ_PM       => {},
);

 view release on metacpan or  search on metacpan

engine/read_only/win32/do_config_h.pl  view on Meta::CPAN

our %PERL_AUTOCONF_OS = map { $_ => 1 } qw( MSWin32 openbsd solaris sunos midnightbsd );

my $MARPA_DEBUG       = $ENV{MARPA_DEBUG}                 || 0;
my $USE_PERL_AUTOCONF = $ENV{MARPA_USE_PERL_AUTOCONF}     || ( $PERL_AUTOCONF_OS{$^O} // 0 );
my $CC                = $ENV{CC} || $Config{cc}           || 'cc';
my $CCFLAGS           = $ENV{CCFLAGS} || $Config{ccflags} || '';
my $SH                = $ENV{SH} || $Config{sh}           || '';
my $OBJ_EXT           = $ENV{OBJ_EXT} || $Config{obj_ext} || '.o';

GetOptions ('marpa_debug!'       => \$MARPA_DEBUG,
            'use_perl_autoconf!' => \$USE_PERL_AUTOCONF,

engine/read_only/win32/do_config_h.pl  view on Meta::CPAN

exit($rc ? EXIT_SUCCESS : EXIT_FAILURE);

sub do_config_h {

  $ENV{CC} = $CC;
  $ENV{CCFLAGS} = $CCFLAGS;
  $ENV{OBJ_EXT} = $OBJ_EXT;

    # If current directory exists and contains a stamp file more recent than an eventual config.h
    # we are done.
    if (-e 'config.h' && -e 'stamp-h1' && up_to_date( 'config.h', 'stamp-h1' )) {

engine/read_only/win32/do_config_h.pl  view on Meta::CPAN

        ##no critic(ValuesAndExpressions::RequireInterpolationOfMetachars)
            $shell or die q{No Bourne shell available says $SH};
        ##use critic
    }
    
    my $original_cflags = $ENV{CFLAGS};
    local $ENV{CFLAGS};
    $ENV{CFLAGS} = $original_cflags if defined $original_cflags;

    # We need PIC, but do not want the overhead of building the shared library
    my @configure_command_args = qw(--with-pic --disable-shared);

    my @debug_flags = ();
    if ( $MARPA_DEBUG ) {
        if ( defined $ENV{LIBMARPA_CFLAGS} ) {
            $ENV{CFLAGS} = $ENV{LIBMARPA_CFLAGS};
        }
        push @debug_flags, '-DMARPA_DEBUG=1';
        push @debug_flags, '-fno-inline', '-Wno-inline' if ($CC eq 'gcc');
        push @configure_command_args,
            'MARPA_DEBUG_FLAG=' . ( join q{ }, @debug_flags );

 view release on metacpan or  search on metacpan

etc/compile_marpaESLIF.pl  view on Meta::CPAN

# from default ExtUtils::Cbuilder will ensure cc and cpp settings will become independant
# if we are doing to modify any of them.
# We do that for linker settings as well for coherency although we will NEVER touch them.
# OTHERLDFLAGS will be specific to this makefile.
#
# Take care: with ExtUtils::CBuilder, $ENV{CFLAGS} and $ENV{LDFLAGS} are appended to default perl compile flags, not the others
#
#
my %cbuilder_config = ExtUtils::CBuilder->new()->get_config;
$ENV{CC} = $cbuilder_config{cc} // 'cc';
$ENV{CFLAGS} //= '';
$ENV{CFLAGS} .= ' -DNDEBUG -DNTRACE';
$ENV{CXX} = $cbuilder_config{cxx} // $ENV{CC};
$ENV{CXXFLAGS} = $cbuilder_config{cxxflags} // $cbuilder_config{ccflags} // '';
$ENV{LD} = $cbuilder_config{ld} // $ENV{CC};
$ENV{LDFLAGS} //= '';
my @OTHERLDFLAGS = ();
my $optimize = '';

print "==========================================\n";
print "Original compilers and linker settings as per ExtUtils::CBuilder\n";
print "\n";
print "CC           (overwrite) $ENV{CC}\n";
print "CFLAGS       (    fixed) " . ($cbuilder_config{ccflags} // '') . "\n";
print "CFLAGS       (   append) $ENV{CFLAGS}\n";
print "CXX          (overwrite) $ENV{CXX}\n";
print "CXXFLAGS     (overwrite) $ENV{CXXFLAGS}\n";
print "LD           (overwrite) $ENV{LD}\n";
print "LDFLAGS      (    fixed) " . ($cbuilder_config{ldflags} // '') . "\n";
print "LDFLAGS      (   append) $ENV{LDFLAGS}\n";
print "==========================================\n";
print "\n";

my $ac = Config::AutoConf->new();
# goto jdd;

etc/compile_marpaESLIF.pl  view on Meta::CPAN

            $ac->msg_notice("Forcing CXX to $cxx");
            $ENV{CXX} = $cxx;
            #
            # We got "CC" executable - no need of eventual -x c++ that perl may have add
            #
            if ($ENV{CXXFLAGS} =~ s/\-x\s+c\+\+\s*//) {
                $ac->msg_notice("Removed -x c++ from CXXFLAGS");
            }
        } else {
            $ac->msg_notice("Warning! Sun C compiler detected but no CC found neither in path neither where is the C compiler");
        }

etc/compile_marpaESLIF.pl  view on Meta::CPAN

        if (defined($cxx_guess) && (length($cxx_guess) > 0) && which($cxx_guess)) {
            $ac->msg_notice("Setting CXX to $cxx_guess");
            $ENV{CXX} = $cxx_guess;
            if (defined($extra_cxxflags_guess) && (length($extra_cxxflags_guess) > 0)) {
                $ac->msg_notice("Appending $extra_cxxflags_guess to CXXFLAGS");
                $ENV{CXXFLAGS} .= " $extra_cxxflags_guess";
            }
            if (defined($extra_ldflags_guess) && (length($extra_ldflags_guess) > 0)) {
		#
		# If $extra_ldflags_guess matches -lc++ or -lstdc++ remember this is a guess.
		# It can be one or the other, and we use the standard ciso646 with _LIBCPP_VERSION technique

etc/compile_marpaESLIF.pl  view on Meta::CPAN

        $ac->msg_result('');
        foreach my $flag (qw/-std=gnu99 -std=c99 -c99 -AC99 -xc99=all -qlanglvl=extc99/) {
            $ac->msg_checking("if flag $flag works");
            if (try_compile("#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L\n#error \"C99 is not enabled\"\n#endif\nint main(){return 0;}", { extra_compiler_flags => $flag })) {
                $ac->msg_result('yes');
                $ENV{CFLAGS} .= " $flag";
                $isc99 = 1;
                last;
            } else {
                $ac->msg_result('no');
            }

etc/compile_marpaESLIF.pl  view on Meta::CPAN

      #
      # C.f. http://clang.llvm.org/compatibility.html#inline
      #      https://bugzilla.mozilla.org/show_bug.cgi?id=917526
      #
      $ac->msg_notice("Adding -std=gnu89 to CFLAGS for inline semantics");
      $ENV{CFLAGS} .= ' -std=gnu89';
  } else {
      $ac->msg_result('no');
  }
}

if ($^O eq "netbsd" && ! $isc99) {
    #
    # We need long long, that C99 guarantees, else _NETBSD_SOURCE will do it
    #
    $ac->msg_notice("NetBSD platform: Append _NETBSD_SOURCE to CFLAGS to have long long");
    $ENV{CFLAGS} .= ' -D_NETBSD_SOURCE';
}

my $has_Werror = 0;
if(! defined($ENV{MARPAESLIFPERL_OPTIM}) || $ENV{MARPAESLIFPERL_OPTIM}) {
    if(defined($ENV{MARPAESLIFPERL_OPTIM_FLAGS})) {

etc/compile_marpaESLIF.pl  view on Meta::CPAN

print "==========================================\n";
print "Tweaked compilers and linker settings\n";
print "\n";
print "CC           (overwrite) $ENV{CC}\n";
print "CFLAGS       (    fixed) " . ($cbuilder_config{ccflags} // '') . "\n";
print "CFLAGS       (   append) $ENV{CFLAGS}\n";
print "CXX          (overwrite) $ENV{CXX}\n";
print "CXXFLAGS     (overwrite) $ENV{CXXFLAGS}\n";
print "LD           (overwrite) $ENV{LD}\n";
print "LDFLAGS      (    fixed) " . ($cbuilder_config{ldflags} // '') . "\n";
print "LDFLAGS      (   append) $ENV{LDFLAGS}\n";
print "OTHERLDFLAGS             $OTHERLDFLAGS\n";
print "==========================================\n";
print "\n";

my %HAVE_HEADERS = ();

etc/compile_marpaESLIF.pl  view on Meta::CPAN

# Write config file
#
print "Generating $CONFIG_H\n";
$ac->write_config_h($CONFIG_H);
$ac->msg_notice("Append -I$EXTRA_INCLUDE_DIR to compile flags");
$ENV{CFLAGS} .= " -I$EXTRA_INCLUDE_DIR";
$ENV{CXXFLAGS} .= " -I$EXTRA_INCLUDE_DIR";
#
# Generate extra headers eventually
#
if (! $HAVE_HEADERS{"stdint.h"}) {
    configure_file($ac, File::Spec->catfile('etc', 'stdint.h.in'), File::Spec->catfile($EXTRA_INCLUDE_DIR, 'stdint.h'));

etc/compile_marpaESLIF.pl  view on Meta::CPAN

#
# General flags that we always set
#
foreach my $flag (qw/_REENTRANT _THREAD_SAFE/) {
    $ac->msg_notice("Append $flag to compile flags");
    $ENV{CFLAGS} .= " -D$flag";
    $ENV{CXXFLAGS} .= " -D$flag";
}
#
# Specific flags for cl
#
if ($ENV{CC} =~ /\bcl\b/) {
    foreach my $flag (qw/WIN32_LEAN_AND_MEAN CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE/) {
        $ac->msg_notice("Append $flag to compile flags");
        $ENV{CFLAGS} .= " -D$flag";
        $ENV{CXXFLAGS} .= " -D$flag";
    }
}
#
# Extract and process tarballs in an order that we know in advance
#

etc/compile_marpaESLIF.pl  view on Meta::CPAN

my $otherldflags = 'OTHERLDFLAGS.txt';
open(my $otherldflags_fd, '>', $otherldflags) || die "Cannot open $otherldflags, $!";
foreach (@OTHERLDFLAGS) {
    print $otherldflags_fd "$_\n";
}
print $otherldflags_fd "$ENV{LDFLAGS}\n";
close($otherldflags_fd) || warn "Cannot close $otherldflags, $!";

#
# Write CFLAGS to CFLAGS.txt
#
my $cflags = 'CFLAGS.txt';
open(my $cflags_fd, '>', $cflags) || die "Cannot open $cflags, $!";
print $cflags_fd "$ENV{CFLAGS}\n";
close($cflags_fd) || warn "Cannot close $cflags, $!";

exit(EXIT_SUCCESS);

sub guess_compiler {

etc/compile_marpaESLIF.pl  view on Meta::CPAN

    if($lm) {
	$ac->msg_result("$lm");
	$ac->search_libs('log', $lm, { action_on_true => $ac->define_var("HAVE_LOG", 1) });
	$ac->search_libs('exp', $lm, { action_on_true => $ac->define_var("HAVE_EXP", 1) });
        $ac->msg_notice("Append -l$lm to LDFLAGS");
	$ENV{LDFLAGS} .= " -l$lm";
    } else {
	$ac->msg_result("not needed");
	$ac->search_libs('log', { action_on_true => $ac->define_var("HAVE_LOG", 1) });
	$ac->search_libs('exp', { action_on_true => $ac->define_var("HAVE_EXP", 1) });
    }

etc/compile_marpaESLIF.pl  view on Meta::CPAN

BODY
    my $program = $ac->lang_build_program($prologue, $body);
    if (try_run($program)) {
        $ac->msg_result("yes");
        $ac->msg_notice("Append _GNU_SOURCE to compile flags");
        $ENV{CFLAGS} .= ' -D_GNU_SOURCE';
        $ENV{CXXFLAGS} .= ' -D_GNU_SOURCE';
    } else {
        $ac->msg_result("no");
    }
}

 view release on metacpan or  search on metacpan

lib/MegaDistro/Install.pm  view on Meta::CPAN

	if ( $args{'debug'} ) {
		print "\t" . 'Instantiating CPANPLUS::Backend object' . "\n";
	}

	# This can interfere with the operation of CPANPLUS.
	delete $ENV{MAKEFLAGS};
	
	#instantiate backend obj
	$cb = CPANPLUS::Backend->new;

	if ( $args{'debug'} ) {

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

sub build_dropbear
{
  my $db_src = 'dropbear/';
  local $ENV{DESTDIR};    # do not let Perl module config leak through

  local $ENV{CFLAGS}   = $Config{cccdlflags} . ' ' . $Config{ccflags};
  local $ENV{LDFLAGS}  = $Config{ldflags} . ' ' . $Config{ccdlflags};
  local $ENV{CPPFLAGS} = $Config{cppflags};

  return
      if -e "$db_src/dropbear";

  run("cd $db_src && make distclean")

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

$config{bsdos } = $config{freebsd};
$config{darwin} = $config{freebsd};
$config{netbsd} = $config{freebsd};

my $name = $Config{osname} || "others"; 
my $def = $config{$name}->[0] . (defined $ENV{CFLAGS} ? " $ENV{'CFLAGS'}" : "");
my $obj = $config{$name}->[1];
print $config{$name}->[2];
eval $config{$name}->[3];

print "Compiler: $Config{cc}\n";

 view release on metacpan or  search on metacpan

inc/Inline/C.pm  view on Meta::CPAN

}
sub make {
    my ($o) = @_;
    my $make = $o->{ILSM}{MAKE} || $Config::Config{make}
        or croak "Can't locate your make binary";
    local $ENV{MAKEFLAGS} = $ENV{MAKEFLAGS} =~ s/(--jobserver-fds=[\d,]+)//
        if $ENV{MAKEFLAGS};
    $o->system_call("$make", 'out.make');
}
sub make_install {
    my ($o) = @_;
    my $make = $o->{ILSM}{MAKE} || $Config::Config{make}
        or croak "Can't locate your make binary";
    if ($ENV{MAKEFLAGS}) { # Avoid uninitialized warnings
        local $ENV{MAKEFLAGS} = $ENV{MAKEFLAGS} =~
            s/(--jobserver-fds=[\d,]+)//;
    }
    $o->system_call("$make pure_install", 'out.make_install');
}
sub cleanup {

 view release on metacpan or  search on metacpan

inc/Inline/C.pm  view on Meta::CPAN

}
sub make {
    my ($o) = @_;
    my $make = $o->{ILSM}{MAKE} || $Config::Config{make}
        or croak "Can't locate your make binary";
    local $ENV{MAKEFLAGS} = $ENV{MAKEFLAGS} =~ s/(--jobserver-fds=[\d,]+)//
        if $ENV{MAKEFLAGS};
    $o->system_call("$make", 'out.make');
}
sub make_install {
    my ($o) = @_;
    my $make = $o->{ILSM}{MAKE} || $Config::Config{make}
        or croak "Can't locate your make binary";
    if ($ENV{MAKEFLAGS}) { # Avoid uninitialized warnings
        local $ENV{MAKEFLAGS} = $ENV{MAKEFLAGS} =~
            s/(--jobserver-fds=[\d,]+)//;
    }
    $o->system_call("$make pure_install", 'out.make_install');
}
sub cleanup {

 view release on metacpan or  search on metacpan

inc/Inline/C.pm  view on Meta::CPAN

}
sub make {
    my ($o) = @_;
    my $make = $o->{ILSM}{MAKE} || $Config::Config{make}
        or croak "Can't locate your make binary";
    local $ENV{MAKEFLAGS} = $ENV{MAKEFLAGS} =~ s/(--jobserver-fds=[\d,]+)//
        if $ENV{MAKEFLAGS};
    $o->system_call("$make", 'out.make');
}
sub make_install {
    my ($o) = @_;
    my $make = $o->{ILSM}{MAKE} || $Config::Config{make}
        or croak "Can't locate your make binary";
    if ($ENV{MAKEFLAGS}) { # Avoid uninitialized warnings
        local $ENV{MAKEFLAGS} = $ENV{MAKEFLAGS} =~
            s/(--jobserver-fds=[\d,]+)//;
    }
    $o->system_call("$make pure_install", 'out.make_install');
}
sub cleanup {