From 2cb5bf997bfa81df0290e0496a15f1f39a569e78 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=93scar=20N=C3=A1jera?= Date: Thu, 5 May 2022 14:42:32 +0200 Subject: Import my guile libraries --- bin/habit | 41 + bin/tagmail | 2 +- home-dots/dot-bashrc | 2 +- install.scm | 1 - lib/guile/ffi/notmuch.ffi | 4 + lib/guile/ffi/notmuch.scm | 2512 +++++++++++++++++++++++++++++++++++++++++++++ lib/guile/mail-tools.scm | 126 +++ lib/guile/read-habit.scm | 68 ++ lib/guile/tests.scm | 65 ++ lib/guile/utils.scm | 27 + 10 files changed, 2845 insertions(+), 3 deletions(-) create mode 100755 bin/habit create mode 100644 lib/guile/ffi/notmuch.ffi create mode 100644 lib/guile/ffi/notmuch.scm create mode 100644 lib/guile/mail-tools.scm create mode 100755 lib/guile/read-habit.scm create mode 100755 lib/guile/tests.scm create mode 100755 lib/guile/utils.scm diff --git a/bin/habit b/bin/habit new file mode 100755 index 0000000..5afb4ce --- /dev/null +++ b/bin/habit @@ -0,0 +1,41 @@ +#!/usr/bin/guile \ +-e main-rofi -s +!# + +(add-to-load-path "/home/titan/dev/dotfiles/lib/guile/") + +(use-modules (ice-9 rdelim) + (ice-9 popen) + (ice-9 ftw) + (ice-9 format) + (ice-9 and-let-star) + (utils)) + +(define habits-dir (expand-file "~/org/habits/")) + +(define (get-habit-files dir) + (scandir dir (lambda (file) (string-suffix? ".dat" file)))) + +(define (prepare-options files) + (string-join (map (lambda (name) (string-drop-right name 4)) files) "\n")) + +(define (rofi-capture-option options) + (let* ((cmd (format #f "echo -e ~s | rofi -dmenu" options)) + (port (open-input-pipe cmd)) + (option (read-line port))) + (close-pipe port) + (if (eof-object? option) #f option))) + +(define (rofi-capture-habit-quantity habit) + (let* ((cmd (format #f "echo 1 | rofi -dmenu -p 'Add to ~a'" habit)) + (port (open-input-pipe cmd)) + (quantity (read-line port))) + (close-pipe port) + (if (eof-object? quantity) #f quantity))) + +(define (main-rofi args) + (and-let* ((habit (rofi-capture-option (prepare-options (get-habit-files habits-dir)))) + (quantity (rofi-capture-habit-quantity habit)) + (file-out (open-file (string-append habits-dir habit ".dat") "a"))) + (format file-out "~d:~a\n" (current-time) quantity) + (close-port file-out))) diff --git a/bin/tagmail b/bin/tagmail index 31a236d..02e5d6e 100755 --- a/bin/tagmail +++ b/bin/tagmail @@ -10,7 +10,7 @@ LD_LIBRARY_PATH=$HOME/.guix-profile/lib exec guile -e main -s "$0" "$@" (add-to-load-path (string-append (passwd:dir (getpwuid (geteuid))) - "/dev/helpful_scripts/guile/" )) + "/dev/dotfiles/lib/guile/" )) (use-modules (ffi notmuch) diff --git a/home-dots/dot-bashrc b/home-dots/dot-bashrc index 963fbec..55d28a4 100644 --- a/home-dots/dot-bashrc +++ b/home-dots/dot-bashrc @@ -59,7 +59,7 @@ if [ "${gnupg_SSH_AUTH_SOCK_by:-0}" -ne $$ ]; then export SSH_AUTH_SOCK="$(gpgconf --list-dirs agent-ssh-socket)" fi -export PATH="$HOME/.local/bin:$PATH" +export PATH="$HOME/.local/bin:$HOME/dev/dotfiles/bin:$PATH" alias isrun='ps -ae | grep' alias gdimg='git difftool -t image_diff' alias G='grep -i' diff --git a/install.scm b/install.scm index 05dd0bc..fe0dc2d 100755 --- a/install.scm +++ b/install.scm @@ -207,7 +207,6 @@ (symlink-tree "home-dots" "~/") (config-links "gnupg/gpg.conf" "~/.gnupg/gpg.conf" #f) (config-links "gnupg/gpg-agent.conf" "~/.gnupg/gpg-agent.conf" #f) - (symlink-tree "bin" "~/.local/bin") (symlink-tree "config" "~/.config") (mail-config) diff --git a/lib/guile/ffi/notmuch.ffi b/lib/guile/ffi/notmuch.ffi new file mode 100644 index 0000000..1f8bfce --- /dev/null +++ b/lib/guile/ffi/notmuch.ffi @@ -0,0 +1,4 @@ +(define-ffi-module (ffi notmuch) + ; #:pkg-config "notmuch" + #:library '("libnotmuch") + #:include '("notmuch.h")) diff --git a/lib/guile/ffi/notmuch.scm b/lib/guile/ffi/notmuch.scm new file mode 100644 index 0000000..42c3ab3 --- /dev/null +++ b/lib/guile/ffi/notmuch.scm @@ -0,0 +1,2512 @@ +;; generated with `guild compile-ffi ffi/notmuch.ffi' + +(define-module (ffi notmuch) + #:use-module (system ffi-help-rt) + #:use-module ((system foreign) #:prefix ffi:) + #:use-module (bytestructures guile)) + +(define ffi-notmuch-llibs + (delay (list (dynamic-link "libnotmuch")))) + +(cond-expand + (guile-2.2) + (guile-2 + (define intptr_t long) + (define uintptr_t unsigned-long))) + + +;; typedef int notmuch_bool_t; +(define-public notmuch_bool_t-desc int) + +;; typedef enum _notmuch_status { +;; NOTMUCH_STATUS_SUCCESS = 0, +;; NOTMUCH_STATUS_OUT_OF_MEMORY, +;; NOTMUCH_STATUS_READ_ONLY_DATABASE, +;; NOTMUCH_STATUS_XAPIAN_EXCEPTION, +;; NOTMUCH_STATUS_FILE_ERROR, +;; NOTMUCH_STATUS_FILE_NOT_EMAIL, +;; NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID, +;; NOTMUCH_STATUS_NULL_POINTER, +;; NOTMUCH_STATUS_TAG_TOO_LONG, +;; NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW, +;; NOTMUCH_STATUS_UNBALANCED_ATOMIC, +;; NOTMUCH_STATUS_UNSUPPORTED_OPERATION, +;; NOTMUCH_STATUS_UPGRADE_REQUIRED, +;; NOTMUCH_STATUS_PATH_ERROR, +;; NOTMUCH_STATUS_IGNORED, +;; NOTMUCH_STATUS_ILLEGAL_ARGUMENT, +;; NOTMUCH_STATUS_MALFORMED_CRYPTO_PROTOCOL, +;; NOTMUCH_STATUS_FAILED_CRYPTO_CONTEXT_CREATION, +;; NOTMUCH_STATUS_UNKNOWN_CRYPTO_PROTOCOL, +;; NOTMUCH_STATUS_LAST_STATUS, +;; } notmuch_status_t; +(define notmuch_status_t-enum-nvl + '((NOTMUCH_STATUS_SUCCESS . 0) + (NOTMUCH_STATUS_OUT_OF_MEMORY . 1) + (NOTMUCH_STATUS_READ_ONLY_DATABASE . 2) + (NOTMUCH_STATUS_XAPIAN_EXCEPTION . 3) + (NOTMUCH_STATUS_FILE_ERROR . 4) + (NOTMUCH_STATUS_FILE_NOT_EMAIL . 5) + (NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID . 6) + (NOTMUCH_STATUS_NULL_POINTER . 7) + (NOTMUCH_STATUS_TAG_TOO_LONG . 8) + (NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW . 9) + (NOTMUCH_STATUS_UNBALANCED_ATOMIC . 10) + (NOTMUCH_STATUS_UNSUPPORTED_OPERATION . 11) + (NOTMUCH_STATUS_UPGRADE_REQUIRED . 12) + (NOTMUCH_STATUS_PATH_ERROR . 13) + (NOTMUCH_STATUS_IGNORED . 14) + (NOTMUCH_STATUS_ILLEGAL_ARGUMENT . 15) + (NOTMUCH_STATUS_MALFORMED_CRYPTO_PROTOCOL . 16) + (NOTMUCH_STATUS_FAILED_CRYPTO_CONTEXT_CREATION + . + 17) + (NOTMUCH_STATUS_UNKNOWN_CRYPTO_PROTOCOL . 18) + (NOTMUCH_STATUS_LAST_STATUS . 19)) + ) +(define notmuch_status_t-enum-vnl + (map (lambda (pair) (cons (cdr pair) (car pair))) + notmuch_status_t-enum-nvl)) +(define-public (unwrap-notmuch_status_t n) + (cond + ((symbol? n) + (or (assq-ref notmuch_status_t-enum-nvl n) (error "bad arg"))) + ((integer? n) n) + (else (error "bad arg")))) +(define-public (wrap-notmuch_status_t v) + (assq-ref notmuch_status_t-enum-vnl v)) +(define-public unwrap-enum-_notmuch_status unwrap-notmuch_status_t) +(define-public wrap-enum-_notmuch_status wrap-notmuch_status_t) + +;; enum _notmuch_status { +;; NOTMUCH_STATUS_SUCCESS = 0, +;; NOTMUCH_STATUS_OUT_OF_MEMORY, +;; NOTMUCH_STATUS_READ_ONLY_DATABASE, +;; NOTMUCH_STATUS_XAPIAN_EXCEPTION, +;; NOTMUCH_STATUS_FILE_ERROR, +;; NOTMUCH_STATUS_FILE_NOT_EMAIL, +;; NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID, +;; NOTMUCH_STATUS_NULL_POINTER, +;; NOTMUCH_STATUS_TAG_TOO_LONG, +;; NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW, +;; NOTMUCH_STATUS_UNBALANCED_ATOMIC, +;; NOTMUCH_STATUS_UNSUPPORTED_OPERATION, +;; NOTMUCH_STATUS_UPGRADE_REQUIRED, +;; NOTMUCH_STATUS_PATH_ERROR, +;; NOTMUCH_STATUS_IGNORED, +;; NOTMUCH_STATUS_ILLEGAL_ARGUMENT, +;; NOTMUCH_STATUS_MALFORMED_CRYPTO_PROTOCOL, +;; NOTMUCH_STATUS_FAILED_CRYPTO_CONTEXT_CREATION, +;; NOTMUCH_STATUS_UNKNOWN_CRYPTO_PROTOCOL, +;; NOTMUCH_STATUS_LAST_STATUS, +;; }; + +;; const char *notmuch_status_to_string(notmuch_status_t status); +(define notmuch_status_to_string + (let ((~notmuch_status_to_string + (delay (fh-link-proc + ffi-void* + "notmuch_status_to_string" + (list ffi:int) + (force ffi-notmuch-llibs))))) + (lambda (status) + (let ((~status (unwrap-notmuch_status_t status))) + ((force ~notmuch_status_to_string) ~status))))) +(export notmuch_status_to_string) + +;; typedef struct _notmuch_database notmuch_database_t; +(define-public notmuch_database_t-desc 'void) +(define-fh-type-alias notmuch_database_t fh-void) +(define-public notmuch_database_t? fh-void?) +(define-public make-notmuch_database_t make-fh-void) +(define-public notmuch_database_t*-desc (fh:pointer notmuch_database_t-desc)) +(define-fh-pointer-type notmuch_database_t* notmuch_database_t*-desc + notmuch_database_t*? make-notmuch_database_t*) +(export notmuch_database_t* notmuch_database_t*? make-notmuch_database_t*) + +;; typedef struct _notmuch_query notmuch_query_t; +(define-public notmuch_query_t-desc 'void) +(define-fh-type-alias notmuch_query_t fh-void) +(define-public notmuch_query_t? fh-void?) +(define-public make-notmuch_query_t make-fh-void) +(define-public notmuch_query_t*-desc (fh:pointer notmuch_query_t-desc)) +(define-fh-pointer-type notmuch_query_t* notmuch_query_t*-desc + notmuch_query_t*? make-notmuch_query_t*) +(export notmuch_query_t* notmuch_query_t*? make-notmuch_query_t*) + +;; typedef struct _notmuch_threads notmuch_threads_t; +(define-public notmuch_threads_t-desc 'void) +(define-fh-type-alias notmuch_threads_t fh-void) +(define-public notmuch_threads_t? fh-void?) +(define-public make-notmuch_threads_t make-fh-void) +(define-public notmuch_threads_t*-desc (fh:pointer notmuch_threads_t-desc)) +(define-fh-pointer-type notmuch_threads_t* notmuch_threads_t*-desc + notmuch_threads_t*? make-notmuch_threads_t*) +(export notmuch_threads_t* notmuch_threads_t*? make-notmuch_threads_t*) + +;; typedef struct _notmuch_thread notmuch_thread_t; +(define-public notmuch_thread_t-desc 'void) +(define-fh-type-alias notmuch_thread_t fh-void) +(define-public notmuch_thread_t? fh-void?) +(define-public make-notmuch_thread_t make-fh-void) +(define-public notmuch_thread_t*-desc (fh:pointer notmuch_thread_t-desc)) +(define-fh-pointer-type notmuch_thread_t* notmuch_thread_t*-desc + notmuch_thread_t*? make-notmuch_thread_t*) +(export notmuch_thread_t* notmuch_thread_t*? make-notmuch_thread_t*) + +;; typedef struct _notmuch_messages notmuch_messages_t; +(define-public notmuch_messages_t-desc 'void) +(define-fh-type-alias notmuch_messages_t fh-void) +(define-public notmuch_messages_t? fh-void?) +(define-public make-notmuch_messages_t make-fh-void) +(define-public notmuch_messages_t*-desc (fh:pointer notmuch_messages_t-desc)) +(define-fh-pointer-type notmuch_messages_t* notmuch_messages_t*-desc + notmuch_messages_t*? make-notmuch_messages_t*) +(export notmuch_messages_t* notmuch_messages_t*? make-notmuch_messages_t*) + +;; typedef struct _notmuch_message notmuch_message_t; +(define-public notmuch_message_t-desc 'void) +(define-fh-type-alias notmuch_message_t fh-void) +(define-public notmuch_message_t? fh-void?) +(define-public make-notmuch_message_t make-fh-void) +(define-public notmuch_message_t*-desc (fh:pointer notmuch_message_t-desc)) +(define-fh-pointer-type notmuch_message_t* notmuch_message_t*-desc + notmuch_message_t*? make-notmuch_message_t*) +(export notmuch_message_t* notmuch_message_t*? make-notmuch_message_t*) + +;; typedef struct _notmuch_tags notmuch_tags_t; +(define-public notmuch_tags_t-desc 'void) +(define-fh-type-alias notmuch_tags_t fh-void) +(define-public notmuch_tags_t? fh-void?) +(define-public make-notmuch_tags_t make-fh-void) +(define-public notmuch_tags_t*-desc (fh:pointer notmuch_tags_t-desc)) +(define-fh-pointer-type notmuch_tags_t* notmuch_tags_t*-desc notmuch_tags_t*? + make-notmuch_tags_t*) +(export notmuch_tags_t* notmuch_tags_t*? make-notmuch_tags_t*) + +;; typedef struct _notmuch_directory notmuch_directory_t; +(define-public notmuch_directory_t-desc 'void) +(define-fh-type-alias notmuch_directory_t fh-void) +(define-public notmuch_directory_t? fh-void?) +(define-public make-notmuch_directory_t make-fh-void) +(define-public notmuch_directory_t*-desc (fh:pointer notmuch_directory_t-desc)) +(define-fh-pointer-type notmuch_directory_t* notmuch_directory_t*-desc + notmuch_directory_t*? make-notmuch_directory_t*) +(export notmuch_directory_t* notmuch_directory_t*? make-notmuch_directory_t*) + +;; typedef struct _notmuch_filenames notmuch_filenames_t; +(define-public notmuch_filenames_t-desc 'void) +(define-fh-type-alias notmuch_filenames_t fh-void) +(define-public notmuch_filenames_t? fh-void?) +(define-public make-notmuch_filenames_t make-fh-void) +(define-public notmuch_filenames_t*-desc (fh:pointer notmuch_filenames_t-desc)) +(define-fh-pointer-type notmuch_filenames_t* notmuch_filenames_t*-desc + notmuch_filenames_t*? make-notmuch_filenames_t*) +(export notmuch_filenames_t* notmuch_filenames_t*? make-notmuch_filenames_t*) + +;; typedef struct _notmuch_config_list notmuch_config_list_t; +(define-public notmuch_config_list_t-desc 'void) +(define-fh-type-alias notmuch_config_list_t fh-void) +(define-public notmuch_config_list_t? fh-void?) +(define-public make-notmuch_config_list_t make-fh-void) +(define-public notmuch_config_list_t*-desc (fh:pointer notmuch_config_list_t-desc)) +(define-fh-pointer-type notmuch_config_list_t* notmuch_config_list_t*-desc + notmuch_config_list_t*? make-notmuch_config_list_t*) +(export notmuch_config_list_t* notmuch_config_list_t*? + make-notmuch_config_list_t*) + +;; typedef struct _notmuch_indexopts notmuch_indexopts_t; +(define-public notmuch_indexopts_t-desc 'void) +(define-fh-type-alias notmuch_indexopts_t fh-void) +(define-public notmuch_indexopts_t? fh-void?) +(define-public make-notmuch_indexopts_t make-fh-void) +(define-public notmuch_indexopts_t*-desc (fh:pointer notmuch_indexopts_t-desc)) +(define-fh-pointer-type notmuch_indexopts_t* notmuch_indexopts_t*-desc + notmuch_indexopts_t*? make-notmuch_indexopts_t*) +(export notmuch_indexopts_t* notmuch_indexopts_t*? make-notmuch_indexopts_t*) + +;; notmuch_status_t notmuch_database_create(const char *path, +;; notmuch_database_t **database); +(define notmuch_database_create + (let ((~notmuch_database_create + (delay (fh-link-proc + ffi:int + "notmuch_database_create" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (path database) + (let ((~path (unwrap~pointer path)) + (~database (unwrap~pointer database))) + (wrap-notmuch_status_t + ((force ~notmuch_database_create) + ~path + ~database)))))) +(export notmuch_database_create) + +;; notmuch_status_t notmuch_database_create_verbose(const char *path, +;; notmuch_database_t **database, char **error_message); +(define notmuch_database_create_verbose + (let ((~notmuch_database_create_verbose + (delay (fh-link-proc + ffi:int + "notmuch_database_create_verbose" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (path database error_message) + (let ((~path (unwrap~pointer path)) + (~database (unwrap~pointer database)) + (~error_message (unwrap~pointer error_message))) + (wrap-notmuch_status_t + ((force ~notmuch_database_create_verbose) + ~path + ~database + ~error_message)))))) +(export notmuch_database_create_verbose) + +;; typedef enum { +;; NOTMUCH_DATABASE_MODE_READ_ONLY = 0, +;; NOTMUCH_DATABASE_MODE_READ_WRITE, +;; } notmuch_database_mode_t; +(define notmuch_database_mode_t-enum-nvl + '((NOTMUCH_DATABASE_MODE_READ_ONLY . 0) + (NOTMUCH_DATABASE_MODE_READ_WRITE . 1)) + ) +(define notmuch_database_mode_t-enum-vnl + (map (lambda (pair) (cons (cdr pair) (car pair))) + notmuch_database_mode_t-enum-nvl)) +(define-public (unwrap-notmuch_database_mode_t n) + (cond + ((symbol? n) + (or (assq-ref notmuch_database_mode_t-enum-nvl n) (error "bad arg"))) + ((integer? n) n) + (else (error "bad arg")))) +(define-public (wrap-notmuch_database_mode_t v) + (assq-ref notmuch_database_mode_t-enum-vnl v)) + +;; notmuch_status_t notmuch_database_open(const char *path, +;; notmuch_database_mode_t mode, notmuch_database_t **database); +(define notmuch_database_open + (let ((~notmuch_database_open + (delay (fh-link-proc + ffi:int + "notmuch_database_open" + (list ffi-void* ffi:int ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (path mode database) + (let ((~path (unwrap~pointer path)) + (~mode (unwrap-notmuch_database_mode_t mode)) + (~database (unwrap~pointer database))) + (wrap-notmuch_status_t + ((force ~notmuch_database_open) + ~path + ~mode + ~database)))))) +(export notmuch_database_open) + +;; notmuch_status_t notmuch_database_open_verbose(const char *path, +;; notmuch_database_mode_t mode, notmuch_database_t **database, char ** +;; error_message); +(define notmuch_database_open_verbose + (let ((~notmuch_database_open_verbose + (delay (fh-link-proc + ffi:int + "notmuch_database_open_verbose" + (list ffi-void* ffi:int ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (path mode database error_message) + (let ((~path (unwrap~pointer path)) + (~mode (unwrap-notmuch_database_mode_t mode)) + (~database (unwrap~pointer database)) + (~error_message (unwrap~pointer error_message))) + (wrap-notmuch_status_t + ((force ~notmuch_database_open_verbose) + ~path + ~mode + ~database + ~error_message)))))) +(export notmuch_database_open_verbose) + +;; const char *notmuch_database_status_string(const notmuch_database_t *notmuch +;; ); +(define notmuch_database_status_string + (let ((~notmuch_database_status_string + (delay (fh-link-proc + ffi-void* + "notmuch_database_status_string" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (notmuch) + (let ((~notmuch + ((fht-unwrap notmuch_database_t*) notmuch))) + ((force ~notmuch_database_status_string) + ~notmuch))))) +(export notmuch_database_status_string) + +;; notmuch_status_t notmuch_database_close(notmuch_database_t *database); +(define notmuch_database_close + (let ((~notmuch_database_close + (delay (fh-link-proc + ffi:int + "notmuch_database_close" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database) + (let ((~database + ((fht-unwrap notmuch_database_t*) database))) + (wrap-notmuch_status_t + ((force ~notmuch_database_close) ~database)))))) +(export notmuch_database_close) + +;; typedef void (*notmuch_compact_status_cb_t)(const char *message, void * +;; closure); +(define-public notmuch_compact_status_cb_t-desc + (fh:pointer + (delay (fh:function + 'void + (list (fh:pointer int8) (fh:pointer 'void))))) + ) +(define-fh-function*-type + notmuch_compact_status_cb_t + notmuch_compact_status_cb_t-desc + notmuch_compact_status_cb_t? + make-notmuch_compact_status_cb_t) +(export notmuch_compact_status_cb_t notmuch_compact_status_cb_t? + make-notmuch_compact_status_cb_t) + +;; notmuch_status_t notmuch_database_compact(const char *path, const char * +;; backup_path, notmuch_compact_status_cb_t status_cb, void *closure); +(define notmuch_database_compact + (let ((~notmuch_database_compact + (delay (fh-link-proc + ffi:int + "notmuch_database_compact" + (list ffi-void* ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (path backup_path status_cb closure) + (let ((~path (unwrap~pointer path)) + (~backup_path (unwrap~pointer backup_path)) + (~status_cb + ((fht-unwrap notmuch_compact_status_cb_t) + status_cb)) + (~closure (unwrap~pointer closure))) + (wrap-notmuch_status_t + ((force ~notmuch_database_compact) + ~path + ~backup_path + ~status_cb + ~closure)))))) +(export notmuch_database_compact) + +;; notmuch_status_t notmuch_database_destroy(notmuch_database_t *database); +(define notmuch_database_destroy + (let ((~notmuch_database_destroy + (delay (fh-link-proc + ffi:int + "notmuch_database_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database) + (let ((~database + ((fht-unwrap notmuch_database_t*) database))) + (wrap-notmuch_status_t + ((force ~notmuch_database_destroy) ~database)))))) +(export notmuch_database_destroy) + +;; const char *notmuch_database_get_path(notmuch_database_t *database); +(define notmuch_database_get_path + (let ((~notmuch_database_get_path + (delay (fh-link-proc + ffi-void* + "notmuch_database_get_path" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database) + (let ((~database + ((fht-unwrap notmuch_database_t*) database))) + ((force ~notmuch_database_get_path) ~database))))) +(export notmuch_database_get_path) + +;; unsigned int notmuch_database_get_version(notmuch_database_t *database); +(define notmuch_database_get_version + (let ((~notmuch_database_get_version + (delay (fh-link-proc + ffi:unsigned-int + "notmuch_database_get_version" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database) + (let ((~database + ((fht-unwrap notmuch_database_t*) database))) + ((force ~notmuch_database_get_version) ~database))))) +(export notmuch_database_get_version) + +;; notmuch_bool_t notmuch_database_needs_upgrade(notmuch_database_t *database); +;; +(define notmuch_database_needs_upgrade + (let ((~notmuch_database_needs_upgrade + (delay (fh-link-proc + ffi:int + "notmuch_database_needs_upgrade" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database) + (let ((~database + ((fht-unwrap notmuch_database_t*) database))) + ((force ~notmuch_database_needs_upgrade) + ~database))))) +(export notmuch_database_needs_upgrade) + +;; notmuch_status_t notmuch_database_upgrade(notmuch_database_t *database, void +;; (*progress_notify)(void *closure, double progress), void *closure); +(define notmuch_database_upgrade + (let ((~notmuch_database_upgrade + (delay (fh-link-proc + ffi:int + "notmuch_database_upgrade" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database progress_notify closure) + (let ((~database + ((fht-unwrap notmuch_database_t*) database)) + (~progress_notify + ((make-fctn-param-unwrapper + ffi:void + (list ffi-void* ffi:double)) + progress_notify)) + (~closure (unwrap~pointer closure))) + (wrap-notmuch_status_t + ((force ~notmuch_database_upgrade) + ~database + ~progress_notify + ~closure)))))) +(export notmuch_database_upgrade) + +;; notmuch_status_t notmuch_database_begin_atomic(notmuch_database_t *notmuch); +;; +(define notmuch_database_begin_atomic + (let ((~notmuch_database_begin_atomic + (delay (fh-link-proc + ffi:int + "notmuch_database_begin_atomic" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (notmuch) + (let ((~notmuch + ((fht-unwrap notmuch_database_t*) notmuch))) + (wrap-notmuch_status_t + ((force ~notmuch_database_begin_atomic) ~notmuch)))))) +(export notmuch_database_begin_atomic) + +;; notmuch_status_t notmuch_database_end_atomic(notmuch_database_t *notmuch); +(define notmuch_database_end_atomic + (let ((~notmuch_database_end_atomic + (delay (fh-link-proc + ffi:int + "notmuch_database_end_atomic" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (notmuch) + (let ((~notmuch + ((fht-unwrap notmuch_database_t*) notmuch))) + (wrap-notmuch_status_t + ((force ~notmuch_database_end_atomic) ~notmuch)))))) +(export notmuch_database_end_atomic) + +;; unsigned long notmuch_database_get_revision(notmuch_database_t *notmuch, +;; const char **uuid); +(define notmuch_database_get_revision + (let ((~notmuch_database_get_revision + (delay (fh-link-proc + ffi:unsigned-long + "notmuch_database_get_revision" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (notmuch uuid) + (let ((~notmuch + ((fht-unwrap notmuch_database_t*) notmuch)) + (~uuid (unwrap~pointer uuid))) + ((force ~notmuch_database_get_revision) + ~notmuch + ~uuid))))) +(export notmuch_database_get_revision) + +;; notmuch_status_t notmuch_database_get_directory(notmuch_database_t *database +;; , const char *path, notmuch_directory_t **directory); +(define notmuch_database_get_directory + (let ((~notmuch_database_get_directory + (delay (fh-link-proc + ffi:int + "notmuch_database_get_directory" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database path directory) + (let ((~database + ((fht-unwrap notmuch_database_t*) database)) + (~path (unwrap~pointer path)) + (~directory (unwrap~pointer directory))) + (wrap-notmuch_status_t + ((force ~notmuch_database_get_directory) + ~database + ~path + ~directory)))))) +(export notmuch_database_get_directory) + +;; notmuch_status_t notmuch_database_index_file(notmuch_database_t *database, +;; const char *filename, notmuch_indexopts_t *indexopts, notmuch_message_t +;; **message); +(define notmuch_database_index_file + (let ((~notmuch_database_index_file + (delay (fh-link-proc + ffi:int + "notmuch_database_index_file" + (list ffi-void* ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database filename indexopts message) + (let ((~database + ((fht-unwrap notmuch_database_t*) database)) + (~filename (unwrap~pointer filename)) + (~indexopts + ((fht-unwrap notmuch_indexopts_t*) indexopts)) + (~message (unwrap~pointer message))) + (wrap-notmuch_status_t + ((force ~notmuch_database_index_file) + ~database + ~filename + ~indexopts + ~message)))))) +(export notmuch_database_index_file) + +;; notmuch_status_t notmuch_database_add_message(notmuch_database_t *database, +;; const char *filename, notmuch_message_t **message); +(define notmuch_database_add_message + (let ((~notmuch_database_add_message + (delay (fh-link-proc + ffi:int + "notmuch_database_add_message" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database filename message) + (let ((~database + ((fht-unwrap notmuch_database_t*) database)) + (~filename (unwrap~pointer filename)) + (~message (unwrap~pointer message))) + (wrap-notmuch_status_t + ((force ~notmuch_database_add_message) + ~database + ~filename + ~message)))))) +(export notmuch_database_add_message) + +;; notmuch_status_t notmuch_database_remove_message(notmuch_database_t * +;; database, const char *filename); +(define notmuch_database_remove_message + (let ((~notmuch_database_remove_message + (delay (fh-link-proc + ffi:int + "notmuch_database_remove_message" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database filename) + (let ((~database + ((fht-unwrap notmuch_database_t*) database)) + (~filename (unwrap~pointer filename))) + (wrap-notmuch_status_t + ((force ~notmuch_database_remove_message) + ~database + ~filename)))))) +(export notmuch_database_remove_message) + +;; notmuch_status_t notmuch_database_find_message(notmuch_database_t *database +;; , const char *message_id, notmuch_message_t **message); +(define notmuch_database_find_message + (let ((~notmuch_database_find_message + (delay (fh-link-proc + ffi:int + "notmuch_database_find_message" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database message_id message) + (let ((~database + ((fht-unwrap notmuch_database_t*) database)) + (~message_id (unwrap~pointer message_id)) + (~message (unwrap~pointer message))) + (wrap-notmuch_status_t + ((force ~notmuch_database_find_message) + ~database + ~message_id + ~message)))))) +(export notmuch_database_find_message) + +;; notmuch_status_t notmuch_database_find_message_by_filename( +;; notmuch_database_t *notmuch, const char *filename, notmuch_message_t ** +;; message); +(define notmuch_database_find_message_by_filename + (let ((~notmuch_database_find_message_by_filename + (delay (fh-link-proc + ffi:int + "notmuch_database_find_message_by_filename" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (notmuch filename message) + (let ((~notmuch + ((fht-unwrap notmuch_database_t*) notmuch)) + (~filename (unwrap~pointer filename)) + (~message (unwrap~pointer message))) + (wrap-notmuch_status_t + ((force ~notmuch_database_find_message_by_filename) + ~notmuch + ~filename + ~message)))))) +(export notmuch_database_find_message_by_filename) + +;; notmuch_tags_t *notmuch_database_get_all_tags(notmuch_database_t *db); +(define notmuch_database_get_all_tags + (let ((~notmuch_database_get_all_tags + (delay (fh-link-proc + ffi-void* + "notmuch_database_get_all_tags" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (db) + (let ((~db ((fht-unwrap notmuch_database_t*) db))) + ((fht-wrap notmuch_tags_t*) + ((force ~notmuch_database_get_all_tags) ~db)))))) +(export notmuch_database_get_all_tags) + +;; notmuch_query_t *notmuch_query_create(notmuch_database_t *database, const +;; char *query_string); +(define notmuch_query_create + (let ((~notmuch_query_create + (delay (fh-link-proc + ffi-void* + "notmuch_query_create" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (database query_string) + (let ((~database + ((fht-unwrap notmuch_database_t*) database)) + (~query_string (unwrap~pointer query_string))) + ((fht-wrap notmuch_query_t*) + ((force ~notmuch_query_create) + ~database + ~query_string)))))) +(export notmuch_query_create) + +;; typedef enum { +;; NOTMUCH_SORT_OLDEST_FIRST, +;; NOTMUCH_SORT_NEWEST_FIRST, +;; NOTMUCH_SORT_MESSAGE_ID, +;; NOTMUCH_SORT_UNSORTED, +;; } notmuch_sort_t; +(define notmuch_sort_t-enum-nvl + '((NOTMUCH_SORT_OLDEST_FIRST . 0) + (NOTMUCH_SORT_NEWEST_FIRST . 1) + (NOTMUCH_SORT_MESSAGE_ID . 2) + (NOTMUCH_SORT_UNSORTED . 3)) + ) +(define notmuch_sort_t-enum-vnl + (map (lambda (pair) (cons (cdr pair) (car pair))) + notmuch_sort_t-enum-nvl)) +(define-public (unwrap-notmuch_sort_t n) + (cond + ((symbol? n) + (or (assq-ref notmuch_sort_t-enum-nvl n) (error "bad arg"))) + ((integer? n) n) + (else (error "bad arg")))) +(define-public (wrap-notmuch_sort_t v) + (assq-ref notmuch_sort_t-enum-vnl v)) + +;; const char *notmuch_query_get_query_string(const notmuch_query_t *query); +(define notmuch_query_get_query_string + (let ((~notmuch_query_get_query_string + (delay (fh-link-proc + ffi-void* + "notmuch_query_get_query_string" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query) + (let ((~query ((fht-unwrap notmuch_query_t*) query))) + ((force ~notmuch_query_get_query_string) ~query))))) +(export notmuch_query_get_query_string) + +;; notmuch_database_t *notmuch_query_get_database(const notmuch_query_t *query) +;; ; +(define notmuch_query_get_database + (let ((~notmuch_query_get_database + (delay (fh-link-proc + ffi-void* + "notmuch_query_get_database" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query) + (let ((~query ((fht-unwrap notmuch_query_t*) query))) + ((fht-wrap notmuch_database_t*) + ((force ~notmuch_query_get_database) ~query)))))) +(export notmuch_query_get_database) + +;; typedef enum { +;; NOTMUCH_EXCLUDE_FLAG, +;; NOTMUCH_EXCLUDE_TRUE, +;; NOTMUCH_EXCLUDE_FALSE, +;; NOTMUCH_EXCLUDE_ALL, +;; } notmuch_exclude_t; +(define notmuch_exclude_t-enum-nvl + '((NOTMUCH_EXCLUDE_FLAG . 0) + (NOTMUCH_EXCLUDE_TRUE . 1) + (NOTMUCH_EXCLUDE_FALSE . 2) + (NOTMUCH_EXCLUDE_ALL . 3)) + ) +(define notmuch_exclude_t-enum-vnl + (map (lambda (pair) (cons (cdr pair) (car pair))) + notmuch_exclude_t-enum-nvl)) +(define-public (unwrap-notmuch_exclude_t n) + (cond + ((symbol? n) + (or (assq-ref notmuch_exclude_t-enum-nvl n) (error "bad arg"))) + ((integer? n) n) + (else (error "bad arg")))) +(define-public (wrap-notmuch_exclude_t v) + (assq-ref notmuch_exclude_t-enum-vnl v)) + +;; void notmuch_query_set_omit_excluded(notmuch_query_t *query, +;; notmuch_exclude_t omit_excluded); +(define notmuch_query_set_omit_excluded + (let ((~notmuch_query_set_omit_excluded + (delay (fh-link-proc + ffi:void + "notmuch_query_set_omit_excluded" + (list ffi-void* ffi:int) + (force ffi-notmuch-llibs))))) + (lambda (query omit_excluded) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~omit_excluded + (unwrap-notmuch_exclude_t omit_excluded))) + ((force ~notmuch_query_set_omit_excluded) + ~query + ~omit_excluded))))) +(export notmuch_query_set_omit_excluded) + +;; void notmuch_query_set_sort(notmuch_query_t *query, notmuch_sort_t sort); +(define notmuch_query_set_sort + (let ((~notmuch_query_set_sort + (delay (fh-link-proc + ffi:void + "notmuch_query_set_sort" + (list ffi-void* ffi:int) + (force ffi-notmuch-llibs))))) + (lambda (query sort) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~sort (unwrap-notmuch_sort_t sort))) + ((force ~notmuch_query_set_sort) ~query ~sort))))) +(export notmuch_query_set_sort) + +;; notmuch_sort_t notmuch_query_get_sort(const notmuch_query_t *query); +(define notmuch_query_get_sort + (let ((~notmuch_query_get_sort + (delay (fh-link-proc + ffi:int + "notmuch_query_get_sort" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query) + (let ((~query ((fht-unwrap notmuch_query_t*) query))) + (wrap-notmuch_sort_t + ((force ~notmuch_query_get_sort) ~query)))))) +(export notmuch_query_get_sort) + +;; notmuch_status_t notmuch_query_add_tag_exclude(notmuch_query_t *query, const +;; char *tag); +(define notmuch_query_add_tag_exclude + (let ((~notmuch_query_add_tag_exclude + (delay (fh-link-proc + ffi:int + "notmuch_query_add_tag_exclude" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query tag) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~tag (unwrap~pointer tag))) + (wrap-notmuch_status_t + ((force ~notmuch_query_add_tag_exclude) + ~query + ~tag)))))) +(export notmuch_query_add_tag_exclude) + +;; notmuch_status_t notmuch_query_search_threads(notmuch_query_t *query, +;; notmuch_threads_t **out); +(define notmuch_query_search_threads + (let ((~notmuch_query_search_threads + (delay (fh-link-proc + ffi:int + "notmuch_query_search_threads" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query out) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~out (unwrap~pointer out))) + (wrap-notmuch_status_t + ((force ~notmuch_query_search_threads) + ~query + ~out)))))) +(export notmuch_query_search_threads) + +;; notmuch_status_t notmuch_query_search_threads_st(notmuch_query_t *query, +;; notmuch_threads_t **out); +(define notmuch_query_search_threads_st + (let ((~notmuch_query_search_threads_st + (delay (fh-link-proc + ffi:int + "notmuch_query_search_threads_st" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query out) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~out (unwrap~pointer out))) + (wrap-notmuch_status_t + ((force ~notmuch_query_search_threads_st) + ~query + ~out)))))) +(export notmuch_query_search_threads_st) + +;; notmuch_status_t notmuch_query_search_messages(notmuch_query_t *query, +;; notmuch_messages_t **out); +(define notmuch_query_search_messages + (let ((~notmuch_query_search_messages + (delay (fh-link-proc + ffi:int + "notmuch_query_search_messages" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query out) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~out (unwrap~pointer out))) + (wrap-notmuch_status_t + ((force ~notmuch_query_search_messages) + ~query + ~out)))))) +(export notmuch_query_search_messages) + +;; notmuch_status_t notmuch_query_search_messages_st(notmuch_query_t *query, +;; notmuch_messages_t **out); +(define notmuch_query_search_messages_st + (let ((~notmuch_query_search_messages_st + (delay (fh-link-proc + ffi:int + "notmuch_query_search_messages_st" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query out) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~out (unwrap~pointer out))) + (wrap-notmuch_status_t + ((force ~notmuch_query_search_messages_st) + ~query + ~out)))))) +(export notmuch_query_search_messages_st) + +;; void notmuch_query_destroy(notmuch_query_t *query); +(define notmuch_query_destroy + (let ((~notmuch_query_destroy + (delay (fh-link-proc + ffi:void + "notmuch_query_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query) + (let ((~query ((fht-unwrap notmuch_query_t*) query))) + ((force ~notmuch_query_destroy) ~query))))) +(export notmuch_query_destroy) + +;; notmuch_bool_t notmuch_threads_valid(notmuch_threads_t *threads); +(define notmuch_threads_valid + (let ((~notmuch_threads_valid + (delay (fh-link-proc + ffi:int + "notmuch_threads_valid" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (threads) + (let ((~threads + ((fht-unwrap notmuch_threads_t*) threads))) + ((force ~notmuch_threads_valid) ~threads))))) +(export notmuch_threads_valid) + +;; notmuch_thread_t *notmuch_threads_get(notmuch_threads_t *threads); +(define notmuch_threads_get + (let ((~notmuch_threads_get + (delay (fh-link-proc + ffi-void* + "notmuch_threads_get" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (threads) + (let ((~threads + ((fht-unwrap notmuch_threads_t*) threads))) + ((fht-wrap notmuch_thread_t*) + ((force ~notmuch_threads_get) ~threads)))))) +(export notmuch_threads_get) + +;; void notmuch_threads_move_to_next(notmuch_threads_t *threads); +(define notmuch_threads_move_to_next + (let ((~notmuch_threads_move_to_next + (delay (fh-link-proc + ffi:void + "notmuch_threads_move_to_next" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (threads) + (let ((~threads + ((fht-unwrap notmuch_threads_t*) threads))) + ((force ~notmuch_threads_move_to_next) ~threads))))) +(export notmuch_threads_move_to_next) + +;; void notmuch_threads_destroy(notmuch_threads_t *threads); +(define notmuch_threads_destroy + (let ((~notmuch_threads_destroy + (delay (fh-link-proc + ffi:void + "notmuch_threads_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (threads) + (let ((~threads + ((fht-unwrap notmuch_threads_t*) threads))) + ((force ~notmuch_threads_destroy) ~threads))))) +(export notmuch_threads_destroy) + +;; notmuch_status_t notmuch_query_count_messages(notmuch_query_t *query, +;; unsigned int *count); +(define notmuch_query_count_messages + (let ((~notmuch_query_count_messages + (delay (fh-link-proc + ffi:int + "notmuch_query_count_messages" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query count) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~count (unwrap~pointer count))) + (wrap-notmuch_status_t + ((force ~notmuch_query_count_messages) + ~query + ~count)))))) +(export notmuch_query_count_messages) + +;; notmuch_status_t notmuch_query_count_messages_st(notmuch_query_t *query, +;; unsigned int *count); +(define notmuch_query_count_messages_st + (let ((~notmuch_query_count_messages_st + (delay (fh-link-proc + ffi:int + "notmuch_query_count_messages_st" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query count) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~count (unwrap~pointer count))) + (wrap-notmuch_status_t + ((force ~notmuch_query_count_messages_st) + ~query + ~count)))))) +(export notmuch_query_count_messages_st) + +;; notmuch_status_t notmuch_query_count_threads(notmuch_query_t *query, +;; unsigned *count); +(define notmuch_query_count_threads + (let ((~notmuch_query_count_threads + (delay (fh-link-proc + ffi:int + "notmuch_query_count_threads" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query count) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~count (unwrap~pointer count))) + (wrap-notmuch_status_t + ((force ~notmuch_query_count_threads) + ~query + ~count)))))) +(export notmuch_query_count_threads) + +;; notmuch_status_t notmuch_query_count_threads_st(notmuch_query_t *query, +;; unsigned *count); +(define notmuch_query_count_threads_st + (let ((~notmuch_query_count_threads_st + (delay (fh-link-proc + ffi:int + "notmuch_query_count_threads_st" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (query count) + (let ((~query ((fht-unwrap notmuch_query_t*) query)) + (~count (unwrap~pointer count))) + (wrap-notmuch_status_t + ((force ~notmuch_query_count_threads_st) + ~query + ~count)))))) +(export notmuch_query_count_threads_st) + +;; const char *notmuch_thread_get_thread_id(notmuch_thread_t *thread); +(define notmuch_thread_get_thread_id + (let ((~notmuch_thread_get_thread_id + (delay (fh-link-proc + ffi-void* + "notmuch_thread_get_thread_id" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((force ~notmuch_thread_get_thread_id) ~thread))))) +(export notmuch_thread_get_thread_id) + +;; int notmuch_thread_get_total_messages(notmuch_thread_t *thread); +(define notmuch_thread_get_total_messages + (let ((~notmuch_thread_get_total_messages + (delay (fh-link-proc + ffi:int + "notmuch_thread_get_total_messages" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((force ~notmuch_thread_get_total_messages) + ~thread))))) +(export notmuch_thread_get_total_messages) + +;; int notmuch_thread_get_total_files(notmuch_thread_t *thread); +(define notmuch_thread_get_total_files + (let ((~notmuch_thread_get_total_files + (delay (fh-link-proc + ffi:int + "notmuch_thread_get_total_files" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((force ~notmuch_thread_get_total_files) ~thread))))) +(export notmuch_thread_get_total_files) + +;; notmuch_messages_t *notmuch_thread_get_toplevel_messages(notmuch_thread_t * +;; thread); +(define notmuch_thread_get_toplevel_messages + (let ((~notmuch_thread_get_toplevel_messages + (delay (fh-link-proc + ffi-void* + "notmuch_thread_get_toplevel_messages" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((fht-wrap notmuch_messages_t*) + ((force ~notmuch_thread_get_toplevel_messages) + ~thread)))))) +(export notmuch_thread_get_toplevel_messages) + +;; notmuch_messages_t *notmuch_thread_get_messages(notmuch_thread_t *thread); +(define notmuch_thread_get_messages + (let ((~notmuch_thread_get_messages + (delay (fh-link-proc + ffi-void* + "notmuch_thread_get_messages" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((fht-wrap notmuch_messages_t*) + ((force ~notmuch_thread_get_messages) ~thread)))))) +(export notmuch_thread_get_messages) + +;; int notmuch_thread_get_matched_messages(notmuch_thread_t *thread); +(define notmuch_thread_get_matched_messages + (let ((~notmuch_thread_get_matched_messages + (delay (fh-link-proc + ffi:int + "notmuch_thread_get_matched_messages" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((force ~notmuch_thread_get_matched_messages) + ~thread))))) +(export notmuch_thread_get_matched_messages) + +;; const char *notmuch_thread_get_authors(notmuch_thread_t *thread); +(define notmuch_thread_get_authors + (let ((~notmuch_thread_get_authors + (delay (fh-link-proc + ffi-void* + "notmuch_thread_get_authors" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((force ~notmuch_thread_get_authors) ~thread))))) +(export notmuch_thread_get_authors) + +;; const char *notmuch_thread_get_subject(notmuch_thread_t *thread); +(define notmuch_thread_get_subject + (let ((~notmuch_thread_get_subject + (delay (fh-link-proc + ffi-void* + "notmuch_thread_get_subject" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((force ~notmuch_thread_get_subject) ~thread))))) +(export notmuch_thread_get_subject) + +;; time_t notmuch_thread_get_oldest_date(notmuch_thread_t *thread); +(define notmuch_thread_get_oldest_date + (let ((~notmuch_thread_get_oldest_date + (delay (fh-link-proc + ffi:long + "notmuch_thread_get_oldest_date" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((force ~notmuch_thread_get_oldest_date) ~thread))))) +(export notmuch_thread_get_oldest_date) + +;; time_t notmuch_thread_get_newest_date(notmuch_thread_t *thread); +(define notmuch_thread_get_newest_date + (let ((~notmuch_thread_get_newest_date + (delay (fh-link-proc + ffi:long + "notmuch_thread_get_newest_date" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((force ~notmuch_thread_get_newest_date) ~thread))))) +(export notmuch_thread_get_newest_date) + +;; notmuch_tags_t *notmuch_thread_get_tags(notmuch_thread_t *thread); +(define notmuch_thread_get_tags + (let ((~notmuch_thread_get_tags + (delay (fh-link-proc + ffi-void* + "notmuch_thread_get_tags" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((fht-wrap notmuch_tags_t*) + ((force ~notmuch_thread_get_tags) ~thread)))))) +(export notmuch_thread_get_tags) + +;; void notmuch_thread_destroy(notmuch_thread_t *thread); +(define notmuch_thread_destroy + (let ((~notmuch_thread_destroy + (delay (fh-link-proc + ffi:void + "notmuch_thread_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (thread) + (let ((~thread ((fht-unwrap notmuch_thread_t*) thread))) + ((force ~notmuch_thread_destroy) ~thread))))) +(export notmuch_thread_destroy) + +;; notmuch_bool_t notmuch_messages_valid(notmuch_messages_t *messages); +(define notmuch_messages_valid + (let ((~notmuch_messages_valid + (delay (fh-link-proc + ffi:int + "notmuch_messages_valid" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (messages) + (let ((~messages + ((fht-unwrap notmuch_messages_t*) messages))) + ((force ~notmuch_messages_valid) ~messages))))) +(export notmuch_messages_valid) + +;; notmuch_message_t *notmuch_messages_get(notmuch_messages_t *messages); +(define notmuch_messages_get + (let ((~notmuch_messages_get + (delay (fh-link-proc + ffi-void* + "notmuch_messages_get" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (messages) + (let ((~messages + ((fht-unwrap notmuch_messages_t*) messages))) + ((fht-wrap notmuch_message_t*) + ((force ~notmuch_messages_get) ~messages)))))) +(export notmuch_messages_get) + +;; void notmuch_messages_move_to_next(notmuch_messages_t *messages); +(define notmuch_messages_move_to_next + (let ((~notmuch_messages_move_to_next + (delay (fh-link-proc + ffi:void + "notmuch_messages_move_to_next" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (messages) + (let ((~messages + ((fht-unwrap notmuch_messages_t*) messages))) + ((force ~notmuch_messages_move_to_next) + ~messages))))) +(export notmuch_messages_move_to_next) + +;; void notmuch_messages_destroy(notmuch_messages_t *messages); +(define notmuch_messages_destroy + (let ((~notmuch_messages_destroy + (delay (fh-link-proc + ffi:void + "notmuch_messages_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (messages) + (let ((~messages + ((fht-unwrap notmuch_messages_t*) messages))) + ((force ~notmuch_messages_destroy) ~messages))))) +(export notmuch_messages_destroy) + +;; notmuch_tags_t *notmuch_messages_collect_tags(notmuch_messages_t *messages); +;; +(define notmuch_messages_collect_tags + (let ((~notmuch_messages_collect_tags + (delay (fh-link-proc + ffi-void* + "notmuch_messages_collect_tags" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (messages) + (let ((~messages + ((fht-unwrap notmuch_messages_t*) messages))) + ((fht-wrap notmuch_tags_t*) + ((force ~notmuch_messages_collect_tags) + ~messages)))))) +(export notmuch_messages_collect_tags) + +;; notmuch_database_t *notmuch_message_get_database(const notmuch_message_t * +;; message); +(define notmuch_message_get_database + (let ((~notmuch_message_get_database + (delay (fh-link-proc + ffi-void* + "notmuch_message_get_database" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + ((fht-wrap notmuch_database_t*) + ((force ~notmuch_message_get_database) ~message)))))) +(export notmuch_message_get_database) + +;; const char *notmuch_message_get_message_id(notmuch_message_t *message); +(define notmuch_message_get_message_id + (let ((~notmuch_message_get_message_id + (delay (fh-link-proc + ffi-void* + "notmuch_message_get_message_id" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + ((force ~notmuch_message_get_message_id) + ~message))))) +(export notmuch_message_get_message_id) + +;; const char *notmuch_message_get_thread_id(notmuch_message_t *message); +(define notmuch_message_get_thread_id + (let ((~notmuch_message_get_thread_id + (delay (fh-link-proc + ffi-void* + "notmuch_message_get_thread_id" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + ((force ~notmuch_message_get_thread_id) ~message))))) +(export notmuch_message_get_thread_id) + +;; notmuch_messages_t *notmuch_message_get_replies(notmuch_message_t *message); +;; +(define notmuch_message_get_replies + (let ((~notmuch_message_get_replies + (delay (fh-link-proc + ffi-void* + "notmuch_message_get_replies" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + ((fht-wrap notmuch_messages_t*) + ((force ~notmuch_message_get_replies) ~message)))))) +(export notmuch_message_get_replies) + +;; int notmuch_message_count_files(notmuch_message_t *message); +(define notmuch_message_count_files + (let ((~notmuch_message_count_files + (delay (fh-link-proc + ffi:int + "notmuch_message_count_files" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + ((force ~notmuch_message_count_files) ~message))))) +(export notmuch_message_count_files) + +;; const char *notmuch_message_get_filename(notmuch_message_t *message); +(define notmuch_message_get_filename + (let ((~notmuch_message_get_filename + (delay (fh-link-proc + ffi-void* + "notmuch_message_get_filename" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + ((force ~notmuch_message_get_filename) ~message))))) +(export notmuch_message_get_filename) + +;; notmuch_filenames_t *notmuch_message_get_filenames(notmuch_message_t * +;; message); +(define notmuch_message_get_filenames + (let ((~notmuch_message_get_filenames + (delay (fh-link-proc + ffi-void* + "notmuch_message_get_filenames" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + ((fht-wrap notmuch_filenames_t*) + ((force ~notmuch_message_get_filenames) ~message)))))) +(export notmuch_message_get_filenames) + +;; notmuch_status_t notmuch_message_reindex(notmuch_message_t *message, +;; notmuch_indexopts_t *indexopts); +(define notmuch_message_reindex + (let ((~notmuch_message_reindex + (delay (fh-link-proc + ffi:int + "notmuch_message_reindex" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message indexopts) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~indexopts + ((fht-unwrap notmuch_indexopts_t*) indexopts))) + (wrap-notmuch_status_t + ((force ~notmuch_message_reindex) + ~message + ~indexopts)))))) +(export notmuch_message_reindex) + +;; typedef enum _notmuch_message_flag { +;; NOTMUCH_MESSAGE_FLAG_MATCH, +;; NOTMUCH_MESSAGE_FLAG_EXCLUDED, +;; NOTMUCH_MESSAGE_FLAG_GHOST, +;; } notmuch_message_flag_t; +(define notmuch_message_flag_t-enum-nvl + '((NOTMUCH_MESSAGE_FLAG_MATCH . 0) + (NOTMUCH_MESSAGE_FLAG_EXCLUDED . 1) + (NOTMUCH_MESSAGE_FLAG_GHOST . 2)) + ) +(define notmuch_message_flag_t-enum-vnl + (map (lambda (pair) (cons (cdr pair) (car pair))) + notmuch_message_flag_t-enum-nvl)) +(define-public (unwrap-notmuch_message_flag_t n) + (cond + ((symbol? n) + (or (assq-ref notmuch_message_flag_t-enum-nvl n) (error "bad arg"))) + ((integer? n) n) + (else (error "bad arg")))) +(define-public (wrap-notmuch_message_flag_t v) + (assq-ref notmuch_message_flag_t-enum-vnl v)) +(define-public unwrap-enum-_notmuch_message_flag unwrap-notmuch_message_flag_t) +(define-public wrap-enum-_notmuch_message_flag wrap-notmuch_message_flag_t) + +;; enum _notmuch_message_flag { +;; NOTMUCH_MESSAGE_FLAG_MATCH, +;; NOTMUCH_MESSAGE_FLAG_EXCLUDED, +;; NOTMUCH_MESSAGE_FLAG_GHOST, +;; }; + +;; notmuch_bool_t notmuch_message_get_flag(notmuch_message_t *message, +;; notmuch_message_flag_t flag); +(define notmuch_message_get_flag + (let ((~notmuch_message_get_flag + (delay (fh-link-proc + ffi:int + "notmuch_message_get_flag" + (list ffi-void* ffi:int) + (force ffi-notmuch-llibs))))) + (lambda (message flag) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~flag (unwrap-notmuch_message_flag_t flag))) + ((force ~notmuch_message_get_flag) + ~message + ~flag))))) +(export notmuch_message_get_flag) + +;; notmuch_status_t notmuch_message_get_flag_st(notmuch_message_t *message, +;; notmuch_message_flag_t flag, notmuch_bool_t *is_set); +(define notmuch_message_get_flag_st + (let ((~notmuch_message_get_flag_st + (delay (fh-link-proc + ffi:int + "notmuch_message_get_flag_st" + (list ffi-void* ffi:int ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message flag is_set) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~flag (unwrap-notmuch_message_flag_t flag)) + (~is_set (unwrap~pointer is_set))) + (wrap-notmuch_status_t + ((force ~notmuch_message_get_flag_st) + ~message + ~flag + ~is_set)))))) +(export notmuch_message_get_flag_st) + +;; void notmuch_message_set_flag(notmuch_message_t *message, +;; notmuch_message_flag_t flag, notmuch_bool_t value); +(define notmuch_message_set_flag + (let ((~notmuch_message_set_flag + (delay (fh-link-proc + ffi:void + "notmuch_message_set_flag" + (list ffi-void* ffi:int ffi:int) + (force ffi-notmuch-llibs))))) + (lambda (message flag value) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~flag (unwrap-notmuch_message_flag_t flag)) + (~value (unwrap~fixed value))) + ((force ~notmuch_message_set_flag) + ~message + ~flag + ~value))))) +(export notmuch_message_set_flag) + +;; time_t notmuch_message_get_date(notmuch_message_t *message); +(define notmuch_message_get_date + (let ((~notmuch_message_get_date + (delay (fh-link-proc + ffi:long + "notmuch_message_get_date" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + ((force ~notmuch_message_get_date) ~message))))) +(export notmuch_message_get_date) + +;; const char *notmuch_message_get_header(notmuch_message_t *message, const +;; char *header); +(define notmuch_message_get_header + (let ((~notmuch_message_get_header + (delay (fh-link-proc + ffi-void* + "notmuch_message_get_header" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message header) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~header (unwrap~pointer header))) + ((force ~notmuch_message_get_header) + ~message + ~header))))) +(export notmuch_message_get_header) + +;; notmuch_tags_t *notmuch_message_get_tags(notmuch_message_t *message); +(define notmuch_message_get_tags + (let ((~notmuch_message_get_tags + (delay (fh-link-proc + ffi-void* + "notmuch_message_get_tags" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + ((fht-wrap notmuch_tags_t*) + ((force ~notmuch_message_get_tags) ~message)))))) +(export notmuch_message_get_tags) + +;; notmuch_status_t notmuch_message_add_tag(notmuch_message_t *message, const +;; char *tag); +(define notmuch_message_add_tag + (let ((~notmuch_message_add_tag + (delay (fh-link-proc + ffi:int + "notmuch_message_add_tag" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message tag) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~tag (unwrap~pointer tag))) + (wrap-notmuch_status_t + ((force ~notmuch_message_add_tag) ~message ~tag)))))) +(export notmuch_message_add_tag) + +;; notmuch_status_t notmuch_message_remove_tag(notmuch_message_t *message, +;; const char *tag); +(define notmuch_message_remove_tag + (let ((~notmuch_message_remove_tag + (delay (fh-link-proc + ffi:int + "notmuch_message_remove_tag" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message tag) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~tag (unwrap~pointer tag))) + (wrap-notmuch_status_t + ((force ~notmuch_message_remove_tag) + ~message + ~tag)))))) +(export notmuch_message_remove_tag) + +;; notmuch_status_t notmuch_message_remove_all_tags(notmuch_message_t *message) +;; ; +(define notmuch_message_remove_all_tags + (let ((~notmuch_message_remove_all_tags + (delay (fh-link-proc + ffi:int + "notmuch_message_remove_all_tags" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + (wrap-notmuch_status_t + ((force ~notmuch_message_remove_all_tags) + ~message)))))) +(export notmuch_message_remove_all_tags) + +;; notmuch_status_t notmuch_message_maildir_flags_to_tags(notmuch_message_t * +;; message); +(define notmuch_message_maildir_flags_to_tags + (let ((~notmuch_message_maildir_flags_to_tags + (delay (fh-link-proc + ffi:int + "notmuch_message_maildir_flags_to_tags" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + (wrap-notmuch_status_t + ((force ~notmuch_message_maildir_flags_to_tags) + ~message)))))) +(export notmuch_message_maildir_flags_to_tags) + +;; notmuch_bool_t notmuch_message_has_maildir_flag(notmuch_message_t *message, +;; char flag); +(define notmuch_message_has_maildir_flag + (let ((~notmuch_message_has_maildir_flag + (delay (fh-link-proc + ffi:int + "notmuch_message_has_maildir_flag" + (list ffi-void* ffi:int8) + (force ffi-notmuch-llibs))))) + (lambda (message flag) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~flag (unwrap~fixed flag))) + ((force ~notmuch_message_has_maildir_flag) + ~message + ~flag))))) +(export notmuch_message_has_maildir_flag) + +;; notmuch_status_t notmuch_message_has_maildir_flag_st(notmuch_message_t * +;; message, char flag, notmuch_bool_t *is_set); +(define notmuch_message_has_maildir_flag_st + (let ((~notmuch_message_has_maildir_flag_st + (delay (fh-link-proc + ffi:int + "notmuch_message_has_maildir_flag_st" + (list ffi-void* ffi:int8 ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message flag is_set) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~flag (unwrap~fixed flag)) + (~is_set (unwrap~pointer is_set))) + (wrap-notmuch_status_t + ((force ~notmuch_message_has_maildir_flag_st) + ~message + ~flag + ~is_set)))))) +(export notmuch_message_has_maildir_flag_st) + +;; notmuch_status_t notmuch_message_tags_to_maildir_flags(notmuch_message_t * +;; message); +(define notmuch_message_tags_to_maildir_flags + (let ((~notmuch_message_tags_to_maildir_flags + (delay (fh-link-proc + ffi:int + "notmuch_message_tags_to_maildir_flags" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + (wrap-notmuch_status_t + ((force ~notmuch_message_tags_to_maildir_flags) + ~message)))))) +(export notmuch_message_tags_to_maildir_flags) + +;; notmuch_status_t notmuch_message_freeze(notmuch_message_t *message); +(define notmuch_message_freeze + (let ((~notmuch_message_freeze + (delay (fh-link-proc + ffi:int + "notmuch_message_freeze" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + (wrap-notmuch_status_t + ((force ~notmuch_message_freeze) ~message)))))) +(export notmuch_message_freeze) + +;; notmuch_status_t notmuch_message_thaw(notmuch_message_t *message); +(define notmuch_message_thaw + (let ((~notmuch_message_thaw + (delay (fh-link-proc + ffi:int + "notmuch_message_thaw" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + (wrap-notmuch_status_t + ((force ~notmuch_message_thaw) ~message)))))) +(export notmuch_message_thaw) + +;; void notmuch_message_destroy(notmuch_message_t *message); +(define notmuch_message_destroy + (let ((~notmuch_message_destroy + (delay (fh-link-proc + ffi:void + "notmuch_message_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message) + (let ((~message + ((fht-unwrap notmuch_message_t*) message))) + ((force ~notmuch_message_destroy) ~message))))) +(export notmuch_message_destroy) + +;; notmuch_status_t notmuch_message_get_property(notmuch_message_t *message, +;; const char *key, const char **value); +(define notmuch_message_get_property + (let ((~notmuch_message_get_property + (delay (fh-link-proc + ffi:int + "notmuch_message_get_property" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message key value) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~key (unwrap~pointer key)) + (~value (unwrap~pointer value))) + (wrap-notmuch_status_t + ((force ~notmuch_message_get_property) + ~message + ~key + ~value)))))) +(export notmuch_message_get_property) + +;; notmuch_status_t notmuch_message_add_property(notmuch_message_t *message, +;; const char *key, const char *value); +(define notmuch_message_add_property + (let ((~notmuch_message_add_property + (delay (fh-link-proc + ffi:int + "notmuch_message_add_property" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message key value) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~key (unwrap~pointer key)) + (~value (unwrap~pointer value))) + (wrap-notmuch_status_t + ((force ~notmuch_message_add_property) + ~message + ~key + ~value)))))) +(export notmuch_message_add_property) + +;; notmuch_status_t notmuch_message_remove_property(notmuch_message_t *message +;; , const char *key, const char *value); +(define notmuch_message_remove_property + (let ((~notmuch_message_remove_property + (delay (fh-link-proc + ffi:int + "notmuch_message_remove_property" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message key value) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~key (unwrap~pointer key)) + (~value (unwrap~pointer value))) + (wrap-notmuch_status_t + ((force ~notmuch_message_remove_property) + ~message + ~key + ~value)))))) +(export notmuch_message_remove_property) + +;; notmuch_status_t notmuch_message_remove_all_properties(notmuch_message_t * +;; message, const char *key); +(define notmuch_message_remove_all_properties + (let ((~notmuch_message_remove_all_properties + (delay (fh-link-proc + ffi:int + "notmuch_message_remove_all_properties" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message key) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~key (unwrap~pointer key))) + (wrap-notmuch_status_t + ((force ~notmuch_message_remove_all_properties) + ~message + ~key)))))) +(export notmuch_message_remove_all_properties) + +;; notmuch_status_t notmuch_message_remove_all_properties_with_prefix( +;; notmuch_message_t *message, const char *prefix); +(define notmuch_message_remove_all_properties_with_prefix + (let ((~notmuch_message_remove_all_properties_with_prefix + (delay (fh-link-proc + ffi:int + "notmuch_message_remove_all_properties_with_prefix" + (list ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message prefix) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~prefix (unwrap~pointer prefix))) + (wrap-notmuch_status_t + ((force ~notmuch_message_remove_all_properties_with_prefix) + ~message + ~prefix)))))) +(export notmuch_message_remove_all_properties_with_prefix) + +;; typedef struct _notmuch_string_map_iterator notmuch_message_properties_t; +(define-public notmuch_message_properties_t-desc 'void) +(define-fh-type-alias notmuch_message_properties_t fh-void) +(define-public notmuch_message_properties_t? fh-void?) +(define-public make-notmuch_message_properties_t make-fh-void) +(define-public notmuch_message_properties_t*-desc (fh:pointer notmuch_message_properties_t-desc)) +(define-fh-pointer-type notmuch_message_properties_t* + notmuch_message_properties_t*-desc notmuch_message_properties_t*? + make-notmuch_message_properties_t*) +(export notmuch_message_properties_t* notmuch_message_properties_t*? + make-notmuch_message_properties_t*) + +;; notmuch_message_properties_t *notmuch_message_get_properties( +;; notmuch_message_t *message, const char *key, notmuch_bool_t exact); +(define notmuch_message_get_properties + (let ((~notmuch_message_get_properties + (delay (fh-link-proc + ffi-void* + "notmuch_message_get_properties" + (list ffi-void* ffi-void* ffi:int) + (force ffi-notmuch-llibs))))) + (lambda (message key exact) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~key (unwrap~pointer key)) + (~exact (unwrap~fixed exact))) + ((fht-wrap notmuch_message_properties_t*) + ((force ~notmuch_message_get_properties) + ~message + ~key + ~exact)))))) +(export notmuch_message_get_properties) + +;; notmuch_status_t notmuch_message_count_properties(notmuch_message_t *message +;; , const char *key, unsigned int *count); +(define notmuch_message_count_properties + (let ((~notmuch_message_count_properties + (delay (fh-link-proc + ffi:int + "notmuch_message_count_properties" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (message key count) + (let ((~message + ((fht-unwrap notmuch_message_t*) message)) + (~key (unwrap~pointer key)) + (~count (unwrap~pointer count))) + (wrap-notmuch_status_t + ((force ~notmuch_message_count_properties) + ~message + ~key + ~count)))))) +(export notmuch_message_count_properties) + +;; notmuch_bool_t notmuch_message_properties_valid(notmuch_message_properties_t +;; *properties); +(define notmuch_message_properties_valid + (let ((~notmuch_message_properties_valid + (delay (fh-link-proc + ffi:int + "notmuch_message_properties_valid" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (properties) + (let ((~properties + ((fht-unwrap notmuch_message_properties_t*) + properties))) + ((force ~notmuch_message_properties_valid) + ~properties))))) +(export notmuch_message_properties_valid) + +;; void notmuch_message_properties_move_to_next(notmuch_message_properties_t * +;; properties); +(define notmuch_message_properties_move_to_next + (let ((~notmuch_message_properties_move_to_next + (delay (fh-link-proc + ffi:void + "notmuch_message_properties_move_to_next" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (properties) + (let ((~properties + ((fht-unwrap notmuch_message_properties_t*) + properties))) + ((force ~notmuch_message_properties_move_to_next) + ~properties))))) +(export notmuch_message_properties_move_to_next) + +;; const char *notmuch_message_properties_key(notmuch_message_properties_t * +;; properties); +(define notmuch_message_properties_key + (let ((~notmuch_message_properties_key + (delay (fh-link-proc + ffi-void* + "notmuch_message_properties_key" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (properties) + (let ((~properties + ((fht-unwrap notmuch_message_properties_t*) + properties))) + ((force ~notmuch_message_properties_key) + ~properties))))) +(export notmuch_message_properties_key) + +;; const char *notmuch_message_properties_value(notmuch_message_properties_t * +;; properties); +(define notmuch_message_properties_value + (let ((~notmuch_message_properties_value + (delay (fh-link-proc + ffi-void* + "notmuch_message_properties_value" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (properties) + (let ((~properties + ((fht-unwrap notmuch_message_properties_t*) + properties))) + ((force ~notmuch_message_properties_value) + ~properties))))) +(export notmuch_message_properties_value) + +;; void notmuch_message_properties_destroy(notmuch_message_properties_t * +;; properties); +(define notmuch_message_properties_destroy + (let ((~notmuch_message_properties_destroy + (delay (fh-link-proc + ffi:void + "notmuch_message_properties_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (properties) + (let ((~properties + ((fht-unwrap notmuch_message_properties_t*) + properties))) + ((force ~notmuch_message_properties_destroy) + ~properties))))) +(export notmuch_message_properties_destroy) + +;; notmuch_bool_t notmuch_tags_valid(notmuch_tags_t *tags); +(define notmuch_tags_valid + (let ((~notmuch_tags_valid + (delay (fh-link-proc + ffi:int + "notmuch_tags_valid" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (tags) + (let ((~tags ((fht-unwrap notmuch_tags_t*) tags))) + ((force ~notmuch_tags_valid) ~tags))))) +(export notmuch_tags_valid) + +;; const char *notmuch_tags_get(notmuch_tags_t *tags); +(define notmuch_tags_get + (let ((~notmuch_tags_get + (delay (fh-link-proc + ffi-void* + "notmuch_tags_get" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (tags) + (let ((~tags ((fht-unwrap notmuch_tags_t*) tags))) + ((force ~notmuch_tags_get) ~tags))))) +(export notmuch_tags_get) + +;; void notmuch_tags_move_to_next(notmuch_tags_t *tags); +(define notmuch_tags_move_to_next + (let ((~notmuch_tags_move_to_next + (delay (fh-link-proc + ffi:void + "notmuch_tags_move_to_next" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (tags) + (let ((~tags ((fht-unwrap notmuch_tags_t*) tags))) + ((force ~notmuch_tags_move_to_next) ~tags))))) +(export notmuch_tags_move_to_next) + +;; void notmuch_tags_destroy(notmuch_tags_t *tags); +(define notmuch_tags_destroy + (let ((~notmuch_tags_destroy + (delay (fh-link-proc + ffi:void + "notmuch_tags_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (tags) + (let ((~tags ((fht-unwrap notmuch_tags_t*) tags))) + ((force ~notmuch_tags_destroy) ~tags))))) +(export notmuch_tags_destroy) + +;; notmuch_status_t notmuch_directory_set_mtime(notmuch_directory_t *directory +;; , time_t mtime); +(define notmuch_directory_set_mtime + (let ((~notmuch_directory_set_mtime + (delay (fh-link-proc + ffi:int + "notmuch_directory_set_mtime" + (list ffi-void* ffi:long) + (force ffi-notmuch-llibs))))) + (lambda (directory mtime) + (let ((~directory + ((fht-unwrap notmuch_directory_t*) directory)) + (~mtime (unwrap~fixed mtime))) + (wrap-notmuch_status_t + ((force ~notmuch_directory_set_mtime) + ~directory + ~mtime)))))) +(export notmuch_directory_set_mtime) + +;; time_t notmuch_directory_get_mtime(notmuch_directory_t *directory); +(define notmuch_directory_get_mtime + (let ((~notmuch_directory_get_mtime + (delay (fh-link-proc + ffi:long + "notmuch_directory_get_mtime" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (directory) + (let ((~directory + ((fht-unwrap notmuch_directory_t*) directory))) + ((force ~notmuch_directory_get_mtime) ~directory))))) +(export notmuch_directory_get_mtime) + +;; notmuch_filenames_t *notmuch_directory_get_child_files(notmuch_directory_t * +;; directory); +(define notmuch_directory_get_child_files + (let ((~notmuch_directory_get_child_files + (delay (fh-link-proc + ffi-void* + "notmuch_directory_get_child_files" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (directory) + (let ((~directory + ((fht-unwrap notmuch_directory_t*) directory))) + ((fht-wrap notmuch_filenames_t*) + ((force ~notmuch_directory_get_child_files) + ~directory)))))) +(export notmuch_directory_get_child_files) + +;; notmuch_filenames_t *notmuch_directory_get_child_directories( +;; notmuch_directory_t *directory); +(define notmuch_directory_get_child_directories + (let ((~notmuch_directory_get_child_directories + (delay (fh-link-proc + ffi-void* + "notmuch_directory_get_child_directories" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (directory) + (let ((~directory + ((fht-unwrap notmuch_directory_t*) directory))) + ((fht-wrap notmuch_filenames_t*) + ((force ~notmuch_directory_get_child_directories) + ~directory)))))) +(export notmuch_directory_get_child_directories) + +;; notmuch_status_t notmuch_directory_delete(notmuch_directory_t *directory); +(define notmuch_directory_delete + (let ((~notmuch_directory_delete + (delay (fh-link-proc + ffi:int + "notmuch_directory_delete" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (directory) + (let ((~directory + ((fht-unwrap notmuch_directory_t*) directory))) + (wrap-notmuch_status_t + ((force ~notmuch_directory_delete) ~directory)))))) +(export notmuch_directory_delete) + +;; void notmuch_directory_destroy(notmuch_directory_t *directory); +(define notmuch_directory_destroy + (let ((~notmuch_directory_destroy + (delay (fh-link-proc + ffi:void + "notmuch_directory_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (directory) + (let ((~directory + ((fht-unwrap notmuch_directory_t*) directory))) + ((force ~notmuch_directory_destroy) ~directory))))) +(export notmuch_directory_destroy) + +;; notmuch_bool_t notmuch_filenames_valid(notmuch_filenames_t *filenames); +(define notmuch_filenames_valid + (let ((~notmuch_filenames_valid + (delay (fh-link-proc + ffi:int + "notmuch_filenames_valid" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (filenames) + (let ((~filenames + ((fht-unwrap notmuch_filenames_t*) filenames))) + ((force ~notmuch_filenames_valid) ~filenames))))) +(export notmuch_filenames_valid) + +;; const char *notmuch_filenames_get(notmuch_filenames_t *filenames); +(define notmuch_filenames_get + (let ((~notmuch_filenames_get + (delay (fh-link-proc + ffi-void* + "notmuch_filenames_get" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (filenames) + (let ((~filenames + ((fht-unwrap notmuch_filenames_t*) filenames))) + ((force ~notmuch_filenames_get) ~filenames))))) +(export notmuch_filenames_get) + +;; void notmuch_filenames_move_to_next(notmuch_filenames_t *filenames); +(define notmuch_filenames_move_to_next + (let ((~notmuch_filenames_move_to_next + (delay (fh-link-proc + ffi:void + "notmuch_filenames_move_to_next" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (filenames) + (let ((~filenames + ((fht-unwrap notmuch_filenames_t*) filenames))) + ((force ~notmuch_filenames_move_to_next) + ~filenames))))) +(export notmuch_filenames_move_to_next) + +;; void notmuch_filenames_destroy(notmuch_filenames_t *filenames); +(define notmuch_filenames_destroy + (let ((~notmuch_filenames_destroy + (delay (fh-link-proc + ffi:void + "notmuch_filenames_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (filenames) + (let ((~filenames + ((fht-unwrap notmuch_filenames_t*) filenames))) + ((force ~notmuch_filenames_destroy) ~filenames))))) +(export notmuch_filenames_destroy) + +;; notmuch_status_t notmuch_database_set_config(notmuch_database_t *db, const +;; char *key, const char *value); +(define notmuch_database_set_config + (let ((~notmuch_database_set_config + (delay (fh-link-proc + ffi:int + "notmuch_database_set_config" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (db key value) + (let ((~db ((fht-unwrap notmuch_database_t*) db)) + (~key (unwrap~pointer key)) + (~value (unwrap~pointer value))) + (wrap-notmuch_status_t + ((force ~notmuch_database_set_config) + ~db + ~key + ~value)))))) +(export notmuch_database_set_config) + +;; notmuch_status_t notmuch_database_get_config(notmuch_database_t *db, const +;; char *key, char **value); +(define notmuch_database_get_config + (let ((~notmuch_database_get_config + (delay (fh-link-proc + ffi:int + "notmuch_database_get_config" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (db key value) + (let ((~db ((fht-unwrap notmuch_database_t*) db)) + (~key (unwrap~pointer key)) + (~value (unwrap~pointer value))) + (wrap-notmuch_status_t + ((force ~notmuch_database_get_config) + ~db + ~key + ~value)))))) +(export notmuch_database_get_config) + +;; notmuch_status_t notmuch_database_get_config_list(notmuch_database_t *db, +;; const char *prefix, notmuch_config_list_t **out); +(define notmuch_database_get_config_list + (let ((~notmuch_database_get_config_list + (delay (fh-link-proc + ffi:int + "notmuch_database_get_config_list" + (list ffi-void* ffi-void* ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (db prefix out) + (let ((~db ((fht-unwrap notmuch_database_t*) db)) + (~prefix (unwrap~pointer prefix)) + (~out (unwrap~pointer out))) + (wrap-notmuch_status_t + ((force ~notmuch_database_get_config_list) + ~db + ~prefix + ~out)))))) +(export notmuch_database_get_config_list) + +;; notmuch_bool_t notmuch_config_list_valid(notmuch_config_list_t *config_list) +;; ; +(define notmuch_config_list_valid + (let ((~notmuch_config_list_valid + (delay (fh-link-proc + ffi:int + "notmuch_config_list_valid" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (config_list) + (let ((~config_list + ((fht-unwrap notmuch_config_list_t*) config_list))) + ((force ~notmuch_config_list_valid) ~config_list))))) +(export notmuch_config_list_valid) + +;; const char *notmuch_config_list_key(notmuch_config_list_t *config_list); +(define notmuch_config_list_key + (let ((~notmuch_config_list_key + (delay (fh-link-proc + ffi-void* + "notmuch_config_list_key" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (config_list) + (let ((~config_list + ((fht-unwrap notmuch_config_list_t*) config_list))) + ((force ~notmuch_config_list_key) ~config_list))))) +(export notmuch_config_list_key) + +;; const char *notmuch_config_list_value(notmuch_config_list_t *config_list); +(define notmuch_config_list_value + (let ((~notmuch_config_list_value + (delay (fh-link-proc + ffi-void* + "notmuch_config_list_value" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (config_list) + (let ((~config_list + ((fht-unwrap notmuch_config_list_t*) config_list))) + ((force ~notmuch_config_list_value) ~config_list))))) +(export notmuch_config_list_value) + +;; void notmuch_config_list_move_to_next(notmuch_config_list_t *config_list); +(define notmuch_config_list_move_to_next + (let ((~notmuch_config_list_move_to_next + (delay (fh-link-proc + ffi:void + "notmuch_config_list_move_to_next" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (config_list) + (let ((~config_list + ((fht-unwrap notmuch_config_list_t*) config_list))) + ((force ~notmuch_config_list_move_to_next) + ~config_list))))) +(export notmuch_config_list_move_to_next) + +;; void notmuch_config_list_destroy(notmuch_config_list_t *config_list); +(define notmuch_config_list_destroy + (let ((~notmuch_config_list_destroy + (delay (fh-link-proc + ffi:void + "notmuch_config_list_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (config_list) + (let ((~config_list + ((fht-unwrap notmuch_config_list_t*) config_list))) + ((force ~notmuch_config_list_destroy) + ~config_list))))) +(export notmuch_config_list_destroy) + +;; notmuch_indexopts_t *notmuch_database_get_default_indexopts( +;; notmuch_database_t *db); +(define notmuch_database_get_default_indexopts + (let ((~notmuch_database_get_default_indexopts + (delay (fh-link-proc + ffi-void* + "notmuch_database_get_default_indexopts" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (db) + (let ((~db ((fht-unwrap notmuch_database_t*) db))) + ((fht-wrap notmuch_indexopts_t*) + ((force ~notmuch_database_get_default_indexopts) + ~db)))))) +(export notmuch_database_get_default_indexopts) + +;; typedef enum { +;; NOTMUCH_DECRYPT_FALSE, +;; NOTMUCH_DECRYPT_TRUE, +;; NOTMUCH_DECRYPT_AUTO, +;; NOTMUCH_DECRYPT_NOSTASH, +;; } notmuch_decryption_policy_t; +(define notmuch_decryption_policy_t-enum-nvl + '((NOTMUCH_DECRYPT_FALSE . 0) + (NOTMUCH_DECRYPT_TRUE . 1) + (NOTMUCH_DECRYPT_AUTO . 2) + (NOTMUCH_DECRYPT_NOSTASH . 3)) + ) +(define notmuch_decryption_policy_t-enum-vnl + (map (lambda (pair) (cons (cdr pair) (car pair))) + notmuch_decryption_policy_t-enum-nvl)) +(define-public (unwrap-notmuch_decryption_policy_t n) + (cond + ((symbol? n) + (or (assq-ref notmuch_decryption_policy_t-enum-nvl n) (error "bad arg"))) + ((integer? n) n) + (else (error "bad arg")))) +(define-public (wrap-notmuch_decryption_policy_t v) + (assq-ref notmuch_decryption_policy_t-enum-vnl v)) + +;; notmuch_status_t notmuch_indexopts_set_decrypt_policy(notmuch_indexopts_t * +;; indexopts, notmuch_decryption_policy_t decrypt_policy); +(define notmuch_indexopts_set_decrypt_policy + (let ((~notmuch_indexopts_set_decrypt_policy + (delay (fh-link-proc + ffi:int + "notmuch_indexopts_set_decrypt_policy" + (list ffi-void* ffi:int) + (force ffi-notmuch-llibs))))) + (lambda (indexopts decrypt_policy) + (let ((~indexopts + ((fht-unwrap notmuch_indexopts_t*) indexopts)) + (~decrypt_policy + (unwrap-notmuch_decryption_policy_t + decrypt_policy))) + (wrap-notmuch_status_t + ((force ~notmuch_indexopts_set_decrypt_policy) + ~indexopts + ~decrypt_policy)))))) +(export notmuch_indexopts_set_decrypt_policy) + +;; notmuch_decryption_policy_t notmuch_indexopts_get_decrypt_policy(const +;; notmuch_indexopts_t *indexopts); +(define notmuch_indexopts_get_decrypt_policy + (let ((~notmuch_indexopts_get_decrypt_policy + (delay (fh-link-proc + ffi:int + "notmuch_indexopts_get_decrypt_policy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (indexopts) + (let ((~indexopts + ((fht-unwrap notmuch_indexopts_t*) indexopts))) + (wrap-notmuch_decryption_policy_t + ((force ~notmuch_indexopts_get_decrypt_policy) + ~indexopts)))))) +(export notmuch_indexopts_get_decrypt_policy) + +;; void notmuch_indexopts_destroy(notmuch_indexopts_t *options); +(define notmuch_indexopts_destroy + (let ((~notmuch_indexopts_destroy + (delay (fh-link-proc + ffi:void + "notmuch_indexopts_destroy" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (options) + (let ((~options + ((fht-unwrap notmuch_indexopts_t*) options))) + ((force ~notmuch_indexopts_destroy) ~options))))) +(export notmuch_indexopts_destroy) + +;; notmuch_bool_t notmuch_built_with(const char *name); +(define notmuch_built_with + (let ((~notmuch_built_with + (delay (fh-link-proc + ffi:int + "notmuch_built_with" + (list ffi-void*) + (force ffi-notmuch-llibs))))) + (lambda (name) + (let ((~name (unwrap~pointer name))) + ((force ~notmuch_built_with) ~name))))) +(export notmuch_built_with) + +;; access to enum symbols and #define'd constants: +(define ffi-notmuch-symbol-tab + '((NOTMUCH_DECRYPT_NOSTASH . 3) + (NOTMUCH_DECRYPT_AUTO . 2) + (NOTMUCH_DECRYPT_TRUE . 1) + (NOTMUCH_DECRYPT_FALSE . 0) + (NOTMUCH_DECRYPT_NOSTASH . 3) + (NOTMUCH_DECRYPT_AUTO . 2) + (NOTMUCH_DECRYPT_TRUE . 1) + (NOTMUCH_DECRYPT_FALSE . 0) + (NOTMUCH_MESSAGE_FLAG_GHOST . 2) + (NOTMUCH_MESSAGE_FLAG_EXCLUDED . 1) + (NOTMUCH_MESSAGE_FLAG_MATCH . 0) + (NOTMUCH_MESSAGE_FLAG_GHOST . 2) + (NOTMUCH_MESSAGE_FLAG_EXCLUDED . 1) + (NOTMUCH_MESSAGE_FLAG_MATCH . 0) + (NOTMUCH_EXCLUDE_ALL . 3) + (NOTMUCH_EXCLUDE_FALSE . 2) + (NOTMUCH_EXCLUDE_TRUE . 1) + (NOTMUCH_EXCLUDE_FLAG . 0) + (NOTMUCH_EXCLUDE_ALL . 3) + (NOTMUCH_EXCLUDE_FALSE . 2) + (NOTMUCH_EXCLUDE_TRUE . 1) + (NOTMUCH_EXCLUDE_FLAG . 0) + (NOTMUCH_SORT_UNSORTED . 3) + (NOTMUCH_SORT_MESSAGE_ID . 2) + (NOTMUCH_SORT_NEWEST_FIRST . 1) + (NOTMUCH_SORT_OLDEST_FIRST . 0) + (NOTMUCH_SORT_UNSORTED . 3) + (NOTMUCH_SORT_MESSAGE_ID . 2) + (NOTMUCH_SORT_NEWEST_FIRST . 1) + (NOTMUCH_SORT_OLDEST_FIRST . 0) + (NOTMUCH_DATABASE_MODE_READ_WRITE . 1) + (NOTMUCH_DATABASE_MODE_READ_ONLY . 0) + (NOTMUCH_DATABASE_MODE_READ_WRITE . 1) + (NOTMUCH_DATABASE_MODE_READ_ONLY . 0) + (NOTMUCH_STATUS_LAST_STATUS . 19) + (NOTMUCH_STATUS_UNKNOWN_CRYPTO_PROTOCOL . 18) + (NOTMUCH_STATUS_FAILED_CRYPTO_CONTEXT_CREATION + . + 17) + (NOTMUCH_STATUS_MALFORMED_CRYPTO_PROTOCOL . 16) + (NOTMUCH_STATUS_ILLEGAL_ARGUMENT . 15) + (NOTMUCH_STATUS_IGNORED . 14) + (NOTMUCH_STATUS_PATH_ERROR . 13) + (NOTMUCH_STATUS_UPGRADE_REQUIRED . 12) + (NOTMUCH_STATUS_UNSUPPORTED_OPERATION . 11) + (NOTMUCH_STATUS_UNBALANCED_ATOMIC . 10) + (NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW . 9) + (NOTMUCH_STATUS_TAG_TOO_LONG . 8) + (NOTMUCH_STATUS_NULL_POINTER . 7) + (NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID . 6) + (NOTMUCH_STATUS_FILE_NOT_EMAIL . 5) + (NOTMUCH_STATUS_FILE_ERROR . 4) + (NOTMUCH_STATUS_XAPIAN_EXCEPTION . 3) + (NOTMUCH_STATUS_READ_ONLY_DATABASE . 2) + (NOTMUCH_STATUS_OUT_OF_MEMORY . 1) + (NOTMUCH_STATUS_SUCCESS . 0) + (NOTMUCH_STATUS_LAST_STATUS . 19) + (NOTMUCH_STATUS_UNKNOWN_CRYPTO_PROTOCOL . 18) + (NOTMUCH_STATUS_FAILED_CRYPTO_CONTEXT_CREATION + . + 17) + (NOTMUCH_STATUS_MALFORMED_CRYPTO_PROTOCOL . 16) + (NOTMUCH_STATUS_ILLEGAL_ARGUMENT . 15) + (NOTMUCH_STATUS_IGNORED . 14) + (NOTMUCH_STATUS_PATH_ERROR . 13) + (NOTMUCH_STATUS_UPGRADE_REQUIRED . 12) + (NOTMUCH_STATUS_UNSUPPORTED_OPERATION . 11) + (NOTMUCH_STATUS_UNBALANCED_ATOMIC . 10) + (NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW . 9) + (NOTMUCH_STATUS_TAG_TOO_LONG . 8) + (NOTMUCH_STATUS_NULL_POINTER . 7) + (NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID . 6) + (NOTMUCH_STATUS_FILE_NOT_EMAIL . 5) + (NOTMUCH_STATUS_FILE_ERROR . 4) + (NOTMUCH_STATUS_XAPIAN_EXCEPTION . 3) + (NOTMUCH_STATUS_READ_ONLY_DATABASE . 2) + (NOTMUCH_STATUS_OUT_OF_MEMORY . 1) + (NOTMUCH_STATUS_SUCCESS . 0) + (NOTMUCH_TAG_MAX . 200) + (LIBNOTMUCH_MICRO_VERSION . 0) + (LIBNOTMUCH_MINOR_VERSION . 3) + (LIBNOTMUCH_MAJOR_VERSION . 5) + (TRUE . 1) + (FALSE . 0))) + +(define ffi-notmuch-symbol-val + (lambda (k) + (or (assq-ref ffi-notmuch-symbol-tab k)))) +(export ffi-notmuch-symbol-val) + +(define (unwrap-enum obj) + (cond ((number? obj) obj) + ((symbol? obj) (ffi-notmuch-symbol-val obj)) + ((fh-object? obj) (struct-ref obj 0)) + (else (error "type mismatch")))) + +(define ffi-notmuch-types + '((pointer . "notmuch_database_t") "notmuch_database_t" (pointer . + "notmuch_query_t") "notmuch_query_t" (pointer . "notmuch_threads_t") + "notmuch_threads_t" (pointer . "notmuch_thread_t") "notmuch_thread_t" + (pointer . "notmuch_messages_t") "notmuch_messages_t" (pointer . + "notmuch_message_t") "notmuch_message_t" (pointer . "notmuch_tags_t") + "notmuch_tags_t" (pointer . "notmuch_directory_t") "notmuch_directory_t" + (pointer . "notmuch_filenames_t") "notmuch_filenames_t" (pointer . + "notmuch_config_list_t") "notmuch_config_list_t" (pointer . + "notmuch_indexopts_t") "notmuch_indexopts_t" "notmuch_compact_status_cb_t" + (pointer . "notmuch_message_properties_t") "notmuch_message_properties_t")) +(export ffi-notmuch-types) + +;; --- last line --- diff --git a/lib/guile/mail-tools.scm b/lib/guile/mail-tools.scm new file mode 100644 index 0000000..d496c5b --- /dev/null +++ b/lib/guile/mail-tools.scm @@ -0,0 +1,126 @@ +(define-module (mail-tools) + #:use-module (ffi notmuch) + #:use-module (ice-9 rdelim) + #:use-module (ice-9 regex) + #:use-module (srfi srfi-1) + #:use-module (system ffi-help-rt) + #:use-module (system foreign) + #:export (rename-higher + get-uidvalidity + get-folder-uidvalidity + new-path + with-new + nm-open-database + nm-query-db + nm-result-messages + nm-header + nm-count-messages + nm-apply-tags + nm-iter + with-nm-database + with-nm-query)) + +(define (rename-higher name limit) + (let ((mat (string-match ",U=[0-9]+" name))) + (if (and mat (< limit (string->number (substring (match:substring mat) 3)))) + (string-append (match:prefix mat) (match:suffix mat)) + name))) + +(define (get-uidvalidity port) + (read-line port) + (string->number (read-line port))) + +(define (get-folder-uidvalidity folder) + (call-with-input-file (string-append folder "/.uidvalidity") get-uidvalidity)) + +(define (new-path path destination) + (let ((filename (basename path)) + (submaildir (basename (dirname path)))) + (string-join (list destination submaildir filename) + file-name-separator-string))) + +(define (with-new rule new) + (list + (if new (string-append (car rule) " -new") (car rule)) + (if new + (if (string=? (cadr rule) "*") + "tag:new" + (simple-format #f "(~a) and ~a" (cadr rule) "tag:new")) + (cadr rule)))) + +;; NOTMUCH interface +(define (nm-open-database path mode) + (let ((ffi-db (make-notmuch_database_t*))) + (notmuch_database_open (string->pointer path) mode (pointer-to ffi-db)) + ffi-db)) + +(define (nm-query-db db str) + (let ((query (notmuch_query_create db (string->pointer str)))) + (for-each (lambda (tag) + (notmuch_query_add_tag_exclude query (string->pointer tag))) + (list "deleted" "spam")) + query)) + +(define (nm-result-messages query) + (let ((messages (make-notmuch_messages_t*))) + (notmuch_query_search_messages query (pointer-to messages)) + messages)) + +(define (nm-header message label) + (pointer->string (notmuch_message_get_header message (string->pointer label)))) + +(define (nm-count-messages query) + (let ((counter (make-int32))) + (notmuch_query_count_messages query (pointer-to counter)) + (fh-object-ref counter))) + +(eval-when (expand load eval) + (define (stx->str stx) (symbol->string (syntax->datum stx))) + (define (singular stx) (string-drop-right (stx->str stx) 1)) + (define (nm-symbols tmpl-id . args) + (datum->syntax + tmpl-id + (string->symbol + (apply string-append + (map (lambda (ss) (if (string? ss) ss (stx->str ss))) args)))))) + +(define-syntax nm-iter + (lambda (x) + (syntax-case x () + ((_ type query proc) + (with-syntax ((valid? (nm-symbols #'type "notmuch_" #'type "_valid")) + (destroy (nm-symbols #'type "notmuch_" #'type "_destroy")) + (get (nm-symbols #'type "notmuch_" #'type "_get")) + (next (nm-symbols #'type "notmuch_" #'type "_move_to_next")) + (item-destroy (nm-symbols #'type "notmuch_" (singular #'type) "_destroy"))) + #'(let ((obj query)) + (let loop ((item (get obj)) + (acc '())) + (if (= 0 (valid? obj)) + (begin + (destroy obj) + acc) + (let ((result (proc item))) + (when (defined? (quote item-destroy)) + (item-destroy item)) + (next obj) + (loop (get obj) (cons result acc))))))))))) + +(define (nm-apply-tags message tags) + (let loop ((rest (string-tokenize tags))) + (unless (null-list? rest) + (let ((tag (string->pointer (substring (car rest) 1)))) + (if (string-prefix? "-" (car rest)) + (notmuch_message_remove_tag message tag) + (notmuch_message_add_tag message tag))) + (loop (cdr rest))))) + +(define-syntax-rule (with-nm-database (db path mode) body body* ...) + (let ((db (nm-open-database path mode))) + body body* ... + (notmuch_database_destroy db))) + +(define-syntax-rule (with-nm-query (db qobj query) body body* ...) + (let ((qobj (nm-query-db db query))) + body body* ... + (notmuch_query_destroy qobj))) diff --git a/lib/guile/read-habit.scm b/lib/guile/read-habit.scm new file mode 100755 index 0000000..7ba7002 --- /dev/null +++ b/lib/guile/read-habit.scm @@ -0,0 +1,68 @@ +#!/usr/bin/guile \ +--listen -s +!# + +(add-to-load-path "/home/titan/dev/helpful_scripts/guile/") + +(use-modules (ice-9 rdelim) + (ice-9 popen) + (ice-9 ftw) + (ice-9 format) + (term ansi-color) + (web request) + (json) + (web response) + (web server) + (web uri) + (utils)) + +(define habits-dir (expand-file "~/org/habits/")) + +(define (parse-file port) + (let loop ((values '()) + (line (read-line port))) + (if (eof-object? line) + (reverse values) + (loop (cons (map string->number (string-split line #\:)) values) + (read-line port))))) + +(define (cli-print file-name) + (map (lambda (row) + (format #t "~a -> ~d~%" + (colorize-string (strftime "%c" (localtime (car row))) 'CYAN 'BOLD) + (cadr row))) + (call-with-input-file (string-append habits-dir file-name) + parse-file))) + +(define (request-path-components request) + (split-and-decode-uri-path (uri-path (request-uri request)))) + +(define (not-found request) + (values (build-response #:code 404) + (string-append "Resource not found: " + (uri->string (request-uri request))))) + +(define (handle-request request request-body) + (and=> request-body display) + (newline) + (let ((path (request-path-components request)) ) + (display path) + (cond ((null? path) + (values '((content-type . (application/json))) + (scm->json-string (list->vector (scandir habits-dir))))) + ((file-exists? (string-append habits-dir (car path))) + (values '((content-type . (application/json))) + (scm->json-string (list->vector + (map (lambda (row) (list->vector row)) + (call-with-input-file (string-append habits-dir (car path)) + parse-file)))))) + ((string=? "hi" (car path)) + (values '((content-type . (application/json))) + '(hi))) + (else (not-found request))))) + + +(cli-print "pull-ups.dat") +(display "pu\n") +(cli-print "push-ups.dat") +;(run-server (lambda (request request-body) (handle-request request request-body))) diff --git a/lib/guile/tests.scm b/lib/guile/tests.scm new file mode 100755 index 0000000..bc0606c --- /dev/null +++ b/lib/guile/tests.scm @@ -0,0 +1,65 @@ +#!/usr/bin/guile \ +-L . --no-auto-compile -s +!# + +(use-modules + (ice-9 and-let-star) + (language tree-il) + (term ansi-color) + (srfi srfi-64) + (mail-tools) + (utils)) + +(define (%test-write-result1 pair port) + (simple-format port (string-append (colorize-string " ~a: " 'BOLD) "~s~%") + (car pair) (cdr pair))) + +(define (test-on-test-end-color runner) + (let ((log (test-runner-aux-value runner)) + (kind (test-result-ref runner 'result-kind)) + (results (test-result-alist runner))) + (when (memq kind '(fail xpass)) + (display (colorize-string (if (eq? kind 'xpass) "XPASS" "FAIL") 'RED)) + (map (lambda (y) + (and-let* ((x (assq y results))) + (format #t ":~a" (cdr x)))) + '(source-file source-line test-name)) + (newline)) + (when (output-port? log) + (display "Test end:\n" log) + (map (lambda (pair) + ;; Write out properties not written out by on-test-begin. + (unless (memq (car pair) '(test-name source-file source-line source-form)) + (%test-write-result1 pair log))) + results)))) + +(test-runner-factory + (lambda () + (let ((runner (test-runner-simple))) + (test-runner-on-test-end! runner test-on-test-end-color) + runner))) + +(test-begin "Mail tools") +(test-equal "mail/spam/cur/postU=5" (new-path "mail/inbox/cur/postU=5" "mail/spam")) +(test-equal 60 (call-with-input-string "1595684247\n60\n" get-uidvalidity)) +(test-equal "Ha;S" (rename-higher "Ha,U=55;S" 5)) +(test-equal "Ha,U=20;S" (rename-higher "Ha,U=20;S" 55)) +(test-equal '("+one -new" "(from:first) and tag:new") (with-new '("+one" "from:first") #t)) +(test-equal '("+one" "from:first") (with-new '("+one" "from:first") #f)) +(test-equal '(" -new" "tag:new") (with-new '("" "*") #t)) +(test-equal '("" "*") (with-new '("" "*") #f)) +(test-end "Mail tools") + +(test-begin "Thread macros") +(test-equal '(+ 5 9) (tree-il->scheme (macroexpand '(-> 5 (+ 9))))) +(test-equal '(+ 8) (tree-il->scheme (macroexpand '(-> 8 +)))) +(test-equal '(string-append (number->string (inc 8)) " EUR") + (tree-il->scheme (macroexpand '(-> 8 inc number->string (string-append " EUR"))))) +(test-equal "29 EUR" (-> 28 1+ number->string (string-append " EUR"))) + +(test-equal '(2) + (-> (->> '(5 9 2) (cons 1) (filter even?)) + macroexpand + tree-il->scheme)) + +(test-end "Thread macros") diff --git a/lib/guile/utils.scm b/lib/guile/utils.scm new file mode 100755 index 0000000..ad1b1ed --- /dev/null +++ b/lib/guile/utils.scm @@ -0,0 +1,27 @@ +(define-module (utils) + #:export (-> ->> expand-file)) + +(define-syntax -> + (syntax-rules () + ((_ value) value) + ((_ value (f1 . body) next ...) (-> (f1 value . body) next ...)) + ((_ value fun next ...) (-> (fun value) next ...)))) + +(define-syntax ->> + (syntax-rules () + ((_ value) value) + ((_ value (f ...) rest ...) (->> (f ... value) rest ...)) + ((_ value f rest ...) (->> (f value) rest ...)))) + +(define (expand-file f) + ;; https://irreal.org/blog/?p=83 + (cond ((char=? (string-ref f 0) #\/) f) + ((string=? (substring f 0 2) "~/") + (let ((prefix (passwd:dir (getpwuid (geteuid))))) + (string-append prefix (substring f 1 (string-length f))))) + ((char=? (string-ref f 0) #\~) + (let* ((user-end (string-index f #\/)) + (user (substring f 1 user-end)) + (prefix (passwd:dir (getpwnam user)))) + (string-append prefix (substring f user-end (string-length f))))) + (else (string-append (getcwd) "/" f)))) -- cgit v1.2.3