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

pylib/gyp/input.py

 #!/usr/bin/python
 
+from compiler.ast import Const
+from compiler.ast import Dict
+from compiler.ast import Discard
+from compiler.ast import List
+from compiler.ast import Module
+from compiler.ast import Node
+from compiler.ast import Stmt
+import compiler
 import copy
 import gyp.common
 import optparse
 import os.path
 import re
 import shlex
 import subprocess
 import sys
 
 
@@ skipping 87 matching lines @@
   if build_file_path in included:
     return included
 
   included.append(build_file_path)
 
   for included_build_file in aux_data[build_file_path].get('included', []):
     GetIncludedBuildFiles(included_build_file, aux_data, included)
 
   return included
 
+def CheckedEval(file_contents):
+  """Return the eval of a gyp file.
+
+  The gyp file is restricted to dictionaries and lists only, and
+  repeated keys are not allowed.
+
+  Note that this is slower than eval() is.
+  """
+  
+  ast = compiler.parse(file_contents)
+  assert isinstance(ast, Module)
+  c1 = ast.getChildren()
+  assert c1[0] is None
+  assert isinstance(c1[1], Stmt)
+  c2 = c1[1].getChildren()
+  assert isinstance(c2[0], Discard)
+  c3 = c2[0].getChildren()
+  assert len(c3) == 1
+  return CheckNode(c3[0],0)
+
+def CheckNode(node, level):
+  if isinstance(node, Dict):
+    c = node.getChildren()
+    dict = {}
+    for n in range(0, len(c), 2):
+      assert isinstance(c[n], Const)
+      key = c[n].getChildren()[0]
+      if key in dict:
+        raise KeyError, "Key '" + key + "' repeated at level " \
+              + repr(level)
+      dict[key] = CheckNode(c[n + 1], level + 1)
+    return dict
+  elif isinstance(node, List):
+    c = node.getChildren()
+    list = []
+    for child in c:
+      list.append(CheckNode(child, level + 1))
+    return list
+  elif isinstance(node, Const):
+    return node.getChildren()[0]
+  else:
+    raise TypeError, "Unknown AST node " + repr(node)
 
 def LoadOneBuildFile(build_file_path, data, aux_data, variables, includes,
-                     is_target):
+                     is_target, check):
   if build_file_path in data:
     return data[build_file_path]
 
   if os.path.exists(build_file_path):
     build_file_contents = open(build_file_path).read()
   else:
     raise Exception("%s not found (cwd: %s)" % (build_file_path, os.getcwd()))
 
   build_file_data = None
   try:
-    build_file_data = eval(build_file_contents, {'__builtins__': None}, None)
+    if check:
+        build_file_data = CheckedEval(build_file_contents)
+    else:
+        build_file_data = eval(build_file_contents, {'__builtins__': None},
+                               None)
   except SyntaxError, e:
     e.filename = build_file_path
     raise
   except Exception, e:
     gyp.common.ExceptionAppend(e, 'while reading ' + build_file_path)
     raise
 
   data[build_file_path] = build_file_data
   aux_data[build_file_path] = {}
 
   # Scan for includes and merge them in.
   try:
     if is_target:
       LoadBuildFileIncludesIntoDict(build_file_data, build_file_path, data,
-                                    aux_data, variables, includes)
+                                    aux_data, variables, includes, check)
     else:
       LoadBuildFileIncludesIntoDict(build_file_data, build_file_path, data,
-                                    aux_data, variables, None)
+                                    aux_data, variables, None, check)
   except Exception, e:
     gyp.common.ExceptionAppend(e,
                                'while reading includes of ' + build_file_path)
     raise
 
   return build_file_data
 
 
 def LoadBuildFileIncludesIntoDict(subdict, subdict_path, data, aux_data,
-                                  variables, includes):
+                                  variables, includes, check):
   includes_list = []
   if includes != None:
     includes_list.extend(includes)
   if 'includes' in subdict:
     for include in subdict['includes']:
       # "include" is specified relative to subdict_path, so compute the real
       # path to include by appending the provided "include" to the directory
       # in which subdict_path resides.
       relative_include = \
           os.path.normpath(os.path.join(os.path.dirname(subdict_path), include))
       includes_list.append(relative_include)
     # Unhook the includes list, it's no longer needed.
     del subdict['includes']
 
   # Merge in the included files.
   for include in includes_list:
     if not 'included' in aux_data[subdict_path]:
       aux_data[subdict_path]['included'] = []
     aux_data[subdict_path]['included'].append(include)
     MergeDicts(subdict,
                LoadOneBuildFile(include, data, aux_data, variables, None,
-                                False),
+                                False, check),
                subdict_path, include)
 
   # Recurse into subdictionaries.
   for k, v in subdict.iteritems():
     if v.__class__ == dict:
       LoadBuildFileIncludesIntoDict(v, subdict_path, data, aux_data, variables,
-                                    None)
+                                    None, check)
     elif v.__class__ == list:
