[p5sagit/p5-mst-13.2.git] / ext / Compress-Raw-Zlib / Makefile.PL

#! perl -w

use strict ;
require 5.004 ;

use private::MakeUtil;
use ExtUtils::MakeMaker 5.16 ;
use ExtUtils::Install (); # only needed to check for version

my $ZLIB_LIB ;
my $ZLIB_INCLUDE ;
my $BUILD_ZLIB = 0 ;
my $OLD_ZLIB = '' ;
my $WALL = '' ;
my $GZIP_OS_CODE = -1 ;
my $USE_PPPORT_H = ($ENV{PERL_CORE}) ? '' : '-DUSE_PPPORT_H';

#$WALL = ' -pedantic ' if $Config{'cc'} =~ /gcc/ ;
#$WALL = ' -Wall -Wno-comment ' if $Config{'cc'} =~ /gcc/ ;

# Ticket #18986 says that ExtUtils::Install 1.39 fixes the in-use issue
# on win32/cygwin, so make the code below conditional on the version of
# ExtUtils::Install.

# Don't ask if MM_USE_DEFAULT is set -- enables perl core building on cygwin
if ($^O =~ /cygwin/i and $ExtUtils::Install::VERSION < 1.39 
        and not ($ENV{PERL_MM_USE_DEFAULT} or $ENV{PERL_CORE}))
{
    print <<EOM ;

I see you are running Cygwin.

Please note that this module cannot be installed on Cygwin using the CPAN
shell. The CPAN Shell uses Compress::Raw::Zlib internally and it is not
possible to delete an active DLL.

If you are running the CPAN shell, please exit it and install this module
by hand by running 'make install' under the directory

    ~/.cpan/build/Compress-Raw-Zlib-VERSION

EOM

    print "Do you want to continue? [Y/N]: " ;
    my $answer = <STDIN> ;

    if ($answer =~ /^yes|y/i)
    {
	print "continuing...\n" 
    }
    else
    {
	print "exiting...\n" ;
	exit 1 ;
    }


}

ParseCONFIG() ;

UpDowngrade(getPerlFiles('MANIFEST')) 
    unless $ENV{PERL_CORE};

WriteMakefile( 
    NAME         => 'Compress::Raw::Zlib',
    VERSION_FROM => 'lib/Compress/Raw/Zlib.pm',
    INC          => "-I$ZLIB_INCLUDE" ,
    DEFINE       => "$OLD_ZLIB $WALL -DGZIP_OS_CODE=$GZIP_OS_CODE $USE_PPPORT_H" ,
    XS           => { 'Zlib.xs' => 'Zlib.c'},
    'depend'     => { 'Makefile'   => 'config.in' },
    'clean'      => { FILES        => '*.c constants.h constants.xs' },
    'dist'       => { COMPRESS     => 'gzip', 
                      TARFLAGS     => '-chvf',
                      SUFFIX       => 'gz',
                      DIST_DEFAULT => 'MyTrebleCheck tardist',
                    },

    (
      $BUILD_ZLIB
        ? zlib_files($ZLIB_LIB)
        : (LIBS => [ "-L$ZLIB_LIB -lz " ])
    ),
      
    INSTALLDIRS => ($] >= 5.009 ? 'perl' : 'site'),

    ((ExtUtils::MakeMaker->VERSION() gt '6.30') ?
        ('LICENSE'  => 'perl')         : ()),    

) ;

my @names = qw(

    DEF_WBITS
    MAX_MEM_LEVEL
    MAX_WBITS
    OS_CODE

    Z_ASCII
    Z_BEST_COMPRESSION
    Z_BEST_SPEED
    Z_BINARY
    Z_BLOCK
    Z_BUF_ERROR
    Z_DATA_ERROR
    Z_DEFAULT_COMPRESSION
    Z_DEFAULT_STRATEGY
    Z_DEFLATED
    Z_ERRNO
    Z_FILTERED
    Z_FINISH
    Z_FIXED
    Z_FULL_FLUSH
    Z_HUFFMAN_ONLY
    Z_MEM_ERROR
    Z_NEED_DICT
    Z_NO_COMPRESSION
    Z_NO_FLUSH
    Z_NULL
    Z_OK
    Z_PARTIAL_FLUSH
    Z_RLE
    Z_STREAM_END
    Z_STREAM_ERROR
    Z_SYNC_FLUSH
    Z_UNKNOWN
    Z_VERSION_ERROR

);
    #ZLIB_VERNUM

