zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/select/selection.c

@@ -0,0 +1,192 @@
+static enum zsv_select_column_index_selection_type zsv_select_column_index_selection(const unsigned char *arg,
+                                                                                     unsigned *lo, unsigned *hi);
+
+static inline void zsv_select_add_exclusion(struct zsv_select_data *data, const char *name) {
+  if (data->exclusion_count < MAX_EXCLUSIONS)
+    data->exclusions[data->exclusion_count++] = (const unsigned char *)name;
+}
+
+static inline unsigned char *zsv_select_get_header_name(struct zsv_select_data *data, unsigned in_ix) {
+  if (in_ix < data->header_name_count)
+    return data->header_names[in_ix];
+  return NULL;
+}
+
+static inline char zsv_select_excluded_current_header_name(struct zsv_select_data *data, unsigned in_ix) {
+  if (data->exclusion_count) {
+    if (data->use_header_indexes) {
+      for (unsigned int ix = 0; ix < data->exclusion_count; ix++) {
+        unsigned i, j;
+        switch (zsv_select_column_index_selection(data->exclusions[ix], &i, &j)) {
+        case zsv_select_column_index_selection_type_none:
+          // not expected!
+          break;
+        case zsv_select_column_index_selection_type_single:
+          if (in_ix + 1 == i)
+            return 1;
+          break;
+        case zsv_select_column_index_selection_type_range:
+          if (i <= in_ix + 1 && in_ix + 1 <= j)
+            return 1;
+          break;
+        case zsv_select_column_index_selection_type_lower_bounded:
+          if (i <= in_ix + 1)
+            return 1;
+          break;
+        }
+      }
+    } else {
+      unsigned char *header_name = zsv_select_get_header_name(data, in_ix);
+      if (header_name) {
+        for (unsigned int i = 0; i < data->exclusion_count; i++)
+          if (!zsv_stricmp(header_name, data->exclusions[i]))
+            return 1;
+      }
+    }
+  }
+  return 0;
+}
+
+// zsv_select_find_header(): return 1-based index, or 0 if not found
+static int zsv_select_find_header(struct zsv_select_data *data, const unsigned char *header_name) {
+  if (header_name) {
+    for (unsigned int i = 0; i < data->output_cols_count; i++) {
+      unsigned char *prior_header_name = zsv_select_get_header_name(data, data->out2in[i].ix);
+      if (prior_header_name && !zsv_stricmp(header_name, prior_header_name))
+        return i + 1;
+    }
+  }
+  return 0;
+}
+
+static int zsv_select_add_output_col(struct zsv_select_data *data, unsigned in_ix) {
+  int err = 0;
+  if (data->output_cols_count < data->opts->max_columns) {
+    int found = zsv_select_find_header(data, zsv_select_get_header_name(data, in_ix));
+    if (data->distinct && found) {
+      if (data->distinct == ZSV_SELECT_DISTINCT_MERGE) {
+        // add this index
+        struct zsv_select_uint_list *ix = calloc(1, sizeof(*ix));
+        if (!ix)
+          err = zsv_printerr(1, "Out of memory!\n");
+        else {
+          ix->value = in_ix;
+          if (!data->out2in[found - 1].merge.indexes)
+            data->out2in[found - 1].merge.indexes = ix;
+          else
+            *data->out2in[found - 1].merge.last_index = ix;
+          data->out2in[found - 1].merge.last_index = &ix->next;
+        }
+      }
+      return err;
+    }
+    if (zsv_select_excluded_current_header_name(data, in_ix))
+      return err;
+    data->out2in[data->output_cols_count++].ix = in_ix;
+  }
+  return err;
+}
+
+// not very fast, but we don't need it to be
+static inline unsigned int str_array_ifind(const unsigned char *needle, unsigned char *haystack[], unsigned hay_count) {
+  for (unsigned int i = 0; i < hay_count; i++) {
+    if (!(needle && *needle) && !(haystack[i] && *haystack[i]))
+      return i + 1;
+    if (!(needle && *needle && haystack[i] && *haystack[i]))
+      continue;
+    if (!zsv_stricmp(needle, haystack[i]))
+      return i + 1;
+  }
+  return 0;
+}
+
+static int zsv_select_set_output_columns(struct zsv_select_data *data) {
+  int err = 0;
+  unsigned int header_name_count = data->header_name_count;
+  if (!data->col_argc) {
+    for (unsigned int i = 0; !err && i < header_name_count; i++)
+      err = zsv_select_add_output_col(data, i);
+  } else if (data->use_header_indexes) {
+    for (int arg_i = 0; !err && arg_i < data->col_argc; arg_i++) {
+      const char *arg = data->col_argv[arg_i];
+      unsigned i, j;
+      switch (zsv_select_column_index_selection((const unsigned char *)arg, &i, &j)) {
+      case zsv_select_column_index_selection_type_none:
+        zsv_printerr(1, "Invalid column index: %s", arg);
+        err = -1;
+        break;
+      case zsv_select_column_index_selection_type_single:
+        err = zsv_select_add_output_col(data, i - 1);
+        break;
+      case zsv_select_column_index_selection_type_range:
+        while (i <= j && i < data->opts->max_columns) {
+          err = zsv_select_add_output_col(data, i - 1);
+          i++;
+        }
+        break;
+      case zsv_select_column_index_selection_type_lower_bounded:
+        if (i) {
+          for (unsigned int k = i - 1; !err && k < header_name_count; k++)
+            err = zsv_select_add_output_col(data, k);
+        }
+        break;
+      }
+    }
+  } else { // using header names
+    for (int arg_i = 0; !err && arg_i < data->col_argc; arg_i++) {
+      // find the location of the matching header name, if any
+      unsigned int in_pos =
+        str_array_ifind((const unsigned char *)data->col_argv[arg_i], data->header_names, header_name_count);
+      if (!in_pos) {
+        fprintf(stderr, "Column %s not found\n", data->col_argv[arg_i]);
+        err = -1;
+      } else
+        err = zsv_select_add_output_col(data, in_pos - 1);
+    }
+  }
+  return err;
+}
+
+static enum zsv_select_column_index_selection_type zsv_select_column_index_selection(const unsigned char *arg,
+                                                                                     unsigned *lo, unsigned *hi) {
+  enum zsv_select_column_index_selection_type result = zsv_select_column_index_selection_type_none;
+
+  unsigned int i = 0;
+  unsigned int j = 0;
+  int n = 0;
+  int k = sscanf((const char *)arg, "%u-%u%n", &i, &j, &n);
+  if (k == 2) {
+    if (n >= 0 && (size_t)n == strlen((const char *)arg) && i > 0 && j >= i)
+      result = zsv_select_column_index_selection_type_range;
+  } else {
+    k = sscanf((const char *)arg, "%u%n", &i, &n);
+    if (k == 1 && n >= 0 && (size_t)n == strlen((const char *)arg)) {
+      if (i > 0)
+        result = zsv_select_column_index_selection_type_single;
+    } else {
+      k = sscanf((const char *)arg, "%u-%n", &i, &n);
+      if (k == 1 && n >= 0 && (size_t)n == strlen((const char *)arg)) {
+        if (i > 0) {
+          result = zsv_select_column_index_selection_type_lower_bounded;
+          j = 0;
+        }
+      }
+    }
+  }
+  if (lo)
+    *lo = i;
+  if (hi)
+    *hi = j;
+  return result;
+}
+
+// zsv_select_check_exclusions_are_indexes(): return err
+static int zsv_select_check_exclusions_are_indexes(struct zsv_select_data *data) {
+  int err = 0;
+  for (unsigned int e = 0; e < data->exclusion_count; e++) {
+    const unsigned char *arg = data->exclusions[e];
+    if (zsv_select_column_index_selection(arg, NULL, NULL) == zsv_select_column_index_selection_type_none)
+      err = zsv_printerr(1, "Invalid column index: %s", arg);
+  }
+  return err;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/select/usage.c

@@ -0,0 +1,72 @@
+const char *zsv_select_usage_msg[] = {
+  APPNAME ": extracts and outputs specified columns",
+  "",
+  "Usage: " APPNAME " [filename] [options] [-- col_specifier [... col_specifier]]",
+  "       where col_specifier is a column name or, if the -n option is used,",
+  "       a column index (starting at 1) or index range in the form of n-m",
+  "       e.g. " APPNAME " -n file.csv -- 1 4-6 50 10",
+  "            " APPNAME " file.csv -- first_col fiftieth_column \"Tenth Column\"",
+  "",
+  "Note: Outputs the columns specified after '--' separator, or all columns if omitted.",
+  "",
+  "Options:",
+  "  -b,--with-bom                : output with BOM",
+  "  --fixed <offset1,offset2,..> : parse as fixed-width text; use given CSV list of positive integers for",
+  "                                 cell and indexes",
+  "  --fixed-auto                 : parse as fixed-width text; derive widths from first row in input data (max 256k)",
+  "                                 assumes ASCII whitespace; multi-byte whitespace is not counted as whitespace",
+  "  --fixed-auto-max-lines       : maximum number of lines to use in calculating fixed widths",
+#ifndef ZSV_CLI
+  "  -v,--verbose                 : verbose output",
+#endif
+  "  -H,--head <n>                : (head) only process the first n rows of input data (including header)",
+  "  --skip-data <n>              : skip the specified number of data rows",
+  "  --no-header                  : do not output header row",
+  "  --prepend-header <value>     : prepend each column header with the given text <value>",
+  "  -s,--search <value>          : only output rows with at least one cell containing <value>",
+#ifdef HAVE_PCRE2_8
+  "  --regex-search <pattern>     : only output rows with at least one cell matching the given regex pattern",
+#endif
+  // TO DO: " -s,--search /<pattern>/modifiers: search on regex pattern; modifiers include 'g' (global) and 'i'
+  // (case-insensitive)",
+  "  --sample-every <num_of_rows> : output a sample consisting of the first row, then every nth row",
+  "  --sample-pct <percentage>    : output a randomly-selected sample (32 bits of randomness) of n%% of input rows",
+  "  --distinct                   : skip subsequent occurrences of columns with the same name",
+  "  --merge                      : merge subsequent occurrences of columns with the same name",
+  "                                 outputting first non-null value",
+  // --rename: like distinct, but instead of removing cols with dupe names, renames them, trying _<n> for n up to max
+  // cols
+  "  -e <embedded_lineend_char>   : char to replace embedded lineend. If left empty, embedded lineends are preserved.",
+  "                                 If the provided string begins with 0x, it will be interpreted as the hex",
+  "                                 representation of a string.",
+  "  -x <column>                  : exclude the indicated column. can be specified more than once",
+  "  -N,--line-number             : prefix each row with the row number",
+  "  -n                           : provided column indexes are numbers corresponding to column positions",
+  "                                 (starting with 1), instead of names",
+#ifndef ZSV_CLI
+  "  -T                           : input is tab-delimited, instead of comma-delimited",
+  "  -O,--other-delim <delim>     : input is delimited with the given char",
+  "                                 Note: This option does not support quoted values with embedded delimiters.",
+#endif
+  "  --unescape                   : escape any backslash-escaped input e.g. \\t, \\n, \\r such as output from `2tsv`",
+  "  -w,--whitespace-clean        : normalize all whitespace to space or newline, single-char (non-consecutive)",
+  "                                 occurrences",
+  "  --whitespace-clean-no-newline: clean whitespace and remove embedded newlines",
+  "  -W,--no-trim                 : do not trim whitespace",
+#ifndef ZSV_CLI
+  "  -C <max_num_of_columns>      : defaults to " ZSV_SELECT_MAX_COLS_DEFAULT_S,
+  "  -L,--max-row-size <n>        : set the maximum memory used for a single row",
+  "                                 Default: " ZSV_ROW_MAX_SIZE_MIN_S " (min), " ZSV_ROW_MAX_SIZE_DEFAULT_S " (max)",
+#endif
+#ifndef ZSV_NO_PARALLEL
+  "  -j,--jobs <N>                : parallelize using N threads",
+  "  --parallel                   : parallelize using a number of threads equal to the number of cores",
+#endif
+  "  -o <filename>                : filename to save output to",
+  NULL,
+};
+
+static void zsv_select_usage(void) {
+  for (size_t i = 0; zsv_select_usage_msg[i]; i++)
+    fprintf(stdout, "%s\n", zsv_select_usage_msg[i]);
+}