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')