if (eval {require ExtUtils::Constant; 1}) {
    # Check the constants above all appear in @EXPORT in Zlib.pm
    my %names = map { $_, 1} @names, 'ZLIB_VERSION';
    open F, "<lib/Compress/Raw/Zlib.pm" or die "Cannot open Zlib.pm: $!\n";
    while (<F>)
    {
        last if /^\s*\@EXPORT\s+=\s+qw\(/ ;
    }

    while (<F>)
    {
        last if /^\s*\)/ ;
        /(\S+)/ ;
        delete $names{$1} if defined $1 ;
    }
    close F ;

    if ( keys %names )
    {
        my $missing = join ("\n\t", sort keys %names) ;
        die "The following names are missing from \@EXPORT in Zlib.pm\n" .
            "\t$missing\n" ;
    }
    
    push @names, {name => 'ZLIB_VERSION', type => 'PV' };

    ExtUtils::Constant::WriteConstants(
                                     NAME => 'Zlib',
                                     NAMES => \@names,
                                     C_FILE  => 'constants.h',
                                     XS_FILE  => 'constants.xs',
                                                                       
                                    );
} 
else {
    foreach my $name (qw( constants.h constants.xs ))
    {
        my $from = catfile('fallback', $name);
        copy ($from, $name)
          or die "Can't copy $from to $name: $!";
    }
}

sub ParseCONFIG
{
    my ($k, $v) ;
    my @badkey = () ;
    my %Info = () ;
    my @Options = qw( INCLUDE LIB BUILD_ZLIB OLD_ZLIB GZIP_OS_CODE ) ;
    my %ValidOption = map {$_, 1} @Options ;
    my %Parsed = %ValidOption ;
    my $CONFIG = 'config.in' ;

    print "Parsing $CONFIG...\n" ;

    open(F, "<$CONFIG") or die "Cannot open file $CONFIG: $!\n" ;
    while (<F>) {
	s/^\s*|\s*$//g ;
	next if /^\s*$/ or /^\s*#/ ;
	s/\s*#\s*$// ;

	($k, $v) = split(/\s+=\s+/, $_, 2) ;
	$k = uc $k ;
	if ($ValidOption{$k}) {
	    delete $Parsed{$k} ;
	    $Info{$k} = $v ;
	}
	else {
	    push(@badkey, $k) ;
	}
    }
    close F ;

    print "Unknown keys in $CONFIG ignored [@badkey]\n"
	if @badkey ;

    # check parsed values
    my @missing = () ;
    die "The following keys are missing from $CONFIG  [@missing]\n" 
        if @missing = keys %Parsed ;

    $ZLIB_INCLUDE = $ENV{'ZLIB_INCLUDE'} || $Info{'INCLUDE'} ;
    $ZLIB_LIB = $ENV{'ZLIB_LIB'} || $Info{'LIB'} ;

    if ($^O eq 'VMS') {
        $ZLIB_INCLUDE = VMS::Filespec::vmspath($ZLIB_INCLUDE);
        $ZLIB_LIB = VMS::Filespec::vmspath($ZLIB_LIB);
    }

    my $y = $ENV{'OLD_ZLIB'} || $Info{'OLD_ZLIB'} ;
    $OLD_ZLIB = '-DOLD_ZLIB' if $y and $y =~ /^yes|on|true|1$/i;

    my $x = $ENV{'BUILD_ZLIB'} || $Info{'BUILD_ZLIB'} ;

    if ($x and $x =~ /^yes|on|true|1$/i ) {

        $BUILD_ZLIB = 1 ;

	# ZLIB_LIB & ZLIB_INCLUDE must point to the same place when 
	# BUILD_ZLIB is specified.
	die "INCLUDE & LIB must be the same when BUILD_ZLIB is True\n"
	    if $ZLIB_LIB ne $ZLIB_INCLUDE ;

	# Check the zlib source directory exists
	die "LIB/INCLUDE directory '$ZLIB_LIB' does not exits\n"
	   unless -d $ZLIB_LIB ;

	# check for a well known file
	die "LIB/INCLUDE directory, '$ZLIB_LIB', doesn't seem to have the zlib source files\n"
	   unless -e catfile($ZLIB_LIB, 'zlib.h') ;


	# write the Makefile
	print "Building Zlib enabled\n" ;
    }

    $GZIP_OS_CODE = defined $ENV{'GZIP_OS_CODE'} 
                          ? $ENV{'GZIP_OS_CODE'} 
                          : $Info{'GZIP_OS_CODE'} ;

	die "GZIP_OS_CODE not 'AUTO_DETECT' or a number between 0 and 255\n"
	   unless uc $GZIP_OS_CODE eq 'AUTO_DETECT'
                    || ( $GZIP_OS_CODE =~ /^(\d+)$/ && $1 >= 0 && $1 <= 255) ;

    if (uc $GZIP_OS_CODE eq 'AUTO_DETECT')
    {
        print "Auto Detect Gzip OS Code..\n" ;
        $GZIP_OS_CODE = getOSCode() ;
    }
    
    my $name = getOSname($GZIP_OS_CODE);
    print "Setting Gzip OS Code to $GZIP_OS_CODE [$name]\n" ;

    print <<EOM if 0 ;
    INCLUDE         [$ZLIB_INCLUDE]
    LIB             [$ZLIB_LIB]
    GZIP_OS_CODE    [$GZIP_OS_CODE]
    OLD_ZLIB        [$OLD_ZLIB]
    BUILD_ZLIB      [$BUILD_ZLIB]

EOM

    print "Looks Good.\n" ;

}


