8 use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
10 @EXPORT = qw(gentemplate);
17 my $generator = OpenSSL::GenTemplate->new(%opts);
19 # Build mandatory header file generators
20 foreach (@{$generator->{info}->{depends}->{""}}) { $generator->dogenerate($_); }
22 # Build all known targets, libraries, modules, programs and scripts.
23 # Everything else will be handled as a consequence.
24 foreach (@{$generator->{info}->{targets}}) { $generator->dotarget($_); }
25 foreach (@{$generator->{info}->{libraries}}) { $generator->dolib($_); }
26 foreach (@{$generator->{info}->{modules}}) { $generator->domodule($_); }
27 foreach (@{$generator->{info}->{programs}}) { $generator->dobin($_); }
28 foreach (@{$generator->{info}->{scripts}}) { $generator->doscript($_); }
29 foreach (sort keys %{$generator->{info}->{htmldocs}}) { $generator->dodocs('html', $_); }
30 foreach (sort keys %{$generator->{info}->{mandocs}}) { $generator->dodocs('man', $_); }
31 foreach (sort keys %{$generator->{info}->{dirinfo}}) { $generator->dodir($_); }
34 package OpenSSL::GenTemplate;
43 output => $opts{output},
44 config => $opts{config} // {},
45 disabled => $opts{disabled} // {},
46 info => $opts{unified_info} // {},
49 return bless $data, $class;
56 my $fh = $self->{output};
58 die "No name?" unless $name;
59 print $fh "{-\n ", $name, '(', dump_data(\%opts), ');', " \n-}"
60 unless defined $opts{attrs}->{skip};
63 my $debug_resolvedepends = $ENV{BUILDFILE_DEBUG_DEPENDS};
64 my $debug_rules = $ENV{BUILDFILE_DEBUG_RULES};
66 # A cache of objects for which a recipe has already been generated
69 # collectdepends, expanddepends and reducedepends work together to make
70 # sure there are no duplicate or weak dependencies and that they are in
71 # the right order. This is used to sort the list of libraries that a
73 sub extensionlesslib {
74 my @result = map { $_ =~ /(\.a)?$/; $` } @_;
75 return @result if wantarray;
79 # collectdepends dives into the tree of dependencies and returns
80 # a list of all the non-weak ones.
86 my $extensionlessthing = extensionlesslib($thing);
87 my @listsofar = @_; # to check if we're looping
88 my @list = @{ $self->{info}->{depends}->{$thing} //
89 $self->{info}->{depends}->{$extensionlessthing}
93 print STDERR "DEBUG[collectdepends] $thing > ", join(' ', @listsofar), "\n"
94 if $debug_resolvedepends;
95 foreach my $item (@list) {
96 my $extensionlessitem = extensionlesslib($item);
97 # It's time to break off when the dependency list starts looping
98 next if grep { extensionlesslib($_) eq $extensionlessitem } @listsofar;
99 # Don't add anything here if the dependency is weak
100 next if defined $self->{info}->{attributes}->{depends}->{$thing}->{$item}->{'weak'};
101 my @resolved = $self->collectdepends($item, @listsofar, $item);
102 push @newlist, $item, @resolved;
104 print STDERR "DEBUG[collectdepends] $thing < ", join(' ', @newlist), "\n"
105 if $debug_resolvedepends;
109 # expanddepends goes through a list of stuff, checks if they have any
110 # dependencies, and adds them at the end of the current position if
111 # they aren't already present later on.
115 print STDERR "DEBUG[expanddepends]> ", join(' ', @after), "\n"
116 if $debug_resolvedepends;
119 my $item = shift @after;
120 print STDERR "DEBUG[expanddepends]\\ ", join(' ', @before), "\n"
121 if $debug_resolvedepends;
122 print STDERR "DEBUG[expanddepends] - ", $item, "\n"
123 if $debug_resolvedepends;
128 my $extlessx = extensionlesslib($x);
129 if (grep { $extlessx eq extensionlesslib($_) } @before
131 !grep { $extlessx eq extensionlesslib($_) } @after) {
132 print STDERR "DEBUG[expanddepends] + ", $x, "\n"
133 if $debug_resolvedepends;
136 print STDERR "DEBUG[expanddepends] ! ", $x, "\n"
137 if $debug_resolvedepends;
140 } @{$self->{info}->{depends}->{$item} // []}
142 print STDERR "DEBUG[expanddepends] = ", join(' ', @middle), "\n"
143 if $debug_resolvedepends;
144 print STDERR "DEBUG[expanddepends]/ ", join(' ', @after), "\n"
145 if $debug_resolvedepends;
146 push @before, @middle;
148 print STDERR "DEBUG[expanddepends]< ", join(' ', @before), "\n"
149 if $debug_resolvedepends;
153 # reducedepends looks through a list, and checks if each item is
154 # repeated later on. If it is, the earlier copy is dropped.
157 print STDERR "DEBUG[reducedepends]> ", join(' ', @list), "\n"
158 if $debug_resolvedepends;
162 my $item = shift @list;
163 my $extensionlessitem = extensionlesslib($item);
164 if (grep { $extensionlessitem eq extensionlesslib($_) } @list) {
165 if ($item ne $extensionlessitem) {
166 # If this instance of the library is explicitly static, we
167 # prefer that to any shared library name, since it must have
168 # been done on purpose.
169 $replace{$extensionlessitem} = $item;
172 push @newlist, $item;
175 @newlist = map { $replace{$_} // $_; } @newlist;
176 print STDERR "DEBUG[reducedepends]< ", join(' ', @newlist), "\n"
177 if $debug_resolvedepends;
182 # This takes multiple inputs and combine them into a single list of
183 # interdependent things. The returned value will include all the input.
184 # Callers are responsible for taking away the things they are building.
187 print STDERR "DEBUG[resolvedepends] START (", join(', ', @_), ")\n"
188 if $debug_resolvedepends;
190 reducedepends($self->expanddepends(map { ( $_, $self->collectdepends($_) ) } @_));
191 print STDERR "DEBUG[resolvedepends] END (", join(', ', @_), ") : ",
192 join(',', map { "\n $_" } @all), "\n"
193 if $debug_resolvedepends;
197 # dogenerate is responsible for producing all the recipes that build
198 # generated source files. It recurses in case a dependency is also a
199 # generated source file.
204 return "" unless defined $self->{info}->{generate}->{$src};
205 return "" if $cache{$src};
209 if ($self->{info}->{generate}->{$src}) {
210 die "$src is generated by Configure, should not appear in build file\n"
211 if ref $self->{info}->{generate}->{$src} eq "";
212 my $script = $self->{info}->{generate}->{$src}->[0];
213 my %attrs = %{$self->{info}->{attributes}->{generate}->{$src} // {}};
214 $self->emit('generatesrc',
217 generator => $self->{info}->{generate}->{$src},
218 generator_incs => $self->{info}->{includes}->{$script} // [],
219 generator_deps => $self->{info}->{depends}->{$script} // [],
220 deps => $self->{info}->{depends}->{$src} // [],
221 incs => [ defined $obj ? @{$self->{info}->{includes}->{$obj} // []} : (),
222 defined $bin ? @{$self->{info}->{includes}->{$bin} // []} : () ],
223 defs => [ defined $obj ? @{$self->{info}->{defines}->{$obj} // []} : (),
224 defined $bin ? @{$self->{info}->{defines}->{$bin} // []} : () ],
227 foreach (@{$self->{info}->{depends}->{$src} // []}) {
228 $self->dogenerate($_, $obj, $bin, %opts);
230 # The generator itself may be is generated
231 if ($self->{info}->{generate}->{$script}) {
232 $self->dogenerate($script, $obj, $bin, %opts);
241 return "" if $cache{$target};
242 $self->emit('generatetarget',
244 deps => $self->{info}->{depends}->{$target} // []);
245 foreach (@{$self->{info}->{depends}->{$target} // []}) {
246 $self->dogenerate($_);
251 # doobj is responsible for producing all the recipes that build
252 # object files as well as dependency files.
256 return "" if $cache{$obj};
259 if (@{$self->{info}->{sources}->{$obj} // []}) {
260 my @srcs = @{$self->{info}->{sources}->{$obj}};
261 my @deps = @{$self->{info}->{depends}->{$obj} // []};
262 my @incs = ( @{$self->{info}->{includes}->{$obj} // []},
263 @{$self->{info}->{includes}->{$bin} // []} );
264 my @defs = ( @{$self->{info}->{defines}->{$obj} // []},
265 @{$self->{info}->{defines}->{$bin} // []} );
266 print STDERR "DEBUG[doobj] \@srcs for $obj ($bin) : ",
267 join(",", map { "\n $_" } @srcs), "\n"
269 print STDERR "DEBUG[doobj] \@deps for $obj ($bin) : ",
270 join(",", map { "\n $_" } @deps), "\n"
272 print STDERR "DEBUG[doobj] \@incs for $obj ($bin) : ",
273 join(",", map { "\n $_" } @incs), "\n"
275 print STDERR "DEBUG[doobj] \@defs for $obj ($bin) : ",
276 join(",", map { "\n $_" } @defs), "\n"
278 print STDERR "DEBUG[doobj] \%opts for $obj ($bin) : ", ,
279 join(",", map { "\n $_ = $opts{$_}" } sort keys %opts), "\n"
281 $self->emit('src2obj',
282 obj => $obj, product => $bin,
283 srcs => [ @srcs ], deps => [ @deps ],
284 incs => [ @incs ], defs => [ @defs ],
286 foreach ((@{$self->{info}->{sources}->{$obj}},
287 @{$self->{info}->{depends}->{$obj} // []})) {
288 $self->dogenerate($_, $obj, $bin, %opts);
294 # Helper functions to grab all applicable intermediary files.
295 # This is particularly useful when a library is given as source
296 # rather than a dependency. In that case, we consider it to be a
297 # container with object file references, or possibly references
298 # to further libraries to pilfer in the same way.
303 # For all input, see if it sources static libraries. If it does,
304 # return them together with the result of a recursive call.
305 map { ( $_, getsrclibs($section, $_) ) }
306 grep { $_ =~ m|\.a$| }
307 map { @{$self->{info}->{$section}->{$_} // []} }
315 # For all input, see if it's an intermediary file (library or object).
316 # If it is, collect the result of a recursive call, or if that returns
317 # an empty list, the element itself. Return the result.
319 my @x = $self->getlibobjs($section, @{$self->{info}->{$section}->{$_}});
322 grep { defined $self->{info}->{$section}->{$_} }
326 # dolib is responsible for building libraries. It will call
327 # obj2shlib if shared libraries are produced, and obj2lib in all
328 # cases. It also makes sure all object files for the library are
333 return "" if $cache{$lib};
335 my %attrs = %{$self->{info}->{attributes}->{libraries}->{$lib} // {}};
337 my @deps = ( $self->resolvedepends(getsrclibs('sources', $lib)) );
339 # We support two types of objs, those who are specific to this library
340 # (they end up in @objs) and those that we get indirectly, via other
341 # libraries (they end up in @foreign_objs). We get the latter any time
342 # someone has done something like this in build.info:
343 # SOURCE[libfoo.a]=libbar.a
344 # The indirect object files must be kept in a separate array so they
345 # don't get rebuilt unnecessarily (and with incorrect auxiliary
348 # Object files can't be collected commonly for shared and static
349 # libraries, because we contain their respective object files in
350 # {shared_sources} and {sources}, and because the implications are
351 # slightly different for each library form.
353 # We grab all these "foreign" object files recursively with getlibobjs().
355 unless ($self->{disabled}->{shared} || $lib =~ /\.a$/) {
356 # If this library sources other static libraries and those
357 # libraries are marked {noinst}, there's no need to include
358 # all of their object files. Instead, we treat those static
359 # libraries as dependents alongside any other library this
360 # one depends on, and let symbol resolution do its job.
361 my @sourced_libs = ();
363 my @foreign_objs = ();
365 foreach (@{$self->{info}->{shared_sources}->{$lib} // []}) {
368 } elsif ($self->{info}->{attributes}->{libraries}->{$_}->{noinst}) {
371 push @deps, $self->getsrclibs('sources', $_);
372 push @foreign_objs, $self->getlibobjs('sources', $_);
375 @deps = ( grep { $_ ne $lib } $self->resolvedepends($lib, @deps) );
376 print STDERR "DEBUG[dolib:shlib] \%attrs for $lib : ", ,
377 join(",", map { "\n $_ = $attrs{$_}" } sort keys %attrs), "\n"
378 if %attrs && $debug_rules;
379 print STDERR "DEBUG[dolib:shlib] \@deps for $lib : ",
380 join(",", map { "\n $_" } @deps), "\n"
381 if @deps && $debug_rules;
382 print STDERR "DEBUG[dolib:shlib] \@objs for $lib : ",
383 join(",", map { "\n $_" } @objs), "\n"
384 if @objs && $debug_rules;
385 print STDERR "DEBUG[dolib:shlib] \@foreign_objs for $lib : ",
386 join(",", map { "\n $_" } @foreign_objs), "\n"
387 if @foreign_objs && $debug_rules;
388 $self->emit('obj2shlib',
391 objs => [ @objs, @foreign_objs ],
394 # If this is somehow a compiled object, take care of it that way
395 # Otherwise, it might simply be generated
396 if (defined $self->{info}->{sources}->{$_}) {
400 $self->doobj($_, $lib, intent => "shlib", attrs => { %attrs });
403 $self->dogenerate($_, undef, undef, intent => "lib");
408 # When putting static libraries together, we cannot rely on any
409 # symbol resolution, so for all static libraries used as source for
410 # this one, as well as other libraries they depend on, we simply
411 # grab all their object files unconditionally,
412 # Symbol resolution will happen when any program, module or shared
413 # library is linked with this one.
416 my @foreign_objs = ();
417 foreach (@{$self->{info}->{sources}->{$lib}}) {
421 push @sourcedeps, $_;
424 @sourcedeps = ( grep { $_ ne $lib } $self->resolvedepends(@sourcedeps) );
425 print STDERR "DEBUG[dolib:lib] : \@sourcedeps for $_ : ",
426 join(",", map { "\n $_" } @sourcedeps), "\n"
427 if @sourcedeps && $debug_rules;
428 @foreign_objs = $self->getlibobjs('sources', @sourcedeps);
429 print STDERR "DEBUG[dolib:lib] \%attrs for $lib : ", ,
430 join(",", map { "\n $_ = $attrs{$_}" } sort keys %attrs), "\n"
431 if %attrs && $debug_rules;
432 print STDERR "DEBUG[dolib:lib] \@objs for $lib : ",
433 join(",", map { "\n $_" } @objs), "\n"
434 if @objs && $debug_rules;
435 print STDERR "DEBUG[dolib:lib] \@foreign_objs for $lib : ",
436 join(",", map { "\n $_" } @foreign_objs), "\n"
437 if @foreign_objs && $debug_rules;
438 $self->emit('obj2lib',
439 lib => $lib, attrs => { %attrs },
440 objs => [ @objs, @foreign_objs ]);
442 $self->doobj($_, $lib, intent => "lib", attrs => { %attrs });
448 # domodule is responsible for building modules. It will call
449 # obj2dso, and also makes sure all object files for the library
454 return "" if $cache{$module};
455 my %attrs = %{$self->{info}->{attributes}->{modules}->{$module} // {}};
456 my @objs = @{$self->{info}->{sources}->{$module}};
457 my @deps = ( grep { $_ ne $module }
458 $self->resolvedepends($module) );
459 print STDERR "DEBUG[domodule] \%attrs for $module :",
460 join(",", map { "\n $_ = $attrs{$_}" } sort keys %attrs), "\n"
462 print STDERR "DEBUG[domodule] \@objs for $module : ",
463 join(",", map { "\n $_" } @objs), "\n"
465 print STDERR "DEBUG[domodule] \@deps for $module : ",
466 join(",", map { "\n $_" } @deps), "\n"
468 $self->emit('obj2dso',
473 foreach (@{$self->{info}->{sources}->{$module}}) {
474 # If this is somehow a compiled object, take care of it that way
475 # Otherwise, it might simply be generated
476 if (defined $self->{info}->{sources}->{$_}) {
477 $self->doobj($_, $module, intent => "dso", attrs => { %attrs });
479 $self->dogenerate($_, undef, $module, intent => "dso");
485 # dobin is responsible for building programs. It will call obj2bin,
486 # and also makes sure all object files for the library are built.
490 return "" if $cache{$bin};
491 my %attrs = %{$self->{info}->{attributes}->{programs}->{$bin} // {}};
492 my @objs = @{$self->{info}->{sources}->{$bin}};
493 my @deps = ( grep { $_ ne $bin } $self->resolvedepends($bin) );
494 print STDERR "DEBUG[dobin] \%attrs for $bin : ",
495 join(",", map { "\n $_ = $attrs{$_}" } sort keys %attrs), "\n"
496 if %attrs && $debug_rules;
497 print STDERR "DEBUG[dobin] \@objs for $bin : ",
498 join(",", map { "\n $_" } @objs), "\n"
499 if @objs && $debug_rules;
500 print STDERR "DEBUG[dobin] \@deps for $bin : ",
501 join(",", map { "\n $_" } @deps), "\n"
502 if @deps && $debug_rules;
503 $self->emit('obj2bin',
509 $self->doobj($_, $bin, intent => "bin", attrs => { %attrs });
514 # doscript is responsible for building scripts from templates. It will
519 return "" if $cache{$script};
520 $self->emit('in2script',
522 attrs => $self->{info}->{attributes}->{scripts}->{$script} // {},
523 sources => $self->{info}->{sources}->{$script});
530 return "" if !exists(&generatedir) or $cache{$dir};
531 $self->emit('generatedir',
533 deps => $self->{info}->{dirinfo}->{$dir}->{deps} // [],
534 %{$self->{info}->{dirinfo}->{$_}->{products}});
538 # dodocs is responsible for building documentation from .pods.
539 # It will call generatesrc.
544 foreach my $doc (@{$self->{info}->{"${type}docs"}->{$section}}) {
545 next if $cache{$doc};
546 $self->emit('generatesrc',
548 generator => $self->{info}->{generate}->{$doc});
549 foreach ((@{$self->{info}->{depends}->{$doc} // []})) {
550 $self->dogenerate($_, undef, undef);