zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/pivot.c

@@ -0,0 +1,318 @@
+/*
+ * Copyright (C) 2021 Liquidaty and zsv contributors. All rights reserved.
+ * This file is part of zsv/lib, distributed under the license defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include "../external/sqlite3/sqlite3.h"
+#include <zsv/ext/implementation.h>
+#include <zsv/ext/sheet.h>
+#include <zsv/utils/writer.h>
+#include <zsv/utils/file.h>
+#include <zsv/utils/prop.h>
+#include "file.h"
+#include "handlers_internal.h"
+#include "./curses.h"
+#include "../sql_internal.h"
+
+#include "sheet-sql.c"
+
+struct pivot_row {
+  char *value;
+};
+
+struct pivot_data {
+  char *value_sql; // the sql expression entered by the user e.g. City
+  char *data_filename;
+  struct {
+    struct pivot_row *data; // for each row, the value of the sql expression e.g. New York
+    size_t capacity;
+    size_t used;
+  } rows;
+  char column_name_expr;
+};
+
+static void pivot_data_delete(void *h) {
+  struct pivot_data *pd = h;
+  if (pd) {
+    for (size_t i = 0; i < pd->rows.used; i++)
+      free(pd->rows.data[i].value);
+    free(pd->rows.data);
+    free(pd->value_sql);
+    free(pd->data_filename);
+    free(pd);
+  }
+}
+
+static struct pivot_data *pivot_data_new(const char *data_filename, const char *value_sql, char column_name_expr) {
+  struct pivot_data *pd = calloc(1, sizeof(*pd));
+  if (pd && (pd->value_sql = strdup(value_sql)) && (pd->data_filename = strdup(data_filename))) {
+    pd->column_name_expr = column_name_expr;
+    return pd;
+  }
+  pivot_data_delete(pd);
+  return NULL;
+}
+
+#define ZSV_MYSHEET_PIVOT_DATA_ROWS_INITIAL 32
+static int pivot_data_grow(struct pivot_data *pd) {
+  if (pd->rows.used == pd->rows.capacity) {
+    size_t new_capacity = pd->rows.capacity == 0 ? ZSV_MYSHEET_PIVOT_DATA_ROWS_INITIAL : pd->rows.capacity * 2;
+    struct pivot_row *new_data = realloc(pd->rows.data, new_capacity * sizeof(*pd->rows.data));
+    if (!new_data)
+      return ENOMEM;
+    pd->rows.data = new_data;
+    pd->rows.capacity = new_capacity;
+  }
+  return 0;
+}
+
+static int add_pivot_row(struct pivot_data *pd, const char *value, size_t len) {
+  int err = pivot_data_grow(pd);
+  char *value_dup = NULL;
+  if (!err && value && len) {
+    value_dup = malloc(len + 1);
+    if (value_dup) {
+      memcpy(value_dup, value, len);
+      value_dup[len] = '\0';
+    }
+  }
+  pd->rows.data[pd->rows.used++].value = value_dup;
+  return err;
+}
+
+static struct pivot_row *get_pivot_row_data(struct pivot_data *pd, size_t row_ix) {
+  if (pd && row_ix < pd->rows.used)
+    return &pd->rows.data[row_ix];
+  return NULL;
+}
+
+static enum zsv_ext_status get_cell_attrs(void *pdh, zsvsheet_cell_attr_t *attrs, size_t start_row, size_t row_count,
+                                          size_t cols) {
+  struct pivot_data *pd = pdh;
+  size_t end_row = start_row + row_count;
+  int attr = 0;
+
+#ifdef A_BOLD
+  attr |= A_BOLD;
+#endif
+// Absent on Mac OSX 13
+#ifdef A_ITALIC
+  attr |= A_ITALIC;
+#endif
+
+  if (end_row > pd->rows.used)
+    end_row = pd->rows.used;
+  for (size_t i = start_row; i < end_row; i++)
+    attrs[i * cols] = attr;
+  return zsv_ext_status_ok;
+}
+
+static void pivot_on_header_cell(void *ctx, size_t col_ix, const char *colname) {
+  (void)colname;
+  if (col_ix == 0)
+    add_pivot_row(ctx, NULL, 0);
+}
+
+static void pivot_on_data_cell(void *ctx, size_t col_ix, const char *text, size_t len) {
+  if (col_ix == 0)
+    add_pivot_row(ctx, text, len);
+}
+
+zsvsheet_status pivot_drill_down(zsvsheet_proc_context_t ctx) {
+  enum zsvsheet_status zst = zsvsheet_status_ok;
+  zsvsheet_buffer_t buff = zsvsheet_buffer_current(ctx);
+  struct pivot_data *pd;
+  struct zsvsheet_rowcol rc;
+  if (zsvsheet_buffer_get_ctx(buff, (void **)&pd) != zsv_ext_status_ok ||
+      zsvsheet_buffer_get_selected_cell(buff, &rc) != zsvsheet_status_ok) {
+    return zsvsheet_status_error;
+  }
+  struct pivot_row *pr = get_pivot_row_data(pd, rc.row);
+  if (pd && pd->data_filename && pd->value_sql && pr) {
+    struct zsv_sqlite3_dbopts dbopts = {0};
+    sqlite3_str *sql_str = NULL;
+    struct zsv_sqlite3_db *zdb = zsv_sqlite3_db_new(&dbopts);
+
+    if (!zdb || !(sql_str = sqlite3_str_new(zdb->db)))
+      zst = zsvsheet_status_memory;
+    else if (zdb->rc == SQLITE_OK && zsv_sqlite3_add_csv_no_dq(zdb, pd->data_filename, NULL, NULL) == SQLITE_OK) {
+      if (zsvsheet_buffer_info(buff).has_row_num)
+        sqlite3_str_appendf(sql_str, "select *");
+      else
+        sqlite3_str_appendf(sql_str, "select rowid as [Row #], *");
+      if (pd->column_name_expr)
+        sqlite3_str_appendf(sql_str, " from data where \"%w\" = %Q", pd->value_sql, pr->value);
+      else
+        // we haven't tracked whether the underlying value is a string, number or other
+        // we only know that its string representation is pr->value
+        // so we add `|| ''` to the sql expression to force text conversion
+        sqlite3_str_appendf(sql_str, " from data where (%s) || '' = %Q", pd->value_sql, pr->value);
+      const char *err_msg = NULL;
+      zst = zsv_sqlite3_to_csv(ctx, zdb, sqlite3_str_value(sql_str), &err_msg, NULL, NULL, NULL);
+      if (err_msg)
+        zsvsheet_ui_buffer_set_status(buff, err_msg);
+      else if (zst == zsvsheet_status_no_data)
+        zsvsheet_ui_buffer_set_status(buff, "No results returned");
+    }
+
+    if (sql_str)
+      sqlite3_free(sqlite3_str_finish(sql_str));
+    if (zdb) {
+      if (zst != zsvsheet_status_ok) {
+        // to do: consolidate this with same code in /app/sql.c
+        if (zdb->err_msg)
+          fprintf(stderr, "Error: %s\n", zdb->err_msg);
+        else if (!zdb->db)
+          fprintf(stderr, "Error (unable to open db, code %i): %s\n", zdb->rc, sqlite3_errstr(zdb->rc));
+        else if (zdb->rc != SQLITE_OK)
+          fprintf(stderr, "Error (code %i): %s\n", zdb->rc, sqlite3_errstr(zdb->rc));
+      }
+      zsv_sqlite3_db_delete(zdb);
+    }
+  }
+  return zst;
+}
+
+static void zsvsheet_check_buffer_worker_updates(struct zsvsheet_ui_buffer *ub,
+                                                 struct zsvsheet_display_dimensions *display_dims,
+                                                 struct zsvsheet_sheet_context *handler_state);
+
+/**
+ * Here we define a custom command for the zsv `sheet` feature
+ */
+static zsvsheet_status zsvsheet_pivot_handler(struct zsvsheet_proc_context *ctx) {
+  char result_buffer[256] = {0};
+  const char *expr;
+  char column_name_expr;
+  struct zsvsheet_rowcol rc;
+  int ch = zsvsheet_ext_keypress(ctx);
+
+  if (ch < 0)
+    return zsvsheet_status_error;
+
+  zsvsheet_buffer_t buff = zsvsheet_buffer_current(ctx);
+  const char *data_filename = NULL;
+  if (buff)
+    data_filename = zsvsheet_buffer_data_filename(buff);
+
+  if (!data_filename) { // TO DO: check that the underlying data is a tabular file and we know how to parse
+    zsvsheet_ui_buffer_set_status(buff, "Pivot table only available for tabular data buffers");
+    return zsvsheet_status_ok;
+  }
+
+  char *selected_cell_str_dup = NULL;
+  switch (ctx->proc_id) {
+  case zsvsheet_builtin_proc_pivot_expr:
+    zsvsheet_ext_prompt(ctx, result_buffer, sizeof(result_buffer), "Pivot table: Enter group-by SQL expr");
+    if (*result_buffer == '\0')
+      return zsvsheet_status_ok;
+    expr = result_buffer;
+    column_name_expr = 0;
+    break;
+  case zsvsheet_builtin_proc_pivot_cur_col:
+    if (zsvsheet_buffer_get_selected_cell(buff, &rc) != zsvsheet_status_ok)
+      return zsvsheet_status_error;
+    const unsigned char *selected_cell_str =
+      zsvsheet_screen_buffer_cell_display(((struct zsvsheet_ui_buffer *)buff)->buffer, rc.row, rc.col);
+    while (selected_cell_str && *selected_cell_str == ' ')
+      selected_cell_str++;
+    size_t len = selected_cell_str ? strlen((const char *)selected_cell_str) : 0;
+    while (len > 0 && selected_cell_str[len - 1] == ' ')
+      len--;
+    if (len)
+      selected_cell_str_dup = zsv_memdup(selected_cell_str, len);
+    expr = zsvsheet_ui_buffer_get_header(buff, rc.col);
+    column_name_expr = 1;
+    assert(expr);
+    break;
+  default:
+    assert(0);
+    return zsvsheet_status_error;
+  }
+
+  enum zsvsheet_status zst = zsvsheet_status_ok;
+  struct zsv_sqlite3_dbopts dbopts = {0};
+  struct zsv_opts zopts = zsvsheet_buffer_get_zsv_opts(buff);
+  struct zsv_sqlite3_db *zdb = zsv_sqlite3_db_new(&dbopts);
+  sqlite3_str *sql_str = NULL;
+  struct pivot_data *pd = NULL;
+  if (!zdb || !(sql_str = sqlite3_str_new(zdb->db)))
+    zst = zsvsheet_status_memory;
+  else if (zdb->rc == SQLITE_OK && zsv_sqlite3_add_csv_no_dq(zdb, data_filename, &zopts, NULL) == SQLITE_OK) {
+    int ok = 0;
+    const char *err_msg = NULL;
+    if (column_name_expr) {
+      sqlite3_str_appendf(sql_str, "select \"%w\" as %#Q, count(1) as Count from data group by \"%w\"", expr, expr,
+                          expr);
+      ok = 1;
+    } else {
+      int err = 0;
+      if (is_constant_expression(zdb->db, expr, &err))
+        err_msg = "Please enter an expression that is not a constant";
+      else {
+        enum check_select_expression_result expr_rc = check_select_expression(zdb->db, expr, &err);
+        if (expr_rc != zsv_select_sql_expression_valid)
+          err_msg = check_select_expression_result_str(expr_rc);
+        else if (!err)
+          ok = 1;
+      }
+      if (!ok) {
+        if (err)
+          zsvsheet_ui_buffer_set_status(buff, strerror(err));
+        else if (err_msg)
+          zsvsheet_ui_buffer_set_status(buff, err_msg);
+        else
+          zsvsheet_ui_buffer_set_status(buff, "Unknown error");
+      } else
+        sqlite3_str_appendf(sql_str, "select %s as %#Q, count(1) as Count from data group by %s", expr, expr, expr);
+    }
+    if (ok) {
+      if (!(pd = pivot_data_new(data_filename, expr, column_name_expr)))
+        zst = zsvsheet_status_memory;
+      else {
+        zst = zsv_sqlite3_to_csv(ctx, zdb, sqlite3_str_value(sql_str), &err_msg, pd, pivot_on_header_cell,
+                                 pivot_on_data_cell);
+        if (zst != zsvsheet_status_ok) {
+          if (zst == zsvsheet_status_no_data)
+            zsvsheet_ui_buffer_set_status(buff, "No results returned");
+          else
+            zsvsheet_ui_buffer_set_status(buff, err_msg ? err_msg : "Unexpected error preparing SQL");
+        } else {
+          buff = zsvsheet_buffer_current(ctx);
+          zsvsheet_buffer_set_ctx(buff, pd, pivot_data_delete);
+          zsvsheet_buffer_set_cell_attrs(buff, get_cell_attrs);
+          zsvsheet_buffer_on_newline(buff, pivot_drill_down);
+          pd = NULL; // so that it isn't cleaned up below
+
+          while (!zsvsheet_ui_buffer_index_ready(buff, 0))
+            napms(200); // sleep for 200ms, then check index again
+          // TO DO: fix this if there is no data!
+
+          if (selected_cell_str_dup) {
+            struct zsvsheet_sheet_context *state = (struct zsvsheet_sheet_context *)ctx->subcommand_context;
+            struct zsvsheet_display_info *di = &state->display_info;
+            zsvsheet_check_buffer_worker_updates(buff, di->dimensions, NULL);
+            zsvsheet_handle_find_next(di, buff, selected_cell_str_dup,
+                                      1, // find value in first column
+                                      1, // exact
+                                      1, // header_span
+                                      di->dimensions, &di->update_buffer, NULL);
+          }
+        }
+      }
+    }
+    // TO DO: add param to ext_sheet_open_file to set filename vs data_filename, and set buffer type or proc owner
+    // TO DO: add way to attach custom context, and custom context destructor, to the new buffer
+    // TO DO: add cell highlighting
+  }
+
+  zsv_sqlite3_db_delete(zdb);
+  if (sql_str)
+    sqlite3_free(sqlite3_str_finish(sql_str));
+  pivot_data_delete(pd);
+  free(selected_cell_str_dup);
+  return zst;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/procedure.c

@@ -0,0 +1,134 @@
+#include "procedure.h"
+
+#if 0
+#define proc_debug(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define proc_debug(...) ((void)0)
+#endif
+
+#define MAX_PROCEDURES 512
+
+/* Each procedure can be given a name and in the future argument specification
+ * so it can be typed from the procedureline. Simple procedure like call motion
+ * don't can omit a name meaning they can only be executed via key binding.
+ */
+struct zsvsheet_procedure {
+  zsvsheet_proc_id_t id;
+  const char *name;
+  const char *description;
+  zsvsheet_proc_fn handler;
+};
+
+/* This array both stores procedures and works as a lookup table. */
+static struct zsvsheet_procedure procedure_lookup[MAX_PROCEDURES] = {0};
+
+static inline bool is_valid_proc_id(zsvsheet_proc_id_t id) {
+  return (0 < id && id < MAX_PROCEDURES);
+}
+
+struct zsvsheet_procedure *zsvsheet_find_procedure(zsvsheet_proc_id_t proc_id) {
+  struct zsvsheet_procedure *proc;
+  if (!is_valid_proc_id(proc_id))
+    return NULL;
+  proc = &procedure_lookup[proc_id];
+  if (proc->id == ZSVSHEET_PROC_INVALID)
+    return NULL;
+  assert(proc->id == proc_id);
+  return proc;
+}
+
+struct zsvsheet_procedure *zsvsheet_find_procedure_by_name(const char *name) {
+  struct zsvsheet_procedure *proc;
+  if (!name)
+    return NULL;
+  for (int i = 0; i < MAX_PROCEDURES; ++i) {
+    proc = &procedure_lookup[i];
+    if (is_valid_proc_id(proc->id) && proc->name && !strcmp(name, proc->name))
+      return proc;
+  }
+  return NULL;
+}
+
+static zsvsheet_proc_id_t zsvsheet_generate_proc_id(void) {
+  for (zsvsheet_proc_id_t id = MAX_PROCEDURES - 1; id > ZSVSHEET_PROC_INVALID; --id) {
+    if (!is_valid_proc_id(procedure_lookup[id].id))
+      return id;
+  }
+  return ZSVSHEET_PROC_INVALID;
+}
+
+zsvsheet_status zsvsheet_proc_invoke(zsvsheet_proc_id_t proc_id, struct zsvsheet_proc_context *ctx) {
+  proc_debug("invoke proc %d\n", proc_id);
+  struct zsvsheet_procedure *proc = zsvsheet_find_procedure(proc_id);
+  if (proc) {
+    proc_debug("call proc %d handler %p\n", proc->id, proc->handler);
+    return proc->handler(ctx);
+  }
+  return -1;
+}
+
+zsvsheet_status zsvsheet_proc_invoke_from_keypress(zsvsheet_proc_id_t proc_id, int ch, void *subcommand_context) {
+  struct zsvsheet_proc_context context = {
+    .proc_id = proc_id,
+    .invocation.type = zsvsheet_proc_invocation_type_keypress,
+    .invocation.interactive = true,
+    .invocation.u.keypress.ch = ch,
+    .subcommand_context = subcommand_context,
+  };
+  return zsvsheet_proc_invoke(proc_id, &context);
+}
+
+zsvsheet_status zsvsheet_proc_invoke_from_command(const char *command, struct zsvsheet_proc_context *context) {
+  char *toks[10] = {0};
+  char tokbuf[1024];
+  struct zsvsheet_lexer lexer;
+  char *proc_name;
+  struct zsvsheet_procedure *proc;
+
+  proc_debug("invoke from command: %s\n", command);
+  zsvsheet_lexer_init(&lexer, command, tokbuf, sizeof(tokbuf), toks, sizeof(toks) / sizeof(toks[0]));
+
+  if (zsvsheet_lexer_parse(&lexer) != zsvsheet_lexer_status_ok)
+    goto out;
+  if (lexer.num_toks == 0 || lexer.num_toks - 1 > ZSVSHEET_PROC_MAX_ARGS)
+    goto out;
+
+  proc_name = lexer.toks[0];
+  proc = zsvsheet_find_procedure_by_name(proc_name);
+  if (!proc)
+    goto out;
+
+  /* Prototypes can be added to procedures to specify what exact arguments they
+   * take. Here the arguments could be validated and typechecked against the
+   * prototype. For now we just pass the parameters as they are */
+  context->proc_id = proc->id;
+  context->num_params = lexer.num_toks - 1;
+  for (int i = 0; i < context->num_params; ++i)
+    context->params[i].u.string = lexer.toks[i + 1];
+
+  return zsvsheet_proc_invoke(proc->id, context);
+out:
+  return zsvsheet_status_error;
+}
+
+static zsvsheet_proc_id_t zsvsheet_do_register_proc(struct zsvsheet_procedure *proc) {
+  proc_debug("register proc %d %s\n", proc->id, proc->name ? proc->name : "(unnamed)");
+  if (!is_valid_proc_id(proc->id))
+    return -1;
+  if (zsvsheet_find_procedure(proc->id))
+    return -1;
+  procedure_lookup[proc->id] = *proc;
+  return proc->id;
+}
+
+zsvsheet_proc_id_t zsvsheet_register_builtin_proc(zsvsheet_proc_id_t id, const char *name, const char *description,
+                                                  zsvsheet_proc_fn handler) {
+  struct zsvsheet_procedure procedure = {.id = id, .name = name, .description = description, .handler = handler};
+  return zsvsheet_do_register_proc(&procedure);
+}
+
+zsvsheet_proc_id_t zsvsheet_register_proc(const char *name, const char *description, zsvsheet_proc_fn handler) {
+  struct zsvsheet_procedure procedure = {
+    .id = zsvsheet_generate_proc_id(), .name = name, .description = description, .handler = handler};
+  return zsvsheet_do_register_proc(&procedure);
+}

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/procedure.h

@@ -0,0 +1,119 @@
+#ifndef ZSVSHEET_PROCEDURE_H
+#define ZSVSHEET_PROCEDURE_H
+#include <stdbool.h>
+#include <zsv/ext.h>
+
+/* ID's of bulitin procedures, extensions can register more.
+ *
+ * TODO: What specific procedures are bulitin and what are their
+ *       id's is not a concern of the procedure system. This should
+ *       be defined by the registrar who defines those procedures,
+ *       in this case sheet. move it out of here at some point.
+ */
+enum {
+  zsvsheet_builtin_proc_unknown = 0,
+  zsvsheet_builtin_proc_quit,
+  zsvsheet_builtin_proc_escape,
+  zsvsheet_builtin_proc_move_bottom,
+  zsvsheet_builtin_proc_move_top,
+  zsvsheet_builtin_proc_move_first_col,
+  zsvsheet_builtin_proc_pg_down,
+  zsvsheet_builtin_proc_pg_up,
+  zsvsheet_builtin_proc_move_last_col,
+  zsvsheet_builtin_proc_move_up,
+  zsvsheet_builtin_proc_move_down,
+  zsvsheet_builtin_proc_move_left,
+  zsvsheet_builtin_proc_move_right,
+  zsvsheet_builtin_proc_filter,
+  zsvsheet_builtin_proc_filter_this,
+  zsvsheet_builtin_proc_sqlfilter,
+  zsvsheet_builtin_proc_find,
+  zsvsheet_builtin_proc_find_next,
+  zsvsheet_builtin_proc_goto_column,
+  zsvsheet_builtin_proc_open_file,
+  zsvsheet_builtin_proc_resize,
+  zsvsheet_builtin_proc_prompt,
+  zsvsheet_builtin_proc_subcommand,
+  zsvsheet_builtin_proc_help,
+  zsvsheet_builtin_proc_vim_g_key_binding_dmux,
+  zsvsheet_builtin_proc_newline,
+  zsvsheet_builtin_proc_pivot_expr,
+  zsvsheet_builtin_proc_pivot_cur_col,
+  zsvsheet_builtin_proc_errors,
+  zsvsheet_builtin_proc_errors_clear
+};
+
+#define ZSVSHEET_PROC_INVALID 0
+#define ZSVSHEET_PROC_MAX_ARGS 5
+
+/* Procedures perform various actions in the editor. Procedures can be invoked
+ * by key-bindings, prompt invocation, another procedure or script. */
+
+enum zsvsheet_proc_invocation_type {
+  zsvsheet_proc_invocation_type_keypress,
+  zsvsheet_proc_invocation_type_proc,
+  /* Add more... */
+};
+
+struct zsvsheet_proc_context {
+  zsvsheet_proc_id_t proc_id;
+  /* Information about how this procedure was called i.e. through a keypress,
+   * command invocation, another procedure, a script etc... */
+  struct {
+    enum zsvsheet_proc_invocation_type type;
+
+    /* Can we prompt user to type-in parameters? If not prompt_get should fail. */
+    bool interactive;
+
+    /* Type specific info */
+    union {
+      struct {
+        int ch;
+      } keypress;
+      struct {
+        zsvsheet_proc_id_t id;
+      } proc;
+    } u;
+  } invocation;
+
+  int num_params;
+  struct {
+    /* TODO: typing */
+    union {
+      const char *string;
+    } u;
+  } params[ZSVSHEET_PROC_MAX_ARGS];
+
+  /* Within context of which subcommand has this proc been called? */
+  void *subcommand_context;
+};
+
+enum zsvsheet_proc_arg_type {
+  ZSVSHEET_PROC_ARG_TYPE_INVALID,
+  ZSVSHEET_PROC_ARG_TYPE_INT,
+  ZSVSHEET_PROC_ARG_TYPE_STRING,
+};
+
+typedef zsvsheet_status (*zsvsheet_proc_fn)(struct zsvsheet_proc_context *ctx);
+
+/* Wrapper for procedure invocation from keypress */
+zsvsheet_status zsvsheet_proc_invoke_from_keypress(zsvsheet_proc_id_t proc_id, int ch, void *subcommand_context);
+
+/* Invoke a procedure based on subcommand/script statement. For script support
+ * this is likely too simple but its a nice simple API subcommand.  */
+zsvsheet_status zsvsheet_proc_invoke_from_command(const char *command, struct zsvsheet_proc_context *context);
+
+/* Base proc invocation function */
+zsvsheet_status zsvsheet_proc_invoke(zsvsheet_proc_id_t proc_id, struct zsvsheet_proc_context *ctx);
+
+/* Register builtin procedure with fixed id */
+zsvsheet_proc_id_t zsvsheet_register_builtin_proc(zsvsheet_proc_id_t id, const char *name, const char *description,
+                                                  zsvsheet_proc_fn handler);
+
+/* Dynamically register a procedure, returns a positive id or negative error */
+zsvsheet_proc_id_t zsvsheet_register_proc(const char *name, const char *description, zsvsheet_proc_fn handler);
+
+/* Find procedure by name */
+struct zsvsheet_procedure *zsvsheet_find_procedure_by_name(const char *name);
+
+#endif /* ZSVSHEET_PROCEDURE_H */