mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-25 12:56:06 +00:00
b9c1b51e45
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
217 lines
7.5 KiB
Python
217 lines
7.5 KiB
Python
#!/usr/bin/env python
|
|
|
|
"""
|
|
SWIG generation client. Supports both local and remote generation of SWIG
|
|
bindings for multiple languages.
|
|
"""
|
|
|
|
# Future imports
|
|
from __future__ import absolute_import
|
|
from __future__ import print_function
|
|
|
|
# Python modules
|
|
import argparse
|
|
import io
|
|
import logging
|
|
import os
|
|
import socket
|
|
import struct
|
|
import sys
|
|
|
|
# LLDB modules
|
|
import use_lldb_suite
|
|
from lldbsuite.support import fs
|
|
from lldbsuite.support import sockutil
|
|
|
|
# package imports
|
|
from . import local
|
|
from . import remote
|
|
|
|
default_ip = "127.0.0.1"
|
|
default_port = 8537
|
|
|
|
|
|
def add_subparser_args(parser):
|
|
"""Returns options processed from the provided command line.
|
|
|
|
@param args the command line to process.
|
|
"""
|
|
|
|
# A custom action used by the --local command line option. It can be
|
|
# used with either 0 or 1 argument. If used with 0 arguments, it
|
|
# searches for a copy of swig located on the physical machine. If
|
|
# used with 1 argument, the argument is the path to a swig executable.
|
|
class FindLocalSwigAction(argparse.Action):
|
|
|
|
def __init__(self, option_strings, dest, **kwargs):
|
|
super(FindLocalSwigAction, self).__init__(
|
|
option_strings, dest, nargs='?', **kwargs)
|
|
|
|
def __call__(self, parser, namespace, values, option_string=None):
|
|
swig_exe = None
|
|
if values is None:
|
|
swig_exe = fs.find_executable('swig')
|
|
else:
|
|
swig_exe = values
|
|
setattr(namespace, self.dest, os.path.normpath(swig_exe))
|
|
|
|
# A custom action used by the --remote command line option. It can be
|
|
# used with either 0 or 1 arguments. If used with 0 arguments it chooses
|
|
# a default connection string. If used with one argument it is a string
|
|
# of the form `ip_address[:port]`. If the port is unspecified, the
|
|
# default port is used.
|
|
class RemoteIpAction(argparse.Action):
|
|
|
|
def __init__(self, option_strings, dest, **kwargs):
|
|
super(RemoteIpAction, self).__init__(
|
|
option_strings, dest, nargs='?', **kwargs)
|
|
|
|
def __call__(self, parser, namespace, values, option_string=None):
|
|
ip_port = None
|
|
if values is None:
|
|
ip_port = (default_ip, default_port)
|
|
else:
|
|
result = values.split(':')
|
|
if len(result) == 1:
|
|
ip_port = (result[0], default_port)
|
|
elif len(result) == 2:
|
|
ip_port = (result[0], int(result[1]))
|
|
else:
|
|
raise ValueError("Invalid connection string")
|
|
setattr(namespace, self.dest, ip_port)
|
|
|
|
parser.add_argument(
|
|
"--local",
|
|
action=FindLocalSwigAction,
|
|
dest="swig_executable",
|
|
help=(
|
|
"Run the copy of swig at the specified location, or search PATH"
|
|
"if the location is omitted"))
|
|
|
|
parser.add_argument(
|
|
"--remote",
|
|
action=RemoteIpAction,
|
|
help=(
|
|
"Use the given connection string to connect to a remote "
|
|
"generation service"))
|
|
|
|
parser.add_argument(
|
|
"--src-root",
|
|
required=True,
|
|
help="The root folder of the LLDB source tree.")
|
|
|
|
parser.add_argument(
|
|
"--target-dir",
|
|
default=os.getcwd(),
|
|
help=(
|
|
"Specifies the build dir where the language binding "
|
|
"should be placed"))
|
|
|
|
parser.add_argument(
|
|
"--language",
|
|
dest="languages",
|
|
action="append",
|
|
help="Specifies the language to generate bindings for")
|
|
|
|
|
|
def finalize_subparser_options(options):
|
|
if options.languages is None:
|
|
options.languages = ['python']
|
|
|
|
if options.remote is None and options.swig_executable is None:
|
|
logging.error("Must specify either --local or --remote")
|
|
sys.exit(-3)
|
|
|
|
return options
|
|
|
|
|
|
def establish_remote_connection(ip_port):
|
|
logging.debug("Creating socket...")
|
|
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
logging.info("Connecting to server {} on port {}"
|
|
.format(ip_port[0], ip_port[1]))
|
|
s.connect(ip_port)
|
|
logging.info("Connection established...")
|
|
return s
|
|
|
|
|
|
def transmit_request(connection, packed_input):
|
|
logging.info("Sending {} bytes of compressed data."
|
|
.format(len(packed_input)))
|
|
connection.sendall(struct.pack("!I", len(packed_input)))
|
|
connection.sendall(packed_input)
|
|
logging.info("Awaiting response.")
|
|
response_len = struct.unpack("!I", sockutil.recvall(connection, 4))[0]
|
|
logging.debug("Expecting {} byte response".format(response_len))
|
|
response = sockutil.recvall(connection, response_len)
|
|
return response
|
|
|
|
|
|
def handle_response(options, connection, response):
|
|
logging.debug("Received {} byte response.".format(len(response)))
|
|
logging.debug("Creating output directory {}"
|
|
.format(options.target_dir))
|
|
os.makedirs(options.target_dir, exist_ok=True)
|
|
|
|
logging.info("Unpacking response archive into {}"
|
|
.format(options.target_dir))
|
|
local.unpack_archive(options.target_dir, response)
|
|
response_file_path = os.path.normpath(
|
|
os.path.join(options.target_dir, "swig_output.json"))
|
|
if not os.path.isfile(response_file_path):
|
|
logging.error("Response file '{}' does not exist."
|
|
.format(response_file_path))
|
|
return
|
|
try:
|
|
response = remote.deserialize_response_status(
|
|
io.open(response_file_path))
|
|
if response[0] != 0:
|
|
logging.error("An error occurred during generation. Status={}"
|
|
.format(response[0]))
|
|
logging.error(response[1])
|
|
else:
|
|
logging.info("SWIG generation successful.")
|
|
if len(response[1]) > 0:
|
|
logging.info(response[1])
|
|
finally:
|
|
os.unlink(response_file_path)
|
|
|
|
|
|
def run(options):
|
|
if options.remote is None:
|
|
logging.info("swig bot client using local swig installation at '{}'"
|
|
.format(options.swig_executable))
|
|
if not os.path.isfile(options.swig_executable):
|
|
logging.error("Swig executable '{}' does not exist."
|
|
.format(options.swig_executable))
|
|
config = local.LocalConfig()
|
|
config.languages = options.languages
|
|
config.src_root = options.src_root
|
|
config.target_dir = options.target_dir
|
|
config.swig_executable = options.swig_executable
|
|
local.generate(config)
|
|
else:
|
|
logging.info("swig bot client using remote generation with server '{}'"
|
|
.format(options.remote))
|
|
connection = None
|
|
try:
|
|
config = remote.generate_config(options.languages)
|
|
logging.debug("Generated config json {}".format(config))
|
|
inputs = [("include/lldb", ".h"),
|
|
("include/lldb/API", ".h"),
|
|
("scripts", ".swig"),
|
|
("scripts/Python", ".swig"),
|
|
("scripts/interface", ".i")]
|
|
zip_data = io.BytesIO()
|
|
packed_input = local.pack_archive(
|
|
zip_data, options.src_root, inputs)
|
|
logging.info("(null) -> config.json")
|
|
packed_input.writestr("config.json", config)
|
|
packed_input.close()
|
|
connection = establish_remote_connection(options.remote)
|
|
response = transmit_request(connection, zip_data.getvalue())
|
|
handle_response(options, connection, response)
|
|
finally:
|
|
if connection is not None:
|
|
connection.close()
|