]>
Commit | Line | Data |
---|---|---|
f83133a5 RL |
1 | Design document for the unified scheme data |
2 | =========================================== | |
3 | ||
4 | How are things connected? | |
5 | ------------------------- | |
6 | ||
7 | The unified scheme takes all its data from the build.info files seen | |
8 | throughout the source tree. These files hold the minimum information | |
9 | needed to build end product files from diverse sources. See the | |
10 | section on build.info files below. | |
11 | ||
12 | From the information in build.info files, Configure builds up an | |
13 | information database as a hash table called %unified_info, which is | |
14 | stored in configdata.pm, found at the top of the build tree (which may | |
15 | or may not be the same as the source tree). | |
16 | ||
17 | Configurations/common.tmpl uses the data from %unified_info to | |
18 | generate the rules for building end product files as well as | |
19 | intermediary files with the help of a few functions found in the | |
20 | build-file templates. See the section on build-file templates further | |
21 | down for more information. | |
22 | ||
23 | build.info files | |
24 | ---------------- | |
25 | ||
26 | As mentioned earlier, build.info files are meant to hold the minimum | |
27 | information needed to build output files, and therefore only (with a | |
28 | few possible exceptions [1]) have information about end products (such | |
29 | as scripts, library files and programs) and source files (such as C | |
30 | files, C header files, assembler files, etc). Intermediate files such | |
b6453a68 | 31 | as object files are rarely directly referred to in build.info files (and |
f83133a5 | 32 | when they are, it's always with the file name extension .o), they are |
b6453a68 | 33 | inferred by Configure. By the same rule of minimalism, end product |
f83133a5 | 34 | file name extensions (such as .so, .a, .exe, etc) are never mentioned |
b6453a68 | 35 | in build.info. Their file name extensions will be inferred by the |
f83133a5 RL |
36 | build-file templates, adapted for the platform they are meant for (see |
37 | sections on %unified_info and build-file templates further down). | |
38 | ||
1842f369 | 39 | The variables PROGRAMS, LIBS, MODULES and SCRIPTS are used to declare |
52fef270 RL |
40 | end products. There are variants for them with '_NO_INST' as suffix |
41 | (PROGRAM_NO_INST etc) to specify end products that shouldn't get | |
42 | installed. | |
f83133a5 | 43 | |
b96ab5e6 RL |
44 | The variables SOURCE, DEPEND, INCLUDE and DEFINE are indexed by a |
45 | produced file, and their values are the source used to produce that | |
46 | particular produced file, extra dependencies, include directories | |
47 | needed, or C macros to be defined. | |
f83133a5 RL |
48 | |
49 | All their values in all the build.info throughout the source tree are | |
1842f369 | 50 | collected together and form a set of programs, libraries, modules and |
f83133a5 RL |
51 | scripts to be produced, source files, dependencies, etc etc etc. |
52 | ||
53 | Let's have a pretend example, a very limited contraption of OpenSSL, | |
54 | composed of the program 'apps/openssl', the libraries 'libssl' and | |
1842f369 | 55 | 'libcrypto', an module 'engines/ossltest' and their sources and |
f83133a5 RL |
56 | dependencies. |
57 | ||
58 | # build.info | |
59 | LIBS=libcrypto libssl | |
f83133a5 RL |
60 | INCLUDE[libcrypto]=include |
61 | INCLUDE[libssl]=include | |
62 | DEPEND[libssl]=libcrypto | |
63 | ||
64 | This is the top directory build.info file, and it tells us that two | |
d201dbc9 RL |
65 | libraries are to be built, the include directory 'include/' shall be |
66 | used throughout when building anything that will end up in each | |
67 | library, and that the library 'libssl' depend on the library | |
68 | 'libcrypto' to function properly. | |
f83133a5 RL |
69 | |
70 | # apps/build.info | |
71 | PROGRAMS=openssl | |
72 | SOURCE[openssl]=openssl.c | |
73 | INCLUDE[openssl]=.. ../include | |
74 | DEPEND[openssl]=../libssl | |
75 | ||
76 | This is the build.info file in 'apps/', one may notice that all file | |
77 | paths mentioned are relative to the directory the build.info file is | |
78 | located in. This one tells us that there's a program to be built | |
79 | called 'apps/openssl' (the file name extension will depend on the | |
80 | platform and is therefore not mentioned in the build.info file). It's | |
81 | built from one source file, 'apps/openssl.c', and building it requires | |
82 | the use of '.' and 'include' include directories (both are declared | |
83 | from the point of view of the 'apps/' directory), and that the program | |
84 | depends on the library 'libssl' to function properly. | |
85 | ||
86 | # crypto/build.info | |
87 | LIBS=../libcrypto | |
88 | SOURCE[../libcrypto]=aes.c evp.c cversion.c | |
89 | DEPEND[cversion.o]=buildinf.h | |
df443918 | 90 | |
ae4c7450 RL |
91 | GENERATE[buildinf.h]=../util/mkbuildinf.pl "$(CC) $(CFLAGS)" "$(PLATFORM)" |
92 | DEPEND[buildinf.h]=../Makefile | |
2036fd50 | 93 | DEPEND[../util/mkbuildinf.pl]=../util/Foo.pm |
f83133a5 RL |
94 | |
95 | This is the build.info file in 'crypto', and it tells us a little more | |
96 | about what's needed to produce 'libcrypto'. LIBS is used again to | |
97 | declare that 'libcrypto' is to be produced. This declaration is | |
98 | really unnecessary as it's already mentioned in the top build.info | |
99 | file, but can make the info file easier to understand. This is to | |
100 | show that duplicate information isn't an issue. | |
101 | ||
102 | This build.info file informs us that 'libcrypto' is built from a few | |
103 | source files, 'crypto/aes.c', 'crypto/evp.c' and 'crypto/cversion.c'. | |
104 | It also shows us that building the object file inferred from | |
df443918 | 105 | 'crypto/cversion.c' depends on 'crypto/buildinf.h'. Finally, it |
e38bd948 | 106 | also shows the possibility to declare how some files are generated |
2036fd50 RL |
107 | using some script, in this case a perl script, and how such scripts |
108 | can be declared to depend on other files, in this case a perl module. | |
f83133a5 RL |
109 | |
110 | Two things are worth an extra note: | |
111 | ||
b6453a68 | 112 | 'DEPEND[cversion.o]' mentions an object file. DEPEND indexes is the |
f83133a5 RL |
113 | only location where it's valid to mention them |
114 | ||
f83133a5 RL |
115 | # ssl/build.info |
116 | LIBS=../libssl | |
117 | SOURCE[../libssl]=tls.c | |
118 | ||
119 | This is the build.info file in 'ssl/', and it tells us that the | |
120 | library 'libssl' is built from the source file 'ssl/tls.c'. | |
121 | ||
122 | # engines/build.info | |
1842f369 | 123 | MODULES=dasync |
52fef270 RL |
124 | SOURCE[dasync]=e_dasync.c |
125 | DEPEND[dasync]=../libcrypto | |
126 | INCLUDE[dasync]=../include | |
127 | ||
1842f369 | 128 | MODULES_NO_INST=ossltest |
52fef270 | 129 | SOURCE[ossltest]=e_ossltest.c |
473a9547 | 130 | DEPEND[ossltest]=../libcrypto.a |
52fef270 RL |
131 | INCLUDE[ossltest]=../include |
132 | ||
1842f369 | 133 | This is the build.info file in 'engines/', telling us that two modules |
52fef270 RL |
134 | called 'engines/dasync' and 'engines/ossltest' shall be built, that |
135 | dasync's source is 'engines/e_dasync.c' and ossltest's source is | |
f83133a5 | 136 | 'engines/e_ossltest.c' and that the include directory 'include/' may |
1842f369 RL |
137 | be used when building anything that will be part of these modules. |
138 | Also, both modules depend on the library 'libcrypto' to function | |
473a9547 RL |
139 | properly. ossltest is explicitly linked with the static variant of |
140 | the library 'libcrypto'. Finally, only dasync is being installed, as | |
141 | ossltest is only for internal testing. | |
f83133a5 RL |
142 | |
143 | When Configure digests these build.info files, the accumulated | |
144 | information comes down to this: | |
145 | ||
146 | LIBS=libcrypto libssl | |
f83133a5 RL |
147 | SOURCE[libcrypto]=crypto/aes.c crypto/evp.c crypto/cversion.c |
148 | DEPEND[crypto/cversion.o]=crypto/buildinf.h | |
149 | INCLUDE[libcrypto]=include | |
f83133a5 RL |
150 | SOURCE[libssl]=ssl/tls.c |
151 | INCLUDE[libssl]=include | |
152 | DEPEND[libssl]=libcrypto | |
df443918 | 153 | |
f83133a5 RL |
154 | PROGRAMS=apps/openssl |
155 | SOURCE[apps/openssl]=apps/openssl.c | |
156 | INCLUDE[apps/openssl]=. include | |
157 | DEPEND[apps/openssl]=libssl | |
158 | ||
1842f369 | 159 | MODULES=engines/dasync |
52fef270 RL |
160 | SOURCE[engines/dasync]=engines/e_dasync.c |
161 | DEPEND[engines/dasync]=libcrypto | |
162 | INCLUDE[engines/dasync]=include | |
163 | ||
1842f369 | 164 | MODULES_NO_INST=engines/ossltest |
e38bd948 | 165 | SOURCE[engines/ossltest]=engines/e_ossltest.c |
473a9547 | 166 | DEPEND[engines/ossltest]=libcrypto.a |
e38bd948 | 167 | INCLUDE[engines/ossltest]=include |
df443918 | 168 | |
ae4c7450 RL |
169 | GENERATE[crypto/buildinf.h]=util/mkbuildinf.pl "$(CC) $(CFLAGS)" "$(PLATFORM)" |
170 | DEPEND[crypto/buildinf.h]=Makefile | |
2036fd50 | 171 | DEPEND[util/mkbuildinf.pl]=util/Foo.pm |
f83133a5 RL |
172 | |
173 | ||
174 | A few notes worth mentioning: | |
175 | ||
176 | LIBS may be used to declare routine libraries only. | |
177 | ||
178 | PROGRAMS may be used to declare programs only. | |
179 | ||
1842f369 | 180 | MODULES may be used to declare modules only. |
f83133a5 | 181 | |
d201dbc9 | 182 | The indexes for SOURCE must only be end product files, such as |
1842f369 | 183 | libraries, programs or modules. The values of SOURCE variables must |
d201dbc9 | 184 | only be source files (possibly generated). |
f83133a5 | 185 | |
2036fd50 RL |
186 | INCLUDE and DEPEND shows a relationship between different files |
187 | (usually produced files) or between files and directories, such as a | |
188 | program depending on a library, or between an object file and some | |
189 | extra source file. | |
f83133a5 RL |
190 | |
191 | When Configure processes the build.info files, it will take it as | |
192 | truth without question, and will therefore perform very few checks. | |
193 | If the build tree is separate from the source tree, it will assume | |
194 | that all built files and up in the build directory and that all source | |
195 | files are to be found in the source tree, if they can be found there. | |
196 | Configure will assume that source files that can't be found in the | |
197 | source tree (such as 'crypto/bildinf.h' in the example above) are | |
198 | generated and will be found in the build tree. | |
199 | ||
200 | ||
201 | The %unified_info database | |
202 | -------------------------- | |
203 | ||
204 | The information in all the build.info get digested by Configure and | |
205 | collected into the %unified_info database, divided into the following | |
206 | indexes: | |
207 | ||
208 | depends => a hash table containing 'file' => [ 'dependency' ... ] | |
209 | pairs. These are directly inferred from the DEPEND | |
210 | variables in build.info files. | |
211 | ||
1842f369 RL |
212 | modules => a list of modules. These are directly inferred from |
213 | the MODULES variable in build.info files. | |
f83133a5 | 214 | |
e38bd948 RL |
215 | generate => a hash table containing 'file' => [ 'generator' ... ] |
216 | pairs. These are directly inferred from the GENERATE | |
217 | variables in build.info files. | |
218 | ||
f83133a5 RL |
219 | includes => a hash table containing 'file' => [ 'include' ... ] |
220 | pairs. These are directly inferred from the INCLUDE | |
221 | variables in build.info files. | |
222 | ||
52fef270 | 223 | install => a hash table containing 'type' => [ 'file' ... ] pairs. |
1842f369 | 224 | The types are 'programs', 'libraries', 'modules' and |
52fef270 RL |
225 | 'scripts', and the array of files list the files of |
226 | that type that should be installed. | |
227 | ||
f83133a5 RL |
228 | libraries => a list of libraries. These are directly inferred from |
229 | the LIBS variable in build.info files. | |
230 | ||
f83133a5 RL |
231 | programs => a list of programs. These are directly inferred from |
232 | the PROGRAMS variable in build.info files. | |
233 | ||
f83133a5 RL |
234 | scripts => a list of scripts. There are directly inferred from |
235 | the SCRIPTS variable in build.info files. | |
236 | ||
237 | sources => a hash table containing 'file' => [ 'sourcefile' ... ] | |
238 | pairs. These are indirectly inferred from the SOURCE | |
239 | variables in build.info files. Object files are | |
240 | mentioned in this hash table, with source files from | |
241 | SOURCE variables, and AS source files for programs and | |
242 | libraries. | |
243 | ||
2a08d1a0 RL |
244 | shared_sources => |
245 | a hash table just like 'sources', but only as source | |
246 | files (object files) for building shared libraries. | |
247 | ||
f83133a5 RL |
248 | As an example, here is how the build.info files example from the |
249 | section above would be digested into a %unified_info table: | |
250 | ||
251 | our %unified_info = ( | |
252 | "depends" => | |
253 | { | |
254 | "apps/openssl" => | |
255 | [ | |
256 | "libssl", | |
257 | ], | |
e38bd948 RL |
258 | "crypto/buildinf.h" => |
259 | [ | |
260 | "Makefile", | |
261 | ], | |
f83133a5 RL |
262 | "crypto/cversion.o" => |
263 | [ | |
264 | "crypto/buildinf.h", | |
265 | ], | |
473a9547 | 266 | "engines/dasync" => |
f83133a5 RL |
267 | [ |
268 | "libcrypto", | |
269 | ], | |
473a9547 RL |
270 | "engines/ossltest" => |
271 | [ | |
272 | "libcrypto.a", | |
273 | ], | |
f83133a5 RL |
274 | "libssl" => |
275 | [ | |
276 | "libcrypto", | |
277 | ], | |
2036fd50 RL |
278 | "util/mkbuildinf.pl" => |
279 | [ | |
280 | "util/Foo.pm", | |
281 | ], | |
f83133a5 | 282 | }, |
1842f369 | 283 | "modules" => |
f83133a5 | 284 | [ |
52fef270 | 285 | "engines/dasync", |
e38bd948 | 286 | "engines/ossltest", |
f83133a5 | 287 | ], |
e38bd948 RL |
288 | "generate" => |
289 | { | |
290 | "crypto/buildinf.h" => | |
291 | [ | |
292 | "util/mkbuildinf.pl", | |
293 | "\"\$(CC)", | |
294 | "\$(CFLAGS)\"", | |
295 | "\"$(PLATFORM)\"", | |
296 | ], | |
297 | }, | |
f83133a5 RL |
298 | "includes" => |
299 | { | |
300 | "apps/openssl" => | |
301 | [ | |
302 | ".", | |
303 | "include", | |
304 | ], | |
e38bd948 | 305 | "engines/ossltest" => |
f83133a5 RL |
306 | [ |
307 | "include" | |
308 | ], | |
309 | "libcrypto" => | |
310 | [ | |
311 | "include", | |
312 | ], | |
313 | "libssl" => | |
314 | [ | |
315 | "include", | |
316 | ], | |
2036fd50 RL |
317 | "util/mkbuildinf.pl" => |
318 | [ | |
319 | "util", | |
320 | ], | |
f83133a5 | 321 | } |
52fef270 RL |
322 | "install" => |
323 | { | |
1842f369 | 324 | "modules" => |
52fef270 RL |
325 | [ |
326 | "engines/dasync", | |
327 | ], | |
328 | "libraries" => | |
329 | [ | |
330 | "libcrypto", | |
331 | "libssl", | |
332 | ], | |
333 | "programs" => | |
334 | [ | |
335 | "apps/openssl", | |
336 | ], | |
337 | }, | |
f83133a5 RL |
338 | "libraries" => |
339 | [ | |
340 | "libcrypto", | |
341 | "libssl", | |
342 | ], | |
f83133a5 RL |
343 | "programs" => |
344 | [ | |
345 | "apps/openssl", | |
346 | ], | |
f83133a5 RL |
347 | "sources" => |
348 | { | |
349 | "apps/openssl" => | |
350 | [ | |
351 | "apps/openssl.o", | |
352 | ], | |
353 | "apps/openssl.o" => | |
354 | [ | |
355 | "apps/openssl.c", | |
356 | ], | |
357 | "crypto/aes.o" => | |
358 | [ | |
359 | "crypto/aes.c", | |
360 | ], | |
361 | "crypto/cversion.o" => | |
362 | [ | |
363 | "crypto/cversion.c", | |
364 | ], | |
365 | "crypto/evp.o" => | |
366 | [ | |
367 | "crypto/evp.c", | |
368 | ], | |
473a9547 RL |
369 | "engines/e_dasync.o" => |
370 | [ | |
371 | "engines/e_dasync.c", | |
372 | ], | |
373 | "engines/dasync" => | |
374 | [ | |
375 | "engines/e_dasync.o", | |
376 | ], | |
f83133a5 RL |
377 | "engines/e_ossltest.o" => |
378 | [ | |
379 | "engines/e_ossltest.c", | |
380 | ], | |
e38bd948 | 381 | "engines/ossltest" => |
f83133a5 RL |
382 | [ |
383 | "engines/e_ossltest.o", | |
384 | ], | |
385 | "libcrypto" => | |
386 | [ | |
387 | "crypto/aes.c", | |
388 | "crypto/cversion.c", | |
389 | "crypto/evp.c", | |
390 | ], | |
391 | "libssl" => | |
392 | [ | |
393 | "ssl/tls.c", | |
394 | ], | |
395 | "ssl/tls.o" => | |
396 | [ | |
397 | "ssl/tls.c", | |
398 | ], | |
399 | }, | |
400 | ); | |
401 | ||
b6453a68 | 402 | As can be seen, everything in %unified_info is fairly simple suggest |
f83133a5 RL |
403 | of information. Still, it tells us that to build all programs, we |
404 | must build 'apps/openssl', and to build the latter, we will need to | |
405 | build all its sources ('apps/openssl.o' in this case) and all the | |
406 | other things it depends on (such as 'libssl'). All those dependencies | |
407 | need to be built as well, using the same logic, so to build 'libssl', | |
408 | we need to build 'ssl/tls.o' as well as 'libcrypto', and to build the | |
409 | latter... | |
410 | ||
411 | ||
412 | Build-file templates | |
413 | -------------------- | |
414 | ||
415 | Build-file templates are essentially build-files (such as Makefile on | |
416 | Unix) with perl code fragments mixed in. Those perl code fragment | |
417 | will generate all the configuration dependent data, including all the | |
418 | rules needed to build end product files and intermediary files alike. | |
419 | At a minimum, there must be a perl code fragment that defines a set of | |
420 | functions that are used to generates specific build-file rules, to | |
421 | build static libraries from object files, to build shared libraries | |
422 | from static libraries, to programs from object files and libraries, | |
423 | etc. | |
424 | ||
e38bd948 RL |
425 | generatesrc - function that produces build file lines to generate |
426 | a source file from some input. | |
427 | ||
428 | It's called like this: | |
429 | ||
430 | generatesrc(src => "PATH/TO/tobegenerated", | |
431 | generator => [ "generatingfile", ... ] | |
2036fd50 RL |
432 | generator_incs => [ "INCL/PATH", ... ] |
433 | generator_deps => [ "dep1", ... ] | |
e38bd948 RL |
434 | incs => [ "INCL/PATH", ... ], |
435 | deps => [ "dep1", ... ], | |
436 | intent => one of "libs", "dso", "bin" ); | |
437 | ||
438 | 'src' has the name of the file to be generated. | |
439 | 'generator' is the command or part of command to | |
440 | generate the file, of which the first item is | |
441 | expected to be the file to generate from. | |
442 | generatesrc() is expected to analyse and figure out | |
443 | exactly how to apply that file and how to capture | |
2036fd50 RL |
444 | the result. 'generator_incs' and 'generator_deps' |
445 | are include directories and files that the generator | |
446 | file itself depends on. 'incs' and 'deps' are | |
447 | include directories and files that are used if $(CC) | |
448 | is used as an intermediary step when generating the | |
449 | end product (the file indicated by 'src'). 'intent' | |
450 | indicates what the generated file is going to be | |
451 | used for. | |
e38bd948 | 452 | |
f83133a5 RL |
453 | src2obj - function that produces build file lines to build an |
454 | object file from source files and associated data. | |
455 | ||
456 | It's called like this: | |
457 | ||
458 | src2obj(obj => "PATH/TO/objectfile", | |
459 | srcs => [ "PATH/TO/sourcefile", ... ], | |
460 | deps => [ "dep1", ... ], | |
45502bfe RL |
461 | incs => [ "INCL/PATH", ... ] |
462 | intent => one of "lib", "dso", "bin" ); | |
f83133a5 | 463 | |
aa343982 RL |
464 | 'obj' has the intended object file with '.o' |
465 | extension, src2obj() is expected to change it to | |
466 | something more suitable for the platform. | |
f83133a5 RL |
467 | 'srcs' has the list of source files to build the |
468 | object file, with the first item being the source | |
469 | file that directly corresponds to the object file. | |
45502bfe RL |
470 | 'deps' is a list of explicit dependencies. 'incs' |
471 | is a list of include file directories. Finally, | |
472 | 'intent' indicates what this object file is going | |
473 | to be used for. | |
f83133a5 RL |
474 | |
475 | obj2lib - function that produces build file lines to build a | |
476 | static library file ("libfoo.a" in Unix terms) from | |
477 | object files. | |
478 | ||
479 | called like this: | |
480 | ||
481 | obj2lib(lib => "PATH/TO/libfile", | |
482 | objs => [ "PATH/TO/objectfile", ... ]); | |
483 | ||
484 | 'lib' has the intended library file name *without* | |
485 | extension, obj2lib is expected to add that. 'objs' | |
aa343982 | 486 | has the list of object files to build this library. |
f83133a5 | 487 | |
aa343982 RL |
488 | libobj2shlib - backward compatibility function that's used the |
489 | same way as obj2shlib (described next), and was | |
490 | expected to build the shared library from the | |
491 | corresponding static library when that was suitable. | |
492 | NOTE: building a shared library from a static | |
493 | library is now DEPRECATED, as they no longer share | |
494 | object files. Attempting to do this will fail. | |
495 | ||
496 | obj2shlib - function that produces build file lines to build a | |
f83133a5 | 497 | shareable object library file ("libfoo.so" in Unix |
aa343982 | 498 | terms) from the corresponding object files. |
f83133a5 RL |
499 | |
500 | called like this: | |
501 | ||
aa343982 RL |
502 | obj2shlib(shlib => "PATH/TO/shlibfile", |
503 | lib => "PATH/TO/libfile", | |
504 | objs => [ "PATH/TO/objectfile", ... ], | |
505 | deps => [ "PATH/TO/otherlibfile", ... ]); | |
f83133a5 | 506 | |
aa343982 RL |
507 | 'lib' has the base (static) library file name |
508 | *without* extension. This is useful in case | |
509 | supporting files are needed (such as import | |
510 | libraries on Windows). | |
b6453a68 | 511 | 'shlib' has the corresponding shared library name |
f83133a5 RL |
512 | *without* extension. 'deps' has the list of other |
513 | libraries (also *without* extension) this library | |
514 | needs to be linked with. 'objs' has the list of | |
aa343982 | 515 | object files to build this library. |
f83133a5 | 516 | |
aa343982 RL |
517 | obj2dso - function that produces build file lines to build a |
518 | dynamic shared object file from object files. | |
f83133a5 RL |
519 | |
520 | called like this: | |
521 | ||
aa343982 RL |
522 | obj2dso(lib => "PATH/TO/libfile", |
523 | objs => [ "PATH/TO/objectfile", ... ], | |
524 | deps => [ "PATH/TO/otherlibfile", | |
525 | ... ]); | |
f83133a5 | 526 | |
aa343982 | 527 | This is almost the same as obj2shlib, but the |
f83133a5 | 528 | intent is to build a shareable library that can be |
aa343982 | 529 | loaded in runtime (a "plugin"...). |
f83133a5 RL |
530 | |
531 | obj2bin - function that produces build file lines to build an | |
532 | executable file from object files. | |
533 | ||
534 | called like this: | |
535 | ||
536 | obj2bin(bin => "PATH/TO/binfile", | |
537 | objs => [ "PATH/TO/objectfile", ... ], | |
538 | deps => [ "PATH/TO/libfile", ... ]); | |
539 | ||
540 | 'bin' has the intended executable file name | |
541 | *without* extension, obj2bin is expected to add | |
aa343982 RL |
542 | that. 'objs' has the list of object files to build |
543 | this library. 'deps' has the list of library files | |
544 | (also *without* extension) that the programs needs | |
545 | to be linked with. | |
f83133a5 RL |
546 | |
547 | in2script - function that produces build file lines to build a | |
548 | script file from some input. | |
549 | ||
550 | called like this: | |
551 | ||
552 | in2script(script => "PATH/TO/scriptfile", | |
553 | sources => [ "PATH/TO/infile", ... ]); | |
554 | ||
555 | 'script' has the intended script file name. | |
556 | 'sources' has the list of source files to build the | |
557 | resulting script from. | |
558 | ||
1842f369 | 559 | Along with the build-file templates is the driving template |
f83133a5 RL |
560 | Configurations/common.tmpl, which looks through all the information in |
561 | %unified_info and generates all the rulesets to build libraries, | |
562 | programs and all intermediate files, using the rule generating | |
563 | functions defined in the build-file template. | |
564 | ||
565 | As an example with the smaller build.info set we've seen as an | |
2036fd50 | 566 | example, producing the rules to build 'libcrypto' would result in the |
f83133a5 RL |
567 | following calls: |
568 | ||
aa343982 | 569 | # Note: obj2shlib will only be called if shared libraries are |
f83133a5 | 570 | # to be produced. |
aa343982 RL |
571 | # Note 2: obj2shlib must convert the '.o' extension to whatever |
572 | # is suitable on the local platform. | |
573 | obj2shlib(shlib => "libcrypto", | |
574 | objs => [ "crypto/aes.o", "crypto/evp.o", "crypto/cversion.o" ], | |
575 | deps => [ ]); | |
2036fd50 RL |
576 | |
577 | obj2lib(lib => "libcrypto" | |
aa343982 | 578 | objs => [ "crypto/aes.o", "crypto/evp.o", "crypto/cversion.o" ]); |
f83133a5 | 579 | |
aa343982 | 580 | src2obj(obj => "crypto/aes.o" |
2036fd50 RL |
581 | srcs => [ "crypto/aes.c" ], |
582 | deps => [ ], | |
583 | incs => [ "include" ], | |
584 | intent => "lib"); | |
f83133a5 | 585 | |
aa343982 | 586 | src2obj(obj => "crypto/evp.o" |
2036fd50 | 587 | srcs => [ "crypto/evp.c" ], |
f83133a5 | 588 | deps => [ ], |
e38bd948 RL |
589 | incs => [ "include" ], |
590 | intent => "lib"); | |
f83133a5 | 591 | |
aa343982 | 592 | src2obj(obj => "crypto/cversion.o" |
2036fd50 RL |
593 | srcs => [ "crypto/cversion.c" ], |
594 | deps => [ "crypto/buildinf.h" ], | |
595 | incs => [ "include" ], | |
596 | intent => "lib"); | |
597 | ||
598 | generatesrc(src => "crypto/buildinf.h", | |
599 | generator => [ "util/mkbuildinf.pl", "\"$(CC)", | |
600 | "$(CFLAGS)\"", "\"$(PLATFORM)\"" ], | |
601 | generator_incs => [ "util" ], | |
602 | generator_deps => [ "util/Foo.pm" ], | |
603 | incs => [ ], | |
604 | deps => [ ], | |
605 | intent => "lib"); | |
606 | ||
f83133a5 RL |
607 | The returned strings from all those calls are then concatenated |
608 | together and written to the resulting build-file. |