Move glfw build code into setup.py

This was on my TODO list for a long time and doing this allows the
setup.py module code to be re-used in slang.py

Author: kovidgoyal

glfw/__init__.py

@@ -2,234 +2,13 @@
 # vim:fileencoding=utf-8
 # License: GPL v3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
 
-import json
 import os
 import re
-import subprocess
 import sys
-from enum import Enum
-from typing import Any, Callable, Dict, List, NamedTuple, Optional, Sequence, Tuple
 
 _plat = sys.platform.lower()
 is_linux = 'linux' in _plat
 is_openbsd = 'openbsd' in _plat
-base = os.path.dirname(os.path.abspath(__file__))
-
-
-def null_func() -> None:
-    return None
-
-
-class CompileKey(NamedTuple):
-    src: str
-    dest: str
-
-
-class Command(NamedTuple):
-    desc: str
-    cmd: Sequence[str]
-    is_newer_func: Callable[[], bool]
-    on_success: Callable[[], None] = null_func
-    key: Optional[CompileKey] = None
-    keyfile: Optional[str] = None
-
-
-class ISA(Enum):
-    X86 = 0x03
-    AMD64 = 0x3e
-    ARM64 = 0xb7
-    Other = 0x0
-
-
-class BinaryArch(NamedTuple):
-    bits: int = 64
-    isa: ISA = ISA.AMD64
-
-
-class CompilerType(Enum):
-    gcc = 'gcc'
-    clang = 'clang'
-    unknown = 'unknown'
-
-
-class Env:
-
-    cc: List[str] = []
-    cppflags: List[str] = []
-    cflags: List[str] = []
-    ldflags: List[str] = []
-    library_paths: Dict[str, List[str]] = {}
-    ldpaths: List[str] = []
-    ccver: Tuple[int, int]
-    vcs_rev: str = ''
-    binary_arch: BinaryArch = BinaryArch()
-    native_optimizations: bool = False
-    primary_version: int = 0
-    secondary_version: int = 0
-    xt_version: str = ''
-    has_copy_file_range: bool = False
-
-    # glfw stuff
-    all_headers: List[str] = []
-    sources: List[str] = []
-    wayland_packagedir: str = ''
-    wayland_scanner: str = ''
-    wayland_scanner_code: str = ''
-    wayland_protocols: Tuple[str, ...] = ()
-
-    def __init__(
-        self, cc: List[str] = [], cppflags: List[str] = [], cflags: List[str] = [], ldflags: List[str] = [],
-        library_paths: Dict[str, List[str]] = {}, ldpaths: Optional[List[str]] = None, ccver: Tuple[int, int] = (0, 0),
-        vcs_rev: str = '', binary_arch: BinaryArch = BinaryArch(),
-        native_optimizations: bool = False,
-    ):
-        self.cc, self.cppflags, self.cflags, self.ldflags, self.library_paths = cc, cppflags, cflags, ldflags, library_paths
-        self.ldpaths = ldpaths or []
-        self.ccver = ccver
-        self.vcs_rev = vcs_rev
-        self.binary_arch = binary_arch
-        self.native_optimizations = native_optimizations
-        self._cc_version_string = ''
-        self._compiler_type: Optional[CompilerType] = None
-
-    @property
-    def cc_version_string(self) -> str:
-        if not self._cc_version_string:
-            self._cc_version_string = subprocess.check_output(self.cc + ['--version']).decode()
-        return self._cc_version_string
-
-    @property
-    def compiler_type(self) -> CompilerType:
-        if self._compiler_type is None:
-            raw = self.cc_version_string
-            if 'Free Software Foundation' in raw:
-                self._compiler_type = CompilerType.gcc
-            elif 'clang' in raw.lower().split():
-                self._compiler_type = CompilerType.clang
-            else:
-                self._compiler_type = CompilerType.unknown
-        return self._compiler_type
-
-    def copy(self) -> 'Env':
-        ans = Env(self.cc, list(self.cppflags), list(self.cflags), list(self.ldflags), dict(self.library_paths), list(self.ldpaths), self.ccver)
-        ans.all_headers = list(self.all_headers)
-        ans._cc_version_string = self._cc_version_string
-        ans.sources = list(self.sources)
-        ans.wayland_packagedir = self.wayland_packagedir
-        ans.wayland_scanner = self.wayland_scanner
-        ans.wayland_scanner_code = self.wayland_scanner_code
-        ans.wayland_protocols = self.wayland_protocols
-        ans.vcs_rev = self.vcs_rev
-        ans.binary_arch = self.binary_arch
-        ans.native_optimizations = self.native_optimizations
-        ans.primary_version = self.primary_version
-        ans.secondary_version = self.secondary_version
-        ans.xt_version = self.xt_version
-        ans.has_copy_file_range = self.has_copy_file_range
-        return ans
-
-
-def wayland_protocol_file_name(base: str, ext: str = 'c') -> str:
-    base = os.path.basename(base).rpartition('.')[0]
-    return f'wayland-{base}-client-protocol.{ext}'
-
-
-def init_env(
-    env: Env,
-    pkg_config: Callable[..., List[str]],
-    pkg_version: Callable[[str], Tuple[int, int]],
-    at_least_version: Callable[..., None],
-    test_compile: Callable[..., Any],
-    module: str = 'x11'
-) -> Env:
-    ans = env.copy()
-    ans.cflags.append('-fPIC')
-    ans.cppflags.append(f'-D_GLFW_{module.upper()}')
-    ans.cppflags.append('-D_GLFW_BUILD_DLL')
-
-    with open(os.path.join(base, 'source-info.json')) as f:
-        sinfo = json.load(f)
-    module_sources = list(sinfo[module]['sources'])
-    if module in ('x11', 'wayland'):
-        remove = 'null_joystick.c' if is_linux else 'linux_joystick.c'
-        module_sources.remove(remove)
-
-    ans.sources = sinfo['common']['sources'] + module_sources
-    ans.all_headers = [x for x in os.listdir(base) if x.endswith('.h')]
-
-    if module in ('x11', 'wayland'):
-        ans.cflags.append('-pthread')
-        ans.ldpaths.extend('-pthread -lm'.split())
-        if not is_openbsd:
-            ans.ldpaths.extend('-lrt -ldl'.split())
-        major, minor = pkg_version('xkbcommon')
-        if (major, minor) < (0, 5):
-            raise SystemExit('libxkbcommon >= 0.5 required')
-        if major < 1:
-            ans.cflags.append('-DXKB_HAS_NO_UTF32')
-
-    if module == 'x11':
-        for dep in 'x11 xrandr xinerama xcursor xkbcommon xkbcommon-x11 x11-xcb dbus-1'.split():
-            ans.cflags.extend(pkg_config(dep, '--cflags-only-I'))
-            ans.ldpaths.extend(pkg_config(dep, '--libs'))
-
-    elif module == 'cocoa':
-        ans.cppflags.append('-DGL_SILENCE_DEPRECATION')
-        for f_ in 'Cocoa IOKit CoreFoundation CoreVideo QuartzCore UniformTypeIdentifiers'.split():
-            ans.ldpaths.extend(('-framework', f_))
-
-    elif module == 'wayland':
-        at_least_version('wayland-protocols', *sinfo['wayland_protocols'])
-        ans.wayland_packagedir = os.path.abspath(pkg_config('wayland-protocols', '--variable=pkgdatadir')[0])
-        ans.wayland_scanner = os.path.abspath(pkg_config('wayland-scanner', '--variable=wayland_scanner')[0])
-        scanner_version = tuple(map(int, pkg_config('wayland-scanner', '--modversion')[0].strip().split('.')))
-        ans.wayland_scanner_code = 'private-code' if scanner_version >= (1, 14, 91) else 'code'
-        ans.wayland_protocols = tuple(sinfo[module]['protocols'])
-        for p in ans.wayland_protocols:
-            ans.sources.append(wayland_protocol_file_name(p))
-            ans.all_headers.append(wayland_protocol_file_name(p, 'h'))
-        for dep in 'wayland-client wayland-cursor xkbcommon dbus-1'.split():
-            ans.cflags.extend(pkg_config(dep, '--cflags-only-I'))
-            ans.ldpaths.extend(pkg_config(dep, '--libs'))
-        has_memfd_create = test_compile(env.cc, '-Werror', src='''#define _GNU_SOURCE
-    #include <unistd.h>
-    #include <sys/syscall.h>
-    int main(void) {
-        return syscall(__NR_memfd_create, "test", 0);
-    }''')
-        if has_memfd_create:
-            ans.cppflags.append('-DHAS_MEMFD_CREATE')
-
-    return ans
-
-
-def build_wayland_protocols(
-    env: Env,
-    parallel_run: Callable[[List[Command]], None],
-    emphasis: Callable[[str], str],
-    newer: Callable[..., bool],
-    dest_dir: str
-) -> None:
-    items = []
-    for protocol in env.wayland_protocols:
-        if '/' in protocol:
-            src = os.path.join(env.wayland_packagedir, protocol)
-            if not os.path.exists(src):
-                raise SystemExit(f'The wayland-protocols package on your system is missing the {protocol} protocol definition file')
-        else:
-            src = os.path.join(os.path.dirname(os.path.abspath(__file__)), protocol)
-            if not os.path.exists(src):
-                raise SystemExit(f'The local Wayland protocol {protocol} is missing from kitty sources')
-        for ext in 'hc':
-            dest = wayland_protocol_file_name(src, ext)
-            dest = os.path.join(dest_dir, dest)
-            if newer(dest, src):
-                q = 'client-header' if ext == 'h' else env.wayland_scanner_code
-                items.append(Command(
-                    f'Generating {emphasis(os.path.basename(dest))} ...',
-                    [env.wayland_scanner, q, src, dest], lambda: True))
-    if items:
-        parallel_run(items)
 
 
 class Arg:

glfw/glfw.py

@@ -404,6 +404,8 @@ def create_specialisations(sources: dict[str, SlangFile], build_dir: str, dest_d
 
 
 def compile_builtin_shaders(build_dir: str, dest_dir: str, parallel_run: ParallelRun) -> None:
+    os.makedirs(build_dir, exist_ok=True)
+    os.makedirs(dest_dir, exist_ok=True)
     src_dir = os.path.abspath('kitty/shaders')
     source_tree = get_ordered_sources_in_tree(src_dir)
     # First ensure all IR is generated