zsv 1.3.0

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

@@ -0,0 +1,255 @@
+#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+#include <windows.h>        // For CreateDirectoryW, MultiByteToWideChar, GetLastError etc.
+#include <stdio.h>          // For printf, perror
+#include <stdlib.h>         // For malloc, free, exit
+#include <string.h>         // For strlen, strcpy, strncpy
+#include <wchar.h>          // For wide character types and functions like wcslen, wcscpy
+
+#include "io.h"
+
+/**
+ * @brief Creates a directory, supporting paths longer than MAX_PATH.
+ *
+ * This function uses the Windows API CreateDirectoryW with the \\?\ prefix
+ * to reliably create directories even if their absolute path exceeds the
+ * traditional MAX_PATH limit.
+ *
+ * @param path A UTF-8 encoded string representing the absolute path of the
+ * directory to create. Relative paths are NOT reliably handled.
+ * Forward slashes '/' will be converted to backslashes '\'.
+ * @return 0 on success (directory created or already exists).
+ * Returns a non-zero Win32 error code on failure (see GetLastError()).
+ */
+
+DWORD zsv_mkdir_winlp(const char *path_utf8) {
+  if (path_utf8 == NULL || path_utf8[0] == '\0') {
+    fprintf(stderr, "Error: Input path is NULL or empty.\n");
+    return ERROR_INVALID_PARAMETER; // Or another suitable error code
+  }
+
+  if (strlen(path_utf8) < 260) { // try the easy way first
+    int rc = mkdir(path_utf8);
+    if (!rc || rc == EEXIST)
+      return 0;
+  }
+
+  wchar_t *finalPath;
+  DWORD rc = zsv_pathToPrefixedWidePath(path_utf8, &finalPath);
+  if (rc)
+    return rc;
+
+  // 4. Call CreateDirectoryW
+  BOOL success = CreateDirectoryW(finalPath, NULL); // NULL for default security attributes
+
+  DWORD lastError = 0;
+  if (!success) {
+    lastError = GetLastError();
+    // It's okay if the directory already exists
+    if (lastError == ERROR_ALREADY_EXISTS) {
+      // printf("Debug: Directory already exists (considered success).\n");
+      lastError = 0; // Treat as success
+    } else {
+      fprintf(stderr, "Error: CreateDirectoryW failed (%lu) for path: %ls\n", lastError, finalPath);
+    }
+  } else {
+    // printf("Debug: CreateDirectoryW succeeded for path: %ls\n", finalPath);
+    lastError = 0; // Success
+  }
+
+  free(finalPath);
+
+  return lastError; // Return 0 on success (or already exists), else the error code
+}
+
+#ifdef DIRS_MKDIR_TEST
+#define FILESLASH '\\'
+
+#include "win/io.c"
+#include "dirs_exists_longpath.c"
+/**
+ * Check if a directory exists
+ * return true (non-zero) or false (zero)
+ */
+int zsv_dir_exists(const char *path) {
+#ifdef WIN32
+  if (strlen(path) >= MAX_PATH)
+    return zsv_dir_exists_winlp(path);
+
+  // TO DO: support win long filepath prefix
+  // TO DO: work properly if dir exists but we don't have permission
+  wchar_t wpath[MAX_PATH];
+  mbstowcs(wpath, path, MAX_PATH);
+
+  DWORD attrs = GetFileAttributesW(wpath);
+  if (attrs == INVALID_FILE_ATTRIBUTES)
+    // Could check GetLastError() to see if it's a permission issue vs. not-found
+    return 0;
+
+  // If it has the directory attribute, it's presumably a directory
+  return (attrs & FILE_ATTRIBUTE_DIRECTORY) != 0;
+
+#else
+  struct stat path_stat;
+  if (!stat(path, &path_stat))
+    return S_ISDIR(path_stat.st_mode);
+  return 0;
+#endif
+}
+
+/**
+ * Make a directory, as well as any intermediate dirs
+ * return zero on success
+ */
+#ifdef WIN32
+#define zsv_mkdir zsv_mkdir_winlp
+#else
+#define zsv_mkdir mkdir
+#endif
+int zsv_mkdirs(const char *path, char path_is_filename) {
+  // int rc = 0;
+  if (!path || !*path)
+    return -1;
+  size_t len = strlen(path);
+
+  /*
+#ifdef WIN32
+  // TO DO: handle windows long-file prefix "\\?\"
+  // for now, explicitly do not handle
+  if (len > 2 && path[2] == '?')
+    fprintf(stderr, "Invalid path (long file prefix not supported): %s\n", path);
+#endif
+  */
+  if (len < 1) //  || len > FILENAME_MAX)
+    return -1;
+
+  char *tmp = strdup(path);
+  if (!tmp) {
+    perror(path);
+    return -1;
+  }
+
+  if (len && strchr("/\\", tmp[len - 1]))
+    tmp[--len] = 0;
+
+  int offset = 0;
+#ifdef WIN32
+  if (len > 1) {
+    // starts with two slashes
+    if (strchr("/\\", tmp[0]) && strchr("/\\", tmp[1])) {
+      offset = 2;
+      // find the next slash
+      char *path_end = tmp + 3;
+      while (*path_end && !strchr("/\\", *path_end))
+        path_end++;
+      if (*path_end)
+        path_end++;
+      if (*path_end)
+        offset = path_end - tmp;
+      else {
+        fprintf(stderr, "Invalid path: %s\n", path);
+        free(tmp);
+        return -1;
+      }
+    }
+    // starts with *:
+    else if (tmp[1] == ':')
+      offset = 2;
+  }
+#else
+  offset = 1;
+#endif
+
+  // TO DO: first find the longest subdir that exists, in *reverse* order so as
+  // to properly handle case where no access to intermediate dir,
+  // and then only start mkdir from there
+  int last_dir_exists_rc = 0;
+  int last_errno = -1;
+  for (char *p = tmp + offset; /* !rc && */ *p; p++) {
+    if (strchr("/\\", *p)) {
+      char tmp_c = p[1];
+      p[0] = FILESLASH;
+      p[1] = '\0';
+      if (*tmp && !(last_dir_exists_rc = zsv_dir_exists(tmp))) {
+        if (zsv_mkdir(tmp
+#ifndef WIN32
+                      ,
+                      S_IRWXU
+#endif
+                      )) {
+          if (errno == EEXIST)
+            last_dir_exists_rc = 1;
+          else { // errno could be EEXIST if we have no permissions to an intermediate directory
+            last_errno = errno;
+            perror(tmp);
+            //          rc = -1;
+          }
+        } else
+          last_dir_exists_rc = 1;
+      }
+      p[1] = tmp_c;
+    }
+  }
+
+  if (/* !rc && */ path_is_filename == 0 && *tmp && !(last_dir_exists_rc = zsv_dir_exists(tmp))) {
+    if (zsv_mkdir(tmp
+#ifndef WIN32
+                  ,
+                  S_IRWXU
+#endif
+                  )) {
+      if (errno == EEXIST)
+        last_dir_exists_rc = 1;
+      else {
+        last_errno = errno;
+        perror(tmp);
+        // rc = -1;
+      }
+    } else
+      last_dir_exists_rc = 1;
+  }
+
+  free(tmp);
+  return last_dir_exists_rc ? 0 : last_errno ? last_errno : -1;
+}
+
+int main(int argc, char *argv[]) {
+  if (argc != 2) {
+    fprintf(stderr, "Usage: %s <absolute_directory_path>\n", argv[0]);
+    fprintf(stderr, "Example: %s \"C:\\Temp\\My Very Long Directory Name That Exceeds 260 Characters\\Subfolder\"\n",
+            argv[0]);
+    fprintf(stderr, "       %s \"\\\\?\\C:\\Temp\\Another Long Path\\Subfolder\"\n", argv[0]);
+    fprintf(stderr, "Note: Provide an ABSOLUTE path.\n");
+    return 1;
+  }
+
+  const char *targetPath = argv[1];
+
+  printf("Attempting to create directory: %s\n", targetPath);
+
+  DWORD result = zsv_mkdirs(targetPath, 0);
+
+  if (result == 0) {
+    printf("Success: Directory created or already exists.\n");
+    return 0;
+  } else {
+    // You can provide more detailed error messages by checking specific Win32 error codes
+    // For example: if (result == ERROR_PATH_NOT_FOUND) { ... }
+    fprintf(stderr, "Error: Failed to create directory %s. Win32 Error Code: %lu\n", targetPath, result);
+
+    // Optionally print the system error message for the code
+    LPSTR messageBuffer = NULL;
+    size_t size =
+      FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
+                     result, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&messageBuffer, 0, NULL);
+    if (messageBuffer) {
+      fprintf(stderr, "System Message: %s\n", messageBuffer);
+      LocalFree(messageBuffer); // Free buffer allocated by FormatMessage
+    } else {
+      fprintf(stderr, "Could not format error message for code %lu.\n", result);
+    }
+
+    return 1; // Indicate failure
+  }
+}
+
+#endif // DIRS_MKDIR_TEST

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

