zsv 1.3.0

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

@@ -0,0 +1,228 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h> // unlink()
+
+#include <errno.h>
+#include <zsv/utils/cache.h>
+#include <zsv/utils/jq.h>
+
+#ifndef APPNAME
+#define APPNAME "cache"
+#endif
+
+#include <zsv/utils/os.h>
+#include <zsv/utils/err.h>
+#include <zsv/utils/dirs.h>
+#include <zsv/utils/file.h>
+
+static const char *zsv_cache_type_name(enum zsv_cache_type t) {
+  switch (t) {
+  case zsv_cache_type_property:
+    return ZSV_CACHE_PROPERTIES_NAME ".json";
+  case zsv_cache_type_tag:
+    return "tag.json";
+  case zsv_cache_type_overwrite:
+    return "overwrite.sqlite3";
+  default:
+    return NULL;
+  }
+}
+
+unsigned char *zsv_cache_filepath(const unsigned char *data_filepath, enum zsv_cache_type type, char create_dir,
+                                  char temp_file) {
+  if (!data_filepath || !*data_filepath)
+    return NULL;
+
+  const char *cache_filename_base = zsv_cache_type_name(type);
+  if (!cache_filename_base) {
+    zsv_printerr(ENOMEM, "Out of memory!");
+    return NULL;
+  }
+
+  unsigned char *cache_filename;
+  asprintf((char **)&cache_filename, "%s%s", cache_filename_base, temp_file ? ZSV_TEMPFILE_SUFFIX : "");
+
+  unsigned char *s = cache_filename ? zsv_cache_path(data_filepath, cache_filename, 0) : NULL;
+  if (s && create_dir) {
+    char *last_slash_s = (char *)strrchr((void *)s, FILESLASH);
+    int err = 0;
+
+    // temporarily truncate the string so as to only leave its parent folder
+    *last_slash_s = '\0';
+
+    // ensure the parent dir exists
+    if (!zsv_dir_exists((char *)s))
+      err = zsv_mkdirs((char *)s, 0);
+    if (err) {
+      fprintf(stderr, "Unable to create cache directory %s\n", s);
+      free(s);
+      s = NULL;
+    } else
+      *last_slash_s = FILESLASH;
+  }
+
+  free(cache_filename);
+  return s;
+}
+
+/*
+ * print cache file to stdout
+ */
+int zsv_cache_print(const unsigned char *filepath, enum zsv_cache_type ctype, const unsigned char *default_value) {
+  int err = 0;
+  // to do: parse the json rather than just blindly regurgitating the file
+  unsigned char *cache_fn = zsv_cache_filepath(filepath, ctype, 0, 0);
+  if (cache_fn) {
+    FILE *f;
+    if (zsv_file_readable((char *)cache_fn, &err, &f)) {
+      char buff[1024];
+      size_t bytes;
+      while ((bytes = fread(buff, 1, sizeof(buff), f)))
+        fwrite(buff, 1, bytes, stdout);
+      fclose(f);
+    } else if (err == ENOENT) {
+      if (default_value)
+        printf("%s\n", default_value);
+    } else {
+      perror((const char *)cache_fn);
+      if (!err)
+        err = 1;
+    }
+  }
+  free(cache_fn);
+  return err;
+}
+
+/*
+ * remove a cache file
+ */
+
+int zsv_cache_remove(const unsigned char *filepath, enum zsv_cache_type ctype) {
+  int err = 0;
+  unsigned char *fn = zsv_cache_filepath(filepath, ctype, 0, 0);
+  if (!fn)
+    err = ENOMEM;
+  else if (zsv_file_readable((const char *)fn, &err, NULL)) {
+    err = unlink((const char *)fn);
+    if (err)
+      perror((const char *)fn);
+  } else if (err == ENOENT)
+    err = 0; // file d.n. exist, nothing to do
+  else
+    perror((const char *)fn);
+  free(fn);
+  return err;
+}
+
+/*
+ * modify a JSON cache file, write to tmp file, then replace the cache file
+ */
+int zsv_modify_cache_file(const unsigned char *filepath, enum zsv_cache_type ctype, const unsigned char *json_value1,
+                          const unsigned char *json_value2, const unsigned char *filter) {
+  unsigned char *cache_fn = zsv_cache_filepath((const unsigned char *)filepath, ctype, 0, 0);
+  unsigned char *cache_tmp_fn = zsv_cache_filepath((const unsigned char *)filepath, ctype, 1, 1);
+  FILE *cache_data = NULL;
+  if (!(cache_fn && cache_tmp_fn))
+    return zsv_printerr(ENOMEM, "Out of memory!");
+
+  cache_data = zsv_fopen((void *)cache_fn, "rb");
+  int err = 0;
+  if (!cache_data) {
+    err = errno;
+    if (err == ENOENT)
+      err = 0;
+    else { // file exists but could not be opened
+      perror((const char *)cache_fn);
+      return err;
+    }
+  }
+
+  if (cache_data) {
+    // check that we have at least 1 byte of data
+    fseek(cache_data, 1, SEEK_SET);
+    if (!ftell(cache_data)) { // empty file; will use default value of "{}"
+      fclose(cache_data);
+      cache_data = NULL;
+    } else
+      fseek(cache_data, 0, SEEK_SET);
+  }
+
+  // jq filter to apply to [current_properties, id, value]
+  FILE *tmp = zsv_fopen((const char *)cache_tmp_fn, "wb");
+  if (!tmp) {
+    if (!(err = errno))
+      err = 1;
+    perror((const char *)cache_tmp_fn);
+  } else {
+    struct jv_to_json_ctx ctx = {0};
+    ctx.write1 = zsv_jq_fwrite1;
+    ctx.ctx = tmp;
+    ctx.flags = JV_PRINT_PRETTY | JV_PRINT_SPACE1;
+    enum zsv_jq_status jqstat;
+    void *jqh = zsv_jq_new(filter, jv_to_json_func, &ctx, &jqstat);
+    if (jqstat || !jqh)
+      err = zsv_printerr(-1, "Unable to initialize jq filter");
+    else if (!(jqstat = zsv_jq_parse(jqh, "[", 1))) {
+      if (cache_data)
+        jqstat = zsv_jq_parse_file(jqh, cache_data);
+      else
+        jqstat = zsv_jq_parse(jqh, "{}", 2);
+      if (!jqstat && !(jqstat = zsv_jq_parse(jqh, ",", 1)) &&
+          !(jqstat = zsv_jq_parse(jqh, json_value1, strlen((void *)json_value1))) &&
+          !(jqstat = zsv_jq_parse(jqh, ",", 1)) &&
+          !(jqstat = zsv_jq_parse(jqh, json_value2, strlen((void *)json_value2))) &&
+          !(jqstat = zsv_jq_parse(jqh, "]", 1)) && !(jqstat = zsv_jq_finish(jqh))) {
+        ;
+      }
+    }
+    zsv_jq_delete(jqh);
+
+    if (cache_data) {
+      fclose(cache_data);
+      cache_data = NULL;
+    }
+    fclose(tmp);
+
+    if (!jqstat && zsv_replace_file(cache_tmp_fn, cache_fn)) {
+      err = zsv_printerr(-1, "Unable to save %s: ", cache_fn);
+      zsv_perror(NULL);
+    }
+  }
+
+  if (cache_data)
+    fclose(cache_data);
+  free(cache_fn);
+  free(cache_tmp_fn);
+  return err;
+}
+
+/**
+ * Returns the folder or file path to the cache for a given data file
+ * Caller must free the returned result
+ */
+unsigned char *zsv_cache_path(const unsigned char *data_filepath, const unsigned char *cache_filename, char temp_file) {
+  if (!data_filepath)
+    return NULL;
+  const unsigned char *last_slash = (void *)strrchr((void *)data_filepath, '/');
+  const unsigned char *last_backslash = (void *)strrchr((void *)data_filepath, '\\');
+  const unsigned char *dir_end = (!last_slash && !last_backslash ? NULL
+                                  : last_backslash > last_slash  ? last_backslash
+                                                                 : last_slash);
+  char *s = NULL;
+  char *filename_suffix = NULL;
+  if (cache_filename)
+    asprintf(&filename_suffix, "%c%s%s", FILESLASH, cache_filename, temp_file ? ZSV_TEMPFILE_SUFFIX : "");
+
+  if (!dir_end) // file is in current dir
+    asprintf(&s, ZSV_CACHE_DIR "%c%s%s", FILESLASH, data_filepath, filename_suffix ? filename_suffix : "");
+  else if (dir_end[1]) {
+    asprintf(&s, "%.*s%c" ZSV_CACHE_DIR "%c%s%s", (int)(dir_end - data_filepath), data_filepath, FILESLASH, FILESLASH,
+             dir_end + 1, filename_suffix ? filename_suffix : "");
+    for (int i = 0; s && s[i]; i++)
+      if (s[i] != FILESLASH && (s[i] == '/' || s[i] == '\\'))
+        s[i] = FILESLASH;
+  }
+  free(filename_suffix);
+  return (unsigned char *)s;
+}

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

