build/gypi_to_gn.py

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 """Converts a given gypi file to a python scope and writes the result to stdout.
   6
   7 It is assumed that the file contains a toplevel dictionary, and this script
   8 will return that dictionary as a GN "scope" (see example below). This script
   9 does not know anything about GYP and it will not expand variables or execute
  10 conditions.
  11
  12 It will strip conditions blocks.
  13
  14 A variables block at the top level will be flattened so that the variables
  15 appear in the root dictionary. This way they can be returned to the GN code.
  16
  17 Say your_file.gypi looked like this:
  18   {
  19      'sources': [ 'a.cc', 'b.cc' ],
  20      'defines': [ 'ENABLE_DOOM_MELON' ],
  21   }
  22
  23 You would call it like this:
  24   gypi_values = exec_script("//build/gypi_to_gn.py",
  25                             [ rebase_path("your_file.gypi") ],
  26                             "scope",
  27                             [ "your_file.gypi" ])
  28
  29 Notes:
  30  - The rebase_path call converts the gypi file from being relative to the
  31    current build file to being system absolute for calling the script, which
  32    will have a different current directory than this file.
  33
  34  - The "scope" parameter tells GN to interpret the result as a series of GN
  35    variable assignments.
  36
  37  - The last file argument to exec_script tells GN that the given file is a
  38    dependency of the build so Ninja can automatically re-run GN if the file
  39    changes.
  40
  41 Read the values into a target like this:
  42   component("mycomponent") {
  43     sources = gypi_values.sources
  44     defines = gypi_values.defines
  45   }
  46
  47 Sometimes your .gypi file will include paths relative to a different
  48 directory than the current .gn file. In this case, you can rebase them to
  49 be relative to the current directory.
  50   sources = rebase_path(gypi_values.sources, ".",
  51                         "//path/gypi/input/values/are/relative/to")
  52
  53 This script will tolerate a 'variables' in the toplevel dictionary or not. If
  54 the toplevel dictionary just contains one item called 'variables', it will be
  55 collapsed away and the result will be the contents of that dictinoary. Some
  56 .gypi files are written with or without this, depending on how they expect to
  57 be embedded into a .gyp file.
  58
  59 This script also has the ability to replace certain substrings in the input.
  60 Generally this is used to emulate GYP variable expansion. If you passed the
  61 argument "--replace=<(foo)=bar" then all instances of "<(foo)" in strings in
  62 the input will be replaced with "bar":
  63
  64   gypi_values = exec_script("//build/gypi_to_gn.py",
  65                             [ rebase_path("your_file.gypi"),
  66                               "--replace=<(foo)=bar"],
  67                             "scope",
  68                             [ "your_file.gypi" ])
  69
  70 """
  71
  72 import gn_helpers
  73 from optparse import OptionParser
  74 import sys
  75
  76 def LoadPythonDictionary(path):
  77   file_string = open(path).read()
  78   try:
  79     file_data = eval(file_string, {'__builtins__': None}, None)
  80   except SyntaxError, e:
  81     e.filename = path
  82     raise
  83   except Exception, e:
  84     raise Exception("Unexpected error while reading %s: %s" % (path, str(e)))
  85
  86   assert isinstance(file_data, dict), "%s does not eval to a dictionary" % path
  87
  88   # Flatten any variables to the top level.
  89   if 'variables' in file_data:
  90     file_data.update(file_data['variables'])
  91     del file_data['variables']
  92
  93   # Strip any conditions.
  94   if 'conditions' in file_data:
  95     del file_data['conditions']
  96   if 'target_conditions' in file_data:
  97     del file_data['target_conditions']
  98
  99   # Strip targets in the toplevel, since some files define these and we can't
 100   # slurp them in.
 101   if 'targets' in file_data:
 102     del file_data['targets']
 103
 104   return file_data
 105
 106
 107 def ReplaceSubstrings(values, search_for, replace_with):
 108   """Recursively replaces substrings in a value.
 109
 110   Replaces all substrings of the "search_for" with "repace_with" for all
 111   strings occurring in "values". This is done by recursively iterating into
 112   lists as well as the keys and values of dictionaries."""
 113   if isinstance(values, str):
 114     return values.replace(search_for, replace_with)
 115
 116   if isinstance(values, list):
 117     return [ReplaceSubstrings(v, search_for, replace_with) for v in values]
 118
 119   if isinstance(values, dict):
 120     # For dictionaries, do the search for both the key and values.
 121     result = {}
 122     for key, value in values.items():
 123       new_key = ReplaceSubstrings(key, search_for, replace_with)
 124       new_value = ReplaceSubstrings(value, search_for, replace_with)
 125       result[new_key] = new_value
 126     return result
 127
 128   # Assume everything else is unchanged.
 129   return values
 130
 131 def main():
 132   parser = OptionParser()
 133   parser.add_option("-r", "--replace", action="append",
 134     help="Replaces substrings. If passed a=b, replaces all substrs a with b.")
 135   (options, args) = parser.parse_args()
 136
 137   if len(args) != 1:
 138     raise Exception("Need one argument which is the .gypi file to read.")
 139
 140   data = LoadPythonDictionary(args[0])
 141   if options.replace:
 142     # Do replacements for all specified patterns.
 143     for replace in options.replace:
 144       split = replace.split('=')
 145       # Allow "foo=" to replace with nothing.
 146       if len(split) == 1:
 147         split.append('')
 148       assert len(split) == 2, "Replacement must be of the form 'key=value'."
 149       data = ReplaceSubstrings(data, split[0], split[1])
 150
 151   # Sometimes .gypi files use the GYP syntax with percents at the end of the
 152   # variable name (to indicate not to overwrite a previously-defined value):
 153   #   'foo%': 'bar',
 154   # Convert these to regular variables.
 155   for key in data:
 156     if len(key) > 1 and key[len(key) - 1] == '%':
 157       data[key[:-1]] = data[key]
 158       del data[key]
 159
 160   print gn_helpers.ToGNString(data)
 161
 162 if __name__ == '__main__':
 163   try:
 164     main()
 165   except Exception, e:
 166     print str(e)
 167     sys.exit(1)