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