-      LoadBuildFileIncludesIntoList(v, subdict_path, data, aux_data, variables)
+      LoadBuildFileIncludesIntoList(v, subdict_path, data, aux_data, variables,
+                                    check)
 
 
 # This recurses into lists so that it can look for dicts.
 def LoadBuildFileIncludesIntoList(sublist, sublist_path, data, aux_data,
-                                  variables):
+                                  variables, check):
   for item in sublist:
     if item.__class__ == dict:
       LoadBuildFileIncludesIntoDict(item, sublist_path, data, aux_data,
-                                    variables, None)
+                                    variables, None, check)
     elif item.__class__ == list:
       LoadBuildFileIncludesIntoList(item, sublist_path, data, aux_data,
-                                    variables)
+                                    variables, check)
 
 
 # TODO(mark): I don't love this name.  It just means that it's going to load
 # a build file that contains targets and is expected to provide a targets dict
 # that contains the targets...
 def LoadTargetBuildFile(build_file_path, data, aux_data, variables, includes,
-                        depth):
+                        depth, check):
   global absolute_build_file_paths
 
   # If depth is set, predefine the DEPTH variable to be a relative path from
   # this build file's directory to the directory identified by depth.
   if depth:
     d = gyp.common.RelativePath(depth, os.path.dirname(build_file_path))
     if d == '':
       variables['DEPTH'] = '.'
     else:
       variables['DEPTH'] = d
 
   # If the generator needs absolue paths, then do so.
   if absolute_build_file_paths:
     build_file_path = os.path.abspath(build_file_path)
 
   if build_file_path in data:
     # Already loaded.
     return
 
   build_file_data = LoadOneBuildFile(build_file_path, data, aux_data, variables,
-                                     includes, True)
+                                     includes, True, check)
 
   # Store DEPTH for later use in generators.
   build_file_data['_DEPTH'] = depth
 
   # Set up the included_files key indicating which .gyp files contributed to
   # this target dict.
   if 'included_files' in build_file_data:
     raise KeyError, build_file_path + ' must not contain included_files key'
 
   included = GetIncludedBuildFiles(build_file_path, aux_data)
@@ skipping 43 matching lines @@
 
   if 'targets' in build_file_data:
     for target_dict in build_file_data['targets']:
       if 'dependencies' not in target_dict:
         continue
       for dependency in target_dict['dependencies']:
         other_build_file = \
             gyp.common.BuildFileAndTarget(build_file_path, dependency)[0]
         try:
           LoadTargetBuildFile(other_build_file, data, aux_data, variables,
-                              includes, depth)
+                              includes, depth, check)
         except Exception, e:
           gyp.common.ExceptionAppend(
             e, 'while loading dependencies of %s' % build_file_path)
           raise
 
   return data
 
 # Look for the bracket that matches the first bracket seen in a
 # string, and return the start and end as a tuple.  For example, if
 # the input is something like "<(foo <(bar)) blah", then it would
@@ skipping 1380 matching lines @@
   if working_directory and not isinstance(working_directory, str):
     raise Exception("The 'working_directory' for 'run_as' in target %s "
                     "in file %s should be a string." %
                     (target_name, build_file))
   environment = run_as.get('environment')
   if environment and not isinstance(environment, dict):
     raise Exception("The 'environment' for 'run_as' in target %s "
                     "in file %s should be a dictionary." %
                     (target_name, build_file))
 
-def Load(build_files, variables, includes, depth, generator_input_info):
+def Load(build_files, variables, includes, depth, generator_input_info, check):
   # Set up path_sections and non_configuration_keys with the default data plus
   # the generator-specifc data.
   global path_sections
   path_sections = base_path_sections[:]
   path_sections.extend(generator_input_info['path_sections'])
 
   global non_configuration_keys
   non_configuration_keys = base_non_configuration_keys[:]
   non_configuration_keys.extend(generator_input_info['non_configuration_keys'])
 
@@ skipping 13 matching lines @@
   # the |data| dictionary such that the keys to |data| are build file names,
   # and the values are the entire build file contents after "early" or "pre"
   # processing has been done and includes have been resolved.
   data = {}
   aux_data = {}
   for build_file in build_files:
     # Normalize paths everywhere.  This is important because paths will be
     # used as keys to the data dict and for references between input files.
     build_file = os.path.normpath(build_file)
     try:
-      LoadTargetBuildFile(build_file, data, aux_data, variables, includes, depth)
+      LoadTargetBuildFile(build_file, data, aux_data, variables, includes,
+                          depth, check)
     except Exception, e:
       gyp.common.ExceptionAppend(e, 'while trying to load %s' % build_file)
       raise
 
   # Build a dict to access each target's subdict by qualified name.
   targets = BuildTargetsDict(data)
 
   # Fully qualify all dependency links.
   QualifyDependencies(targets)
 
@@ skipping 45 matching lines @@
 
   # Validate run_as sections in targets.
   for target in flat_list:
     build_file = gyp.common.BuildFileAndTarget('', target)[0]
     ValidateRunAsInTarget(target, targets[target], build_file)
 
   # TODO(mark): Return |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.
   return [flat_list, targets, data]