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', True),
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    abs_src_path = CMakeStringEscape(project.GetAbsolutePath(src))
376    # CMake distinguishes between copying files and copying directories but
377    # gn does not. We assume if the src has a period in its name then it is
378    # a file and otherwise a directory.
379    if "." in os.path.basename(abs_src_path):
380      out.write('  COMMAND ${CMAKE_COMMAND} -E copy "')
381    else:
382      out.write('  COMMAND ${CMAKE_COMMAND} -E copy_directory "')
383    out.write(abs_src_path)
384    out.write('" "')
385    out.write(CMakeStringEscape(dst))
386    out.write('"\n')
387
388  out.write('  DEPENDS ')
389  for sources_type_name in sources.values():
390    WriteVariable(out, sources_type_name, ' ')
391  out.write('\n')
392
393  out.write('  WORKING_DIRECTORY "')
394  out.write(CMakeStringEscape(project.build_path))
395  out.write('"\n')
396
397  out.write('  COMMENT "Copy ${target}"\n')
398
399  out.write('  VERBATIM)\n')
400
401  synthetic_dependencies.add(outputs_name)
402
403
404def WriteCompilerFlags(out, target, project, sources):
405  # Hack, set linker language to c if no c or cxx files present.
406  if not 'c' in sources and not 'cxx' in sources:
407    SetCurrentTargetProperty(out, 'LINKER_LANGUAGE', ['C'])
408
409  # Mark uncompiled sources as uncompiled.
410  if 'input' in sources:
411    SetFilesProperty(out, sources['input'], 'HEADER_FILE_ONLY', ('True',), '')
412  if 'other' in sources:
413    SetFilesProperty(out, sources['other'], 'HEADER_FILE_ONLY', ('True',), '')
414
415  # Mark object sources as linkable.
416  if 'obj' in sources:
417    SetFilesProperty(out, sources['obj'], 'EXTERNAL_OBJECT', ('True',), '')
418
419  # TODO: 'output_name', 'output_dir', 'output_extension'
420  # This includes using 'source_outputs' to direct compiler output.
421
422  # Includes
423  includes = target.properties.get('include_dirs', [])
424  if includes:
425    out.write('set_property(TARGET "${target}" ')
426    out.write('APPEND PROPERTY INCLUDE_DIRECTORIES')
427    for include_dir in includes:
428      out.write('\n  "')
429      out.write(project.GetAbsolutePath(include_dir))
430      out.write('"')
431    out.write(')\n')
432
433  # Defines
434  defines = target.properties.get('defines', [])
435  if defines:
436    SetCurrentTargetProperty(out, 'COMPILE_DEFINITIONS', defines, ';')
437
438  # Compile flags
439  # "arflags", "asmflags", "cflags",
440  # "cflags_c", "clfags_cc", "cflags_objc", "clfags_objcc"
441  # CMake does not have per target lang compile flags.
442  # TODO: $<$<COMPILE_LANGUAGE:CXX>:cflags_cc style generator expression.
443  #       http://public.kitware.com/Bug/view.php?id=14857
444  flags = []
445  flags.extend(target.properties.get('cflags', []))
446  cflags_asm = target.properties.get('asmflags', [])
447  cflags_c = target.properties.get('cflags_c', [])
448  cflags_cxx = target.properties.get('cflags_cc', [])
449  if 'c' in sources and not any(k in sources for k in ('asm', 'cxx')):
450    flags.extend(cflags_c)
451  elif 'cxx' in sources and not any(k in sources for k in ('asm', 'c')):
452    flags.extend(cflags_cxx)
453  else:
454    # TODO: This is broken, one cannot generally set properties on files,
455    # as other targets may require different properties on the same files.
456    if 'asm' in sources and cflags_asm:
457      SetFilesProperty(out, sources['asm'], 'COMPILE_FLAGS', cflags_asm, ' ')
458    if 'c' in sources and cflags_c:
459      SetFilesProperty(out, sources['c'], 'COMPILE_FLAGS', cflags_c, ' ')
460    if 'cxx' in sources and cflags_cxx:
461      SetFilesProperty(out, sources['cxx'], 'COMPILE_FLAGS', cflags_cxx, ' ')
462  if flags:
463    SetCurrentTargetProperty(out, 'COMPILE_FLAGS', flags, ' ')
464
465  # Linker flags
466  ldflags = target.properties.get('ldflags', [])
467  if ldflags:
468    SetCurrentTargetProperty(out, 'LINK_FLAGS', ldflags, ' ')
469
470
471gn_target_types_that_absorb_objects = (
472  'executable',
473  'loadable_module',
474  'shared_library',
475  'static_library'
476)
477
478
479def WriteSourceVariables(out, target, project):
480  # gn separates the sheep from the goats based on file extensions.
481  # A full separation is done here because of flag handing (see Compile flags).
482  source_types = {'cxx':[], 'c':[], 'asm':[],
483                  'obj':[], 'obj_target':[], 'input':[], 'other':[]}
484
485  all_sources = target.properties.get('sources', [])
486
487  # As of cmake 3.11 add_library must have sources. If there are
488  # no sources, add empty.cpp as the file to compile.
489  if len(all_sources) == 0:
490    all_sources.append(posixpath.join(project.build_path, 'empty.cpp'))
491
492  # TODO .def files on Windows
493  for source in all_sources:
494    _, ext = posixpath.splitext(source)
495    source_abs_path = project.GetAbsolutePath(source)
496    source_types[source_file_types.get(ext, 'other')].append(source_abs_path)
497
498  for input_path in target.properties.get('inputs', []):
499    input_abs_path = project.GetAbsolutePath(input_path)
500    source_types['input'].append(input_abs_path)
501
502  # OBJECT library dependencies need to be listed as sources.
503  # Only executables and non-OBJECT libraries may reference an OBJECT library.
504  # https://gitlab.kitware.com/cmake/cmake/issues/14778
505  if target.gn_type in gn_target_types_that_absorb_objects:
506    object_dependencies = set()
507    project.GetObjectSourceDependencies(target.gn_name, object_dependencies)
508    for dependency in object_dependencies:
509      cmake_dependency_name = project.GetCMakeTargetName(dependency)
510      obj_target_sources = '$<TARGET_OBJECTS:' + cmake_dependency_name + '>'
511      source_types['obj_target'].append(obj_target_sources)
512
513  sources = {}
514  for source_type, sources_of_type in source_types.items():
515    if sources_of_type:
516      sources[source_type] = '${target}__' + source_type + '_srcs'
517      SetVariableList(out, sources[source_type], sources_of_type)
518  return sources
519
520
521def WriteTarget(out, target, project):
522  out.write('\n#')
523  out.write(target.gn_name)
524  out.write('\n')
525
526  if target.cmake_type is None:
527    print ('Target %s has unknown target type %s, skipping.' %
528          (        target.gn_name,            target.gn_type ) )
529    return
530
531  SetVariable(out, 'target', target.cmake_name)
532
533  sources = WriteSourceVariables(out, target, project)
534
535  synthetic_dependencies = set()
536  if target.gn_type == 'action':
537    WriteAction(out, target, project, sources, synthetic_dependencies)
538  if target.gn_type == 'action_foreach':
539    WriteActionForEach(out, target, project, sources, synthetic_dependencies)
540  if target.gn_type == 'copy':
541    WriteCopy(out, target, project, sources, synthetic_dependencies)
542
543  out.write(target.cmake_type.command)
544  out.write('("${target}"')
545  if target.cmake_type.modifier is not None:
546    out.write(' ')
547    out.write(target.cmake_type.modifier)
548  for sources_type_name in sources.values():
549    WriteVariable(out, sources_type_name, ' ')
550  if synthetic_dependencies:
551    out.write(' DEPENDS')
552    for synthetic_dependencie in synthetic_dependencies:
553      WriteVariable(out, synthetic_dependencie, ' ')
554  out.write(')\n')
555
556  if target.cmake_type.command != 'add_custom_target':
557    WriteCompilerFlags(out, target, project, sources)
558
559  libraries = set()
560  nonlibraries = set()
561
562  dependencies = set(target.properties.get('deps', []))
563  # Transitive OBJECT libraries are in sources.
564  # Those sources are dependent on the OBJECT library dependencies.
565  # Those sources cannot bring in library dependencies.
566  object_dependencies = set()
567  if target.gn_type != 'source_set':
568    project.GetObjectLibraryDependencies(target.gn_name, object_dependencies)
569  for object_dependency in object_dependencies:
570    dependencies.update(project.targets.get(object_dependency).get('deps', []))
571
572  for dependency in dependencies:
573    gn_dependency_type = project.targets.get(dependency, {}).get('type', None)
574    cmake_dependency_type = cmake_target_types.get(gn_dependency_type, None)
575    cmake_dependency_name = project.GetCMakeTargetName(dependency)
576    if cmake_dependency_type.command != 'add_library':
577      nonlibraries.add(cmake_dependency_name)
578    elif cmake_dependency_type.modifier != 'OBJECT':
579      if target.cmake_type.is_linkable:
580        libraries.add(cmake_dependency_name)
581      else:
582        nonlibraries.add(cmake_dependency_name)
583
584  # Non-library dependencies.
585  if nonlibraries:
586    out.write('add_dependencies("${target}"')
587    for nonlibrary in nonlibraries:
588      out.write('\n  "')
589      out.write(nonlibrary)
590      out.write('"')
591    out.write(')\n')
592
593  # Non-OBJECT library dependencies.
594  external_libraries = target.properties.get('libs', [])
595  if target.cmake_type.is_linkable and (external_libraries or libraries):
596    library_dirs = target.properties.get('lib_dirs', [])
597    if library_dirs:
598      SetVariableList(out, '${target}__library_directories', library_dirs)
599
600    system_libraries = []
601    for external_library in external_libraries:
602      if '/' in external_library:
603        libraries.add(project.GetAbsolutePath(external_library))
604      else:
605        if external_library.endswith('.framework'):
606          external_library = external_library[:-len('.framework')]
607        system_library = 'library__' + external_library
608        if library_dirs:
609          system_library = system_library + '__for_${target}'
610        out.write('find_library("')
611        out.write(CMakeStringEscape(system_library))
612        out.write('" "')
613        out.write(CMakeStringEscape(external_library))
614        out.write('"')
615        if library_dirs:
616          out.write(' PATHS "')
617          WriteVariable(out, '${target}__library_directories')
618          out.write('"')
619        out.write(')\n')
620        system_libraries.append(system_library)
621    out.write('target_link_libraries("${target}"')
622    for library in libraries:
623      out.write('\n  "')
624      out.write(CMakeStringEscape(library))
625      out.write('"')
626    for system_library in system_libraries:
627      WriteVariable(out, system_library, '\n  "')
628      out.write('"')
629    out.write(')\n')
630
631
632def WriteProject(project):
633  out = open(posixpath.join(project.build_path, 'CMakeLists.txt'), 'w+')
634  extName = posixpath.join(project.build_path, 'CMakeLists.ext')
635  out.write('# Generated by gn_to_cmake.py.\n')
636  out.write('cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)\n')
637  out.write('cmake_policy(VERSION 2.8.8)\n\n')
638
639  out.write('file(WRITE "')
640  out.write(CMakeStringEscape(posixpath.join(project.build_path, "empty.cpp")))
641  out.write('")\n')
642
643  # Update the gn generated ninja build.
644  # If a build file has changed, this will update CMakeLists.ext if
645  # gn gen out/config --ide=json --json-ide-script=../../gn/gn_to_cmake.py
646  # style was used to create this config.
647  out.write('execute_process(COMMAND\n')
648  out.write('  ninja -C "')
649  out.write(CMakeStringEscape(project.build_path))
650  out.write('" build.ninja\n')
651  out.write('  RESULT_VARIABLE ninja_result)\n')
652  out.write('if (ninja_result)\n')
653  out.write('  message(WARNING ')
654  out.write('"Regeneration failed running ninja: ${ninja_result}")\n')
655  out.write('endif()\n')
656
657  out.write('include("')
658  out.write(CMakeStringEscape(extName))
659  out.write('")\n')
660  out.close()
661
662  out = open(extName, 'w+')
663  out.write('# Generated by gn_to_cmake.py.\n')
664  out.write('cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)\n')
665  out.write('cmake_policy(VERSION 2.8.8)\n')
666
667  # The following appears to be as-yet undocumented.
668  # http://public.kitware.com/Bug/view.php?id=8392
669  out.write('enable_language(ASM)\n\n')
670  # ASM-ATT does not support .S files.
671  # output.write('enable_language(ASM-ATT)\n')
672
673  # Current issues with automatic re-generation:
674  # The gn generated build.ninja target uses build.ninja.d
675  #   but build.ninja.d does not contain the ide or gn.
676  # Currently the ide is not run if the project.json file is not changed
677  #   but the ide needs to be run anyway if it has itself changed.
678  #   This can be worked around by deleting the project.json file.
679  out.write('file(READ "')
680  gn_deps_file = posixpath.join(project.build_path, 'build.ninja.d')
681  out.write(CMakeStringEscape(gn_deps_file))
682  out.write('" "gn_deps_string" OFFSET ')
683  out.write(str(len('build.ninja: ')))
684  out.write(')\n')
685  # One would think this would need to worry about escaped spaces
686  # but gn doesn't escape spaces here (it generates invalid .d files).
687  out.write('string(REPLACE " " ";" "gn_deps" ${gn_deps_string})\n')
688  out.write('foreach("gn_dep" ${gn_deps})\n')
689  out.write('  configure_file("')
690  out.write(CMakeStringEscape(project.build_path))
691  out.write('${gn_dep}" "CMakeLists.devnull" COPYONLY)\n')
692  out.write('endforeach("gn_dep")\n')
693
694  out.write('list(APPEND other_deps "')
695  out.write(CMakeStringEscape(os.path.abspath(__file__)))
696  out.write('")\n')
697  out.write('foreach("other_dep" ${other_deps})\n')
698  out.write('  configure_file("${other_dep}" "CMakeLists.devnull" COPYONLY)\n')
699  out.write('endforeach("other_dep")\n')
700
701  for target_name in project.targets.keys():
702    out.write('\n')
703    WriteTarget(out, Target(target_name, project), project)
704
705
706def main():
707  if len(sys.argv) != 2:
708    print('Usage: ' + sys.argv[0] + ' <json_file_name>')
709    exit(1)
710
711  json_path = sys.argv[1]
712  project = None
713  with open(json_path, 'r') as json_file:
714    project = json.loads(json_file.read())
715
716  WriteProject(Project(project))
717
718
719if __name__ == "__main__":
720  main()
721