Unified - a native Windows makefile template

##

## Makefile for OpenSSL

##

## {- join("\n## ", @autowarntext) -}

{-

 our $objext = $target{obj_extension} || ".obj";

 our $depext = $target{dep_extension} || ".d";

 our $exeext = $target{exe_extension} || ".exe";

 our $libext = $target{lib_extension} || ".lib";

 our $shlibext = $target{shared_extension} || ".dll";

 our $shlibextimport = $target{shared_import_extension} || ".lib";

 our $dsoext = $target{dso_extension} || ".dll";

 sub shlib {

     return () if $disabled{shared};

     my $lib = shift;

     return $unified_info{sharednames}->{$lib} . $shlibext;

 }

 sub shlib_import {

     return () if $disabled{shared};

     my $lib = shift;

     return $lib . $shlibextimport;

 }

 sub dso {

     my $dso = shift;

     return $dso . $dsoext;

 }

 '';

-}

PLATFORM={- $config{target} -}

SRCDIR={- $config{sourcedir} -}

BLDDIR={- $config{builddir} -}

VERSION={- $config{version} -}

MAJOR={- $config{major} -}

MINOR={- $config{minor} -}

SHLIB_VERSION_NUMBER={- $config{shlib_version_number} -}

LIBS={- join(" ", map { $_.$libext } @{$unified_info{libraries}}) -}

SHLIBS={- join(" ", map { shlib($_) } @{$unified_info{libraries}}) -}

ENGINES={- join(" ", map { dso($_) } @{$unified_info{engines}}) -}

PROGRAMS={- join(" ", map { $_.$exeext } grep { !m|^test\\| } @{$unified_info{programs}}) -}

TESTPROGS={- join(" ", map { $_.$exeext } grep { m|^test\\| } @{$unified_info{programs}}) -}

SCRIPTS={- join(" ", @{$unified_info{scripts}}) -}

DEPS={- join(" ", map { (my $x = $_) =~ s|\.o$|$depext|; $x; }

                  grep { $unified_info{sources}->{$_}->[0] =~ /\.c$/ }

                  keys %{$unified_info{sources}}); -}

# Do not edit these manually. Use Configure with --prefix or --openssldir

# to change this!  Short explanation in the top comment in Configure

INSTALLTOP={- # $prefix is used in the OPENSSLDIR perl snippet

	      #

	      our $prefix = $config{prefix} || "/usr/local";

              $prefix -}

OPENSSLDIR={- #

	      # The logic here is that if no --openssldir was given,

	      # OPENSSLDIR will get the value from $prefix plus "/ssl".

	      # If --openssldir was given and the value is an absolute

	      # path, OPENSSLDIR will get its value without change.

	      # If the value from --openssldir is a relative path,

	      # OPENSSLDIR will get $prefix with the --openssldir

	      # value appended as a subdirectory.

	      #

              use File::Spec::Functions;

              our $openssldir =

                  $config{openssldir} ?

                      (file_name_is_absolute($config{openssldir}) ?

                           $config{openssldir}

                           : catdir($prefix, $config{openssldir}))

                      : catdir($prefix, "ssl");

              $openssldir -}

LIBDIR={- #

          # if $prefix/lib$target{multilib} is not an existing

          # directory, then assume that it's not searched by linker

          # automatically, in which case adding $target{multilib} suffix

          # causes more grief than we're ready to tolerate, so don't...

          our $multilib =

              -d "$prefix/lib$target{multilib}" ? $target{multilib} : "";

          our $libdir = $config{libdir} || "lib$multilib";

          $libdir -}

ENGINESDIR={- use File::Spec::Functions;

              our $enginesdir = catdir($prefix,$libdir,"engines");

	      $enginesdir -}

CC={- $target{cc} -}

CFLAGS={- join(" ",(map { "-D".$_} @{$target{defines}}, @{$config{defines}})) -} {- join(" ", quotify_l("-DENGINESDIR=\"$enginesdir\"", "-DOPENSSLDIR=\"$openssldir\"")) -} {- $target{cflags} -} {- $config{cflags} -}

