← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

Viewing changes to gentpl.py

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
https://launchpad.net/bugs/677758
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

Lines of Context:
gentpl.py
 
1
#! /usr/bin/python
 
2
 
 
3
#
 
4
# This is the python script used to generate Makefile.tpl
 
5
#
 
6
 
 
7
GRUB_PLATFORMS = [ "emu", "i386_pc", "i386_efi", "i386_qemu", "i386_coreboot",
 
8
                   "i386_multiboot", "i386_ieee1275", "x86_64_efi",
 
9
                   "mips_yeeloong", "sparc64_ieee1275",
 
10
                   "powerpc_ieee1275" ]
 
11
 
 
12
GROUPS = {}
 
13
 
 
14
GROUPS["common"]   = GRUB_PLATFORMS[:]
 
15
 
 
16
# Groups based on CPU
 
17
GROUPS["i386"]     = [ "i386_pc", "i386_efi", "i386_qemu", "i386_coreboot", "i386_multiboot", "i386_ieee1275" ]
 
18
GROUPS["x86_64"]   = [ "x86_64_efi" ]
 
19
GROUPS["x86"]      = GROUPS["i386"] + GROUPS["x86_64"]
 
20
GROUPS["mips"]     = [ "mips_yeeloong" ]
 
21
GROUPS["sparc64"]  = [ "sparc64_ieee1275" ]
 
22
GROUPS["powerpc"]  = [ "powerpc_ieee1275" ]
 
23
 
 
24
# Groups based on firmware
 
25
GROUPS["x86_efi"]  = [ "i386_efi", "x86_64_efi" ]
 
26
GROUPS["ieee1275"]   = [ "i386_ieee1275", "sparc64_ieee1275", "powerpc_ieee1275" ]
 
27
 
 
28
# emu is a special case so many core functionality isn't needed on this platform
 
29
GROUPS["noemu"]   = GRUB_PLATFORMS[:]; GROUPS["noemu"].remove("emu")
 
30
 
 
31
# Groups based on hardware features
 
32
GROUPS["cmos"] = GROUPS["x86"][:] + ["mips_yeeloong"]; GROUPS["cmos"].remove("i386_efi"); GROUPS["cmos"].remove("x86_64_efi")
 
33
GROUPS["pci"]      = GROUPS["x86"] + GROUPS["mips"]
 
34
GROUPS["usb"]      = GROUPS["pci"]
 
35
 
 
36
# If gfxterm is main output console integrate it into kernel
 
37
GROUPS["videoinkernel"] = ["mips_yeeloong"]
 
38
GROUPS["videomodules"]   = GRUB_PLATFORMS[:];
 
39
for i in GROUPS["videoinkernel"]: GROUPS["videomodules"].remove(i)
 
40
 
 
41
# Similar for terminfo
 
42
GROUPS["terminfoinkernel"] = ["mips_yeeloong"] + GROUPS["ieee1275"];
 
43
GROUPS["terminfomodule"]   = GRUB_PLATFORMS[:];
 
44
for i in GROUPS["terminfoinkernel"]: GROUPS["terminfomodule"].remove(i)
 
45
 
 
46
# Miscelaneous groups schedulded to disappear in future
 
47
GROUPS["nosparc64"] = GRUB_PLATFORMS[:]; GROUPS["nosparc64"].remove("sparc64_ieee1275")
 
48
GROUPS["i386_coreboot_multiboot_qemu"] = ["i386_coreboot", "i386_multiboot", "i386_qemu"]
 
49
GROUPS["nopc"] = GRUB_PLATFORMS[:]; GROUPS["nopc"].remove("i386_pc")
 
50
 
 
51
#
 
52
# Create platform => groups reverse map, where groups covering that
 
53
# platform are ordered by their sizes
 
54
#
 
55
RMAP = {}
 
56
for platform in GRUB_PLATFORMS:
 
57
    # initialize with platform itself as a group
 
58
    RMAP[platform] = [ platform ]
 