sub zlib_files
{
    my $dir = shift ;

    my @h_files = ();
    my @c_files = ();
    
    if (-f catfile($dir, "infback.c")) {
        # zlib 1.2.0 or greater
        #
        @h_files = qw(crc32.h    inffast.h inflate.h  trees.h    zconf.in.h 
    	              zutil.h    deflate.h inffixed.h inftrees.h zconf.h  
    		      zlib.h 
    		 );
        @c_files = qw(adler32  crc32   infback  inflate  uncompr
    		      compress deflate inffast  inftrees  
    		      trees    zutil 
    		 );
    }
    else {
        # zlib 1.1.x
    
        @h_files = qw(deflate.h  infcodes.h inftrees.h zconf.h zutil.h
    		      infblock.h inffast.h  infutil.h  zlib.h
    		 );
        @c_files = qw(adler32  compress crc32    uncompr
    		      deflate  trees    zutil    inflate infblock
    		      inftrees infcodes infutil  inffast
    		 );
    }
    
    @h_files = map { catfile($dir, $_)  } @h_files ;
    my @o_files = map { "$_\$(OBJ_EXT)" } 'Zlib', @c_files;
    @c_files = map { "$_.c" } 'Zlib', @c_files ;

    foreach my $file (@c_files)
      { copy(catfile($dir, $file), '.') }
    
    return (
        #'H'         =>  [ @h_files ],
    	'C'         =>  [ @c_files ] ,
        #'OBJECT'    => qq[ @o_files ],
        'OBJECT'    => q[ $(O_FILES) ],
        

           ) ;
}


use vars qw ( @GZIP_OS_Names  %OSnames) ;

