Add a --check flag. This causes gyp to check syntax of files more carefully,...

pylib/gyp/__init__.py

 #!/usr/bin/python
 
 import copy
 import gyp.input
 import optparse
 import os.path
 import re
 import shlex
 import sys
 
@@ skipping 12 matching lines @@
   extension = '.gyp'
   files = os.listdir(os.getcwd())
   build_files = []
   for file in files:
     if file[-len(extension):] == extension:
       build_files.append(file)
   return build_files
 
 
 def Load(build_files, format, default_variables={},
-         includes=[], depth='.', params={}):
+         includes=[], depth='.', params={}, check=False):
   """
   Loads one or more specified build files.
   default_variables and includes will be copied before use.
   Returns the generator for the specified format and the
   data returned by loading the specified build files.
   """
   default_variables = copy.copy(default_variables)
 
   # Default variables provided by this program and its modules should be
   # named WITH_CAPITAL_LETTERS to provide a distinct "best practice" namespace,
@@ skipping 22 matching lines @@
     'non_configuration_keys':
         getattr(generator, 'generator_additional_non_configuration_keys', []),
     'path_sections':
         getattr(generator, 'generator_additional_path_sections', []),
     'extra_sources_for_rules':
         getattr(generator, 'generator_extra_sources_for_rules', []),
   }
 
   # Process the input specific to this generator.
   result = gyp.input.Load(build_files, default_variables, includes[:],
-                          depth, generator_input_info)
+                          depth, generator_input_info, check)
   return [generator] + result
 
 def NameValueListToDict(name_value_list):
   """
   Takes an array of strings of the form 'NAME=VALUE' and creates a dictionary
   of the pairs.  If a string is simply NAME, then the value in the dictionary
   is set to True.  If VALUE can be converted to an integer, it is.
   """
   result = { }
   for item in name_value_list:
@@ skipping 32 matching lines @@
                     action='append', default=[], help='turn on a debugging '
                     'mode for debugging GYP.  Supported modes are "variables" '
                     'and "general"')
   parser.add_option('-S', '--suffix', dest='suffix', default='',
                     help='suffix to add to generated files')
   parser.add_option('-G', dest='generator_flags', action='append', default=[],
                     metavar='FLAG=VAL', help='sets generator flag FLAG to VAL')
   parser.add_option('--generator-output', dest='generator_output',
                     action='store', default=None, metavar='DIR',
                     help='puts generated build files under DIR')
+  parser.add_option('--check', dest='check', action='store_true',
+                    help='check format of gyp files')
 
   # We read a few things from ~/.gyp, so set up a var for that.
   home_vars = ['HOME']
   if sys.platform in ('cygwin', 'win32'):
     home_vars.append('USERPROFILE')
   home = None
   for home_var in home_vars:
     home = os.getenv(home_var)
     if home != None:
       break
@@ skipping 123 matching lines @@
   for format in set(options.formats):
     params = {'options': options,
               'build_files': build_files,
               'generator_flags': generator_flags,
               'cwd': os.getcwd()}
 
     # Start with the default variables from the command line.
     [generator, flat_list, targets, data] = Load(build_files, format,
                                                  cmdline_default_variables,
                                                  includes, options.depth,
-                                                 params)
+                                                 params, options.check)
 
     # TODO(mark): Pass |data| for now because the generator needs a list of
     # build files that came in.  In the future, maybe it should just accept
     # a list, and not the whole data dict.
     # NOTE: flat_list is the flattened dependency graph specifying the order
     # that targets may be built.  Build systems that operate serially or that
     # need to have dependencies defined before dependents reference them should
     # generate targets in the order specified in flat_list.
     generator.GenerateOutput(flat_list, targets, data, params)
 
   # Done
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))