59
 
 
60
    for k in GROUPS.keys():
 
61
        v = GROUPS[k]
 
62
        # skip groups that don't cover this platform
 
63
        if platform not in v: continue
 
64
 
 
65
        bigger = []
 
66
        smaller = []
 
67
        # partition currently known groups based on their size
 
68
        for group in RMAP[platform]:
 
69
            if group in GRUB_PLATFORMS: smaller.append(group)
 
70
            elif len(GROUPS[group]) < len(v): smaller.append(group)
 
71
            else: bigger.append(group)
 
72
        # insert in the middle
 
73
        RMAP[platform] = smaller + [ k ] + bigger
 
74
 
 
75
#
 
76
# Global variables
 
77
#
 
78
GVARS = set()
 
79
 
 
80
def gvar_add(var, value):
 
81
    GVARS.add(var)
 
82
    return var + " += " + value + "\n"
 
83
 
 
84
def global_variable_initializers():
 
85
    r = ""
 
86
    for var in sorted(GVARS):
 
87
        r += var + " ?= \n"
 
88
    return r
 
89
 
 
90
#
 
91
# Per PROGRAM/SCRIPT variables 
 
92
#
 
93
 
 
94
def vars_init(*var_list):
 
95
    r = "[+ IF (if (not (assoc-ref seen-vars (get \".name\"))) \"seen\") +]"
 
96
    r += "[+ (out-suspend \"v\") +]"
 
97
    for var in var_list:
 
98
        r += var + "  = \n"
 
99
    r += "[+ (out-resume \"v\") +]"
 
100
    r += "[+ (set! seen-vars (assoc-set! seen-vars (get \".name\") 0)) +]"
 
101
    r += "[+ ENDIF +]"
 
102
    return first_time(r)
 
103
 
 
104
def var_set(var, value):
 
105
    return var + "  = " + value + "\n"
 
106
 
 
107
def var_add(var, value):
 
108
    return var + " += " + value + "\n"
 
109
 
 
110
#
 
111
# Autogen constructs
 
112
#
 
113
 
 
114
def set_canonical_name_suffix(suffix): return "[+ % name `export cname=$(echo %s" + suffix + " | sed -e 's/[^0-9A-Za-z@_]/_/g')` +]"
 
115
def cname(): return "[+ % name `echo $cname` +]"
 
116
 
 
117
def rule(target, source, cmd):
 
118
    if cmd[0] == "\n":
 
119
        return "\n" + target + ": " + source + cmd.replace("\n", "\n\t") + "\n"
 
120
    else:
 
121
        return "\n" + target + ": " + source + "\n\t" + cmd.replace("\n", "\n\t") + "\n"
 
122
 
 
123
#
 
124
# Template for keys with platform names as values, for example:
 
125
#
 
126
# kernel = {
 
127
#   nostrip = emu;
 
128
#   ...
 
129
# }
 
130
#
 
131
def if_platform_tagged(platform, tag, snippet_if, snippet_else=None):
 
132
    r = ""
 
133
    r += "[+ IF " + tag + " defined +]"
 
134
    r += "[+ FOR " + tag + " +][+ CASE " + tag + " +]"
 
135
    for group in RMAP[platform]:
 
136
        r += "[+ = \"" + group + "\" +]" + snippet_if
 
137
 
 
138
    if snippet_else != None: r += "[+ * +]" + snippet_else
 
139
    r += "[+ ESAC +][+ ENDFOR +]"
 
140
 
 
141
    if snippet_else == None:
 
142
        r += "[+ ENDIF +]"
 
143
        return r
 
144
 
 
145
    r += "[+ ELSE +]" + snippet_else + "[+ ENDIF +]"
 
146
    return r
 
147
 
 
148
#
 
149
# Template for tagged values
 
150
#
 
151
# module = {
 
152
#   extra_dist = ...
 
153
#   extra_dist = ...
 
154
#   ...
 
155
# };
 
156
#
 
157
def foreach_value(tag, closure):
 
