[NaCl SDK] Make the SDK examples buildable as a packaged app.

native_client_sdk/src/build_tools/generate_make.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import cStringIO
 import optparse
 import os
 import sys
 
@@ skipping 69 matching lines @@
 
 
 def GetProjectObjects(source_dict):
   object_list = []
   for key in ['.c', '.cc']:
     for src in source_dict[key]:
       object_list.append(os.path.splitext(src)[0])
   return object_list
 
 
-def GetPlatforms(plat_list, plat_filter):
+def GetPlatforms(plat_list, plat_filter, first_toolchain):
   platforms = []
   for plat in plat_list:
     if plat in plat_filter:
       platforms.append(plat)
+
+  if first_toolchain:
+    return [platforms[0]]
   return platforms
 
 
 # 'KEY' : ( <TYPE>, [Accepted Values], <Required?>)
 DSC_FORMAT = {
     'TOOLS' : (list, ['newlib:arm', 'newlib:x64', 'newlib:x86', 'newlib',
                       'glibc', 'pnacl', 'win', 'linux'], True),
     'CONFIGS' : (list, ['Debug', 'Release'], False),
     'PREREQ' : (list, '', False),
     'TARGETS' : (list, {
         'NAME': (str, '', True),
-        'TYPE': (str, ['main', 'lib', 'so'], True),
+        'TYPE': (str, ['main', 'lib', 'so', 'so-standalone'], True),

[noelallen1, 2013/04/08 17:42:56]

We should document somewhere what these different types mean.

[binji, 2013/04/08 19:33:52]

Done.

         'SOURCES': (list, '', True),
         'CCFLAGS': (list, '', False),
         'CXXFLAGS': (list, '', False),
         'DEFINES': (list, '', False),
         'LDFLAGS': (list, '', False),
         'INCLUDES': (list, '', False),
         'LIBS' : (list, '', False),
         'DEPS' : (list, '', False)
     }, True),
     'HEADERS': (list, {
         'FILES': (list, '', True),
         'DEST': (str, '', True),
     }, False),
     'SEARCH': (list, '', False),
     'POST': (str, '', False),
     'PRE': (str, '', False),
     'DEST': (str, ['examples', 'src', 'testlibs', 'tests'], True),
     'NAME': (str, '', False),
     'DATA': (list, '', False),
     'TITLE': (str, '', False),
-    'DESC': (str, '', False),
-    'FOCUS': (str, '', False),
     'GROUP': (str, '', False),
     'EXPERIMENTAL': (bool, [True, False], False)
 }
 
 
 def ErrorMsgFunc(text):
   sys.stderr.write(text + '\n')
 
 
 def ValidateFormat(src, dsc_format, ErrorMsg=ErrorMsgFunc):
@@ skipping 107 matching lines @@
   return None
 
 
 def IsNexe(desc):
   for target in desc['TARGETS']:
     if target['TYPE'] == 'main':
       return True
   return False
 
 
-def ProcessHTML(srcroot, dstroot, desc, toolchains):
+def ProcessHTML(srcroot, dstroot, desc, toolchains, configs, first_toolchain):
   name = desc['NAME']
   outdir = os.path.join(dstroot, desc['DEST'], name)
   srcfile = os.path.join(srcroot, 'index.html')
   dstfile = os.path.join(outdir, 'index.html')
-  tools = GetPlatforms(toolchains, desc['TOOLS'])
+  tools = GetPlatforms(toolchains, desc['TOOLS'], first_toolchain)
 
   if use_gyp and getos.GetPlatform() != 'win':
-    configs = ['debug', 'release']
-  else:
-    configs = ['Debug', 'Release']
+    # Make the config names lowercase when using gyp...
+    configs = [c.lower() for c in configs]

[noelallen1, 2013/04/08 17:42:56]

This change assumes it's always correct for windows.  Do you know that's true?

[binji, 2013/04/08 19:33:52]

