zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/utils/string.c

@@ -0,0 +1,357 @@
+/*
+ * Copyright (C) 2021 Liquidaty and the zsv/lib contributors
+ * All rights reserved
+ *
+ * This file is part of zsv/lib, distributed under the license defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <string.h>
+#include <stdint.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <zsv/utils/compiler.h>
+#include <zsv/utils/utf8.h>
+#include <zsv/utils/string.h>
+
+#ifdef ZSV_UTILS_STRING_STANDALONE
+#include "../../src/zsv_strencode.c"
+#endif
+
+#ifndef NO_UTF8PROC
+#include <utf8proc.h>
+
+static utf8proc_int32_t utf8proc_tolower1(utf8proc_int32_t codepoint, void *data) {
+  (void)data;
+  return utf8proc_tolower(codepoint);
+}
+
+static unsigned char *utf8proc_tolower_str(const unsigned char *str, size_t *len) {
+  // note: for some unknown reason, this func intermittently can fail on win (compiled w mingw64) when called in a tight
+  // loop may be related to realloc()
+  utf8proc_uint8_t *output;
+  utf8proc_option_t options = {0};
+  /* options = UTF8PROC_COMPOSE | UTF8PROC_COMPAT
+  | UTF8PROC_CASEFOLD | UTF8PROC_IGNORE | UTF8PROC_STRIPMARK | UTF8PROC_STRIPCC | UTF8PROC_STRIPNA;
+  */
+  // utf8proc_map_custom allocates new mem
+  options = UTF8PROC_STRIPNA;
+  *len = (size_t)utf8proc_map_custom((const utf8proc_uint8_t *)str, (utf8proc_ssize_t)*len, &output, options,
+                                     utf8proc_tolower1, NULL);
+  return (unsigned char *)output;
+}
+#endif // ndef NO_UTF8PROC
+
+// zsv_strtolowercase(): to do: utf8 support
+unsigned char *zsv_strtolowercase_w_err(const unsigned char *s, size_t *lenp, int *err) {
+  *err = 0;
+#ifndef NO_UTF8PROC
+  size_t len_orig = *lenp;
+  unsigned char *new_s = utf8proc_tolower_str(s, lenp);
+  if (!new_s && len_orig) {
+    *err = 1;
+    unsigned char *tmp_s = malloc(len_orig + 1);
+    if (tmp_s) {
+      memcpy(tmp_s, s, len_orig);
+      tmp_s[len_orig] = '\0';
+      *lenp = zsv_strencode(tmp_s, len_orig, '?', NULL, NULL);
+      new_s = utf8proc_tolower_str(tmp_s, lenp);
+      free(tmp_s);
+    }
+  }
+#else  // ndef NO_UTF8PROC
+  unsigned char *new_s = malloc((*lenp + 1) * sizeof(*new_s));
+  if (new_s) {
+    for (size_t i = 0, j = *lenp; i < j; i++)
+      new_s[i] = tolower(s[i]);
+    new_s[*lenp] = '\0';
+  }
+#endif // ndef NO_UTF8PROC
+  return new_s;
+}
+
+unsigned char *zsv_strtolowercase(const unsigned char *s, size_t *lenp) {
+  int err;
+  size_t len_orig = *lenp;
+  unsigned char *result = zsv_strtolowercase_w_err(s, lenp, &err);
+  if (err)
+    fprintf(stderr, "Warning: malformed UTF8 '%.*s'\n", (int)len_orig, s);
+  return result;
+}
+
+// zsv_strstr(): strstr
+const unsigned char *zsv_strstr(const unsigned char *hay, const unsigned char *needle) {
+  return (const unsigned char *)strstr((const char *)hay, (const char *)needle);
+}
+
+/*
+ * zsv_stricmp, zsv_strincmp(): case-insensitive comparison
+ *
+ * @param s1     string to convert
+ * @param len1   length of s1
+ * @param s2     string to convert
+ * @param len2   length of s2
+ */
+int zsv_stricmp(const unsigned char *s1, const unsigned char *s2) {
+  return zsv_strincmp(s1, strlen((const char *)s1), s2, strlen((const char *)s2));
+}
+
+int zsv_strincmp_ascii(const unsigned char *s1, size_t len1, const unsigned char *s2, size_t len2) {
+  while (len1 && len2) {
+    if (!*s1)
+      return *s2 == 0 ? 0 : -1;
+    if (!*s2)
+      return 1;
+    int c1 = tolower(*s1);
+    int c2 = tolower(*s2);
+    if (c1 == c2) {
+      s1++, s2++, len1--, len2--;
+    } else
+      return c1 < c2 ? -1 : 1;
+  }
+  return len1 > len2 ? 1 : len1 < len2 ? -1 : 0;
+}
+
+int zsv_strincmp(const unsigned char *s1, size_t len1, const unsigned char *s2, size_t len2) {
+#ifndef NO_UTF8PROC
+  unsigned char *lc1 = zsv_strtolowercase(s1, &len1);
+  unsigned char *lc2 = zsv_strtolowercase(s2, &len2);
+  int result;
+  if (VERY_UNLIKELY(!lc1 || !lc2))
+    fprintf(stderr, "Out of memory!\n"), result = -2;
+  else
+    result = strcmp((char *)lc1, (char *)lc2);
+  free(lc1);
+  free(lc2);
+  return result;
+#else
+  return zsv_strincmp_ascii(s1, len1, s2, len2);
+#endif
+}
+
+__attribute__((always_inline)) static inline const unsigned char *zsv_strtrim_left_inline(
+  const char unsigned *restrict s, size_t *lenp) {
+  utf8proc_ssize_t bytes_read;
+  utf8proc_int32_t codepoint = 0;
+  size_t len = *lenp;
+  utf8proc_category_t category;
+
+  // trim front
+  while ((bytes_read = zsv_strnext(s, len, &codepoint)) > 0 &&
+         ((category = utf8proc_category(codepoint)) == UTF8PROC_CATEGORY_ZS || category == UTF8PROC_CATEGORY_ZL ||
+          category == UTF8PROC_CATEGORY_ZP)) {
+    s += bytes_read;
+    len -= bytes_read;
+  }
+  *lenp = len;
+  return s;
+}
+
+__attribute__((always_inline)) static inline const unsigned char *zsv_strtrim_right_inline(
+  const char unsigned *restrict s, size_t *lenp) {
+  utf8proc_ssize_t bytes_read;
+  utf8proc_int32_t codepoint = 0;
+  size_t len = *lenp;
+  utf8proc_category_t category;
+
+  // trim back
+  while ((bytes_read = zsv_strlast(s, len, (int32_t *)&codepoint)) > 0 &&
+         ((category = utf8proc_category(codepoint)) == UTF8PROC_CATEGORY_ZS || category == UTF8PROC_CATEGORY_ZL ||
+          category == UTF8PROC_CATEGORY_ZP)) {
+    len -= bytes_read;
+  }
+  *lenp = len;
+  return s;
+}
+
+const unsigned char *zsv_strtrim_right(const char unsigned *restrict s, size_t *lenp) {
+  return zsv_strtrim_right_inline(s, lenp);
+}
+
+const unsigned char *zsv_strtrim_left(const char unsigned *restrict s, size_t *lenp) {
+  return zsv_strtrim_left_inline(s, lenp);
+}
+
+const unsigned char *zsv_strtrim(const char unsigned *restrict s, size_t *lenp) {
+  s = zsv_strtrim_left_inline(s, lenp);
+  return zsv_strtrim_right_inline(s, lenp);
+}
+
+size_t zsv_strnext(const unsigned char *s, size_t len, int32_t *codepoint) {
+  utf8proc_ssize_t bytes_read = utf8proc_iterate(s, len, (utf8proc_int32_t *)codepoint);
+  if (bytes_read < 1)
+    return 0;
+  return (size_t)bytes_read;
+}
+
+/**
+ * Return the 1-based position of the last byte
+ */
+__attribute__((always_inline)) static inline size_t zsv_strlast_position(const unsigned char *s, size_t len) {
+  // from the end, search backwards for the first byte that begins with 0 or 11
+  while (len && !(s[len - 1] < 128 || s[len - 1] >= 192))
+    len--;
+  return len;
+}
+
+size_t zsv_strlast(const unsigned char *s, size_t len, int32_t *codepoint) {
+  size_t position = zsv_strlast_position(s, len);
+  if (position) {
+    position--;
+    return zsv_strnext(s + position, len - position, codepoint);
+  }
+  return 0;
+}
+
+/**
+ *  Check if the next char is a currency char. If so, return its length, else return 0
+ */
+size_t zsv_strnext_is_currency(const unsigned char *s, size_t len) {
+  utf8proc_int32_t codepoint;
+  utf8proc_ssize_t bytes_read = utf8proc_iterate(s, len, &codepoint);
+  if (VERY_LIKELY(bytes_read > 0)) {
+    utf8proc_category_t category = utf8proc_category(codepoint);
+    if (category == UTF8PROC_CATEGORY_SC)
+      return (size_t)bytes_read;
+  }
+  return 0;
+}
+
+/**
+ *  Check if the next char is a plus or minus. If so, return its length, else return 0
+ */
+size_t zsv_strnext_is_sign(const unsigned char *s, size_t len) {
+  if (len && *s == '+')
+    return 1;
+
+  utf8proc_int32_t codepoint;
+  utf8proc_ssize_t bytes_read = utf8proc_iterate(s, len, &codepoint);
+  if (VERY_LIKELY(bytes_read > 0)) {
+    utf8proc_category_t category = utf8proc_category(codepoint);
+    if (category == UTF8PROC_CATEGORY_PD)
+      return (size_t)bytes_read;
+  }
+  return 0;
+}
+
+/**
+ * zsv_strwhite(): convert consecutive white to single space
+ *
+ * @param s     string to convert
+ * @param len   length of input string
+ * @param flags bitfield of ZSV_STRWHITE_FLAG_XXX values
+ */
+size_t zsv_strwhite(unsigned char *s, size_t len, unsigned int flags) {
+  int this_is_space, last_was_space = 0;
+  size_t new_len = 0;
+  char replacement = ' ';
+  int clen;
+
+  for (size_t i = 0; i < len; i += clen) {
+#ifndef NO_UTF8PROC
+    clen = ZSV_UTF8_CHARLEN(s[i]);
+    this_is_space = 0;
+    if (UNLIKELY(clen < 1 || i + clen > len)) { // bad UTF8. replace w '?'
+      clen = 1;
+      s[i] = '?';
+    } else if (UNLIKELY(clen > 1)) { // multi-byte UTF8
+      utf8proc_int32_t codepoint;
+      utf8proc_ssize_t bytes_read = utf8proc_iterate(s + i, clen, &codepoint);
+      if (UNLIKELY(bytes_read < 1)) { // error! but this could only happen if ZSV_UTF8_CHARLEN was wrong
+        clen = 1;
+        s[i] = '?';
+      } else {
+        utf8proc_category_t category = utf8proc_category(codepoint);
+        switch (category) {        // Unicode space categories
+        case UTF8PROC_CATEGORY_ZL: // line separator
+        case UTF8PROC_CATEGORY_ZP: // paragraph separator
+          this_is_space = 1;
+          s[i] = (flags & ZSV_STRWHITE_FLAG_NO_EMBEDDED_NEWLINE ? ' ' : '\n');
+          break;
+        case UTF8PROC_CATEGORY_ZS: // regular space
+          this_is_space = 1;
+          s[i] = ' ';
+          break;
+        default:
+          break;
+        }
+      }
+    } else { // regular ascii, clen == 1
+      this_is_space = isspace(s[i]);
+    }
+#else  // no UTF8PROC, assume clen = 1
+    {
+      clen = 1;
+      this_is_space = isspace(s[i]);
+    }
+#endif // ndef NO_UTF8PROC
+
+    if (this_is_space) {
+      if (UNLIKELY((s[i] == '\n' || s[i] == '\r')) && !(flags & ZSV_STRWHITE_FLAG_NO_EMBEDDED_NEWLINE))
+        replacement = '\n';
+      else if (!last_was_space)
+        replacement = ' ';
+      last_was_space = 1;
+    } else {
+      // current position is not a space
+      if (last_was_space)
+        s[new_len++] = replacement;
+      for (int j = 0; j < clen; j++)
+        s[new_len++] = s[i + j];
+      last_was_space = 0;
+    }
+  }
+  return new_len;
+}
+
+size_t zsv_strip_trailing_zeros(const char *s, size_t len) {
+  if (len && memchr(s, '.', len)) {
+    while (len && s[len - 1] == '0')
+      len--;
+    if (len && s[len - 1] == '.')
+      len--;
+  }
+  return len;
+}
+
+/**
+ * zsv_strunescape_backslash(): convert consecutive white to single space
+ *
+ * @param s     string to convert
+ * @param len   length of input string
+ * @param flags bitfield of ZSV_STRWHITE_FLAG_XXX values
+ */
+size_t zsv_strunescape_backslash(unsigned char *s, size_t len) {
+  if (len == 0 || !memchr(s, '\\', len - 1))
+    return len;
+  size_t j = 0;
+  for (size_t i = 0; i < len; i++, j++) {
+    if (UNLIKELY(s[i] == '\\' && i + 1 < len && memchr("tnr", s[i + 1], 3))) {
+      ++i;
+      s[j] = s[i] == 't' ? '\t' : s[i] == 'n' ? '\n' : '\r';
+    } else
+      s[j] = s[i];
+  }
+  return j;
+}
+
+// zsv_strtod_exact(const char *s): return error; if 0, set value of *d
+int zsv_strtod_exact(const char *s, double *d) {
+  if (!*s)
+    return 1;
+  char *end;
+  *d = strtod(s, &end);
+  if (*end)
+    return 1;
+  return 0;
+}
+
+#ifndef ZSV_STRING_LIB_ONLY
+struct zsv_cell zsv_get_cell_trimmed(zsv_parser parser, size_t ix) {
+  struct zsv_cell c = zsv_get_cell(parser, ix);
+  c.str = (unsigned char *)zsv_strtrim(c.str, &c.len);
+  return c;
+}
+#endif

