beancount-format 0.1.17__tar.gz → 0.1.18__tar.gz

{beancount_format-0.1.17 → beancount_format-0.1.18}/Cargo.lock

@@ -128,7 +128,7 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "beancount-formatter"
-version = "0.1.17"
+version = "0.1.18"
 dependencies = [
  "anyhow",
  "beancount-parser",
@@ -140,7 +140,7 @@ dependencies = [
 
 [[package]]
 name = "beancount-formatter-cli"
-version = "0.1.17"
+version = "0.1.18"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -154,7 +154,7 @@ dependencies = [
 
 [[package]]
 name = "beancount-formatter-py"
-version = "0.1.17"
+version = "0.1.18"
 dependencies = [
  "beancount-formatter",
  "beancount-formatter-cli",
@@ -408,7 +408,7 @@ dependencies = [
 
 [[package]]
 name = "dprint-plugin-beancount"
-version = "0.1.17"
+version = "0.1.18"
 dependencies = [
  "anyhow",
  "beancount-formatter",

{beancount_format-0.1.17 → beancount_format-0.1.18}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "3"
 
 [workspace.package]
-version = "0.1.17"
+version = "0.1.18"
 authors = ["Trim21 <trim21.me@gmail.com>"]
 edition = "2024"
 homepage = "https://github.com/trim21/beancount-format"

{beancount_format-0.1.17 → beancount_format-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beancount-format
-Version: 0.1.17
+Version: 0.1.18
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

beancount_format-0.1.18/patches/tree-sitter-language/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "tree-sitter-language"
+version = "0.1.6"
+authors = [
+  "Max Brunsfeld <maxbrunsfeld@gmail.com>",
+  "Amaan Qureshi <amaanq12@gmail.com>",
+]
+categories = ["api-bindings", "development-tools::ffi", "parsing"]
+documentation = "https://docs.rs/tree-sitter-language"
+edition = "2021"
+readme = "README.md"
+rust-version = "1.77"
+description = "The tree-sitter Language type, used by the library and by language implementations"
+
+build = "build.rs"
+links = "tree-sitter-language"
+
+[lib]
+path = "src/language.rs"

beancount_format-0.1.18/patches/tree-sitter-language/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Max Brunsfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

beancount_format-0.1.18/patches/tree-sitter-language/README.md

@@ -0,0 +1,4 @@
+# Tree-sitter Language
+
+This crate provides a `LanguageFn` type for grammars to create `Language` instances from a parser,
+without having to worry about the `tree-sitter` crate version not matching.

beancount_format-0.1.18/patches/tree-sitter-language/build.rs

@@ -0,0 +1,13 @@
+fn main() {
+    if std::env::var("TARGET")
+        .unwrap_or_default()
+        .starts_with("wasm32-unknown")
+    {
+        let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+        let wasm_headers = std::path::Path::new(&manifest_dir).join("wasm/include");
+        let wasm_src = std::path::Path::new(&manifest_dir).join("wasm/src");
+
+        println!("cargo::metadata=wasm-headers={}", wasm_headers.display());
+        println!("cargo::metadata=wasm-src={}", wasm_src.display());
+    }
+}

beancount_format-0.1.18/patches/tree-sitter-language/src/language.rs

@@ -0,0 +1,23 @@
+#![no_std]
+/// `LanguageFn` wraps a C function that returns a pointer to a tree-sitter grammar.
+#[repr(transparent)]
+#[derive(Clone, Copy)]
+pub struct LanguageFn(unsafe extern "C" fn() -> *const ());
+
+impl LanguageFn {
+    /// Creates a [`LanguageFn`].
+    ///
+    /// # Safety
+    ///
+    /// Only call this with language functions generated from grammars
+    /// by the Tree-sitter CLI.
+    pub const unsafe fn from_raw(f: unsafe extern "C" fn() -> *const ()) -> Self {
+        Self(f)
+    }
+
+    /// Gets the function wrapped by this [`LanguageFn`].
+    #[must_use]
+    pub const fn into_raw(self) -> unsafe extern "C" fn() -> *const () {
+        self.0
+    }
+}

beancount_format-0.1.18/patches/tree-sitter-language/wasm/include/assert.h

@@ -0,0 +1,14 @@
+#ifndef TREE_SITTER_WASM_ASSERT_H_
+#define TREE_SITTER_WASM_ASSERT_H_
+
+#ifdef NDEBUG
+#define assert(e) ((void)0)
+#else
+__attribute__((noreturn)) void __assert_fail(const char *assertion, const char *file, unsigned line, const char *function) {
+    __builtin_trap();
+}
+#define assert(expression) \
+  ((expression) ? (void)0 : __assert_fail(#expression, __FILE__, __LINE__, __func__))
+#endif
+
+#endif // TREE_SITTER_WASM_ASSERT_H_

beancount_format-0.1.18/patches/tree-sitter-language/wasm/include/ctype.h

@@ -0,0 +1,8 @@
+#ifndef TREE_SITTER_WASM_CTYPE_H_
+#define TREE_SITTER_WASM_CTYPE_H_
+
+static inline int isprint(int c) {
+  return c >= 0x20 && c <= 0x7E;
+}
+
+#endif // TREE_SITTER_WASM_CTYPE_H_

beancount_format-0.1.18/patches/tree-sitter-language/wasm/include/endian.h

@@ -0,0 +1,12 @@
+#ifndef TREE_SITTER_WASM_ENDIAN_H_
+#define TREE_SITTER_WASM_ENDIAN_H_
+
+#define be16toh(x) __builtin_bswap16(x)
+#define be32toh(x) __builtin_bswap32(x)
+#define be64toh(x) __builtin_bswap64(x)
+#define le16toh(x) (x)
+#define le32toh(x) (x)
+#define le64toh(x) (x)
+
+
+#endif // TREE_SITTER_WASM_ENDIAN_H_

beancount_format-0.1.18/patches/tree-sitter-language/wasm/include/inttypes.h

@@ -0,0 +1,8 @@
+#ifndef TREE_SITTER_WASM_INTTYPES_H_
+#define TREE_SITTER_WASM_INTTYPES_H_
+
+// https://github.com/llvm/llvm-project/blob/0c3cf200f5b918fb5c1114e9f1764c2d54d1779b/libc/include/llvm-libc-macros/inttypes-macros.h#L209
+
+#define PRId32 "d"
+
+#endif // TREE_SITTER_WASM_INTTYPES_H_

beancount_format-0.1.18/patches/tree-sitter-language/wasm/include/stdint.h

@@ -0,0 +1,46 @@
+#ifndef TREE_SITTER_WASM_STDINT_H_
+#define TREE_SITTER_WASM_STDINT_H_
+
+// https://github.com/llvm/llvm-project/blob/0c3cf200f5b918fb5c1114e9f1764c2d54d1779b/clang/test/Preprocessor/init.c#L1672
+
+typedef signed char int8_t;
+
+typedef short int16_t;
+
+typedef int int32_t;
+
+typedef long long int int64_t;
+
+typedef unsigned char uint8_t;
+
+typedef unsigned short uint16_t;
+
+typedef unsigned int uint32_t;
+
+typedef long long unsigned int uint64_t;
+
+typedef long unsigned int size_t;
+
+typedef long unsigned int uintptr_t;
+
+#define INT8_MAX 127
+#define INT16_MAX 32767
+#define INT32_MAX 2147483647L
+#define INT64_MAX 9223372036854775807LL
+
+#define UINT8_MAX 255
+#define UINT16_MAX 65535
+#define UINT32_MAX 4294967295U
+#define UINT64_MAX 18446744073709551615ULL
+
+#if defined(__wasm32__)
+
+#define SIZE_MAX 4294967295UL
+
+#elif defined(__wasm64__)
+
+#define SIZE_MAX 18446744073709551615UL
+
+#endif
+
+#endif // TREE_SITTER_WASM_STDINT_H_

beancount_format-0.1.18/patches/tree-sitter-language/wasm/include/stdio.h

@@ -0,0 +1,36 @@
+#ifndef TREE_SITTER_WASM_STDIO_H_
+#define TREE_SITTER_WASM_STDIO_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef struct FILE FILE;
+
+typedef __builtin_va_list va_list;
+#define va_start(ap, last) __builtin_va_start(ap, last)
+#define va_end(ap) __builtin_va_end(ap)
+#define va_arg(ap, type) __builtin_va_arg(ap, type)
+
+#define stdout ((FILE *)0)
+
+#define stderr ((FILE *)1)
+
+#define stdin ((FILE *)2)
+
+int fclose(FILE *stream);
+
+FILE *fdopen(int fd, const char *mode);
+
+int fputc(int c, FILE *stream);
+
+int fputs(const char *restrict s, FILE *restrict stream);
+
+size_t fwrite(const void *restrict buffer, size_t size, size_t nmemb, FILE *restrict stream);
+
+int fprintf(FILE *restrict stream, const char *restrict format, ...);
+
+int snprintf(char *restrict buffer, size_t buffsz, const char *restrict format, ...);
+
+int vsnprintf(char *restrict buffer, size_t buffsz, const char *restrict format, va_list vlist);
+
+#endif // TREE_SITTER_WASM_STDIO_H_

beancount_format-0.1.18/patches/tree-sitter-language/wasm/include/stdlib.h

@@ -0,0 +1,15 @@
+#ifndef TREE_SITTER_WASM_STDLIB_H_
+#define TREE_SITTER_WASM_STDLIB_H_
+
+#include <stdint.h>
+
+#define NULL ((void*)0)
+
+void* malloc(size_t);
+void* calloc(size_t, size_t);
+void free(void*);
+void* realloc(void*, size_t);
+
+__attribute__((noreturn)) void abort(void);
+
+#endif // TREE_SITTER_WASM_STDLIB_H_

beancount_format-0.1.18/patches/tree-sitter-language/wasm/include/string.h

@@ -0,0 +1,18 @@
+#ifndef TREE_SITTER_WASM_STRING_H_
+#define TREE_SITTER_WASM_STRING_H_
+
+#include <stdint.h>
+
+int memcmp(const void *lhs, const void *rhs, size_t count);
+
+void *memcpy(void *restrict dst, const void *restrict src, size_t size);
+
+void *memmove(void *dst, const void *src, size_t count);
+
+void *memset(void *dst, int value, size_t count);
+
+int strncmp(const char *left, const char *right, size_t n);
+
+size_t strlen(const char *str);
+
+#endif // TREE_SITTER_WASM_STRING_H_

beancount_format-0.1.18/patches/tree-sitter-language/wasm/include/wctype.h

@@ -0,0 +1,168 @@
+#ifndef TREE_SITTER_WASM_WCTYPE_H_
+#define TREE_SITTER_WASM_WCTYPE_H_
+
+typedef int wint_t;
+
+static inline bool iswalpha(wint_t wch) {
+  switch (wch) {
+  case L'a':
+  case L'b':
+  case L'c':
+  case L'd':
+  case L'e':
+  case L'f':
+  case L'g':
+  case L'h':
+  case L'i':
+  case L'j':
+  case L'k':
+  case L'l':
+  case L'm':
+  case L'n':
+  case L'o':
+  case L'p':
+  case L'q':
+  case L'r':
+  case L's':
+  case L't':
+  case L'u':
+  case L'v':
+  case L'w':
+  case L'x':
+  case L'y':
+  case L'z':
+  case L'A':
+  case L'B':
+  case L'C':
+  case L'D':
+  case L'E':
+  case L'F':
+  case L'G':
+  case L'H':
+  case L'I':
+  case L'J':
+  case L'K':
+  case L'L':
+  case L'M':
+  case L'N':
+  case L'O':
+  case L'P':
+  case L'Q':
+  case L'R':
+  case L'S':
+  case L'T':
+  case L'U':
+  case L'V':
+  case L'W':
+  case L'X':
+  case L'Y':
+  case L'Z':
+    return true;
+  default:
+    return false;
+  }
+}
+
+static inline bool iswdigit(wint_t wch) {
+  switch (wch) {
+  case L'0':
+  case L'1':
+  case L'2':
+  case L'3':
+  case L'4':
+  case L'5':
+  case L'6':
+  case L'7':
+  case L'8':
+  case L'9':
+    return true;
+  default:
+    return false;
+  }
+}
+
+static inline bool iswalnum(wint_t wch) {
+  switch (wch) {
+  case L'a':
+  case L'b':
+  case L'c':
+  case L'd':
+  case L'e':
+  case L'f':
+  case L'g':
+  case L'h':
+  case L'i':
+  case L'j':
+  case L'k':
+  case L'l':
+  case L'm':
+  case L'n':
+  case L'o':
+  case L'p':
+  case L'q':
+  case L'r':
+  case L's':
+  case L't':
+  case L'u':
+  case L'v':
+  case L'w':
+  case L'x':
+  case L'y':
+  case L'z':
+  case L'A':
+  case L'B':
+  case L'C':
+  case L'D':
+  case L'E':
+  case L'F':
+  case L'G':
+  case L'H':
+  case L'I':
+  case L'J':
+  case L'K':
+  case L'L':
+  case L'M':
+  case L'N':
+  case L'O':
+  case L'P':
+  case L'Q':
+  case L'R':
+  case L'S':
+  case L'T':
+  case L'U':
+  case L'V':
+  case L'W':
+  case L'X':
+  case L'Y':
+  case L'Z':
+  case L'0':
+  case L'1':
+  case L'2':
+  case L'3':
+  case L'4':
+  case L'5':
+  case L'6':
+  case L'7':
+  case L'8':
+  case L'9':
+    return true;
+  default:
+    return false;
+  }
+}
+
+static inline bool iswspace(wint_t wch) {
+  switch (wch) {
+  case L' ':
+  case L'\t':
+  case L'\n':
+  case L'\v':
+  case L'\f':
+  case L'\r':
+    return true;
+  default:
+    return false;
+  }
+}
+
+#endif // TREE_SITTER_WASM_WCTYPE_H_

beancount_format-0.1.18/patches/tree-sitter-language/wasm/src/stdio.c

@@ -0,0 +1,299 @@
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+  bool left_justify;   // -
+  bool zero_pad;       // 0
+  bool show_sign;      // +
+  bool space_prefix;   // ' '
+  bool alternate_form; // #
+} format_flags_t;
+
+static const char* parse_format_spec(
+  const char *format,
+  int *width,
+  int *precision,
+  format_flags_t *flags
+) {
+  *width = 0;
+  *precision = -1;
+  flags->left_justify = false;
+  flags->zero_pad = false;
+  flags->show_sign = false;
+  flags->space_prefix = false;
+  flags->alternate_form = false;
+
+  const char *p = format;
+
+  // Parse flags
+  while (*p == '-' || *p == '+' || *p == ' ' || *p == '#' || *p == '0') {
+    switch (*p) {
+      case '-': flags->left_justify = true; break;
+      case '0': flags->zero_pad = true; break;
+      case '+': flags->show_sign = true; break;
+      case ' ': flags->space_prefix = true; break;
+      case '#': flags->alternate_form = true; break;
+    }
+    p++;
+  }
+
+  // width
+  while (*p >= '0' && *p <= '9') {
+    *width = (*width * 10) + (*p - '0');
+    p++;
+  }
+
+  // precision
+  if (*p == '.') {
+    p++;
+    *precision = 0;
+    while (*p >= '0' && *p <= '9') {
+      *precision = (*precision * 10) + (*p - '0');
+      p++;
+    }
+  }
+
+  return p;
+}
+
+static int int_to_str(
+  long long value,
+  char *buffer,
+  int base,
+  bool is_signed,
+  bool uppercase
+) {
+  if (base < 2 || base > 16) return 0;
+
+  const char *digits = uppercase ? "0123456789ABCDEF" : "0123456789abcdef";
+  char temp[32];
+  int i = 0, len = 0;
+  bool is_negative = false;
+
+  if (value == 0) {
+    buffer[0] = '0';
+    buffer[1] = '\0';
+    return 1;
+  }
+
+  if (is_signed && value < 0 && base == 10) {
+    is_negative = true;
+    value = -value;
+  }
+
+  unsigned long long uval = (unsigned long long)value;
+  while (uval > 0) {
+    temp[i++] = digits[uval % base];
+    uval /= base;
+  }
+
+  if (is_negative) {
+    buffer[len++] = '-';
+  }
+
+  while (i > 0) {
+    buffer[len++] = temp[--i];
+  }
+
+  buffer[len] = '\0';
+  return len;
+}
+
+static int ptr_to_str(void *ptr, char *buffer) {
+  buffer[0] = '0';
+  buffer[1] = 'x';
+  int len = int_to_str((uintptr_t)ptr, buffer + 2, 16, 0, 0);
+  return 2 + len;
+}
+
+char *strncpy(char *dest, const char *src, size_t n) {
+  char *d = dest;
+  const char *s = src;
+  while (n-- && (*d++ = *s++));
+  if (n == (size_t)-1) *d = '\0';
+  return dest;
+}
+
+static int write_formatted_to_buffer(
+  char *buffer,
+  size_t buffer_size,
+  size_t *pos,
+  const char *str,
+  int width,
+  const format_flags_t *flags
+) {
+  int len = strlen(str);
+  int written = 0;
+  int pad_len = (width > len) ? (width - len) : 0;
+  int zero_pad = flags->zero_pad && !flags->left_justify;
+
+  if (!flags->left_justify && pad_len > 0) {
+    char pad_char = zero_pad ? '0' : ' ';
+    for (int i = 0; i < pad_len && *pos < buffer_size - 1; i++) {
+      buffer[(*pos)++] = pad_char;
+      written++;
+    }
+  }
+
+  for (int i = 0; i < len && *pos < buffer_size - 1; i++) {
+    buffer[(*pos)++] = str[i];
+    written++;
+  }
+
+  if (flags->left_justify && pad_len > 0) {
+    for (int i = 0; i < pad_len && *pos < buffer_size - 1; i++) {
+      buffer[(*pos)++] = ' ';
+      written++;
+    }
+  }
+
+  return written;
+}
+
+static int vsnprintf_impl(char *buffer, size_t buffsz, const char *format, va_list args) {
+  if (!buffer || buffsz == 0 || !format) return -1;
+
+  size_t pos = 0;
+  int total_chars = 0;
+  const char *p = format;
+
+  while (*p) {
+    if (*p == '%') {
+      p++;
+      if (*p == '%') {
+        if (pos < buffsz - 1) buffer[pos++] = '%';
+        total_chars++;
+        p++;
+        continue;
+      }
+
+      int width, precision;
+      format_flags_t flags;
+      p = parse_format_spec(p, &width, &precision, &flags);
+
+      char temp_buf[64];
+      const char *output_str = temp_buf;
+
+      switch (*p) {
+        case 's': {
+          const char *str = va_arg(args, const char*);
+          if (!str) str = "(null)";
+
+          int str_len = strlen(str);
+          if (precision >= 0 && str_len > precision) {
+            strncpy(temp_buf, str, precision);
+            temp_buf[precision] = '\0';
+            output_str = temp_buf;
+          } else {
+            output_str = str;
+          }
+          break;
+        }
+        case 'd':
+        case 'i': {
+          int value = va_arg(args, int);
+          int_to_str(value, temp_buf, 10, true, false);
+          break;
+        }
+        case 'u': {
+          unsigned int value = va_arg(args, unsigned int);
+          int_to_str(value, temp_buf, 10, false, false);
+          break;
+        }
+        case 'x': {
+          unsigned int value = va_arg(args, unsigned int);
+          int_to_str(value, temp_buf, 16, false, false);
+          break;
+        }
+        case 'X': {
+          unsigned int value = va_arg(args, unsigned int);
+          int_to_str(value, temp_buf, 16, false, true);
+          break;
+        }
+        case 'p': {
+          void *ptr = va_arg(args, void*);
+          ptr_to_str(ptr, temp_buf);
+          break;
+        }
+        case 'c': {
+          int c = va_arg(args, int);
+          temp_buf[0] = (char)c;
+          temp_buf[1] = '\0';
+          break;
+        }
+        case 'z': {
+          if (*(p + 1) == 'u') {
+            size_t value = va_arg(args, size_t);
+            int_to_str(value, temp_buf, 10, false, false);
+            p++;
+          } else {
+            temp_buf[0] = 'z';
+            temp_buf[1] = '\0';
+          }
+          break;
+        }
+        default:
+          temp_buf[0] = '%';
+          temp_buf[1] = *p;
+          temp_buf[2] = '\0';
+          break;
+      }
+
+      int str_len = strlen(output_str);
+      int formatted_len = (width > str_len) ? width : str_len;
+      total_chars += formatted_len;
+
+      if (pos < buffsz - 1) {
+        write_formatted_to_buffer(buffer, buffsz, &pos, output_str, width, &flags);
+      }
+
+    } else {
+      if (pos < buffsz - 1) buffer[pos++] = *p;
+      total_chars++;
+    }
+    p++;
+  }
+
+  if (buffsz > 0) buffer[pos < buffsz ? pos : buffsz - 1] = '\0';
+
+  return total_chars;
+}
+
+int snprintf(char *restrict buffer, size_t buffsz, const char *restrict format, ...) {
+  if (!buffer || buffsz == 0 || !format) return -1;
+
+  va_list args;
+  va_start(args, format);
+  int result = vsnprintf_impl(buffer, buffsz, format, args);
+  va_end(args);
+
+  return result;
+}
+
+int vsnprintf(char *restrict buffer, size_t buffsz, const char *restrict format, va_list vlist) {
+  return vsnprintf_impl(buffer, buffsz, format, vlist);
+}
+
+int fclose(FILE *stream) {
+  return 0;
+}
+
+FILE* fdopen(int fd, const char *mode) {
+  return 0;
+}
+
+int fputc(int c, FILE *stream) {
+  return c;
+}
+
+int fputs(const char *restrict str, FILE *restrict stream) {
+  return 0;
+}
+
+size_t fwrite(const void *restrict buffer, size_t size, size_t nmemb, FILE *restrict stream) {
+  return size * nmemb;
+}
+
+int fprintf(FILE *restrict stream, const char *restrict format, ...) {
+  return 0;
+}

beancount_format-0.1.18/patches/tree-sitter-language/wasm/src/stdlib.c

@@ -0,0 +1,161 @@
+// This file implements a very simple allocator for external scanners running
+// in Wasm. Allocation is just bumping a static pointer and growing the heap
+// as needed, and freeing is just adding the freed region to a free list.
+// When additional memory is allocated, the free list is searched first.
+// If there is not a suitable region in the free list, the heap is
+// grown as necessary, and the allocation is made at the end of the heap.
+// When the heap is reset, all allocated memory is considered freed.
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern void tree_sitter_debug_message(const char *, size_t);
+
+#define PAGESIZE 0x10000
+#define MAX_HEAP_SIZE (4 * 1024 * 1024)
+
+typedef struct {
+  size_t size;
+  struct Region *next;
+  char data[0];
+} Region;
+
+static Region *heap_end = NULL;
+static Region *heap_start = NULL;
+static Region *next = NULL;
+static Region *free_list = NULL;
+
+// Get the region metadata for the given heap pointer.
+static inline Region *region_for_ptr(void *ptr) { return ((Region *)ptr) - 1; }
+
+// Get the location of the next region after the given region,
+// if the given region had the given size.
+static inline Region *region_after(Region *self, size_t len) {
+  char *address = self->data + len;
+  char *aligned = (char *)((uintptr_t)(address + 3) & ~0x3);
+  return (Region *)aligned;
+}
+
+static void *get_heap_end() {
+  return (void *)(__builtin_wasm_memory_size(0) * PAGESIZE);
+}
+
+static int grow_heap(size_t size) {
+  size_t new_page_count = ((size - 1) / PAGESIZE) + 1;
+  return __builtin_wasm_memory_grow(0, new_page_count) != SIZE_MAX;
+}
+
+// Clear out the heap, and move it to the given address.
+void reset_heap(void *new_heap_start) {
+  heap_start = new_heap_start;
+  next = new_heap_start;
+  heap_end = get_heap_end();
+  free_list = NULL;
+}
+
+void *malloc(size_t size) {
+  if (size == 0)
+    return NULL;
+
+  Region *prev = NULL;
+  Region *curr = free_list;
+  while (curr != NULL) {
+    if (curr->size >= size) {
+      if (prev == NULL) {
+        free_list = curr->next;
+      } else {
+        prev->next = curr->next;
+      }
+      return &curr->data;
+    }
+    prev = curr;
+    curr = curr->next;
+  }
+
+  Region *region_end = region_after(next, size);
+
+  if (region_end > heap_end) {
+    if ((char *)region_end - (char *)heap_start > MAX_HEAP_SIZE) {
+      return NULL;
+    }
+    if (!grow_heap(size))
+      return NULL;
+    heap_end = get_heap_end();
+  }
+
+  void *result = &next->data;
+  next->size = size;
+  next = region_end;
+
+  return result;
+}
+
+void free(void *ptr) {
+  if (ptr == NULL)
+    return;
+
+  Region *region = region_for_ptr(ptr);
+  Region *region_end = region_after(region, region->size);
+
+  // When freeing the last allocated pointer, re-use that
+  // pointer for the next allocation.
+  if (region_end == next) {
+    next = region;
+  } else {
+    region->next = free_list;
+    free_list = region;
+  }
+}
+
+void *calloc(size_t count, size_t size) {
+  void *result = malloc(count * size);
+  if (!result)
+    return NULL;
+  memset(result, 0, count * size);
+  return result;
+}
+
+void *realloc(void *ptr, size_t new_size) {
+  if (ptr == NULL) {
+    return malloc(new_size);
+  }
+  if (new_size == 0) {
+    free(ptr);
+    return NULL;
+  }
+
+  Region *region = region_for_ptr(ptr);
+  Region *region_end = region_after(region, region->size);
+
+  // When reallocating the last allocated region, return
+  // the same pointer, and skip copying the data.
+  if (region_end == next) {
+    // Resize in place: bypass the free list to ensure
+    // we keep the same pointer and adjust the bump allocator.
+    Region *new_end = region_after(region, new_size);
+    if (new_end > heap_end) {
+      if ((char *)new_end - (char *)heap_start > MAX_HEAP_SIZE) {
+        return NULL;
+      }
+      if (!grow_heap(new_size))
+        return NULL;
+      heap_end = get_heap_end();
+    }
+    region->size = new_size;
+    next = new_end;
+    return &region->data;
+  }
+
+  void *result = malloc(new_size);
+  if (!result)
+    return NULL;
+
+  size_t copy_size = region->size < new_size ? region->size : new_size;
+  memcpy(result, &region->data, copy_size);
+
+  free(ptr);
+  return result;
+}
+
+__attribute__((noreturn)) void abort(void) { __builtin_trap(); }

beancount_format-0.1.18/patches/tree-sitter-language/wasm/src/string.c

@@ -0,0 +1,66 @@
+#include <string.h>
+
+int memcmp(const void *lhs, const void *rhs, size_t count) {
+  const unsigned char *l = lhs;
+  const unsigned char *r = rhs;
+  while (count--) {
+    if (*l != *r) {
+      return *l - *r;
+    }
+    l++;
+    r++;
+  }
+  return 0;
+}
+
+void *memcpy(void *restrict dst, const void *restrict src, size_t size) {
+  unsigned char *d = dst;
+  const unsigned char *s = src;
+  while (size--) {
+    *d++ = *s++;
+  }
+  return dst;
+}
+
+void *memmove(void *dst, const void *src, size_t count) {
+  unsigned char *d = dst;
+  const unsigned char *s = src;
+  if (d < s) {
+    while (count--) {
+      *d++ = *s++;
+    }
+  } else if (d > s) {
+    d += count;
+    s += count;
+    while (count--) {
+      *(--d) = *(--s);
+    }
+  }
+  return dst;
+}
+
+void *memset(void *dst, int value, size_t count) {
+  unsigned char *p = dst;
+  while (count--) {
+    *p++ = (unsigned char)value;
+  }
+  return dst;
+}
+
+int strncmp(const char *left, const char *right, size_t n) {
+  while (n-- > 0) {
+    if (*left != *right) {
+      return *(unsigned char *)left - *(unsigned char *)right;
+    }
+    if (*left == '\0') break;
+    left++;
+    right++;
+  }
+  return 0;
+}
+
+size_t strlen(const char *str) {
+  const char *s = str;
+  while (*s) s++;
+  return s - str;
+}

{beancount_format-0.1.17 → beancount_format-0.1.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "beancount-format"
-version = "0.1.17"
+version = "0.1.18"
 description = "Beancount formatter powered by dprint-plugin-beancount"
 authors = [{ name = "trim21", email = "trim21.me@gmail.com" }]
 license = { file = "LICENSE" }
@@ -29,6 +29,7 @@ manifest-path = "crates/beancount-formatter-py/Cargo.toml"
 module-name = "beancount_format"
 strip = true
 python-source = "python/src"
+include = [{ path = "patches/**/*", format = "sdist" }]
 
 [tool.uv]
 package = false