@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h> // malloc/free
+#include <errno.h>  // error reporting
+
+// Define a reasonable buffer size for the buffered copy
+#define COPY_BUFFER_SIZE (1024 * 64) // 64KB
+
+#ifdef _WIN32
+// Windows target (via mingw64)
+#include <io.h>      // _get_osfhandle
+#include <windows.h> // HANDLE, ReadFile, WriteFile
+#else
+// POSIX target (Linux/macOS)
+#include <sys/stat.h> // fstat, stat
+// #include <sys/uio.h>  // macOS/BSD sendfile() definition
+#ifdef __linux__
+#include <sys/sendfile.h> // only on Linux
+#endif
+#endif
+
+// concatenate two files. if possible, use zero-copy via sendfile
+long zsv_concatenate_copy(int out_fd, int in_fd, off_t size) {
+  long total_written = 0;
+
+#ifdef _WIN32
+  // --- windows: buffered copy via native apis
+  HANDLE hOut = (HANDLE)_get_osfhandle(out_fd);
+  HANDLE hIn = (HANDLE)_get_osfhandle(in_fd);
+  if (hOut == INVALID_HANDLE_VALUE || hIn == INVALID_HANDLE_VALUE)
+    return -1;
+
+  char *buffer = malloc(COPY_BUFFER_SIZE);
+  if (!buffer)
+    return -1;
+
+  DWORD bytes_read, bytes_written;
+  BOOL result;
+
+  while (total_written < size) {
+    DWORD bytes_to_read =
+      (DWORD)((size - total_written < COPY_BUFFER_SIZE) ? (size - total_written) : COPY_BUFFER_SIZE);
+
+    result = ReadFile(hIn, buffer, bytes_to_read, &bytes_read, NULL);
+    if (!result || bytes_read == 0) {
+      free(buffer);
+      return -1;
+    }
+
+    result = WriteFile(hOut, buffer, bytes_read, &bytes_written, NULL);
+    if (!result || bytes_written != bytes_read) {
+      free(buffer);
+      return -1;
+    }
+
+    total_written += bytes_written;
+  }
+
+  free(buffer);
+  return total_written;
+
+#elif defined(__linux__)
+  // --- linux: zero-copy! ---
+  off_t offset = 0;
+  long bytes_to_copy = size;
+  // sendfile: target_fd, source_fd, offset*, count
+  long result = sendfile(out_fd, in_fd, &offset, bytes_to_copy);
+  return result;
+
+#else
+  (void)(size);
+  // --- generic posix fallback (buffered copy) ---
+  char *buffer = malloc(COPY_BUFFER_SIZE);
+  if (!buffer)
+    return -1;
+
+  ssize_t read_bytes, write_bytes;
+  while ((read_bytes = read(in_fd, buffer, COPY_BUFFER_SIZE)) > 0) {
+    write_bytes = write(out_fd, buffer, read_bytes);
+    if (write_bytes != read_bytes) {
+      free(buffer);
+      return -1;
+    }
+    total_written += write_bytes;
+  }
+  free(buffer);
+  return (read_bytes == 0) ? total_written : -1;
+#endif
+}

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