data/ext/zsv/vendor/zsv-1.3.0/app/utils/win/dir_exists_longpath.c

@@ -0,0 +1,83 @@
+#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+#include <windows.h>
+#include <stdlib.h>  // For malloc, free
+#include <wchar.h>   // Optional, primarily for wcslen if needed
+#include <string.h>  // For strncmp, wcslen, wcscpy_s, wcscat_s
+#include <shlwapi.h> // For PathIsRelativeA
+#include <stdio.h>   // For printf, fprintf in main
+// Link against -lShlwapi.for PathIsRelativeA
+
+#include "io.h"
+
+/**
+ * Check if a directory exists on Windows, supporting long paths (> MAX_PATH).
+ * Handles paths with or without the \\?\ prefix.
+ * Works even if directory exists but permissions are limited (as long as attributes can be read).
+ *
+ * @param path_utf8 The path to check (assumed to be UTF-8 encoded).
+ * @return Non-zero (true) if the path exists and is a directory, 0 (false) otherwise.
+ */
+int zsv_dir_exists_winlp(const char *path_utf8) {
+  if (path_utf8 == NULL || path_utf8[0] == '\0') {
+    return 0; // Invalid or empty path
+  }
+
+  wchar_t *path_to_use;
+  DWORD rc = zsv_pathToPrefixedWidePath(path_utf8, &path_to_use);
+  if (rc)
+    return rc;
+
+  // --- 3. Call GetFileAttributesW ---
+  // fprintf(stderr, "Debug: Calling GetFileAttributesW with: %ls\n", path_to_use); // Debug print wide string
+  DWORD dwAttrib = GetFileAttributesW(path_to_use);
+
+  // --- 4. Check the result ---
+  int result;
+  if (dwAttrib != INVALID_FILE_ATTRIBUTES && (dwAttrib & FILE_ATTRIBUTE_DIRECTORY)) {
+    // Path exists and it is a directory.
+    result = 1; // True
+  } else {
+    // Path does not exist, is not a directory, or access denied to get attributes.
+    // GetLastError() could distinguish these cases if needed.
+    // fprintf(stderr, "Debug: GetFileAttributesW failed or not a directory. Attributes: 0x%lX, LastError: %lu\n",
+    // dwAttrib, GetLastError());
+    result = 0; // False
+  }
+
+  // --- 5. Cleanup ---
+  free(path_to_use);
+  return result;
+}
+
+#ifdef ZSV_DIR_EXISTS_WINLP_TEST
+
+// --- Main function for testing ---
+int main(int argc, char *argv[]) {
+  // Check if a path argument was provided
+  if (argc != 2) {
+    // Note: argv[0] might not be UTF-8 on Windows console, print generic message
+    fprintf(stderr, "Usage: <program_name> <path_to_check>\n");
+    fprintf(stderr, "Example: %s C:\\Windows\n", argv[0] ? argv[0] : "checkdir");
+    fprintf(stderr, "Example: %s \"\\\\?\\C:\\Very Long Path Directory Name\"\n", argv[0] ? argv[0] : "checkdir");
+    fprintf(stderr, "Example: %s non_existent_dir\n", argv[0] ? argv[0] : "checkdir");
+    return 1; // Indicate error
+  }
+
+  // The path provided by the user
+  const char *path_to_check = argv[1];
+
+  printf("Checking path: '%s'\n", path_to_check);
+
+  // Call the directory checking function
+  int exists = zsv_dir_exists_winlp(path_to_check);
+
+  // Print the result
+  if (exists) {
+    printf("Result: Directory exists.\n");
+  } else {
+    printf("Result: Path does not exist or is not a directory.\n");
+  }
+
+  return 0; // Indicate success
+}
+#endif // ZSV_DIR_EXISTS_WINLP_TEST