BEGIN
{
  @GZIP_OS_Names = (
    [ ''        => 0,    'MS-DOS'                       ],
    [ 'amigaos' => 1,    'Amiga'                        ],
    [ 'VMS'     => 2,    'VMS'                          ],
    [ ''        => 3,    'Unix/Default'                 ],
    [ ''        => 4,    'VM/CMS'                       ],
    [ ''        => 5,    'Atari TOS'                    ],
    [ 'os2'     => 6,    'HPFS (OS/2, NT)'              ],
    [ 'MacOS'   => 7,    'Macintosh'                    ],
    [ ''        => 8,    'Z-System'                     ],
    [ ''        => 9,    'CP/M'                         ],
    [ ''        => 10,   'TOPS-20'                      ],
    [ ''        => 11,   'NTFS (NT)'                    ],
    [ ''        => 12,   'SMS QDOS'                     ],
    [ ''        => 13,   'Acorn RISCOS'                 ],
    [ 'MSWin32' => 14,   'VFAT file system (Win95, NT)' ],
    [ ''        => 15,   'MVS'                          ],
    [ 'beos'    => 16,   'BeOS'                         ],
    [ ''        => 17,   'Tandem/NSK'                   ],
    [ ''        => 18,   'THEOS'                        ],
    [ ''        => 255,  'Unknown OS'                   ],
  );

  %OSnames = map { $$_[1] => $$_[2] }  
             @GZIP_OS_Names ;
}

sub getOSCode
{
    my $default = 3 ; # Unix is the default

    my $uname = $^O;

    for my $h (@GZIP_OS_Names)
    {
        my ($pattern, $code, $name) = @$h;

        return $code
            if $pattern && $uname eq $pattern ;
    }

    return $default ;
}

sub getOSname
{
    my $code = shift ;

    return $OSnames{$code} || 'Unknown OS' ;
}

# end of file Makefile.PL
Commit	Line	Data
25f0751f	1	#! perl -w
	2
	3	use strict ;
	4	require 5.004 ;
	5
	6	use private::MakeUtil;
	7	use ExtUtils::MakeMaker 5.16 ;
258133d1	8	use ExtUtils::Install (); # only needed to check for version
25f0751f	9
	10	my $ZLIB_LIB ;
	11	my $ZLIB_INCLUDE ;
	12	my $BUILD_ZLIB = 0 ;
	13	my $OLD_ZLIB = '' ;
	14	my $WALL = '' ;
	15	my $GZIP_OS_CODE = -1 ;
9f44f717	16	my $USE_PPPORT_H = ($ENV{PERL_CORE}) ? '' : '-DUSE_PPPORT_H';
25f0751f	17
	18	#$WALL = ' -pedantic ' if $Config{'cc'} =~ /gcc/ ;
	19	#$WALL = ' -Wall -Wno-comment ' if $Config{'cc'} =~ /gcc/ ;
	20
258133d1	21	# Ticket #18986 says that ExtUtils::Install 1.39 fixes the in-use issue
	22	# on win32/cygwin, so make the code below conditional on the version of
	23	# ExtUtils::Install.
	24
	25	# Don't ask if MM_USE_DEFAULT is set -- enables perl core building on cygwin
	26	if ($^O =~ /cygwin/i and $ExtUtils::Install::VERSION < 1.39
	27	and not ($ENV{PERL_MM_USE_DEFAULT} or $ENV{PERL_CORE}))
25f0751f	28	{
	29	print <<EOM ;
	30
	31	I see you are running Cygwin.
	32
258133d1	33	Please note that this module cannot be installed on Cygwin using the CPAN
258133d1	34	shell. The CPAN Shell uses Compress::Raw::Zlib internally and it is not
25f0751f	35	possible to delete an active DLL.
	36
	37	If you are running the CPAN shell, please exit it and install this module
	38	by hand by running 'make install' under the directory
	39
	40	~/.cpan/build/Compress-Raw-Zlib-VERSION
	41
	42	EOM
	43
	44	print "Do you want to continue? [Y/N]: " ;
	45	my $answer = <STDIN> ;
	46
	47	if ($answer =~ /^yes\|y/i)
	48	{
	49	print "continuing...\n"
	50	}
	51	else
	52	{
	53	print "exiting...\n" ;
	54	exit 1 ;
	55	}
	56
	57
	58	}
	59
	60	ParseCONFIG() ;
	61
	62	UpDowngrade(getPerlFiles('MANIFEST'))
	63	unless $ENV{PERL_CORE};
	64
	65	WriteMakefile(
	66	NAME => 'Compress::Raw::Zlib',
	67	VERSION_FROM => 'lib/Compress/Raw/Zlib.pm',
	68	INC => "-I$ZLIB_INCLUDE" ,
9f44f717	69	DEFINE => "$OLD_ZLIB $WALL -DGZIP_OS_CODE=$GZIP_OS_CODE $USE_PPPORT_H" ,
25f0751f	70	XS => { 'Zlib.xs' => 'Zlib.c'},
	71	'depend' => { 'Makefile' => 'config.in' },
	72	'clean' => { FILES => '*.c constants.h constants.xs' },
	73	'dist' => { COMPRESS => 'gzip',
	74	TARFLAGS => '-chvf',
	75	SUFFIX => 'gz',
	76	DIST_DEFAULT => 'MyTrebleCheck tardist',
	77	},
	78
	79	(
25f0751f	80	$BUILD_ZLIB
	81	? zlib_files($ZLIB_LIB)
	82	: (LIBS => [ "-L$ZLIB_LIB -lz " ])
	83	),
	84
d56f7e4c	85	INSTALLDIRS => ($] >= 5.009 ? 'perl' : 'site'),
d56f7e4c	86
4e7676c7	87	((ExtUtils::MakeMaker->VERSION() gt '6.30') ?
	88	('LICENSE' => 'perl') : ()),
	89
