mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-08-05 23:59:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Meta: Do not pass arguments around as kwargs in ladybird.py

Browse source 
Use proper function arguments instead.
This commit is contained in:
Timothy Flynn 2025-05-21 16:31:12 -04:00 • committed by Andrew Kaster
commit 620a2b7598
Notes: github-actions[bot] 2025-05-21 22:57:22 +00:00
1 changed files with 77 additions and 91 deletions
Download patch file Download diff file Expand all files Collapse all files

168
Meta/ladybird.py
View file

@ -155,10 +155,8 @@ def main(platform):
addr2line_parser.add_argument("addresses", nargs=argparse.REMAINDER) addr2line_parser.add_argument("addresses", nargs=argparse.REMAINDER)
args = parser.parse_args() args = parser.parse_args()
kwargs = vars(args)
command = kwargs.pop("command", None)
if not command: if not args.command:
parser.print_help() parser.print_help()
sys.exit(1) sys.exit(1)
@ -169,15 +167,15 @@ def main(platform):
print("ladybird.py must be run from a Visual Studio enabled environment", file=sys.stderr) print("ladybird.py must be run from a Visual Studio enabled environment", file=sys.stderr)
sys.exit(1) sys.exit(1)
if command == "build": if args.command == "build":
build_dir = configure_main(platform, **kwargs) build_dir = configure_main(platform, args.preset, args.cc, args.cxx)
build_main(build_dir, **kwargs) build_main(build_dir, args.target, args.args)
elif command == "test": elif args.command == "test":
build_dir = configure_main(platform, **kwargs) build_dir = configure_main(platform, args.preset, args.cc, args.cxx)
build_main(build_dir) build_main(build_dir)
test_main(build_dir, **kwargs) test_main(build_dir, args.preset, args.pattern)
elif command == "run": elif args.command == "run":
if kwargs.get("preset") == "Sanitizer": if args.preset == "Sanitizer":
# FIXME: Find some way to centralize these b/w CMakePresets.json, CI files, Documentation and here. # FIXME: Find some way to centralize these b/w CMakePresets.json, CI files, Documentation and here.
os.environ["ASAN_OPTIONS"] = os.environ.get( os.environ["ASAN_OPTIONS"] = os.environ.get(
"ASAN_OPTIONS", "ASAN_OPTIONS",
@ -187,41 +185,40 @@ def main(platform):
os.environ["UBSAN_OPTIONS"] = os.environ.get( os.environ["UBSAN_OPTIONS"] = os.environ.get(
"UBSAN_OPTIONS", "print_stacktrace=1:print_summary=1:halt_on_error=1" "UBSAN_OPTIONS", "print_stacktrace=1:print_summary=1:halt_on_error=1"
) )
build_dir = configure_main(platform, **kwargs) build_dir = configure_main(platform, args.preset, args.cc, args.cxx)
build_main(build_dir, **kwargs) build_main(build_dir, args.target, args.args)
run_main(platform.host_system, build_dir, **kwargs) run_main(platform.host_system, build_dir, args.target, args.args)
elif command == "debug": elif args.command == "debug":
build_dir = configure_main(platform, **kwargs) build_dir = configure_main(platform, args.preset, args.cc, args.cxx)
build_main(build_dir, **kwargs) build_main(build_dir, args.target, args.args)
debug_main(platform.host_system, build_dir, **kwargs) debug_main(platform.host_system, build_dir, args.target, args.debugger, args.cmd)
elif command == "install": elif args.command == "install":
build_dir = configure_main(platform, **kwargs) build_dir = configure_main(platform, args.preset, args.cc, args.cxx)
build_main(build_dir, **kwargs) build_main(build_dir, args.target, args.args)
kwargs["target"] = "install" build_main(build_dir, "install", args.args)
build_main(build_dir, **kwargs) elif args.command == "vcpkg":
elif command == "vcpkg": configure_build_env(args.preset, args.cc, args.cxx)
configure_build_env(**kwargs)
build_vcpkg() build_vcpkg()
elif command == "clean": elif args.command == "clean":
clean_main(**kwargs) clean_main(args.preset, args.cc, args.cxx)
elif command == "rebuild": elif args.command == "rebuild":
clean_main(**kwargs) clean_main(args.preset, args.cc, args.cxx)
build_dir = configure_main(platform, **kwargs) build_dir = configure_main(platform, args.preset, args.cc, args.cxx)
build_main(build_dir, **kwargs) build_main(build_dir, args.target, args.args)
elif command == "addr2line": elif args.command == "addr2line":
build_dir = configure_main(platform, **kwargs) build_dir = configure_main(platform, args.preset, args.cc, args.cxx)
build_main(build_dir, **kwargs) build_main(build_dir, args.target, args.args)
addr2line_main(build_dir, **kwargs) addr2line_main(build_dir, args.target, args.program, args.addresses)
def configure_main(platform, **kwargs): def configure_main(platform, preset: str, cc: str, cxx: str):
cmake_args = [] cmake_args = []
host_system = platform.host_system host_system = platform.host_system
if host_system == HostSystem.Linux and platform.host_architecture == HostArchitecture.AArch64: if host_system == HostSystem.Linux and platform.host_architecture == HostArchitecture.AArch64:
cmake_args.extend(configure_skia_jemalloc()) cmake_args.extend(configure_skia_jemalloc())
lb_source_dir, build_preset_dir, build_env_cmake_args = configure_build_env(**kwargs) lb_source_dir, build_preset_dir, build_env_cmake_args = configure_build_env(preset, cc, cxx)
if build_preset_dir.joinpath("build.ninja").exists() or build_preset_dir.joinpath("ladybird.sln").exists(): if build_preset_dir.joinpath("build.ninja").exists() or build_preset_dir.joinpath("ladybird.sln").exists():
return build_preset_dir return build_preset_dir
@ -232,7 +229,7 @@ def configure_main(platform, **kwargs):
config_args = [ config_args = [
"cmake", "cmake",
"--preset", "--preset",
kwargs.get("preset"), preset,
"-S", "-S",
lb_source_dir, lb_source_dir,
"-B", "-B",
@ -277,10 +274,7 @@ def configure_skia_jemalloc():
return cmake_args return cmake_args
def configure_build_env(**kwargs): def configure_build_env(preset: str, cc: str, cxx: str):
preset = kwargs.get("preset")
cc = kwargs.get("cc")
cxx = kwargs.get("cxx")
cmake_args = [] cmake_args = []
cmake_args.extend( cmake_args.extend(
[ [
@ -374,7 +368,7 @@ def ensure_ladybird_source_dir():
return ladybird_source_dir return ladybird_source_dir
def build_main(build_dir, **kwargs): def build_main(build_dir, target: str | None = None, args: list[str] = []):
build_args = [ build_args = [
"cmake", "cmake",
"--build", "--build",
@ -382,64 +376,63 @@ def build_main(build_dir, **kwargs):
"--parallel", "--parallel",
os.environ.get("MAKEJOBS", str(multiprocessing.cpu_count())), os.environ.get("MAKEJOBS", str(multiprocessing.cpu_count())),
] ]
build_target = kwargs.get("target", "") if target:
if build_target:
build_args.extend( build_args.extend(
[ [
"--target", "--target",
build_target, target,
] ]
) )
build_system_args = kwargs.get("args", [])
if build_system_args: if args:
build_args.append("--") build_args.append("--")
build_args.extend(build_system_args) build_args.extend(args)
try: try:
subprocess.check_call(build_args) subprocess.check_call(build_args)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
msg = "Unable to build ladybird " msg = "Unable to build ladybird "
if build_target: if target:
msg += f'target "{build_target}"' msg += f'target "{target}"'
else: else:
msg += "project" msg += "project"
print_process_stderr(e, msg) print_process_stderr(e, msg)
sys.exit(1) sys.exit(1)
def test_main(build_dir, **kwargs): def test_main(build_dir, preset: str, pattern: str | None):
build_preset = kwargs.get("preset")
test_args = [ test_args = [
"ctest", "ctest",
"--preset", "--preset",
build_preset, preset,
"--output-on-failure", "--output-on-failure",
"--test-dir", "--test-dir",
str(build_dir), str(build_dir),
] ]
test_name_pattern = kwargs.get("pattern", None)
if test_name_pattern: if pattern:
test_args.extend( test_args.extend(
[ [
"-R", "-R",
test_name_pattern, pattern,
] ]
) )
try: try:
subprocess.check_call(test_args) subprocess.check_call(test_args)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
msg = "Unable to test ladybird " msg = "Unable to test ladybird "
if test_name_pattern: if pattern:
msg += f'name pattern "{test_name_pattern}"' msg += f'name pattern "{pattern}"'
else: else:
msg += "project" msg += "project"
print_process_stderr(e, msg) print_process_stderr(e, msg)
sys.exit(1) sys.exit(1)
def run_main(host_system, build_dir, **kwargs): def run_main(host_system, build_dir, target: str, args: list[str]):
run_args = [] run_args = []
app_target = kwargs.get("target")
if host_system == HostSystem.macOS and app_target in ( if host_system == HostSystem.macOS and target in (
"headless-browser", "headless-browser",
"ImageDecoder", "ImageDecoder",
"Ladybird", "Ladybird",
@ -448,23 +441,21 @@ def run_main(host_system, build_dir, **kwargs):
"WebDriver", "WebDriver",
"WebWorker", "WebWorker",
): ):
run_args.append(str(build_dir.joinpath("bin", "Ladybird.app", "Contents", "MacOS", app_target))) run_args.append(str(build_dir.joinpath("bin", "Ladybird.app", "Contents", "MacOS", target)))
else: else:
run_args.append(str(build_dir.joinpath("bin", app_target))) run_args.append(str(build_dir.joinpath("bin", target)))
app_args = kwargs.get("args", [])
run_args.extend(app_args) run_args.extend(args)
try: try:
# FIXME: For Windows, set the working directory so DLLs are found # FIXME: For Windows, set the working directory so DLLs are found
subprocess.check_call(run_args) subprocess.check_call(run_args)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
print_process_stderr(e, f'Unable to run ladybird target "{app_target}"') print_process_stderr(e, f'Unable to run ladybird target "{target}"')
sys.exit(1) sys.exit(1)
def debug_main(host_system, build_dir, **kwargs): def debug_main(host_system, build_dir, target: str, debugger: str, debugger_commands: list[str]):
app_target = kwargs.get("target")
debugger = kwargs.get("debugger")
debugger_commands = kwargs.get("cmd", [])
debuggers = ["gdb", "lldb"] debuggers = ["gdb", "lldb"]
if debugger not in debuggers or not shutil.which(debugger): if debugger not in debuggers or not shutil.which(debugger):
print("Please install gdb or lldb!", file=sys.stderr) print("Please install gdb or lldb!", file=sys.stderr)
@ -479,55 +470,50 @@ def debug_main(host_system, build_dir, **kwargs):
cmd, cmd,
] ]
) )
if app_target == "Ladybird" and host_system == HostSystem.macOS: if target == "Ladybird" and host_system == HostSystem.macOS:
gdb_args.append(str(build_dir.joinpath("bin", "Ladybird.app"))) gdb_args.append(str(build_dir.joinpath("bin", "Ladybird.app")))
else: else:
gdb_args.append(str(build_dir.joinpath("bin", app_target))) gdb_args.append(str(build_dir.joinpath("bin", target)))
try: try:
# FIXME: For Windows, set the working directory so DLLs are found # FIXME: For Windows, set the working directory so DLLs are found
subprocess.check_call(gdb_args) subprocess.check_call(gdb_args)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
print_process_stderr(e, f'Unable to run ladybird target "{app_target}" with "{debugger}" debugger') print_process_stderr(e, f'Unable to run ladybird target "{target}" with "{debugger}" debugger')
sys.exit(1) sys.exit(1)
def clean_main(**kwargs): def clean_main(preset: str, cc: str, cxx: str):
lb_source_dir, build_preset_dir, _ = configure_build_env(**kwargs) lb_source_dir, build_preset_dir, _ = configure_build_env(preset, cc, cxx)
shutil.rmtree(str(build_preset_dir), ignore_errors=True) shutil.rmtree(str(build_preset_dir), ignore_errors=True)
user_vars_cmake_module = lb_source_dir.joinpath("Meta", "CMake", "vcpkg", "user-variables.cmake") user_vars_cmake_module = lb_source_dir.joinpath("Meta", "CMake", "vcpkg", "user-variables.cmake")
user_vars_cmake_module.unlink(missing_ok=True) user_vars_cmake_module.unlink(missing_ok=True)
def addr2line_main(build_dir, **kwargs): def addr2line_main(build_dir, target: str, program: str, addresses: list[str]):
addr2line_target = kwargs.get("target") if not shutil.which(program):
addr2line_program = kwargs.get("program") print(f"Please install {program}!", file=sys.stderr)
addr2line_addresses = kwargs.get("addresses", [])
if not shutil.which(addr2line_program):
print(f"Please install {addr2line_program}!", file=sys.stderr)
sys.exit(1) sys.exit(1)
binary_file_path = None binary_file_path = None
for root, _, files in os.walk(build_dir): for root, _, files in os.walk(build_dir):
if addr2line_target in files: if target in files:
candidate = Path(root) / addr2line_target candidate = Path(root) / target
if os.access(candidate, os.X_OK): if os.access(candidate, os.X_OK):
binary_file_path = str(candidate) binary_file_path = str(candidate)
if not binary_file_path: if not binary_file_path:
print(f'Unable to find binary target "{addr2line_target}" in build directory "{build_dir}"', file=sys.stderr) print(f'Unable to find binary target "{target}" in build directory "{build_dir}"', file=sys.stderr)
sys.exit(1) sys.exit(1)
addr2line_args = [ addr2line_args = [
addr2line_program, program,
"-o" if addr2line_program == "atos" else "-e", "-o" if program == "atos" else "-e",
binary_file_path, binary_file_path,
] ]
addr2line_args.extend(addr2line_addresses) addr2line_args.extend(addresses)
try: try:
subprocess.check_call(addr2line_args) subprocess.check_call(addr2line_args)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
print_process_stderr( print_process_stderr(e, f'Unable to find lines with "{program}" for binary target "{target}"')
e, f'Unable to find lines with "{addr2line_program}" for binary target ' f'{addr2line_target}"'
)
sys.exit(1) sys.exit(1)