libdash 0.5.2__tar.gz → 0.5.3__tar.gz

{libdash-0.5.2 → libdash-0.5.3}/MANIFEST.in

@@ -5,7 +5,7 @@ exclude src/dash
 exclude src/init.c src/mkinit
 exclude src/mknodes src/mksignames src/mksyntax
 exclude src/nodes.c src/nodes.h
-exclude src/signames.c
+exclude src/signames.c src/libdash_layout.c
 exclude src/syntax.c src/syntax.h
 exclude src/token.h
 prune src/.deps

{libdash-0.5.2/libdash.egg-info → libdash-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libdash
-Version: 0.5.2
+Version: 0.5.3
 Summary: Bindings for the dash shell as a library
 Author: PaSh contributors
 Author-email: Michael Greenberg <michael@greenberg.science>
@@ -124,9 +124,33 @@ For Python, see [`python/rt.py`](https://github.com/mgree/libdash/blob/master/py
 
 For OCaml, see [`ocaml/shell_to_json.ml`](https://github.com/mgree/libdash/blob/master/ocaml/shell_to_json.ml), a tool that parses shell syntax and produces JSON (using the [atdgen](https://opam.ocaml.org/packages/atdgen/) bindings).
 
-The ideal low-level interface to use is `parsecmd_safe` in `parser.c`; you'll need to ensure that dash's initialization routines have been called and that the stack marks are managed correctly. Parsing the POSIX shell is a complicated affair: beyond the usual locale issues, aliases affect the lexer, so one must use `setalias` and `unalias` to manage any aliases that ought to exist.
+The ideal low-level interface to use is `parsecmd_safe` in `parser.c`; you'll need to ensure that dash's initialization routines have been called and that the stack marks are managed correctly. Parsing the POSIX shell is a complicated affair: beyond the usual locale issues, aliases affect the lexer, so one must use `setalias_safe` and `unalias` to manage any aliases that ought to exist. Outside of `parsecmd_safe`, call only entry points that cannot raise a dash error (e.g., `setinputfile_safe` rather than `setinputfile`).
 
-# How work with the parsed nodes
+# Locales and multibyte characters
+
+dash's lexer decodes multibyte characters using the process's current
+`LC_CTYPE`. In a multibyte locale (e.g., `C.UTF-8`), each multibyte character
+is wrapped in `CTLMBCHAR` markers, and the bindings decode it to Unicode.
+In the `C` locale, it stays as raw bytes, and any byte that collides with a
+dash control code is escaped with `CTLESC`. The same script can therefore
+parse to different ASTs depending on the locale in effect when you parse.
+
+libdash never sets the locale for you:
+
+- The OCaml binding's `Dash.initialize` calls `initialize_dash_setlocale`,
+  i.e., `setlocale(LC_ALL, "")`, so it uses the environment's locale.
+- The Python binding uses whatever locale the interpreter set at startup.
+  Python calls `setlocale(LC_CTYPE, "")` and coerces a `C` locale to
+  `C.UTF-8` (PEP 538), so Python usually parses in UTF-8 even when the
+  environment says `C`.
+- Programs calling the C library directly (e.g., from C or another
+  language's FFI) stay in the `C` locale unless they call `setlocale` or
+  `initialize_dash_setlocale` themselves.
+
+To get the same ASTs from different bindings, set the same `LC_CTYPE` in
+each process before parsing.
+
+# How to work with parsed nodes
 
 The general AST is described in `nodes.h`. There are some tricky invariants around the precise formatting of control codes; the OCaml code shows some examples of working with the `args` fields in `ocaml/ast.ml`, which converts the C AST to an OCaml AST.
 

{libdash-0.5.2 → libdash-0.5.3}/README.md

@@ -52,9 +52,33 @@ For Python, see [`python/rt.py`](https://github.com/mgree/libdash/blob/master/py
 
 For OCaml, see [`ocaml/shell_to_json.ml`](https://github.com/mgree/libdash/blob/master/ocaml/shell_to_json.ml), a tool that parses shell syntax and produces JSON (using the [atdgen](https://opam.ocaml.org/packages/atdgen/) bindings).
 
-The ideal low-level interface to use is `parsecmd_safe` in `parser.c`; you'll need to ensure that dash's initialization routines have been called and that the stack marks are managed correctly. Parsing the POSIX shell is a complicated affair: beyond the usual locale issues, aliases affect the lexer, so one must use `setalias` and `unalias` to manage any aliases that ought to exist.
+The ideal low-level interface to use is `parsecmd_safe` in `parser.c`; you'll need to ensure that dash's initialization routines have been called and that the stack marks are managed correctly. Parsing the POSIX shell is a complicated affair: beyond the usual locale issues, aliases affect the lexer, so one must use `setalias_safe` and `unalias` to manage any aliases that ought to exist. Outside of `parsecmd_safe`, call only entry points that cannot raise a dash error (e.g., `setinputfile_safe` rather than `setinputfile`).
 
-# How work with the parsed nodes
+# Locales and multibyte characters
+
+dash's lexer decodes multibyte characters using the process's current
+`LC_CTYPE`. In a multibyte locale (e.g., `C.UTF-8`), each multibyte character
+is wrapped in `CTLMBCHAR` markers, and the bindings decode it to Unicode.
+In the `C` locale, it stays as raw bytes, and any byte that collides with a
+dash control code is escaped with `CTLESC`. The same script can therefore
+parse to different ASTs depending on the locale in effect when you parse.
+
+libdash never sets the locale for you:
+
+- The OCaml binding's `Dash.initialize` calls `initialize_dash_setlocale`,
+  i.e., `setlocale(LC_ALL, "")`, so it uses the environment's locale.
+- The Python binding uses whatever locale the interpreter set at startup.
+  Python calls `setlocale(LC_CTYPE, "")` and coerces a `C` locale to
+  `C.UTF-8` (PEP 538), so Python usually parses in UTF-8 even when the
+  environment says `C`.
+- Programs calling the C library directly (e.g., from C or another
+  language's FFI) stay in the `C` locale unless they call `setlocale` or
+  `initialize_dash_setlocale` themselves.
+
+To get the same ASTs from different bindings, set the same `LC_CTYPE` in
+each process before parsing.
+
+# How to work with parsed nodes
 
 The general AST is described in `nodes.h`. There are some tricky invariants around the precise formatting of control codes; the OCaml code shows some examples of working with the `args` fields in `ocaml/ast.ml`, which converts the C AST to an OCaml AST.
 

libdash-0.5.3/libdash/__init__.py

@@ -0,0 +1,3 @@
+from .parser import parse, check_layout
+from ._dash import LibdashLayoutError
+from .printer import to_string

{libdash-0.5.2 → libdash-0.5.3}/libdash/_dash.py

@@ -36,11 +36,12 @@ NNOT      = 25;
 #     size_t stacknleft;
 # };
 #
-# We only care about getting the struct size correct, not the contents.
+# The bindings use it only as an opaque buffer of this size; the fields
+# carry their C names so that the layout check covers them too.
 class stackmark (Structure):
-    _fields_ = [("stackp", c_void_p),
-                ("nxt",    c_void_p),
-                ("size",   c_size_t)];
+    _fields_ = [("stackp",     c_void_p),
+                ("stacknxt",   c_void_p),
+                ("stacknleft", c_size_t)];
 
 def init_stack (libdash):
     stack = create_string_buffer (sizeof (stackmark));
@@ -75,6 +76,7 @@ def initialize_dash_errno (libdash):
 
 
 def initialize (libdash):
+    require_layout (libdash);
     initialize_dash_errno (libdash);
     dash_init (libdash);
 
@@ -88,9 +90,24 @@ def setinputtostdin (libdash):
 
 # TODO: allow push parameter
 def setinputfile (libdash, filename):
-    libdash.setinputfile.argtypes = [c_char_p, c_int];
-    libdash.setinputfile.restypes = c_int;
-    libdash.setinputfile (filename.encode ('utf-8'), 0);
+    libdash.setinputfile_safe.argtypes = [c_char_p, c_int];
+    libdash.setinputfile_safe.restype = c_int;
+    if (libdash.setinputfile_safe (filename.encode ('utf-8'), 0) < 0):
+        raise OSError ("cannot open %s" % filename);
+
+
+def setalias (libdash, name, value):
+    libdash.setalias_safe.argtypes = [c_char_p, c_char_p];
+    libdash.setalias_safe.restype = c_int;
+    if (libdash.setalias_safe (name.encode ('utf-8'), value.encode ('utf-8')) != 0):
+        raise ValueError ("invalid alias name: %r" % name);
+
+
+def unalias (libdash, name):
+    """Returns True if `name` was an alias."""
+    libdash.unalias.argtypes = [c_char_p];
+    libdash.unalias.restype = c_int;
+    return (libdash.unalias (name.encode ('utf-8')) == 0);
 
 
 def parsecmd_safe (libdash, interactive):
@@ -261,6 +278,8 @@ class parsefile (Structure):
 #     /* Number of outstanding calls to pungetc. */
 #     int unget;
 # };
+#
+# No lleft: configure.ac defines SMALL unless dash is built --with-libedit.
 parsefile._fields_ = [("prev",        POINTER (parsefile)),
                       ("linno",       c_int),
                       ("fd",          c_int),
@@ -271,10 +290,123 @@ parsefile._fields_ = [("prev",        POINTER (parsefile)),
                       ("strpush",     POINTER (strpush)),
                       ("basestrpush", strpush),
                       ("spfree",      POINTER (strpush)),
-                      ("lleft",       c_int),
                       ("unget",       c_int)];
 
 
+# Every struct above, by its C name. libdash.so's libdash_struct_layout
+# (generated by src/mklayout from the same list in src/Makefile.am) holds
+# their real sizes and field offsets; require_layout compares the two.
+LAYOUT = [("struct stackmark",  stackmark),
+          ("struct nodelist",   nodelist),
+          ("union node",        union_node),
+          ("struct ncmd",       ncmd),
+          ("struct npipe",      npipe),
+          ("struct nredir",     nredir),
+          ("struct nbinary",    nbinary),
+          ("struct nif",        nif),
+          ("struct nfor",       nfor),
+          ("struct ncase",      ncase),
+          ("struct nclist",     nclist),
+          ("struct ndefun",     ndefun),
+          ("struct narg",       narg),
+          ("struct nfile",      nfile),
+          ("struct ndup",       ndup),
+          ("struct nhere",      nhere),
+          ("struct nnot",       nnot),
+          ("struct strpush",    strpush),
+          ("struct parsefile",  parsefile)];
+
+
+class LibdashLayoutError (Exception):
+    """The ctypes structs in libdash/_dash.py disagree with the ones
+    libdash.so was built with, so reading the AST would read the wrong
+    fields."""
+    pass;
+
+
+class _layout_row (Structure):
+    _fields_ = [("type",  c_char_p),
+                ("field", c_char_p),   # NULL: value is the sizeof type
+                ("value", c_size_t)];
+
+
+def library_layout (libdash):
+    """libdash.so's layout table, as {C type: (sizeof, {field: offset})},
+    with fields in declaration order."""
+    first = _layout_row.in_dll (libdash, "libdash_struct_layout");
+    rows = cast (addressof (first), POINTER (_layout_row));
+
+    out = {};
+    i = 0;
+    while (rows [i].type is not None):
+        row = rows [i];
+        ctype = row.type.decode ();
+        if (row.field is None):
+            out [ctype] = (row.value, {});
+        else:
+            out [ctype][1][row.field.decode ()] = row.value;
+        i += 1;
+
+    return out;
+
+
+def layout_problems (libdash, layout):
+    """How `layout` (rows like LAYOUT's) disagrees with libdash.so's table,
+    as a list of messages; empty if they agree."""
+    c = library_layout (libdash);
+    mine = dict (layout);
+    problems = [];
+
+    for ctype in c:
+        if ctype not in mine:
+            problems.append ("%s: in libdash.so, but has no ctypes mirror" % ctype);
+
+    for (ctype, cls) in layout:
+        if ctype not in c:
+            problems.append ("%s: has a ctypes mirror, but is not in libdash.so" % ctype);
+            continue;
+
+        (size, offsets) = c [ctype];
+        fields = [name for (name, _t) in cls._fields_];
+
+        if (sizeof (cls) != size):
+            problems.append ("%s: sizeof is %d in C, %d in ctypes"
+                             % (ctype, size, sizeof (cls)));
+
+        for (name, offset) in offsets.items ():
+            if name not in fields:
+                problems.append ("%s.%s: in C (offset %d), missing from ctypes"
+                                 % (ctype, name, offset));
+            elif (getattr (cls, name).offset != offset):
+                problems.append ("%s.%s: offset is %d in C, %d in ctypes"
+                                 % (ctype, name, offset, getattr (cls, name).offset));
+
+        for name in fields:
+            if name not in offsets:
+                problems.append ("%s.%s: in ctypes, not in C" % (ctype, name));
+
+    return problems;
+
+
+_layout_checked = False;
+
+def require_layout (libdash, force = False):
+    """Raises LibdashLayoutError unless LAYOUT matches libdash.so. Checks
+    once per process, unless `force`."""
+    global _layout_checked;
+
+    if (_layout_checked and not force):
+        return;
+
+    problems = layout_problems (libdash, LAYOUT);
+    if problems:
+        raise LibdashLayoutError (
+            "libdash/_dash.py's ctypes structs disagree with libdash.so:\n  "
+            + "\n  ".join (problems));
+
+    _layout_checked = True;
+
+
 # dash.ast
 # let rec nodelist (n : nodelist structure ptr) : (node union ptr) list =
 #   if nullptr n

{libdash-0.5.2 → libdash-0.5.3}/libdash/ast.py

@@ -230,12 +230,14 @@ def of_binary (n):
     return [of_node (n.nbinary.ch1), of_node (n.nbinary.ch2)]
 
 
-def to_arg (narg):
+def to_arg (narg, assign = False):
     s = explode_rev (narg.text)
     bqlist = narg.backquote
     stack = []
 
-    a = parse_arg (s, bqlist, stack)
+    # An assignment word starts with its name; tilde prefixes may only come
+    # after the first '=' (and after unquoted ':'s).
+    a = parse_arg (s, bqlist, stack, assign = assign, tilde_ok = not assign)
 
     assert (len (s) == 0)
     # assert (nullptr bqlist)
@@ -248,10 +250,26 @@ def to_arg (narg):
     return (a)
 
 
-def parse_arg (s, bqlist, stack):
+def parse_arg (s, bqlist, stack, assign = False, tilde_ok = False):
+    """`tilde_ok`: a tilde prefix may start here (the start of a word). In an
+    assignment (`assign`), one may also start right after the first '=' and
+    after any unquoted ':'."""
     acc = []
+    seen_len = 0
+    seen_equals = False
 
     while (True):
+        # after each new element, decide whether a tilde prefix may follow it
+        if (len (acc) != seen_len):
+            seen_len = len (acc)
+            last = acc [-1]
+
+            if (assign and not seen_equals and last == ["C", ORD_EQUALS]):
+                seen_equals = True
+                tilde_ok = True
+            else:
+                tilde_ok = assign and (last == ["C", ORD_COLON])
+
         s_len = len (s)
         # stack_len = len (stack)
 
@@ -324,7 +342,7 @@ def parse_arg (s, bqlist, stack):
 
                     stack.append (STACK_CTLVAR)
 
-                    a = parse_arg (s, bqlist, stack)
+                    a = parse_arg (s, bqlist, stack, assign = assign, tilde_ok = True)
 
                     v = ["V", [var_type (vstype), (t & 0x10 == 0x10), var_name, a]]
                 elif (len (s) >= 1):
@@ -424,7 +442,7 @@ def parse_arg (s, bqlist, stack):
 
                 stack.append (STACK_CTLARI)
 
-                a = parse_arg (s, bqlist, stack)
+                a = parse_arg (s, bqlist, stack, assign = assign)
 
                 # TODO: assert (stack = stack')
 
@@ -465,7 +483,7 @@ def parse_arg (s, bqlist, stack):
                     s.pop ()
                     stack.append (STACK_CTLQUO)
 
-                    a = parse_arg (s, bqlist, stack)
+                    a = parse_arg (s, bqlist, stack, assign = assign)
 
                     acc.append (["Q", a])
 
@@ -474,12 +492,17 @@ def parse_arg (s, bqlist, stack):
             elif (s [-1] == ORD_TILDE):
                 s.pop ()
 
-                if ((STACK_CTLQUO in stack) or (STACK_CTLARI in stack)):
+                # no tilde prefix here, in arithmetic, or in double quotes
+                if ((not tilde_ok) or (STACK_CTLQUO in stack) or (STACK_CTLARI in stack)):
                     acc.append (["C", ORD_TILDE])
                 else:
-                    uname = parse_tilde (s)
+                    (is_prefix, uname) = parse_tilde (s, assign)
 
-                    acc.append (["T", uname])
+                    if (is_prefix):
+                        acc.append (["T", uname])
+                    else:
+                        # interrupted: the ~ and what follows are ordinary
+                        acc.append (["C", ORD_TILDE])
 
             # (* ordinary character *)
             # | c::s,_ -> arg_char (C c) s bqlist stack
@@ -496,22 +519,26 @@ def stringOrNull (acc_str):
         return ["Some", acc_str]
 
 
-def parse_tilde (s):
-    acc_str = ""
+def parse_tilde (s, assign):
+    """Returns (True, uname) and consumes the tilde prefix at the end of the
+    reversed `s` (uname is "None" for the bare ~), or (False, None), leaving
+    `s` untouched, if there is no tilde prefix (see exptilde in
+    src/expand.c)."""
+    i = len (s)
 
     while (True):
-        if (s == []):
-            return stringOrNull (acc_str)
-        else:
-            s_last = s [-1]
+        i = i - 1
 
-            if (s_last in [CTLESC, CTLVAR, CTLQUOTEMARK, CTLBACKQ, CTLARI]):
-                return ("None")
-            elif (s_last in [CTLENDVAR, CTLENDARI, ORD_COLON, ORD_SLASH]):
-                return (stringOrNull (acc_str))
-            else:
-                c = s.pop ()
-                acc_str = acc_str + chr (c)
+        if ((i < 0) or (s [i] in [CTLENDVAR, CTLENDARI, ORD_SLASH])
+                or (assign and (s [i] == ORD_COLON))):
+            break
+        elif (s [i] in [CTLESC, CTLVAR, CTLQUOTEMARK, CTLBACKQ, CTLARI]):
+            return (False, None)
+
+    acc_str = "".join (chr (c) for c in reversed (s [i + 1:]))
+    del s [i + 1:]
+
+    return (True, stringOrNull (acc_str))
 
 
 def to_assign (a_rev):
@@ -551,7 +578,7 @@ def to_assigns (n):
             sys.stdout.flush ()
             os.abort ()
 
-        arg = to_arg (n.contents.narg)
+        arg = to_arg (n.contents.narg, assign = True)
 
         arg.reverse ()
         assigns.append (to_assign (arg))

{libdash-0.5.2 → libdash-0.5.3}/libdash/parser.py

@@ -16,6 +16,11 @@ def libdash_library_path():
     LIBDASH_LIBRARY_PATH = os.path.join(FILE_PATH, "libdash.so")
     return LIBDASH_LIBRARY_PATH
 
+def check_layout():
+    """Raises LibdashLayoutError if the bindings' ctypes structs disagree
+    with libdash.so's. parse() checks this itself before its first parse."""
+    require_layout(CDLL(libdash_library_path()), force=True)
+
 # parsefile->eof bit 1: set by preadbuffer at EOF, never cleared by pungetc.
 PARSEFILE_EOF = 2;
 

{libdash-0.5.2 → libdash-0.5.3/libdash.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libdash
-Version: 0.5.2
+Version: 0.5.3
 Summary: Bindings for the dash shell as a library
 Author: PaSh contributors
 Author-email: Michael Greenberg <michael@greenberg.science>
@@ -124,9 +124,33 @@ For Python, see [`python/rt.py`](https://github.com/mgree/libdash/blob/master/py
 
 For OCaml, see [`ocaml/shell_to_json.ml`](https://github.com/mgree/libdash/blob/master/ocaml/shell_to_json.ml), a tool that parses shell syntax and produces JSON (using the [atdgen](https://opam.ocaml.org/packages/atdgen/) bindings).
 
-The ideal low-level interface to use is `parsecmd_safe` in `parser.c`; you'll need to ensure that dash's initialization routines have been called and that the stack marks are managed correctly. Parsing the POSIX shell is a complicated affair: beyond the usual locale issues, aliases affect the lexer, so one must use `setalias` and `unalias` to manage any aliases that ought to exist.
+The ideal low-level interface to use is `parsecmd_safe` in `parser.c`; you'll need to ensure that dash's initialization routines have been called and that the stack marks are managed correctly. Parsing the POSIX shell is a complicated affair: beyond the usual locale issues, aliases affect the lexer, so one must use `setalias_safe` and `unalias` to manage any aliases that ought to exist. Outside of `parsecmd_safe`, call only entry points that cannot raise a dash error (e.g., `setinputfile_safe` rather than `setinputfile`).
 
-# How work with the parsed nodes
+# Locales and multibyte characters
+
+dash's lexer decodes multibyte characters using the process's current
+`LC_CTYPE`. In a multibyte locale (e.g., `C.UTF-8`), each multibyte character
+is wrapped in `CTLMBCHAR` markers, and the bindings decode it to Unicode.
+In the `C` locale, it stays as raw bytes, and any byte that collides with a
+dash control code is escaped with `CTLESC`. The same script can therefore
+parse to different ASTs depending on the locale in effect when you parse.
+
+libdash never sets the locale for you:
+
+- The OCaml binding's `Dash.initialize` calls `initialize_dash_setlocale`,
+  i.e., `setlocale(LC_ALL, "")`, so it uses the environment's locale.
+- The Python binding uses whatever locale the interpreter set at startup.
+  Python calls `setlocale(LC_CTYPE, "")` and coerces a `C` locale to
+  `C.UTF-8` (PEP 538), so Python usually parses in UTF-8 even when the
+  environment says `C`.
+- Programs calling the C library directly (e.g., from C or another
+  language's FFI) stay in the `C` locale unless they call `setlocale` or
+  `initialize_dash_setlocale` themselves.
+
+To get the same ASTs from different bindings, set the same `LC_CTYPE` in
+each process before parsing.
+
+# How to work with parsed nodes
 
 The general AST is described in `nodes.h`. There are some tricky invariants around the precise formatting of control codes; the OCaml code shows some examples of working with the `args` fields in `ocaml/ast.ml`, which converts the C AST to an OCaml AST.
 

{libdash-0.5.2 → libdash-0.5.3}/libdash.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ src/miscbltin.c
 src/miscbltin.h
 src/mkbuiltins
 src/mkinit.c
+src/mklayout
 src/mknodes.c
 src/mksignames.c
 src/mksyntax.c

{libdash-0.5.2 → libdash-0.5.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "libdash"
-version = "0.5.2"
+version = "0.5.3"
 authors = [
   { name="Michael Greenberg", email="michael@greenberg.science" },
   { name="PaSh contributors" },

libdash-0.5.3/setup.py

@@ -0,0 +1,146 @@
+from setuptools import Extension, setup
+from setuptools.command.build_ext import build_ext
+
+import os
+import platform
+import shutil
+import subprocess
+import sys
+
+from pathlib import Path
+
+HERE = Path(__file__).parent.resolve()
+long_description = (HERE / "README.md").read_text()
+
+# What autotools needs to build the library.
+SOURCES = ['configure.ac', 'Makefile.am', 'src']
+
+
+def git_lines(*args):
+    """The NUL-separated output of `git args` (which must include -z) in
+    HERE, or None if HERE isn't the top of a git work tree (e.g., an
+    unpacked sdist)."""
+    try:
+        top = subprocess.run(['git', 'rev-parse', '--show-toplevel'], cwd=HERE,
+                             capture_output=True, text=True)
+        if top.returncode != 0 or Path(top.stdout.strip()).resolve() != HERE:
+            return None
+        out = subprocess.run(['git', *args], cwd=HERE,
+                             capture_output=True, text=True, check=True)
+    except (OSError, subprocess.CalledProcessError):
+        return None
+    return [line for line in out.stdout.split('\0') if line]
+
+
+def source_files():
+    """The files under SOURCES, relative to HERE.
+
+    In a git checkout, exactly the tracked files, so that leftovers from an
+    in-tree build (e.g., a stale src/builtins.h) can never reach the build.
+    In an sdist, everything: MANIFEST.in chose what to pack."""
+    tracked = git_lines('ls-files', '-z', '--', *SOURCES)
+    if tracked is None:
+        return [str(f.relative_to(HERE))
+                for d in SOURCES
+                for f in ([HERE / d] if (HERE / d).is_file() else (HERE / d).rglob('*'))
+                if f.is_file()]
+
+    leftovers = git_lines('ls-files', '-z', '--others', '--', *SOURCES)
+    if leftovers:
+        print(f'warning: ignoring {len(leftovers)} untracked file(s) in the source tree, '
+              'e.g., from an in-tree build (`git clean -fdX src` removes them):',
+              file=sys.stderr)
+        for f in leftovers[:10]:
+            print(f'  {f}', file=sys.stderr)
+        if len(leftovers) > 10:
+            print(f'  ... and {len(leftovers) - 10} more', file=sys.stderr)
+    return tracked
+
+
+def try_exec(*cmds, cwd):
+    proc = subprocess.run(cmds, cwd=cwd)
+
+    if proc.returncode != 0:
+        print('`{}` failed'.format(' '.join(cmds)), file=sys.stderr)
+        proc.check_returncode()
+
+
+class AutotoolsLibrary(Extension):
+    """libdash's shared library, built by autotools and loaded with ctypes
+    (it is not a Python extension module)."""
+
+    def __init__(self, name):
+        super().__init__(name, sources=[])
+
+
+class libdash_build_ext(build_ext):
+    """Builds the library in a copy of the C sources under build_temp, so that
+    autoreconf, configure, and make never write into the source tree."""
+
+    def run(self):
+        self.build_autotools()
+
+    def package_dir(self):
+        # in place (e.g., editable installs): next to the Python sources
+        return HERE / 'libdash' if self.inplace else Path(self.build_lib) / 'libdash'
+
+    def library_names(self):
+        names = ['libdash.so']
+        if sys.platform == 'darwin':
+            names.append('libdash.dylib')
+        return names
+
+    def get_outputs(self):
+        return [str(self.package_dir() / name) for name in self.library_names()]
+
+    def get_output_mapping(self):
+        return {}
+
+    def build_autotools(self):
+        if sys.platform == 'darwin':
+            target_arch = os.environ.get("ARCHFLAGS")
+            build_arch = platform.machine()
+            if not target_arch:
+                target_arch = f"-arch {build_arch}"
+                os.environ["ARCHFLAGS"] = target_arch
+            if build_arch not in target_arch and "MACOSX_DEPLOYMENT_TARGET" not in os.environ:
+                os.environ["MACOSX_DEPLOYMENT_TARGET"] = "11.0"
+
+            # configure reads CFLAGS/LDFLAGS, not CCFLAGS; an explicit CFLAGS
+            # replaces autoconf's default -g -O2, so keep it
+            os.environ["CFLAGS"] = f'{os.environ.get("CFLAGS", "-g -O2")} {target_arch}'
+            os.environ["LDFLAGS"] = f'{os.environ.get("LDFLAGS", "")} {target_arch}'.strip()
+
+            print(f'ARCHFLAGS: {target_arch} MACOSX_DEPLOYMENT_TARGET: {os.environ.get("MACOSX_DEPLOYMENT_TARGET", "")} CFLAGS: {os.environ.get("CFLAGS")} LDFLAGS: {os.environ.get("LDFLAGS")}')
+
+        # A fresh copy every time: cibuildwheel builds every wheel from the
+        # same source tree, and objects from a previous build may target a
+        # different arch.
+        work = Path(self.build_temp).resolve() / 'autotools'
+        if work.exists():
+            shutil.rmtree(work)
+        work.mkdir(parents=True)
+
+        for f in source_files():
+            (work / f).parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(HERE / f, work / f)
+
+        try_exec('autoreconf', '--install', '--force', cwd=work)
+        try_exec('./configure', cwd=work)
+        try_exec('make', cwd=work)
+
+        dest = self.package_dir()
+        dest.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(work / 'src/.libs/dlldash.so', dest / 'libdash.so')
+        if sys.platform == 'darwin':
+            shutil.copy2(work / 'src/.libs/libdash.dylib', dest / 'libdash.dylib')
+
+
+setup(name='libdash',
+      packages=['libdash'],
+      ext_modules=[AutotoolsLibrary('libdash.libdash')],
+      cmdclass={'build_ext': libdash_build_ext},
+      version='0.5.3',
+      long_description=long_description,
+      long_description_content_type='text/markdown',
+      include_package_data=True)