@@ -0,0 +1,96 @@
+#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h> // Required for malloc, free
+#include <string.h>
+#include <wchar.h> // Required for wide character functions
+
+#include "io.h"
+#include <errno.h>
+
+// Function to map common Windows error codes to POSIX errno values
+// return 0 if could not map
+int windows_error_to_errno(DWORD windows_error_code) {
+  switch (windows_error_code) {
+  case ERROR_FILE_NOT_FOUND:
+    return ENOENT;
+  case ERROR_PATH_NOT_FOUND:
+    return ENOENT;
+  case ERROR_INVALID_DRIVE:
+    return ENODEV; // Or ENOENT
+
+  case ERROR_ACCESS_DENIED:
+    return EACCES;
+  case ERROR_INVALID_ACCESS:
+    return EACCES; // Or EPERM depending on context
+  case ERROR_SHARING_VIOLATION:
+    return EACCES; // File is locked/in use
+  case ERROR_INVALID_HANDLE:
+    return EBADF;
+  case ERROR_INVALID_DATA:
+    return EILSEQ; // Or EINVAL
+  case ERROR_INVALID_PARAMETER:
+    return EINVAL;
+  case ERROR_NEGATIVE_SEEK:
+    return EINVAL;
+  case ERROR_WRITE_PROTECT:
+    return EROFS; // Read-only filesystem or media
+  case ERROR_DISK_FULL:
+    return ENOSPC; // No space left on device
+  case ERROR_ALREADY_EXISTS:
+    return EEXIST;
+  case ERROR_FILE_EXISTS:
+    return EEXIST;
+  case ERROR_TOO_MANY_OPEN_FILES:
+    return EMFILE;
+  case ERROR_DIRECTORY:
+    return ENOTDIR; // Attempted file op on directory (approx)
+  case ERROR_BROKEN_PIPE:
+    return EPIPE;
+  case ERROR_PIPE_NOT_CONNECTED:
+    return EPIPE;
+  case ERROR_WAIT_NO_CHILDREN:
+    return ECHILD; // Wait functions
+  case ERROR_CHILD_NOT_COMPLETE:
+    return ECHILD; // Wait functions
+  case ERROR_SUCCESS:
+    return 0; // Not really an error
+  default:
+    return 0;
+  }
+}
+
+int zsv_remove_winlp(const char *path_utf8) {
+  if (path_utf8 == NULL || path_utf8[0] == '\0') {
+    return 0; // Invalid or empty path
+  }
+
+  wchar_t *path_to_use = NULL;
+  DWORD rc = zsv_pathToPrefixedWidePath(path_utf8, &path_to_use);
+  if (!rc) {
+    if (!DeleteFileW(path_to_use)) {
+      DWORD lastError = GetLastError();
+#ifndef NDEBUG
+      fprintf(stderr, "Error deleting file '%ls': %lu\n", path_to_use, lastError);
+#endif
+      if (windows_error_to_errno(lastError)) {
+        rc = windows_error_to_errno(lastError);
+        errno = rc;
+      } else {
+        fprintf(stderr, "Unable to delete file '%ls': %lu\n", path_to_use, GetLastError());
+        LPSTR messageBuffer = NULL;
+        FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+                       NULL, lastError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&messageBuffer, 0, NULL);
+        if (messageBuffer) {
+          fprintf(stderr, "Error message: %s\n", messageBuffer);
+          LocalFree(messageBuffer);
+        } else
+          fprintf(stderr, "Could not format error message for code %lu.\n", lastError);
+        errno = rc = -1;
+      }
+    }
+  }
+
+  free(path_to_use);
+  return rc;
+}

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

