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