158
    return "[+ FOR " + tag + " +]" + closure("[+ ." + tag + " +]") + "[+ ENDFOR +]"
 
159
 
 
160
#
 
161
# Template for handling best matched values for a platform, for example:
 
162
#
 
163
# module = {
 
164
#   cflags = '-Wall';
 
165
#   emu_cflags = '-Wall -DGRUB_EMU=1';
 
166
#   ...
 
167
# }
 
168
#
 
169
def foreach_platform_specific_value(platform, suffix, nonetag, closure):
 
170
    r = ""
 
171
    for group in RMAP[platform]:
 
172
        gtag = group + suffix
 
173
 
 
174
        if group == RMAP[platform][0]:
 
175
            r += "[+ IF " + gtag + " +]"
 
176
        else:
 
177
            r += "[+ ELIF " + gtag + " +]"
 
178
 
 
179
        r += "[+ FOR " + gtag + " +]" + closure("[+ ." + gtag + " +]") + "[+ ENDFOR +]"
 
180
    r += "[+ ELSE +][+ FOR " + nonetag + " +]" + closure("[+ ." + nonetag + " +]") + "[+ ENDFOR +][+ ENDIF +]"
 
181
    return r
 
182
 
 
183
#
 
184
# Template for handling values from sum of all groups for a platform,
 
185
# for example:
 
186
#
 
187
# module = {
 
188
#   common = kern/misc.c;
 
189
#   emu = kern/emu/misc.c;
 
190
#   ...
 
191
# }
 
192
#
 
193
def foreach_platform_value (platform, suffix, closure):
 
194
    r = ""
 
195
    for group in RMAP[platform]:
 
196
        gtag = group + suffix
 
197
 
 
198
        r += "[+ IF " + gtag + " +]"
 
199
        r += "[+ FOR " + gtag + " +]" + closure("[+ ." + gtag + " +]") + "[+ ENDFOR +]"
 
200
        r += "[+ ENDIF +]"
 
201
    return r
 
202
 
 
203
#
 
204
# Template for gaurding with platform specific "enable" keys, for example:
 
205
#
 
206
#  module = {
 
207
#    name = pci;
 
208
#    noemu = bus/pci.c;
 
209
#    emu = bus/emu/pci.c;
 
210
#    emu = commands/lspci.c;
 
211
#
 
212
#    enable = emu;
 
213
#    enable = i386_pc;
 
214
#    enable = x86_efi;
 
215
#    enable = i386_ieee1275;
 
216
#    enable = i386_coreboot;
 
217
#  };
 
218
#
 
219
def foreach_enabled_platform(closure):
 
220
    r = "[+ IF - enable undefined +]"
 
221
    for platform in GRUB_PLATFORMS:
 
222
        r += "\nif COND_" + platform + "\n" + closure(platform) + "endif\n"
 
223
    r += "[+ ELSE +]"
 
224
    for platform in GRUB_PLATFORMS:
 
225
        x = "\nif COND_" + platform + "\n" + closure(platform) + "endif\n"
 
226
        r += if_platform_tagged(platform, "enable", x)
 
227
    r += "[+ ENDIF +]"
 
228
    return r
 
229
 
 
230
#
 
231
# Template for gaurding with platform specific automake conditionals,
 
232
# for example:
 
233
#
 
234
#  module = {
 
235
#    name = usb;
 
236
#    common = bus/usb/usb.c;
 
237
#    noemu = bus/usb/usbtrans.c;
 
238
#    noemu = bus/usb/usbhub.c;
 
239
#    enable = emu;
 
240
#    enable = i386;
 
241
#    enable = mips_yeeloong;
 
242
#    emu_condition = COND_GRUB_EMU_USB;
 
243
#  };
 
244
#
 
245
def under_platform_specific_conditionals(platform, snippet):
 
246
    r  = foreach_platform_specific_value(platform, "_condition", "condition", lambda cond: "if " + cond + "\n")
 
247
    r += snippet
 