@@ -0,0 +1,361 @@
+/*
+ * 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 <zsv/utils/writer.h>
+#include <zsv/utils/compiler.h>
+#include <zsv/utils/os.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+
+// clang-format off
+
+// return 0 on eof, +1 on error, > 0 if valid utf8 first byte read
+static inline char UTF8_charLenC_noerr(int c) {
+  char len;
+  if (c == EOF) len = 0;
+  else if (!(c & 128)) len = 1;
+  else if ((c & 224) == 192) len = 2; // 110xxxxx
+  else if ((c & 240) == 224) len = 3; // 1110xxxx
+  else if ((c & 248) == 240) len = 4; // 11110xxx
+  else if ((c & 252) == 248) len = 5; // 111110xx
+  else if ((c & 254) == 252) len = 6; // 1111110x
+  else len = 1; // error, but we are going to ignore and just call it a 1-byte char
+  return len;
+}
+
+// clang-format on
+
+static struct zsv_csv_writer_options zsv_csv_writer_default_opts = {0};
+static char zsv_writer_default_opts_initd = 0;
+void zsv_writer_set_default_opts(struct zsv_csv_writer_options opts) {
+  zsv_writer_default_opts_initd = 1;
+  zsv_csv_writer_default_opts = opts;
+}
+
+struct zsv_csv_writer_options zsv_writer_get_default_opts(void) {
+  if (!zsv_writer_default_opts_initd) {
+    zsv_writer_default_opts_initd = 1;
+    zsv_csv_writer_default_opts.write = (size_t(*)(const void *restrict, size_t, size_t, void *restrict))fwrite;
+    zsv_csv_writer_default_opts.stream = stdout;
+  }
+  return zsv_csv_writer_default_opts;
+}
+
+// zsv_csv_quote() returns:
+// - NULL if no quoting needed
+// - buff if buff size was large enough to hold result
+// - newly-allocated char * if buff not large enough, and was able to get from heap
+// in last case, caller must free
+unsigned char *zsv_csv_quote(const unsigned char *utf8_value, size_t len, unsigned char *buff, size_t buffsize) {
+  char need = 0;
+  unsigned quotes = 0;
+  for (unsigned int i = 0; i < len; i++) {
+    switch (utf8_value[i]) {
+    case ',':
+    case '\n':
+    case '\r':
+      need = 1;
+      break;
+    case '"':
+      need = 1;
+      quotes++;
+      break;
+    }
+  }
+  if (!need)
+    return NULL;
+
+  unsigned char *target;
+  unsigned mem_length = len + quotes + 3; // str + 2 quotes + terminating null
+  if (mem_length < buffsize)
+    target = buff;
+  else
+    target = malloc(mem_length * sizeof(*target));
+
+  if (target) {
+    *target = '"';
+    if (!quotes)
+      memcpy(target + 1, utf8_value, len);
+    else {
+      for (unsigned int i = 0, j = 1; i < len; i++) {
+        if ((target[j++] = utf8_value[i]) == '"')
+          target[j++] = '"';
+      }
+    }
+    target[mem_length - 2] = '"';
+    target[mem_length - 1] = '\0';
+  }
+  return target;
+}
+
+// to do: test #define ZSV_OUTPUT_BUFF_SIZE 65536 * 4 * 8
+#define ZSV_OUTPUT_BUFF_SIZE 65536 * 4
+
+struct zsv_output_buff {
+  char *buff; // will be ZSV_OUTPUT_BUFF_SIZE. to do: option to modify buff size
+  size_t (*write)(const void *restrict, size_t size, size_t nitems, void *restrict stream);
+  void *stream;
+  size_t used;
+  uint64_t written;
+  unsigned char close_on_delete : 1;
+  unsigned char _ : 7;
+};
+
+struct zsv_writer_data {
+  size_t buffsize;     // corresponds to buf
+  unsigned char *buff; // option
+
+  struct zsv_output_buff out;
+
+  void (*table_init)(void *);
+  void *table_init_ctx;
+
+  const char *cell_prepend;
+
+  void (*on_row)(void *);
+  void *on_row_ctx;
+
+  void (*on_delete)(void *);
+  void *on_delete_ctx;
+
+  unsigned char with_bom : 1;
+  unsigned char started : 1;
+  unsigned char _ : 6;
+};
+
+#include <unistd.h> // write
+
+static inline void zsv_output_buff_flush(struct zsv_output_buff *b) {
+  b->write(b->buff, b->used, 1, b->stream);
+  b->written += b->used;
+  b->used = 0;
+}
+
+static inline void zsv_output_buff_write(struct zsv_output_buff *b, const unsigned char *s, size_t n) {
+  if (n) {
+    if (n + b->used > ZSV_OUTPUT_BUFF_SIZE) {
+      zsv_output_buff_flush(b);
+      if (n > ZSV_OUTPUT_BUFF_SIZE) { // n too big, so write directly
+        b->write(s, n, 1, b->stream);
+        b->written += n;
+        return;
+      }
+    }
+    // n + used < buff size
+    memcpy(b->buff + b->used, s, n);
+    b->used += n;
+  }
+}
+
+void zsv_writer_set_temp_buff(zsv_csv_writer w, unsigned char *buff, size_t buffsize) {
+  w->buff = buff;
+  w->buffsize = buffsize;
+}
+
+static int writer_opts_ok(struct zsv_csv_writer_options *opts) {
+  if (opts) {
+    if (opts->output_path) {
+      if ((opts->write && opts->write != (size_t(*)(const void *restrict, size_t, size_t, void *restrict))fwrite) ||
+          (opts->stream && opts->stream != stdout)) {
+        fprintf(stderr, "Invalid zsv writer options: non-NULL 'output_path' with invalid 'write' and/or 'stream'\n");
+        errno = EINVAL;
+        return 0;
+      }
+    }
+  }
+  return 1;
+}
+
+zsv_csv_writer zsv_writer_new(struct zsv_csv_writer_options *opts) {
+  if (!(writer_opts_ok(opts)))
+    return NULL;
+  struct zsv_writer_data *w = calloc(1, sizeof(*w));
+  if (w) {
+    if (!(w->out.buff = malloc(ZSV_OUTPUT_BUFF_SIZE)))
+      goto zsv_writer_new_err;
+
+    if (!opts) {
+      w->out.write = (size_t(*)(const void *restrict, size_t, size_t, void *restrict))fwrite;
+      w->out.stream = stdout;
+    } else {
+      if (opts->output_path) {
+        if (!(w->out.stream = zsv_fopen(opts->output_path, "wb"))) {
+          perror(opts->output_path);
+          goto zsv_writer_new_err;
+        }
+        w->out.close_on_delete = 1;
+        w->out.write = (size_t(*)(const void *restrict, size_t, size_t, void *restrict))fwrite;
+      } else if (opts->write) {
+        w->out.write = opts->write;
+        w->out.stream = opts->stream;
+      } else {
+        w->out.write = (size_t(*)(const void *restrict, size_t, size_t, void *restrict))fwrite;
+        w->out.stream = opts->stream ? opts->stream : stdout;
+      }
+
+      w->with_bom = opts->with_bom;
+      w->table_init = opts->table_init;
+      w->table_init_ctx = opts->table_init_ctx;
+      w->on_row = opts->on_row;
+      w->on_row_ctx = opts->on_row_ctx;
+      w->on_delete = opts->on_delete;
+      w->on_delete_ctx = opts->on_delete_ctx;
+    }
+  }
+  return w;
+
+  int e;
+zsv_writer_new_err:
+  e = errno;
+  zsv_writer_delete(w);
+  errno = e;
+  return NULL;
+}
+
+enum zsv_writer_status zsv_writer_flush(zsv_csv_writer w) {
+  if (!w)
+    return zsv_writer_status_missing_handle;
+
+  zsv_output_buff_flush(&w->out);
+  return zsv_writer_status_ok;
+}
+
+enum zsv_writer_status zsv_writer_delete(zsv_csv_writer w) {
+  if (!w)
+    return zsv_writer_status_missing_handle;
+
+  if (w->started)
+    zsv_output_buff_write(&w->out, (const unsigned char *)"\n", 1);
+
+  if (w->out.stream && w->out.write && w->out.buff)
+    zsv_output_buff_flush(&w->out);
+
+  if (w->on_delete)
+    w->on_delete(w->on_delete_ctx);
+
+  if (w->out.buff)
+    free(w->out.buff);
+
+  if (w->out.close_on_delete && w->out.stream)
+    fclose(w->out.stream);
+
+  free(w);
+  return zsv_writer_status_ok;
+}
+
+static inline enum zsv_writer_status zsv_writer_cell_aux(zsv_csv_writer w, const unsigned char *s, size_t len,
+                                                         char check_if_needs_quoting) {
+  if (len) {
+    if (check_if_needs_quoting) {
+      unsigned char *quoted_s = zsv_csv_quote(s, len, w->buff, w->buffsize);
+      if (!quoted_s)
+        zsv_output_buff_write(&w->out, s, len);
+      else {
+        zsv_output_buff_write(&w->out, quoted_s, strlen((char *)quoted_s));
+        if (!(w->buff && quoted_s == w->buff))
+          free(quoted_s);
+      }
+    } else
+      zsv_output_buff_write(&w->out, s, len);
+  }
+  return zsv_writer_status_ok;
+}
+
+uint64_t zsv_writer_cum_bytes_written(zsv_csv_writer w) {
+  return (uint64_t)(w->out.used + w->out.written);
+}
+
+enum zsv_writer_status zsv_writer_cell(zsv_csv_writer w, char new_row, const unsigned char *s, size_t len,
+                                       char check_if_needs_quoting) {
+  if (!w)
+    return zsv_writer_status_missing_handle;
+  if (!w->started) {
+    if (w->table_init)
+      w->table_init(w->table_init_ctx);
+    if (w->with_bom)
+      zsv_output_buff_write(&w->out, (const unsigned char *)"\xef\xbb\xbf", 3);
+    w->started = 1;
+  } else if (new_row) {
+    if (VERY_UNLIKELY(w->on_row != NULL))
+      w->on_row(w->on_row_ctx);
+    zsv_output_buff_write(&w->out, (const unsigned char *)"\n", 1);
+  } else
+    zsv_output_buff_write(&w->out, (const unsigned char *)",", 1);
+
+  if (VERY_UNLIKELY(w->cell_prepend && *w->cell_prepend)) {
+    char *tmp = NULL;
+    asprintf(&tmp, "%s%.*s", w->cell_prepend, (int)len, s ? s : (const unsigned char *)"");
+    if (!tmp) {
+      perror(NULL);
+      return zsv_writer_status_error;
+    }
+    s = (const unsigned char *)tmp;
+    len = len + strlen(w->cell_prepend);
+    enum zsv_writer_status stat = zsv_writer_cell_aux(w, s, len, 1);
+    free(tmp);
+    return stat;
+  }
+  return zsv_writer_cell_aux(w, s, len, check_if_needs_quoting);
+}
+
+void zsv_writer_cell_prepend(zsv_csv_writer w, const unsigned char *s) {
+  w->cell_prepend = (const char *)s;
+}
+
+enum zsv_writer_status zsv_writer_cell_Lf(zsv_csv_writer w, char new_row, const char *fmt_spec, long double ldbl) {
+  char s[128];
+  char fmt[64];
+  int n = snprintf(fmt, sizeof(fmt), "%%%sLf", fmt_spec ? fmt_spec : "");
+  if (!(n > 0 && n < (int)sizeof(fmt)))
+    fprintf(stderr, "Invalid format specifier, should be X for format %%XLf e.g. '.2'\n");
+  else {
+    n = snprintf(s, sizeof(s), fmt, ldbl);
+    if (!(n > 0 && n < (int)sizeof(fmt)))
+      fprintf(stderr, "Unable to format value with fmt %s: %Lf\n", fmt, ldbl);
+    else
+      return zsv_writer_cell(w, new_row, (unsigned char *)s, n, 0);
+  }
+  zsv_writer_cell(w, new_row, NULL, 0, 0);
+  return zsv_writer_status_error;
+}
+
+enum zsv_writer_status zsv_writer_cell_blank(zsv_csv_writer w, char new_row) {
+  return zsv_writer_cell(w, new_row, (const unsigned char *)"", 0, 0);
+}
+
+enum zsv_writer_status zsv_writer_cell_zu(zsv_csv_writer w, char new_row, size_t zu) {
+  char s[64];
+  int n = snprintf(s, sizeof(s), "%zu", zu);
+  if (n < 1 || n >= (int)sizeof(s))
+    n = 0; // unexpected overflow
+  return zsv_writer_cell(w, new_row, (unsigned char *)s, n, 0);
+}
+
+enum zsv_writer_status zsv_writer_cell_s(zsv_csv_writer w, char new_row, const unsigned char *s,
+                                         char check_if_needs_quoting) {
+  return zsv_writer_cell(w, new_row, s, s ? strlen((const char *)s) : 0, check_if_needs_quoting);
+}
+
+/*
+ * returns: newly allocated value (caller must free) or NULL
+ */
+unsigned char *zsv_writer_str_to_csv(const unsigned char *s, size_t len) {
+  if (len) {
+    unsigned char *csv_s = zsv_csv_quote(s, len, NULL, 0);
+    if (csv_s)
+      return csv_s;
+    csv_s = malloc(len + 1);
+    memcpy(csv_s, s, len);
+    csv_s[len] = '\0';
+    return csv_s;
+  }
+  return NULL;
+}