def test_create_fail():
"""Check we fail loading a database with an assertion"""
path = os.path.dirname(__file__)
try:
CompilationDatabase.fromDirectory(path)
except CompilationDatabaseError as e:
assert e.cdb_error == CompilationDatabaseError.ERROR_CANNOTLOADDATABASE
else:
assert False
def test_compilationDB_references(self):
"""Ensure CompilationsCommands are independent of the database"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
del cdb
gc.collect()
workingdir = cmds[0].directory
def test_2_compilecommand():
"""Check file with 2 compile commands"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands("/home/john.doe/MyProject/project2.cpp")
assert len(cmds) == 2
expected = [
{
"wd": "/home/john.doe/MyProjectA",
"line": ["clang++", "-o", "project2.o", "-c", "/home/john.doe/MyProject/project2.cpp"],
},
{
"wd": "/home/john.doe/MyProjectB",
"line": [
"clang++",
"-DFEATURE=1",
"-o",
"project2-feature.o",
"-c",
"/home/john.doe/MyProject/project2.cpp",
],
},
]
for i in range(len(cmds)):
assert cmds[i].directory == expected[i]["wd"]
for arg, exp in zip(cmds[i].arguments, expected[i]["line"]):
assert arg == exp
def test_all_compilecommand(self):
"""Check we get all results from the db"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getAllCompileCommands()
self.assertEqual(len(cmds), 3)
expected = [
{ 'wd': '/home/john.doe/MyProject',
'file': '/home/john.doe/MyProject/project.cpp',
'line': ['clang++', '-o', 'project.o', '-c',
'/home/john.doe/MyProject/project.cpp']},
{ 'wd': '/home/john.doe/MyProjectA',
'file': '/home/john.doe/MyProject/project2.cpp',
'line': ['clang++', '-o', 'project2.o', '-c',
'/home/john.doe/MyProject/project2.cpp']},
{ 'wd': '/home/john.doe/MyProjectB',
'file': '/home/john.doe/MyProject/project2.cpp',
'line': ['clang++', '-DFEATURE=1', '-o', 'project2-feature.o', '-c',
'/home/john.doe/MyProject/project2.cpp']},
]
for i in range(len(cmds)):
self.assertEqual(cmds[i].directory, expected[i]['wd'])
self.assertEqual(cmds[i].filename, expected[i]['file'])
for arg, exp in zip(cmds[i].arguments, expected[i]['line']):
self.assertEqual(arg, exp)
def test_2_compilecommand(self):
"""Check file with 2 compile commands"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project2.cpp')
self.assertEqual(len(cmds), 2)
expected = [{
'wd':
'/home/john.doe/MyProjectA',
'line': [
'clang++', '--driver-mode=g++', '-o', 'project2.o', '-c',
'/home/john.doe/MyProject/project2.cpp'
]
}, {
'wd':
'/home/john.doe/MyProjectB',
'line': [
'clang++', '--driver-mode=g++', '-DFEATURE=1', '-o',
'project2-feature.o', '-c',
'/home/john.doe/MyProject/project2.cpp'
]
}]
for i in range(len(cmds)):
self.assertEqual(cmds[i].directory, expected[i]['wd'])
for arg, exp in zip(cmds[i].arguments, expected[i]['line']):
self.assertEqual(arg, exp)
def test_compilationDB_references(self):
"""Ensure CompilationsCommands are independent of the database"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
del cdb
gc.collect()
workingdir = cmds[0].directory
def test_compilecommand_iterator_stops(self):
"""Check that iterator stops after the correct number of elements"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
count = 0
for cmd in cdb.getCompileCommands('/home/john.doe/MyProject/project2.cpp'):
count += 1
self.assertLessEqual(count, 2)
def test_all_compilecommand(self):
"""Check we get all results from the db"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getAllCompileCommands()
self.assertEqual(len(cmds), 3)
expected = [
{ 'wd': '/home/john.doe/MyProject',
'file': '/home/john.doe/MyProject/project.cpp',
'line': ['clang++', '--driver-mode=g++', '-o', 'project.o', '-c',
'/home/john.doe/MyProject/project.cpp']},
{ 'wd': '/home/john.doe/MyProjectA',
'file': '/home/john.doe/MyProject/project2.cpp',
'line': ['clang++', '--driver-mode=g++', '-o', 'project2.o', '-c',
'/home/john.doe/MyProject/project2.cpp']},
{ 'wd': '/home/john.doe/MyProjectB',
'file': '/home/john.doe/MyProject/project2.cpp',
'line': ['clang++', '--driver-mode=g++', '-DFEATURE=1', '-o',
'project2-feature.o', '-c',
'/home/john.doe/MyProject/project2.cpp']},
]
for i in range(len(cmds)):
self.assertEqual(cmds[i].directory, expected[i]['wd'])
self.assertEqual(cmds[i].filename, expected[i]['file'])
for arg, exp in zip(cmds[i].arguments, expected[i]['line']):
self.assertEqual(arg, exp)
def test_2_compilecommand():
"""Check file with 2 compile commands"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project2.cpp')
assert len(cmds) == 2
expected = [
{
'wd': b'/home/john.doe/MyProjectA',
'line': [
b'clang++',
b'-o', b'project2.o',
b'-c', b'/home/john.doe/MyProject/project2.cpp'
]
},
{
'wd': b'/home/john.doe/MyProjectB',
'line': [
b'clang++',
b'-DFEATURE=1',
b'-o', b'project2-feature.o',
b'-c', b'/home/john.doe/MyProject/project2.cpp'
]
}
]
for i in range(len(cmds)):
assert cmds[i].directory == expected[i]['wd']
for arg, exp in zip(cmds[i].arguments, expected[i]['line']):
assert arg == exp
def test_compilecommand_iterator_stops():
"""Check that iterator stops after the correct number of elements"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
count = 0
for cmd in cdb.getCompileCommands("/home/john.doe/MyProject/project2.cpp"):
count += 1
assert count <= 2
def test_all_compilecommand():
"""Check we get all results from the db"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getAllCompileCommands()
assert len(cmds) == 3
expected = [{
'wd':
'/home/john.doe/MyProjectA',
'line': [
'clang++', '-o', 'project2.o', '-c',
'/home/john.doe/MyProject/project2.cpp'
]
}, {
'wd':
'/home/john.doe/MyProjectB',
'line': [
'clang++', '-DFEATURE=1', '-o', 'project2-feature.o', '-c',
'/home/john.doe/MyProject/project2.cpp'
]
}, {
'wd':
'/home/john.doe/MyProject',
'line': [
'clang++', '-o', 'project.o', '-c',
'/home/john.doe/MyProject/project.cpp'
]
}]
for i in range(len(cmds)):
assert cmds[i].directory == expected[i]['wd']
for arg, exp in zip(cmds[i].arguments, expected[i]['line']):
assert arg == exp
def test_compilecommand_iterator_stops(self):
"""Check that iterator stops after the correct number of elements"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
count = 0
for cmd in cdb.getCompileCommands('/home/john.doe/MyProject/project2.cpp'):
count += 1
self.assertLessEqual(count, 2)
def test_create_fail(self):
"""Check we fail loading a database with an assertion"""
path = os.path.dirname(__file__)
with self.assertRaises(CompilationDatabaseError) as cm:
cdb = CompilationDatabase.fromDirectory(path)
e = cm.exception
self.assertEqual(e.cdb_error,
CompilationDatabaseError.ERROR_CANNOTLOADDATABASE)
def test_create_fail(self):
"""Check we fail loading a database with an assertion"""
path = os.path.dirname(__file__)
with self.assertRaises(CompilationDatabaseError) as cm:
cdb = CompilationDatabase.fromDirectory(path)
e = cm.exception
self.assertEqual(e.cdb_error,
CompilationDatabaseError.ERROR_CANNOTLOADDATABASE)
def initClangComplete(clang_complete_flags, clang_compilation_database,
library_path):
global index
debug = int(vim.eval("g:clang_debug")) == 1
quiet = int(vim.eval("g:clang_quiet")) == 1
if library_path:
if os.path.isdir(library_path):
Config.set_library_path(library_path)
else:
Config.set_library_file(library_path)
Config.set_compatibility_check(False)
try:
index = Index.create()
except Exception as e:
if quiet:
return 0
if library_path:
suggestion = "Are you sure '%s' contains libclang?" % library_path
else:
suggestion = "Consider setting g:clang_library_path."
if debug:
exception_msg = str(e)
else:
exception_msg = ''
print('''Loading libclang failed, completion won't be available. %s
%s
''' % (suggestion, exception_msg))
return 0
global builtinHeaderPath
builtinHeaderPath = None
if not canFindBuiltinHeaders(index):
builtinHeaderPath = getBuiltinHeaderPath(library_path)
if not builtinHeaderPath:
print("WARNING: libclang can not find the builtin includes.")
print(" This will cause slow code completion.")
print(" Please report the problem.")
global translationUnits
translationUnits = dict()
global complete_flags
complete_flags = int(clang_complete_flags)
global compilation_database
if clang_compilation_database != '':
compilation_database = CompilationDatabase.fromDirectory(
clang_compilation_database)
else:
compilation_database = None
global libclangLock
libclangLock = threading.Lock()
return 1
def test_1_compilecommand():
"""Check file with single compile command"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands("/home/john.doe/MyProject/project.cpp")
assert len(cmds) == 1
assert cmds[0].directory == "/home/john.doe/MyProject"
expected = ["clang++", "-o", "project.o", "-c", "/home/john.doe/MyProject/project.cpp"]
for arg, exp in zip(cmds[0].arguments, expected):
assert arg == exp
def test_compilationCommands_references(self):
"""Ensure CompilationsCommand keeps a reference to CompilationCommands"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
del cdb
cmd0 = cmds[0]
del cmds
gc.collect()
workingdir = cmd0.directory
def initClangComplete(clang_complete_flags, clang_compilation_database,
library_path):
global index
debug = int(vim.eval("g:clang_debug")) == 1
quiet = int(vim.eval("g:clang_quiet")) == 1
if library_path:
if os.path.isdir(library_path):
Config.set_library_path(library_path)
else:
Config.set_library_file(library_path)
Config.set_compatibility_check(False)
try:
index = Index.create()
except Exception as e:
if quiet:
return 0
if library_path:
suggestion = "Are you sure '%s' contains libclang?" % library_path
else:
suggestion = "Consider setting g:clang_library_path."
if debug:
exception_msg = str(e)
else:
exception_msg = ''
print('''Loading libclang failed, completion won't be available. %s
%s
''' % (suggestion, exception_msg))
return 0
global builtinHeaderPath
builtinHeaderPath = None
if not canFindBuiltinHeaders(index):
builtinHeaderPath = getBuiltinHeaderPath(library_path)
if not builtinHeaderPath:
print("WARNING: libclang can not find the builtin includes.")
print(" This will cause slow code completion.")
print(" Please report the problem.")
global translationUnits
translationUnits = dict()
global complete_flags
complete_flags = int(clang_complete_flags)
global compilation_database
if clang_compilation_database != '':
compilation_database = CompilationDatabase.fromDirectory(clang_compilation_database)
else:
compilation_database = None
global libclangLock
libclangLock = threading.Lock()
return 1
def test_compilationCommands_references(self):
"""Ensure CompilationsCommand keeps a reference to CompilationCommands"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
del cdb
cmd0 = cmds[0]
del cmds
gc.collect()
workingdir = cmd0.directory
def test_1_compilecommand():
"""Check file with single compile command"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
assert len(cmds) == 1
assert cmds[0].directory == '/home/john.doe/MyProject'
expected = [ 'clang++', '-o', 'project.o', '-c',
'/home/john.doe/MyProject/project.cpp']
for arg, exp in zip(cmds[0].arguments, expected):
assert arg == exp
def test_1_compilecommand():
"""Check file with single compile command"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
assert len(cmds) == 1
assert cmds[0].directory == '/home/john.doe/MyProject'
expected = [ 'clang++', '-o', 'project.o', '-c',
'/home/john.doe/MyProject/project.cpp']
for arg, exp in zip(cmds[0].arguments, expected):
assert arg.spelling == exp
def __init__(self, task_queue, max_contexts_num, max_path_len,
max_subtokens_num, max_ast_depth, input_path, output_path):
multiprocessing.Process.__init__(self)
self.task_queue = task_queue
self.parser = AstParser(max_contexts_num, max_path_len,
max_subtokens_num, max_ast_depth, output_path)
try:
self.compdb = CompilationDatabase.fromDirectory(input_path)
except CompilationDatabaseError:
self.compdb = None
def test_1_compilecommand(self):
"""Check file with single compile command"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
file = '/home/john.doe/MyProject/project.cpp'
cmds = cdb.getCompileCommands(file)
self.assertEqual(len(cmds), 1)
self.assertEqual(cmds[0].directory, os.path.dirname(file))
self.assertEqual(cmds[0].filename, file)
expected = [ 'clang++', '-o', 'project.o', '-c',
'/home/john.doe/MyProject/project.cpp']
for arg, exp in zip(cmds[0].arguments, expected):
self.assertEqual(arg, exp)
def test_1_compilecommand(self):
"""Check file with single compile command"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
file = '/home/john.doe/MyProject/project.cpp'
cmds = cdb.getCompileCommands(file)
self.assertEqual(len(cmds), 1)
self.assertEqual(cmds[0].directory, os.path.dirname(file))
self.assertEqual(cmds[0].filename, file)
expected = [ 'clang++', '--driver-mode=g++', '-o', 'project.o', '-c',
'/home/john.doe/MyProject/project.cpp']
for arg, exp in zip(cmds[0].arguments, expected):
self.assertEqual(arg, exp)
def get_comp_args(target_file: str,
compdb: cindex.CompilationDatabase) -> Iterator[str]:
result = list()
for db_cmd in compdb.getCompileCommands(target_file):
result.extend(db_cmd.arguments)
# Remove compiler.
result = result[1:]
# Remove filename itself.
result = result[:len(result) - 1]
# Parse all comments. Clang, by default, parses only doxygen.
result.append("-fparse-all-comments")
return result
def test_create_fail(self):
"""Check we fail loading a database with an assertion"""
path = os.path.dirname(__file__)
# clang_CompilationDatabase_fromDirectory calls fprintf(stderr, ...)
# Suppress its output.
stderr = os.dup(2)
with open(os.devnull, 'wb') as null:
os.dup2(null.fileno(), 2)
with self.assertRaises(CompilationDatabaseError) as cm:
cdb = CompilationDatabase.fromDirectory(path)
os.dup2(stderr, 2)
os.close(stderr)
e = cm.exception
self.assertEqual(e.cdb_error,
CompilationDatabaseError.ERROR_CANNOTLOADDATABASE)
def test_create_fail(self):
"""Check we fail loading a database with an assertion"""
path = os.path.dirname(__file__)
# clang_CompilationDatabase_fromDirectory calls fprintf(stderr, ...)
# Suppress its output.
stderr = os.dup(2)
with open(os.devnull, 'wb') as null:
os.dup2(null.fileno(), 2)
with self.assertRaises(CompilationDatabaseError) as cm:
cdb = CompilationDatabase.fromDirectory(path)
os.dup2(stderr, 2)
os.close(stderr)
e = cm.exception
self.assertEqual(e.cdb_error,
CompilationDatabaseError.ERROR_CANNOTLOADDATABASE)
def test_2_compilecommand(self):
"""Check file with 2 compile commands"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project2.cpp')
self.assertEqual(len(cmds), 2)
expected = [
{ 'wd': '/home/john.doe/MyProjectA',
'line': ['clang++', '-o', 'project2.o', '-c',
'/home/john.doe/MyProject/project2.cpp']},
{ 'wd': '/home/john.doe/MyProjectB',
'line': ['clang++', '-DFEATURE=1', '-o', 'project2-feature.o', '-c',
'/home/john.doe/MyProject/project2.cpp']}
]
for i in range(len(cmds)):
self.assertEqual(cmds[i].directory, expected[i]['wd'])
for arg, exp in zip(cmds[i].arguments, expected[i]['line']):
self.assertEqual(arg, exp)
def translation_units(compile_commands: cindex.CompilationDatabase, cache_path: Optional[str]) -> Iterator[typing.Union[cindex.TranslationUnit, SerializedTU]]:
'''Returns an iterator over a translation unit for each file in the compilation database.'''
compile_command: cindex.CompileCommand
for compile_command in compile_commands.getAllCompileCommands():
if cache_path:
full_path = os.path.join(
compile_command.directory,
compile_command.filename,
)
serialized_tu = read_tu(
cache_path,
full_path,
)
modified_time = os.path.getmtime(full_path)
if serialized_tu.serialization_time >= modified_time:
log(LogLevel.INFO, f'Using cached analysis for {full_path}')
yield serialized_tu
continue
log(
LogLevel.INFO,
f'parsing {compile_command.filename}'
)
try:
if 'lua' in compile_command.filename:
continue
os.chdir(compile_command.directory)
translation_unit = cindex.TranslationUnit.from_source(
os.path.join(compile_command.directory,
compile_command.filename),
args=[arg for arg in compile_command.arguments
if arg != compile_command.filename] + ['-I' + inc.decode() for inc in ccsyspath.system_include_paths('clang')],
)
for diag in translation_unit.diagnostics:
log(
LogLevel.WARNING,
f'Parsing: {compile_command.filename}: {diag}'
)
yield translation_unit
except cindex.TranslationUnitLoadError:
log(
LogLevel.WARNING,
f'could not parse {os.path.join(compile_command.directory, compile_command.filename)}',
)
def init(self):
clang_complete_flags = self.vim.eval('g:clang_complete_lib_flags')
library_path = self.vim.eval('g:clang_library_path')
clang_compilation_database = self.vim.eval(
'g:clang_compilation_database')
if library_path:
if os.path.isdir(library_path):
Config.set_library_path(library_path)
else:
Config.set_library_file(library_path)
Config.set_compatibility_check(False)
try:
self.index = Index.create()
except Exception as e:
if library_path:
suggestion = "Are you sure '%s' contains libclang?" % library_path
else:
suggestion = "Consider setting g:clang_library_path."
logger.exception(
"Loading libclang failed, completion won't be available. %s %s ",
suggestion, exception_msg)
return 0
if not self.canFindBuiltinHeaders(self.index):
self.builtinHeaderPath = self.getBuiltinHeaderPath(library_path)
if not self.builtinHeaderPath:
logger.warn("libclang find builtin header path failed: %s",
self.builtinHeaderPath)
self.complete_flags = int(clang_complete_flags)
if clang_compilation_database != '':
self.compilation_database = CompilationDatabase.fromDirectory(
clang_compilation_database)
else:
self.compilation_database = None
return 1
def test_all_compilecommand():
"""Check we get all results from the db"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getAllCompileCommands()
assert len(cmds) == 3
expected = [
{ 'wd': '/home/john.doe/MyProject',
'line': ['clang++', '-o', 'project.o', '-c',
'/home/john.doe/MyProject/project.cpp']},
{ 'wd': '/home/john.doe/MyProjectA',
'line': ['clang++', '-o', 'project2.o', '-c',
'/home/john.doe/MyProject/project2.cpp']},
{ 'wd': '/home/john.doe/MyProjectB',
'line': ['clang++', '-DFEATURE=1', '-o', 'project2-feature.o', '-c',
'/home/john.doe/MyProject/project2.cpp']}
]
for i in range(len(cmds)):
assert cmds[i].directory == expected[i]['wd']
for arg, exp in zip(cmds[i].arguments, expected[i]['line']):
assert arg == exp
def test_create(self):
"""Check we can load a compilation database"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
def test_lookup_succeed(self):
"""Check we get some results if the file exists in the db"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
self.assertNotEqual(len(cmds), 0)
def test_lookup_succeed_pathlike(self):
"""Same as test_lookup_succeed, but with PathLikes"""
cdb = CompilationDatabase.fromDirectory(str_to_path(kInputsDir))
cmds = cdb.getCompileCommands(str_to_path('/home/john.doe/MyProject/project.cpp'))
self.assertNotEqual(len(cmds), 0)
def test_lookup_succeed(self):
"""Check we get some results if the file exists in the db"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands('/home/john.doe/MyProject/project.cpp')
self.assertNotEqual(len(cmds), 0)
def test_create(self):
"""Check we can load a compilation database"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
def test_lookup_succeed_pathlike(self):
"""Same as test_lookup_succeed, but with PathLikes"""
cdb = CompilationDatabase.fromDirectory(str_to_path(kInputsDir))
cmds = cdb.getCompileCommands(str_to_path('/home/john.doe/MyProject/project.cpp'))
self.assertNotEqual(len(cmds), 0)
def main():
from clang.cindex import Index, CompilationDatabase, CompilationDatabaseError, Cursor
from pprint import pprint
from optparse import OptionParser
import re
parser = OptionParser("usage: %prog [options] {filename} [clang-args*]")
parser.add_option("",
"--anti-pattern",
dest="aPat",
help="Check if classes in file are FD anti-pattern",
action="store_true",
default=False)
parser.add_option(
"",
"--compile-commands",
dest="cComs",
help=
"Source file is compile_commands.json (full path) of the project to parse",
action="store_true",
default=False)
parser.add_option(
"",
"--file-list",
dest="fList",
help="Source file is .txt file with the sources of the files to parse",
action="store_true",
default=False)
parser.disable_interspersed_args()
(opts, args) = parser.parse_args()
if len(args) == 0:
parser.error('invalid number arguments')
input_file = args[0]
input_args = args[1:]
files_list = []
if (opts.aPat):
#from sklearn.svm import SVC, LinearSVC
from sklearn.externals import joblib
clf = joblib.load('classifier_params.pkl')
if (opts.cComs):
if input_file[len(input_file) - 21:] != 'compile_commands.json':
pprint(('Invalid file: ' + input_file +
'. Should be compile_commands.json'))
return
ind = -1
for i in xrange(len(input_file)):
if input_file[i] == '/':
ind = i
path_dir = input_file[:ind + 1]
# Step 1: load the compilation database
compdb = CompilationDatabase.fromDirectory(path_dir)
# Step 2: query compilation flags
try:
commands = compdb.getAllCompileCommands()
for command in commands:
comp_args = list(command.arguments)
source_file = comp_args[len(comp_args) - 1]
if source_file[len(source_file) - 4:] == '.cpp':
files_list.append({
'source_file':
source_file,
'file_args':
comp_args[:len(comp_args) - 1]
})
except CompilationDatabaseError:
pprint(('Could not load compilation flags for ' + source_file))
elif (opts.fList):
if input_file[len(input_file) - 4:] != '.txt':
pprint(('Invalid file format: ' + input_file + '. Should be .txt'))
return
f = open(input_file, 'r')
for line in f:
if line.strip() == '':
continue
comp_args = re.split(' ', line.strip())
source_file = comp_args[len(comp_args) - 1]
if len(comp_args) == 1:
source_args = input_args
else:
source_args = comp_args[:len(comp_args) - 1]
if source_file[len(source_file) - 4:] == '.cpp':
files_list.append({
'source_file': source_file,
'file_args': source_args
})
else:
if input_file[len(input_file) - 4:] == '.cpp':
files_list.append({
'source_file': input_file,
'file_args': input_args
})
else:
pprint(('Invalid file format: ' + input_file + '. Should be .cpp'))
import csv
output_file_name = 'result.csv'
with open(output_file_name, 'w') as csvfile:
fieldnames = [
'name', 'file_path', 'label', 'verb_in_name', 'template',
'is_inherited', 'constructors', 'total_methods',
'nonpublic_methods', 'static_methods', 'biggest_method_size',
'total_fields', 'nonpublic_fields', 'fields_class_refs', 'getters',
'setters', 'CG_edges', 'CG_no_entrance_vertexes',
'CG_no_out_vertexes', 'CG_comp_num', 'CG_strong_comp_num'
]
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
index = Index.create()
classes = {}
handled_classes = set()
not_defined_classes = set()
for src_file in files_list:
tu = index.parse(src_file['source_file'], src_file['file_args'])
if not tu:
parser.error("unable to load file")
classes_defined_in_file = set()
visit_classdecl(tu.cursor, classes, handled_classes,
not_defined_classes, classes_defined_in_file)
for class_def in classes_defined_in_file:
if classes[class_def].are_methods_defined:
not_defined_classes.discard(class_def)
if classes.get(class_def) is not None:
class_prec = classes.pop(class_def)
if (opts.aPat):
class_prec.mark_class(classify(class_prec, clf))
if (opts.cComs) | (opts.fList):
export_precedent(class_prec, writer)
else:
if class_prec.label == 1:
pprint(('Class ' + class_prec.name +
' in file ' + class_prec.file_name +
' is a FD anti-pattern.'))
elif class_prec.label == 0:
pprint(('Class ' + class_prec.name +
' in file ' + class_prec.file_name +
' is not a FD anti-pattern.'))
pprint((class_prec.name + ' : ',
class_prec.get_print_info()))
handled_classes.add(class_def)
for class_prec in classes:
if (opts.aPat):
classes[class_prec].mark_class(
classify(classes[class_prec], clf))
if (opts.cComs) | (opts.fList):
export_precedent(classes[class_prec], writer)
else:
if classes[class_prec].label == 1:
pprint(('Class ' + classes[class_prec].name + ' in file ' +
classes[class_prec].file_name +
' is a FD anti-pattern.'))
elif classes[class_prec].label == 0:
pprint(('Class ' + classes[class_prec].name + ' in file ' +
classes[class_prec].file_name +
' is not a FD anti-pattern.'))
pprint((classes[class_prec].name + ' : ',
classes[class_prec].get_print_info()))
def main():
# This script should be run using filters and only those nodes who match the
# filter types will be processed.
#
# Example:
# ./libclang.py CXX_METHOD FUNCTION_DECL
filters = [getattr(CursorKind, arg) for arg in sys.argv]
file_ext = vim.eval("expand('%:p:e')")
filename = vim.eval("expand('%:p')")
ext = file_ext if file_ext else vim.eval('&filetype')
workdir = vim.eval("expand('%:p:h')")
try:
Config.set_library_file(vim.eval('g:doge_libclang_path'))
except:
pass
try:
args = vim.eval('g:doge_clang_args')
except vim.error:
args = []
lines = vim.eval("getline(line(1), line('$'))")
current_line = int(vim.eval("line('.')"))
compilation_database_path = vim.eval("getcwd()")
# Normalize the expression by transforming everything into 1 line.
opener_pos = int(vim.eval("search('\m[{;]', 'n')"))
normalized_expr = vim.eval(
"join(map(getline(line('.'), {}), 'doge#helpers#trim(v:val)'), ' ')".
format(opener_pos))
del lines[current_line - 1:opener_pos]
lines.insert(current_line - 1, normalized_expr)
try:
index = Index.create()
compiledb = CompilationDatabase.fromDirectory(
compilation_database_path)
file_args = compiledb.getCompileCommands(filename)
args = list(file_args[0].arguments)
args = args[1:-1] + SYSTEM_INCLUDE
tu = index.parse(filename,
args=args,
unsaved_files=[(filename, '\n'.join(lines))],
options=0x200)
# tu = index.parse(filename, args=args, options=0x200)
# print(list(tu.diagnostics))
# print(filename, args)
if tu:
# print([(x.source, x.depth) for x in tu.get_includes()])
with open('/tmp/libclang.log', 'w') as fp:
node = find_node(tu.cursor, filename, current_line, fp, 0)
if node and node.kind in filters:
if node.kind == CursorKind.FIELD_DECL:
print_field_decl(node)
elif node.kind == CursorKind.STRUCT_DECL:
print_struct_decl(node)
elif node.kind in [
CursorKind.CONSTRUCTOR, CursorKind.CXX_METHOD,
CursorKind.FUNCTION_DECL, CursorKind.FUNCTION_TEMPLATE,
CursorKind.CLASS_TEMPLATE
]:
print_func_decl(node)
except Exception as e:
print(type(e), e)
import traceback
traceback.print_exc
finally:
pass
def test_lookup_succeed():
"""Check we get some results if the file exists in the db"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
cmds = cdb.getCompileCommands("/home/john.doe/MyProject/project.cpp")
assert len(cmds) != 0
def test_lookup_fail():
"""Check file lookup failure"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
assert cdb.getCompileCommands('file_do_not_exist.cpp') == None
def test_lookup_fail(self):
"""Check file lookup failure"""
cdb = CompilationDatabase.fromDirectory(kInputsDir)
self.assertIsNone(cdb.getCompileCommands('file_do_not_exist.cpp'))