248
    r += foreach_platform_specific_value(platform, "_condition", "condition", lambda cond: "endif " + cond + "\n")
 
249
    return r
 
250
 
 
251
def platform_specific_values(platform, suffix, nonetag):
 
252
    return foreach_platform_specific_value(platform, suffix, nonetag,
 
253
                                           lambda value: value + " ")
 
254
 
 
255
def platform_values(platform, suffix):
 
256
    return foreach_platform_value(platform, suffix, lambda value: value + " ")
 
257
 
 
258
def extra_dist():
 
259
    return foreach_value("extra_dist", lambda value: value + " ")
 
260
 
 
261
def platform_sources(p): return platform_values(p, "")
 
262
def platform_nodist_sources(p): return platform_values(p, "_nodist")
 
263
def platform_dependencies(p): return platform_values(p, "dependencies", "_dependencies")
 
264
 
 
265
def platform_startup(p): return platform_specific_values(p, "_startup", "startup")
 
266
def platform_ldadd(p): return platform_specific_values(p, "_ldadd", "ldadd")
 
267
def platform_cflags(p): return platform_specific_values(p, "_cflags", "cflags")
 
268
def platform_ldflags(p): return platform_specific_values(p, "_ldflags", "ldflags")
 
269
def platform_cppflags(p): return platform_specific_values(p, "_cppflags", "cppflags")
 
270
def platform_ccasflags(p): return platform_specific_values(p, "_ccasflags", "ccasflags")
 
271
def platform_stripflags(p): return platform_specific_values(p, "_stripflags", "stripflags")
 
272
def platform_objcopyflags(p): return platform_specific_values(p, "_objcopyflags", "objcopyflags")
 
273
 
 
274
#
 
275
# Emit snippet only the first time through for the current name.
 
276
#
 
277
def first_time(snippet):
 
278
    r = "[+ IF (if (not (assoc-ref seen-target (get \".name\"))) \"seen\") +]"
 
279
    r += snippet
 
280
    r += "[+ ENDIF +]"
 
281
    return r
 
282
 
 
283
def module(platform):
 
284
    r = set_canonical_name_suffix(".module")
 
285
 
 
286
    r += gvar_add("noinst_PROGRAMS", "[+ name +].module")
 
287
    r += gvar_add("MODULE_FILES", "[+ name +].module$(EXEEXT)")
 
288
 
 
289
    r += var_set(cname() + "_SOURCES", platform_sources(platform) + " ## platform sources")
 
290
    r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform) + " ## platform nodist sources")
 
291
    r += var_set(cname() + "_LDADD", platform_ldadd(platform))
 
292
    r += var_set(cname() + "_CFLAGS", "$(AM_CFLAGS) $(CFLAGS_MODULE) " + platform_cflags(platform))
 
293
    r += var_set(cname() + "_LDFLAGS", "$(AM_LDFLAGS) $(LDFLAGS_MODULE) " + platform_ldflags(platform))
 
294
    r += var_set(cname() + "_CPPFLAGS", "$(AM_CPPFLAGS) $(CPPFLAGS_MODULE) " + platform_cppflags(platform))
 
295
    r += var_set(cname() + "_CCASFLAGS", "$(AM_CCASFLAGS) $(CCASFLAGS_MODULE) " + platform_ccasflags(platform))
 
296
    # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform))
 
297
 
 
298
    r += gvar_add("EXTRA_DIST", extra_dist())
 
299
    r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)")
 
300
    r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)")
 
301
 
 
302
    r += gvar_add("MOD_FILES", "[+ name +].mod")
 
303
    r += gvar_add("MARKER_FILES", "[+ name +].marker")
 
304
    r += gvar_add("CLEANFILES", "[+ name +].marker")
 