25f0751f	90	) ;
	91
	92	my @names = qw(
	93
	94	DEF_WBITS
	95	MAX_MEM_LEVEL
	96	MAX_WBITS
	97	OS_CODE
	98
	99	Z_ASCII
	100	Z_BEST_COMPRESSION
	101	Z_BEST_SPEED
	102	Z_BINARY
	103	Z_BLOCK
	104	Z_BUF_ERROR
	105	Z_DATA_ERROR
	106	Z_DEFAULT_COMPRESSION
	107	Z_DEFAULT_STRATEGY
	108	Z_DEFLATED
	109	Z_ERRNO
	110	Z_FILTERED
	111	Z_FINISH
	112	Z_FIXED
	113	Z_FULL_FLUSH
	114	Z_HUFFMAN_ONLY
	115	Z_MEM_ERROR
	116	Z_NEED_DICT
	117	Z_NO_COMPRESSION
	118	Z_NO_FLUSH
	119	Z_NULL
	120	Z_OK
	121	Z_PARTIAL_FLUSH
	122	Z_RLE
	123	Z_STREAM_END
	124	Z_STREAM_ERROR
	125	Z_SYNC_FLUSH
	126	Z_UNKNOWN
	127	Z_VERSION_ERROR
	128
	129	);
	130	#ZLIB_VERNUM
	131
	132	if (eval {require ExtUtils::Constant; 1}) {
	133	# Check the constants above all appear in @EXPORT in Zlib.pm
	134	my %names = map { $_, 1} @names, 'ZLIB_VERSION';
	135	open F, "<lib/Compress/Raw/Zlib.pm" or die "Cannot open Zlib.pm: $!\n";
	136	while (<F>)
	137	{
	138	last if /^\s*\@EXPORT\s+=\s+qw\(/ ;
	139	}
	140
	141	while (<F>)
	142	{
	143	last if /^\s*\)/ ;
	144	/(\S+)/ ;
	145	delete $names{$1} if defined $1 ;
	146	}
	147	close F ;
	148
	149	if ( keys %names )
	150	{
	151	my $missing = join ("\n\t", sort keys %names) ;
	152	die "The following names are missing from \@EXPORT in Zlib.pm\n" .
	153	"\t$missing\n" ;
154	}
155
156	push @names, {name => 'ZLIB_VERSION', type => 'PV' };
157
158	ExtUtils::Constant::WriteConstants(
159	NAME => 'Zlib',
160	NAMES => \@names,
161	C_FILE => 'constants.h',
162	XS_FILE => 'constants.xs',
163
164	);
165	}
166	else {
167	foreach my $name (qw( constants.h constants.xs ))
168	{
169	my $from = catfile('fallback', $name);
170	copy ($from, $name)
171	or die "Can't copy $from to $name: $!";
172	}
173	}
174
175	sub ParseCONFIG
176	{
177	my ($k, $v) ;
178	my @badkey = () ;
179	my %Info = () ;
180	my @Options = qw( INCLUDE LIB BUILD_ZLIB OLD_ZLIB GZIP_OS_CODE ) ;
181	my %ValidOption = map {$_, 1} @Options ;
182	my %Parsed = %ValidOption ;
183	my $CONFIG = 'config.in' ;
184
185	print "Parsing $CONFIG...\n" ;
186
187	open(F, "<$CONFIG") or die "Cannot open file $CONFIG: $!\n" ;
188	while (<F>) {
189	s/^\s\|\s$//g ;
190	next if /^\s$/ or /^\s#/ ;
191	s/\s#\s$// ;
192
193	($k, $v) = split(/\s+=\s+/, $_, 2) ;
194	$k = uc $k ;
195	if ($ValidOption{$k}) {
196	delete $Parsed{$k} ;
197	$Info{$k} = $v ;
198	}
199	else {
200	push(@badkey, $k) ;
201	}
202	}
203	close F ;
204
205	print "Unknown keys in $CONFIG ignored [@badkey]\n"
206	if @badkey ;
207
208	# check parsed values
209	my @missing = () ;
210	die "The following keys are missing from $CONFIG [@missing]\n"
211	if @missing = keys %Parsed ;
212
213	$ZLIB_INCLUDE = $ENV{'ZLIB_INCLUDE'} \|\| $Info{'INCLUDE'} ;
214	$ZLIB_LIB = $ENV{'ZLIB_LIB'} \|\| $Info{'LIB'} ;
215
216	if ($^O eq 'VMS') {
217	$ZLIB_INCLUDE = VMS::Filespec::vmspath($ZLIB_INCLUDE);
218	$ZLIB_LIB = VMS::Filespec::vmspath($ZLIB_LIB);
219	}
220
221	my $y = $ENV{'OLD_ZLIB'} \|\| $Info{'OLD_ZLIB'} ;
222	$OLD_ZLIB = '-DOLD_ZLIB' if $y and $y =~ /^yes\|on\|true\|1$/i;
223
224	my $x = $ENV{'BUILD_ZLIB'} \|\| $Info{'BUILD_ZLIB'} ;
225
226	if ($x and $x =~ /^yes\|on\|true\|1$/i ) {
227
228	$BUILD_ZLIB = 1 ;
229
230	# ZLIB_LIB & ZLIB_INCLUDE must point to the same place when
231	# BUILD_ZLIB is specified.
232	die "INCLUDE & LIB must be the same when BUILD_ZLIB is True\n"
233	if $ZLIB_LIB ne $ZLIB_INCLUDE ;
234
235	# Check the zlib source directory exists
236	die "LIB/INCLUDE directory '$ZLIB_LIB' does not exits\n"
237	unless -d $ZLIB_LIB ;
238
239	# check for a well known file
240	die "LIB/INCLUDE directory, '$ZLIB_LIB', doesn't seem to have the zlib source files\n"
241	unless -e catfile($ZLIB_LIB, 'zlib.h') ;
242
243
244	# write the Makefile
245	print "Building Zlib enabled\n" ;
246	}
247
248	$GZIP_OS_CODE = defined $ENV{'GZIP_OS_CODE'}
249	? $ENV{'GZIP_OS_CODE'}
250	: $Info{'GZIP_OS_CODE'} ;
251
252	die "GZIP_OS_CODE not 'AUTO_DETECT' or a number between 0 and 255\n"
253	unless uc $GZIP_OS_CODE eq 'AUTO_DETECT'
254	\|\| ( $GZIP_OS_CODE =~ /^(\d+)$/ && $1 >= 0 && $1 <= 255) ;
255
256	if (uc $GZIP_OS_CODE eq 'AUTO_DETECT')
257	{
258	print "Auto Detect Gzip OS Code..\n" ;
259	$GZIP_OS_CODE = getOSCode() ;
260	}
261
262	my $name = getOSname($GZIP_OS_CODE);
263	print "Setting Gzip OS Code to $GZIP_OS_CODE [$name]\n" ;
264
265	print <<EOM if 0 ;
266	INCLUDE [$ZLIB_INCLUDE]
267	LIB [$ZLIB_LIB]
268	GZIP_OS_CODE [$GZIP_OS_CODE]
269	OLD_ZLIB [$OLD_ZLIB]
270	BUILD_ZLIB [$BUILD_ZLIB]
271
272	EOM
273
274	print "Looks Good.\n" ;
275
276	}
277
278
279
280	sub zlib_files
281	{
282	my $dir = shift ;
283
284	my @h_files = ();
285	my @c_files = ();
286
287	if (-f catfile($dir, "infback.c")) {
288	# zlib 1.2.0 or greater
289	#
290	@h_files = qw(crc32.h inffast.h inflate.h trees.h zconf.in.h
291	zutil.h deflate.h inffixed.h inftrees.h zconf.h
292	zlib.h
293	);
294	@c_files = qw(adler32 crc32 infback inflate uncompr
295	compress deflate inffast inftrees
296	trees zutil
297	);
298	}
299	else {
300	# zlib 1.1.x
301
302	@h_files = qw(deflate.h infcodes.h inftrees.h zconf.h zutil.h
303	infblock.h inffast.h infutil.h zlib.h
304	);
305	@c_files = qw(adler32 compress crc32 uncompr
306	deflate trees zutil inflate infblock
307	inftrees infcodes infutil inffast
308	);
309	}
310
311	@h_files = map { catfile($dir, $_) } @h_files ;
312	my @o_files = map { "$_\$(OBJ_EXT)" } 'Zlib', @c_files;
313	@c_files = map { "$_.c" } 'Zlib', @c_files ;
314
315	foreach my $file (@c_files)
316	{ copy(catfile($dir, $file), '.') }
317
318	return (
319	#'H' => [ @h_files ],
320	'C' => [ @c_files ] ,
321	#'OBJECT' => qq[ @o_files ],
322	'OBJECT' => q[ $(O_FILES) ],
323
324
325	) ;
326	}
327
328
329
cb7abd7f	330	use vars qw ( @GZIP_OS_Names %OSnames) ;
25f0751f	331
	332	BEGIN
	333	{
	334	@GZIP_OS_Names = (
	335	[ '' => 0, 'MS-DOS' ],
	336	[ 'amigaos' => 1, 'Amiga' ],
	337	[ 'VMS' => 2, 'VMS' ],
	338	[ '' => 3, 'Unix/Default' ],
	339	[ '' => 4, 'VM/CMS' ],
	340	[ '' => 5, 'Atari TOS' ],
	341	[ 'os2' => 6, 'HPFS (OS/2, NT)' ],
	342	[ 'MacOS' => 7, 'Macintosh' ],
	343	[ '' => 8, 'Z-System' ],
	344	[ '' => 9, 'CP/M' ],
	345	[ '' => 10, 'TOPS-20' ],
	346	[ '' => 11, 'NTFS (NT)' ],
	347	[ '' => 12, 'SMS QDOS' ],
	348	[ '' => 13, 'Acorn RISCOS' ],
	349	[ 'MSWin32' => 14, 'VFAT file system (Win95, NT)' ],
	350	[ '' => 15, 'MVS' ],
	351	[ 'beos' => 16, 'BeOS' ],
	352	[ '' => 17, 'Tandem/NSK' ],
	353	[ '' => 18, 'THEOS' ],
	354	[ '' => 255, 'Unknown OS' ],
	355	);
	356
	357	%OSnames = map { $$_[1] => $$_[2] }
	358	@GZIP_OS_Names ;
	359	}
	360
	361	sub getOSCode
	362	{
	363	my $default = 3 ; # Unix is the default
	364
	365	my $uname = $^O;
	366
	367	for my $h (@GZIP_OS_Names)
	368	{
	369	my ($pattern, $code, $name) = @$h;
	370
	371	return $code
	372	if $pattern && $uname eq $pattern ;
	373	}
	374
	375	return $default ;
	376	}
	377
	378	sub getOSname
	379	{
	380	my $code = shift ;
	381
	382	return $OSnames{$code} \|\| 'Unknown OS' ;
	383	}
	384
	385	# end of file Makefile.PL
	386