1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
# Copyright 2015 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
# Autocompletion config for YouCompleteMe in V8.
#
# USAGE:
#
# 1. Install YCM [https://github.com/Valloric/YouCompleteMe]
# (Googlers should check out [go/ycm])
#
# 2. Profit
#
#
# Usage notes:
#
# * You must use ninja & clang to build V8.
#
# * You must have run gyp_v8 and built V8 recently.
#
#
# Hacking notes:
#
# * The purpose of this script is to construct an accurate enough command line
# for YCM to pass to clang so it can build and extract the symbols.
#
# * Right now, we only pull the -I and -D flags. That seems to be sufficient
# for everything I've used it for.
#
# * That whole ninja & clang thing? We could support other configs if someone
# were willing to write the correct commands and a parser.
#
# * This has only been tested on gTrusty.
import os
import os.path
import subprocess
import sys
# Flags from YCM's default config.
flags = [
'-DUSE_CLANG_COMPLETER',
'-x',
'c++',
]
def PathExists(*args):
return os.path.exists(os.path.join(*args))
def FindV8SrcFromFilename(filename):
"""Searches for the root of the V8 checkout.
Simply checks parent directories until it finds .gclient and v8/.
Args:
filename: (String) Path to source file being edited.
Returns:
(String) Path of 'v8/', or None if unable to find.
"""
curdir = os.path.normpath(os.path.dirname(filename))
while not (PathExists(curdir, 'v8') and PathExists(curdir, 'v8', 'DEPS')
and (PathExists(curdir, '.gclient')
or PathExists(curdir, 'v8', '.git'))):
nextdir = os.path.normpath(os.path.join(curdir, '..'))
if nextdir == curdir:
return None
curdir = nextdir
return os.path.join(curdir, 'v8')
def GetClangCommandFromNinjaForFilename(v8_root, filename):
"""Returns the command line to build |filename|.
Asks ninja how it would build the source file. If the specified file is a
header, tries to find its companion source file first.
Args:
v8_root: (String) Path to v8/.
filename: (String) Path to source file being edited.
Returns:
(List of Strings) Command line arguments for clang.
"""
if not v8_root:
return []
# Generally, everyone benefits from including V8's root, because all of
# V8's includes are relative to that.
v8_flags = ['-I' + os.path.join(v8_root)]
# Version of Clang used to compile V8 can be newer then version of
# libclang that YCM uses for completion. So it's possible that YCM's libclang
# doesn't know about some used warning options, which causes compilation
# warnings (and errors, because of '-Werror');
v8_flags.append('-Wno-unknown-warning-option')
# Header files can't be built. Instead, try to match a header file to its
# corresponding source file.
if filename.endswith('.h'):
base = filename[:-6] if filename.endswith('-inl.h') else filename[:-2]
for alternate in [base + e for e in ['.cc', '.cpp']]:
if os.path.exists(alternate):
filename = alternate
break
else:
# If this is a standalone .h file with no source, we ask ninja for the
# compile flags of some generic cc file ('src/utils/utils.cc'). This
# should contain most/all of the interesting flags for other targets too.
filename = os.path.join(v8_root, 'src', 'utils', 'utils.cc')
sys.path.append(os.path.join(v8_root, 'tools', 'vim'))
from ninja_output import GetNinjaOutputDirectory
out_dir = os.path.realpath(GetNinjaOutputDirectory(v8_root))
# Ninja needs the path to the source file relative to the output build
# directory.
rel_filename = os.path.relpath(os.path.realpath(filename), out_dir)
# Ask ninja how it would build our source file.
p = subprocess.Popen(['ninja', '-v', '-C', out_dir, '-t',
'commands', rel_filename + '^'],
stdout=subprocess.PIPE)
stdout, stderr = p.communicate()
if p.returncode:
return v8_flags
# Ninja might execute several commands to build something. We want the last
# clang command.
clang_line = None
for line in reversed(stdout.splitlines()):
try:
line = line.decode('utf-8')
except UnicodeDecodeError:
continue
if 'clang' in line:
clang_line = line
break
else:
return v8_flags
# Parse flags that are important for YCM's purposes.
for flag in clang_line.split(' '):
if flag.startswith('-I'):
v8_flags.append(MakeIncludePathAbsolute(flag, "-I", out_dir))
elif flag.startswith('-isystem'):
v8_flags.append(MakeIncludePathAbsolute(flag, "-isystem", out_dir))
elif flag.startswith('-std') or flag.startswith(
'-pthread') or flag.startswith('-no'):
v8_flags.append(flag)
elif flag.startswith('-') and flag[1] in 'DWFfmgOX':
v8_flags.append(flag)
return v8_flags
def MakeIncludePathAbsolute(flag, prefix, out_dir):
# Relative paths need to be resolved, because they're relative to the
# output dir, not the source.
if flag[len(prefix)] == '/':
return flag
else:
abs_path = os.path.normpath(os.path.join(out_dir, flag[len(prefix):]))
return prefix + abs_path
def FlagsForFile(filename):
"""This is the main entry point for YCM. Its interface is fixed.
Args:
filename: (String) Path to source file being edited.
Returns:
(Dictionary)
'flags': (List of Strings) Command line flags.
'do_cache': (Boolean) True if the result should be cached.
"""
v8_root = FindV8SrcFromFilename(filename)
v8_flags = GetClangCommandFromNinjaForFilename(v8_root, filename)
final_flags = flags + v8_flags
return {
'flags': final_flags,
'do_cache': True
}
def Settings(**kwargs):
if kwargs['language'] == 'cfamily':
return FlagsForFile(kwargs['filename'])
return {}
|
