Add the possibility to generate documentation at build time
[openssl.git] / Configurations / common.tmpl
1 {- # -*- Mode: perl -*-
2
3  use File::Basename;
4
5  my $debug_resolvedepends = $ENV{BUILDFILE_DEBUG_DEPENDS};
6  my $debug_rules = $ENV{BUILDFILE_DEBUG_RULES};
7
8  # A cache of objects for which a recipe has already been generated
9  my %cache;
10
11  # collectdepends, expanddepends and reducedepends work together to make
12  # sure there are no duplicate or weak dependencies and that they are in
13  # the right order.  This is used to sort the list of libraries  that a
14  # build depends on.
15  sub extensionlesslib {
16      my @result = map { $_ =~ /(\.a)?$/; $` } @_;
17      return @result if wantarray;
18      return $result[0];
19  }
20
21  # collectdepends dives into the tree of dependencies and returns
22  # a list of all the non-weak ones.
23  sub collectdepends {
24      return () unless @_;
25
26      my $thing = shift;
27      my $extensionlessthing = extensionlesslib($thing);
28      my @listsofar = @_;    # to check if we're looping
29      my @list = @{$unified_info{depends}->{$thing} //
30                       $unified_info{depends}->{$extensionlessthing}};
31      my @newlist = ();
32
33      print STDERR "DEBUG[collectdepends] $thing > ", join(' ', @listsofar), "\n"
34          if $debug_resolvedepends;
35      foreach my $item (@list) {
36          my $extensionlessitem = extensionlesslib($item);
37          # It's time to break off when the dependency list starts looping
38          next if grep { extensionlesslib($_) eq $extensionlessitem } @listsofar;
39          # Don't add anything here if the dependency is weak
40          next if defined $unified_info{attributes}->{depends}->{$thing}->{$item}->{'weak'};
41          my @resolved = collectdepends($item, @listsofar, $item);
42          push @newlist, $item, @resolved;
43      }
44      print STDERR "DEBUG[collectdepends] $thing < ", join(' ', @newlist), "\n"
45          if $debug_resolvedepends;
46      @newlist;
47  }
48
49  # expanddepends goes through a list of stuff, checks if they have any
50  # dependencies, and adds them at the end of the current position if
51  # they aren't already present later on.
52  sub expanddepends {
53      my @after = ( @_ );
54      print STDERR "DEBUG[expanddepends]> ", join(' ', @after), "\n"
55          if $debug_resolvedepends;
56      my @before = ();
57      while (@after) {
58          my $item = shift @after;
59          print STDERR "DEBUG[expanddepends]\\  ", join(' ', @before), "\n"
60              if $debug_resolvedepends;
61          print STDERR "DEBUG[expanddepends] - ", $item, "\n"
62              if $debug_resolvedepends;
63          my @middle = (
64              $item,
65              map {
66                  my $x = $_;
67                  my $extlessx = extensionlesslib($x);
68                  if (grep { $extlessx eq extensionlesslib($_) } @before
69                      and
70                      !grep { $extlessx eq extensionlesslib($_) } @after) {
71                      print STDERR "DEBUG[expanddepends] + ", $x, "\n"
72                          if $debug_resolvedepends;
73                      ( $x )
74                  } else {
75                      print STDERR "DEBUG[expanddepends] ! ", $x, "\n"
76                          if $debug_resolvedepends;
77                      ()
78                  }
79              } @{$unified_info{depends}->{$item} // []}
80          );
81          print STDERR "DEBUG[expanddepends] = ", join(' ', @middle), "\n"
82              if $debug_resolvedepends;
83          print STDERR "DEBUG[expanddepends]/  ", join(' ', @after), "\n"
84              if $debug_resolvedepends;
85          push @before, @middle;
86      }
87      print STDERR "DEBUG[expanddepends]< ", join(' ', @before), "\n"
88          if $debug_resolvedepends;
89      @before;
90  }
91
92  # reducedepends looks through a list, and checks if each item is
93  # repeated later on.  If it is, the earlier copy is dropped.
94  sub reducedepends {
95      my @list = @_;
96      print STDERR "DEBUG[reducedepends]> ", join(' ', @list), "\n"
97          if $debug_resolvedepends;
98      my @newlist = ();
99      my %replace = ();
100      while (@list) {
101          my $item = shift @list;
102          my $extensionlessitem = extensionlesslib($item);
103          if (grep { $extensionlessitem eq extensionlesslib($_) } @list) {
104              if ($item ne $extensionlessitem) {
105                  # If this instance of the library is explicitly static, we
106                  # prefer that to any shared library name, since it must have
107                  # been done on purpose.
108                  $replace{$extensionlessitem} = $item;
109              }
110          } else {
111              push @newlist, $item;
112          }
113      }
114      @newlist = map { $replace{$_} // $_; } @newlist;
115      print STDERR "DEBUG[reducedepends]< ", join(' ', @newlist), "\n"
116          if $debug_resolvedepends;
117      @newlist;
118  }
119
120  # Do it all
121  # This takes multiple inputs and combine them into a single list of
122  # interdependent things.  The returned value will include all the input.
123  # Callers are responsible for taking away the things they are building.
124  sub resolvedepends {
125      print STDERR "DEBUG[resolvedepends] START (", join(', ', @_), ")\n"
126          if $debug_resolvedepends;
127      my @all =
128          reducedepends(expanddepends(map { ( $_, collectdepends($_) ) } @_));
129      print STDERR "DEBUG[resolvedepends] END (", join(', ', @_), ") : ",
130          join(',', map { "\n    $_" } @all), "\n"
131          if $debug_resolvedepends;
132      @all;
133  }
134
135  # dogenerate is responsible for producing all the recipes that build
136  # generated source files.  It recurses in case a dependency is also a
137  # generated source file.
138  sub dogenerate {
139      my $src = shift;
140      return "" if $cache{$src};
141      my $obj = shift;
142      my $bin = shift;
143      my %opts = @_;
144      if ($unified_info{generate}->{$src}) {
145          die "$src is generated by Configure, should not appear in build file\n"
146              if ref $unified_info{generate}->{$src} eq "";
147          my $script = $unified_info{generate}->{$src}->[0];
148          $OUT .= generatesrc(src => $src,
149                              product => $bin,
150                              generator => $unified_info{generate}->{$src},
151                              generator_incs => $unified_info{includes}->{$script},
152                              generator_deps => $unified_info{depends}->{$script},
153                              deps => $unified_info{depends}->{$src},
154                              incs => [ defined $obj
155                                            ? @{$unified_info{includes}->{$obj}}
156                                            : (),
157                                        defined $bin
158                                            ? @{$unified_info{includes}->{$bin}}
159                                            : () ],
160                              defs => [ defined $obj
161                                            ? @{$unified_info{defines}->{$obj}}
162                                            : (),
163                                        defined $bin
164                                            ? @{$unified_info{defines}->{$bin}}
165                                            : () ],
166                              %opts);
167          foreach (@{$unified_info{depends}->{$src}}) {
168              dogenerate($_, $obj, $bin, %opts);
169          }
170      }
171      $cache{$src} = 1;
172  }
173
174  # doobj is responsible for producing all the recipes that build
175  # object files as well as dependency files.
176  sub doobj {
177      my $obj = shift;
178      return "" if $cache{$obj};
179      my $bin = shift;
180      my %opts = @_;
181      if (@{$unified_info{sources}->{$obj}}) {
182          my @srcs = @{$unified_info{sources}->{$obj}};
183          my @deps = @{$unified_info{depends}->{$obj}};
184          my @incs = ( @{$unified_info{includes}->{$obj}},
185                       @{$unified_info{includes}->{$bin}} );
186          my @defs = ( @{$unified_info{defines}->{$obj}},
187                       @{$unified_info{defines}->{$bin}} );
188          print STDERR "DEBUG[doobj] \@srcs for $obj ($bin) : ",
189              join(",", map { "\n    $_" } @srcs), "\n"
190              if $debug_rules;
191          print STDERR "DEBUG[doobj] \@deps for $obj ($bin) : ",
192              join(",", map { "\n    $_" } @deps), "\n"
193              if $debug_rules;
194          print STDERR "DEBUG[doobj] \@incs for $obj ($bin) : ",
195              join(",", map { "\n    $_" } @incs), "\n"
196              if $debug_rules;
197          print STDERR "DEBUG[doobj] \@defs for $obj ($bin) : ",
198              join(",", map { "\n    $_" } @defs), "\n"
199              if $debug_rules;
200          print STDERR "DEBUG[doobj] \%opts for $obj ($bin) : ", ,
201              join(",", map { "\n    $_ = $opts{$_}" } sort keys %opts), "\n"
202              if $debug_rules;
203          $OUT .= src2obj(obj => $obj, product => $bin,
204                          srcs => [ @srcs ], deps => [ @deps ],
205                          incs => [ @incs ], defs => [ @defs ],
206                          %opts);
207          foreach ((@{$unified_info{sources}->{$obj}},
208                    @{$unified_info{depends}->{$obj}})) {
209              dogenerate($_, $obj, $bin, %opts);
210          }
211      }
212      $cache{$obj} = 1;
213  }
214
215  # Helper functions to grab all applicable intermediary files.
216  # This is particularly useful when a library is given as source
217  # rather than a dependency.  In that case, we consider it to be a
218  # container with object file references, or possibly references
219  # to further libraries to pilfer in the same way.
220  sub getsrclibs {
221      my $section = shift;
222
223      # For all input, see if it sources static libraries.  If it does,
224      # return them together with the result of a recursive call.
225      map { ( $_, getsrclibs($section, $_) ) }
226      grep { $_ =~ m|\.a$| }
227      map { @{$unified_info{$section}->{$_} // []} }
228      @_;
229  }
230
231  sub getlibobjs {
232      my $section = shift;
233
234      # For all input, see if it's an intermediary file (library or object).
235      # If it is, collect the result of a recursive call, or if that returns
236      # an empty list, the element itself.  Return the result.
237      map {
238          my @x = getlibobjs($section, @{$unified_info{$section}->{$_}});
239          @x ? @x : ( $_ );
240      }
241      grep { defined $unified_info{$section}->{$_} }
242      @_;
243  }
244
245  # dolib is responsible for building libraries.  It will call
246  # obj2shlib if shared libraries are produced, and obj2lib in all
247  # cases.  It also makes sure all object files for the library are
248  # built.
249  sub dolib {
250      my $lib = shift;
251      return "" if $cache{$lib};
252
253      my %attrs = %{$unified_info{attributes}->{libraries}->{$lib}};
254
255      my @deps = ( resolvedepends(getsrclibs('sources', $lib)) );
256
257      # We support two types of objs, those who are specific to this library
258      # (they end up in @objs) and those that we get indirectly, via other
259      # libraries (they end up in @foreign_objs).  We get the latter any time
260      # someone has done something like this in build.info:
261      #     SOURCE[libfoo.a]=libbar.a
262      # The indirect object files must be kept in a separate array so they
263      # don't get rebuilt unnecessarily (and with incorrect auxiliary
264      # information).
265      #
266      # Object files can't be collected commonly for shared and static
267      # libraries, because we contain their respective object files in
268      # {shared_sources} and {sources}, and because the implications are
269      # slightly different for each library form.
270      #
271      # We grab all these "foreign" object files recursively with getlibobjs().
272
273      unless ($disabled{shared} || $lib =~ /\.a$/) {
274          my $obj2shlib = defined &obj2shlib ? \&obj2shlib : \&libobj2shlib;
275          # If this library sources other static libraries and those
276          # libraries are marked {noinst}, there's no need to include
277          # all of their object files.  Instead, we treat those static
278          # libraries as dependents alongside any other library this
279          # one depends on, and let symbol resolution do its job.
280          my @sourced_libs = ();
281          my @objs = ();
282          my @foreign_objs = ();
283          my @deps = ();
284          foreach (@{$unified_info{shared_sources}->{$lib}}) {
285              if ($_ !~ m|\.a$|) {
286                  push @objs, $_;
287              } elsif ($unified_info{attributes}->{libraries}->{$_}->{noinst}) {
288                  push @deps, $_;
289              } else {
290                  push @deps, getsrclibs('sources', $_);
291                  push @foreign_objs, getlibobjs('sources', $_);
292              }
293          }
294          @deps = ( grep { $_ ne $lib } resolvedepends($lib, @deps) );
295          print STDERR "DEBUG[dolib:shlib] \%attrs for $lib : ", ,
296              join(",", map { "\n    $_ = $attrs{$_}" } sort keys %attrs), "\n"
297              if %attrs && $debug_rules;
298          print STDERR "DEBUG[dolib:shlib] \@deps for $lib : ",
299              join(",", map { "\n    $_" } @deps), "\n"
300              if @deps && $debug_rules;
301          print STDERR "DEBUG[dolib:shlib] \@objs for $lib : ",
302              join(",", map { "\n    $_" } @objs), "\n"
303              if @objs && $debug_rules;
304          print STDERR "DEBUG[dolib:shlib] \@foreign_objs for $lib : ",
305              join(",", map { "\n    $_" } @foreign_objs), "\n"
306              if @foreign_objs && $debug_rules;
307          $OUT .= $obj2shlib->(lib => $lib,
308                               attrs => { %attrs },
309                               objs => [ @objs, @foreign_objs ],
310                               deps => [ @deps ]);
311          foreach (@objs) {
312              # If this is somehow a compiled object, take care of it that way
313              # Otherwise, it might simply be generated
314              if (defined $unified_info{sources}->{$_}) {
315                  if($_ =~ /\.a$/) {
316                      dolib($_);
317                  } else {
318                      doobj($_, $lib, intent => "shlib", attrs => { %attrs });
319                  }
320              } else {
321                  dogenerate($_, undef, undef, intent => "lib");
322              }
323          }
324      }
325      {
326          # When putting static libraries together, we cannot rely on any
327          # symbol resolution, so for all static libraries used as source for
328          # this one, as well as other libraries they depend on, we simply
329          # grab all their object files unconditionally,
330          # Symbol resolution will happen when any program, module or shared
331          # library is linked with this one.
332          my @objs = ();
333          my @sourcedeps = ();
334          my @foreign_objs = ();
335          foreach (@{$unified_info{sources}->{$lib}}) {
336              if ($_ !~ m|\.a$|) {
337                  push @objs, $_;
338              } else {
339                  push @sourcedeps, $_;
340              }
341          }
342          @sourcedeps = ( grep { $_ ne $lib } resolvedepends(@sourcedeps) );
343          print STDERR "DEBUG[dolib:lib] : \@sourcedeps for $_ : ",
344              join(",", map { "\n    $_" } @sourcedeps), "\n"
345              if @sourcedeps && $debug_rules;
346          @foreign_objs = getlibobjs('sources', @sourcedeps);
347          print STDERR "DEBUG[dolib:lib] \%attrs for $lib : ", ,
348              join(",", map { "\n    $_ = $attrs{$_}" } sort keys %attrs), "\n"
349              if %attrs && $debug_rules;
350          print STDERR "DEBUG[dolib:lib] \@objs for $lib : ",
351              join(",", map { "\n    $_" } @objs), "\n"
352              if @objs && $debug_rules;
353          print STDERR "DEBUG[dolib:lib] \@foreign_objs for $lib : ",
354              join(",", map { "\n    $_" } @foreign_objs), "\n"
355              if @foreign_objs && $debug_rules;
356          $OUT .= obj2lib(lib => $lib, attrs => { %attrs },
357                          objs => [ @objs, @foreign_objs ]);
358          foreach (@objs) {
359              doobj($_, $lib, intent => "lib", attrs => { %attrs });
360          }
361      }
362      $cache{$lib} = 1;
363  }
364
365  # domodule is responsible for building modules.  It will call
366  # obj2dso, and also makes sure all object files for the library
367  # are built.
368  sub domodule {
369      my $module = shift;
370      return "" if $cache{$module};
371      my %attrs = %{$unified_info{attributes}->{modules}->{$module}};
372      my @objs = @{$unified_info{sources}->{$module}};
373      my @deps = ( grep { $_ ne $module }
374                   resolvedepends($module) );
375      print STDERR "DEBUG[domodule] \%attrs for $module :",
376          join(",", map { "\n    $_ = $attrs{$_}" } sort keys %attrs), "\n"
377          if $debug_rules;
378      print STDERR "DEBUG[domodule] \@objs for $module : ",
379          join(",", map { "\n    $_" } @objs), "\n"
380          if $debug_rules;
381      print STDERR "DEBUG[domodule] \@deps for $module : ",
382          join(",", map { "\n    $_" } @deps), "\n"
383          if $debug_rules;
384      $OUT .= obj2dso(module => $module,
385                      attrs => { %attrs },
386                      objs => [ @objs ],
387                      deps => [ @deps ]);
388      foreach (@{$unified_info{sources}->{$module}}) {
389          # If this is somehow a compiled object, take care of it that way
390          # Otherwise, it might simply be generated
391          if (defined $unified_info{sources}->{$_}) {
392              doobj($_, $module, intent => "dso", attrs => { %attrs });
393          } else {
394              dogenerate($_, undef, $module, intent => "dso");
395          }
396      }
397      $cache{$module} = 1;
398  }
399
400  # dobin is responsible for building programs.  It will call obj2bin,
401  # and also makes sure all object files for the library are built.
402  sub dobin {
403      my $bin = shift;
404      return "" if $cache{$bin};
405      my %attrs = %{$unified_info{attributes}->{programs}->{$bin}};
406      my @objs = @{$unified_info{sources}->{$bin}};
407      my @deps = ( grep { $_ ne $bin } resolvedepends($bin) );
408      print STDERR "DEBUG[dobin] \%attrs for $bin : ",
409          join(",", map { "\n    $_ = $attrs{$_}" } sort keys %attrs), "\n"
410          if %attrs && $debug_rules;
411      print STDERR "DEBUG[dobin] \@objs for $bin : ",
412          join(",", map { "\n    $_" } @objs), "\n"
413          if @objs && $debug_rules;
414      print STDERR "DEBUG[dobin] \@deps for $bin : ",
415          join(",", map { "\n    $_" } @deps), "\n"
416          if @deps && $debug_rules;
417      $OUT .= obj2bin(bin => $bin,
418                      attrs => { %attrs },
419                      objs => [ @objs ],
420                      deps => [ @deps ]);
421      foreach (@objs) {
422          doobj($_, $bin, intent => "bin", attrs => { %attrs });
423      }
424      $cache{$bin} = 1;
425  }
426
427  # dobin is responsible for building scripts from templates.  It will
428  # call in2script.
429  sub doscript {
430      my $script = shift;
431      return "" if $cache{$script};
432      $OUT .= in2script(script => $script,
433                        attrs => $unified_info{attributes}->{$script},
434                        sources => $unified_info{sources}->{$script});
435      $cache{$script} = 1;
436  }
437
438  sub dodir {
439      my $dir = shift;
440      return "" if !exists(&generatedir) or $cache{$dir};
441      $OUT .= generatedir(dir => $dir,
442                          deps => $unified_info{dirinfo}->{$dir}->{deps},
443                          %{$unified_info{dirinfo}->{$_}->{products}});
444      $cache{$dir} = 1;
445  }
446
447  # dodocs is responsible for building documentation from .pods.
448  # It will call generatesrc.
449  sub dodocs {
450      my $type = shift;
451      my $section = shift;
452      foreach my $doc (@{$unified_info{"${type}docs"}->{$section}}) {
453          next if $cache{$doc};
454          $OUT .= generatesrc(src => $doc,
455                              generator => $unified_info{generate}->{$doc});
456          foreach ((@{$unified_info{depends}->{$doc}})) {
457              dogenerate($_, undef, undef, %opts);
458          }
459          $cache{$doc} = 1;
460      }
461  }
462
463  # Start with populating the cache with all the overrides
464  %cache = map { $_ => 1 } @{$unified_info{overrides}};
465
466  # Build mandatory generated headers
467  foreach (@{$unified_info{depends}->{""}}) { dogenerate($_); }
468
469  # Build all known libraries, modules, programs and scripts.
470  # Everything else will be handled as a consequence.
471  foreach (@{$unified_info{libraries}}) { dolib($_);    }
472  foreach (@{$unified_info{modules}})   { domodule($_); }
473  foreach (@{$unified_info{programs}})  { dobin($_);    }
474  foreach (@{$unified_info{scripts}})   { doscript($_); }
475  foreach (sort keys %{$unified_info{htmldocs}}) { dodocs('html', $_); }
476  foreach (sort keys %{$unified_info{mandocs}})  { dodocs('man', $_); }
477  foreach (sort keys %{$unified_info{dirinfo}})  { dodir($_); }
478 -}