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