[NaCl SDK] Build gtest on buildbots, but don't include it in the SDK.

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 buildbot_common
 import make_rules
 import optparse
 import os
 import sys
 
 from make_rules import BuildDefineList, BuildLibList, BuildToolDict
-from make_rules import GetBuildRule, BUILD_RULES
+from make_rules import BuildIncludeList, GetBuildRule, BUILD_RULES
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 SDK_SRC_DIR = os.path.dirname(SCRIPT_DIR)
 SDK_EXAMPLE_DIR = os.path.join(SDK_SRC_DIR, 'examples')
 SDK_DIR = os.path.dirname(SDK_SRC_DIR)
 SRC_DIR = os.path.dirname(SDK_DIR)
 OUT_DIR = os.path.join(SRC_DIR, 'out')
 PPAPI_DIR = os.path.join(SRC_DIR, 'ppapi')
 
 # Add SDK make tools scripts to the python path.
@@ skipping 114 matching lines @@
   For the given target, toolset and architecture, returns a rule to generate
   the object files for the set of sources.
 
   Returns:
     Returns a tuple containin the objects and the rule.
   """
   rules = ''
   name = target['NAME']
   object_sets = []
 
-  defines = target.get('DEFINES', [])
-  defs = BuildDefineList(tool, defines)
+  defs = BuildDefineList(tool, target.get('DEFINES', []))
+  includes = BuildIncludeList(tool, target.get('INCLUDES', []))
 
   if srcs['.c']:
-    replace = BuildToolDict(tool, name, arch, 'c', DEFLIST=defs)
+    replace = BuildToolDict(tool, name, arch, 'c',
+        DEFLIST=defs, INCLUDELIST=includes)
     compile_rule = GetBuildRule(tool, 'CC')
     rules += Replace(compile_rule, replace)
     object_sets.append('$(%s)' % replace['<OBJS>'])
 
   if srcs['.cc']:
-    replace = BuildToolDict(tool, name, arch, 'cc', DEFLIST=defs)
+    replace = BuildToolDict(tool, name, arch, 'cc',
+        DEFLIST=defs, INCLUDELIST=includes)
     compile_rule = GetBuildRule(tool, 'CXX')
     rules += Replace(compile_rule, replace)
     object_sets.append('$(%s)' % replace['<OBJS>'])
 
   return (' '.join(object_sets), rules)
 
 
 def GenerateLink(target, tool, arch, objs):
   """Generate a Link target.
 
@@ skipping 28 matching lines @@
         tc, tc, tc)
     main = None
     for target in desc['TARGETS']:
       name = target['NAME']
       srcs = GetSourcesDict(target['SOURCES'])
       for arch in BUILD_RULES[tc]['ARCHES']:
         objs, comp_rule = GenerateCompile(target, tc, arch, srcs)
         targs, link_rule = GenerateLink(target, tc, arch, objs)
         rules += comp_rule + link_rule
         clean.append(objs)
+        if target['TYPE'] == 'lib':
+          all_targets.append(targs)
 
       if target['TYPE'] == 'main':
         main = target
-      elif target['TYPE'] == 'lib':
-        all_targets.append(targs)
 
     if main:
       targs, nmf_rule = GenerateNMF(main, tc)
       rules += nmf_rule
       all_targets.append(targs)
   rules += '\n.PHONY : clean\nclean:\n\t$(RM) $(DEPFILES) ' + ' '.join(clean)
   rules += '\n\n-include $(DEPFILES)'
   return ' '.join(all_targets), rules
 
 
@@ skipping 40 matching lines @@
 DSC_FORMAT = {
     'TOOLS' : (list, ['newlib', 'glibc', 'pnacl', 'win'], True),
     'PREREQ' : (list, '', False),
     'TARGETS' : (list, {
         'NAME': (str, '', True),
         'TYPE': (str, ['main', 'nexe', 'lib', 'so'], True),
         'SOURCES': (list, '', True),
         'CCFLAGS': (list, '', False),
         'CXXFLAGS': (list, '', False),
         'LDFLAGS': (list, '', False),
+        'INCLUDES': (list, '', False),
         'LIBS' : (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'], True),
+    'DEST': (str, ['examples', 'src', 'testing'], True),
     'NAME': (str, '', False),
     'DATA': (list, '', False),
     'TITLE': (str, '', False),
     'DESC': (str, '', False),
     'INFO': (str, '', False),
     'EXPERIMENTAL': (bool, [True, False], False)
 }
 
 
 def ErrorMsgFunc(text):
@@ skipping 27 matching lines @@
           key, exp_type.__name__.upper(), type(value).__name__.upper()))
       failed = True
       continue
 
     # Verify the value is non-empty if required
     if required and not value:
       ErrorMsg('Expected non-empty value for %s.' % key)
       failed = True
       continue
 
+    # If it's a bool, the expected values are always True or False.
+    if exp_type is bool:
+      continue
+
     # If it's a string and there are expected values, make sure it matches
     if exp_type is str:
       if type(exp_value) is list and exp_value:
         if value not in exp_value:
           ErrorMsg('Value %s not expected for %s.' % (value, key))
           failed = True
       continue
 
     # if it's a list, then we need to validate the values
     if exp_type is list:
@@ skipping 206 matching lines @@
     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']
     print 'Using default toolchains: ' + ' '.join(toolchains)
 
-  examples = []
-  libs = []
+  master_projects = {}
   for filename in args:
     desc = LoadProject(filename, toolchains)
     if not desc:
       print 'Skipping %s, not in [%s].' % (filename, ', '.join(toolchains))
       continue
 
     if desc.get('EXPERIMENTAL', False) and not options.experimental:
       print 'Skipping %s, experimental only.' % (filename,)
       continue
 
     srcroot = os.path.dirname(os.path.abspath(filename))
     if not ProcessProject(srcroot, options.dstroot, desc, toolchains):
       ErrorExit('\n*** Failed to process project: %s ***' % filename)
 
-    # if this is an example add it to the master make and update the html
+    # if this is an example update the html
     if desc['DEST'] == 'examples':
-      examples.append(desc['NAME'])
       ProcessHTML(srcroot, options.dstroot, desc, toolchains)
 
-    # if this is a library add it to the master make
-    if desc['DEST'] == 'src':
-      libs.append(desc['NAME'])
+    # Create a list of projects for each DEST. This will be used to generate a
+    # master makefile.
+    master_projects.setdefault(desc['DEST'], []).append(desc['NAME'])
 
   if options.master:
     master_in = os.path.join(SDK_EXAMPLE_DIR, 'Makefile')
-    master_out = os.path.join(options.dstroot, 'examples', 'Makefile')
-    GenerateMasterMakefile(master_in, master_out, examples)
-    master_out = os.path.join(options.dstroot, 'src', 'Makefile')
-    GenerateMasterMakefile(master_in, master_out, libs)
+    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:]))