305
    r += """
 
306
[+ name +].marker: $(""" + cname() + """_SOURCES) $(nodist_""" + cname() + """_SOURCES)
 
307
        $(TARGET_CPP) -DGRUB_LST_GENERATOR $(CPPFLAGS_MARKER) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(""" + cname() + """_CPPFLAGS) $(CPPFLAGS) $^ > $@.new || (rm -f $@; exit 1)
 
308
        grep 'MARKER' $@.new > $@; rm -f $@.new
 
309
"""
 
310
    return r
 
311
 
 
312
def kernel(platform):
 
313
    r = set_canonical_name_suffix(".exec")
 
314
    r += gvar_add("noinst_PROGRAMS", "[+ name +].exec")
 
315
    r += var_set(cname() + "_SOURCES", platform_startup(platform))
 
316
    r += var_add(cname() + "_SOURCES", platform_sources(platform))
 
317
    r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform) + " ## platform nodist sources")
 
318
    r += var_set(cname() + "_LDADD", platform_ldadd(platform))
 
319
    r += var_set(cname() + "_CFLAGS", "$(AM_CFLAGS) $(CFLAGS_KERNEL) " + platform_cflags(platform))
 
320
    r += var_set(cname() + "_LDFLAGS", "$(AM_LDFLAGS) $(LDFLAGS_KERNEL) " + platform_ldflags(platform))
 
321
    r += var_set(cname() + "_CPPFLAGS", "$(AM_CPPFLAGS) $(CPPFLAGS_KERNEL) " + platform_cppflags(platform))
 
322
    r += var_set(cname() + "_CCASFLAGS", "$(AM_CCASFLAGS) $(CCASFLAGS_KERNEL) " + platform_ccasflags(platform))
 
323
    r += var_set(cname() + "_STRIPFLAGS", "$(AM_STRIPFLAGS) $(STRIPFLAGS_KERNEL) " + platform_stripflags(platform))
 
324
    # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform))
 
325
 
 
326
    r += gvar_add("EXTRA_DIST", extra_dist())
 
327
    r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)")
 
328
    r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)")
 
329
 
 
330
    r += gvar_add("platform_DATA", "[+ name +].img")
 
331
    r += gvar_add("CLEANFILES", "[+ name +].img")
 
332
    r += rule("[+ name +].img", "[+ name +].exec$(EXEEXT)",
 
333
              if_platform_tagged(platform, "nostrip", "cp $< $@",
 
334
                                 "$(STRIP) $(" + cname() + "_STRIPFLAGS) -o $@ $<"))
 
335
    return r
 
336
 
 
337
def image(platform):
 
338
    r = set_canonical_name_suffix(".image")
 
339
    r += gvar_add("noinst_PROGRAMS", "[+ name +].image")
 
340
    r += var_set(cname() + "_SOURCES", platform_sources(platform))
 
341
    r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform) + "## platform nodist sources")
 
342
    r += var_set(cname() + "_LDADD", platform_ldadd(platform))
 
343
    r += var_set(cname() + "_CFLAGS", "$(AM_CFLAGS) $(CFLAGS_IMAGE) " + platform_cflags(platform))
 
344
    r += var_set(cname() + "_LDFLAGS", "$(AM_LDFLAGS) $(LDFLAGS_IMAGE) " + platform_ldflags(platform))
 
345
    r += var_set(cname() + "_CPPFLAGS", "$(AM_CPPFLAGS) $(CPPFLAGS_IMAGE) " + platform_cppflags(platform))
 
346
    r += var_set(cname() + "_CCASFLAGS", "$(AM_CCASFLAGS) $(CCASFLAGS_IMAGE) " + platform_ccasflags(platform))
 
347
    r += var_set(cname() + "_OBJCOPYFLAGS", "$(OBJCOPYFLAGS_IMAGE) " + platform_objcopyflags(platform))
 
348
    # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform))
 
349
 
 
350
    r += gvar_add("EXTRA_DIST", extra_dist())
 
351
    r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)")
 
352
    r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)")
 
353
 
 
354
    r += gvar_add("platform_DATA", "[+ name +].img")
 
355
    r += gvar_add("CLEANFILES", "[+ name +].img")
 
