gentpl.py

   1 #! /usr/bin/python
   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/>.
  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",
  23                    "i386_multiboot", "i386_ieee1275", "x86_64_efi",
  24                    "mips_loongson", "sparc64_ieee1275",
  25                    "powerpc_ieee1275", "mips_arc", "ia64_efi",
  26                    "mips_qemu_mips" ]
  27
  28 GROUPS = {}
  29
  30 GROUPS["common"]   = GRUB_PLATFORMS[:]
  31
  32 # Groups based on CPU
  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"]
  36 GROUPS["mips"]     = [ "mips_loongson", "mips_qemu_mips", "mips_arc" ]
  37 GROUPS["sparc64"]  = [ "sparc64_ieee1275" ]
  38 GROUPS["powerpc"]  = [ "powerpc_ieee1275" ]
  39
  40 # Groups based on firmware
  41 GROUPS["efi"]  = [ "i386_efi", "x86_64_efi", "ia64_efi" ]
  42 GROUPS["ieee1275"]   = [ "i386_ieee1275", "sparc64_ieee1275", "powerpc_ieee1275" ]
  43
  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
  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")
  51 GROUPS["pci"]      = GROUPS["x86"] + ["mips_loongson"]
  52 GROUPS["usb"]      = GROUPS["pci"]
  53
  54 # If gfxterm is main output console integrate it into kernel
  55 GROUPS["videoinkernel"] = ["mips_loongson", "mips_qemu_mips"]
  56 GROUPS["videomodules"]   = GRUB_PLATFORMS[:];
  57 for i in GROUPS["videoinkernel"]: GROUPS["videomodules"].remove(i)
  58
  59 # Similar for terminfo
  60 GROUPS["terminfoinkernel"] = ["mips_loongson", "mips_arc", "mips_qemu_mips" ] + GROUPS["ieee1275"];
  61 GROUPS["terminfomodule"]   = GRUB_PLATFORMS[:];
  62 for i in GROUPS["terminfoinkernel"]: GROUPS["terminfomodule"].remove(i)
  63
  64 # Miscelaneous groups schedulded to disappear in future
  65 GROUPS["i386_coreboot_multiboot_qemu"] = ["i386_coreboot", "i386_multiboot", "i386_qemu"]
  66 GROUPS["nopc"] = GRUB_PLATFORMS[:]; GROUPS["nopc"].remove("i386_pc")
  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 #
  95 GVARS = set()
  96
  97 def gvar_add(var, value):
  98     GVARS.add(var)
  99     return var + " += " + value + "\n"
 100
 101 def global_variable_initializers():
 102     r = ""
 103     for var in sorted(GVARS):
 104         r += var + " ?= \n"
 105     return r
 106
 107 #
 108 # Per PROGRAM/SCRIPT variables
 109 #
 110
 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
 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
 131 def set_canonical_name_suffix(suffix): return "[+ % name `export cname=$(echo %s" + suffix + " | sed -e 's/[^0-9A-Za-z@_]/_/g')` +]"
 132 def cname(): return "[+ % name `echo $cname` +]"
 133
 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"
 139
 140 #
 141 # Template for keys with platform names as values, for example:
 142 #
 143 # kernel = {
 144 #   nostrip = emu;
 145 #   ...
 146 # }
 147 #
 148 def if_platform_tagged(platform, tag, snippet_if, snippet_else=None):
 149     r = ""
 150     r += "[+ IF " + tag + " defined +]"
 151     r += "[+ FOR " + tag + " +][+ CASE " + tag + " +]"
 152     for group in RMAP[platform]:
 153         r += "[+ = \"" + group + "\" +]" + snippet_if
 154
 155     if snippet_else != None: r += "[+ * +]" + snippet_else
 156     r += "[+ ESAC +][+ ENDFOR +]"
 157
 158     if snippet_else == None:
 159         r += "[+ ENDIF +]"
 160         return r
 161
 162     r += "[+ ELSE +]" + snippet_else + "[+ ENDIF +]"
 163     return r
 164
 165 #
 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:
 179 #
 180 # module = {
 181 #   cflags = '-Wall';
 182 #   emu_cflags = '-Wall -DGRUB_EMU=1';
 183 #   ...
 184 # }
 185 #
 186 def foreach_platform_specific_value(platform, suffix, nonetag, closure):
 187     r = ""
 188     for group in RMAP[platform]:
 189         gtag = group + suffix
 190
 191         if group == RMAP[platform][0]:
 192             r += "[+ IF " + gtag + " +]"
 193         else:
 194             r += "[+ ELIF " + gtag + " +]"
 195
 196         r += "[+ FOR " + gtag + " +]" + closure("[+ ." + gtag + " +]") + "[+ ENDFOR +]"
 197     r += "[+ ELSE +][+ FOR " + nonetag + " +]" + closure("[+ ." + nonetag + " +]") + "[+ ENDFOR +][+ ENDIF +]"
 198     return r
 199
 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
 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 +]"
 229     return r
 230
 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):
 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"
 254         r += if_platform_tagged(platform, "enable", x)
 255     r += "[+ ENDIF +]"
 256     return r
 257
 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;
 269 #    enable = mips_loongson;
 270 #    emu_condition = COND_GRUB_EMU_USB;
 271 #  };
 272 #
 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"))
 281 def under_platform_specific_conditionals(platform, snippet):
 282     r  = "[+ if_" + platform + "_conditionals +]"
 283     r += snippet
 284     r += "[+ endif_" + platform + "_conditionals +]"
 285     return r
 286
 287 def platform_specific_values(platform, suffix, nonetag):
 288     return foreach_platform_specific_value(platform, suffix, nonetag,
 289                                            lambda value: value + " ")
 290
 291 def platform_values(platform, suffix):
 292     return foreach_platform_value(platform, suffix, lambda value: value + " ")
 293
 294 def extra_dist():
 295     return foreach_value("extra_dist", lambda value: value + " ")
 296
 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 +]"
 312
 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 +]"
 360
 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
 370 def module(platform):
 371     r = set_canonical_name_suffix(".module")
 372
 373     r += gvar_add("platform_PROGRAMS", "[+ name +].module")
 374     r += gvar_add("MODULE_FILES", "[+ name +].module$(EXEEXT)")
 375
 376     r += var_set(cname() + "_SOURCES", platform_sources(platform) + " ## platform sources")
 377     r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform) + " ## platform nodist sources")
 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))
 383     # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform))
 384
 385     r += gvar_add("EXTRA_DIST", extra_dist())
 386     r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)")
 387     r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)")
 388
 389     r += gvar_add("MOD_FILES", "[+ name +].mod")
 390     r += gvar_add("MARKER_FILES", "[+ name +].marker")
 391     r += gvar_add("CLEANFILES", "[+ name +].marker")
 392     r += """
 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
 396 """
 397     return r
 398
 399 def kernel(platform):
 400     r = set_canonical_name_suffix(".exec")
 401     r += gvar_add("platform_PROGRAMS", "[+ name +].exec")
 402     r += var_set(cname() + "_SOURCES", platform_startup(platform))
 403     r += var_add(cname() + "_SOURCES", platform_sources(platform))
 404     r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform) + " ## platform nodist sources")
 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))
 411     # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform))
 412
 413     r += gvar_add("EXTRA_DIST", extra_dist())
 414     r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)")
 415     r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)")
 416
 417     r += gvar_add("platform_DATA", "[+ name +].img")
 418     r += gvar_add("CLEANFILES", "[+ name +].img")
 419     r += rule("[+ name +].img", "[+ name +].exec$(EXEEXT)",
 420               if_platform_tagged(platform, "nostrip",
 421 """if test x$(USE_APPLE_CC_FIXES) = xyes; then \
 422      $(OBJCONV) -f$(TARGET_MODULE_FORMAT) -nr:_grub_mod_init:grub_mod_init -nr:_grub_mod_fini:grub_mod_fini -ed2022 -wd1106 -nu -nd $< $@; \
 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 $<; \
 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 $@; \
 429 else """  + "$(STRIP) $(" + cname() + "_STRIPFLAGS) -o $@ $<; \
 430 fi"""))
 431     return r
 432
 433 def image(platform):
 434     r = set_canonical_name_suffix(".image")
 435     r += gvar_add("platform_PROGRAMS", "[+ name +].image")
 436     r += var_set(cname() + "_SOURCES", platform_sources(platform))
 437     r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform) + "## platform nodist sources")
 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))
 443     r += var_set(cname() + "_OBJCOPYFLAGS", "$(OBJCOPYFLAGS_IMAGE) " + platform_objcopyflags(platform))
 444     # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform))
 445
 446     r += gvar_add("EXTRA_DIST", extra_dist())
 447     r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)")
 448     r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)")
 449
 450     r += gvar_add("platform_DATA", "[+ name +].img")
 451     r += gvar_add("CLEANFILES", "[+ name +].img")
 452     r += rule("[+ name +].img", "[+ name +].image$(EXEEXT)", """
 453 if test x$(USE_APPLE_CC_FIXES) = xyes; then \
 454   $(MACHO2IMG) $< $@; \
 455 else \
 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 $< $@; \
 457 fi
 458 """)
 459     return r
 460
 461 def library(platform):
 462     r = set_canonical_name_suffix("")
 463
 464     r += vars_init(cname() + "_SOURCES",
 465                    "nodist_" + cname() + "_SOURCES",
 466                    cname() + "_CFLAGS",
 467                    cname() + "_CPPFLAGS",
 468                    cname() + "_CCASFLAGS")
 469     #              cname() + "_DEPENDENCIES")
 470
 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)"))
 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"
 489     r += gvar_add("man_MANS", "[+ name +].[+ mansection +]\n")
 490     r += rule("[+ name +].[+ mansection +]", "[+ name +]", """
 491 chmod a+x [+ name +]
 492 PATH=$(builddir):$$PATH pkgdatadir=$(builddir) $(HELP2MAN) --section=[+ mansection +] -i $(top_srcdir)/docs/man/[+ name +].h2m -o $@ [+ name +]
 493 """)
 494     r += gvar_add("CLEANFILES", "[+ name +].[+ mansection +]")
 495     r += "endif\n"
 496     return r
 497
 498 def program(platform, test=False):
 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 +]"
 505     r += var_add(installdir() + "_PROGRAMS", "[+ name +]")
 506     r += "[+ IF mansection +]" + manpage() + "[+ ENDIF +]"
 507     r += "[+ ENDIF +]"
 508
 509     r += var_set(cname() + "_SOURCES", platform_sources(platform))
 510     r += var_set("nodist_" + cname() + "_SOURCES", platform_nodist_sources(platform))
 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))
 516     # r += var_set(cname() + "_DEPENDENCIES", platform_dependencies(platform) + " " + platform_ldadd(platform))
 517
 518     r += gvar_add("EXTRA_DIST", extra_dist())
 519     r += gvar_add("BUILT_SOURCES", "$(nodist_" + cname() + "_SOURCES)")
 520     r += gvar_add("CLEANFILES", "$(nodist_" + cname() + "_SOURCES)")
 521     return r
 522
 523 def data(platform):
 524     r  = gvar_add("EXTRA_DIST", platform_sources(platform))
 525     r += gvar_add("EXTRA_DIST", extra_dist())
 526     r += var_add(installdir() + "_DATA", platform_sources(platform))
 527     return r
 528
 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 +]"
 534     r += var_add(installdir() + "_SCRIPTS", "[+ name +]")
 535     r += "[+ IF mansection +]" + manpage() + "[+ ENDIF +]"
 536     r += "[+ ENDIF +]"
 537
 538     r += rule("[+ name +]", platform_sources(platform) + " $(top_builddir)/config.status", """
 539 $(top_builddir)/config.status --file=$@:$<
 540 chmod a+x [+ name +]
 541 """)
 542
 543     r += gvar_add("CLEANFILES", "[+ name +]")
 544     r += gvar_add("dist_noinst_DATA", platform_sources(platform))
 545     return r
 546
 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
 564 def module_rules():
 565     return rules("module", module)
 566
 567 def kernel_rules():
 568     return rules("kernel", kernel)
 569
 570 def image_rules():
 571     return rules("image", image)
 572
 573 def library_rules():
 574     return rules("library", library)
 575
 576 def program_rules():
 577     return rules("program", program)
 578
 579 def script_rules():
 580     return rules("script", script)
 581
 582 def data_rules():
 583     return rules("data", data)
 584
 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()
 592 z = global_variable_initializers()
 593
 594 print ("[+ AutoGen5 template +]\n")
 595 for p in GRUB_PLATFORMS:
 596     print (define_macro_for_platform_sources(p))
 597     print (define_macro_for_platform_nodist_sources(p))
 598     # print define_macro_for_platform_dependencies(p)
 599
 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))
 611 # print z # initializer for all vars
 612 print (a)
 613 print (b)
 614 print (c)
 615 print (d)
 616 print (e)
 617 print (f)
 618 print (g)