@@ -0,0 +1,240 @@
+// /src/app/utils/chunk.c: implements /src/app/utils/chunk.h
+
+#include <sys/stat.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "chunk.h"
+
+/**
+ * @brief Checks if a character is a newline character ('\n' or '\r').
+ * @param c The character to check.
+ * @return int 1 if newline, 0 otherwise.
+ */
+static int zsv_is_newline(char c) {
+  return (c == '\n' || c == '\r');
+}
+
+/**
+ * @brief Scans forward from an initial offset to find the first position after a newline sequence.
+ *
+ * @param fp The open file pointer.
+ * @param initial_offset The starting point of the search (nominal boundary).
+ * @param boundary The absolute maximum file size (total_size).
+ * @param only_crlf If non-zero, only treat \r\n as a newline.
+ * @return zsv_file_pos The position after the newline sequence, or -1 if not found.
+ */
+static zsv_file_pos zsv_find_chunk_start(FILE *fp, zsv_file_pos initial_offset, zsv_file_pos boundary, int only_crlf) {
+  char c;
+  // Seek to the initial offset.
+  if (fseek(fp, initial_offset, SEEK_SET) != 0) {
+    return -1; // Seek error
+  }
+
+  // Scan forward for the start of a newline sequence
+  while (ftell(fp) < boundary && fread(&c, 1, 1, fp) == 1) {
+    if (only_crlf) {
+      if (c == '\r') {
+        // We found a CR. Check immediately if the next char is LF.
+        char next;
+        if (ftell(fp) < boundary && fread(&next, 1, 1, fp) == 1) {
+          if (next == '\n') {
+            // Found \r\n sequence. The chunk starts immediately after.
+            return ftell(fp);
+          }
+          // The next char was NOT \n.
+          // We must rewind one byte so the loop processes 'next' correctly
+          // (in case 'next' is itself a \r starting a valid sequence).
+          fseek(fp, -1, SEEK_CUR);
+        }
+      }
+    } else {
+      if (zsv_is_newline(c)) {
+        // Found the start of a sequence. Scan past all consecutive newline characters.
+        zsv_file_pos position_after_newline = ftell(fp);
+
+        while (position_after_newline < boundary && fread(&c, 1, 1, fp) == 1) {
+          if (zsv_is_newline(c)) {
+            position_after_newline = ftell(fp); // Keep tracking position past the sequence
+          } else {
+            // Found the first non-newline character.
+            // The new start is at the current position (one byte past the last read)
+            // so we return the start of that character (ftell - 1).
+            return ftell(fp) - 1;
+          }
+        }
+        // If inner loop breaks due to EOF, return -1
+        return -1;
+      }
+    }
+  }
+
+  // Reached EOF/boundary without finding a valid split point
+  return -1;
+}
+
+static int zsv_read_first_line_at_offset(const char *filename, zsv_file_pos offset, char *buffer, size_t buf_size) {
+  FILE *fp = fopen(filename, "rb");
+  if (fp == NULL) {
+    perror("zsv_read_first_line_at_offset: Failed to open file");
+    return -1;
+  }
+
+  if (offset < 0 || fseek(fp, offset, SEEK_SET) != 0) {
+    fprintf(stderr, "zsv_read_first_line_at_offset: Error: Invalid offset or fseek failed at %lld\n",
+            (long long)offset);
+    fclose(fp);
+    return -1;
+  }
+
+  // Use fgets. It handles both \n and \r\n line endings appropriately.
+  if (fgets(buffer, (int)buf_size, fp) == NULL) {
+    if (feof(fp)) {
+      buffer[0] = '\0'; // Empty chunk
+    } else {
+      perror("zsv_read_first_line_at_offset: fgets failed");
+      fclose(fp);
+      return -1;
+    }
+  }
+
+  // Remove the trailing newline sequence (CRLF or LF) for clean output (DRY cleanup logic)
+  size_t len = strlen(buffer);
+  if (len > 0) {
+    // Check for LF
+    if (buffer[len - 1] == '\n') {
+      buffer[--len] = '\0';
+    }
+    // Check for CR (handles both bare CR and the CR in CRLF)
+    if (len > 0 && buffer[len - 1] == '\r') {
+      buffer[len - 1] = '\0';
+    }
+  }
+
+  fclose(fp);
+  return 0;
+}
+
+// --- Public Library Implementations ---
+
+struct zsv_chunk_position *zsv_guess_file_chunks(const char *filename, uint64_t N, uint64_t min_size,
+                                                 zsv_file_pos initial_offset
+#ifndef ZSV_NO_ONLY_CRLF
+                                                 ,
+                                                 int only_crlf
+#endif
+) {
+
+#ifdef ZSV_NO_ONLY_CRLF
+  int only_crlf = 0;
+#endif
+  if (N == 0)
+    return NULL;
+
+  // Open in binary mode ('rb') is crucial for accurate byte counts.
+  FILE *fp = fopen(filename, "rb");
+  if (fp == NULL) {
+    perror("zsv_guess_file_chunks: Failed to open file");
+    return NULL;
+  }
+
+  // 1. Get total file size using fstat()
+  struct stat st;
+  if (fstat(fileno(fp), &st) == -1) {
+    perror("zsv_guess_file_chunks: fstat failed");
+    fclose(fp);
+    return NULL;
+  }
+  zsv_file_pos total_size = (zsv_file_pos)st.st_size;
+  if (total_size < initial_offset) {
+    perror("zsv_guess_file_chunks: initial_offset exceeds file size");
+    fclose(fp);
+    return NULL;
+  }
+  total_size -= initial_offset;
+
+  if (total_size < (zsv_file_pos)min_size) {
+    fprintf(stderr, "file size too small for parallelization\n");
+    fclose(fp);
+    return NULL;
+  }
+
+  // Allocate memory for the N chunk positions
+  struct zsv_chunk_position *chunks = (struct zsv_chunk_position *)malloc(N * sizeof(*chunks));
+  if (chunks == NULL) {
+    perror("zsv_guess_file_chunks: malloc failed");
+    fclose(fp);
+    return NULL;
+  }
+
+  if (initial_offset)
+    fseek(fp, initial_offset, SEEK_SET);
+
+  zsv_file_pos base_size = total_size / N;
+  zsv_file_pos current_offset = initial_offset;
+
+  for (uint64_t i = 0; i < N; ++i) {
+    chunks[i].start = current_offset;
+
+    // Calculate the initial nominal boundary for this chunk
+    zsv_file_pos nominal_boundary = (i == N - 1) ? total_size : (zsv_file_pos)((i + 1) * base_size);
+
+    if (i < N - 1) {
+      // Adjust the boundary for all but the last chunk
+      // Pass the only_crlf flag down to the helper
+      zsv_file_pos new_start_offset = zsv_find_chunk_start(fp, nominal_boundary, total_size, only_crlf);
+
+      if (new_start_offset < 0) {
+        // Warning: Could not find a valid split after nominal boundary
+        // We use the nominal boundary, which might break a line
+        chunks[i].end = nominal_boundary - 1;
+        current_offset = nominal_boundary;
+      } else {
+        chunks[i].end = new_start_offset - 1;
+        current_offset = new_start_offset;
+      }
+    } else {
+      // The last chunk always ends at the total_size - 1 byte
+      chunks[i].end = total_size + initial_offset > 0 ? total_size + initial_offset - 1 : 0;
+    }
+
+    // Defensive check for inverted start/end
+    if (chunks[i].start > chunks[i].end && total_size > 0)
+      chunks[i].end = chunks[i].start;
+  }
+
+  fclose(fp);
+  return chunks;
+}
+
+void zsv_free_chunks(struct zsv_chunk_position *chunks) {
+  if (chunks) {
+    free(chunks);
+  }
+}
+
+const char *zsv_chunk_status_str(enum zsv_chunk_status stat) {
+  switch (stat) {
+  case zsv_chunk_status_ok:
+    return NULL;
+  case zsv_chunk_status_no_file_input:
+    return "Parallelization requires a file input";
+  case zsv_chunk_status_overwrite:
+    return "Parallelization cannot be used with overwrite";
+  case zsv_chunk_status_max_rows:
+    return "Parallelization cannot be used with -L,--limit-rows";
+  }
+  return NULL;
+}
+
+enum zsv_chunk_status zsv_chunkable(const char *inputpath, struct zsv_opts *opts) {
+  if (!inputpath)
+    return zsv_chunk_status_no_file_input;
+  struct zsv_opt_overwrite o = {0};
+  if (memcmp(&opts->overwrite, &o, sizeof(o)) || opts->overwrite_auto)
+    return zsv_chunk_status_overwrite;
+  if (opts->max_rows)
+    return zsv_chunk_status_max_rows;
+  return zsv_chunk_status_ok;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/chunk.h

@@ -0,0 +1,63 @@
+#ifndef ZSV_CHUNK_H
+#define ZSV_CHUNK_H
+
+#include <zsv/common.h> // struct zsv_opts
+#include <stddef.h>     // For size_t
+#include <stdint.h>     // For uint64_t
+#include <sys/types.h>  // For off_t
+
+typedef off_t zsv_file_pos;
+
+// Define a struct to hold the (start, end) pair using the standard zsv_file_pos type
+struct zsv_chunk_position {
+  zsv_file_pos start;
+  zsv_file_pos end;
+};
+
+/**
+ * @brief Divide a file into N chunks for parallel processing.
+ *
+ * Scans the file to find N approximately equal sections, ensuring that
+ * chunk boundaries align with newline sequences so rows are not split.
+ *
+ * @param filename Path to the file to be chunked.
+ * @param N The target number of chunks.
+ * @param min_size The minimum file size required to attempt parallelization.
+ * @param initial_offset The byte offset to start chunking from (usually 0).
+ * @param only_crlf If non-zero, boundaries are split strictly on \r\n sequences.
+ * If zero, \r or \n are accepted as boundaries.
+ * @return struct zsv_chunk_position* An array of N chunk positions (must be freed by caller),
+ * or NULL if the file cannot be chunked or an error occurs.
+ */
+struct zsv_chunk_position *zsv_guess_file_chunks(const char *filename, uint64_t N, uint64_t min_size,
+                                                 zsv_file_pos initial_offset
+#ifndef ZSV_NO_ONLY_CRLF
+                                                 ,
+                                                 int only_crlf
+#endif
+);
+
+/**
+ * @brief Frees the memory allocated by zsv_guess_file_chunks. (DRY Cleanup)
+ * @param chunks The pointer to the allocated chunk array.
+ */
+void zsv_free_chunks(struct zsv_chunk_position *chunks);
+
+enum zsv_chunk_status {
+  zsv_chunk_status_ok = 0,
+  zsv_chunk_status_no_file_input,
+  zsv_chunk_status_overwrite,
+  zsv_chunk_status_max_rows
+};
+
+/**
+ * zsv_chunkable(): check if chunking is compatible wth options; return chunk_status
+ */
+enum zsv_chunk_status zsv_chunkable(const char *inputpath, struct zsv_opts *opts);
+
+/**
+ * Convert zsv_chunk_status to string description
+ */
+const char *zsv_chunk_status_str(enum zsv_chunk_status stat);
+
+#endif // ZSV_CHUNK_H

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

@@ -0,0 +1,57 @@
+/*
+ * 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/clock.h>
+
+clock_t zsv_clock_begin;
+clock_t zsv_clock_in;
+clock_t zsv_clock_out;
+int i_tmp;
+
+size_t zsv_fread_clock(void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream) {
+  clock_t clock_tmp = clock();
+  size_t sz = fread(ptr, size, nitems, stream);
+  zsv_clock_in += clock() - clock_tmp;
+  return sz;
+}
+
+size_t zsv_fwrite_clock(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream) {
+  clock_t clock_tmp = clock();
+  size_t sz = fwrite(ptr, size, nitems, stream);
+  zsv_clock_out += clock() - clock_tmp;
+  return sz;
+}
+
+int zsv_fflush_clock(FILE *stream) {
+  clock_t clock_tmp = clock();
+  int i = fflush(stream);
+  zsv_clock_out += clock() - clock_tmp;
+  return i;
+}
+
+void zsv_clocks_begin(void) {
+  zsv_clock_in = zsv_clock_out = 0;
+  zsv_clock_begin = clock();
+}
+
+void zsv_clocks_end(void) {
+  clock_t clock_end = clock();
+  clock_t clock_total = clock_end - zsv_clock_begin;
+  clock_t clock_other = clock_total - zsv_clock_in - zsv_clock_out;
+  fprintf(stderr,
+          "elapsed time:\n"
+          "  total %zu, %Lf\n"
+          "  in %zu, %Lf\n"
+          "  out %zu, %Lf\n"
+          "  other %zu, %Lf\n"
+          "\n",
+          (size_t)(clock_total), (long double)(clock_total) / CLOCKS_PER_SEC, (size_t)zsv_clock_in,
+          (long double)(zsv_clock_in) / CLOCKS_PER_SEC, (size_t)zsv_clock_out,
+          (long double)(zsv_clock_out) / CLOCKS_PER_SEC, (size_t)clock_other,
+          (long double)(clock_other) / CLOCKS_PER_SEC);
+}