package gentemplate; use strict; use warnings; use Carp; use Exporter; use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); @ISA = qw(Exporter); @EXPORT = qw(gentemplate); use File::Basename; sub gentemplate { my %opts = @_; my $generator = OpenSSL::GenTemplate->new(%opts); # Build mandatory header file generators foreach (@{$generator->{info}->{depends}->{""}}) { $generator->dogenerate($_); } # Build all known targets, libraries, modules, programs and scripts. # Everything else will be handled as a consequence. foreach (@{$generator->{info}->{targets}}) { $generator->dotarget($_); } foreach (@{$generator->{info}->{libraries}}) { $generator->dolib($_); } foreach (@{$generator->{info}->{modules}}) { $generator->domodule($_); } foreach (@{$generator->{info}->{programs}}) { $generator->dobin($_); } foreach (@{$generator->{info}->{scripts}}) { $generator->doscript($_); } foreach (sort keys %{$generator->{info}->{htmldocs}}) { $generator->dodocs('html', $_); } foreach (sort keys %{$generator->{info}->{mandocs}}) { $generator->dodocs('man', $_); } foreach (sort keys %{$generator->{info}->{dirinfo}}) { $generator->dodir($_); } } package OpenSSL::GenTemplate; use OpenSSL::Util; sub new { my $class = shift; my %opts = @_; my $data = { output => $opts{output}, config => $opts{config} // {}, disabled => $opts{disabled} // {}, info => $opts{unified_info} // {}, }; return bless $data, $class; }; sub emit { my $self = shift; my $name = shift; my %opts = @_; my $fh = $self->{output}; die "No name?" unless $name; print $fh "{-\n ", $name, '(', dump_data(\%opts), ');', " \n-}"; } my $debug_resolvedepends = $ENV{BUILDFILE_DEBUG_DEPENDS}; my $debug_rules = $ENV{BUILDFILE_DEBUG_RULES}; # A cache of objects for which a recipe has already been generated our %cache; # collectdepends, expanddepends and reducedepends work together to make # sure there are no duplicate or weak dependencies and that they are in # the right order. This is 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]; } # collectdepends dives into the tree of dependencies and returns # a list of all the non-weak ones. sub collectdepends { my $self = shift; return () unless @_; my $thing = shift; my $extensionlessthing = extensionlesslib($thing); my @listsofar = @_; # to check if we're looping my @list = @{ $self->{info}->{depends}->{$thing} // $self->{info}->{depends}->{$extensionlessthing} // [] }; my @newlist = (); print STDERR "DEBUG[collectdepends] $thing > ", join(' ', @listsofar), "\n" if $debug_resolvedepends; 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; # Don't add anything here if the dependency is weak next if defined $self->{info}->{attributes}->{depends}->{$thing}->{$item}->{'weak'}; my @resolved = $self->collectdepends($item, @listsofar, $item); push @newlist, $item, @resolved; } print STDERR "DEBUG[collectdepends] $thing < ", join(' ', @newlist), "\n" if $debug_resolvedepends; @newlist; } # expanddepends goes through a list of stuff, checks if they have any # dependencies, and adds them at the end of the current position if # they aren't already present later on. sub expanddepends { my $self = shift; my @after = ( @_ ); print STDERR "DEBUG[expanddepends]> ", join(' ', @after), "\n" if $debug_resolvedepends; my @before = (); while (@after) { my $item = shift @after; print STDERR "DEBUG[expanddepends]\\ ", join(' ', @before), "\n" if $debug_resolvedepends; print STDERR "DEBUG[expanddepends] - ", $item, "\n" if $debug_resolvedepends; my @middle = ( $item, map { my $x = $_; my $extlessx = extensionlesslib($x); if (grep { $extlessx eq extensionlesslib($_) } @before and !grep { $extlessx eq extensionlesslib($_) } @after) { print STDERR "DEBUG[expanddepends] + ", $x, "\n" if $debug_resolvedepends; ( $x ) } else { print STDERR "DEBUG[expanddepends] ! ", $x, "\n" if $debug_resolvedepends; () } } @{$self->{info}->{depends}->{$item} // []} ); print STDERR "DEBUG[expanddepends] = ", join(' ', @middle), "\n" if $debug_resolvedepends; print STDERR "DEBUG[expanddepends]/ ", join(' ', @after), "\n" if $debug_resolvedepends; push @before, @middle; } print STDERR "DEBUG[expanddepends]< ", join(' ', @before), "\n" if $debug_resolvedepends; @before; } # reducedepends looks through a list, and checks if each item is # repeated later on. If it is, the earlier copy is dropped. sub reducedepends { my @list = @_; print STDERR "DEBUG[reducedepends]> ", join(' ', @list), "\n" if $debug_resolvedepends; 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; } } @newlist = map { $replace{$_} // $_; } @newlist; print STDERR "DEBUG[reducedepends]< ", join(' ', @newlist), "\n" if $debug_resolvedepends; @newlist; } # Do it all # This takes multiple inputs and combine them into a single list of # interdependent things. The returned value will include all the input. # Callers are responsible for taking away the things they are building. sub resolvedepends { my $self = shift; print STDERR "DEBUG[resolvedepends] START (", join(', ', @_), ")\n" if $debug_resolvedepends; my @all = reducedepends($self->expanddepends(map { ( $_, $self->collectdepends($_) ) } @_)); print STDERR "DEBUG[resolvedepends] END (", join(', ', @_), ") : ", join(',', map { "\n $_" } @all), "\n" if $debug_resolvedepends; @all; } # 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 $self = shift; my $src = shift; # Safety measure return "" unless defined $self->{info}->{generate}->{$_}; return "" if $cache{$src}; my $obj = shift; my $bin = shift; my %opts = @_; if ($self->{info}->{generate}->{$src}) { die "$src is generated by Configure, should not appear in build file\n" if ref $self->{info}->{generate}->{$src} eq ""; my $script = $self->{info}->{generate}->{$src}->[0]; $self->emit('generatesrc', src => $src, product => $bin, generator => $self->{info}->{generate}->{$src}, generator_incs => $self->{info}->{includes}->{$script} // [], generator_deps => $self->{info}->{depends}->{$script} // [], deps => $self->{info}->{depends}->{$src} // [], incs => [ defined $obj ? @{$self->{info}->{includes}->{$obj} // []} : (), defined $bin ? @{$self->{info}->{includes}->{$bin} // []} : () ], defs => [ defined $obj ? @{$self->{info}->{defines}->{$obj} // []} : (), defined $bin ? @{$self->{info}->{defines}->{$bin} // []} : () ], %opts); foreach (@{$self->{info}->{depends}->{$src} // []}) { $self->dogenerate($_, $obj, $bin, %opts); } } $cache{$src} = 1; } sub dotarget { my $self = shift; my $target = shift; return "" if $cache{$target}; $self->emit('generatetarget', target => $target, deps => $self->{info}->{depends}->{$target} // []); foreach (@{$self->{info}->{depends}->{$target} // []}) { $self->dogenerate($_); } $cache{$target} = 1; } # doobj is responsible for producing all the recipes that build # object files as well as dependency files. sub doobj { my $self = shift; my $obj = shift; return "" if $cache{$obj}; my $bin = shift; my %opts = @_; if (@{$self->{info}->{sources}->{$obj} // []}) { my @srcs = @{$self->{info}->{sources}->{$obj}}; my @deps = @{$self->{info}->{depends}->{$obj} // []}; my @incs = ( @{$self->{info}->{includes}->{$obj} // []}, @{$self->{info}->{includes}->{$bin} // []} ); my @defs = ( @{$self->{info}->{defines}->{$obj} // []}, @{$self->{info}->{defines}->{$bin} // []} ); print STDERR "DEBUG[doobj] \@srcs for $obj ($bin) : ", join(",", map { "\n $_" } @srcs), "\n" if $debug_rules; print STDERR "DEBUG[doobj] \@deps for $obj ($bin) : ", join(",", map { "\n $_" } @deps), "\n" if $debug_rules; print STDERR "DEBUG[doobj] \@incs for $obj ($bin) : ", join(",", map { "\n $_" } @incs), "\n" if $debug_rules; print STDERR "DEBUG[doobj] \@defs for $obj ($bin) : ", join(",", map { "\n $_" } @defs), "\n" if $debug_rules; print STDERR "DEBUG[doobj] \%opts for $obj ($bin) : ", , join(",", map { "\n $_ = $opts{$_}" } sort keys %opts), "\n" if $debug_rules; $self->emit('src2obj', obj => $obj, product => $bin, srcs => [ @srcs ], deps => [ @deps ], incs => [ @incs ], defs => [ @defs ], %opts); foreach ((@{$self->{info}->{sources}->{$obj}}, @{$self->{info}->{depends}->{$obj} // []})) { $self->dogenerate($_, $obj, $bin, %opts); } } $cache{$obj} = 1; } # Helper functions to grab all applicable intermediary files. # This is particularly useful when a library is given as source # rather than a dependency. In that case, we consider it to be a # container with object file references, or possibly references # to further libraries to pilfer in the same way. sub getsrclibs { my $self = shift; my $section = shift; # For all input, see if it sources static libraries. If it does, # return them together with the result of a recursive call. map { ( $_, getsrclibs($section, $_) ) } grep { $_ =~ m|\.a$| } map { @{$self->{info}->{$section}->{$_} // []} } @_; } sub getlibobjs { my $self = shift; my $section = shift; # For all input, see if it's an intermediary file (library or object). # If it is, collect the result of a recursive call, or if that returns # an empty list, the element itself. Return the result. map { my @x = $self->getlibobjs($section, @{$self->{info}->{$section}->{$_}}); @x ? @x : ( $_ ); } grep { defined $self->{info}->{$section}->{$_} } @_; } # dolib is responsible for building libraries. It will call # obj2shlib if shared libraries are produced, and obj2lib in all # cases. It also makes sure all object files for the library are # built. sub dolib { my $self = shift; my $lib = shift; return "" if $cache{$lib}; my %attrs = %{$self->{info}->{attributes}->{libraries}->{$lib} // {}}; my @deps = ( $self->resolvedepends(getsrclibs('sources', $lib)) ); # We support two types of objs, those who are specific to this library # (they end up in @objs) and those that we get indirectly, via other # libraries (they end up in @foreign_objs). We get the latter any time # someone has done something like this in build.info: # SOURCE[libfoo.a]=libbar.a # The indirect object files must be kept in a separate array so they # don't get rebuilt unnecessarily (and with incorrect auxiliary # information). # # Object files can't be collected commonly for shared and static # libraries, because we contain their respective object files in # {shared_sources} and {sources}, and because the implications are # slightly different for each library form. # # We grab all these "foreign" object files recursively with getlibobjs(). unless ($self->{disabled}->{shared} || $lib =~ /\.a$/) { # If this library sources other static libraries and those # libraries are marked {noinst}, there's no need to include # all of their object files. Instead, we treat those static # libraries as dependents alongside any other library this # one depends on, and let symbol resolution do its job. my @sourced_libs = (); my @objs = (); my @foreign_objs = (); my @deps = (); foreach (@{$self->{info}->{shared_sources}->{$lib} // []}) { if ($_ !~ m|\.a$|) { push @objs, $_; } elsif ($self->{info}->{attributes}->{libraries}->{$_}->{noinst}) { push @deps, $_; } else { push @deps, $self->getsrclibs('sources', $_); push @foreign_objs, $self->getlibobjs('sources', $_); } } @deps = ( grep { $_ ne $lib } $self->resolvedepends($lib, @deps) ); print STDERR "DEBUG[dolib:shlib] \%attrs for $lib : ", , join(",", map { "\n $_ = $attrs{$_}" } sort keys %attrs), "\n" if %attrs && $debug_rules; print STDERR "DEBUG[dolib:shlib] \@deps for $lib : ", join(",", map { "\n $_" } @deps), "\n" if @deps && $debug_rules; print STDERR "DEBUG[dolib:shlib] \@objs for $lib : ", join(",", map { "\n $_" } @objs), "\n" if @objs && $debug_rules; print STDERR "DEBUG[dolib:shlib] \@foreign_objs for $lib : ", join(",", map { "\n $_" } @foreign_objs), "\n" if @foreign_objs && $debug_rules; $self->emit('obj2shlib', lib => $lib, attrs => { %attrs }, objs => [ @objs, @foreign_objs ], deps => [ @deps ]); foreach (@objs) { # If this is somehow a compiled object, take care of it that way # Otherwise, it might simply be generated if (defined $self->{info}->{sources}->{$_}) { if($_ =~ /\.a$/) { $self->dolib($_); } else { $self->doobj($_, $lib, intent => "shlib", attrs => { %attrs }); } } else { $self->dogenerate($_, undef, undef, intent => "lib"); } } } { # When putting static libraries together, we cannot rely on any # symbol resolution, so for all static libraries used as source for # this one, as well as other libraries they depend on, we simply # grab all their object files unconditionally, # Symbol resolution will happen when any program, module or shared # library is linked with this one. my @objs = (); my @sourcedeps = (); my @foreign_objs = (); foreach (@{$self->{info}->{sources}->{$lib}}) { if ($_ !~ m|\.a$|) { push @objs, $_; } else { push @sourcedeps, $_; } } @sourcedeps = ( grep { $_ ne $lib } $self->resolvedepends(@sourcedeps) ); print STDERR "DEBUG[dolib:lib] : \@sourcedeps for $_ : ", join(",", map { "\n $_" } @sourcedeps), "\n" if @sourcedeps && $debug_rules; @foreign_objs = $self->getlibobjs('sources', @sourcedeps); print STDERR "DEBUG[dolib:lib] \%attrs for $lib : ", , join(",", map { "\n $_ = $attrs{$_}" } sort keys %attrs), "\n" if %attrs && $debug_rules; print STDERR "DEBUG[dolib:lib] \@objs for $lib : ", join(",", map { "\n $_" } @objs), "\n" if @objs && $debug_rules; print STDERR "DEBUG[dolib:lib] \@foreign_objs for $lib : ", join(",", map { "\n $_" } @foreign_objs), "\n" if @foreign_objs && $debug_rules; $self->emit('obj2lib', lib => $lib, attrs => { %attrs }, objs => [ @objs, @foreign_objs ]); foreach (@objs) { $self->doobj($_, $lib, intent => "lib", attrs => { %attrs }); } } $cache{$lib} = 1; } # domodule is responsible for building modules. It will call # obj2dso, and also makes sure all object files for the library # are built. sub domodule { my $self = shift; my $module = shift; return "" if $cache{$module}; my %attrs = %{$self->{info}->{attributes}->{modules}->{$module} // {}}; my @objs = @{$self->{info}->{sources}->{$module}}; my @deps = ( grep { $_ ne $module } $self->resolvedepends($module) ); print STDERR "DEBUG[domodule] \%attrs for $module :", join(",", map { "\n $_ = $attrs{$_}" } sort keys %attrs), "\n" if $debug_rules; print STDERR "DEBUG[domodule] \@objs for $module : ", join(",", map { "\n $_" } @objs), "\n" if $debug_rules; print STDERR "DEBUG[domodule] \@deps for $module : ", join(",", map { "\n $_" } @deps), "\n" if $debug_rules; $self->emit('obj2dso', module => $module, attrs => { %attrs }, objs => [ @objs ], deps => [ @deps ]); foreach (@{$self->{info}->{sources}->{$module}}) { # If this is somehow a compiled object, take care of it that way # Otherwise, it might simply be generated if (defined $self->{info}->{sources}->{$_}) { $self->doobj($_, $module, intent => "dso", attrs => { %attrs }); } else { $self->dogenerate($_, undef, $module, intent => "dso"); } } $cache{$module} = 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 $self = shift; my $bin = shift; return "" if $cache{$bin}; my %attrs = %{$self->{info}->{attributes}->{programs}->{$bin} // {}}; my @objs = @{$self->{info}->{sources}->{$bin}}; my @deps = ( grep { $_ ne $bin } $self->resolvedepends($bin) ); print STDERR "DEBUG[dobin] \%attrs for $bin : ", join(",", map { "\n $_ = $attrs{$_}" } sort keys %attrs), "\n" if %attrs && $debug_rules; print STDERR "DEBUG[dobin] \@objs for $bin : ", join(",", map { "\n $_" } @objs), "\n" if @objs && $debug_rules; print STDERR "DEBUG[dobin] \@deps for $bin : ", join(",", map { "\n $_" } @deps), "\n" if @deps && $debug_rules; $self->emit('obj2bin', bin => $bin, attrs => { %attrs }, objs => [ @objs ], deps => [ @deps ]); foreach (@objs) { $self->doobj($_, $bin, intent => "bin", attrs => { %attrs }); } $cache{$bin} = 1; } # doscript is responsible for building scripts from templates. It will # call in2script. sub doscript { my $self = shift; my $script = shift; return "" if $cache{$script}; $self->emit('in2script', script => $script, attrs => $self->{info}->{attributes}->{scripts}->{$script} // {}, sources => $self->{info}->{sources}->{$script}); $cache{$script} = 1; } sub dodir { my $self = shift; my $dir = shift; return "" if !exists(&generatedir) or $cache{$dir}; $self->emit('generatedir', dir => $dir, deps => $self->{info}->{dirinfo}->{$dir}->{deps} // [], %{$self->{info}->{dirinfo}->{$_}->{products}}); $cache{$dir} = 1; } # dodocs is responsible for building documentation from .pods. # It will call generatesrc. sub dodocs { my $self = shift; my $type = shift; my $section = shift; foreach my $doc (@{$self->{info}->{"${type}docs"}->{$section}}) { next if $cache{$doc}; $self->emit('generatesrc', src => $doc, generator => $self->{info}->{generate}->{$doc}); foreach ((@{$self->{info}->{depends}->{$doc} // []})) { $self->dogenerate($_, undef, undef); } $cache{$doc} = 1; } } 1;