def convert(self, defs, flags=None, dump=False, **kw): hfile = mktemp(".h") open(hfile, "w").write(defs) xmlfile = mktemp(".xml") try: if flags: h2xml.main(["h2xml", "-q", "-I.", hfile, "-o", xmlfile, flags]) else: h2xml.main(["h2xml", "-q", "-I.", hfile, "-o", xmlfile]) ofi = StringIO() from ctypes import CDLL generate_code(xmlfile, ofi, **kw) namespace = {} exec ofi.getvalue() in namespace ## print ofi.getvalue() return ADict(namespace) finally: os.unlink(hfile) if dump: print open(xmlfile).read() os.unlink(xmlfile)
def convert(self, defs, flags=None, dump=False, **kw): hfile = mktemp(".h") open(hfile, "w").write(defs) xmlfile = mktemp(".xml") try: if flags: h2xml.main(["h2xml", "-q", "-I.", hfile, "-o", xmlfile, flags]) else: h2xml.main(["h2xml", "-q", "-I.", hfile, "-o", xmlfile]) ofi = StringIO() generate_code(xmlfile, ofi, **kw) namespace = {} exec ofi.getvalue() in namespace ## print ofi.getvalue() return ADict(namespace) finally: os.unlink(hfile) if dump: print open(xmlfile).read() os.unlink(xmlfile)
def main(argv=None): if argv is None: argv = sys.argv def windows_dlls(option, opt, value, parser): parser.values.dlls.extend(windows_dll_names) parser = OptionParser("usage: %prog xmlfile [options]") parser.add_option("-c", action="store_true", dest="generate_comments", help="include source file location in comments", default=False) parser.add_option("-d", action="store_true", dest="generate_docstrings", help="include docstrings containing C prototype and source file location", default=False) parser.add_option("-k", action="store", dest="kind", help="kind of type descriptions to include: " "d = #defines, " "e = enumerations, " "f = functions, " "s = structures, " "t = typedefs", metavar="TYPEKIND", default=None) parser.add_option("-l", dest="dlls", help="libraries to search for exported functions", action="append", default=[]) parser.add_option("-o", dest="output", help="output filename (if not specified, standard output will be used)", default="-") parser.add_option("-r", dest="expressions", metavar="EXPRESSION", action="append", help="regular expression for symbols to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_option("-s", dest="symbols", metavar="SYMBOL", action="append", help="symbol to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_option("-v", action="store_true", dest="verbose", help="verbose output", default=False) parser.add_option("-w", action="callback", callback=windows_dlls, help="add all standard windows dlls to the searched dlls list") if os.name in ("ce", "nt"): default_modules = ["ctypes.wintypes", "ctypes" ] else: default_modules = ["ctypes" ] parser.add_option("-m", dest="modules", metavar="module", help="Python module(s) containing symbols which will " "be imported instead of generated", action="append", default=default_modules) parser.add_option("--preload", dest="preload", metavar="DLL", help="dlls to be loaded before all others (to resolve symbols)", action="append", default=[]) options, files = parser.parse_args(argv[1:]) if len(files) != 1: parser.error("Exactly one input file must be specified") if options.output == "-": stream = sys.stdout else: stream = open(options.output, "w") if options.expressions: options.expressions = map(re.compile, options.expressions) if options.generate_comments: stream.write("# generated by 'xml2py'\n") stream.write("# flags '%s'\n" % " ".join(argv[1:])) known_symbols = {} from ctypes import CDLL, RTLD_LOCAL, RTLD_GLOBAL from ctypes.util import find_library def load_library(name, mode=RTLD_LOCAL): if os.name == "nt": from ctypes import WinDLL # WinDLL does demangle the __stdcall names, so use that. return WinDLL(name, mode=mode) path = find_library(name) if path is None: # Maybe 'name' is not a library name in the linker style, # give CDLL a last chance to find the library. path = name return CDLL(path, mode=mode) preloaded_dlls = [load_library(name, mode=RTLD_GLOBAL) for name in options.preload] dlls = [load_library(name) for name in options.dlls] for name in options.modules: mod = __import__(name) for submodule in name.split(".")[1:]: mod = getattr(mod, submodule) for name, item in mod.__dict__.iteritems(): if isinstance(item, type): known_symbols[name] = mod.__name__ if options.kind: types = [] for char in options.kind: typ = {"a": [typedesc.Alias], "d": [typedesc.Variable], "e": [typedesc.Enumeration, typedesc.EnumValue], "f": [typedesc.Function], "m": [typedesc.Macro], "s": [typedesc.Structure], "t": [typedesc.Typedef], }[char] types.extend(typ) options.kind = tuple(types) generate_code(files[0], stream, symbols=options.symbols, expressions=options.expressions, verbose=options.verbose, generate_comments=options.generate_comments, generate_docstrings=options.generate_docstrings, known_symbols=known_symbols, searched_dlls=dlls, preloaded_dlls=options.preload, types=options.kind)
"u": [typedesc.Union], } if options.kind: types = [] for char in options.kind: try: typ = type_table[char] except KeyError, e: parser.error("%s is not a valid choice for a TYPEKIND"%(char)) types.extend(typ) options.kind = tuple(types) generate_code(files, stream, symbols=options.symbols, expressions=options.expressions, verbose=options.verbose, generate_comments=options.generate_comments, generate_docstrings=options.generate_docstrings, generate_locations=options.generate_locations, generate_includes=options.generate_includes, known_symbols=known_symbols, searched_dlls=dlls, preloaded_dlls=options.preload, types=options.kind, flags=clang_opts) if __name__ == "__main__": #sys.exit(main()) main()
def main(argv=None): if argv is None: argv = sys.argv def windows_dlls(option, opt, value, parser): parser.values.dlls.extend(windows_dll_names) parser = argparse.ArgumentParser( prog='clang2py', description='generate python ABI code from C code') parser.add_argument("--debug", dest="debug", action="store_const", const=True, help='setLevel to DEBUG') parser.add_argument("-c", dest="generate_comments", action="store_true", help="include source file location in comments", default=False) parser.add_argument( "-d", dest="generate_docstrings", action="store_true", help= "include docstrings containing C prototype and source file location", default=False) parser.add_argument("-k", action="store", dest="kind", help="kind of type descriptions to include: " "d = #defines, " "e = enumerations, " "f = functions, " "s = structures, " "t = typedefs", metavar="TYPEKIND", default=None) parser.add_argument("-l", dest="dlls", help="libraries to search for exported functions", action="append", default=[]) parser.add_argument( "-o", dest="output", help="output filename (if not specified, standard output will be used)", default="-") parser.add_argument("-r", dest="expressions", metavar="EXPRESSION", action="append", help="regular expression for symbols to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_argument("-s", dest="symbols", metavar="SYMBOL", action="append", help="symbol to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_argument("-v", action="store_true", dest="verbose", help="verbose output", default=False) parser.add_argument( "-w", action="store", default=windows_dlls, help="add all standard windows dlls to the searched dlls list") if os.name in ("ce", "nt"): default_modules = ["ctypes.wintypes"] else: default_modules = [] # ctypes is already imported parser.add_argument("-m", dest="modules", metavar="module", help="Python module(s) containing symbols which will " "be imported instead of generated", action="append", default=default_modules) parser.add_argument( "--preload", dest="preload", metavar="DLL", help="dlls to be loaded before all others (to resolve symbols)", action="append", default=[]) parser.add_argument("--show-ids", dest="showIDs", help="Don't compute cursor IDs (very slow)", default=False) parser.add_argument("--max-depth", dest="maxDepth", help="Limit cursor expansion to depth N", metavar="N", type=int, default=None) parser.add_argument("files", nargs="+", help="source filenames", type=argparse.FileType('r')) #parser.add_argument("clang-opts", required=False, help="clang options", type=str) parser.epilog = '''About clang-args: You can pass modifier to clang after your file name. For example, try "-target x86_64" or "-target i386-linux" as the last argument to change the target CPU arch.''' options, clang_opts = parser.parse_known_args() files = [f.name for f in options.files] level = logging.INFO if options.debug: level = logging.DEBUG logging.basicConfig(level=level, stream=sys.stderr) if options.output == "-": stream = sys.stdout else: stream = open(options.output, "w") if options.expressions: options.expressions = map(re.compile, options.expressions) if options.generate_comments: stream.write("# generated by 'clang2py'\n") stream.write("# flags '%s'\n" % " ".join(argv[1:])) known_symbols = {} from ctypes import CDLL, RTLD_LOCAL, RTLD_GLOBAL from ctypes.util import find_library def load_library(name, mode=RTLD_LOCAL): if os.name == "nt": from ctypes import WinDLL # WinDLL does demangle the __stdcall names, so use that. return WinDLL(name, mode=mode) path = find_library(name) if path is None: # Maybe 'name' is not a library name in the linker style, # give CDLL a last chance to find the library. path = name return CDLL(path, mode=mode) preloaded_dlls = [ load_library(name, mode=RTLD_GLOBAL) for name in options.preload ] dlls = [load_library(name) for name in options.dlls] for name in options.modules: mod = __import__(name) for submodule in name.split(".")[1:]: mod = getattr(mod, submodule) for name, item in mod.__dict__.iteritems(): if isinstance(item, type): known_symbols[name] = mod.__name__ if options.kind: types = [] for char in options.kind: typ = { "a": [typedesc.Alias], "d": [typedesc.Variable], "e": [typedesc.Enumeration, typedesc.EnumValue], "f": [typedesc.Function], "m": [typedesc.Macro], "s": [typedesc.Structure], "t": [typedesc.Typedef], }[char] types.extend(typ) options.kind = tuple(types) generate_code(files, stream, symbols=options.symbols, expressions=options.expressions, verbose=options.verbose, generate_comments=options.generate_comments, generate_docstrings=options.generate_docstrings, known_symbols=known_symbols, searched_dlls=dlls, preloaded_dlls=options.preload, types=options.kind, flags=clang_opts)
def main(argv=None): if argv is None: argv = sys.argv local_platform_triple = "%s-%s"%(platform.machine(),platform.system()) clang_opts = [] files = None def windows_dlls(option, opt, value, parser): parser.values.dlls.extend(windows_dll_names) version = ctypeslib.__version__ parser = argparse.ArgumentParser(prog='clang2py', description='Version %s. Generate python code from C headers' % (version)) parser.add_argument("-c", "--comments", dest="generate_comments", action="store_true", help="include source doxygen-style comments", default=False) parser.add_argument("-d","--doc", dest="generate_docstrings", action="store_true", help="include docstrings containing C prototype and source file location", default=False) parser.add_argument("--debug", action="store_const", const=True, help='setLevel to DEBUG') parser.add_argument("-e", "--show-definition-location", dest="generate_locations", action="store_true", help="include source file location in comments", default=False) parser.add_argument("-k", "--kind", action="store", dest="kind", help="kind of type descriptions to include: " "a = Alias,\n" "c = Class,\n" "d = Variable,\n" "e = Enumeration,\n" "f = Function,\n" "m = Macro, #define\n" "s = Structure,\n" "t = Typedef,\n" "u = Union\n" "default = 'cdefstu'\n", metavar="TYPEKIND", default="cdefstu") parser.add_argument("-i", "--includes", dest="generate_includes", action="store_true", help="include declaration defined outside of the sourcefiles", default=False) parser.add_argument("-l","--include-librarie", dest="dlls", help="libraries to search for exported functions", action="append", default=[]) if os.name in ("ce", "nt"): default_modules = ["ctypes.wintypes"] else: default_modules = [] # ctypes is already imported parser.add_argument("-m","--module", dest="modules", metavar="module", help="Python module(s) containing symbols which will " "be imported instead of generated", action="append", default=default_modules) parser.add_argument("-o","--output", dest="output", help="output filename (if not specified, standard output will be used)", default="-") parser.add_argument("-p","--preload", dest="preload", metavar="DLL", help="dlls to be loaded before all others (to resolve symbols)", action="append", default=[]) parser.add_argument("-q","--quiet", action="store_true", dest="quiet", help="Shut down warnings and below", default="False") parser.add_argument("-r","--regex", dest="expressions", metavar="EXPRESSION", action="append", help="regular expression for symbols to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_argument("-s","--symbol", dest="symbols", metavar="SYMBOL", action="append", help="symbol to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_argument("-t","--target", dest="target", help="target architecture (default: %s)"%(local_platform_triple), default=None) # actually let clang alone decide. parser.add_argument("-v","--verbose", action="store_true", dest="verbose", help="verbose output", default=False) parser.add_argument('-V', '--version', action='version', version="%(prog)s version "+version) parser.add_argument("-w", action="store", default=windows_dlls, help="add all standard windows dlls to the searched dlls list") parser.add_argument("-x","--exclude-includes", action="store_true", default=False, help="Parse object in sources files only. Ignore includes") parser.add_argument("--show-ids", dest="showIDs", help="Don't compute cursor IDs (very slow)", default=False) parser.add_argument("--max-depth", dest="maxDepth", help="Limit cursor expansion to depth N", metavar="N", type=int, default=None) # recognize - as stdin # we do NOT support stdin parser.add_argument("files", nargs="+", help="source filenames. stdin is not supported", type=argparse.FileType('r')) parser.add_argument("--clang-args", action="store", default=None, required=False, help="clang options", type=str) parser.epilog = """Cross-architecture: You can pass target modifiers to clang. For example, try "-target x86_64" or "-target i386-linux" as the last argument to change the target CPU arch.""" options = parser.parse_args() # handle stdin, just in case files = [] for f in options.files: if f == sys.stdin: raise ValueError('stdin is not supported') files.append(f.name) f.close() #files = [f.name for f in options.files] if options.target is not None: clang_opts = ["-target",options.target] if options.clang_args is not None: clang_opts.extend(options.clang_args.split(" ")) level = logging.INFO if options.debug: level = logging.DEBUG elif options.quiet: level = logging.ERROR logging.basicConfig(level=level, stream=sys.stderr) if options.output == "-": stream = sys.stdout else: stream = open(options.output, "w") if options.expressions: options.expressions = map(re.compile, options.expressions) if options.generate_comments: stream.write("# generated by 'clang2py'\n") stream.write("# flags '%s'\n" % " ".join(argv[1:])) known_symbols = {} from ctypes import CDLL, RTLD_LOCAL, RTLD_GLOBAL from ctypes.util import find_library # local library finding def load_library(name, mode=RTLD_LOCAL): if os.name == "nt": from ctypes import WinDLL # WinDLL does demangle the __stdcall names, so use that. return WinDLL(name, mode=mode) path = find_library(name) if path is None: # Maybe 'name' is not a library name in the linker style, # give CDLL a last chance to find the library. path = name return CDLL(path, mode=mode) preloaded_dlls = [ load_library( name, mode=RTLD_GLOBAL) for name in options.preload] dlls = [load_library(name) for name in options.dlls] for name in options.modules: mod = __import__(name) for submodule in name.split(".")[1:]: mod = getattr(mod, submodule) for name, item in mod.__dict__.iteritems(): if isinstance(item, type): known_symbols[name] = mod.__name__ type_table = {"a": [typedesc.Alias], "c": [typedesc.Structure], "d": [typedesc.Variable], "e": [typedesc.Enumeration], # , typedesc.EnumValue], "f": [typedesc.Function], "m": [typedesc.Macro], "s": [typedesc.Structure], "t": [typedesc.Typedef], "u": [typedesc.Union], } if options.kind: types = [] for char in options.kind: try: typ = type_table[char] except KeyError: parser.error( "%s is not a valid choice for a TYPEKIND" % (char)) types.extend(typ) options.kind = tuple(types) generate_code(files, stream, symbols=options.symbols, expressions=options.expressions, verbose=options.verbose, generate_comments=options.generate_comments, generate_docstrings=options.generate_docstrings, generate_locations=options.generate_locations, filter_location=not options.generate_includes, known_symbols=known_symbols, searched_dlls=dlls, preloaded_dlls=options.preload, types=options.kind, flags=clang_opts)
def main(argv=None): if argv is None: argv = sys.argv[1:] local_platform_triple = "%s-%s" % (platform.machine(), platform.system()) clang_opts = [] files = None def windows_dlls(option, opt, value, parser): parser.values.dlls.extend(windows_dll_names) version = ctypeslib.__version__ parser = argparse.ArgumentParser(prog='clang2py', description='Version %s. Generate python code from C headers' % (version)) parser.add_argument("-c", "--comments", dest="generate_comments", action="store_true", help="include source doxygen-style comments", default=False) parser.add_argument("-d", "--doc", dest="generate_docstrings", action="store_true", help="include docstrings containing C prototype and source file location", default=False) parser.add_argument("--debug", action="store_const", const=True, help='setLevel to DEBUG') parser.add_argument("-e", "--show-definition-location", dest="generate_locations", action="store_true", help="include source file location in comments", default=False) parser.add_argument("-k", "--kind", action="store", dest="kind", help="kind of type descriptions to include: " "a = Alias,\n" "c = Class,\n" "d = Variable,\n" "e = Enumeration,\n" "f = Function,\n" "m = Macro, #define\n" "s = Structure,\n" "t = Typedef,\n" "u = Union\n" "default = 'cdefstu'\n", metavar="TYPEKIND", default="cdefstu") parser.add_argument("-i", "--includes", dest="generate_includes", action="store_true", help="include declaration defined outside of the sourcefiles", default=False) parser.add_argument("-l", "--include-library", dest="dll", help="library to search for exported functions. Add multiple times if required", action="append", default=[]) if os.name in ("ce", "nt"): default_modules = ["ctypes.wintypes"] else: default_modules = [] # ctypes is already imported parser.add_argument("-m", "--module", dest="modules", metavar="module", help="Python module(s) containing symbols which will " "be imported instead of generated", action="append", default=default_modules) parser.add_argument("--nm", dest="nm", default="nm", help="nm program to use to extract symbols from libraries") parser.add_argument("-o", "--output", dest="output", help="output filename (if not specified, standard output will be used)", default="-") parser.add_argument("-p", "--preload", dest="preload", metavar="DLL", help="dll to be loaded before all others (to resolve symbols)", action="append", default=[]) parser.add_argument("-q", "--quiet", action="store_const", const="quiet", help="Shut down warnings and below", default=False) parser.add_argument("-r", "--regex", dest="expressions", metavar="EXPRESSION", action="append", help="regular expression for symbols to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_argument("-s", "--symbol", dest="symbols", metavar="SYMBOL", action="append", help="symbol to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_argument("-t", "--target", dest="target", help="target architecture (default: %s)" % local_platform_triple, default=None) # actually let clang alone decide. parser.add_argument("-v", "--verbose", action="store_true", dest="verbose", help="verbose output", default=False) parser.add_argument('-V', '--version', action='version', version="%(prog)s version " + version + " clang: " + clang_version()) parser.add_argument("-w", action="store", default=windows_dlls, help="add all standard windows dlls to the searched dlls list") parser.add_argument("-x", "--exclude-includes", action="store_true", default=False, help="Parse object in sources files only. Ignore includes") parser.add_argument("--show-ids", dest="showIDs", help="Don't compute cursor IDs (very slow)", default=False) parser.add_argument("--max-depth", dest="maxDepth", help="Limit cursor expansion to depth N", metavar="N", type=int, default=None) # recognize - as stdin # we do NOT support stdin parser.add_argument("files", nargs="+", help="source filenames. stdin is not supported", type=argparse.FileType('r')) parser.add_argument("--clang-args", action="store", default=None, required=False, help="clang options, in quotes: --clang-args=\"-std=c99 -Wall\"", type=str) parser.epilog = """Cross-architecture: You can pass target modifiers to clang. For example, try --clang-args="-target x86_64" or "-target i386-linux" to change the target CPU arch.""" options = parser.parse_args(argv) # handle stdin files = [] _stdin = None for f in options.files: if f == sys.stdin: import tempfile _stdin = tempfile.NamedTemporaryFile(mode="w", prefix="stdin", suffix=".c", delete=False) _stdin.write(f.read()) f = _stdin files.append(f.name) f.close() # files = [f.name for f in options.files] if options.target is not None: clang_opts = ["-target", options.target] if options.clang_args is not None: clang_opts.extend(re.split("\s+", options.clang_args)) level = logging.INFO if options.debug: level = logging.DEBUG elif options.quiet: level = logging.ERROR logging.basicConfig(level=level, stream=sys.stderr) if options.output == "-": stream = sys.stdout output_file = None else: stream = open(options.output, "w") output_file = stream if options.expressions: options.expressions = map(re.compile, options.expressions) if options.generate_comments: stream.write("# generated by 'clang2py'\n") stream.write("# flags '%s'\n" % " ".join(argv[1:])) known_symbols = {} # Preload libraries [Library( name, mode=RTLD_GLOBAL) for name in options.preload] # List exported symbols from libraries dlls = [Library(name, nm=options.nm) for name in options.dll] for name in options.modules: mod = __import__(name) for submodule in name.split(".")[1:]: mod = getattr(mod, submodule) for name, item in mod.__dict__.items(): if isinstance(item, type): known_symbols[name] = mod.__name__ type_table = {"a": [typedesc.Alias], "c": [typedesc.Structure], "d": [typedesc.Variable], "e": [typedesc.Enumeration], # , typedesc.EnumValue], "f": [typedesc.Function], "m": [typedesc.Macro], "s": [typedesc.Structure], "t": [typedesc.Typedef], "u": [typedesc.Union], } if options.kind: types = [] for char in options.kind: try: typ = type_table[char] types.extend(typ) except KeyError: parser.error("%s is not a valid choice for a TYPEKIND" % char) options.kind = tuple(types) try: generate_code(files, stream, symbols=options.symbols, expressions=options.expressions, verbose=options.verbose, generate_comments=options.generate_comments, generate_docstrings=options.generate_docstrings, generate_locations=options.generate_locations, filter_location=not options.generate_includes, known_symbols=known_symbols, searched_dlls=dlls, preloaded_dlls=options.preload, types=options.kind, flags=clang_opts) finally: if output_file is not None: output_file.close() os.remove(options.output) if _stdin: os.remove(_stdin.name) return 0
def main(argv=None): if argv is None: argv = sys.argv def windows_dlls(option, opt, value, parser): parser.values.dlls.extend(windows_dll_names) parser = OptionParser("usage: %prog xmlfile [options]") parser.add_option("-c", action="store_true", dest="generate_comments", help="include source file location in comments", default=False) parser.add_option( "-d", action="store_true", dest="generate_docstrings", help= "include docstrings containing C prototype and source file location", default=False) parser.add_option("-k", action="store", dest="kind", help="kind of type descriptions to include: " "d = #defines, " "e = enumerations, " "f = functions, " "s = structures, " "t = typedefs", metavar="TYPEKIND", default=None) parser.add_option("-l", dest="dlls", help="libraries to search for exported functions", action="append", default=[]) parser.add_option( "-o", dest="output", help="output filename (if not specified, standard output will be used)", default="-") parser.add_option("-r", dest="expressions", metavar="EXPRESSION", action="append", help="regular expression for symbols to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_option("-s", dest="symbols", metavar="SYMBOL", action="append", help="symbol to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_option("-v", action="store_true", dest="verbose", help="verbose output", default=False) parser.add_option( "-w", action="callback", callback=windows_dlls, help="add all standard windows dlls to the searched dlls list") if os.name in ("ce", "nt"): default_modules = ["ctypes.wintypes", "ctypes"] else: default_modules = ["ctypes"] parser.add_option("-m", dest="modules", metavar="module", help="Python module(s) containing symbols which will " "be imported instead of generated", action="append", default=default_modules) parser.add_option( "--preload", dest="preload", metavar="DLL", help="dlls to be loaded before all others (to resolve symbols)", action="append", default=[]) options, files = parser.parse_args(argv[1:]) if len(files) != 1: parser.error("Exactly one input file must be specified") if options.output == "-": stream = sys.stdout else: stream = open(options.output, "w") if options.expressions: options.expressions = map(re.compile, options.expressions) if options.generate_comments: stream.write("# generated by 'xml2py'\n") stream.write("# flags '%s'\n" % " ".join(argv[1:])) known_symbols = {} from ctypes import CDLL, RTLD_LOCAL, RTLD_GLOBAL from ctypes.util import find_library def load_library(name, mode=RTLD_LOCAL): if os.name == "nt": return CDLL(name, mode=mode) path = find_library(name) if path is None: # Maybe 'name' is not a library name in the linker style, # give CDLL a last chance to find the library. path = name return CDLL(path, mode=mode) preloaded_dlls = [ load_library(name, mode=RTLD_GLOBAL) for name in options.preload ] dlls = [load_library(name) for name in options.dlls] for name in options.modules: mod = __import__(name) for submodule in name.split(".")[1:]: mod = getattr(mod, submodule) for name, item in mod.__dict__.iteritems(): if isinstance(item, type): known_symbols[name] = mod.__name__ if options.kind: types = [] for char in options.kind: typ = { "a": [typedesc.Alias], "d": [typedesc.Variable], "e": [typedesc.Enumeration, typedesc.EnumValue], "f": [typedesc.Function], "m": [typedesc.Macro], "s": [typedesc.Structure], "t": [typedesc.Typedef], }[char] types.extend(typ) options.kind = tuple(types) generate_code(files[0], stream, symbols=options.symbols, expressions=options.expressions, verbose=options.verbose, generate_comments=options.generate_comments, generate_docstrings=options.generate_docstrings, known_symbols=known_symbols, searched_dlls=dlls, preloaded_dlls=options.preload, types=options.kind)
def main(argv=None): if argv is None: argv = sys.argv local_platform_triple = "%s-%s" % (platform.machine(), platform.system()) clang_opts = [] files = None def windows_dlls(option, opt, value, parser): parser.values.dlls.extend(windows_dll_names) version = ctypeslib.__version__ parser = argparse.ArgumentParser( prog='clang2py', description='Version %s. Generate python code from C headers' % (version)) parser.add_argument("-c", "--comments", dest="generate_comments", action="store_true", help="include source doxygen-style comments", default=False) parser.add_argument( "-d", "--doc", dest="generate_docstrings", action="store_true", help= "include docstrings containing C prototype and source file location", default=False) parser.add_argument("--debug", action="store_const", const=True, help='setLevel to DEBUG') parser.add_argument("-e", "--show-definition-location", dest="generate_locations", action="store_true", help="include source file location in comments", default=False) parser.add_argument("-k", "--kind", action="store", dest="kind", help="kind of type descriptions to include: " "a = Alias,\n" "c = Class,\n" "d = Variable,\n" "e = Enumeration,\n" "f = Function,\n" "m = Macro, #define\n" "s = Structure,\n" "t = Typedef,\n" "u = Union\n" "default = 'cdefstu'\n", metavar="TYPEKIND", default="cdefstu") parser.add_argument( "-i", "--includes", dest="generate_includes", action="store_true", help="include declaration defined outside of the sourcefiles", default=False) parser.add_argument( "-l", "--include-library", dest="dll", help= "library to search for exported functions. Add multiple times if required", action="append", default=[]) if os.name in ("ce", "nt"): default_modules = ["ctypes.wintypes"] else: default_modules = [] # ctypes is already imported parser.add_argument("-m", "--module", dest="modules", metavar="module", help="Python module(s) containing symbols which will " "be imported instead of generated", action="append", default=default_modules) parser.add_argument( "-o", "--output", dest="output", help="output filename (if not specified, standard output will be used)", default="-") parser.add_argument( "-p", "--preload", dest="preload", metavar="DLL", help="dll to be loaded before all others (to resolve symbols)", action="append", default=[]) parser.add_argument("-q", "--quiet", action="store_const", const="quiet", help="Shut down warnings and below", default=False) parser.add_argument("-r", "--regex", dest="expressions", metavar="EXPRESSION", action="append", help="regular expression for symbols to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_argument("-s", "--symbol", dest="symbols", metavar="SYMBOL", action="append", help="symbol to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_argument("-t", "--target", dest="target", help="target architecture (default: %s)" % local_platform_triple, default=None) # actually let clang alone decide. parser.add_argument("-v", "--verbose", action="store_true", dest="verbose", help="verbose output", default=False) parser.add_argument('-V', '--version', action='version', version="%(prog)s version " + version) parser.add_argument( "-w", action="store", default=windows_dlls, help="add all standard windows dlls to the searched dlls list") parser.add_argument( "-x", "--exclude-includes", action="store_true", default=False, help="Parse object in sources files only. Ignore includes") parser.add_argument("--show-ids", dest="showIDs", help="Don't compute cursor IDs (very slow)", default=False) parser.add_argument("--max-depth", dest="maxDepth", help="Limit cursor expansion to depth N", metavar="N", type=int, default=None) parser.add_argument( "--use-ctypes-pointer", dest="use_ctypes_pointer", action='store_true', help="Use ctypes POINTER instead of the platform independent POINTER_T." ) parser.add_argument( "--rename", dest="rename_patterns", action='append', help= "Specify patterns to substitute generated names. Each pattern must be specified as two " "fields separated by a comma. The first field is a regex expresssion and the second is a " "text to substitute ocurrences of the regex on a name. E.G. --regex=\"foo,bar\". You can " "use this option more than once. Be sure that names will not conflict or unexpected " "behaviour can happen.") # recognize - as stdin # we do NOT support stdin parser.add_argument("files", nargs="+", help="source filenames. stdin is not supported", type=argparse.FileType('r')) parser.add_argument( "--clang-args", action="store", default=None, required=False, help="clang options, in quotes: --clang-args=\"-std=c99 -Wall\"", type=str) parser.epilog = """Cross-architecture: You can pass target modifiers to clang. For example, try --clang-args="-target x86_64" or "-target i386-linux" to change the target CPU arch.""" options = parser.parse_args() # handle stdin, just in case files = [] for f in options.files: if f == sys.stdin: raise ValueError('stdin is not supported') files.append(f.name) f.close() # files = [f.name for f in options.files] if options.target is not None: clang_opts = ["-target", options.target] if options.clang_args is not None: clang_opts.extend(options.clang_args.split(" ")) level = logging.INFO if options.debug: level = logging.DEBUG elif options.quiet: level = logging.ERROR logging.basicConfig(level=level, stream=sys.stderr) if options.output == "-": stream = sys.stdout else: stream = open(options.output, "w") if options.expressions: options.expressions = map(re.compile, options.expressions) if options.generate_comments: stream.write("# generated by 'clang2py'\n") stream.write("# flags '%s'\n" % " ".join(argv[1:])) known_symbols = {} from ctypes import CDLL, RTLD_LOCAL, RTLD_GLOBAL from ctypes.util import find_library # local library finding def load_library(name, mode=RTLD_LOCAL): if os.name == "nt": from ctypes import WinDLL # WinDLL does demangle the __stdcall names, so use that. return WinDLL(name, mode=mode) path = find_library(name) if path is None: # Maybe 'name' is not a library name in the linker style, # give CDLL a last chance to find the library. path = name return CDLL(path, mode=mode) preloaded_dlls = [ load_library(name, mode=RTLD_GLOBAL) for name in options.preload ] dlls = [load_library(name) for name in options.dll] for name in options.modules: mod = __import__(name) for submodule in name.split(".")[1:]: mod = getattr(mod, submodule) for name, item in mod.__dict__.items(): if isinstance(item, type): known_symbols[name] = mod.__name__ type_table = { "a": [typedesc.Alias], "c": [typedesc.Structure], "d": [typedesc.Variable], "e": [typedesc.Enumeration], # , typedesc.EnumValue], "f": [typedesc.Function], "m": [typedesc.Macro], "s": [typedesc.Structure], "t": [typedesc.Typedef], "u": [typedesc.Union], } if options.kind: types = [] for char in options.kind: try: typ = type_table[char] types.extend(typ) except KeyError: parser.error("%s is not a valid choice for a TYPEKIND" % char) options.kind = tuple(types) generate_code(files, stream, symbols=options.symbols, expressions=options.expressions, verbose=options.verbose, generate_comments=options.generate_comments, generate_docstrings=options.generate_docstrings, generate_locations=options.generate_locations, filter_location=not options.generate_includes, known_symbols=known_symbols, searched_dlls=dlls, preloaded_dlls=options.preload, generate_pointer_t=not options.use_ctypes_pointer, rename_patterns=options.rename_patterns, types=options.kind, flags=clang_opts)
def main(argv=None): if argv is None: argv = sys.argv def windows_dlls(option, opt, value, parser): parser.values.dlls.extend(windows_dll_names) parser = argparse.ArgumentParser(prog='clang2py', description='generate python ABI code from C code') parser.add_argument("--debug", dest="debug", action="store_const", const=True, help='setLevel to DEBUG') parser.add_argument("-c", dest="generate_comments", action="store_true", help="include source file location in comments", default=False) parser.add_argument("-d", dest="generate_docstrings", action="store_true", help="include docstrings containing C prototype and source file location", default=False) parser.add_argument("-k", action="store", dest="kind", help="kind of type descriptions to include: " "d = #defines, " "e = enumerations, " "f = functions, " "s = structures, " "t = typedefs", metavar="TYPEKIND", default=None) parser.add_argument("-l", dest="dlls", help="libraries to search for exported functions", action="append", default=[]) parser.add_argument("-o", dest="output", help="output filename (if not specified, standard output will be used)", default="-") parser.add_argument("-r", dest="expressions", metavar="EXPRESSION", action="append", help="regular expression for symbols to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_argument("-s", dest="symbols", metavar="SYMBOL", action="append", help="symbol to include " "(if neither symbols nor expressions are specified," "everything will be included)", default=None) parser.add_argument("-v", action="store_true", dest="verbose", help="verbose output", default=False) parser.add_argument("-w", action="store", default=windows_dlls, help="add all standard windows dlls to the searched dlls list") if os.name in ("ce", "nt"): default_modules = ["ctypes.wintypes" ] else: default_modules = [ ] # ctypes is already imported parser.add_argument("-m", dest="modules", metavar="module", help="Python module(s) containing symbols which will " "be imported instead of generated", action="append", default=default_modules) parser.add_argument("--preload", dest="preload", metavar="DLL", help="dlls to be loaded before all others (to resolve symbols)", action="append", default=[]) parser.add_argument("--show-ids", dest="showIDs", help="Don't compute cursor IDs (very slow)", default=False) parser.add_argument("--max-depth", dest="maxDepth", help="Limit cursor expansion to depth N", metavar="N", type=int, default=None) parser.add_argument("files", nargs="+", help="source filenames", type=argparse.FileType('r')) #parser.add_argument("clang-opts", required=False, help="clang options", type=str) parser.epilog = '''About clang-args: You can pass modifier to clang after your file name. For example, try "-target x86_64" or "-target i386-linux" as the last argument to change the target CPU arch.''' options,clang_opts = parser.parse_known_args() files = [f.name for f in options.files] level=logging.INFO if options.debug: level=logging.DEBUG logging.basicConfig(level=level, stream=sys.stderr) if options.output == "-": stream = sys.stdout else: stream = open(options.output, "w") if options.expressions: options.expressions = map(re.compile, options.expressions) if options.generate_comments: stream.write("# generated by 'clang2py'\n") stream.write("# flags '%s'\n" % " ".join(argv[1:])) known_symbols = {} from ctypes import CDLL, RTLD_LOCAL, RTLD_GLOBAL from ctypes.util import find_library def load_library(name, mode=RTLD_LOCAL): if os.name == "nt": from ctypes import WinDLL # WinDLL does demangle the __stdcall names, so use that. return WinDLL(name, mode=mode) path = find_library(name) if path is None: # Maybe 'name' is not a library name in the linker style, # give CDLL a last chance to find the library. path = name return CDLL(path, mode=mode) preloaded_dlls = [load_library(name, mode=RTLD_GLOBAL) for name in options.preload] dlls = [load_library(name) for name in options.dlls] for name in options.modules: mod = __import__(name) for submodule in name.split(".")[1:]: mod = getattr(mod, submodule) for name, item in mod.__dict__.iteritems(): if isinstance(item, type): known_symbols[name] = mod.__name__ if options.kind: types = [] for char in options.kind: typ = {"a": [typedesc.Alias], "d": [typedesc.Variable], "e": [typedesc.Enumeration, typedesc.EnumValue], "f": [typedesc.Function], "m": [typedesc.Macro], "s": [typedesc.Structure], "t": [typedesc.Typedef], }[char] types.extend(typ) options.kind = tuple(types) generate_code(files, stream, symbols=options.symbols, expressions=options.expressions, verbose=options.verbose, generate_comments=options.generate_comments, generate_docstrings=options.generate_docstrings, known_symbols=known_symbols, searched_dlls=dlls, preloaded_dlls=options.preload, types=options.kind, flags=clang_opts)