← 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, Robert Millan, Updated translations
  • Date: 2010-11-22 12:24:56 UTC
  • mfrom: (1.26.4 upstream) (17.3.36 sid)
  • mto: (17.3.43 sid)
  • mto: This revision was merged to the branch mainline in revision 89.
  • Revision ID: james.westby@ubuntu.com-20101122122456-y82z3sfb7k4zfdcc
Tags: 1.99~20101122-1
http://bugs.debian.org/550658
http://bugs.debian.org/550702
http://bugs.debian.org/591416
http://bugs.debian.org/593347
http://bugs.debian.org/551627
http://bugs.debian.org/589325
http://bugs.debian.org/543924
http://bugs.debian.org/603354
http://bugs.debian.org/604003
http://bugs.debian.org/604102
[ Colin Watson ]
* New Bazaar snapshot.  Too many changes to list in full, but some of the
  more user-visible ones are as follows:
  - GRUB script:
    + Function parameters, "break", "continue", "shift", "setparams",
      "return", and "!".
    + "export" command supports multiple variable names.
    + Multi-line quoted strings support.
    + Wildcard expansion.
  - sendkey support.
  - USB hotunplugging and USB serial support.
  - Rename CD-ROM to cd on BIOS.
  - Add new --boot-directory option to grub-install, grub-reboot, and
    grub-set-default; the old --root-directory option is still accepted
    but was often confusing.
  - Basic btrfs detection/UUID support (but no file reading yet).
  - bash-completion for utilities.
  - If a device is listed in device.map, always assume that it is
    BIOS-visible rather than using extra layers such as LVM or RAID.
  - Add grub-mknetdir script (closes: #550658).
  - Remove deprecated "root" command.
  - Handle RAID devices containing virtio components.
  - GRUB Legacy configuration file support (via grub-menulst2cfg).
  - Keyboard layout support (via grub-mklayout and grub-kbdcomp).
  - Check generated grub.cfg for syntax errors before saving.
  - Pause execution for at most ten seconds if any errors are displayed,
    so that the user has a chance to see them.
  - Support submenus.
  - Write embedding zone using Reed-Solomon, so that it's robust against
    being partially overwritten (closes: #550702, #591416, #593347).
  - GRUB_DISABLE_LINUX_RECOVERY and GRUB_DISABLE_NETBSD_RECOVERY merged
    into a single GRUB_DISABLE_RECOVERY variable.
  - Fix loader memory allocation failure (closes: #551627).
  - Don't call savedefault on recovery entries (closes: #589325).
  - Support triple-indirect blocks on ext2 (closes: #543924).
  - Recognise DDF1 fake RAID (closes: #603354).

[ Robert Millan ]
* Use dpkg architecture wildcards.

[ Updated translations ]
* Slovenian (Vanja Cvelbar).  Closes: #604003
* Dzongkha (dawa pemo via Tenzin Dendup).  Closes: #604102

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