Below we validate that config is in ['Debug', 'Release']. This code should be
logically the same as before -- the difference is that we can pass in just
['Release'] to config, to only build the release builds.

 
   if use_gyp:
     path = "build/{tc}-{config}"
   else:
     path = "{tc}/{config}"
 
   replace = {
     'title': desc['TITLE'],
     'attrs':
         'data-name="%s" data-tools="%s" data-configs="%s" data-path="%s"' % (
@@ skipping 39 matching lines @@
       ErrorExit('Failed to find: ' + src_name)
     dst_file = os.path.join(dst_dir, src_name)
     if os.path.exists(dst_file):
       if os.stat(src_file).st_mtime <= os.stat(dst_file).st_mtime:
         Trace('Skipping "%s", destination "%s" is newer.' % (
             src_file, dst_file))
         continue
     buildbot_common.CopyFile(src_file, dst_file)
 
 
-def ProcessProject(srcroot, dstroot, desc, toolchains):
+def ProcessProject(srcroot, dstroot, desc, toolchains, first_toolchain):
   name = desc['NAME']
   out_dir = os.path.join(dstroot, desc['DEST'], name)
   buildbot_common.MakeDir(out_dir)
   srcdirs = desc.get('SEARCH', ['.', '..'])
 
   # Copy sources to example directory
   sources = GenerateSourceCopyList(desc)
   FindAndCopyFiles(sources, srcroot, srcdirs, out_dir)
 
   # Copy public headers to the include directory.
@@ skipping 22 matching lines @@
       gyp += '.bat'
     buildbot_common.Run([gyp, '-Gstandalone', '--format',  generator,
                         '--toplevel-dir=.', gypfile], cwd=out_dir)
 
   if sys.platform == 'win32' or not use_gyp:
     if IsNexe(desc):
       template = os.path.join(SCRIPT_DIR, 'template.mk')
     else:
       template = os.path.join(SCRIPT_DIR, 'library.mk')
 
-    tools = {}
-    tool_list = []
-    for tool in desc['TOOLS']:
-      if ':' in tool:
-        tool, arch = tool.split(':')
-      else:
-        arch = None
-      # Ignore tools that are not enabled in this SDK build
-      if tool not in toolchains:
-        continue
-      tools.setdefault(tool, [])
-      if tool not in tool_list:
-        tool_list.append(tool)
-      if arch:
-        tools[tool].append(arch)
-
+    # Ensure the order of |tools| is the same as toolchains; that way if
+    # first_toolchain is set, it will choose based on the order of |toolchains|.
+    tools = [tool for tool in toolchains if tool in desc['TOOLS']]
+    if first_toolchain:

[noelallen1, 2013/04/08 17:42:56]

Is this actually what we want?  Do we really want 'First', or do we want 'Only'
such that examples that don't support that toolchain get skipped?

[binji, 2013/04/08 19:33:52]

This change is so that we don't include extra toolchain builds for the packaged
app (reduces the app size from 180M -> 10M zipped)

the trouble is, we can't build everything as newlib (dlopen wouldn't work) or
glibc (arm wouldn't work) -- so this says, build the first toolchain that is
valid for the example. Usually that is newlib, but for dlopen it is glibc.

Maybe there's a better way of doing this...?

[noelallen1, 2013/04/08 19:48:16]

That's fine, I though you were trying to solve a different problem.

On 2013/04/08 19:33:52, binji wrote:

+      tools = [tools[0]]
     template_dict = {
       'pre': desc.get('PRE', ''),
-      'tools': tool_list,
+      'tools': tools,
       'targets': desc['TARGETS'],
     }
     RunTemplateFile(template, make_path, template_dict)
 
   outdir = os.path.dirname(os.path.abspath(make_path))
   pepperdir = os.path.dirname(os.path.dirname(outdir))
   AddMakeBat(pepperdir, outdir)
   return (name, desc['DEST'])
 
 
@@ skipping 16 matching lines @@
   parser.add_option('--master', help='Create master Makefile.',
       action='store_true')
   parser.add_option('--newlib', help='Create newlib examples.',
       action='store_true')
   parser.add_option('--glibc', help='Create glibc examples.',
       action='store_true')
   parser.add_option('--pnacl', help='Create pnacl examples.',
       action='store_true')
   parser.add_option('--host', help='Create host examples.',
       action='store_true')
+  parser.add_option('--config', help='Add configuration (debug/release).',
+      action='append')
   parser.add_option('--experimental', help='Create experimental examples.',
       action='store_true')
+  parser.add_option('--first-valid-toolchain',

[noelallen1, 2013/04/08 17:42:56]

Same comment as above.  Is this a testing optimization for development?

+      help='Only build one toolchain, the first one that is valid.',
+      action='store_true')
   parser.add_option('-v', '--verbose', help='Verbose output',
       action='store_true')
 
   toolchains = []
   platform = getos.GetPlatform()
 
   options, args = parser.parse_args(argv)
   if options.verbose:
     Trace.verbose = True
   if options.newlib:
     toolchains.append('newlib')
   if options.glibc:
     toolchains.append('glibc')
   if options.pnacl:
     toolchains.append('pnacl')
   if options.host:
     toolchains.append(platform)
 
   if not args:
     ErrorExit('Please specify one or more projects to generate Makefiles for.')
 
   # By default support newlib and glibc
   if not toolchains:
     toolchains = ['newlib', 'glibc', 'pnacl']
 
+  valid_configs = ['Debug', 'Release']
+  if options.config:
+    configs = []
+    for config in options.config:
+      if config in valid_configs:
+        configs.append(config)
+      else:
+        ErrorExit('Invalid config: %s' % config)
+  else:
+    configs = valid_configs
+
   master_projects = {}
 
-  landing_page = LandingPage()
   for i, filename in enumerate(args):
     if i:
       # Print two newlines between each dsc file we process
       Trace('\n')
     desc = LoadProject(filename, toolchains)
     if not desc:
       Trace('Skipping %s, not in [%s].' % (filename, ', '.join(toolchains)))
       continue
 
     if desc.get('EXPERIMENTAL', False) and not options.experimental:
       Trace('Skipping %s, experimental only.' % (filename,))
       continue
 
     srcroot = os.path.dirname(os.path.abspath(filename))
-    if not ProcessProject(srcroot, options.dstroot, desc, toolchains):
+    if not ProcessProject(srcroot, options.dstroot, desc, toolchains,
+        options.first_valid_toolchain):
       ErrorExit('\n*** Failed to process project: %s ***' % filename)
 
     # if this is an example update it's html file.
     if ShouldProcessHTML(desc):
-      ProcessHTML(srcroot, options.dstroot, desc, toolchains)
-
-    # if this is an example, update landing page html file.
-    if desc['DEST'] == 'examples':
-      Trace('Adding desc: %s' % filename)
-      landing_page.AddDesc(desc)
+      ProcessHTML(srcroot, options.dstroot, desc, toolchains, configs,
+                  options.first_valid_toolchain)
 
     # Create a list of projects for each DEST. This will be used to generate a
     # master makefile.
     master_projects.setdefault(desc['DEST'], []).append(desc)
 
-  # Generate the landing page text file.
-  index_html = os.path.join(options.dstroot, 'examples', 'index.html')
-  with open(index_html, 'w') as fh:
-    fh.write(landing_page.GeneratePage())
+
+  if master_projects.get('examples'):
+    landing_page = LandingPage()
+    for desc in master_projects.get('examples'):
+      landing_page.AddDesc(desc)
+
+    # Generate the landing page text file.
+    index_html = os.path.join(options.dstroot, 'examples', 'index.html')
+    example_resources_dir = os.path.join(SDK_EXAMPLE_DIR, 'resources')
+    index_template = os.path.join(example_resources_dir, 'index.html.template')
+    with open(index_html, 'w') as fh:
+      fh.write(landing_page.GeneratePage(index_template))
+
+    # Copy additional files needed for the landing page.
+    extra_files = ['index.css', 'index.js', 'button_close.png',
+                   'button_close_hover.png']
+    for filename in extra_files:
+      src_file = os.path.join(example_resources_dir, filename)
+      dst_file = os.path.join(options.dstroot, 'examples', filename)
+      buildbot_common.CopyFile(src_file, dst_file)
 
   if options.master:
     if use_gyp:
       master_in = os.path.join(SDK_EXAMPLE_DIR, 'Makefile_gyp')
     else:
       master_in = os.path.join(SDK_EXAMPLE_DIR, 'Makefile')
     for dest, projects in master_projects.iteritems():
       master_out = os.path.join(options.dstroot, dest, 'Makefile')
       GenerateMasterMakefile(master_in, master_out, projects)
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))