kitty/bypy/devenv.go
Saadanjum0 7c9144350d devenv: Escape spaces when relocating pkg-config prefixes
relocate_pkgconfig() substitutes the real, absolute dependency path into
the downloaded .pc files by plain byte replacement. pkg-config tokenizes
Cflags/Libs on unescaped whitespace, so when that path contains a space
(for example a checkout under "Desktop/My Projects/kitty") the emitted
-I/-L flags get truncated at the first space and the build fails with
errors like "hb.h file not found", even though the dependency is right
there on disk.

Escape spaces (and literal backslashes) in the new prefix before writing
it into a .pc file so pkg-config round-trips it correctly. The same
function also relocates paths inside _sysconfigdata_*.py, which is a
plain Python string rather than something pkg-config parses, so that case
is left unescaped.

Likely the cause of #8939: the reporter's checkout was under
"3. Ressources" and the -I flags in that log are truncated at the space.
2026-10-02 17:47:34 +05:00

466 lines
12 KiB
Go

// License: GPLv3 Copyright: 2023, Kovid Goyal, <kovid at kovidgoyal.net>
package main
import (
"bufio"
"bytes"
"errors"
"flag"
"fmt"
"io"
"io/fs"
"net/http"
"os"
"os/exec"
"path/filepath"
"regexp"
"runtime"
"strings"
)
const (
folder = "dependencies"
fonts_folder = "fonts"
macos_prefix = "/Users/Shared/kitty-build/sw/sw"
macos_python = "python/Python.framework/Versions/Current/bin/python3"
macos_python_framework = "python/Python.framework/Versions/Current/Python"
macos_python_framework_exe = "python/Python.framework/Versions/Current/Resources/Python.app/Contents/MacOS/Python"
NERD_URL = "https://github.com/ryanoasis/nerd-fonts/releases/latest/download/NerdFontsSymbolsOnly.tar.xz"
)
func root_dir() string {
f, e := filepath.Abs(filepath.Join(folder, runtime.GOOS+"-"+runtime.GOARCH))
if e != nil {
exit(e)
}
return f
}
func fonts_dir() string {
f, e := filepath.Abs(fonts_folder)
if e != nil {
exit(e)
}
return f
}
var _ = fmt.Print
func exit(x any) {
switch v := x.(type) {
case error:
if v == nil {
os.Exit(0)
}
var ee *exec.ExitError
if errors.As(v, &ee) {
os.Exit(ee.ExitCode())
}
case string:
if v == "" {
os.Exit(0)
}
case int:
os.Exit(v)
}
fmt.Fprintf(os.Stderr, "\x1b[31mError\x1b[m: %s\n", x)
os.Exit(1)
}
// download deps {{{
type dependency struct {
path string
basename string
is_id bool
}
func lines(exe string, cmd ...string) []string {
c := exec.Command(exe, cmd...)
c.Stderr = os.Stderr
out, err := c.Output()
if err != nil {
exit(fmt.Errorf("Failed to run '%s' with error: %w", strings.Join(append([]string{exe}, cmd...), " "), err))
}
ans := []string{}
for s := bufio.NewScanner(bytes.NewReader(out)); s.Scan(); {
ans = append(ans, s.Text())
}
return ans
}
func get_dependencies(path string) (ans []dependency) {
a := lines("otool", "-D", path)
install_name := strings.TrimSpace(a[len(a)-1])
for _, line := range lines("otool", "-L", path) {
line = strings.TrimSpace(line)
if strings.Contains(line, "compatibility") && !strings.HasSuffix(line, ":") {
before, _, _ := strings.Cut(line, "(")
dep := strings.TrimSpace(before)
ans = append(ans, dependency{path: dep, is_id: dep == install_name})
}
}
return
}
func get_local_dependencies(path string) (ans []dependency) {
for _, dep := range get_dependencies(path) {
for _, y := range []string{filepath.Join(macos_prefix, "lib") + "/", filepath.Join(macos_prefix, "python", "Python.framework") + "/", "@rpath/"} {
if strings.HasPrefix(dep.path, y) {
if y == "@rpath/" {
dep.basename = "lib/" + dep.path[len(y):]
} else {
y = macos_prefix + "/"
dep.basename = dep.path[len(y):]
}
ans = append(ans, dep)
break
}
}
}
return
}
func change_dep(path string, dep dependency) {
cmd := []string{}
fid := filepath.Join(root_dir(), dep.basename)
if dep.is_id {
cmd = append(cmd, "-id", fid)
} else {
cmd = append(cmd, "-change", dep.path, fid)
}
cmd = append(cmd, path)
c := exec.Command("install_name_tool", cmd...)
c.Stdout = os.Stdout
c.Stderr = os.Stderr
if err := c.Run(); err != nil {
exit(fmt.Errorf("Failed to run command '%s' with error: %w", strings.Join(c.Args, " "), err))
}
}
func fix_dependencies_in_lib(path string) {
path, err := filepath.EvalSymlinks(path)
if err != nil {
exit(err)
}
if s, err := os.Stat(path); err != nil {
exit(err)
} else if err := os.Chmod(path, s.Mode().Perm()|0o200); err != nil {
exit(err)
}
for _, dep := range get_local_dependencies(path) {
change_dep(path, dep)
}
if ldeps := get_local_dependencies(path); len(ldeps) > 0 {
exit(fmt.Errorf("Failed to fix local dependencies in: %s", path))
}
}
func cached_download(url string) string {
fname := filepath.Base(url)
fmt.Println("Downloading", fname)
req, err := http.NewRequest("GET", url, nil)
if err != nil {
exit(err)
}
etag_file := filepath.Join(folder, fname+".etag")
if etag, err := os.ReadFile(etag_file); err == nil {
if _, err := os.Stat(filepath.Join(folder, fname)); err == nil {
req.Header.Add("If-None-Match", string(etag))
}
}
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
exit(err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
if resp.StatusCode == http.StatusNotModified {
return filepath.Join(folder, fname)
}
exit(fmt.Errorf("The server responded with the HTTP error: %s", resp.Status))
}
f, err := os.Create(filepath.Join(folder, fname))
if err != nil {
exit(err)
}
defer f.Close()
if _, err := io.Copy(f, resp.Body); err != nil {
exit(fmt.Errorf("Failed to download file with error: %w", err))
}
if etag := resp.Header.Get("ETag"); etag != "" {
if err := os.WriteFile(etag_file, []byte(etag), 0o644); err != nil {
exit(err)
}
}
return f.Name()
}
func relocate_pkgconfig(path, old_prefix, new_prefix string) error {
raw, err := os.ReadFile(path)
if err != nil {
return err
}
replacement := new_prefix
if filepath.Ext(path) == ".pc" {
// pkg-config tokenizes Cflags/Libs on unescaped whitespace, so a
// prefix containing a space must have that space backslash-escaped,
// otherwise `pkg-config --cflags`/`--libs` silently truncates the
// path at the first space, breaking the build whenever the checkout
// lives under a directory with a space in its name.
replacement = strings.NewReplacer(`\`, `\\`, ` `, `\ `).Replace(new_prefix)
}
nraw := bytes.ReplaceAll(raw, []byte(old_prefix), []byte(replacement))
return os.WriteFile(path, nraw, 0o644)
}
func chdir_to_base() {
_, filename, _, _ := runtime.Caller(0)
base_dir := filepath.Dir(filepath.Dir(filename))
if err := os.Chdir(base_dir); err != nil {
exit(err)
}
}
func dependencies_for_docs() {
fmt.Println("Downloading get-pip.py")
rq, err := http.Get("https://bootstrap.pypa.io/get-pip.py")
if err != nil {
exit(err)
}
defer rq.Body.Close()
if rq.StatusCode != http.StatusOK {
exit(fmt.Errorf("Server responded with HTTP error: %s", rq.Status))
}
gp, err := os.Create(filepath.Join(folder, "get-pip.py"))
if err != nil {
exit(err)
}
defer gp.Close()
if _, err = io.Copy(gp, rq.Body); err != nil {
exit(err)
}
python := setup_to_run_python()
run := func(exe string, args ...string) {
c := exec.Command(exe, args...)
c.Stdout = os.Stdout
c.Stderr = os.Stderr
if err := c.Run(); err != nil {
exit(err)
}
}
run(python, gp.Name())
run(python, "-m", "pip", "install", "-r", "docs/requirements.txt")
}
func dependencies(args []string) {
chdir_to_base()
nf := flag.NewFlagSet("deps", flag.ExitOnError)
docsptr := nf.Bool("for-docs", false, "download the dependencies needed to build the documentation")
if err := nf.Parse(args); err != nil {
exit(err)
}
if *docsptr {
dependencies_for_docs()
fmt.Println("Dependencies needed to generate documentation have been installed. Build docs with ./dev.sh docs")
exit(0)
}
data, err := os.ReadFile(".github/workflows/ci.py")
if err != nil {
exit(err)
}
pat := regexp.MustCompile("BUNDLE_URL = '(.+?)'")
prefix := "/sw/sw"
var url string
if m := pat.FindStringSubmatch(string(data)); len(m) < 2 {
exit("Failed to find BUNDLE_URL in ci.py")
} else {
url = m[1]
}
var which string
switch runtime.GOOS {
case "darwin":
prefix = macos_prefix
which = "macos"
case "linux":
which = "linux"
switch runtime.GOARCH {
case "amd64":
case "arm64", "arm64be":
url = strings.Replace(url, "-64.", "-arm64.", 1)
default:
exit(fmt.Sprintf("Pre-built binaries are not available for the %s architecture", runtime.GOARCH))
}
}
if which == "" {
exit("Prebuilt dependencies are only available for Linux and macOS")
}
url = strings.Replace(url, "{}", which, 1)
if err := os.RemoveAll(root_dir()); err != nil {
exit(err)
}
if err := os.MkdirAll(folder, 0o755); err != nil {
exit(err)
}
tarfile, _ := filepath.Abs(cached_download(url))
root := root_dir()
if err := os.MkdirAll(root, 0o755); err != nil {
exit(err)
}
cmd := exec.Command("tar", "xf", tarfile)
cmd.Dir = root
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err = cmd.Run(); err != nil {
exit(err)
}
if runtime.GOOS == "darwin" {
fix_dependencies_in_lib(filepath.Join(root, macos_python))
fix_dependencies_in_lib(filepath.Join(root, macos_python_framework))
fix_dependencies_in_lib(filepath.Join(root, macos_python_framework_exe))
}
if err = filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
if err != nil {
return err
}
if d.Type().IsRegular() {
name := d.Name()
ext := filepath.Ext(name)
if ext == ".pc" || (ext == ".py" && strings.HasPrefix(name, "_sysconfigdata_")) {
err = relocate_pkgconfig(path, prefix, root)
}
// remove libfontconfig so that we use the system one because
// different distros stupidly use different fontconfig configuration dirs
if strings.HasPrefix(name, "libfontconfig.so") {
os.Remove(path)
}
if runtime.GOOS == "darwin" {
if ext == ".so" || ext == ".dylib" {
fix_dependencies_in_lib(path)
}
}
}
return err
}); err != nil {
exit(err)
}
tarfile, _ = filepath.Abs(cached_download(NERD_URL))
root = fonts_dir()
if err := os.MkdirAll(root, 0o755); err != nil {
exit(err)
}
cmd = exec.Command("tar", "xf", tarfile, "SymbolsNerdFontMono-Regular.ttf")
cmd.Dir = root
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err = cmd.Run(); err != nil {
exit(err)
}
fmt.Println(`Dependencies downloaded. Now build kitty with: ./dev.sh build`)
}
// }}}
func prepend(env_var, path string) {
val := os.Getenv(env_var)
if val != "" {
val = string(filepath.ListSeparator) + val
}
os.Setenv(env_var, path+val)
}
func setup_to_run_python() (python string) {
root := root_dir()
for _, x := range os.Environ() {
if strings.HasPrefix(x, "PYTHON") {
a, _, _ := strings.Cut(x, "=")
os.Unsetenv(a)
}
}
switch runtime.GOOS {
case "linux":
prepend("LD_LIBRARY_PATH", filepath.Join(root, "lib"))
os.Setenv("PYTHONHOME", root)
python = filepath.Join(root, "bin", "python")
case `darwin`:
python = filepath.Join(root, macos_python)
default:
exit("Building is only supported on Linux and macOS")
}
return
}
func build(args []string) {
chdir_to_base()
if _, err := os.Stat(folder); err != nil {
dependencies(nil)
}
root := root_dir()
os.Setenv("DEVELOP_ROOT", root)
os.Setenv("SLANGC", filepath.Join(root, "bin", "slangc"))
prepend("PKG_CONFIG_PATH", filepath.Join(root, "lib", "pkgconfig"))
if runtime.GOOS == "darwin" {
os.Setenv("PKGCONFIG_EXE", filepath.Join(root, "bin", "pkg-config"))
}
python := setup_to_run_python()
args = append([]string{"setup.py", "develop"}, args...)
cmd := exec.Command(python, args...)
cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
if err := cmd.Run(); err != nil {
fmt.Fprintln(os.Stderr, "The following build command failed:", python, strings.Join(args, " "))
exit(err)
}
fmt.Println("Build successful. Run kitty as: kitty/launcher/kitty")
}
func docs(args []string) {
setup_to_run_python()
nf := flag.NewFlagSet("deps", flag.ExitOnError)
livereload := nf.Bool("live-reload", false, "build the docs and make them available via s local server with live reloading for ease of development")
failwarn := nf.Bool("fail-warn", false, "make warnings fatal when building the docs")
if err := nf.Parse(args); err != nil {
exit(err)
}
exe := filepath.Join(root_dir(), "bin", "sphinx-build")
aexe := filepath.Join(root_dir(), "bin", "sphinx-autobuild")
target := "docs"
if *livereload {
target = "develop-docs"
}
cmd := []string{target, "SPHINXBUILD=" + exe, "SPHINXAUTOBUILD=" + aexe}
if *failwarn {
cmd = append(cmd, "FAIL_WARN=1")
}
c := exec.Command("make", cmd...)
c.Stdout = os.Stdout
c.Stderr = os.Stderr
err := c.Run()
if err != nil {
exit(err)
}
fmt.Println("docs successfully built")
}
func main() {
if len(os.Args) < 2 {
exit(`Expected "deps" or "build" subcommands`)
}
switch os.Args[1] {
case "deps":
dependencies(os.Args[2:])
case "build":
build(os.Args[2:])
case "docs":
docs(os.Args[2:])
case "-h", "--help":
fmt.Fprintln(os.Stderr, "Usage: ./dev.sh [build|deps|docs] [options...]")
default:
exit(`Expected "deps" or "build" subcommands`)
}
}