356
    r += rule("[+ name +].img", "[+ name +].image$(EXEEXT)", """
 
357
if test x$(USE_APPLE_CC_FIXES) = xyes; then \
 
358
  $(MACHO2IMG) $< $@; \
 
359
else \
 
360
  $(OBJCOPY) $(""" + cname() + """_OBJCOPYFLAGS) --strip-unneeded -R .note -R .comment -R .note.gnu.build-id -R .reginfo -R .rel.dyn $< $@; \
 
361
fi
 
362
""")
 
363
    return r
 
364
 
 
365
def library(platform):
 
366
    r = set_canonical_name_suffix("")
 
367
 
 
368
    r += vars_init(cname() + "_SOURCES",
 
369
                   "nodist_" + cname() + "_SOURCES",
 
370
                   cname() + "_CFLAGS",
 
371
                   cname() + "_CPPFLAGS",
 
372
                   cname() + "_CCASFLAGS")
 
373
    #              cname() + "_DEPENDENCIES")
 
374
 
 
375
    r += first_time(gvar_add("noinst_LIBRARIES", "[+ name +]"))
 
376
    r += var_add(cname() + "_SOURCES", platform_sources(platform))
 
377
    r += var_add("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform))
 
378
    r += var_add(cname() + "_CFLAGS", first_time("$(AM_CFLAGS) $(CFLAGS_LIBRARY) ") + platform_cflags(platform))
 
379
    r += var_add(cname() + "_CPPFLAGS", first_time("$(AM_CPPFLAGS) $(CPPFLAGS_LIBRARY) ") + platform_cppflags(platform))
 
380
    r += var_add(cname() + "_CCASFLAGS", first_time("$(AM_CCASFLAGS) $(CCASFLAGS_LIBRARY) ") + platform_ccasflags(platform))
 
381
    # r += var_add(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform))
 
382
 
 
383
    r += gvar_add("EXTRA_DIST", extra_dist())
 
384
    r += first_time(gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)"))
 
385
    r += first_time(gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)"))
 
386
    return r
 
387
 
 
388
def installdir(default="bin"):
 
389
    return "[+ IF installdir +][+ installdir +][+ ELSE +]" + default + "[+ ENDIF +]"
 
390
 
 
391
def manpage():
 
392
    r  = "if COND_MAN_PAGES\n"
 
393
    r += gvar_add("man_MANS", "[+ name +].[+ mansection +]\n")
 
394
    r += rule("[+ name +].[+ mansection +]", "[+ name +]", """
 
395
chmod a+x [+ name +]
 
396
PATH=$(builddir):$$PATH $(HELP2MAN) --section=[+ mansection +] -i $(top_srcdir)/docs/man/[+ name +].h2m -o $@ [+ name +]
 
397
""")
 
398
    r += gvar_add("CLEANFILES", "[+ name +].[+ mansection +]")
 
399
    r += "endif\n"
 
400
    return r
 
401
 
 
402
def program(platform, test=False):
 
403
    r = set_canonical_name_suffix("")
 
404
 
 
405
    r += "[+ IF testcase defined +]"
 
406
    r += gvar_add("check_PROGRAMS", "[+ name +]")
 
407
    r += gvar_add("TESTS", "[+ name +]")
 
408
    r += "[+ ELSE +]"
 
409
    r += var_add(installdir() + "_PROGRAMS", "[+ name +]")
 
410
    r += "[+ IF mansection +]" + manpage() + "[+ ENDIF +]"
 
411
    r += "[+ ENDIF +]"
 
412
 
 
413
    r += var_set(cname() + "_SOURCES", platform_sources(platform))
 
414
    r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform))
 
415
    r += var_set(cname() + "_LDADD", platform_ldadd(platform))
 
416
    r += var_set(cname() + "_CFLAGS", "$(AM_CFLAGS) $(CFLAGS_PROGRAM) " + platform_cflags(platform))
 
417
    r += var_set(cname() + "_LDFLAGS", "$(AM_LDFLAGS) $(LDFLAGS_PROGRAM) " + platform_ldflags(platform))
 
