tpy-lang 0.3.0.dev0__py3-none-any.whl

tpyc/_data/runtime/cpp/third_party/pcre2/src/sljit/sljitUtils.c

@@ -0,0 +1,344 @@
+/*
+ *    Stack-less Just-In-Time compiler
+ *
+ *    Copyright Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright notice, this list of
+ *      conditions and the following disclaimer.
+ *
+ *   2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *      of conditions and the following disclaimer in the documentation and/or other materials
+ *      provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+ * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* ------------------------------------------------------------------------ */
+/*  Locks                                                                   */
+/* ------------------------------------------------------------------------ */
+
+/* Executable Allocator */
+
+#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) \
+	&& !(defined SLJIT_WX_EXECUTABLE_ALLOCATOR && SLJIT_WX_EXECUTABLE_ALLOCATOR)
+#if (defined SLJIT_SINGLE_THREADED && SLJIT_SINGLE_THREADED)
+#define SLJIT_ALLOCATOR_LOCK()
+#define SLJIT_ALLOCATOR_UNLOCK()
+#elif !(defined _WIN32)
+#include <pthread.h>
+
+static pthread_mutex_t allocator_lock = PTHREAD_MUTEX_INITIALIZER;
+
+#define SLJIT_ALLOCATOR_LOCK() pthread_mutex_lock(&allocator_lock)
+#define SLJIT_ALLOCATOR_UNLOCK() pthread_mutex_unlock(&allocator_lock)
+#else /* windows */
+static HANDLE allocator_lock;
+
+static SLJIT_INLINE void allocator_grab_lock(void)
+{
+	HANDLE lock;
+	if (SLJIT_UNLIKELY(!InterlockedCompareExchangePointer(&allocator_lock, NULL, NULL))) {
+		lock = CreateMutex(NULL, FALSE, NULL);
+		if (InterlockedCompareExchangePointer(&allocator_lock, lock, NULL))
+			CloseHandle(lock);
+	}
+	WaitForSingleObject(allocator_lock, INFINITE);
+}
+
+#define SLJIT_ALLOCATOR_LOCK() allocator_grab_lock()
+#define SLJIT_ALLOCATOR_UNLOCK() ReleaseMutex(allocator_lock)
+#endif /* thread implementation */
+#endif /* SLJIT_EXECUTABLE_ALLOCATOR && !SLJIT_WX_EXECUTABLE_ALLOCATOR */
+
+/* ------------------------------------------------------------------------ */
+/*  Stack                                                                   */
+/* ------------------------------------------------------------------------ */
+
+#if ((defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) \
+	&& !(defined SLJIT_UTIL_SIMPLE_STACK_ALLOCATION && SLJIT_UTIL_SIMPLE_STACK_ALLOCATION)) \
+	|| ((defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) \
+	&& !((defined SLJIT_PROT_EXECUTABLE_ALLOCATOR && SLJIT_PROT_EXECUTABLE_ALLOCATOR) \
+	|| (defined SLJIT_WX_EXECUTABLE_ALLOCATOR && SLJIT_WX_EXECUTABLE_ALLOCATOR)))
+
+#ifndef _WIN32
+/* Provides mmap function. */
+#include <sys/types.h>
+#include <sys/mman.h>
+
+#ifndef MAP_ANON
+#ifdef MAP_ANONYMOUS
+#define MAP_ANON MAP_ANONYMOUS
+#endif /* MAP_ANONYMOUS */
+#endif /* !MAP_ANON */
+
+#ifndef MAP_ANON
+
+#include <fcntl.h>
+
+#ifdef O_CLOEXEC
+#define SLJIT_CLOEXEC	O_CLOEXEC
+#else /* !O_CLOEXEC */
+#define SLJIT_CLOEXEC	0
+#endif /* O_CLOEXEC */
+
+/* Some old systems do not have MAP_ANON. */
+static int dev_zero = -1;
+
+#if (defined SLJIT_SINGLE_THREADED && SLJIT_SINGLE_THREADED)
+
+static SLJIT_INLINE int open_dev_zero(void)
+{
+	dev_zero = open("/dev/zero", O_RDWR | SLJIT_CLOEXEC);
+
+	return dev_zero < 0;
+}
+
+#else /* !SLJIT_SINGLE_THREADED */
+
+#include <pthread.h>
+
+static pthread_mutex_t dev_zero_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static SLJIT_INLINE int open_dev_zero(void)
+{
+	pthread_mutex_lock(&dev_zero_mutex);
+	if (SLJIT_UNLIKELY(dev_zero < 0))
+		dev_zero = open("/dev/zero", O_RDWR | SLJIT_CLOEXEC);
+
+	pthread_mutex_unlock(&dev_zero_mutex);
+	return dev_zero < 0;
+}
+
+#endif /* SLJIT_SINGLE_THREADED */
+#undef SLJIT_CLOEXEC
+#endif /* !MAP_ANON */
+#endif /* !_WIN32 */
+#endif /* open_dev_zero */
+
+#if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) \
+	|| (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
+
+#ifdef _WIN32
+
+static SLJIT_INLINE sljit_uw get_page_alignment(void) {
+	SYSTEM_INFO si;
+	static sljit_uw sljit_page_align = 0;
+	if (!sljit_page_align) {
+		GetSystemInfo(&si);
+		sljit_page_align = (sljit_uw)si.dwPageSize - 1;
+	}
+	return sljit_page_align;
+}
+
+#else
+
+#include <unistd.h>
+
+static SLJIT_INLINE sljit_uw get_page_alignment(void) {
+	static sljit_uw sljit_page_align = 0;
+
+	sljit_sw align;
+
+	if (!sljit_page_align) {
+#ifdef _SC_PAGESIZE
+		align = sysconf(_SC_PAGESIZE);
+#else
+		align = getpagesize();
+#endif
+		/* Should never happen. */
+		if (align < 0)
+			align = 4096;
+		sljit_page_align = (sljit_uw)align - 1;
+	}
+	return sljit_page_align;
+}
+
+#endif /* _WIN32 */
+
+#endif /* get_page_alignment() */
+
+#if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK)
+
+#if (defined SLJIT_UTIL_SIMPLE_STACK_ALLOCATION && SLJIT_UTIL_SIMPLE_STACK_ALLOCATION)
+
+SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_FUNC sljit_allocate_stack(sljit_uw start_size, sljit_uw max_size, void *allocator_data)
+{
+	struct sljit_stack *stack;
+	void *ptr;
+
+	SLJIT_UNUSED_ARG(allocator_data);
+
+	if (start_size > max_size || start_size < 1)
+		return NULL;
+
+	stack = (struct sljit_stack*)SLJIT_MALLOC(sizeof(struct sljit_stack), allocator_data);
+	if (stack == NULL)
+		return NULL;
+
+	ptr = SLJIT_MALLOC(max_size, allocator_data);
+	if (ptr == NULL) {
+		SLJIT_FREE(stack, allocator_data);
+		return NULL;
+	}
+
+	stack->min_start = (sljit_u8 *)ptr;
+ 	stack->end = stack->min_start + max_size;
+ 	stack->start = stack->end - start_size;
+	stack->top = stack->end;
+	return stack;
+}
+
+SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data)
+{
+	SLJIT_UNUSED_ARG(allocator_data);
+	SLJIT_FREE((void*)stack->min_start, allocator_data);
+	SLJIT_FREE(stack, allocator_data);
+}
+
+SLJIT_API_FUNC_ATTRIBUTE sljit_u8 *SLJIT_FUNC sljit_stack_resize(struct sljit_stack *stack, sljit_u8 *new_start)
+{
+	if ((new_start < stack->min_start) || (new_start >= stack->end))
+		return NULL;
+	stack->start = new_start;
+	return new_start;
+}
+
+#else /* !SLJIT_UTIL_SIMPLE_STACK_ALLOCATION */
+
+#ifdef _WIN32
+
+SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data)
+{
+	SLJIT_UNUSED_ARG(allocator_data);
+	VirtualFree((void*)stack->min_start, 0, MEM_RELEASE);
+	SLJIT_FREE(stack, allocator_data);
+}
+
+#else /* !_WIN32 */
+
+SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data)
+{
+	SLJIT_UNUSED_ARG(allocator_data);
+	munmap((void*)stack->min_start, (size_t)(stack->end - stack->min_start));
+	SLJIT_FREE(stack, allocator_data);
+}
+
+#endif /* _WIN32 */
+
+SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_FUNC sljit_allocate_stack(sljit_uw start_size, sljit_uw max_size, void *allocator_data)
+{
+	struct sljit_stack *stack;
+	void *ptr;
+	sljit_uw page_align;
+
+	SLJIT_UNUSED_ARG(allocator_data);
+
+	if (start_size > max_size || start_size < 1)
+		return NULL;
+
+	stack = (struct sljit_stack*)SLJIT_MALLOC(sizeof(struct sljit_stack), allocator_data);
+	if (stack == NULL)
+		return NULL;
+
+	/* Align max_size. */
+	page_align = get_page_alignment();
+	max_size = (max_size + page_align) & ~page_align;
+
+#ifdef _WIN32
+	ptr = VirtualAlloc(NULL, max_size, MEM_RESERVE, PAGE_READWRITE);
+	if (!ptr) {
+		SLJIT_FREE(stack, allocator_data);
+		return NULL;
+	}
+
+	stack->min_start = (sljit_u8 *)ptr;
+	stack->end = stack->min_start + max_size;
+	stack->start = stack->end;
+
+	if (sljit_stack_resize(stack, stack->end - start_size) == NULL) {
+		sljit_free_stack(stack, allocator_data);
+		return NULL;
+	}
+#else /* !_WIN32 */
+#ifdef MAP_ANON
+	ptr = mmap(NULL, max_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#else /* !MAP_ANON */
+	if (SLJIT_UNLIKELY((dev_zero < 0) && open_dev_zero())) {
+		SLJIT_FREE(stack, allocator_data);
+		return NULL;
+	}
+	ptr = mmap(NULL, max_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, dev_zero, 0);
+#endif /* MAP_ANON */
+	if (ptr == MAP_FAILED) {
+		SLJIT_FREE(stack, allocator_data);
+		return NULL;
+	}
+	stack->min_start = (sljit_u8 *)ptr;
+	stack->end = stack->min_start + max_size;
+	stack->start = stack->end - start_size;
+#endif /* _WIN32 */
+
+	stack->top = stack->end;
+	return stack;
+}
+
+SLJIT_API_FUNC_ATTRIBUTE sljit_u8 *SLJIT_FUNC sljit_stack_resize(struct sljit_stack *stack, sljit_u8 *new_start)
+{
+#if defined _WIN32 || defined(POSIX_MADV_DONTNEED)
+	sljit_uw aligned_old_start;
+	sljit_uw aligned_new_start;
+	sljit_uw page_align;
+#endif
+
+	if ((new_start < stack->min_start) || (new_start >= stack->end))
+		return NULL;
+
+#ifdef _WIN32
+	page_align = get_page_alignment();
+
+	aligned_new_start = (sljit_uw)new_start & ~page_align;
+	aligned_old_start = ((sljit_uw)stack->start) & ~page_align;
+	if (aligned_new_start != aligned_old_start) {
+		if (aligned_new_start < aligned_old_start) {
+			if (!VirtualAlloc((void*)aligned_new_start, aligned_old_start - aligned_new_start, MEM_COMMIT, PAGE_READWRITE))
+				return NULL;
+		}
+		else {
+			if (!VirtualFree((void*)aligned_old_start, aligned_new_start - aligned_old_start, MEM_DECOMMIT))
+				return NULL;
+		}
+	}
+#elif defined(POSIX_MADV_DONTNEED)
+	if (stack->start < new_start) {
+		page_align = get_page_alignment();
+
+		aligned_new_start = (sljit_uw)new_start & ~page_align;
+		aligned_old_start = ((sljit_uw)stack->start) & ~page_align;
+
+		if (aligned_new_start > aligned_old_start) {
+			posix_madvise((void*)aligned_old_start, aligned_new_start - aligned_old_start, POSIX_MADV_DONTNEED);
+#ifdef MADV_FREE
+			madvise((void*)aligned_old_start, aligned_new_start - aligned_old_start, MADV_FREE);
+#endif /* MADV_FREE */
+		}
+	}
+#endif /* _WIN32 */
+
+	stack->start = new_start;
+	return new_start;
+}
+
+#endif /* SLJIT_UTIL_SIMPLE_STACK_ALLOCATION */
+
+#endif /* SLJIT_UTIL_STACK */

tpyc/_data/runtime/cpp/third_party/pcre2.sources.txt

@@ -0,0 +1,54 @@
+# PCRE2 8-bit build sources.
+#
+# Canonical list for libpcre2-8, taken from PCRE2's upstream
+# NON-AUTOTOOLS-BUILD documentation. tpyc/build/pcre2.py reads this file
+# to drive compilation when PCRE2 is built in bundled mode. Keep in
+# sync with upstream when bumping the vendored PCRE2 version.
+#
+# Files in src/ NOT listed here and why they're excluded:
+#   * Standalone tools with their own main():
+#         pcre2grep.c, pcre2test.c, pcre2demo.c
+#   * Test harnesses:
+#         pcre2_jit_test.c, pcre2posix_test.c, pcre2_fuzzsupport.c
+#   * Build helpers (we ship the pre-generated output):
+#         pcre2_dftables.c  (generates pcre2_chartables.c at build time)
+#   * Separate library (POSIX wrapper, different .a):
+#         pcre2posix.c
+#   * Files meant to be `#include`d from other .c files, not compiled
+#     directly -- compiling them would produce duplicate symbols:
+#         pcre2_printint.c      (#include'd by pcre2test, pcre2_dftables)
+#         pcre2_jit_match.c     (#include'd by pcre2_jit_compile.c)
+#         pcre2_jit_misc.c      (#include'd by pcre2_jit_compile.c)
+#         pcre2_ucptables.c     (#include'd by pcre2_tables.c)
+#
+# Format: one filename per line, relative to the vendored `src/` dir.
+# Blank lines and `#` comments ignored.
+
+pcre2_auto_possess.c
+pcre2_chartables.c
+pcre2_chkdint.c
+pcre2_compile.c
+pcre2_config.c
+pcre2_context.c
+pcre2_convert.c
+pcre2_dfa_match.c
+pcre2_error.c
+pcre2_extuni.c
+pcre2_find_bracket.c
+pcre2_jit_compile.c
+pcre2_maketables.c
+pcre2_match.c
+pcre2_match_data.c
+pcre2_newline.c
+pcre2_ord2utf.c
+pcre2_pattern_info.c
+pcre2_script_run.c
+pcre2_serialize.c
+pcre2_string_utils.c
+pcre2_study.c
+pcre2_substitute.c
+pcre2_substring.c
+pcre2_tables.c
+pcre2_ucd.c
+pcre2_valid_utf.c
+pcre2_xclass.c

tpyc/_data/runtime/cpp/third_party/pcre2.vendor.json

@@ -0,0 +1,7 @@
+{
+  "name": "pcre2",
+  "version": "10.44",
+  "url": "https://github.com/PCRE2Project/pcre2/releases/download/pcre2-10.44/pcre2-10.44.tar.gz",
+  "sha256": "86b9cb0aa3bcb7994faa88018292bc704cdbb708e785f7c74352ff6ea7d3175b",
+  "vendored_at": "2026-04-20T00:00:00+00:00"
+}

tpyc/build/__init__.py

@@ -0,0 +1,7 @@
+"""Build-side helpers for tpyc: third-party dependency resolution, etc.
+
+This package hosts modules that deal with the boundary between generated
+C++ and external build inputs (third-party libraries, bundled sources,
+CMake snippet emission). Kept separate from `tpyc/compiler.py` so the
+build concerns don't accumulate there.
+"""

tpyc/build/pcre2.py

@@ -0,0 +1,122 @@
+"""PCRE2-specific build wiring. Registered in
+``tpyc/build/third_party.py::_FACTORIES``.
+
+PCRE2 ships a "non-autotools" build path: rename a few ``.generic`` /
+``.dist`` template files, then compile the .c files with
+``-DPCRE2_CODE_UNIT_WIDTH=8`` and ``-DHAVE_CONFIG_H``. We pre-materialize
+the templates at vendoring time (``scripts/vendor_pcre2.py``), so all
+the direct-compile path does here is:
+
+  * enumerate the .c files (from the sidecar manifest
+    ``runtime/cpp/third_party/pcre2.sources.txt``, next to the vendored
+    tree to keep the upstream tree pristine);
+  * emit the fixed -I / -D flags;
+  * point dependents at the include dir that holds pcre2.h.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .third_party import ThirdPartyLib, read_source_manifest
+
+
+# Manifest lives next to the vendored tree, not inside it, so the
+# upstream tree stays pristine (same reason pcre2.vendor.json lives
+# outside). Filename mirrors the vendor.json sidecar.
+_SOURCE_MANIFEST = "pcre2.sources.txt"
+
+
+def _source_files(lib: ThirdPartyLib) -> list[Path]:
+    """Return the list of PCRE2 .c files to compile into libpcre2-8.
+
+    Reads the sidecar manifest next to the vendored source tree rather
+    than globbing -- globbing would sweep in files that aren't meant to
+    be compiled directly (standalone tools, test harnesses, .c files
+    that exist only to be #included by others). The manifest is the
+    canonical source list from upstream PCRE2's NON-AUTOTOOLS-BUILD doc.
+    """
+    if lib.bundled_source_dir is None:
+        raise RuntimeError(f"{lib.name}: no bundled source dir configured")
+    src_dir = lib.bundled_source_dir / "src"
+    if not src_dir.is_dir():
+        raise FileNotFoundError(
+            f"{lib.name}: bundled src/ not found at {src_dir}"
+        )
+    manifest = lib.bundled_source_dir.parent / _SOURCE_MANIFEST
+    if not manifest.is_file():
+        raise FileNotFoundError(
+            f"{lib.name}: source manifest not found at {manifest}"
+        )
+    paths: list[Path] = []
+    for name in read_source_manifest(manifest):
+        p = src_dir / name
+        if not p.is_file():
+            raise FileNotFoundError(
+                f"{lib.name}: expected source file missing: {p} "
+                f"(listed in {manifest})"
+            )
+        paths.append(p)
+    return paths
+
+
+def _compile_flags(lib: ThirdPartyLib) -> list[str]:
+    """C-compiler flags needed to build a PCRE2 .c file.
+
+    -I<src_dir> is required so PCRE2's internal headers (pcre2_internal.h,
+    pcre2.h, config.h) resolve. -DHAVE_CONFIG_H tells PCRE2 to include
+    config.h (which we materialized from config.h.generic at vendoring
+    time with SUPPORT_PCRE2_8 / SUPPORT_JIT / SUPPORT_UNICODE enabled).
+    """
+    if lib.bundled_source_dir is None:
+        raise RuntimeError(f"{lib.name}: no bundled source dir configured")
+    return [
+        "-DHAVE_CONFIG_H",
+        "-DPCRE2_CODE_UNIT_WIDTH=8",
+        f"-I{lib.bundled_source_dir / 'src'}",
+    ]
+
+
+def _user_include_dir(lib: ThirdPartyLib) -> Path:
+    """Path containing pcre2.h for user code to ``#include``.
+    Same dir as the source files; PCRE2 keeps everything in ``src/``."""
+    if lib.bundled_source_dir is None:
+        raise RuntimeError(f"{lib.name}: no bundled source dir configured")
+    return lib.bundled_source_dir / "src"
+
+
+def factory(runtime_cpp_dir: Path) -> ThirdPartyLib:
+    """Build the PCRE2 ``ThirdPartyLib`` declaration.
+
+    Vendored build options picked for TPy's use:
+      * 8-bit only -- Python str maps to UTF-8 bytes; 16/32-bit unused.
+      * JIT on -- ~10x match-time speedup, widely supported.
+      * Tests + pcre2grep off -- we validate via our own test cases, and
+        the grep CLI utility doesn't belong in a runtime build.
+    """
+    return ThirdPartyLib(
+        name="pcre2",
+        cli_flag="--pcre2",
+        cmake_var="TPY_PCRE2",
+        default_mode="bundled",
+        min_version="10.35",
+        find_package_name="PCRE2",
+        find_package_components=("8BIT",),
+        find_package_target="PCRE2::8BIT",
+        pkgconfig_name="libpcre2-8",
+        system_link_flags=("-lpcre2-8",),
+        bundled_source_dir=runtime_cpp_dir / "third_party" / "pcre2",
+        bundled_cmake_vars={
+            "PCRE2_BUILD_PCRE2_8": "ON",
+            "PCRE2_BUILD_PCRE2_16": "OFF",
+            "PCRE2_BUILD_PCRE2_32": "OFF",
+            "PCRE2_SUPPORT_JIT": "ON",
+            "PCRE2_BUILD_TESTS": "OFF",
+            "PCRE2_BUILD_PCRE2GREP": "OFF",
+        },
+        bundled_static_target="pcre2-8-static",
+        license_file="LICENCE",
+        bundled_source_files=_source_files,
+        bundled_compile_flags=_compile_flags,
+        bundled_user_include_dir=_user_include_dir,
+    )