def update_function(self):
"""
Obtain File-Function mapping through Python bindings for Clang and load into database.
"""
# load libclang.so
if not Config.loaded:
Config.set_library_path("/usr/local/lib")
git_root = "hana"
function_map = dict()
for node in os.listdir(git_root):
curr_path = os.path.join(git_root, node)
if os.path.isdir(curr_path):
print(curr_path)
# update functions by directory
headers = self.header_path(curr_path)
if headers:
function_map.update(self.multi_process(headers))
# insert documents
documents = []
for key in sorted(function_map.keys()):
data = dict()
data["function"] = key
data["component"] = function_map[key]
documents.append(data)
with MongoConnection(self.host, self.port) as mongo:
collection = mongo.connection["kdetector"]["function"]
collection.drop()
collection.insert_many(documents)
print(
f"\x1b[32mSuccessfully updated File-Function mapping ({len(documents)}).\x1b[0m"
)
def main():
import sys
from clang.cindex import Index, Config
from io import open
# TODO: Don't hard code the clang library path
Config.set_library_path("/usr/lib/llvm-3.3/lib")
if len(sys.argv) == 1 or len(sys.argv) > 3:
usage()
sys.exit(1)
cppFile = str()
overwrite = False
if "-o" in sys.argv:
overwrite = True
cppFile = sys.argv[len(sys.argv) - 1]
index = Index.create()
transUnit = index.parse(cppFile)
docBlocks = get_doc_comments(transUnit.cursor, cppFile)
source = source_with_doc_blocks(cppFile, docBlocks)
if overwrite:
with open(cppFile, "w") as file:
file.write(unicode(source))
else:
sys.stdout.write(unicode(source))
def init():
global inited
global script_dir_path
if not inited:
from clang.cindex import Config
Config.set_library_path(script_dir_path)
inited = True
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 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 main():
Config.set_compatibility_check(False)
# NOTE: for darwin
Config.set_library_path("/usr/local/opt/llvm/lib")
parser = argparse.ArgumentParser()
parser.add_argument('--style', type=str, help='coding rule (only google is supported)')
parser.add_argument('filepath')
args, extra_args = parser.parse_known_args()
clang_func_range_parser = ClangFuncRangeParser(args.filepath)
clang_func_range_parser.print_all()
def __init__(self, filename, llvm_libdir=None, llvm_libfile=None):
self.prototypes = []
self.functions = {}
self.filename = filename
if llvm_libdir is not None:
Config.set_library_path(llvm_libdir)
if llvm_libfile is not None:
Config.set_library_file(llvm_libfile)
self._parse()
def __init__(self, library_path, project_root, n_workers=None):
if n_workers is None:
n_workers = (multiprocessing.cpu_count() * 3) / 2
self.clang_library_path = library_path
if not Config.loaded:
Config.set_library_path(self.clang_library_path)
Config.set_compatibility_check(False)
self.builtin_header_path = getBuiltinHeaderPath(
self.clang_library_path)
if self.builtin_header_path is None:
raise Exception("Cannot find clang includes")
project_root = os.path.abspath(project_root)
curr_path = project_root
self.compile_commands_path = None
while curr_path:
compile_commands_path = os.path.join(curr_path,
'compile_commands.json')
if os.path.exists(compile_commands_path):
self.compile_commands_path = compile_commands_path
self.index_db_path = os.path.join(curr_path, '.ctrlk-index')
self.project_root = curr_path
break
elif curr_path == '/':
break
curr_path = os.path.dirname(curr_path)
if self.compile_commands_path is None:
raise Exception("Could not find a 'compile_commands.json' file in the " +\
"directory hierarchy from '%s'" % (project_root))
self._compilation_db = None
self._compilation_db_modtime = 0
self._leveldb_connection = None
indexer.start(self.leveldb_connection, n_workers)
self.current_file_tus = {}
self.current_file_expire = {}
self.current_file_scopes = {}
self.c_parse_queue = []
self.c_parse_lock = threading.Lock()
self.c_parse_cond = threading.Condition(self.c_parse_lock)
threading.Thread(target=ParseCurrentFileThread, args=(self, )).start()
def initialiseClangDoxygen():
conf = Config()
if vim.eval("exists(\"g:clang_doxygen_libclang_library_path\")") != "0":
Config.set_library_path(vim.eval("g:clang_doxygen_libclang_library_path"))
conf.set_library_path(vim.eval("g:clang_doxygen_libclang_library_path"))
try:
conf.get_cindex_library()
except LibclangError as e:
print "Error: " + str(e)
return
vim.command("let g:initialised_clang_doxygen = 1")
def __init__(self, clang_path, args, cache_folder):
self._clang_path = 'clang++'
if clang_path is not None:
Config.set_library_path(clang_path)
self._clang_path = os.path.normpath(
os.path.join(clang_path, "clang++"))
syspath = ccsyspaths_improved.system_include_paths(self._clang_path)
incargs = [b'-I' + inc for inc in syspath]
args = args + incargs
self._args = args
self._parsed_classes = {}
self._cache_folder = cache_folder
def main():
global is_including_other_file
global source_file_path
parser = argparse.ArgumentParser(
description='Convert C++ header file to rust source file.')
parser.add_argument('src', help='C++ header file path.')
parser.add_argument('dst', help='Output file path.')
parser.add_argument('--CLANG_LIBRARY_PATH', help='Clang library path.')
parser.add_argument('-i',
'--include',
action='store_true',
help='Include included file')
args = parser.parse_args()
print('src=' + args.src)
print('dst=' + args.dst)
print('CLANG_LIBRARY_PATH=' + str(args.CLANG_LIBRARY_PATH))
print('include=' + str(args.include))
source_file_path = args.src
is_including_other_file = args.include
if args.CLANG_LIBRARY_PATH:
Config.set_library_path(args.CLANG_LIBRARY_PATH)
else:
CLANG_LIBRARY_PATH = 'CLANG_LIBRARY_PATH'
if CLANG_LIBRARY_PATH in os.environ:
clang_library_path = os.environ[CLANG_LIBRARY_PATH]
Config.set_library_path(clang_library_path)
index = Index.create()
tu = index.parse(args.src,
options=TranslationUnit.PARSE_SKIP_FUNCTION_BODIES)
file_test = open(args.dst + '.txt', 'w')
dump(tu.cursor, file_test)
file_test.close()
converted = convert(tu.cursor, Converted())
file = open(args.dst, 'w')
file.writelines(converted.enums)
file.writelines(converted.unions)
file.writelines(converted.structs)
file.writelines(converted.functions)
file.close()
def __init__(self, library_path, project_root, n_workers=None):
if n_workers is None:
n_workers = (multiprocessing.cpu_count() * 3) / 2
self.clang_library_path = library_path
if not Config.loaded:
Config.set_library_path(self.clang_library_path)
Config.set_compatibility_check(False)
self.builtin_header_path = getBuiltinHeaderPath(self.clang_library_path)
if self.builtin_header_path is None:
raise Exception("Cannot find clang includes")
project_root = os.path.abspath(project_root)
curr_path = project_root
self.compile_commands_path = None
while curr_path:
compile_commands_path = os.path.join(curr_path, 'compile_commands.json')
if os.path.exists(compile_commands_path):
self.compile_commands_path = compile_commands_path
self.index_db_path = os.path.join(curr_path, '.ctrlk-index')
self.project_root = curr_path
break
elif curr_path == '/':
break
curr_path = os.path.dirname(curr_path)
if self.compile_commands_path is None:
raise Exception("Could not find a 'compile_commands.json' file in the " +\
"directory hierarchy from '%s'" % (project_root))
self._compilation_db = None
self._compilation_db_modtime = 0
self._leveldb_connection = None
indexer.start(self.leveldb_connection, n_workers)
self.current_file_tus = {}
self.current_file_expire = {}
self.current_file_scopes = {}
self.c_parse_queue = []
self.c_parse_lock = threading.Lock()
self.c_parse_cond = threading.Condition(self.c_parse_lock)
threading.Thread(target=ParseCurrentFileThread, args=(self,)).start()
def init():
conf = Config()
# here we use the libclang.dylib from the vim plugin -- YouCompleteMe
# path = "/Users/lono/.config/nvim/plugged/YouCompleteMe/third_party/ycmd"
# path = "/Applications/Xcode.app/Contents/Frameworks"
path = "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib"
# path = "/Library/Developer/CommandLineTools/usr/lib/"
# path = "/Applications/Xcode8.app/Contents/Frameworks"
Config.set_library_path(path)
conf.set_library_path(path)
try:
conf.get_cindex_library()
except LibclangError as e:
print "Error: " + str(e)
def __init__(self, hw_file_name, json_file_name, llvm_libdir,
llvm_libfile):
#llvmのファイルをセット
if llvm_libfile != None:
Config.set_library_file(llvm_libfile)
if llvm_libdir != None:
Config.set_library_path(llvm_libdir)
#clangにソースコードをぶちこむ
self.index = clang.cindex.Index.create()
self.tree = self.index.parse(hw_file_name)
self.hw_file_name = hw_file_name
self.json_file_name = json_file_name
#抽出するデータたち
self.func_name = ""
self.func_decl = ""
self.return_type = ""
self.parm_decls = []
self.parm_types = []
self.parm_suffixs = []
self.parm_data_numbers = []
self.parm_interfaces = []
self.parm_bundles = []
self.parm_directions = []
self.parm_slave_bundles_noduplication = []
self.bundle_port_dic = {}
self.use_hp_ports = False
self.func_find_flag = False
self.func_find_flag_once = False
#Json/C解析
self.__analyzeJson()
self.__extractParameter()
#関数名の成形
self.func_name_u = self.func_name.upper()
self.func_name_l = self.func_name.lower()
self.func_name_ul = (self.func_name[0]).upper() + (
self.func_name[1:]).lower()
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 api_init_thread(libraryPath):
global g_api
global g_builtin_header_path
global parsingState
global parsingCurrentState
global updateProcess
global updateFileProcess
Config.set_library_path(libraryPath)
Config.set_compatibility_check(False)
parsingState = "Initializing"
parsingCurrentState = "Initializing"
if not try_initialize(libraryPath):
server_path = ctrlk_server.get_absolute_path()
with open('/tmp/ctrlk_server_stdout', 'a') as server_stdout:
with open('/tmp/ctrlk_server_stderr', 'a') as server_stderr:
subprocess.Popen(['python', server_path, '--port', str(client_api.DEFAULT_PORT), '--suicide-seconds', '3600'],\
stdout=server_stdout, stderr=server_stderr)
for i in range(30):
if try_initialize(libraryPath):
break
time.sleep(0.1)
else:
parsingState = "Failed to initialize"
pass
if g_api is not None:
g_builtin_header_path = g_api.get_builtin_header_path()
parsingCurrentState = "Ready to parse"
if updateProcess == None:
updateProcess = threading.Thread(target=UpdateCppIndexThread)
updateProcess.daemon = True
updateProcess.start()
updateFileProcess = threading.Thread(target=ParseCurrentFileThread)
updateFileProcess.daemon = True
updateFileProcess.start()
def __init__(self):
homebrew_lib_path = '/usr/local/Cellar/llvm/6.0.1/lib/'
xcode_lib_path = '/Applications/Xcode.app/Contents/Developer/Toolchains' \
'/XcodeDefault.xctoolchain/usr/lib/'
if os.path.exists(homebrew_lib_path):
Config.set_library_path(homebrew_lib_path)
elif os.path.exists(xcode_lib_path):
Config.set_library_path(xcode_lib_path)
else:
raise Exception('Path for libclang lib not found')
self.index: Index = Index.create()
self.translation_unit: TranslationUnit = self.index.parse(
path=None,
args=[
'/Users/pierre/src/bitcoin/src/wallet/wallet.h',
'/Users/pierre/src/bitcoin/src/wallet/wallet.cpp'
]
)
import os, sys, platform
import optparse, re, traceback, StringIO, tempfile, subprocess
if platform.system() == 'Windows':
if sys.version_info < (2, 7, 13) or sys.version_info >= (3, 0, 0):
print "Python 2.7.13+ is required on Windows; exiting."
sys.exit(1)
try:
import clang
from clang.cindex import Config
fabric_dir = os.environ.get('FABRIC_DIR')
if fabric_dir:
if platform.system() == 'Windows':
Config.set_library_path(os.path.join(fabric_dir, 'bin'))
else:
Config.set_library_path(os.path.join(fabric_dir, 'lib'))
except:
print "FABRIC_DIR is not set; exiting."
sys.exit(1)
from clang.cindex import AccessSpecifier, CursorKind, TypeKind, TokenKind
from libkludge import util
from libkludge.visibility import Visibility
from libkludge import cpp_type_expr_parser
def fixpath(path):
if platform.system() == 'Windows':
return path.replace('\\', '\\\\').replace('/', '\\\\')
import os
from clang.cindex import Config
if 'CLANG_LIBRARY_PATH' in os.environ:
Config.set_library_path(os.environ['CLANG_LIBRARY_PATH'])
import ctypes
import gc
import unittest
from clang.cindex import AvailabilityKind
from clang.cindex import CursorKind
from clang.cindex import TemplateArgumentKind
from clang.cindex import TranslationUnit
from clang.cindex import TypeKind
from .util import get_cursor
from .util import get_cursors
from .util import get_tu
kInput = """\
struct s0 {
int a;
int b;
};
struct s1;
void f0(int a0, int a1) {
int l0, l1;
if (a0)
import sys
from argument import parser
from regex import find_stack
from clang.cindex import Config
from function import update_functions
from component import update_components
from output import hana_print, formula_print, format_print
from workflow import pre_process, add_knowledge, calculate_sim
if __name__ == "__main__":
args = parser.parse_args()
# load libclang.so
lib_path = r"C:\LLVM\bin" if sys.platform == "win32" else "/usr/lib"
if not Config.loaded:
Config.set_library_path(lib_path)
# show AST workflow
if args.workflow:
# hana_print
step_1 = []
for dump in args.workflow:
step_1.append(add_knowledge(pre_process(dump)))
hana_print(step_1)
# formula print
m_pos = 0.4
n_sim = 1.9
threshold = 0.3104
parameters = [m_pos, n_sim, threshold]
step_2 = calculate_sim(args.workflow, m_pos, n_sim)
formula_print(step_2, parameters)
# comparing based on CSI
import os
from clang.cindex import Config
if 'CLANG_LIBRARY_PATH' in os.environ:
Config.set_library_path(os.environ['CLANG_LIBRARY_PATH'])
from clang.cindex import CompilationDatabase
from clang.cindex import CompilationDatabaseError
from clang.cindex import CompileCommands
from clang.cindex import CompileCommand
import os
import gc
import unittest
import sys
from .util import skip_if_no_fspath
from .util import str_to_path
kInputsDir = os.path.join(os.path.dirname(__file__), 'INPUTS')
@unittest.skipIf(sys.platform == 'win32', "TODO: Fix these tests on Windows")
class TestCDB(unittest.TestCase):
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)
# get literal
if kind == 'INTEGER_LITERAL':
const_int.append(text)
elif kind == 'STRING_LITERAL':
const_str.append(text)
elif kind =='FLOATING_LITERAL':
const_float.append(text)
for n in cursor.get_children():
visit(n)
return
Config.set_library_path(libclang)
index = clang.cindex.Index.create()
# translate unit
if len(sys.argv) > 1:
g_filename = sys.argv[1]
else:
g_filename = 'plugin.cpp'
tu = index.parse(g_filename, ['-x', 'c++', '-std=c++11'])
# tu = index.parse('plugin.cpp', ['-x', 'c++', '-std=c++11', '-D__CODE_GENERATOR__'],
# options=clang.cindex.TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD)
show_token(tu.cursor)
visit(tu.cursor)
pprint.pprint(const_int)
# sdef file emitted by the sdef tool.
#
import sys
import struct
import re
from itertools import chain
from clang.cindex import TranslationUnit
from clang.cindex import CursorKind
from clang.cindex import Config
from clang.cindex import TypeKind
Config.set_library_path("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib")
keywords = ['class', 'deinit', 'enum', 'extension', 'func', 'import', 'init', 'internal', 'let', 'operator', 'private',
'protocol', 'public', 'static', 'struct', 'subscript', 'typealias', 'var', 'break', 'case', 'continue',
'default', 'do', 'else', 'fallthrough', 'for', 'if', 'in', 'return', 'switch', 'where', 'while', 'as',
'dynamicType', 'false', 'is', 'nil', 'self', 'Self', 'super', 'true', 'associativity', 'convenience',
'dynamic', 'didSet', 'final', 'get', 'infix', 'inout', 'lazy', 'left', 'mutating', 'none', 'nonmutating',
'optional', 'override', 'postfix', 'precedence', 'prefix', 'Protocol', 'required', 'right', 'set', 'Type',
'unowned', 'weak', 'willSet']
type_dict = {'BOOL': 'Bool',
'double': 'Double',
'long': 'Int64',
'int': 'Int',
'NSInteger': 'Int',
'NSString': 'String',
#!/usr/bin/env python
#coding=utf-8
import sys
import clang.cindex
from clang.cindex import Config
from clang.cindex import _CXString
Config.set_compatibility_check(False)
Config.set_library_path("C:/Program Files (x86)/LLVM/bin")
# Config.set_library_path(sys.path[0])
def dumpnode(node, indent):
'递归打印 C++ 语法树'
# ...
# do something with the current node here, i.e
# check the kind, spelling, displayname and act baseed on those
# kind : 所查看的 AST 节点的类型, 该节点是类定义 是函数定义 还是参数声明
# spelling : 标记的文本定义. 比如游标指向 void foo(int x); 这样一个函数声明，该游标
# 的 spelling 则是 foo.
# ...
text = node.spelling or node.displayname
kind = str(node.kind)[str(node.kind).index('.') + 1:]
print ' ' * indent, '{} {}'.format(kind, text)
for i in node.get_children():
dumpnode(i, indent + 2)
# def check_argv():
# if len(sys.argv) != 2:
# print("Usage: clang_3.py [header file name]")
# sys.exit()
import asciitree
from clang.cindex import Config, Index, TranslationUnit
from ConfigParser import ConfigParser
from path import path
if not Config.loaded:
_path_ = path(__file__)
while len(_path_) > 0 and not str(_path_.name) == 'src':
_path_ = _path_.parent
_path_ = _path_.parent
configparser = ConfigParser()
configparser.read(_path_/'metainfo.ini')
config = dict(configparser.items('libclang'))
if 'path' in config:
Config.set_library_path(config['path'])
elif 'file' in config:
Config.set_library_file(config['file'])
else:
raise IOError('cannot find libclang path or file')
class AST(object):
"""
"""
def __init__(self, *translation_units):
"""
"""
if any(not isinstance(translation_unit, TranslationUnit) for translation_unit in translation_units):
raise TypeError('`translation_units` parameter')
self._translation_units = translation_units
if args.table:
call(["cp", os.path.join(os.path.dirname(__file__), 'util', 'table_util.hh'), args.util_path])
else:
call(["cp", os.path.join(os.path.dirname(__file__), 'util', 'util.hh'), args.util_path])
def generate_type_erased_interface(args):
type_erasure.detail_generator.write_file(get_data(args))
type_erasure.interface_generator.write_file(get_data(args))
def format_generated_files(args):
# format files
abs_path = os.path.join(os.getcwd(), args.detail_folder, args.detail_file)
type_erasure.util.clang_format(abs_path)
abs_path = os.path.join(os.getcwd(), args.interface_file)
type_erasure.util.clang_format(abs_path)
if not args.header_only:
abs_path = os.path.join(os.getcwd(), type_erasure.interface_generator.get_source_filename(args.interface_file))
type_erasure.util.clang_format(abs_path)
if __name__ == "__main__":
parser = create_parser()
args = parser.parse_args()
if args.clang_path:
Config.set_library_path(args.clang_path)
copy_utility_file(args)
generate_type_erased_interface(args)
format_generated_files(args)
return parser
class Data(object):
def __init__(self, args):
self.impl = args.impl
self.classname = args.classname
self.private_classname = self.classname + self.impl
self.file = args.file
self.cpp_file = '' #args.cpp_file
self.interface_header_file = args.interface_header_file
self.interface_source_file = args.interface_source_file
self.clang_path = args.clang_path
self.clang_args = args.clang_args
self.non_copyable = args.non_copyable
self.non_moveable = args.non_moveable
self.implicit_default_constructor = args.implicit_default_constructor
self.small_buffer_optimization = args.small_buffer_optimization
self.current_namespaces = []
self.current_struct = clang.cindex.conf.lib.clang_getNullCursor()
if __name__ == "__main__":
parser = create_parser()
args = parser.parse_args()
if args.clang_path:
Config.set_library_path(args.clang_path)
data = Data(args)
type_erasure.pimpl_file_writer.pimpl_class(data)
def compute_statics(options):
import shutil
import sqlite3
from clang.cindex import Index, Config, CursorKind, StorageClass
SCTEXT = {
StorageClass.STATIC: 'static',
StorageClass.NONE: 'implicit',
StorageClass.EXTERN: 'extern',
}
Config.set_library_path(options.clang_dir)
index = Index.create()
if not os.path.isfile(options.args):
raise ValueError('No arguments file: %s.' % options.args)
with open(options.args, encoding='utf-8') as f:
arglists = json.load(f)
if (not options.remote_secret and options.new
or not os.path.isfile(options.database)):
logger.info('Creating new database from template: %s.',
options.database)
shutil.copyfile('statics.template.sqlite', options.database)
options.conn = sqlite3.connect(options.database)
if options.remote_secret:
logger.info('Computing statics into %s.', options.remote_url)
else:
logger.info('Computing statics into %s.', options.database)
for rp in sorted(arglists):
p = os.path.join(options.python_dir, rp)
args = arglists[rp]
tu = index.parse(None, args)
if not tu:
logger.warning('Unable to parse %s.', rp)
continue
diags = list(tu.diagnostics)
if not diags:
s = ''
level = logging.INFO
else:
s = ' (there are some parsing errors)'
level = logging.WARNING
logger.log(level, 'Processing AST for %s%s.', rp, s)
if diags:
for diag in diags:
d = get_diag_info(diag)
logger.debug('%s', d)
start = tu.cursor
statics = 0
for node in walk_ast(start):
if not node.extent.start.file:
fn = None
else:
fn = node.extent.start.file.name
if os.name == 'nt':
if fn:
fn = fn.replace(os.sep, '/')
p = p.replace(os.sep, '/')
if fn != p:
continue
if node.spelling in IGNORED_VARIABLES:
continue
if (rp in FILE_SPECIFIC_IGNORED_VARIABLES and
FILE_SPECIFIC_IGNORED_VARIABLES[rp].search(node.spelling)):
continue
if node.kind != CursorKind.VAR_DECL:
continue
if node.storage_class == StorageClass.EXTERN:
continue
if node.semantic_parent.kind == CursorKind.FUNCTION_DECL:
if node.storage_class in (StorageClass.NONE,
StorageClass.REGISTER):
continue
ts = node.type.spelling
if CONST_STRUCT_TYPES.match(ts):
continue
if IGNORED_STRUCT_TYPES.match(ts):
continue
if CONST_TYPES.search(ts):
continue
if (rp in FILE_SPECIFIC_IGNORED_TYPES
and FILE_SPECIFIC_IGNORED_TYPES[rp].search(ts)):
continue
start = node.extent.start
end = node.extent.end
sc = node.storage_class
sc = SCTEXT.get(sc, str(sc))
loc = '(%d, %d) - (%d, %d)' % (start.line, start.column, end.line,
end.column)
register_static(options, node.spelling, sc, ts, rp, start.line,
start.column, end.line, end.column)
statics += 1
logger.debug('%-8s %-16s %s %s' % (sc, loc, ts, node.spelling))
if statics:
s = '' if statics == 1 else 's'
logger.info(' %d static%s found.', statics, s)
from clang.cindex import Config
Config.set_library_path("/usr/i386-linux-cgc/lib")
return Run(cmd)[0].strip()
NACL_CONFIG = os.path.join(NACL_SDK_ROOT, 'tools', 'nacl_config.py')
PNACL_CLANG = RunNaClConfig('-t', 'pnacl', '--tool', 'clang')
PNACL_ROOT = os.path.dirname(os.path.dirname(PNACL_CLANG))
# PNACL_LIB = os.path.join(PNACL_ROOT, GetHostDir(), 'lib')
PNACL_LIB = os.path.join(PNACL_ROOT, 'lib')
sys.path.append(PYTHON_BINDINGS_DIR)
import clang.cindex
from clang.cindex import Index, CursorKind, TypeKind, TranslationUnit, Config
from clang.cindex import TokenKind
Config.set_library_path(PNACL_LIB)
class Error(Exception):
pass
class RunError(Error):
def __init__(self, msg, stdout, stderr):
Error.__init__(self, msg)
self.stdout = stdout
self.stderr = stderr
def CreateTranslationUnit(args, detailed=False):
new_args = GetIndexParseArgs(args)
#!/usr/bin/env python
import sys, os; from os import environ as env
LIBCLANG_PATH = "./libclang-py"
if env.has_key('TM_BUNDLE_SUPPORT'):
LIBCLANG_PATH = env['TM_BUNDLE_SUPPORT']+"/libclang-py"
sys.path.append(LIBCLANG_PATH)
from clang.cindex import Index, Cursor, CursorKind, Config, SourceLocation as Location
Config.set_library_path('/opt/llvm/head/lib')
# PROJECT_DIR = '/Users/bholt/dev/test'
DEBUG = False
class MateIndex:
def __init__(self):
if env.has_key('TM_PROJECT_DIRECTORY'):
self.project_dir = env['TM_PROJECT_DIRECTORY']
else:
self.project_dir = "."
self.index = Index.create()
self.type_kinds = set([CursorKind.STRUCT_DECL, CursorKind.CLASS_DECL, CursorKind.CLASS_TEMPLATE,CursorKind.TYPEDEF_DECL])
def find_types(self, node=None, types=set()):
global DEBUG
if not node:
node = self.tu.cursor
def setup_clang(clang_path):
from clang.cindex import Config
Config.set_library_path(clang_path)
import sys
import clang.cindex
from clang.cindex import Config
Config.set_library_path("D:/msys64/mingw64/bin")
def showToken(node):
ts = node.get_tokens()
for t in ts:
print(t.spelling)
index = clang.cindex.Index.create()
tu = index.parse("test.cpp")
showToken(tu.cursor)
def find_typerefs(node, typename):
""" Find all references to the type named 'typename'
"""
if node.kind.is_reference():
ref_node = node.get_definition()
#print ref_node.spelling
if ref_node.spelling == typename:
print('Found %s [line=%s, col=%s]' % (typename, node.location.line, node.location.column))
# # Recurse for children of this node
for c in node.get_children():
find_typerefs(c, typename)
index = clang.cindex.Index.create()
#! /usr/bin/env /home/satos/sotsuron/neural_decompiler/python_fix_seed.sh
from clang.cindex import Config, Index, CursorKind
Config.set_library_path("/usr/lib/llvm-8/lib/")
import code, os
kinds = set([])
rules = set([])
cnt = 0
def traverse(x, d, fnsrc):
global kinds, rules, cnt
def mp(a):
print('\t' * d + str(a))
#mp(x.kind)
#mp(x.extent)
#mp(x.spelling)
#mp(x.displayname)
#mp(x.get_usr())
kinds |= set([x.kind])
cs = list(x.get_children())
#rule = (str(x.kind),tuple(map(lambda a: str(a.kind),cs)))
rule = (str(x.kind), len(cs))
rules |= set([rule])
# Copyright (C) 2020 Alibaba Group Holding Limited
import os
import sys
from clang.cindex import Config
from clang.cindex import Index
from clang.cindex import CursorKind
import traceback
try:
if None is Config.library_path:
Config.set_library_path("/usr/local/opt/llvm/lib/")
except Exception as e:
traceback.print_exc()
from UtilClasses import *
import subprocess
import json
XNU_6153_EXPORT_HDRS_DIRPATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../xnusrc/build-xnu-6153.11.26/xnu-6153.11.26/")
def getDefinedClasses(node, classes):
try:
if node.kind == CursorKind.CLASS_DECL and node.is_definition():
classes.append(node)
for child in node.get_children():
getDefinedClasses(child, classes)
except ValueError as e:
None
def parseHeaderFileAtPath(headerFilePath, includePaths):
import os, pprint, re, sys
import json
from pathlib import Path
from clang.cindex import Config, CursorKind, Index, TranslationUnit, TranslationUnitLoadError, TypeKind
Config.set_library_path("/usr/local/Cellar/llvm/8.0.1/lib")
####################################################################################################
def generate_type_mapping(headers_list_filename='./sdl2_headers_list.json',
headers_dir='./SDL2'):
headers_list_file = Path(headers_list_filename)
if not headers_list_file.exists():
return False
headers_list = None
with headers_list_file.open() as f:
headers_list = json.load(f)
print("{", file=sys.stdout)
first = True
for header_filename in headers_list:
header_filename = headers_dir + '/' + header_filename
if not Path(header_filename).exists():
continue
ctx = ParseContext()
ctx.parse_file = header_filename
idx = Index.create()
#
import sys
import struct
import re
import platform
from itertools import chain
from clang.cindex import TranslationUnit
from clang.cindex import CursorKind
from clang.cindex import Config
from clang.cindex import TypeKind
Config.set_library_path(
"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib"
)
# See https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html
parameter_keywords = ['let', 'var', 'inout']
general_keywords = [
'associatedtype', 'class', 'deinit', 'enum', 'extension', 'fileprivate',
'func', 'import', 'init', 'inout', 'internal', 'let', 'open', 'operator',
'private', 'protocol', 'public', 'static', 'struct', 'subscript',
'typealias', 'var', 'break', 'case', 'continue', 'default', 'defer', 'do',
'else', 'fallthrough', 'for', 'guard', 'if', 'in', 'repeat', 'return',
'switch', 'where', 'while', 'as', 'Any', 'catch', 'false', 'is', 'nil',
'rethrows', 'super', 'self', 'Self', 'throw', 'throws', 'true', 'try', '_'
]
type_dict = {
AccessSpecifier.PROTECTED, AccessSpecifier.PRIVATE
]:
return False
return True
def getType(self, context):
type = context.split()
if type[0] == 'const':
type = ' '.join(type[1:])
else:
type = ' '.join(type[0:])
return type.split('::')[-1]
if __name__ == '__main__':
parse = argparse.ArgumentParser()
parse.add_argument('--head_path',
default='include/vector.h',
type=str,
help='path for the head file')
parse.add_argument('--libclang_path',
default='libclang.dll',
type=str,
help='path for the head file')
args = parse.parse_args()
Config.set_library_path('.')
Config.set_library_file(args.libclang_path)
cython = cythonGenerator(args.head_path)
cython.generate()
# -*- coding: utf-8 -*-
import os, sys
from PyQt5 import QtWidgets
from frame import Ui_Form
from PyQt5.QtWidgets import QFileDialog, QMessageBox
from clang.cindex import Index, CursorKind
from lxml import etree
import platform
if platform.system() == 'Windows':
from clang.cindex import Config
Config.set_library_path("C:\\Program Files\\LLVM\\bin")
class MainWindow(QtWidgets.QWidget, Ui_Form):
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
self.postfix = ''
self.tree = None
self.section = ''
self.pch = None
self.willgen = {}
self.xml_file = None
def insertRow(self, table, file, func):
row = table.rowCount()
table.insertRow(row)
table.setItem(row, 0, QtWidgets.QTableWidgetItem(file))
table.setItem(row, 1, QtWidgets.QTableWidgetItem(func))
#
# Copyright (c) 2010-2016, Fabric Software Inc. All rights reserved.
#
import os, sys
kludge_llvm_root = os.environ.get('KLUDGE_LLVM_ROOT')
if not kludge_llvm_root:
print "Missing KLUDGE_LLVM_ROOT environment variabling; exiting."
sys.exit(1)
sys.path.insert(0, os.path.join(kludge_llvm_root, 'lib', 'python'))
import optparse, re, traceback, StringIO, tempfile, subprocess
import clang
from clang.cindex import Config
Config.set_library_path(os.path.join(kludge_llvm_root, 'lib'))
from clang.cindex import AccessSpecifier, CursorKind, TypeKind, TokenKind
from libkludge import util
from libkludge.visibility import Visibility
from libkludge import cpp_type_expr_parser
class Parser(object):
def __init__(self, name, opts):
self.name = name
self.opts = opts
clang_output = subprocess.check_output([
self.expand_envvars('${KLUDGE_LLVM_ROOT}/bin/clang'), '--version'
])
clang_version = re.search('version ([0-9]+\.[0-9]+\.[0-9]) ',
import sys, os
import ctypes
import clang.cindex
from clang.cindex import Index, Config, CursorKind, TypeKind, TranslationUnit
Config.set_library_path('/usr/lib/llvm-6.0/lib/')
Config.set_library_file('/usr/lib/llvm-6.0/lib/libclang.so.1')
REAL_NUMBER_TYPES = set({TypeKind.DOUBLE, TypeKind.FLOAT, TypeKind.FLOAT128})
INTEGER_TYPES = set({
TypeKind.INT, TypeKind.INT128, TypeKind.LONG, TypeKind.LONGDOUBLE,
TypeKind.LONGLONG, TypeKind.UCHAR, TypeKind.CHAR32
})
NUMERIC_TYPES = REAL_NUMBER_TYPES | INTEGER_TYPES
BUILTIN_C_TYPES = {
TypeKind.BOOL: ctypes.c_bool,
TypeKind.CHAR_S: ctypes.c_char,
TypeKind.CHAR_U: ctypes.c_char,
TypeKind.DOUBLE: ctypes.c_double,
TypeKind.FLOAT: ctypes.c_float,
TypeKind.INT: ctypes.c_int,
TypeKind.LONG: ctypes.c_long,
TypeKind.LONGDOUBLE: ctypes.c_longdouble,
TypeKind.LONGLONG: ctypes.c_longlong,
TypeKind.SCHAR: ctypes.c_char,
TypeKind.SHORT: ctypes.c_short,
TypeKind.UCHAR: ctypes.c_char,
TypeKind.UINT: ctypes.c_uint,
TypeKind.ULONG: ctypes.c_ulong,
TypeKind.ULONGLONG: ctypes.c_ulonglong,
TypeKind.USHORT: ctypes.c_ushort,
TypeKind.WCHAR: ctypes.c_wchar
#! /usr/bin/env /home/satos/sotsuron/neural_decompiler/python_fix_seed.sh
#coding: utf-8
import c_cfg
import clang_ast_dump
import types
import code
from clang.cindex import Config,Index,CursorKind
Config.set_library_path("/usr/lib/llvm-7/lib")
# clang python bindings is inefficient,
# so I need to use information from clang -ast-dump
import tokenizer
import my_c_ast
def ast2token_seq(data):
ast = my_c_ast.load_astdata(data)
ast.before_show()
#code.interact(local={'ast':ast})
src = ast.show()
with open('tmp.c','w') as fp:
fp.write(src)
#print(src)
res = tokenizer.tokenize('tmp.c')