data/ext/zsv/vendor/zsv-1.3.0/app/utils/win/dl.c

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2021 Liquidaty and the zsv/lib contributors
+ * All rights reserved
+ *
+ * This file is part of zsv/lib, distributed under the license defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#ifdef _WIN32
+#include <windows.h>
+#include <zsv/utils/os.h>
+
+#define RTLD_LAZY 0
+void *dlsym(void *handle, const char *symbol) {
+  return (void *)GetProcAddress((HINSTANCE)(handle), (symbol));
+}
+
+void *dlopen(const char *dll_name, int flags) {
+  (void)flags;
+  wchar_t wbuf[PATH_MAX];
+  zsv_win_to_unicode(dll_name, wbuf, ARRAY_SIZE(wbuf));
+  return LoadLibraryW(wbuf);
+}
+
+int dlclose(void *handle) {
+  int result;
+  if (FreeLibrary((HMODULE)handle) != 0)
+    result = 0;
+  else
+    result = -1;
+  return result;
+}
+#endif

data/ext/zsv/vendor/zsv-1.3.0/app/utils/win/fopen_longpath.c

@@ -0,0 +1,184 @@
+#include <windows.h>
+#include <io.h>     // For _open_osfhandle, _fdopen
+#include <fcntl.h>  // For _O_xxx flags
+#include <stdio.h>  // For FILE*, fopen modes, fclose etc.
+#include <wchar.h>  // For wchar_t
+#include <stdlib.h> // For malloc, free
+
+#include "io.h"
+
+FILE *zsv_fopen_longpath(const char *utf8_path, const char *mode) {
+  wchar_t *wide_path_prefixed;
+  DWORD dwDesiredAccess = 0;
+  DWORD dwShareMode = FILE_SHARE_READ; // Example default
+  DWORD dwCreationDisposition = 0;
+  int c_runtime_flags = 0;
+  if (zsv_pathToPrefixedWidePath(utf8_path, &wide_path_prefixed))
+    return NULL;
+
+  // --- 2. Determine CreateFileW params and _open_osfhandle flags from mode string ---
+  if (strchr(mode, 'w')) {
+    dwDesiredAccess |= GENERIC_WRITE;
+    dwCreationDisposition = CREATE_ALWAYS; // Overwrite or create
+    c_runtime_flags |= _O_WRONLY;
+  } else if (strchr(mode, 'a')) {
+    dwDesiredAccess |= GENERIC_WRITE | FILE_APPEND_DATA; // Or just GENERIC_WRITE and seek later
+    dwCreationDisposition = OPEN_ALWAYS;                 // Append or create
+    c_runtime_flags |= _O_WRONLY | _O_APPEND;
+  } else { // Default to read
+    dwDesiredAccess |= GENERIC_READ;
+    dwCreationDisposition = OPEN_EXISTING;
+    c_runtime_flags |= _O_RDONLY;
+  }
+
+  if (strchr(mode, '+')) { // Read and write modes
+    dwDesiredAccess |= GENERIC_READ | GENERIC_WRITE;
+    c_runtime_flags &= ~(_O_RDONLY | _O_WRONLY); // Clear read/write only flags
+    c_runtime_flags |= _O_RDWR;
+    if (!strchr(mode, 'w')) {              // If it wasn't 'w+', it implies 'r+' or 'a+'
+      dwCreationDisposition = OPEN_ALWAYS; // Make sure it opens if exists
+    }
+  }
+
+  if (strchr(mode, 'b')) {
+    c_runtime_flags |= _O_BINARY;
+  } else {
+    c_runtime_flags |= _O_TEXT;
+  }
+
+  // --- 3. Call CreateFileW ---
+  HANDLE hFile = CreateFileW(wide_path_prefixed, dwDesiredAccess, dwShareMode,
+                             NULL, // Default security attributes
+                             dwCreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL);
+
+  free(wide_path_prefixed); // Don't need the string anymore
+
+  if (hFile == INVALID_HANDLE_VALUE) {
+    // Handle CreateFileW error (use GetLastError())
+    return NULL;
+  }
+
+  // --- 4. Convert HANDLE to C file descriptor ---
+  int fd = _open_osfhandle((intptr_t)hFile, c_runtime_flags);
+  if (fd == -1) {
+    // Handle _open_osfhandle error
+    CloseHandle(hFile); // Crucial: Close handle if fd conversion fails!
+    return NULL;
+  }
+
+  // --- 5. Convert file descriptor to FILE* stream ---
+  FILE *fp = _fdopen(fd, mode);
+  if (fp == NULL) {
+    // Handle _fdopen error
+    // Note: If _fdopen fails, the C runtime might or might not have
+    // taken ownership and closed the fd/handle. It's safer to assume
+    // it might not have, but closing the original hFile here is risky
+    // as _fdopen might have associated it. Usually, _close(fd) is
+    // appropriate here IF _fdopen fails, as _close *should* release the handle.
+    _close(fd); // Close the C descriptor; this should close the underlying handle.
+    return NULL;
+  }
+
+  // --- 6. Success ---
+  return fp;
+  // Remember: fclose(fp) will clean up fd and hFile later.
+}
+
+#ifdef ZSV_DIRS_FOPEN_LONGPATH_TEST
+
+#include "win/io.c"
+
+int main(int argc, char *argv[]) {
+  if (argc < 3 || argc > 4) {
+    fprintf(stderr, "Usage:\n");
+    fprintf(stderr, "  For writing: %s w <absolute_filepath> [content_to_write]\n", argv[0]);
+    fprintf(stderr, "  For reading: %s r <absolute_filepath>\n", argv[0]);
+    fprintf(stderr, "\nArguments:\n");
+    fprintf(stderr, "  mode: 'w' (write - overwrites/creates) or 'r' (read)\n");
+    fprintf(stderr, "  absolute_filepath: The full, absolute path to the file (can exceed MAX_PATH).\n");
+    fprintf(stderr, "                     Use quotes if the path contains spaces.\n");
+    fprintf(stderr, "  content_to_write (optional): Text to write to the file if mode is 'w'.\n");
+    fprintf(stderr, "                             If omitted in write mode, default text is written.\n");
+    fprintf(stderr, "\nExample (Write):\n");
+    fprintf(stderr, "  %s w \"C:\\Temp\\Long Path Folder\\very_long_filename_that_works.txt\" \"Hello Long World!\"\n",
+            argv[0]);
+    fprintf(stderr, "Example (Read):\n");
+    fprintf(stderr, "  %s r \"\\\\?\\C:\\Temp\\Long Path Folder\\very_long_filename_that_works.txt\"\n", argv[0]);
+    return 1;
+  }
+
+  const char *mode_arg = argv[1];
+  const char *filepath_arg = argv[2];
+  const char *content_arg = (argc == 4 && strcmp(mode_arg, "w") == 0) ? argv[3] : NULL;
+  const char *default_content = "Default content written by fopen_longpath test.\n";
+
+  char file_mode[4] = ""; // e.g., "rb", "wt", etc. (Max 3 chars + null)
+
+  if (strcmp(mode_arg, "w") == 0) {
+    strcpy(file_mode, "w"); // Use text mode by default for simplicity
+  } else if (strcmp(mode_arg, "r") == 0) {
+    strcpy(file_mode, "r"); // Use text mode by default
+  } else {
+    fprintf(stderr, "Error: Invalid mode '%s'. Use 'r' or 'w'.\n", mode_arg);
+    return 1;
+  }
+
+  printf("Attempting to open file: %s (Mode: %s)\n", filepath_arg, file_mode);
+
+  FILE *fp = fopen_longpath(filepath_arg, file_mode);
+
+  if (fp == NULL) {
+    // fopen_longpath should have printed specific errors
+    fprintf(stderr, "Main: Failed to open file using fopen_longpath.\n");
+    return 1;
+  }
+
+  printf("Main: File opened successfully.\n");
+  int operation_status = 0; // 0 for success, non-zero for error
+
+  // --- Perform Read or Write ---
+  if (strcmp(mode_arg, "w") == 0) {
+    const char *content_to_write = (content_arg != NULL) ? content_arg : default_content;
+    printf("Main: Writing content: \"%s\"\n", content_to_write);
+    if (fputs(content_to_write, fp) == EOF) {
+      perror("Main: Error writing to file");
+      operation_status = 1;
+    } else {
+      // Add a newline if user content didn't end with one
+      if (content_to_write[strlen(content_to_write) - 1] != '\n') {
+        if (fputc('\n', fp) == EOF) {
+          perror("Main: Error writing newline to file");
+          operation_status = 1;
+        }
+      }
+      printf("Main: Write operation successful.\n");
+    }
+
+  } else { // Mode is 'r'
+    printf("Main: Reading file content:\n---\n");
+    char buffer[1024];
+    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
+      printf("%s", buffer); // Print line including its newline
+    }
+    if (ferror(fp)) {
+      perror("Main: Error reading from file");
+      operation_status = 1;
+    } else {
+      printf("\n---\nMain: Read operation finished.\n");
+      // Reaching EOF without ferror is success
+    }
+  }
+
+  // --- Close the file ---
+  printf("Main: Closing file.\n");
+  if (fclose(fp) != 0) {
+    perror("Main: Error closing file");
+    // Continue, but report overall failure if write/read also failed
+    if (operation_status == 0)
+      operation_status = 1;
+  }
+
+  return operation_status; // 0 if all successful, 1 if any error occurred
+}
+
+#endif // ZSV_DIRS_FOPEN_LONGPATH_TEST