COUTFLAG={- $target{coutflag} || "/Fo" -}

LD={- $target{ld} || "link" -}

LDFLAGS={- $target{lflags} -}

LDOUTFLAG={- $target{loutflag} || "/out:" -}

EX_LIBS={- $config{ex_libs} -}

SHARED_CFLAGS={- $target{shared_cflag} || "" -}

SHARED_LDFLAGS={- $target{shared_ldflag} || "" -}

DSO_CFLAGS={- $target{shared_cflag} || "" -}

BIN_CFLAGS={- $target{bin_cflags} -}

PERL={- $config{perl} -}

AR={- $target{ar} -}

ARFLAGS= {- $target{arflags} -}

AROUTFLAG={- $target{aroutflag} || "/out:" -}

AS={- $target{as} -}

ASFLAGS={- $target{asflags} -}

ASOUTFLAG={- $target{asoutflag} -}

PERLASM_SCHEME= {- $target{perlasm_scheme} -}

PROCESSOR= {- $config{processor} -}

# The main targets ###################################################

all: configdata.pm build_libs_nodep build_engines_nodep build_apps_nodep \

     depend link-utils

build_libs: configdata.pm build_libs_nodep depend

build_libs_nodep: $(LIBS)

build_engines: configdata.pm build_engines_nodep depend

build_engines_nodep: $(ENGINES)

build_apps: configdata.pm build_apps_nodep depend

build_apps_nodep: $(PROGRAMS) $(SCRIPTS)

build_tests: configdata.pm build_tests_nodep depend

build_tests_nodep: $(TESTPROGS)

test tests: build_tests_nodep build_apps_nodep build_engines_nodep depend rehash

	set SRCTOP=$(SRCDIR)

	set BLDTOP=$(BLDDIR)

	set PERL=$(PERL)

	$(PERL) $(SRCDIR)\test\run_tests.pl $(TESTS)

list-tests:

	@set TOP=$(SRCDIR)

	@set PERL=$(PERL)

	@$(PERL) $(SRCDIR)\test\run_tests.pl list

depend:

# Building targets ###################################################

configdata.pm: {- $config{build_file_template} -} $(SRCDIR)\Configure

	@echo "Detected changed: $?"

	@echo "Reconfiguring..."

	$(PERL) $(SRCDIR)\Configure reconf

	@echo "**************************************************"

	@echo "***                                            ***"

	@echo "***   Please run the same make command again   ***"

	@echo "***                                            ***"

	@echo "**************************************************"

	@( exit 1 )

