1#!/usr/bin/env python
2#
3# Copyright 2016 Google Inc.
4#
5# Use of this source code is governed by a BSD-style license that can be
6# found in the LICENSE file.
7
8
9"""
10Usage: gn_to_cmake.py <json_file_name>
11
12gn gen out/config --ide=json --json-ide-script=../../gn/gn_to_cmake.py
13
14or
15
16gn gen out/config --ide=json
17python gn/gn_to_cmake.py out/config/project.json
18
19The first is recommended, as it will auto-update.
20"""
21
22
23import itertools
24import functools
25import json
26import posixpath
27import os
28import string
29import sys
30
31
32def CMakeStringEscape(a):
33  """Escapes the string 'a' for use inside a CMake string.
34
35  This means escaping
36  '\' otherwise it may be seen as modifying the next character
37  '"' otherwise it will end the string
38  ';' otherwise the string becomes a list
39
40  The following do not need to be escaped
41  '#' when the lexer is in string state, this does not start a comment
42  """
43  return a.replace('\\', '\\\\').replace(';', '\\;').replace('"', '\\"')
44
45
46def CMakeTargetEscape(a):
47  """Escapes the string 'a' for use as a CMake target name.
48
49  CMP0037 in CMake 3.0 restricts target names to "^[A-Za-z0-9_.:+-]+$"
50  The ':' is only allowed for imported targets.
51  """
52  def Escape(c):
53    if c in string.ascii_letters or c in string.digits or c in '_.+-':
54      return c
55    else:
56      return '__'
57  return ''.join(map(Escape, a))
58
59
60def SetVariable(out, variable_name, value):
61  """Sets a CMake variable."""
62  out.write('set("')
63  out.write(CMakeStringEscape(variable_name))
64  out.write('" "')
65  out.write(CMakeStringEscape(value))
66  out.write('")\n')
67
68
69def SetVariableList(out, variable_name, values):
70  """Sets a CMake variable to a list."""
71  if not values:
72    return SetVariable(out, variable_name, "")
73  if len(values) == 1:
74    return SetVariable(out, variable_name, values[0])
75  out.write('list(APPEND "')
76  out.write(CMakeStringEscape(variable_name))
77  out.write('"\n  "')
78  out.write('"\n  "'.join([CMakeStringEscape(value) for value in values]))
79  out.write('")\n')
80
81
82def SetFilesProperty(output, variable, property_name, values, sep):
83  """Given a set of source files, sets the given property on them."""
84  output.write('set_source_files_properties(')
85  WriteVariable(output, variable)
86  output.write(' PROPERTIES ')
87  output.write(property_name)
88  output.write(' "')
89  for value in values:
90    output.write(CMakeStringEscape(value))
91    output.write(sep)
92  output.write('")\n')
93
94
95def SetCurrentTargetProperty(out, property_name, values, sep=''):
96  """Given a target, sets the given property."""
97  out.write('set_target_properties("${target}" PROPERTIES ')
98  out.write(property_name)
99  out.write(' "')
100  for value in values:
101    out.write(CMakeStringEscape(value))
102    out.write(sep)
103  out.write('")\n')
104
105
106def WriteVariable(output, variable_name, prepend=None):
107  if prepend:
108    output.write(prepend)
109  output.write('${')
110  output.write(variable_name)
111  output.write('}')
112
113
114# See GetSourceFileType in gn
115source_file_types = {
116  '.cc': 'cxx',
117  '.cpp': 'cxx',
118  '.cxx': 'cxx',
119  '.c': 'c',
120  '.s': 'asm',
121  '.S': 'asm',
122  '.asm': 'asm',
123  '.o': 'obj',
124  '.obj': 'obj',
125}
126
127
128class CMakeTargetType(object):
129  def __init__(self, command, modifier, property_modifier, is_linkable):
130    self.command = command
131    self.modifier = modifier
132    self.property_modifier = property_modifier
133    self.is_linkable = is_linkable
134CMakeTargetType.custom = CMakeTargetType('add_custom_target', 'SOURCES',
135                                         None, False)
136
137# See GetStringForOutputType in gn
138cmake_target_types = {
139  'unknown': CMakeTargetType.custom,
140  'group': CMakeTargetType.custom,
141  'executable': CMakeTargetType('add_executable', None, 'RUNTIME', True),
142  'loadable_module': CMakeTargetType('add_library', 'MODULE', 'LIBRARY', True),
143  'shared_library': CMakeTargetType('add_library', 'SHARED', 'LIBRARY', True),
144  'static_library': CMakeTargetType('add_library', 'STATIC', 'ARCHIVE', False),
145  'source_set': CMakeTargetType('add_library', 'OBJECT', None, False),
146  'copy': CMakeTargetType.custom,
147  'action': CMakeTargetType.custom,
148  'action_foreach': CMakeTargetType.custom,
149  'bundle_data': CMakeTargetType.custom,
150  'create_bundle': CMakeTargetType.custom,
151}
152
153
154def FindFirstOf(s, a):
155  return min(s.find(i) for i in a if i in s)
156
157
158class Project(object):
159  def __init__(self, project_json):
160    self.targets = project_json['targets']
161    build_settings = project_json['build_settings']
162    self.root_path = build_settings['root_path']
163    self.build_path = posixpath.join(self.root_path,
164                                     build_settings['build_dir'][2:])
165
166  def GetAbsolutePath(self, path):
167    if path.startswith("//"):
168      return self.root_path + "/" + path[2:]
169    else:
170      return path
171
172  def GetObjectSourceDependencies(self, gn_target_name, object_dependencies):
173    """All OBJECT libraries whose sources have not been absorbed."""
174    dependencies = self.targets[gn_target_name].get('deps', [])
175    for dependency in dependencies:
176      dependency_type = self.targets[dependency].get('type', None)
177      if dependency_type == 'source_set':
178        object_dependencies.add(dependency)
179      if dependency_type not in gn_target_types_that_absorb_objects:
180        self.GetObjectSourceDependencies(dependency, object_dependencies)
181
182  def GetObjectLibraryDependencies(self, gn_target_name, object_dependencies):
183    """All OBJECT libraries whose libraries have not been absorbed."""
184    dependencies = self.targets[gn_target_name].get('deps', [])
185    for dependency in dependencies:
186      dependency_type = self.targets[dependency].get('type', None)
187      if dependency_type == 'source_set':
188        object_dependencies.add(dependency)
189        self.GetObjectLibraryDependencies(dependency, object_dependencies)
190
191  def GetCMakeTargetName(self, gn_target_name):
192    # See <chromium>/src/tools/gn/label.cc#Resolve
193    # //base/test:test_support(//build/toolchain/win:msvc)
194    path_separator = FindFirstOf(gn_target_name, (':', '('))
195    location = None
196    name = None
197    toolchain = None
198    if not path_separator:
199      location = gn_target_name[2:]
200    else:
201      location = gn_target_name[2:path_separator]
202      toolchain_separator = gn_target_name.find('(', path_separator)
203      if toolchain_separator == -1:
204        name = gn_target_name[path_separator + 1:]
205      else:
206        if toolchain_separator > path_separator:
207          name = gn_target_name[path_separator + 1:toolchain_separator]
208        assert gn_target_name.endswith(')')
209        toolchain = gn_target_name[toolchain_separator + 1:-1]
210    assert location or name
211
212    cmake_target_name = None
213    if location.endswith('/' + name):
214      cmake_target_name = location
215    elif location:
216      cmake_target_name = location + '_' + name
217    else:
218      cmake_target_name = name
219    if toolchain:
220      cmake_target_name += '--' + toolchain
221    return CMakeTargetEscape(cmake_target_name)
222
223
224class Target(object):
225  def __init__(self, gn_target_name, project):
226    self.gn_name = gn_target_name
227    self.properties = project.targets[self.gn_name]
228    self.cmake_name = project.GetCMakeTargetName(self.gn_name)
229    self.gn_type = self.properties.get('type', None)
230    self.cmake_type = cmake_target_types.get(self.gn_type, None)
231
232
233def WriteAction(out, target, project, sources, synthetic_dependencies):
234  outputs = []
235  output_directories = set()
236  for output in target.properties.get('outputs', []):
237    output_abs_path = project.GetAbsolutePath(output)
238    outputs.append(output_abs_path)
239    output_directory = posixpath.dirname(output_abs_path)
240    if output_directory:
241      output_directories.add(output_directory)
242  outputs_name = '${target}__output'
243  SetVariableList(out, outputs_name, outputs)
244
245  out.write('add_custom_command(OUTPUT ')
246  WriteVariable(out, outputs_name)
247  out.write('\n')
248
249  if output_directories:
250    out.write('  COMMAND ${CMAKE_COMMAND} -E make_directory "')
251    out.write('" "'.join(map(CMakeStringEscape, output_directories)))
252    out.write('"\n')
253
254  script = target.properties['script']
255  arguments = target.properties['args']
256  out.write('  COMMAND python "')
257  out.write(CMakeStringEscape(project.GetAbsolutePath(script)))
258  out.write('"')
259  if arguments:
260    out.write('\n    "')
261    out.write('"\n    "'.join(map(CMakeStringEscape, arguments)))
262    out.write('"')
263  out.write('\n')
264
265  out.write('  DEPENDS ')
266  for sources_type_name in sources.values():
267    WriteVariable(out, sources_type_name, ' ')
268  out.write('\n')
269
270  #TODO: CMake 3.7 is introducing DEPFILE
271
272  out.write('  WORKING_DIRECTORY "')
273  out.write(CMakeStringEscape(project.build_path))
274  out.write('"\n')
275
276  out.write('  COMMENT "Action: ${target}"\n')
277
278  out.write('  VERBATIM)\n')
279
280  synthetic_dependencies.add(outputs_name)
281
282
283def ExpandPlaceholders(source, a):
284  source_dir, source_file_part = posixpath.split(source)
285  source_name_part, _ = posixpath.splitext(source_file_part)
286  #TODO: {{source_gen_dir}}, {{source_out_dir}}, {{response_file_name}}
287  return a.replace('{{source}}', source) \
288          .replace('{{source_file_part}}', source_file_part) \
289          .replace('{{source_name_part}}', source_name_part) \
290          .replace('{{source_dir}}', source_dir) \
291          .replace('{{source_root_relative_dir}}', source_dir)
292
293
294def WriteActionForEach(out, target, project, sources, synthetic_dependencies):
295  all_outputs = target.properties.get('outputs', [])
296  inputs = target.properties.get('sources', [])
297  # TODO: consider expanding 'output_patterns' instead.
298  outputs_per_input = len(all_outputs) / len(inputs)
299  for count, source in enumerate(inputs):
300    source_abs_path = project.GetAbsolutePath(source)
301
302    outputs = []
303    output_directories = set()
304    for output in all_outputs[outputs_per_input *  count:
305                              outputs_per_input * (count+1)]:
306      output_abs_path = project.GetAbsolutePath(output)
307      outputs.append(output_abs_path)
308      output_directory = posixpath.dirname(output_abs_path)
309      if output_directory:
310        output_directories.add(output_directory)
311    outputs_name = '${target}__output_' + str(count)
312    SetVariableList(out, outputs_name, outputs)
313
314    out.write('add_custom_command(OUTPUT ')
315    WriteVariable(out, outputs_name)
316    out.write('\n')
317
318    if output_directories:
319      out.write('  COMMAND ${CMAKE_COMMAND} -E make_directory "')
320      out.write('" "'.join(map(CMakeStringEscape, output_directories)))
321      out.write('"\n')
322
323    script = target.properties['script']
324    # TODO: need to expand {{xxx}} in arguments
325    arguments = target.properties['args']
326    out.write('  COMMAND python "')
327    out.write(CMakeStringEscape(project.GetAbsolutePath(script)))
328    out.write('"')
329    if arguments:
330      out.write('\n    "')
331      expand = functools.partial(ExpandPlaceholders, source_abs_path)
332      out.write('"\n    "'.join(map(CMakeStringEscape, map(expand,arguments))))
333      out.write('"')
334    out.write('\n')
335
336    out.write('  DEPENDS')
337    if 'input' in sources:
338      WriteVariable(out, sources['input'], ' ')
339    out.write(' "')
340    out.write(CMakeStringEscape(source_abs_path))
341    out.write('"\n')
342
343    #TODO: CMake 3.7 is introducing DEPFILE
344
345    out.write('  WORKING_DIRECTORY "')
346    out.write(CMakeStringEscape(project.build_path))
347    out.write('"\n')
348
349    out.write('  COMMENT "Action ${target} on ')
350    out.write(CMakeStringEscape(source_abs_path))
351    out.write('"\n')
352
353    out.write('  VERBATIM)\n')
354
355    synthetic_dependencies.add(outputs_name)
356
357
358def WriteCopy(out, target, project, sources, synthetic_dependencies):
359  inputs = target.properties.get('sources', [])
360  raw_outputs = target.properties.get('outputs', [])
361
362  # TODO: consider expanding 'output_patterns' instead.
363  outputs = []
364  for output in raw_outputs:
365    output_abs_path = project.GetAbsolutePath(output)
366    outputs.append(output_abs_path)
367  outputs_name = '${target}__output'
368  SetVariableList(out, outputs_name, outputs)
369
370  out.write('add_custom_command(OUTPUT ')
371  WriteVariable(out, outputs_name)
372  out.write('\n')
373
374  for src, dst in zip(inputs, outputs):
375    out.write('  COMMAND ${CMAKE_COMMAND} -E copy "')
376    out.write(CMakeStringEscape(project.GetAbsolutePath(src)))
377    out.write('" "')
378    out.write(CMakeStringEscape(dst))
379    out.write('"\n')
380
381  out.write('  DEPENDS ')
382  for sources_type_name in sources.values():
383    WriteVariable(out, sources_type_name, ' ')
384  out.write('\n')
385
386  out.write('  WORKING_DIRECTORY "')
387  out.write(CMakeStringEscape(project.build_path))
388  out.write('"\n')
389
390  out.write('  COMMENT "Copy ${target}"\n')
391
392  out.write('  VERBATIM)\n')
393
394  synthetic_dependencies.add(outputs_name)
395
396
397def WriteCompilerFlags(out, target, project, sources):
398  # Hack, set linker language to c if no c or cxx files present.
399  if not 'c' in sources and not 'cxx' in sources:
400    SetCurrentTargetProperty(out, 'LINKER_LANGUAGE', ['C'])
401
402  # Mark uncompiled sources as uncompiled.
403  if 'input' in sources:
404    SetFilesProperty(out, sources['input'], 'HEADER_FILE_ONLY', ('True',), '')
405  if 'other' in sources:
406    SetFilesProperty(out, sources['other'], 'HEADER_FILE_ONLY', ('True',), '')
407
408  # Mark object sources as linkable.
409  if 'obj' in sources:
410    SetFilesProperty(out, sources['obj'], 'EXTERNAL_OBJECT', ('True',), '')
411
412  # TODO: 'output_name', 'output_dir', 'output_extension'
413  # This includes using 'source_outputs' to direct compiler output.
414
415  # Includes
416  includes = target.properties.get('include_dirs', [])
417  if includes:
418    out.write('set_property(TARGET "${target}" ')
419    out.write('APPEND PROPERTY INCLUDE_DIRECTORIES')
420    for include_dir in includes:
421      out.write('\n  "')
422      out.write(project.GetAbsolutePath(include_dir))
423      out.write('"')
424    out.write(')\n')
425
426  # Defines
427  defines = target.properties.get('defines', [])
428  if defines:
429    SetCurrentTargetProperty(out, 'COMPILE_DEFINITIONS', defines, ';')
430
431  # Compile flags
432  # "arflags", "asmflags", "cflags",
433  # "cflags_c", "clfags_cc", "cflags_objc", "clfags_objcc"
434  # CMake does not have per target lang compile flags.
435  # TODO: $<$<COMPILE_LANGUAGE:CXX>:cflags_cc style generator expression.
436  #       http://public.kitware.com/Bug/view.php?id=14857
437  flags = []
438  flags.extend(target.properties.get('cflags', []))
439  cflags_asm = target.properties.get('asmflags', [])
440  cflags_c = target.properties.get('cflags_c', [])
441  cflags_cxx = target.properties.get('cflags_cc', [])
442  if 'c' in sources and not any(k in sources for k in ('asm', 'cxx')):
443    flags.extend(cflags_c)
444  elif 'cxx' in sources and not any(k in sources for k in ('asm', 'c')):
445    flags.extend(cflags_cxx)
446  else:
447    # TODO: This is broken, one cannot generally set properties on files,
448    # as other targets may require different properties on the same files.
449    if 'asm' in sources and cflags_asm:
450      SetFilesProperty(out, sources['asm'], 'COMPILE_FLAGS', cflags_asm, ' ')
451    if 'c' in sources and cflags_c:
452      SetFilesProperty(out, sources['c'], 'COMPILE_FLAGS', cflags_c, ' ')
453    if 'cxx' in sources and cflags_cxx:
454      SetFilesProperty(out, sources['cxx'], 'COMPILE_FLAGS', cflags_cxx, ' ')
455  if flags:
456    SetCurrentTargetProperty(out, 'COMPILE_FLAGS', flags, ' ')
457
458  # Linker flags
459  ldflags = target.properties.get('ldflags', [])
460  if ldflags:
461    SetCurrentTargetProperty(out, 'LINK_FLAGS', ldflags, ' ')
462
463
464gn_target_types_that_absorb_objects = (
465  'executable',
466  'loadable_module',
467  'shared_library',
468  'static_library'
469)
470
471
472def WriteSourceVariables(out, target, project):
473  # gn separates the sheep from the goats based on file extensions.
474  # A full separation is done here because of flag handing (see Compile flags).
475  source_types = {'cxx':[], 'c':[], 'asm':[],
476                  'obj':[], 'obj_target':[], 'input':[], 'other':[]}
477
478  # TODO .def files on Windows
479  for source in target.properties.get('sources', []):
480    _, ext = posixpath.splitext(source)
481    source_abs_path = project.GetAbsolutePath(source)
482    source_types[source_file_types.get(ext, 'other')].append(source_abs_path)
483
484  for input_path in target.properties.get('inputs', []):
485    input_abs_path = project.GetAbsolutePath(input_path)
486    source_types['input'].append(input_abs_path)
487
488  # OBJECT library dependencies need to be listed as sources.
489  # Only executables and non-OBJECT libraries may reference an OBJECT library.
490  # https://gitlab.kitware.com/cmake/cmake/issues/14778
491  if target.gn_type in gn_target_types_that_absorb_objects:
492    object_dependencies = set()
493    project.GetObjectSourceDependencies(target.gn_name, object_dependencies)
494    for dependency in object_dependencies:
495      cmake_dependency_name = project.GetCMakeTargetName(dependency)
496      obj_target_sources = '$<TARGET_OBJECTS:' + cmake_dependency_name + '>'
497      source_types['obj_target'].append(obj_target_sources)
498
499  sources = {}
500  for source_type, sources_of_type in source_types.items():
501    if sources_of_type:
502      sources[source_type] = '${target}__' + source_type + '_srcs'
503      SetVariableList(out, sources[source_type], sources_of_type)
504  return sources
505
506
507def WriteTarget(out, target, project):
508  out.write('\n#')
509  out.write(target.gn_name)
510  out.write('\n')
511
512  if target.cmake_type is None:
513    print ('Target %s has unknown target type %s, skipping.' %
514          (        target.gn_name,            target.gn_type ) )
515    return
516
517  SetVariable(out, 'target', target.cmake_name)
518
519  sources = WriteSourceVariables(out, target, project)
520
521  synthetic_dependencies = set()
522  if target.gn_type == 'action':
523    WriteAction(out, target, project, sources, synthetic_dependencies)
524  if target.gn_type == 'action_foreach':
525    WriteActionForEach(out, target, project, sources, synthetic_dependencies)
526  if target.gn_type == 'copy':
527    WriteCopy(out, target, project, sources, synthetic_dependencies)
528
529  out.write(target.cmake_type.command)
530  out.write('("${target}"')
531  if target.cmake_type.modifier is not None:
532    out.write(' ')
533    out.write(target.cmake_type.modifier)
534  for sources_type_name in sources.values():
535    WriteVariable(out, sources_type_name, ' ')
536  if synthetic_dependencies:
537    out.write(' DEPENDS')
538    for synthetic_dependencie in synthetic_dependencies:
539      WriteVariable(out, synthetic_dependencie, ' ')
540  out.write(')\n')
541
542  if target.cmake_type.command != 'add_custom_target':
543    WriteCompilerFlags(out, target, project, sources)
544
545  libraries = set()
546  nonlibraries = set()
547
548  dependencies = set(target.properties.get('deps', []))
549  # Transitive OBJECT libraries are in sources.
550  # Those sources are dependent on the OBJECT library dependencies.
551  # Those sources cannot bring in library dependencies.
552  object_dependencies = set()
553  if target.gn_type != 'source_set':
554    project.GetObjectLibraryDependencies(target.gn_name, object_dependencies)
555  for object_dependency in object_dependencies:
556    dependencies.update(project.targets.get(object_dependency).get('deps', []))
557
558  for dependency in dependencies:
559    gn_dependency_type = project.targets.get(dependency, {}).get('type', None)
560    cmake_dependency_type = cmake_target_types.get(gn_dependency_type, None)
561    cmake_dependency_name = project.GetCMakeTargetName(dependency)
562    if cmake_dependency_type.command != 'add_library':
563      nonlibraries.add(cmake_dependency_name)
564    elif cmake_dependency_type.modifier != 'OBJECT':
565      if target.cmake_type.is_linkable:
566        libraries.add(cmake_dependency_name)
567      else:
568        nonlibraries.add(cmake_dependency_name)
569
570  # Non-library dependencies.
571  if nonlibraries:
572    out.write('add_dependencies("${target}"')
573    for nonlibrary in nonlibraries:
574      out.write('\n  "')
575      out.write(nonlibrary)
576      out.write('"')
577    out.write(')\n')
578
579  # Non-OBJECT library dependencies.
580  external_libraries = target.properties.get('libs', [])
581  if target.cmake_type.is_linkable and (external_libraries or libraries):
582    library_dirs = target.properties.get('lib_dirs', [])
583    if library_dirs:
584      SetVariableList(out, '${target}__library_directories', library_dirs)
585
586    system_libraries = []
587    for external_library in external_libraries:
588      if '/' in external_library:
589        libraries.add(project.GetAbsolutePath(external_library))
590      else:
591        if external_library.endswith('.framework'):
592          external_library = external_library[:-len('.framework')]
593        system_library = 'library__' + external_library
594        if library_dirs:
595          system_library = system_library + '__for_${target}'
596        out.write('find_library("')
597        out.write(CMakeStringEscape(system_library))
598        out.write('" "')
599        out.write(CMakeStringEscape(external_library))
600        out.write('"')
601        if library_dirs:
602          out.write(' PATHS "')
603          WriteVariable(out, '${target}__library_directories')
604          out.write('"')
605        out.write(')\n')
606        system_libraries.append(system_library)
607    out.write('target_link_libraries("${target}"')
608    for library in libraries:
609      out.write('\n  "')
610      out.write(CMakeStringEscape(library))
611      out.write('"')
612    for system_library in system_libraries:
613      WriteVariable(out, system_library, '\n  "')
614      out.write('"')
615    out.write(')\n')
616
617
618def WriteProject(project):
619  out = open(posixpath.join(project.build_path, 'CMakeLists.txt'), 'w+')
620  out.write('# Generated by gn_to_cmake.py.\n')
621  out.write('cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)\n')
622  out.write('cmake_policy(VERSION 2.8.8)\n\n')
623
624  # Update the gn generated ninja build.
625  # If a build file has changed, this will update CMakeLists.ext if
626  # gn gen out/config --ide=json --json-ide-script=../../gn/gn_to_cmake.py
627  # style was used to create this config.
628  out.write('execute_process(COMMAND ninja -C "')
629  out.write(CMakeStringEscape(project.build_path))
630  out.write('" build.ninja)\n')
631
632  out.write('include(CMakeLists.ext)\n')
633  out.close()
634
635  out = open(posixpath.join(project.build_path, 'CMakeLists.ext'), 'w+')
636  out.write('# Generated by gn_to_cmake.py.\n')
637  out.write('cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)\n')
638  out.write('cmake_policy(VERSION 2.8.8)\n')
639
640  # The following appears to be as-yet undocumented.
641  # http://public.kitware.com/Bug/view.php?id=8392
642  out.write('enable_language(ASM)\n\n')
643  # ASM-ATT does not support .S files.
644  # output.write('enable_language(ASM-ATT)\n')
645
646  # Current issues with automatic re-generation:
647  # The gn generated build.ninja target uses build.ninja.d
648  #   but build.ninja.d does not contain the ide or gn.
649  # Currently the ide is not run if the project.json file is not changed
650  #   but the ide needs to be run anyway if it has itself changed.
651  #   This can be worked around by deleting the project.json file.
652  out.write('file(READ "')
653  gn_deps_file = posixpath.join(project.build_path, 'build.ninja.d')
654  out.write(CMakeStringEscape(gn_deps_file))
655  out.write('" "gn_deps_string" OFFSET ')
656  out.write(str(len('build.ninja: ')))
657  out.write(')\n')
658  # One would think this would need to worry about escaped spaces
659  # but gn doesn't escape spaces here (it generates invalid .d files).
660  out.write('string(REPLACE " " ";" "gn_deps" ${gn_deps_string})\n')
661  out.write('foreach("gn_dep" ${gn_deps})\n')
662  out.write('  configure_file(${gn_dep} "CMakeLists.devnull" COPYONLY)\n')
663  out.write('endforeach("gn_dep")\n')
664
665  for target_name in project.targets.keys():
666    out.write('\n')
667    WriteTarget(out, Target(target_name, project), project)
668
669
670def main():
671  if len(sys.argv) != 2:
672    print('Usage: ' + sys.argv[0] + ' <json_file_name>')
673    exit(1)
674
675  json_path = sys.argv[1]
676  project = None
677  with open(json_path, 'r') as json_file:
678    project = json.loads(json_file.read())
679
680  WriteProject(Project(project))
681
682
683if __name__ == "__main__":
684  main()
685