418
    r += var_set(cname() + "_CPPFLAGS", "$(AM_CPPFLAGS) $(CPPFLAGS_PROGRAM) " + platform_cppflags(platform))
 
419
    r += var_set(cname() + "_CCASFLAGS", "$(AM_CCASFLAGS) $(CCASFLAGS_PROGRAM) " + platform_ccasflags(platform))
 
420
    # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform))
 
421
 
 
422
    r += gvar_add("EXTRA_DIST", extra_dist())
 
423
    r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)")
 
424
    r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)")
 
425
    return r
 
426
 
 
427
def data(platform):
 
428
    r  = gvar_add("EXTRA_DIST", platform_sources(platform))
 
429
    r += gvar_add("EXTRA_DIST", extra_dist())
 
430
    r += var_add(installdir() + "_DATA", platform_sources(platform))
 
431
    return r
 
432
 
 
433
def script(platform):
 
434
    r  = "[+ IF testcase defined +]"
 
435
    r += gvar_add("check_SCRIPTS", "[+ name +]")
 
436
    r += gvar_add ("TESTS", "[+ name +]")
 
437
    r += "[+ ELSE +]"
 
438
    r += var_add(installdir() + "_SCRIPTS", "[+ name +]")
 
439
    r += "[+ IF mansection +]" + manpage() + "[+ ENDIF +]"
 
440
    r += "[+ ENDIF +]"
 
441
 
 
442
    r += rule("[+ name +]", platform_sources(platform) + " $(top_builddir)/config.status", """
 
443
$(top_builddir)/config.status --file=-:$< | sed -e 's,@pkglib_DATA@,$(pkglib_DATA),g' > $@
 
444
chmod a+x [+ name +]
 
445
""")
 
446
 
 
447
    r += gvar_add("CLEANFILES", "[+ name +]")
 
448
    r += gvar_add("dist_noinst_DATA", platform_sources(platform))
 
449
    return r
 
450
 
 
451
def rules(target, closure):
 
452
    # Create association lists for the benefit of first_time and vars_init.
 
453
    r = "[+ (define seen-target '()) +]"
 
454
    r += "[+ (define seen-vars '()) +]"
 
455
    # Most output goes to a diversion.  This allows us to emit variable
 
456
    # initializations before everything else.
 
457
    r += "[+ (out-push-new) +]"
 
458
 
 
459
    r += "[+ FOR " + target + " +]"
 
460
    r += foreach_enabled_platform(
 
461
        lambda p: under_platform_specific_conditionals(p, closure(p)))
 
462
    # Remember that we've seen this target.
 
463
    r += "[+ (set! seen-target (assoc-set! seen-target (get \".name\") 0)) +]"
 
464
    r += "[+ ENDFOR +]"
 
465
    r += "[+ (out-pop #t) +]"
 
466
    return r
 
467
 
 
468
def module_rules():
 
469
    return rules("module", module)
 
470
 
 
471
def kernel_rules():
 
472
    return rules("kernel", kernel)
 
473
 
 
474
def image_rules():
 
475
    return rules("image", image)
 
476
 
 
477
def library_rules():
 
478
    return rules("library", library)
 
479
 
 
480
def program_rules():
 
481
    return rules("program", program)
 
482
 
 
483
def script_rules():
 
484
    return rules("script", script)
 
485
 
 
486
def data_rules():
 
487
    return rules("data", data)
 
488
 
 
489
print "[+ AutoGen5 template +]\n"
 
490
a = module_rules()
 
491
b = kernel_rules()
 
492
c = image_rules()
 
493
d = library_rules()
 
494
e = program_rules()
 
495
f = script_rules()
 
496
g = data_rules()
 
497
z = global_variable_initializers()
 
498
 
 
499
# print z # initializer for all vars
 
500
print a
 
501
print b
 
502
print c
 
503
print d
 
504
print e
 
505
print f
 
506
print g