{- # -*- Mode: perl -*-

 use File::Basename;

 # A cache of objects for which a recipe has already been generated

 my %cache;

 # resolvedepends and reducedepends work in tandem to make sure

 # there are no duplicate dependencies and that they are in the

 # right order.  This is especially used to sort the list of

 # libraries that a build depends on.

 sub extensionlesslib {

     my @result = map { $_ =~ /(\.a)?$/; $` } @_;

     return @result if wantarray;

     return $result[0];

 }

 sub resolvedepends {

     my $thing = shift;

     my $extensionlessthing = extensionlesslib($thing);

     my @listsofar = @_;    # to check if we're looping

     my @list = @{$unified_info{depends}->{$thing} //

                      $unified_info{depends}->{$extensionlessthing}};

     my @newlist = ();

     if (scalar @list) {

         foreach my $item (@list) {

             my $extensionlessitem = extensionlesslib($item);

             # It's time to break off when the dependency list starts looping

             next if grep { extensionlesslib($_) eq $extensionlessitem } @listsofar;

             push @newlist, $item, resolvedepends($item, @listsofar, $item);

         }

     }

     @newlist;

 }

 sub reducedepends {

     my @list = @_;

     my @newlist = ();

     my %replace = ();

     while (@list) {

         my $item = shift @list;

         my $extensionlessitem = extensionlesslib($item);

         if (grep { $extensionlessitem eq extensionlesslib($_) } @list) {

             if ($item ne $extensionlessitem) {

                 # If this instance of the library is explicitly static, we

                 # prefer that to any shared library name, since it must have

                 # been done on purpose.

                 $replace{$extensionlessitem} = $item;

             }

         } else {

             push @newlist, $item;

         }

     }

     map { $replace{$_} // $_; } @newlist;

 }

 # is_installed checks if a given file will be installed (i.e. they are

 # not defined _NO_INST in build.info)

 sub is_installed {

     my $product = shift;

     if (grep { $product eq $_ }

         map { (@{$unified_info{install}->{$_}}) }

         keys %{$unified_info{install}}) {

         return 1;

     }

     return 0;

 }

 # dogenerate is responsible for producing all the recipes that build

 # generated source files.  It recurses in case a dependency is also a

 # generated source file.

 sub dogenerate {

     my $src = shift;

     return "" if $cache{$src};

     my $obj = shift;

     my $bin = shift;

     my %opts = @_;

     if ($unified_info{generate}->{$src}) {

         die "$src is generated by Configure, should not appear in build file\n"

             if ref $unified_info{generate}->{$src} eq "";

         my $script = $unified_info{generate}->{$src}->[0];

         $OUT .= generatesrc(src => $src,

                             generator => $unified_info{generate}->{$src},

                             generator_incs => $unified_info{includes}->{$script},

                             generator_deps => $unified_info{depends}->{$script},

                             deps => $unified_info{depends}->{$src},

                             incs => $unified_info{includes}->{$obj},

                             %opts);

         foreach (@{$unified_info{depends}->{$src}}) {

             dogenerate($_, $obj, $bin, %opts);

         }

     }

     $cache{$src} = 1;

 }

 # doobj is responsible for producing all the recipes that build

 # object files as well as dependency files.

 sub doobj {

     my $obj = shift;

     return "" if $cache{$obj};

     my $bin = shift;

     my %opts = @_;

     if (@{$unified_info{sources}->{$obj}}) {

         $OUT .= src2obj(obj => $obj,

                         product => $bin,

                         srcs => $unified_info{sources}->{$obj},

                         deps => $unified_info{depends}->{$obj},

                         incs => $unified_info{includes}->{$obj},

                         %opts);

         foreach ((@{$unified_info{sources}->{$obj}},

                   @{$unified_info{depends}->{$obj}})) {

             dogenerate($_, $obj, $bin, %opts);

         }

     }

     $cache{$obj} = 1;

 }

 # dolib is responsible for building libraries.  It will call

 # libobj2shlib is shared libraries are produced, and obj2lib in all

 # cases.  It also makes sure all object files for the library are

 # built.

 sub dolib {

     my $lib = shift;

     return "" if $cache{$lib};

     unless ($disabled{shared} || $lib =~ /\.a$/) {

         $OUT .= libobj2shlib(shlib => $unified_info{sharednames}->{$lib},

                              lib => $lib,

                              objs => [ @{$unified_info{shared_sources}->{$lib}},

                                        @{$unified_info{sources}->{$lib}} ],

                              deps => [ reducedepends(resolvedepends($lib)) ],

                              installed => is_installed($lib));

         foreach ((@{$unified_info{shared_sources}->{$lib}},

                   @{$unified_info{sources}->{$lib}})) {

             # If this is somehow a compiled object, take care of it that way

             # Otherwise, it might simply be generated

             if (defined $unified_info{sources}->{$_}) {

                 doobj($_, $lib, intent => "lib", installed => is_installed($lib));

             } else {

                 dogenerate($_, undef, undef, intent => "lib");

             }

         }

     }

     $OUT .= obj2lib(lib => $lib,

                     objs => [ @{$unified_info{sources}->{$lib}} ]);

     foreach (@{$unified_info{sources}->{$lib}}) {

         doobj($_, $lib, intent => "lib", installed => is_installed($lib));

     }

     $cache{$lib} = 1;

 }

 # doengine is responsible for building engines.  It will call

 # obj2dso, and also makes sure all object files for the library

 # are built.

 sub doengine {

     my $lib = shift;

     return "" if $cache{$lib};

     $OUT .= obj2dso(lib => $lib,

                     objs => [ @{$unified_info{sources}->{$lib}},

                               @{$unified_info{shared_sources}->{$lib}} ],

                     deps => [ resolvedepends($lib) ],

                     installed => is_installed($lib));

     foreach ((@{$unified_info{sources}->{$lib}},

               @{$unified_info{shared_sources}->{$lib}})) {

         doobj($_, $lib, intent => "dso", installed => is_installed($lib));

     }

     $cache{$lib} = 1;

 }

 # dobin is responsible for building programs.  It will call obj2bin,

 # and also makes sure all object files for the library are built.

 sub dobin {

     my $bin = shift;

     return "" if $cache{$bin};

     my $deps = [ reducedepends(resolvedepends($bin)) ];

     $OUT .= obj2bin(bin => $bin,

                     objs => [ @{$unified_info{sources}->{$bin}} ],

                     deps => $deps,

                     installed => is_installed($bin));

     foreach (@{$unified_info{sources}->{$bin}}) {

         doobj($_, $bin, intent => "bin", installed => is_installed($bin));

     }

     $cache{$bin} = 1;

 }

 # dobin is responsible for building scripts from templates.  It will

 # call in2script.

 sub doscript {

     my $script = shift;

     return "" if $cache{$script};

     $OUT .= in2script(script => $script,

                       sources => $unified_info{sources}->{$script},

                       installed => is_installed($script));

     $cache{$script} = 1;

 }

 sub dodir {

     my $dir = shift;

     return "" if !exists(&generatedir) or $cache{$dir};

     $OUT .= generatedir(dir => $dir,

                         deps => $unified_info{dirinfo}->{$dir}->{deps},

                         %{$unified_info{dirinfo}->{$_}->{products}});

     $cache{$dir} = 1;

 }

 # Start with populating the cache with all the overrides

 %cache = map { $_ => 1 } @{$unified_info{overrides}};

 # Build mandatory generated headers

 foreach (@{$unified_info{depends}->{""}}) { dogenerate($_); }

 # Build all known libraries, engines, programs and scripts.

 # Everything else will be handled as a consequence.

 foreach (@{$unified_info{libraries}}) { dolib($_);    }

 foreach (@{$unified_info{engines}})   { doengine($_); }

 foreach (@{$unified_info{programs}})  { dobin($_);    }

 foreach (@{$unified_info{scripts}})   { doscript($_); }

 foreach (sort keys %{$unified_info{dirinfo}})  { dodir($_); }

 # Finally, should there be any applicable BEGINRAW/ENDRAW sections,

 # they are added here.

 $OUT .= $_."\n" foreach @{$unified_info{rawlines}};

-}