]>
Commit | Line | Data |
---|---|---|
8c411768 | 1 | #! /usr/bin/python |
e3ec28ab VS |
2 | # GRUB -- GRand Unified Bootloader |
3 | # Copyright (C) 2010,2011 Free Software Foundation, Inc. | |
4 | # | |
5 | # GRUB is free software: you can redistribute it and/or modify | |
6 | # it under the terms of the GNU General Public License as published by | |
7 | # the Free Software Foundation, either version 3 of the License, or | |
8 | # (at your option) any later version. | |
9 | # | |
10 | # GRUB is distributed in the hope that it will be useful, | |
11 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | # GNU General Public License for more details. | |
14 | # | |
15 | # You should have received a copy of the GNU General Public License | |
16 | # along with GRUB. If not, see <http://www.gnu.org/licenses/>. | |
8c411768 BC |
17 | |
18 | # | |
19 | # This is the python script used to generate Makefile.tpl | |
20 | # | |
21 | ||
22 | GRUB_PLATFORMS = [ "emu", "i386_pc", "i386_efi", "i386_qemu", "i386_coreboot", | |
062cdbc1 | 23 | "i386_multiboot", "i386_ieee1275", "x86_64_efi", |
54da1feb | 24 | "mips_loongson", "sparc64_ieee1275", |
3666d5f6 VS |
25 | "powerpc_ieee1275", "mips_arc", "ia64_efi", |
26 | "mips_qemu_mips" ] | |
8c411768 BC |
27 | |
28 | GROUPS = {} | |
eefe8abd VS |
29 | |
30 | GROUPS["common"] = GRUB_PLATFORMS[:] | |
31 | ||
32 | # Groups based on CPU | |
8427685f BC |
33 | GROUPS["i386"] = [ "i386_pc", "i386_efi", "i386_qemu", "i386_coreboot", "i386_multiboot", "i386_ieee1275" ] |
34 | GROUPS["x86_64"] = [ "x86_64_efi" ] | |
35 | GROUPS["x86"] = GROUPS["i386"] + GROUPS["x86_64"] | |
3666d5f6 | 36 | GROUPS["mips"] = [ "mips_loongson", "mips_qemu_mips", "mips_arc" ] |
8427685f BC |
37 | GROUPS["sparc64"] = [ "sparc64_ieee1275" ] |
38 | GROUPS["powerpc"] = [ "powerpc_ieee1275" ] | |
39 | ||
eefe8abd | 40 | # Groups based on firmware |
6585de4c | 41 | GROUPS["efi"] = [ "i386_efi", "x86_64_efi", "ia64_efi" ] |
8427685f | 42 | GROUPS["ieee1275"] = [ "i386_ieee1275", "sparc64_ieee1275", "powerpc_ieee1275" ] |
8427685f | 43 | |
eefe8abd VS |
44 | # emu is a special case so many core functionality isn't needed on this platform |
45 | GROUPS["noemu"] = GRUB_PLATFORMS[:]; GROUPS["noemu"].remove("emu") | |
46 | ||
47 | # Groups based on hardware features | |
a07a81b3 VS |
48 | GROUPS["cmos"] = GROUPS["x86"][:] + ["mips_loongson", "mips_qemu_mips", |
49 | "sparc64_ieee1275", "powerpc_ieee1275"] | |
50 | GROUPS["cmos"].remove("i386_efi"); GROUPS["cmos"].remove("x86_64_efi") | |
bee1aeb9 | 51 | GROUPS["pci"] = GROUPS["x86"] + ["mips_loongson"] |
eefe8abd | 52 | GROUPS["usb"] = GROUPS["pci"] |
8427685f | 53 | |
eefe8abd | 54 | # If gfxterm is main output console integrate it into kernel |
d7345994 | 55 | GROUPS["videoinkernel"] = ["mips_loongson", "mips_qemu_mips"] |
eefe8abd VS |
56 | GROUPS["videomodules"] = GRUB_PLATFORMS[:]; |
57 | for i in GROUPS["videoinkernel"]: GROUPS["videomodules"].remove(i) | |
8427685f | 58 | |
ee74fa48 | 59 | # Similar for terminfo |
3666d5f6 | 60 | GROUPS["terminfoinkernel"] = ["mips_loongson", "mips_arc", "mips_qemu_mips" ] + GROUPS["ieee1275"]; |
ee74fa48 VS |
61 | GROUPS["terminfomodule"] = GRUB_PLATFORMS[:]; |
62 | for i in GROUPS["terminfoinkernel"]: GROUPS["terminfomodule"].remove(i) | |
63 | ||
eefe8abd | 64 | # Miscelaneous groups schedulded to disappear in future |
eefe8abd VS |
65 | GROUPS["i386_coreboot_multiboot_qemu"] = ["i386_coreboot", "i386_multiboot", "i386_qemu"] |
66 | GROUPS["nopc"] = GRUB_PLATFORMS[:]; GROUPS["nopc"].remove("i386_pc") | |
8c411768 BC |
67 | |
68 | # | |
69 | # Create platform => groups reverse map, where groups covering that | |
70 | # platform are ordered by their sizes | |
71 | # | |
72 | RMAP = {} | |
73 | for platform in GRUB_PLATFORMS: | |
74 | # initialize with platform itself as a group | |
75 | RMAP[platform] = [ platform ] | |
76 | ||
77 | for k in GROUPS.keys(): | |
78 | v = GROUPS[k] | |
79 | # skip groups that don't cover this platform | |
80 | if platform not in v: continue | |
81 | ||
82 | bigger = [] | |
83 | smaller = [] | |
84 | # partition currently known groups based on their size | |
85 | for group in RMAP[platform]: | |
86 | if group in GRUB_PLATFORMS: smaller.append(group) | |
87 | elif len(GROUPS[group]) < len(v): smaller.append(group) | |
88 | else: bigger.append(group) | |
89 | # insert in the middle | |
90 | RMAP[platform] = smaller + [ k ] + bigger | |
91 | ||
92 | # | |
93 | # Global variables | |
94 | # | |
e1fd1939 | 95 | GVARS = set() |
8c411768 BC |
96 | |
97 | def gvar_add(var, value): | |
e1fd1939 | 98 | GVARS.add(var) |
8c411768 BC |
99 | return var + " += " + value + "\n" |
100 | ||
101 | def global_variable_initializers(): | |
102 | r = "" | |
e1fd1939 | 103 | for var in sorted(GVARS): |
8c411768 BC |
104 | r += var + " ?= \n" |
105 | return r | |
106 | ||
107 | # | |
108 | # Per PROGRAM/SCRIPT variables | |
109 | # | |
110 | ||
e1fd1939 CW |
111 | def vars_init(*var_list): |
112 | r = "[+ IF (if (not (assoc-ref seen-vars (get \".name\"))) \"seen\") +]" | |
113 | r += "[+ (out-suspend \"v\") +]" | |
114 | for var in var_list: | |
115 | r += var + " = \n" | |
116 | r += "[+ (out-resume \"v\") +]" | |
117 | r += "[+ (set! seen-vars (assoc-set! seen-vars (get \".name\") 0)) +]" | |
118 | r += "[+ ENDIF +]" | |
119 | return first_time(r) | |
120 | ||
8c411768 BC |
121 | def var_set(var, value): |
122 | return var + " = " + value + "\n" | |
123 | ||
124 | def var_add(var, value): | |
125 | return var + " += " + value + "\n" | |
126 | ||
127 | # | |
128 | # Autogen constructs | |
129 | # | |
130 | ||
9e860d54 | 131 | def set_canonical_name_suffix(suffix): return "[+ % name `export cname=$(echo %s" + suffix + " | sed -e 's/[^0-9A-Za-z@_]/_/g')` +]" |
911bd640 | 132 | def cname(): return "[+ % name `echo $cname` +]" |
8c411768 | 133 | |
911bd640 BC |
134 | def rule(target, source, cmd): |
135 | if cmd[0] == "\n": | |
136 | return "\n" + target + ": " + source + cmd.replace("\n", "\n\t") + "\n" | |
137 | else: | |
138 | return "\n" + target + ": " + source + "\n\t" + cmd.replace("\n", "\n\t") + "\n" | |
8c411768 | 139 | |
d9b78bce BC |
140 | # |
141 | # Template for keys with platform names as values, for example: | |
142 | # | |
143 | # kernel = { | |
144 | # nostrip = emu; | |
f6023b61 | 145 | # ... |
d9b78bce BC |
146 | # } |
147 | # | |
148 | def if_platform_tagged(platform, tag, snippet_if, snippet_else=None): | |
911bd640 BC |
149 | r = "" |
150 | r += "[+ IF " + tag + " defined +]" | |
151 | r += "[+ FOR " + tag + " +][+ CASE " + tag + " +]" | |
8c411768 | 152 | for group in RMAP[platform]: |
d9b78bce BC |
153 | r += "[+ = \"" + group + "\" +]" + snippet_if |
154 | ||
02a6605e | 155 | if snippet_else != None: r += "[+ * +]" + snippet_else |
911bd640 | 156 | r += "[+ ESAC +][+ ENDFOR +]" |
8c411768 | 157 | |
d9b78bce | 158 | if snippet_else == None: |
8c411768 | 159 | r += "[+ ENDIF +]" |
911bd640 | 160 | return r |
8c411768 | 161 | |
d9b78bce | 162 | r += "[+ ELSE +]" + snippet_else + "[+ ENDIF +]" |
8c411768 BC |
163 | return r |
164 | ||
d9b78bce | 165 | # |
8427685f BC |
166 | # Template for tagged values |
167 | # | |
168 | # module = { | |
169 | # extra_dist = ... | |
170 | # extra_dist = ... | |
171 | # ... | |
172 | # }; | |
173 | # | |
174 | def foreach_value(tag, closure): | |
175 | return "[+ FOR " + tag + " +]" + closure("[+ ." + tag + " +]") + "[+ ENDFOR +]" | |
176 | ||
177 | # | |
178 | # Template for handling best matched values for a platform, for example: | |
d9b78bce BC |
179 | # |
180 | # module = { | |
181 | # cflags = '-Wall'; | |
182 | # emu_cflags = '-Wall -DGRUB_EMU=1'; | |
f6023b61 | 183 | # ... |
d9b78bce BC |
184 | # } |
185 | # | |
8427685f | 186 | def foreach_platform_specific_value(platform, suffix, nonetag, closure): |
8c411768 | 187 | r = "" |
911bd640 | 188 | for group in RMAP[platform]: |
d9b78bce | 189 | gtag = group + suffix |
911bd640 BC |
190 | |
191 | if group == RMAP[platform][0]: | |
192 | r += "[+ IF " + gtag + " +]" | |
193 | else: | |
194 | r += "[+ ELIF " + gtag + " +]" | |
195 | ||
d9b78bce | 196 | r += "[+ FOR " + gtag + " +]" + closure("[+ ." + gtag + " +]") + "[+ ENDFOR +]" |
8427685f BC |
197 | r += "[+ ELSE +][+ FOR " + nonetag + " +]" + closure("[+ ." + nonetag + " +]") + "[+ ENDFOR +][+ ENDIF +]" |
198 | return r | |
199 | ||
8667a314 BC |
200 | # |
201 | # Returns autogen code that defines an autogen macro using the | |
202 | # definition given in the 'snippet'. | |
203 | # | |
204 | def define_autogen_macro(name, snippet): | |
205 | r = "" | |
206 | r += "[+ DEFINE " + name + " +]" | |
207 | r += snippet | |
208 | r += "[+ ENDDEF +]\n" | |
209 | return r | |
210 | ||
8427685f BC |
211 | # |
212 | # Template for handling values from sum of all groups for a platform, | |
213 | # for example: | |
214 | # | |
215 | # module = { | |
216 | # common = kern/misc.c; | |
217 | # emu = kern/emu/misc.c; | |
218 | # ... | |
219 | # } | |
220 | # | |
221 | def foreach_platform_value (platform, suffix, closure): | |
222 | r = "" | |
223 | for group in RMAP[platform]: | |
224 | gtag = group + suffix | |
225 | ||
226 | r += "[+ IF " + gtag + " +]" | |
227 | r += "[+ FOR " + gtag + " +]" + closure("[+ ." + gtag + " +]") + "[+ ENDFOR +]" | |
228 | r += "[+ ENDIF +]" | |
8c411768 BC |
229 | return r |
230 | ||
8427685f BC |
231 | # |
232 | # Template for gaurding with platform specific "enable" keys, for example: | |
233 | # | |
234 | # module = { | |
235 | # name = pci; | |
236 | # noemu = bus/pci.c; | |
237 | # emu = bus/emu/pci.c; | |
238 | # emu = commands/lspci.c; | |
239 | # | |
240 | # enable = emu; | |
241 | # enable = i386_pc; | |
242 | # enable = x86_efi; | |
243 | # enable = i386_ieee1275; | |
244 | # enable = i386_coreboot; | |
245 | # }; | |
246 | # | |
247 | def foreach_enabled_platform(closure): | |
911bd640 BC |
248 | r = "[+ IF - enable undefined +]" |
249 | for platform in GRUB_PLATFORMS: | |
250 | r += "\nif COND_" + platform + "\n" + closure(platform) + "endif\n" | |
251 | r += "[+ ELSE +]" | |
252 | for platform in GRUB_PLATFORMS: | |
253 | x = "\nif COND_" + platform + "\n" + closure(platform) + "endif\n" | |
d9b78bce | 254 | r += if_platform_tagged(platform, "enable", x) |
911bd640 | 255 | r += "[+ ENDIF +]" |
d9b78bce BC |
256 | return r |
257 | ||
8427685f BC |
258 | # |
259 | # Template for gaurding with platform specific automake conditionals, | |
260 | # for example: | |
261 | # | |
262 | # module = { | |
263 | # name = usb; | |
264 | # common = bus/usb/usb.c; | |
265 | # noemu = bus/usb/usbtrans.c; | |
266 | # noemu = bus/usb/usbhub.c; | |
267 | # enable = emu; | |
268 | # enable = i386; | |
54da1feb | 269 | # enable = mips_loongson; |
8427685f BC |
270 | # emu_condition = COND_GRUB_EMU_USB; |
271 | # }; | |
272 | # | |
8667a314 BC |
273 | def define_macro_for_platform_conditionals_if_statement(p): |
274 | return define_autogen_macro( | |
275 | "if_" + p + "_conditionals", | |
276 | foreach_platform_specific_value(platform, "_condition", "condition", lambda cond: "if " + cond + "\n")) | |
277 | def define_macro_for_platform_conditionals_endif_statement(p): | |
278 | return define_autogen_macro( | |
279 | "endif_" + p + "_conditionals", | |
280 | foreach_platform_specific_value(platform, "_condition", "condition", lambda cond: "endif " + cond + "\n")) | |
d9b78bce | 281 | def under_platform_specific_conditionals(platform, snippet): |
8667a314 | 282 | r = "[+ if_" + platform + "_conditionals +]" |
d9b78bce | 283 | r += snippet |
8667a314 | 284 | r += "[+ endif_" + platform + "_conditionals +]" |
d9b78bce BC |
285 | return r |
286 | ||
8427685f BC |
287 | def platform_specific_values(platform, suffix, nonetag): |
288 | return foreach_platform_specific_value(platform, suffix, nonetag, | |
289 | lambda value: value + " ") | |
911bd640 | 290 | |
8427685f BC |
291 | def platform_values(platform, suffix): |
292 | return foreach_platform_value(platform, suffix, lambda value: value + " ") | |
911bd640 | 293 | |
8427685f BC |
294 | def extra_dist(): |
295 | return foreach_value("extra_dist", lambda value: value + " ") | |
911bd640 | 296 | |
8667a314 BC |
297 | def define_macro_for_platform_sources(p): |
298 | return define_autogen_macro( | |
299 | "get_" + p + "_sources", | |
300 | platform_values(p, "")) | |
301 | def define_macro_for_platform_nodist_sources(p): | |
302 | return define_autogen_macro( | |
303 | "get_" + p + "_nodist_sources", | |
304 | platform_values(p, "_nodist")) | |
305 | def define_macro_for_platform_dependencies(p): | |
306 | return define_autogen_macro( | |
307 | "get_" + p + "_dependencies", | |
308 | platform_values(p, "dependencies", "_dependencies")) | |
309 | def platform_sources(p): return "[+ get_" + p + "_sources +]" | |
310 | def platform_nodist_sources(p): return "[+ get_" + p + "_nodist_sources +]" | |
311 | def platform_dependencies(p): return "[+ get_" + p + "_dependencies +]" | |
8427685f | 312 | |
8667a314 BC |
313 | # |
314 | # Returns Autogen code which defines the autogen macros that collect | |
315 | # platform specific values for cflags, ldflags, etc. tags. | |
316 | # | |
317 | def define_macro_for_platform_startup(p): | |
318 | return define_autogen_macro( | |
319 | "get_" + p + "_startup", | |
320 | platform_specific_values(p, "_startup", "startup")) | |
321 | def define_macro_for_platform_cflags(p): | |
322 | return define_autogen_macro( | |
323 | "get_" + p + "_cflags", | |
324 | platform_specific_values(p, "_cflags", "cflags")) | |
325 | def define_macro_for_platform_ldadd(p): | |
326 | return define_autogen_macro( | |
327 | "get_" + p + "_ldadd", | |
328 | platform_specific_values(p, "_ldadd", "ldadd")) | |
329 | def define_macro_for_platform_ldflags(p): | |
330 | return define_autogen_macro( | |
331 | "get_" + p + "_ldflags", | |
332 | platform_specific_values(p, "_ldflags", "ldflags")) | |
333 | def define_macro_for_platform_cppflags(p): | |
334 | return define_autogen_macro( | |
335 | "get_" + p + "_cppflags", | |
336 | platform_specific_values(p, "_cppflags", "cppflags")) | |
337 | def define_macro_for_platform_ccasflags(p): | |
338 | return define_autogen_macro( | |
339 | "get_" + p + "_ccasflags", | |
340 | platform_specific_values(p, "_ccasflags", "ccasflags")) | |
341 | def define_macro_for_platform_stripflags(p): | |
342 | return define_autogen_macro( | |
343 | "get_" + p + "_stripflags", | |
344 | platform_specific_values(p, "_stripflags", "stripflags")) | |
345 | def define_macro_for_platform_objcopyflags(p): | |
346 | return define_autogen_macro( | |
347 | "get_" + p + "_objcopyflags", | |
348 | platform_specific_values(p, "_objcopyflags", "objcopyflags")) | |
349 | # | |
350 | # Autogen calls to invoke the above macros. | |
351 | # | |
352 | def platform_startup(p): return "[+ get_" + p + "_startup +]" | |
353 | def platform_ldadd(p): return "[+ get_" + p + "_ldadd +]" | |
354 | def platform_cflags(p): return "[+ get_" + p + "_cflags +]" | |
355 | def platform_ldflags(p): return "[+ get_" + p + "_ldflags +]" | |
356 | def platform_cppflags(p): return "[+ get_" + p + "_cppflags +]" | |
357 | def platform_ccasflags(p): return "[+ get_" + p + "_ccasflags +]" | |
358 | def platform_stripflags(p): return "[+ get_" + p + "_stripflags +]" | |
359 | def platform_objcopyflags(p): return "[+ get_" + p + "_objcopyflags +]" | |
8c411768 | 360 | |
e1fd1939 CW |
361 | # |
362 | # Emit snippet only the first time through for the current name. | |
363 | # | |
364 | def first_time(snippet): | |
365 | r = "[+ IF (if (not (assoc-ref seen-target (get \".name\"))) \"seen\") +]" | |
366 | r += snippet | |
367 | r += "[+ ENDIF +]" | |
368 | return r | |
369 | ||
8c411768 | 370 | def module(platform): |
911bd640 BC |
371 | r = set_canonical_name_suffix(".module") |
372 | ||
80a71213 | 373 | r += gvar_add("platform_PROGRAMS", "[+ name +].module") |
e235a228 | 374 | r += gvar_add("MODULE_FILES", "[+ name +].module$(EXEEXT)") |
8c411768 | 375 | |
911bd640 | 376 | r += var_set(cname() + "_SOURCES", platform_sources(platform) + " ## platform sources") |
911bd640 | 377 | r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform) + " ## platform nodist sources") |
911bd640 BC |
378 | r += var_set(cname() + "_LDADD", platform_ldadd(platform)) |
379 | r += var_set(cname() + "_CFLAGS", "$(AM_CFLAGS) $(CFLAGS_MODULE) " + platform_cflags(platform)) | |
380 | r += var_set(cname() + "_LDFLAGS", "$(AM_LDFLAGS) $(LDFLAGS_MODULE) " + platform_ldflags(platform)) | |
381 | r += var_set(cname() + "_CPPFLAGS", "$(AM_CPPFLAGS) $(CPPFLAGS_MODULE) " + platform_cppflags(platform)) | |
382 | r += var_set(cname() + "_CCASFLAGS", "$(AM_CCASFLAGS) $(CCASFLAGS_MODULE) " + platform_ccasflags(platform)) | |
02c9030a | 383 | # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform)) |
8c411768 | 384 | |
8427685f | 385 | r += gvar_add("EXTRA_DIST", extra_dist()) |
911bd640 BC |
386 | r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)") |
387 | r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)") | |
8c411768 | 388 | |
8c411768 | 389 | r += gvar_add("MOD_FILES", "[+ name +].mod") |
6568636e BC |
390 | r += gvar_add("MARKER_FILES", "[+ name +].marker") |
391 | r += gvar_add("CLEANFILES", "[+ name +].marker") | |
8c411768 | 392 | r += """ |
6568636e BC |
393 | [+ name +].marker: $(""" + cname() + """_SOURCES) $(nodist_""" + cname() + """_SOURCES) |
394 | $(TARGET_CPP) -DGRUB_LST_GENERATOR $(CPPFLAGS_MARKER) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(""" + cname() + """_CPPFLAGS) $(CPPFLAGS) $^ > $@.new || (rm -f $@; exit 1) | |
395 | grep 'MARKER' $@.new > $@; rm -f $@.new | |
8c411768 BC |
396 | """ |
397 | return r | |
398 | ||
8c411768 | 399 | def kernel(platform): |
911bd640 | 400 | r = set_canonical_name_suffix(".exec") |
80a71213 | 401 | r += gvar_add("platform_PROGRAMS", "[+ name +].exec") |
8427685f BC |
402 | r += var_set(cname() + "_SOURCES", platform_startup(platform)) |
403 | r += var_add(cname() + "_SOURCES", platform_sources(platform)) | |
911bd640 | 404 | r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform) + " ## platform nodist sources") |
911bd640 BC |
405 | r += var_set(cname() + "_LDADD", platform_ldadd(platform)) |
406 | r += var_set(cname() + "_CFLAGS", "$(AM_CFLAGS) $(CFLAGS_KERNEL) " + platform_cflags(platform)) | |
407 | r += var_set(cname() + "_LDFLAGS", "$(AM_LDFLAGS) $(LDFLAGS_KERNEL) " + platform_ldflags(platform)) | |
408 | r += var_set(cname() + "_CPPFLAGS", "$(AM_CPPFLAGS) $(CPPFLAGS_KERNEL) " + platform_cppflags(platform)) | |
409 | r += var_set(cname() + "_CCASFLAGS", "$(AM_CCASFLAGS) $(CCASFLAGS_KERNEL) " + platform_ccasflags(platform)) | |
410 | r += var_set(cname() + "_STRIPFLAGS", "$(AM_STRIPFLAGS) $(STRIPFLAGS_KERNEL) " + platform_stripflags(platform)) | |
02c9030a | 411 | # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform)) |
8c411768 | 412 | |
8427685f | 413 | r += gvar_add("EXTRA_DIST", extra_dist()) |
911bd640 BC |
414 | r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)") |
415 | r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)") | |
8c411768 BC |
416 | |
417 | r += gvar_add("platform_DATA", "[+ name +].img") | |
911bd640 BC |
418 | r += gvar_add("CLEANFILES", "[+ name +].img") |
419 | r += rule("[+ name +].img", "[+ name +].exec$(EXEEXT)", | |
22899b9c VS |
420 | if_platform_tagged(platform, "nostrip", |
421 | """if test x$(USE_APPLE_CC_FIXES) = xyes; then \ | |
0af1751d | 422 | $(OBJCONV) -f$(TARGET_MODULE_FORMAT) -nr:_grub_mod_init:grub_mod_init -nr:_grub_mod_fini:grub_mod_fini -ed2022 -wd1106 -nu -nd $< $@; \ |
22899b9c VS |
423 | elif test ! -z '$(TARGET_OBJ2ELF)'; then \ |
424 | cp $< $@.bin; $(TARGET_OBJ2ELF) $@.bin && cp $@.bin $@ || (rm -f $@.bin; exit 1); \ | |
425 | else cp $< $@; fi""", | |
426 | """if test x$(USE_APPLE_CC_FIXES) = xyes; then \ | |
427 | $(STRIP) $(""" + cname() + """) -o $@.bin $<; \ | |
0af1751d | 428 | $(OBJCONV) -f$(TARGET_MODULE_FORMAT) -nr:_grub_mod_init:grub_mod_init -nr:_grub_mod_fini:grub_mod_fini -ed2022 -wd1106 -nu -nd $@.bin $@; \ |
22899b9c VS |
429 | else """ + "$(STRIP) $(" + cname() + "_STRIPFLAGS) -o $@ $<; \ |
430 | fi""")) | |
8c411768 BC |
431 | return r |
432 | ||
433 | def image(platform): | |
911bd640 | 434 | r = set_canonical_name_suffix(".image") |
80a71213 | 435 | r += gvar_add("platform_PROGRAMS", "[+ name +].image") |
911bd640 | 436 | r += var_set(cname() + "_SOURCES", platform_sources(platform)) |
911bd640 | 437 | r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform) + "## platform nodist sources") |
911bd640 BC |
438 | r += var_set(cname() + "_LDADD", platform_ldadd(platform)) |
439 | r += var_set(cname() + "_CFLAGS", "$(AM_CFLAGS) $(CFLAGS_IMAGE) " + platform_cflags(platform)) | |
440 | r += var_set(cname() + "_LDFLAGS", "$(AM_LDFLAGS) $(LDFLAGS_IMAGE) " + platform_ldflags(platform)) | |
441 | r += var_set(cname() + "_CPPFLAGS", "$(AM_CPPFLAGS) $(CPPFLAGS_IMAGE) " + platform_cppflags(platform)) | |
442 | r += var_set(cname() + "_CCASFLAGS", "$(AM_CCASFLAGS) $(CCASFLAGS_IMAGE) " + platform_ccasflags(platform)) | |
d9b78bce | 443 | r += var_set(cname() + "_OBJCOPYFLAGS", "$(OBJCOPYFLAGS_IMAGE) " + platform_objcopyflags(platform)) |
02c9030a | 444 | # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform)) |
8c411768 | 445 | |
8427685f | 446 | r += gvar_add("EXTRA_DIST", extra_dist()) |
911bd640 BC |
447 | r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)") |
448 | r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)") | |
8c411768 BC |
449 | |
450 | r += gvar_add("platform_DATA", "[+ name +].img") | |
a60f6ee1 | 451 | r += gvar_add("CLEANFILES", "[+ name +].img") |
e235a228 | 452 | r += rule("[+ name +].img", "[+ name +].image$(EXEEXT)", """ |
8c411768 BC |
453 | if test x$(USE_APPLE_CC_FIXES) = xyes; then \ |
454 | $(MACHO2IMG) $< $@; \ | |
455 | else \ | |
0f021838 | 456 | $(OBJCOPY) $(""" + cname() + """_OBJCOPYFLAGS) --strip-unneeded -R .note -R .comment -R .note.gnu.build-id -R .reginfo -R .rel.dyn -R .note.gnu.gold-version $< $@; \ |
8c411768 BC |
457 | fi |
458 | """) | |
459 | return r | |
460 | ||
461 | def library(platform): | |
911bd640 | 462 | r = set_canonical_name_suffix("") |
8c411768 | 463 | |
e1fd1939 CW |
464 | r += vars_init(cname() + "_SOURCES", |
465 | "nodist_" + cname() + "_SOURCES", | |
466 | cname() + "_CFLAGS", | |
467 | cname() + "_CPPFLAGS", | |
468 | cname() + "_CCASFLAGS") | |
469 | # cname() + "_DEPENDENCIES") | |
8c411768 | 470 | |
e1fd1939 CW |
471 | r += first_time(gvar_add("noinst_LIBRARIES", "[+ name +]")) |
472 | r += var_add(cname() + "_SOURCES", platform_sources(platform)) | |
473 | r += var_add("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform)) | |
474 | r += var_add(cname() + "_CFLAGS", first_time("$(AM_CFLAGS) $(CFLAGS_LIBRARY) ") + platform_cflags(platform)) | |
475 | r += var_add(cname() + "_CPPFLAGS", first_time("$(AM_CPPFLAGS) $(CPPFLAGS_LIBRARY) ") + platform_cppflags(platform)) | |
476 | r += var_add(cname() + "_CCASFLAGS", first_time("$(AM_CCASFLAGS) $(CCASFLAGS_LIBRARY) ") + platform_ccasflags(platform)) | |
477 | # r += var_add(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform)) | |
478 | ||
479 | r += gvar_add("EXTRA_DIST", extra_dist()) | |
480 | r += first_time(gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)")) | |
481 | r += first_time(gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)")) | |
8c411768 BC |
482 | return r |
483 | ||
484 | def installdir(default="bin"): | |
485 | return "[+ IF installdir +][+ installdir +][+ ELSE +]" + default + "[+ ENDIF +]" | |
486 | ||
487 | def manpage(): | |
488 | r = "if COND_MAN_PAGES\n" | |
2e33ae0d | 489 | r += gvar_add("man_MANS", "[+ name +].[+ mansection +]\n") |
0a4fc180 | 490 | r += rule("[+ name +].[+ mansection +]", "[+ name +]", """ |
8c411768 | 491 | chmod a+x [+ name +] |
c8d9ead6 | 492 | PATH=$(builddir):$$PATH pkgdatadir=$(builddir) $(HELP2MAN) --section=[+ mansection +] -i $(top_srcdir)/docs/man/[+ name +].h2m -o $@ [+ name +] |
8c411768 BC |
493 | """) |
494 | r += gvar_add("CLEANFILES", "[+ name +].[+ mansection +]") | |
495 | r += "endif\n" | |
496 | return r | |
497 | ||
498 | def program(platform, test=False): | |
911bd640 BC |
499 | r = set_canonical_name_suffix("") |
500 | ||
501 | r += "[+ IF testcase defined +]" | |
502 | r += gvar_add("check_PROGRAMS", "[+ name +]") | |
503 | r += gvar_add("TESTS", "[+ name +]") | |
504 | r += "[+ ELSE +]" | |
e1fd1939 | 505 | r += var_add(installdir() + "_PROGRAMS", "[+ name +]") |
911bd640 BC |
506 | r += "[+ IF mansection +]" + manpage() + "[+ ENDIF +]" |
507 | r += "[+ ENDIF +]" | |
508 | ||
509 | r += var_set(cname() + "_SOURCES", platform_sources(platform)) | |
911bd640 | 510 | r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform)) |
911bd640 BC |
511 | r += var_set(cname() + "_LDADD", platform_ldadd(platform)) |
512 | r += var_set(cname() + "_CFLAGS", "$(AM_CFLAGS) $(CFLAGS_PROGRAM) " + platform_cflags(platform)) | |
513 | r += var_set(cname() + "_LDFLAGS", "$(AM_LDFLAGS) $(LDFLAGS_PROGRAM) " + platform_ldflags(platform)) | |
514 | r += var_set(cname() + "_CPPFLAGS", "$(AM_CPPFLAGS) $(CPPFLAGS_PROGRAM) " + platform_cppflags(platform)) | |
515 | r += var_set(cname() + "_CCASFLAGS", "$(AM_CCASFLAGS) $(CCASFLAGS_PROGRAM) " + platform_ccasflags(platform)) | |
02c9030a | 516 | # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform)) |
8c411768 | 517 | |
8427685f | 518 | r += gvar_add("EXTRA_DIST", extra_dist()) |
911bd640 BC |
519 | r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)") |
520 | r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)") | |
8c411768 BC |
521 | return r |
522 | ||
8c411768 | 523 | def data(platform): |
a60f6ee1 | 524 | r = gvar_add("EXTRA_DIST", platform_sources(platform)) |
8427685f | 525 | r += gvar_add("EXTRA_DIST", extra_dist()) |
e1fd1939 | 526 | r += var_add(installdir() + "_DATA", platform_sources(platform)) |
a60f6ee1 | 527 | return r |
8c411768 | 528 | |
911bd640 BC |
529 | def script(platform): |
530 | r = "[+ IF testcase defined +]" | |
531 | r += gvar_add("check_SCRIPTS", "[+ name +]") | |
532 | r += gvar_add ("TESTS", "[+ name +]") | |
533 | r += "[+ ELSE +]" | |
e1fd1939 | 534 | r += var_add(installdir() + "_SCRIPTS", "[+ name +]") |
911bd640 BC |
535 | r += "[+ IF mansection +]" + manpage() + "[+ ENDIF +]" |
536 | r += "[+ ENDIF +]" | |
8c411768 | 537 | |
0d4552fa | 538 | r += rule("[+ name +]", platform_sources(platform) + " $(top_builddir)/config.status", """ |
15eff5d9 | 539 | $(top_builddir)/config.status --file=$@:$< |
8c411768 BC |
540 | chmod a+x [+ name +] |
541 | """) | |
542 | ||
543 | r += gvar_add("CLEANFILES", "[+ name +]") | |
6556eba9 | 544 | r += gvar_add("dist_noinst_DATA", platform_sources(platform)) |
8c411768 BC |
545 | return r |
546 | ||
e1fd1939 CW |
547 | def rules(target, closure): |
548 | # Create association lists for the benefit of first_time and vars_init. | |
549 | r = "[+ (define seen-target '()) +]" | |
550 | r += "[+ (define seen-vars '()) +]" | |
551 | # Most output goes to a diversion. This allows us to emit variable | |
552 | # initializations before everything else. | |
553 | r += "[+ (out-push-new) +]" | |
554 | ||
555 | r += "[+ FOR " + target + " +]" | |
556 | r += foreach_enabled_platform( | |
557 | lambda p: under_platform_specific_conditionals(p, closure(p))) | |
558 | # Remember that we've seen this target. | |
559 | r += "[+ (set! seen-target (assoc-set! seen-target (get \".name\") 0)) +]" | |
560 | r += "[+ ENDFOR +]" | |
561 | r += "[+ (out-pop #t) +]" | |
562 | return r | |
563 | ||
8c411768 | 564 | def module_rules(): |
e1fd1939 | 565 | return rules("module", module) |
8c411768 BC |
566 | |
567 | def kernel_rules(): | |
e1fd1939 | 568 | return rules("kernel", kernel) |
8c411768 BC |
569 | |
570 | def image_rules(): | |
e1fd1939 | 571 | return rules("image", image) |
8c411768 BC |
572 | |
573 | def library_rules(): | |
e1fd1939 | 574 | return rules("library", library) |
8c411768 BC |
575 | |
576 | def program_rules(): | |
e1fd1939 | 577 | return rules("program", program) |
8c411768 BC |
578 | |
579 | def script_rules(): | |
e1fd1939 | 580 | return rules("script", script) |
8c411768 BC |
581 | |
582 | def data_rules(): | |
e1fd1939 | 583 | return rules("data", data) |
8c411768 | 584 | |
8c411768 BC |
585 | a = module_rules() |
586 | b = kernel_rules() | |
587 | c = image_rules() | |
588 | d = library_rules() | |
589 | e = program_rules() | |
590 | f = script_rules() | |
591 | g = data_rules() | |
8c411768 BC |
592 | z = global_variable_initializers() |
593 | ||
177b960e | 594 | print ("[+ AutoGen5 template +]\n") |
8667a314 | 595 | for p in GRUB_PLATFORMS: |
177b960e VS |
596 | print (define_macro_for_platform_sources(p)) |
597 | print (define_macro_for_platform_nodist_sources(p)) | |
8667a314 BC |
598 | # print define_macro_for_platform_dependencies(p) |
599 | ||
177b960e VS |
600 | print (define_macro_for_platform_startup(p)) |
601 | print (define_macro_for_platform_cflags(p)) | |
602 | print (define_macro_for_platform_ldadd(p)) | |
603 | print (define_macro_for_platform_ldflags(p)) | |
604 | print (define_macro_for_platform_cppflags(p)) | |
605 | print (define_macro_for_platform_ccasflags(p)) | |
606 | print (define_macro_for_platform_stripflags(p)) | |
607 | print (define_macro_for_platform_objcopyflags(p)) | |
608 | ||
609 | print (define_macro_for_platform_conditionals_if_statement(p)) | |
610 | print (define_macro_for_platform_conditionals_endif_statement(p)) | |
911bd640 | 611 | # print z # initializer for all vars |
177b960e VS |
612 | print (a) |
613 | print (b) | |
614 | print (c) | |
615 | print (d) | |
616 | print (e) | |
617 | print (f) | |
618 | print (g) |