{-

 use File::Basename;

 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;

 # Helper function to figure out dependencies on libraries

 # It takes a list of library names and outputs a list of dependencies

 sub compute_lib_depends {

     if ($disabled{shared}) {

	 return map { $_.$libext } @_;

     }

     return map { shlib_import($_) } @_;

 }

 sub src2obj {

     my %args = @_;

     my $obj = $args{obj};

     my @srcs = map { (my $x = $_) =~ s/\.[sS]$/.asm/; $x } ( @{$args{srcs}} );

     my $srcs = join(" ",  @srcs);

     my $deps = join(" ", @srcs, @{$args{deps}});

     my $incs = join("", map { " /I ".$_ } @{$args{incs}});

     my $ecflags = { lib => '$(SHARED_CFLAGS)',

		     dso => '$(DSO_CFLAGS)',

		     bin => '$(BIN_CFLAGS)' } -> {$args{intent}};

     my $makedepprog = $config{makedepprog};

     if ($srcs[0] =~ /\.asm$/) {

         return <<"EOF";

$obj$objext: $deps

	\$(AS) \$(ASFLAGS) \$(ASOUTFLAG)\$\@ $srcs

EOF

     }

     return <<"EOF";

$obj$depext: $deps

	\$(CC) \$(CFLAGS) $ecflags$inc /Zs /showIncludes $srcs 2>&1 | \\

	    \$(PERL) -n << > $obj$depext

chomp;

s/^Note: including file: *//;

\$\$collect{\$\$_} = 1;

END { print '$obj$objext: ',join(" ", sort keys \%collect),"\\n" }

<<KEEP

$obj$objext: $obj$depext

	\$(CC) \$(CFLAGS) $ecflags$incs -c \$(COUTFLAG)\$\@ @<<

$srcs

<<KEEP

EOF

 }

 # On Unix, we build shlibs from static libs, so we're ignoring the

 # object file array.  We *know* this routine is only called when we've

 # configure 'shared'.

 sub libobj2shlib {

     my %args = @_;

     my $lib = $args{lib};

     my $shlib = $args{shlib};

     (my $mkdef_key = $lib) =~ s/^lib//i;

     my $objs = join("\n", map { $_.$objext } @{$args{objs}});

     my $linklibs = join("",

			 map { "\n$_" } compute_lib_depends(@{$args{deps}}));

     my $deps = join(" ",

		     (map { $_.$objext } @{$args{objs}}),

		     compute_lib_depends(@{$args{deps}}));

     my $ordinalsfile = defined($args{ordinals}) ? $args{ordinals}->[1] : "";

     my $mkdef_pl = abs2rel(rel2abs(catfile($config{sourcedir},

					    "util", "mkdef.pl")),

			    rel2abs($config{builddir}));

     my $target = shlib_import($lib);

     return <<"EOF"

$target: $deps $ordinalsfile

	\$(PERL) $mkdef_pl "$mkdef_key" 32 > $shlib.def

	\$(LD) \$(LDFLAGS) \\

		/dll /implib:$target \$(LDOUTFLAG)$shlib$shlibext /def:$shlib.def @<<

$objs$linklibs \$(EX_LIBS)

<<

EOF

 }

 sub obj2dso {

     my %args = @_;

     my $dso = $args{lib};

     my $objs = join("\n", map { $_.$objext } @{$args{objs}});

     my $linklibs = join("",

			 map { "\n$_" } compute_lib_depends(@{$args{deps}}));

     my $deps = join(" ",

		     (map { $_.$objext } @{$args{objs}}),

		     compute_lib_depends(@{$args{deps}}));

     return <<"EOF";

$dso$dsoext: $deps

	\$(LD) \$(LDFLAGS) /dll \$(LDOUTFLAG)$dso$dsoext /def:<< @<<

LIBRARY         $dso

EXPORTS

    bind_engine		@1

    v_check		@2

<<

$objs$linklibs \$(EX_LIBS)

<<

EOF

 }

 sub obj2lib {

     my %args = @_;

     my $lib = $args{lib};

     my $objs = join("\n", map { $_.$objext } @{$args{objs}});

     my $deps = join(" ", map { $_.$objext } @{$args{objs}});

     return <<"EOF";

$lib$libext: $deps

	\$(AR) \$(ARFLAGS) \$(AROUTFLAG)$lib$libext @<<

$objs

<<

EOF

 }

 sub obj2bin {

     my %args = @_;

     my $bin = $args{bin};

     my $objs = join("\n", map { $_.$objext } @{$args{objs}});

     my $linklibs = join("",

			 map { "\n$_" } compute_lib_depends(@{$args{deps}}));

     my $deps = join(" ",

		     (map { $_.$objext } @{$args{objs}}),

		     compute_lib_depends(@{$args{deps}}));

     return <<"EOF";

$bin$exeext: $deps

	\$(LD) \$(LDFLAGS) \$(LDOUTFLAG)$bin$exeext @<<

$objs setargv.obj$linklibs \$(EX_LIBS)

<<

EOF

  }

  sub in2script {

      my %args = @_;

      my $script = $args{script};

      my $sources = join(" ", @{$args{sources}});

      my $dofile = abs2rel(rel2abs(catfile($config{sourcedir},

                                           "util", "dofile.pl")),

                           rel2abs($config{builddir}));

      return <<"EOF";

$script: $sources

	\$(PERL) "-I\$(BLDDIR)" -Mconfigdata "$dofile" \\

	    "-o$target{build_file}" $sources > "$script"

EOF

  }

  ""    # Important!  This becomes part of the template result.

-}