From fd3ffe35a2bf15676426235b809df915cd3473e4 Mon Sep 17 00:00:00 2001 From: Peter Feigl Date: Thu, 6 Dec 2012 22:12:11 +0100 Subject: [PATCH] Adding an S-expression structured output printer. This commit adds a structured output printer for Lisp S-Expressions. Later commits will use this printer in notmuch search, show and reply. The structure is the same as json, but: - arrays are written as lists: ("foo" "bar" "baaz" 1 2 3) - maps are written as p-lists: (:key "value" :other-key "other-value") - true is written as t - false is written as nil - null is written as nil [ whitespace changes by db ] --- Makefile.local | 1 + sprinter-sexp.c | 236 ++++++++++++++++++++++++++++++++++++++++++++++++ sprinter.h | 4 + 3 files changed, 241 insertions(+) create mode 100644 sprinter-sexp.c diff --git a/Makefile.local b/Makefile.local index 2b919465..0db1713e 100644 --- a/Makefile.local +++ b/Makefile.local @@ -270,6 +270,7 @@ notmuch_client_srcs = \ notmuch-tag.c \ notmuch-time.c \ sprinter-json.c \ + sprinter-sexp.c \ sprinter-text.c \ query-string.c \ mime-node.c \ diff --git a/sprinter-sexp.c b/sprinter-sexp.c new file mode 100644 index 00000000..0aa51e8b --- /dev/null +++ b/sprinter-sexp.c @@ -0,0 +1,236 @@ +/* notmuch - Not much of an email program, (just index and search) + * + * Copyright © 2012 Peter Feigl + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://www.gnu.org/licenses/ . + * + * Author: Peter Feigl + */ + +#include +#include +#include +#include "sprinter.h" +#include + +struct sprinter_sexp { + struct sprinter vtable; + FILE *stream; + /* Top of the state stack, or NULL if the printer is not currently + * inside any aggregate types. */ + struct sexp_state *state; + + /* A flag to signify that a separator should be inserted in the + * output as soon as possible. */ + notmuch_bool_t insert_separator; +}; + +struct sexp_state { + struct sexp_state *parent; + + /* True if nothing has been printed in this aggregate yet. + * Suppresses the space before a value. */ + notmuch_bool_t first; +}; + +/* Helper function to set up the stream to print a value. If this + * value follows another value, prints a space. */ +static struct sprinter_sexp * +sexp_begin_value (struct sprinter *sp) +{ + struct sprinter_sexp *sps = (struct sprinter_sexp *) sp; + + if (sps->state) { + if (! sps->state->first) { + if (sps->insert_separator) { + fputc ('\n', sps->stream); + sps->insert_separator = FALSE; + } else { + fputc (' ', sps->stream); + } + } else { + sps->state->first = FALSE; + } + } + return sps; +} + +/* Helper function to begin an aggregate type. Prints the open + * character and pushes a new state frame. */ +static void +sexp_begin_aggregate (struct sprinter *sp) +{ + struct sprinter_sexp *sps = sexp_begin_value (sp); + struct sexp_state *state = talloc (sps, struct sexp_state); + + fputc ('(', sps->stream); + state->parent = sps->state; + state->first = TRUE; + sps->state = state; +} + +static void +sexp_begin_map (struct sprinter *sp) +{ + sexp_begin_aggregate (sp); +} + +static void +sexp_begin_list (struct sprinter *sp) +{ + sexp_begin_aggregate (sp); +} + +static void +sexp_end (struct sprinter *sp) +{ + struct sprinter_sexp *sps = (struct sprinter_sexp *) sp; + struct sexp_state *state = sps->state; + + fputc (')', sps->stream); + sps->state = state->parent; + talloc_free (state); + if (sps->state == NULL) + fputc ('\n', sps->stream); +} + +static void +sexp_string_len (struct sprinter *sp, const char *val, size_t len) +{ + /* Some characters need escaping. " and \ work fine in all Lisps, + * \n is not supported in CL, but all others work fine. + * Characters below 32 are printed as \123o (three-digit + * octals), which work fine in most Schemes and Emacs. */ + static const char *const escapes[] = { + ['\"'] = "\\\"", ['\\'] = "\\\\", ['\n'] = "\\n" + }; + struct sprinter_sexp *sps = sexp_begin_value (sp); + + fputc ('"', sps->stream); + for (; len; ++val, --len) { + unsigned char ch = *val; + if (ch < ARRAY_SIZE (escapes) && escapes[ch]) + fputs (escapes[ch], sps->stream); + else if (ch >= 32) + fputc (ch, sps->stream); + else + fprintf (sps->stream, "\\%03o", ch); + } + fputc ('"', sps->stream); +} + +static void +sexp_string (struct sprinter *sp, const char *val) +{ + if (val == NULL) + val = ""; + sexp_string_len (sp, val, strlen (val)); +} + +/* Prints a symbol, i.e. the name preceded by a colon. This should work + * in all Lisps, at least as a symbol, if not as a proper keyword */ +static void +sexp_keyword (struct sprinter *sp, const char *val) +{ + unsigned int i = 0; + struct sprinter_sexp *sps = (struct sprinter_sexp *) sp; + char ch; + + if (val == NULL) + INTERNAL_ERROR ("illegal symbol NULL"); + + for (i = 0; i < strlen (val); i++) { + ch = val[i]; + if (! (isalnum (ch) || (ch == '-') || (ch == '_'))) { + INTERNAL_ERROR ("illegal character in symbol %s: %c", val, ch); + } + } + fputc (':', sps->stream); + fputs (val, sps->stream); +} + +static void +sexp_integer (struct sprinter *sp, int val) +{ + struct sprinter_sexp *sps = sexp_begin_value (sp); + + fprintf (sps->stream, "%d", val); +} + +static void +sexp_boolean (struct sprinter *sp, notmuch_bool_t val) +{ + struct sprinter_sexp *sps = sexp_begin_value (sp); + + fputs (val ? "t" : "nil", sps->stream); +} + +static void +sexp_null (struct sprinter *sp) +{ + struct sprinter_sexp *sps = sexp_begin_value (sp); + + fputs ("nil", sps->stream); +} + +static void +sexp_map_key (struct sprinter *sp, const char *key) +{ + sexp_begin_value (sp); + + sexp_keyword (sp, key); +} + +static void +sexp_set_prefix (unused (struct sprinter *sp), unused (const char *name)) +{ +} + +static void +sexp_separator (struct sprinter *sp) +{ + struct sprinter_sexp *sps = (struct sprinter_sexp *) sp; + + sps->insert_separator = TRUE; +} + +struct sprinter * +sprinter_sexp_create (const void *ctx, FILE *stream) +{ + static const struct sprinter_sexp template = { + .vtable = { + .begin_map = sexp_begin_map, + .begin_list = sexp_begin_list, + .end = sexp_end, + .string = sexp_string, + .string_len = sexp_string_len, + .integer = sexp_integer, + .boolean = sexp_boolean, + .null = sexp_null, + .map_key = sexp_map_key, + .separator = sexp_separator, + .set_prefix = sexp_set_prefix, + .is_text_printer = FALSE, + } + }; + struct sprinter_sexp *res; + + res = talloc (ctx, struct sprinter_sexp); + if (! res) + return NULL; + + *res = template; + res->stream = stream; + return &res->vtable; +} diff --git a/sprinter.h b/sprinter.h index 912a5262..59776a9c 100644 --- a/sprinter.h +++ b/sprinter.h @@ -70,4 +70,8 @@ sprinter_text_create (const void *ctx, FILE *stream); struct sprinter * sprinter_json_create (const void *ctx, FILE *stream); +/* Create a new structure printer that emits S-Expressions. */ +struct sprinter * +sprinter_sexp_create (const void *ctx, FILE *stream); + #endif // NOTMUCH_SPRINTER_H