alx/mu4e
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clang-format: update c/cc coding style

Browse Source 
Update all cc code using .clang-format; please do so as well for future PRs
etc.; emacs has a handy 'clang-format' mode to make this automatic.

For comparing old changes with git blame, we can disregard this one using
--ignore-rev

(see https://www.moxio.com/blog/43/ignoring-bulk-change-commits-with-git-blame )
This commit is contained in:
Dirk-Jan C. Binnema
2021-10-20 12:18:15 +03:00
parent 09935cc4b3
commit 3dd721d5a3
111 changed files with 13851 additions and 14579 deletions
Download Patch File Download Diff File Expand all files Collapse all files

543
guile/mu-guile-message.cc
View File

@ -40,60 +40,57 @@ using namespace Mu;
/* some symbols */
static SCM SYMB_PRIO_LOW, SYMB_PRIO_NORMAL, SYMB_PRIO_HIGH;
static SCM SYMB_FLAG_NEW, SYMB_FLAG_PASSED, SYMB_FLAG_REPLIED,
SYMB_FLAG_SEEN, SYMB_FLAG_TRASHED, SYMB_FLAG_DRAFT,
SYMB_FLAG_FLAGGED, SYMB_FLAG_SIGNED, SYMB_FLAG_ENCRYPTED,
SYMB_FLAG_HAS_ATTACH, SYMB_FLAG_UNREAD, SYMB_FLAG_LIST;
static SCM SYMB_CONTACT_TO, SYMB_CONTACT_CC, SYMB_CONTACT_BCC,
SYMB_CONTACT_FROM;
static SCM SYMB_FLAG_NEW, SYMB_FLAG_PASSED, SYMB_FLAG_REPLIED, SYMB_FLAG_SEEN, SYMB_FLAG_TRASHED,
SYMB_FLAG_DRAFT, SYMB_FLAG_FLAGGED, SYMB_FLAG_SIGNED, SYMB_FLAG_ENCRYPTED, SYMB_FLAG_HAS_ATTACH,
SYMB_FLAG_UNREAD, SYMB_FLAG_LIST;
static SCM SYMB_CONTACT_TO, SYMB_CONTACT_CC, SYMB_CONTACT_BCC, SYMB_CONTACT_FROM;
struct _MuMsgWrapper {
MuMsg *_msg;
MuMsg* _msg;
gboolean _unrefme;
};
typedef struct _MuMsgWrapper MuMsgWrapper;
static long MSG_TAG;
static long MSG_TAG;
static gboolean
mu_guile_scm_is_msg (SCM scm)
mu_guile_scm_is_msg(SCM scm)
{
return SCM_NIMP(scm) && (long)SCM_CAR(scm) == MSG_TAG;
}
SCM
mu_guile_msg_to_scm (MuMsg *msg)
mu_guile_msg_to_scm(MuMsg* msg)
{
MuMsgWrapper *msgwrap;
MuMsgWrapper* msgwrap;
g_return_val_if_fail (msg, SCM_UNDEFINED);
g_return_val_if_fail(msg, SCM_UNDEFINED);
msgwrap = (MuMsgWrapper*)scm_gc_malloc (sizeof (MuMsgWrapper), "msg");
msgwrap->_msg = msg;
msgwrap = (MuMsgWrapper*)scm_gc_malloc(sizeof(MuMsgWrapper), "msg");
msgwrap->_msg = msg;
msgwrap->_unrefme = FALSE;
SCM_RETURN_NEWSMOB (MSG_TAG, msgwrap);
SCM_RETURN_NEWSMOB(MSG_TAG, msgwrap);
}
struct _FlagData {
MuFlags flags;
SCM lst;
SCM lst;
};
typedef struct _FlagData FlagData;
#define MU_GUILE_INITIALIZED_OR_ERROR \
do { \
if (!(mu_guile_initialized())) { \
mu_guile_error (FUNC_NAME, 0, \
"mu not initialized; call mu:initialize", \
SCM_UNDEFINED); \
return SCM_UNSPECIFIED; \
} \
#define MU_GUILE_INITIALIZED_OR_ERROR \
do { \
if (!(mu_guile_initialized())) { \
mu_guile_error(FUNC_NAME, \
0, \
"mu not initialized; call mu:initialize", \
SCM_UNDEFINED); \
return SCM_UNSPECIFIED; \
} \
} while (0)
static void
check_flag (MuFlags flag, FlagData *fdata)
check_flag(MuFlags flag, FlagData* fdata)
{
SCM flag_scm;
@ -102,225 +99,211 @@ check_flag (MuFlags flag, FlagData *fdata)
switch (flag) {
case MU_FLAG_NONE: break;
case MU_FLAG_NEW: flag_scm = SYMB_FLAG_NEW; break;
case MU_FLAG_PASSED: flag_scm = SYMB_FLAG_PASSED; break;
case MU_FLAG_REPLIED: flag_scm = SYMB_FLAG_REPLIED; break;
case MU_FLAG_SEEN: flag_scm = SYMB_FLAG_SEEN; break;
case MU_FLAG_TRASHED: flag_scm = SYMB_FLAG_TRASHED; break;
case MU_FLAG_SIGNED: flag_scm = SYMB_FLAG_SIGNED; break;
case MU_FLAG_DRAFT: flag_scm = SYMB_FLAG_DRAFT; break;
case MU_FLAG_FLAGGED: flag_scm = SYMB_FLAG_FLAGGED; break;
case MU_FLAG_ENCRYPTED: flag_scm = SYMB_FLAG_ENCRYPTED; break;
case MU_FLAG_NEW: flag_scm = SYMB_FLAG_NEW; break;
case MU_FLAG_PASSED: flag_scm = SYMB_FLAG_PASSED; break;
case MU_FLAG_REPLIED: flag_scm = SYMB_FLAG_REPLIED; break;
case MU_FLAG_SEEN: flag_scm = SYMB_FLAG_SEEN; break;
case MU_FLAG_TRASHED: flag_scm = SYMB_FLAG_TRASHED; break;
case MU_FLAG_SIGNED: flag_scm = SYMB_FLAG_SIGNED; break;
case MU_FLAG_DRAFT: flag_scm = SYMB_FLAG_DRAFT; break;
case MU_FLAG_FLAGGED: flag_scm = SYMB_FLAG_FLAGGED; break;
case MU_FLAG_ENCRYPTED: flag_scm = SYMB_FLAG_ENCRYPTED; break;
case MU_FLAG_HAS_ATTACH: flag_scm = SYMB_FLAG_HAS_ATTACH; break;
case MU_FLAG_UNREAD: flag_scm = SYMB_FLAG_UNREAD; break;
case MU_FLAG_LIST: flag_scm = SYMB_FLAG_LIST; break;
case MU_FLAG_UNREAD: flag_scm = SYMB_FLAG_UNREAD; break;
case MU_FLAG_LIST: flag_scm = SYMB_FLAG_LIST; break;
default: flag_scm = SCM_UNDEFINED;
}
fdata->lst = scm_append_x
(scm_list_2(fdata->lst,
scm_list_1 (flag_scm)));
fdata->lst = scm_append_x(scm_list_2(fdata->lst, scm_list_1(flag_scm)));
}
static SCM
get_flags_scm (MuMsg *msg)
get_flags_scm(MuMsg* msg)
{
FlagData fdata;
fdata.flags = mu_msg_get_flags (msg);
fdata.flags = mu_msg_get_flags(msg);
fdata.lst = SCM_EOL;
mu_flags_foreach ((MuFlagsForeachFunc)check_flag, &fdata);
mu_flags_foreach((MuFlagsForeachFunc)check_flag, &fdata);
return fdata.lst;
}
static SCM
get_prio_scm (MuMsg *msg)
get_prio_scm(MuMsg* msg)
{
switch (mu_msg_get_prio (msg)) {
switch (mu_msg_get_prio(msg)) {
case MU_MSG_PRIO_LOW: return SYMB_PRIO_LOW;
case MU_MSG_PRIO_NORMAL: return SYMB_PRIO_NORMAL;
case MU_MSG_PRIO_HIGH: return SYMB_PRIO_HIGH;
case MU_MSG_PRIO_LOW: return SYMB_PRIO_LOW;
case MU_MSG_PRIO_NORMAL: return SYMB_PRIO_NORMAL;
case MU_MSG_PRIO_HIGH: return SYMB_PRIO_HIGH;
default:
g_return_val_if_reached (SCM_UNDEFINED);
default: g_return_val_if_reached(SCM_UNDEFINED);
}
}
static SCM
msg_string_list_field (MuMsg *msg, MuMsgFieldId mfid)
msg_string_list_field(MuMsg* msg, MuMsgFieldId mfid)
{
SCM scmlst;
const GSList *lst;
SCM scmlst;
const GSList* lst;
lst = mu_msg_get_field_string_list (msg, mfid);
lst = mu_msg_get_field_string_list(msg, mfid);
for (scmlst = SCM_EOL; lst;
lst = g_slist_next(lst)) {
for (scmlst = SCM_EOL; lst; lst = g_slist_next(lst)) {
SCM item;
item = scm_list_1
(mu_guile_scm_from_str((const char*)lst->data));
scmlst = scm_append_x (scm_list_2(scmlst, item));
item = scm_list_1(mu_guile_scm_from_str((const char*)lst->data));
scmlst = scm_append_x(scm_list_2(scmlst, item));
}
return scmlst;
}
static SCM
get_body (MuMsg *msg, gboolean html)
get_body(MuMsg* msg, gboolean html)
{
SCM data;
const char* body;
SCM data;
const char* body;
MuMsgOptions opts;
opts = MU_MSG_OPTION_NONE;
if (html)
body = mu_msg_get_body_html (msg, opts);
body = mu_msg_get_body_html(msg, opts);
else
body = mu_msg_get_body_text (msg, opts);
body = mu_msg_get_body_text(msg, opts);
if (body)
data = mu_guile_scm_from_str (body);
data = mu_guile_scm_from_str(body);
else
data = SCM_BOOL_F;
/* explicitly close the file backend, so we won't run of fds */
mu_msg_unload_msg_file (msg);
mu_msg_unload_msg_file(msg);
return data;
}
SCM_DEFINE (get_field, "mu:c:get-field", 2, 0, 0,
(SCM MSG, SCM FIELD),
"Get the field FIELD from message MSG.\n")
SCM_DEFINE(get_field,
"mu:c:get-field",
2,
0,
0,
(SCM MSG, SCM FIELD),
"Get the field FIELD from message MSG.\n")
#define FUNC_NAME s_get_field
{
MuMsgWrapper *msgwrap;
MuMsgFieldId mfid;
msgwrap = (MuMsgWrapper*) SCM_CDR(MSG);
MuMsgWrapper* msgwrap;
MuMsgFieldId mfid;
msgwrap = (MuMsgWrapper*)SCM_CDR(MSG);
MU_GUILE_INITIALIZED_OR_ERROR;
SCM_ASSERT (mu_guile_scm_is_msg(MSG), MSG, SCM_ARG1, FUNC_NAME);
SCM_ASSERT (scm_integer_p(FIELD), FIELD, SCM_ARG2, FUNC_NAME);
SCM_ASSERT(mu_guile_scm_is_msg(MSG), MSG, SCM_ARG1, FUNC_NAME);
SCM_ASSERT(scm_integer_p(FIELD), FIELD, SCM_ARG2, FUNC_NAME);
mfid = scm_to_int (FIELD);
SCM_ASSERT (mfid < MU_MSG_FIELD_ID_NUM ||
mfid == MU_GUILE_MSG_FIELD_ID_TIMESTAMP,
FIELD, SCM_ARG2, FUNC_NAME);
mfid = scm_to_int(FIELD);
SCM_ASSERT(mfid < MU_MSG_FIELD_ID_NUM || mfid == MU_GUILE_MSG_FIELD_ID_TIMESTAMP,
FIELD,
SCM_ARG2,
FUNC_NAME);
switch (mfid) {
case MU_MSG_FIELD_ID_PRIO: return get_prio_scm (msgwrap->_msg);
case MU_MSG_FIELD_ID_FLAGS: return get_flags_scm (msgwrap->_msg);
case MU_MSG_FIELD_ID_PRIO: return get_prio_scm(msgwrap->_msg);
case MU_MSG_FIELD_ID_FLAGS: return get_flags_scm(msgwrap->_msg);
case MU_MSG_FIELD_ID_BODY_HTML:
return get_body (msgwrap->_msg, TRUE);
case MU_MSG_FIELD_ID_BODY_TEXT:
return get_body (msgwrap->_msg, FALSE);
case MU_MSG_FIELD_ID_BODY_HTML: return get_body(msgwrap->_msg, TRUE);
case MU_MSG_FIELD_ID_BODY_TEXT: return get_body(msgwrap->_msg, FALSE);
/* our pseudo-field; we get it from the message file */
case MU_GUILE_MSG_FIELD_ID_TIMESTAMP:
return scm_from_uint (
(unsigned)mu_msg_get_timestamp(msgwrap->_msg));
return scm_from_uint((unsigned)mu_msg_get_timestamp(msgwrap->_msg));
default: break;
}
switch (mu_msg_field_type (mfid)) {
switch (mu_msg_field_type(mfid)) {
case MU_MSG_FIELD_TYPE_STRING:
return mu_guile_scm_from_str
(mu_msg_get_field_string(msgwrap->_msg, mfid));
return mu_guile_scm_from_str(mu_msg_get_field_string(msgwrap->_msg, mfid));
case MU_MSG_FIELD_TYPE_BYTESIZE:
case MU_MSG_FIELD_TYPE_TIME_T:
return scm_from_uint (
mu_msg_get_field_numeric (msgwrap->_msg, mfid));
return scm_from_uint(mu_msg_get_field_numeric(msgwrap->_msg, mfid));
case MU_MSG_FIELD_TYPE_INT:
return scm_from_int (
mu_msg_get_field_numeric (msgwrap->_msg, mfid));
case MU_MSG_FIELD_TYPE_STRING_LIST:
return msg_string_list_field (msgwrap->_msg, mfid);
default:
SCM_ASSERT (0, FIELD, SCM_ARG2, FUNC_NAME);
return scm_from_int(mu_msg_get_field_numeric(msgwrap->_msg, mfid));
case MU_MSG_FIELD_TYPE_STRING_LIST: return msg_string_list_field(msgwrap->_msg, mfid);
default: SCM_ASSERT(0, FIELD, SCM_ARG2, FUNC_NAME);
}
}
#undef FUNC_NAME
struct _EachContactData {
SCM lst;
SCM lst;
MuMsgContactType ctype;
};
typedef struct _EachContactData EachContactData;
static void
contacts_to_list (MuMsgContact *contact, EachContactData *ecdata)
contacts_to_list(MuMsgContact* contact, EachContactData* ecdata)
{
SCM item;
if (ecdata->ctype != MU_MSG_CONTACT_TYPE_ALL &&
mu_msg_contact_type (contact) != ecdata->ctype)
mu_msg_contact_type(contact) != ecdata->ctype)
return;
item = scm_list_1
(scm_cons
(mu_guile_scm_from_str(mu_msg_contact_name (contact)),
mu_guile_scm_from_str(mu_msg_contact_email (contact))));
item = scm_list_1(scm_cons(mu_guile_scm_from_str(mu_msg_contact_name(contact)),
mu_guile_scm_from_str(mu_msg_contact_email(contact))));
ecdata->lst = scm_append_x (scm_list_2(ecdata->lst, item));
ecdata->lst = scm_append_x(scm_list_2(ecdata->lst, item));
}
SCM_DEFINE (get_contacts, "mu:c:get-contacts", 2, 0, 0,
(SCM MSG, SCM CONTACT_TYPE),
"Get a list of contact information pairs.\n")
SCM_DEFINE(get_contacts,
"mu:c:get-contacts",
2,
0,
0,
(SCM MSG, SCM CONTACT_TYPE),
"Get a list of contact information pairs.\n")
#define FUNC_NAME s_get_contacts
{
MuMsgWrapper *msgwrap;
MuMsgWrapper* msgwrap;
EachContactData ecdata;
MU_GUILE_INITIALIZED_OR_ERROR;
SCM_ASSERT (mu_guile_scm_is_msg(MSG), MSG, SCM_ARG1, FUNC_NAME);
SCM_ASSERT (scm_symbol_p (CONTACT_TYPE) || scm_is_bool(CONTACT_TYPE),
CONTACT_TYPE, SCM_ARG2, FUNC_NAME);
SCM_ASSERT(mu_guile_scm_is_msg(MSG), MSG, SCM_ARG1, FUNC_NAME);
SCM_ASSERT(scm_symbol_p(CONTACT_TYPE) || scm_is_bool(CONTACT_TYPE),
CONTACT_TYPE,
SCM_ARG2,
FUNC_NAME);
if (CONTACT_TYPE == SCM_BOOL_F)
return SCM_UNSPECIFIED; /* nothing to do */
else if (CONTACT_TYPE == SCM_BOOL_T)
ecdata.ctype = MU_MSG_CONTACT_TYPE_ALL;
else {
if (scm_is_eq (CONTACT_TYPE, SYMB_CONTACT_TO))
if (scm_is_eq(CONTACT_TYPE, SYMB_CONTACT_TO))
ecdata.ctype = MU_MSG_CONTACT_TYPE_TO;
else if (scm_is_eq (CONTACT_TYPE, SYMB_CONTACT_CC))
else if (scm_is_eq(CONTACT_TYPE, SYMB_CONTACT_CC))
ecdata.ctype = MU_MSG_CONTACT_TYPE_CC;
else if (scm_is_eq (CONTACT_TYPE, SYMB_CONTACT_BCC))
else if (scm_is_eq(CONTACT_TYPE, SYMB_CONTACT_BCC))
ecdata.ctype = MU_MSG_CONTACT_TYPE_BCC;
else if (scm_is_eq (CONTACT_TYPE, SYMB_CONTACT_FROM))
else if (scm_is_eq(CONTACT_TYPE, SYMB_CONTACT_FROM))
ecdata.ctype = MU_MSG_CONTACT_TYPE_FROM;
else {
mu_guile_error (FUNC_NAME, 0, "invalid contact type",
SCM_UNDEFINED);
mu_guile_error(FUNC_NAME, 0, "invalid contact type", SCM_UNDEFINED);
return SCM_UNSPECIFIED;
}
}
ecdata.lst = SCM_EOL;
msgwrap = (MuMsgWrapper*) SCM_CDR(MSG);
#pragma GCC diagnostic push
msgwrap = (MuMsgWrapper*)SCM_CDR(MSG);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-function-type"
mu_msg_contact_foreach (msgwrap->_msg,
(MuMsgContactForeachFunc)contacts_to_list,
&ecdata);
mu_msg_contact_foreach(msgwrap->_msg, (MuMsgContactForeachFunc)contacts_to_list, &ecdata);
#pragma GCC diagnostic pop
/* explicitly close the file backend, so we won't run out of fds */
mu_msg_unload_msg_file (msgwrap->_msg);
mu_msg_unload_msg_file(msgwrap->_msg);
return ecdata.lst;
}
@ -333,144 +316,149 @@ struct _AttInfo {
typedef struct _AttInfo AttInfo;
static void
each_part (MuMsg *msg, MuMsgPart *part, AttInfo *attinfo)
each_part(MuMsg* msg, MuMsgPart* part, AttInfo* attinfo)
{
char *mime_type, *filename;
SCM elm;
SCM elm;
if (!part->type)
return;
if (attinfo->attachments_only &&
!mu_msg_part_maybe_attachment (part))
if (attinfo->attachments_only && !mu_msg_part_maybe_attachment(part))
return;
mime_type = g_strdup_printf ("%s/%s", part->type, part->subtype);
filename = mu_msg_part_get_filename (part, FALSE);
mime_type = g_strdup_printf("%s/%s", part->type, part->subtype);
filename = mu_msg_part_get_filename(part, FALSE);
elm = scm_list_5 (
/* msg */
mu_guile_scm_from_str (mu_msg_get_path(msg)),
/* index */
scm_from_uint(part->index),
/* filename or #f */
filename ? mu_guile_scm_from_str (filename) : SCM_BOOL_F,
/* mime-type */
mime_type ? mu_guile_scm_from_str (mime_type): SCM_BOOL_F,
/* size */
part->size > 0 ? scm_from_uint (part->size) : SCM_BOOL_F);
elm = scm_list_5(
/* msg */
mu_guile_scm_from_str(mu_msg_get_path(msg)),
/* index */
scm_from_uint(part->index),
/* filename or #f */
filename ? mu_guile_scm_from_str(filename) : SCM_BOOL_F,
/* mime-type */
mime_type ? mu_guile_scm_from_str(mime_type) : SCM_BOOL_F,
/* size */
part->size > 0 ? scm_from_uint(part->size) : SCM_BOOL_F);
g_free (mime_type);
g_free (filename);
g_free(mime_type);
g_free(filename);
attinfo->attlist = scm_cons (elm, attinfo->attlist);
attinfo->attlist = scm_cons(elm, attinfo->attlist);
}
SCM_DEFINE (get_parts, "mu:c:get-parts", 1, 1, 0,
(SCM MSG, SCM ATTS_ONLY),
"Get the list of mime-parts for MSG. If ATTS_ONLY is #t, only"
"get parts that are (look like) attachments. The resulting list has "
"elements which are list of the form (index name mime-type size).\n")
SCM_DEFINE(get_parts,
"mu:c:get-parts",
1,
1,
0,
(SCM MSG, SCM ATTS_ONLY),
"Get the list of mime-parts for MSG. If ATTS_ONLY is #t, only"
"get parts that are (look like) attachments. The resulting list has "
"elements which are list of the form (index name mime-type size).\n")
#define FUNC_NAME s_get_parts
{
MuMsgWrapper *msgwrap;
AttInfo attinfo;
MuMsgWrapper* msgwrap;
AttInfo attinfo;
MU_GUILE_INITIALIZED_OR_ERROR;
SCM_ASSERT (mu_guile_scm_is_msg(MSG), MSG, SCM_ARG1, FUNC_NAME);
SCM_ASSERT (scm_is_bool(ATTS_ONLY), ATTS_ONLY, SCM_ARG2, FUNC_NAME);
SCM_ASSERT(mu_guile_scm_is_msg(MSG), MSG, SCM_ARG1, FUNC_NAME);
SCM_ASSERT(scm_is_bool(ATTS_ONLY), ATTS_ONLY, SCM_ARG2, FUNC_NAME);
attinfo.attlist = SCM_EOL; /* empty list */
attinfo.attlist = SCM_EOL; /* empty list */
attinfo.attachments_only = ATTS_ONLY == SCM_BOOL_T ? TRUE : FALSE;
msgwrap = (MuMsgWrapper*) SCM_CDR(MSG);
mu_msg_part_foreach (msgwrap->_msg, MU_MSG_OPTION_NONE,
(MuMsgPartForeachFunc)each_part,
&attinfo);
msgwrap = (MuMsgWrapper*)SCM_CDR(MSG);
mu_msg_part_foreach(msgwrap->_msg,
MU_MSG_OPTION_NONE,
(MuMsgPartForeachFunc)each_part,
&attinfo);
/* explicitly close the file backend, so we won't run of fds */
mu_msg_unload_msg_file (msgwrap->_msg);
mu_msg_unload_msg_file(msgwrap->_msg);
return attinfo.attlist;
}
#undef FUNC_NAME
SCM_DEFINE (get_header, "mu:c:get-header", 2, 0, 0,
(SCM MSG, SCM HEADER), "Get an arbitrary HEADER from MSG.\n")
SCM_DEFINE(get_header,
"mu:c:get-header",
2,
0,
0,
(SCM MSG, SCM HEADER),
"Get an arbitrary HEADER from MSG.\n")
#define FUNC_NAME s_get_header
{
MuMsgWrapper *msgwrap;
char *header;
SCM val;
MuMsgWrapper* msgwrap;
char* header;
SCM val;
MU_GUILE_INITIALIZED_OR_ERROR;
SCM_ASSERT (mu_guile_scm_is_msg(MSG), MSG, SCM_ARG1, FUNC_NAME);
SCM_ASSERT (scm_is_string (HEADER)||HEADER==SCM_UNDEFINED,
HEADER, SCM_ARG2, FUNC_NAME);
SCM_ASSERT(mu_guile_scm_is_msg(MSG), MSG, SCM_ARG1, FUNC_NAME);
SCM_ASSERT(scm_is_string(HEADER) || HEADER == SCM_UNDEFINED, HEADER, SCM_ARG2, FUNC_NAME);
msgwrap = (MuMsgWrapper*) SCM_CDR(MSG);
header = scm_to_utf8_string (HEADER);
val = mu_guile_scm_from_str
(mu_msg_get_header(msgwrap->_msg, header));
free (header);
msgwrap = (MuMsgWrapper*)SCM_CDR(MSG);
header = scm_to_utf8_string(HEADER);
val = mu_guile_scm_from_str(mu_msg_get_header(msgwrap->_msg, header));
free(header);
/* explicitly close the file backend, so we won't run of fds */
mu_msg_unload_msg_file (msgwrap->_msg);
mu_msg_unload_msg_file(msgwrap->_msg);
return val;
}
#undef FUNC_NAME
static Mu::Option<Mu::QueryResults>
get_query_results (Mu::Store& store, const char* expr, int maxnum)
get_query_results(Mu::Store& store, const char* expr, int maxnum)
{
Mu::Query query(store);
return query.run(expr, MU_MSG_FIELD_ID_NONE,
Mu::QueryFlags::None, maxnum);
return query.run(expr, MU_MSG_FIELD_ID_NONE, Mu::QueryFlags::None, maxnum);
}
SCM_DEFINE (for_each_message, "mu:c:for-each-message", 3, 0, 0,
(SCM FUNC, SCM EXPR, SCM MAXNUM),
"Call FUNC for each msg in the message store matching EXPR. EXPR is"
"either a string containing a mu search expression or a boolean; in the former "
"case, limit the messages to only those matching the expression, in the "
"latter case, match /all/ messages if the EXPR equals #t, and match "
"none if EXPR equals #f.")
SCM_DEFINE(for_each_message,
"mu:c:for-each-message",
3,
0,
0,
(SCM FUNC, SCM EXPR, SCM MAXNUM),
"Call FUNC for each msg in the message store matching EXPR. EXPR is"
"either a string containing a mu search expression or a boolean; in the former "
"case, limit the messages to only those matching the expression, in the "
"latter case, match /all/ messages if the EXPR equals #t, and match "
"none if EXPR equals #f.")
#define FUNC_NAME s_for_each_message
{
char* expr{};
MU_GUILE_INITIALIZED_OR_ERROR;
SCM_ASSERT (scm_procedure_p (FUNC), FUNC, SCM_ARG1, FUNC_NAME);
SCM_ASSERT (scm_is_bool(EXPR) || scm_is_string (EXPR),
EXPR, SCM_ARG2, FUNC_NAME);
SCM_ASSERT (scm_is_integer (MAXNUM), MAXNUM, SCM_ARG3, FUNC_NAME);
SCM_ASSERT(scm_procedure_p(FUNC), FUNC, SCM_ARG1, FUNC_NAME);
SCM_ASSERT(scm_is_bool(EXPR) || scm_is_string(EXPR), EXPR, SCM_ARG2, FUNC_NAME);
SCM_ASSERT(scm_is_integer(MAXNUM), MAXNUM, SCM_ARG3, FUNC_NAME);
if (EXPR == SCM_BOOL_F)
return SCM_UNSPECIFIED; /* nothing to do */
if (EXPR == SCM_BOOL_T)
expr = strdup (""); /* note, "" matches *all* messages */
expr = strdup(""); /* note, "" matches *all* messages */
else
expr = scm_to_utf8_string(EXPR);
const auto res{get_query_results(mu_guile_store(), expr,
scm_to_int(MAXNUM))};
free (expr);
const auto res{get_query_results(mu_guile_store(), expr, scm_to_int(MAXNUM))};
free(expr);
if (!res)
return SCM_UNSPECIFIED;
for (auto&& mi: *res) {
for (auto&& mi : *res) {
auto msg{mi.floating_msg()};
if (msg) {
auto msgsmob{mu_guile_msg_to_scm (mu_msg_ref(msg))};
scm_call_1 (FUNC, msgsmob);
auto msgsmob{mu_guile_msg_to_scm(mu_msg_ref(msg))};
scm_call_1(FUNC, msgsmob);
}
}
@ -478,90 +466,85 @@ SCM_DEFINE (for_each_message, "mu:c:for-each-message", 3, 0, 0,
}
#undef FUNC_NAME
static SCM
register_symbol (const char *name)
register_symbol(const char* name)
{
SCM scm;
scm = scm_from_utf8_symbol (name);
scm_c_define (name, scm);
scm_c_export (name, NULL);
scm = scm_from_utf8_symbol(name);
scm_c_define(name, scm);
scm_c_export(name, NULL);
return scm;
}
static void
define_symbols (void)
define_symbols(void)
{
SYMB_CONTACT_TO = register_symbol ("mu:contact:to");
SYMB_CONTACT_CC = register_symbol ("mu:contact:cc");
SYMB_CONTACT_FROM = register_symbol ("mu:contact:from");
SYMB_CONTACT_BCC = register_symbol ("mu:contact:bcc");
SYMB_CONTACT_TO = register_symbol("mu:contact:to");
SYMB_CONTACT_CC = register_symbol("mu:contact:cc");
SYMB_CONTACT_FROM = register_symbol("mu:contact:from");
SYMB_CONTACT_BCC = register_symbol("mu:contact:bcc");
SYMB_PRIO_LOW = register_symbol ("mu:prio:low");
SYMB_PRIO_NORMAL = register_symbol ("mu:prio:normal");
SYMB_PRIO_HIGH = register_symbol ("mu:prio:high");
SYMB_PRIO_LOW = register_symbol("mu:prio:low");
SYMB_PRIO_NORMAL = register_symbol("mu:prio:normal");
SYMB_PRIO_HIGH = register_symbol("mu:prio:high");
SYMB_FLAG_NEW = register_symbol ("mu:flag:new");
SYMB_FLAG_PASSED = register_symbol ("mu:flag:passed");
SYMB_FLAG_REPLIED = register_symbol ("mu:flag:replied");
SYMB_FLAG_SEEN = register_symbol ("mu:flag:seen");
SYMB_FLAG_TRASHED = register_symbol ("mu:flag:trashed");
SYMB_FLAG_DRAFT = register_symbol ("mu:flag:draft");
SYMB_FLAG_FLAGGED = register_symbol ("mu:flag:flagged");
SYMB_FLAG_SIGNED = register_symbol ("mu:flag:signed");
SYMB_FLAG_ENCRYPTED = register_symbol ("mu:flag:encrypted");
SYMB_FLAG_HAS_ATTACH = register_symbol ("mu:flag:has-attach");
SYMB_FLAG_UNREAD = register_symbol ("mu:flag:unread");
SYMB_FLAG_NEW = register_symbol("mu:flag:new");
SYMB_FLAG_PASSED = register_symbol("mu:flag:passed");
SYMB_FLAG_REPLIED = register_symbol("mu:flag:replied");
SYMB_FLAG_SEEN = register_symbol("mu:flag:seen");
SYMB_FLAG_TRASHED = register_symbol("mu:flag:trashed");
SYMB_FLAG_DRAFT = register_symbol("mu:flag:draft");
SYMB_FLAG_FLAGGED = register_symbol("mu:flag:flagged");
SYMB_FLAG_SIGNED = register_symbol("mu:flag:signed");
SYMB_FLAG_ENCRYPTED = register_symbol("mu:flag:encrypted");
SYMB_FLAG_HAS_ATTACH = register_symbol("mu:flag:has-attach");
SYMB_FLAG_UNREAD = register_symbol("mu:flag:unread");
SYMB_FLAG_LIST = register_symbol ("mu:flag:list");
SYMB_FLAG_LIST = register_symbol("mu:flag:list");
}
static struct {
static struct {
const char* name;
unsigned val;
unsigned val;
} VAR_PAIRS[] = {
{ "mu:field:bcc", MU_MSG_FIELD_ID_BCC },
{ "mu:field:body-html", MU_MSG_FIELD_ID_BODY_HTML },
{ "mu:field:body-txt", MU_MSG_FIELD_ID_BODY_TEXT },
{ "mu:field:cc", MU_MSG_FIELD_ID_CC },
{ "mu:field:date", MU_MSG_FIELD_ID_DATE },
{ "mu:field:flags", MU_MSG_FIELD_ID_FLAGS },
{ "mu:field:from", MU_MSG_FIELD_ID_FROM },
{ "mu:field:maildir", MU_MSG_FIELD_ID_MAILDIR },
{ "mu:field:message-id",MU_MSG_FIELD_ID_MSGID },
{ "mu:field:path", MU_MSG_FIELD_ID_PATH },
{ "mu:field:prio", MU_MSG_FIELD_ID_PRIO },
{ "mu:field:refs", MU_MSG_FIELD_ID_REFS },
{ "mu:field:size", MU_MSG_FIELD_ID_SIZE },
{ "mu:field:subject", MU_MSG_FIELD_ID_SUBJECT },
{ "mu:field:tags", MU_MSG_FIELD_ID_TAGS },
{ "mu:field:to", MU_MSG_FIELD_ID_TO },
{"mu:field:bcc", MU_MSG_FIELD_ID_BCC},
{"mu:field:body-html", MU_MSG_FIELD_ID_BODY_HTML},
{"mu:field:body-txt", MU_MSG_FIELD_ID_BODY_TEXT},
{"mu:field:cc", MU_MSG_FIELD_ID_CC},
{"mu:field:date", MU_MSG_FIELD_ID_DATE},
{"mu:field:flags", MU_MSG_FIELD_ID_FLAGS},
{"mu:field:from", MU_MSG_FIELD_ID_FROM},
{"mu:field:maildir", MU_MSG_FIELD_ID_MAILDIR},
{"mu:field:message-id", MU_MSG_FIELD_ID_MSGID},
{"mu:field:path", MU_MSG_FIELD_ID_PATH},
{"mu:field:prio", MU_MSG_FIELD_ID_PRIO},
{"mu:field:refs", MU_MSG_FIELD_ID_REFS},
{"mu:field:size", MU_MSG_FIELD_ID_SIZE},
{"mu:field:subject", MU_MSG_FIELD_ID_SUBJECT},
{"mu:field:tags", MU_MSG_FIELD_ID_TAGS},
{"mu:field:to", MU_MSG_FIELD_ID_TO},
/* non-Xapian field: timestamp */
{ "mu:field:timestamp", MU_GUILE_MSG_FIELD_ID_TIMESTAMP }
};
/* non-Xapian field: timestamp */
{"mu:field:timestamp", MU_GUILE_MSG_FIELD_ID_TIMESTAMP}};
static void
define_vars (void)
define_vars(void)
{
unsigned u;
for (u = 0; u != G_N_ELEMENTS(VAR_PAIRS); ++u) {
scm_c_define (VAR_PAIRS[u].name,
scm_from_uint (VAR_PAIRS[u].val));
scm_c_export (VAR_PAIRS[u].name, NULL);
scm_c_define(VAR_PAIRS[u].name, scm_from_uint(VAR_PAIRS[u].val));
scm_c_export(VAR_PAIRS[u].name, NULL);
}
}
static SCM
msg_mark (SCM msg_smob)
msg_mark(SCM msg_smob)
{
MuMsgWrapper *msgwrap;
msgwrap = (MuMsgWrapper*) SCM_CDR(msg_smob);
MuMsgWrapper* msgwrap;
msgwrap = (MuMsgWrapper*)SCM_CDR(msg_smob);
msgwrap->_unrefme = TRUE;
@ -569,48 +552,46 @@ msg_mark (SCM msg_smob)
}
static size_t
msg_free (SCM msg_smob)
msg_free(SCM msg_smob)
{
MuMsgWrapper *msgwrap;
msgwrap = (MuMsgWrapper*) SCM_CDR(msg_smob);
MuMsgWrapper* msgwrap;
msgwrap = (MuMsgWrapper*)SCM_CDR(msg_smob);
if (msgwrap->_unrefme)
mu_msg_unref (msgwrap->_msg);
mu_msg_unref(msgwrap->_msg);
return sizeof (MuMsgWrapper);
return sizeof(MuMsgWrapper);
}
static int
msg_print (SCM msg_smob, SCM port, scm_print_state * pstate)
msg_print(SCM msg_smob, SCM port, scm_print_state* pstate)
{
MuMsgWrapper *msgwrap;
msgwrap = (MuMsgWrapper*) SCM_CDR(msg_smob);
MuMsgWrapper* msgwrap;
msgwrap = (MuMsgWrapper*)SCM_CDR(msg_smob);
scm_puts ("#<msg ", port);
scm_puts("#<msg ", port);
if (msg_smob == SCM_BOOL_F)
scm_puts ("#f", port);
scm_puts("#f", port);
else
scm_puts (mu_msg_get_path(msgwrap->_msg),
port);
scm_puts(mu_msg_get_path(msgwrap->_msg), port);
scm_puts (">", port);
scm_puts(">", port);
return 1;
}
void*
mu_guile_message_init (void *data)
mu_guile_message_init(void* data)
{
MSG_TAG = scm_make_smob_type ("msg", sizeof(MuMsgWrapper));
MSG_TAG = scm_make_smob_type("msg", sizeof(MuMsgWrapper));
scm_set_smob_mark (MSG_TAG, msg_mark);
scm_set_smob_free (MSG_TAG, msg_free);
scm_set_smob_print (MSG_TAG, msg_print);
scm_set_smob_mark(MSG_TAG, msg_mark);
scm_set_smob_free(MSG_TAG, msg_free);
scm_set_smob_print(MSG_TAG, msg_print);
define_vars ();
define_symbols ();
define_vars();
define_symbols();
#ifndef SCM_MAGIC_SNARFER
#include "mu-guile-message.x"

4
guile/mu-guile-message.hh
View File

@ -27,6 +27,8 @@
*
* @return
*/
extern "C" { void* mu_guile_message_init (void *data);}
extern "C" {
void* mu_guile_message_init(void* data);
}
#endif /*MU_GUILE_MESSAGE_HH__*/

181
guile/mu-guile.cc
View File

@ -36,58 +36,58 @@
using namespace Mu;
SCM
mu_guile_scm_from_str (const char *str)
mu_guile_scm_from_str(const char* str)
{
if (!str)
return SCM_BOOL_F;
else
return scm_from_stringn (str, strlen(str), "UTF-8",
SCM_FAILED_CONVERSION_QUESTION_MARK);
return scm_from_stringn(str,
strlen(str),
"UTF-8",
SCM_FAILED_CONVERSION_QUESTION_MARK);
}
SCM
mu_guile_error (const char *func_name, int status,
const char *fmt, SCM args)
mu_guile_error(const char* func_name, int status, const char* fmt, SCM args)
{
scm_error_scm (scm_from_locale_symbol ("MuError"),
scm_from_utf8_string (func_name ? func_name : "<nameless>"),
scm_from_utf8_string (fmt), args,
scm_list_1 (scm_from_int (status)));
scm_error_scm(scm_from_locale_symbol("MuError"),
scm_from_utf8_string(func_name ? func_name : "<nameless>"),
scm_from_utf8_string(fmt),
args,
scm_list_1(scm_from_int(status)));
return SCM_UNSPECIFIED;
}
SCM
mu_guile_g_error (const char *func_name, GError *err)
mu_guile_g_error(const char* func_name, GError* err)
{
scm_error_scm (scm_from_locale_symbol ("MuError"),
scm_from_utf8_string (func_name),
scm_from_utf8_string (err ? err->message : "error"),
SCM_UNDEFINED, SCM_UNDEFINED);
scm_error_scm(scm_from_locale_symbol("MuError"),
scm_from_utf8_string(func_name),
scm_from_utf8_string(err ? err->message : "error"),
SCM_UNDEFINED,
SCM_UNDEFINED);
return SCM_UNSPECIFIED;
}
/* there can be only one */
static std::unique_ptr<Mu::Store> StoreSingleton;
static gboolean
mu_guile_init_instance (const char *muhome) try
{
setlocale (LC_ALL, "");
if (!mu_runtime_init (muhome, "guile", true) || StoreSingleton)
mu_guile_init_instance(const char* muhome)
try {
setlocale(LC_ALL, "");
if (!mu_runtime_init(muhome, "guile", true) || StoreSingleton)
return FALSE;
StoreSingleton = std::make_unique<Mu::Store>(
mu_runtime_path(MU_RUNTIME_PATH_XAPIANDB));
StoreSingleton = std::make_unique<Mu::Store>(mu_runtime_path(MU_RUNTIME_PATH_XAPIANDB));
g_debug ("mu-guile: opened store @ %s (n=%zu); maildir: %s",
StoreSingleton->metadata().database_path.c_str(),
StoreSingleton->size(),
StoreSingleton->metadata().root_maildir.c_str());
g_debug("mu-guile: opened store @ %s (n=%zu); maildir: %s",
StoreSingleton->metadata().database_path.c_str(),
StoreSingleton->size(),
StoreSingleton->metadata().root_maildir.c_str());
return TRUE;
@ -96,16 +96,15 @@ mu_guile_init_instance (const char *muhome) try
}
static void
mu_guile_uninit_instance ()
mu_guile_uninit_instance()
{
StoreSingleton.reset();
mu_runtime_uninit ();
mu_runtime_uninit();
}
Mu::Store&
mu_guile_store ()
mu_guile_store()
{
if (!StoreSingleton)
g_error("mu guile not initialized");
@ -114,124 +113,130 @@ mu_guile_store ()
}
gboolean
mu_guile_initialized ()
mu_guile_initialized()
{
g_debug ("initialized ? %u", !!StoreSingleton);
g_debug("initialized ? %u", !!StoreSingleton);
return !!StoreSingleton;
}
SCM_DEFINE_PUBLIC (mu_initialize, "mu:initialize", 0, 1, 0,
(SCM MUHOME),
"Initialize mu - needed before you call any of the other "
"functions. Optionally, you can provide MUHOME which should be an "
"absolute path to your mu home directory "
"-- typically, the default, ~/.cache/mu, should be just fine.")
SCM_DEFINE_PUBLIC(mu_initialize,
"mu:initialize",
0,
1,
0,
(SCM MUHOME),
"Initialize mu - needed before you call any of the other "
"functions. Optionally, you can provide MUHOME which should be an "
"absolute path to your mu home directory "
"-- typically, the default, ~/.cache/mu, should be just fine.")
#define FUNC_NAME s_mu_initialize
{
char *muhome;
char* muhome;
gboolean rv;
SCM_ASSERT (scm_is_string (MUHOME) || MUHOME == SCM_BOOL_F ||
SCM_UNBNDP(MUHOME), MUHOME, SCM_ARG1, FUNC_NAME);
SCM_ASSERT(scm_is_string(MUHOME) || MUHOME == SCM_BOOL_F || SCM_UNBNDP(MUHOME),
MUHOME,
SCM_ARG1,
FUNC_NAME);
if (mu_guile_initialized())
return mu_guile_error (FUNC_NAME, 0, "Already initialized",
SCM_UNSPECIFIED);
return mu_guile_error(FUNC_NAME, 0, "Already initialized", SCM_UNSPECIFIED);
if (SCM_UNBNDP(MUHOME) || MUHOME == SCM_BOOL_F)
muhome = NULL;
else
muhome = scm_to_utf8_string (MUHOME);
muhome = scm_to_utf8_string(MUHOME);
rv = mu_guile_init_instance (muhome);
free (muhome);
rv = mu_guile_init_instance(muhome);
free(muhome);
if (!rv)
return mu_guile_error (FUNC_NAME, 0, "Failed to initialize mu",
SCM_UNSPECIFIED);
return mu_guile_error(FUNC_NAME, 0, "Failed to initialize mu", SCM_UNSPECIFIED);
g_debug ("mu-guile: initialized @ %s (%p)",
muhome ? muhome : "<default>", StoreSingleton.get());
g_debug("mu-guile: initialized @ %s (%p)",
muhome ? muhome : "<default>",
StoreSingleton.get());
/* cleanup when we're exiting */
atexit (mu_guile_uninit_instance);
atexit(mu_guile_uninit_instance);
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
SCM_DEFINE_PUBLIC (mu_initialized_p, "mu:initialized?", 0, 0, 0,
(void), "Whether mu is initialized or not.\n")
SCM_DEFINE_PUBLIC(mu_initialized_p,
"mu:initialized?",
0,
0,
0,
(void),
"Whether mu is initialized or not.\n")
#define FUNC_NAME s_mu_initialized_p
{
return mu_guile_initialized() ? SCM_BOOL_T : SCM_BOOL_F;
}
#undef FUNC_NAME
SCM_DEFINE (log_func, "mu:c:log", 1, 0, 1, (SCM LEVEL, SCM FRM, SCM ARGS),
"log some message at LEVEL using a list of ARGS applied to FRM"
"(in 'simple-format' notation).\n")
SCM_DEFINE(log_func,
"mu:c:log",
1,
0,
1,
(SCM LEVEL, SCM FRM, SCM ARGS),
"log some message at LEVEL using a list of ARGS applied to FRM"
"(in 'simple-format' notation).\n")
#define FUNC_NAME s_log_func
{
gchar *output;
SCM str;
int level;
gchar* output;
SCM str;
int level;
SCM_ASSERT (scm_integer_p(LEVEL), LEVEL, SCM_ARG1, FUNC_NAME);
SCM_ASSERT (scm_is_string(FRM), FRM, SCM_ARG2, "<write_log>");
SCM_ASSERT(scm_integer_p(LEVEL), LEVEL, SCM_ARG1, FUNC_NAME);
SCM_ASSERT(scm_is_string(FRM), FRM, SCM_ARG2, "<write_log>");
SCM_VALIDATE_REST_ARGUMENT(ARGS);
level = scm_to_int (LEVEL);
if (level != G_LOG_LEVEL_MESSAGE &&
level != G_LOG_LEVEL_WARNING &&
level = scm_to_int(LEVEL);
if (level != G_LOG_LEVEL_MESSAGE && level != G_LOG_LEVEL_WARNING &&
level != G_LOG_LEVEL_CRITICAL)
return mu_guile_error (FUNC_NAME, 0, "invalid log level",
SCM_UNSPECIFIED);
return mu_guile_error(FUNC_NAME, 0, "invalid log level", SCM_UNSPECIFIED);
str = scm_simple_format (SCM_BOOL_F, FRM, ARGS);
str = scm_simple_format(SCM_BOOL_F, FRM, ARGS);
if (!scm_is_string (str))
if (!scm_is_string(str))
return SCM_UNSPECIFIED;
output = scm_to_utf8_string (str);
g_log (G_LOG_DOMAIN, (GLogLevelFlags)level, "%s", output);
free (output);
output = scm_to_utf8_string(str);
g_log(G_LOG_DOMAIN, (GLogLevelFlags)level, "%s", output);
free(output);
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
static struct {
static struct {
const char* name;
unsigned val;
unsigned val;
} VAR_PAIRS[] = {
{ "mu:message", G_LOG_LEVEL_MESSAGE },
{ "mu:warning", G_LOG_LEVEL_WARNING },
{ "mu:critical", G_LOG_LEVEL_CRITICAL }
};
{"mu:message", G_LOG_LEVEL_MESSAGE},
{"mu:warning", G_LOG_LEVEL_WARNING},
{"mu:critical", G_LOG_LEVEL_CRITICAL}};
static void
define_vars (void)
define_vars(void)
{
unsigned u;
for (u = 0; u != G_N_ELEMENTS(VAR_PAIRS); ++u) {
scm_c_define (VAR_PAIRS[u].name,
scm_from_uint (VAR_PAIRS[u].val));
scm_c_export (VAR_PAIRS[u].name, NULL);
scm_c_define(VAR_PAIRS[u].name, scm_from_uint(VAR_PAIRS[u].val));
scm_c_export(VAR_PAIRS[u].name, NULL);
}
}
void*
mu_guile_init (void *data)
mu_guile_init(void* data)
{
define_vars ();
define_vars();
#ifndef SCM_MAGIC_SNARFER
#include "mu-guile.x"

20
guile/mu-guile.hh
View File

@ -24,20 +24,17 @@
#include <libguile.h>
#include <mu-query.hh>
/**
* get the singleton Store instance
*/
Mu::Store& mu_guile_store ();
Mu::Store& mu_guile_store();
/**
* whether mu-guile is initialized
*
* @return TRUE if MuGuile is Initialized, FALSE otherwise
*/
gboolean mu_guile_initialized ();
gboolean mu_guile_initialized();
/**
* raise a guile error (based on a GError)
@ -47,8 +44,7 @@ gboolean mu_guile_initialized ();
*
* @return SCM_UNSPECIFIED
*/
SCM mu_guile_g_error (const char *func_name, GError *err);
SCM mu_guile_g_error(const char* func_name, GError* err);
/**
* raise a guile error
@ -60,9 +56,7 @@ SCM mu_guile_g_error (const char *func_name, GError *err);
*
* @return SCM_UNSPECIFIED
*/
SCM mu_guile_error (const char *func_name, int status,
const char *fmt, SCM args);
SCM mu_guile_error(const char* func_name, int status, const char* fmt, SCM args);
/**
* convert a const char* into an SCM -- either a string or, if str ==
@ -73,7 +67,7 @@ SCM mu_guile_error (const char *func_name, int status,
*
* @return a guile string or #f
*/
SCM mu_guile_scm_from_str (const char *str);
SCM mu_guile_scm_from_str(const char* str);
/**
* Initialize this mu guile module.
@ -82,5 +76,7 @@ SCM mu_guile_scm_from_str (const char *str);
*
* @return
*/
extern "C" { void* mu_guile_init (void *data); }
extern "C" {
void* mu_guile_init(void* data);
}
#endif /*__MU_GUILE_H__*/

110
guile/tests/test-mu-guile.cc
View File

@ -32,105 +32,103 @@
#include "test-mu-common.hh"
#include <lib/mu-store.hh>
/* Tests For The command line interface, uses testdir2 */
static gchar*
fill_database (void)
fill_database(void)
{
gchar *cmdline, *tmpdir;
GError *err;
gchar * cmdline, *tmpdir;
GError* err;
tmpdir = test_mu_common_get_random_tmpdir();
cmdline = g_strdup_printf (
"/bin/sh -c '"
"%s init --muhome=%s --maildir=%s --quiet; "
"%s index --muhome=%s --quiet'",
MU_PROGRAM, tmpdir, MU_TESTMAILDIR2,
MU_PROGRAM, tmpdir);
tmpdir = test_mu_common_get_random_tmpdir();
cmdline = g_strdup_printf("/bin/sh -c '"
"%s init --muhome=%s --maildir=%s --quiet; "
"%s index --muhome=%s --quiet'",
MU_PROGRAM,
tmpdir,
MU_TESTMAILDIR2,
MU_PROGRAM,
tmpdir);
if (g_test_verbose())
g_print ("%s\n", cmdline);
g_print("%s\n", cmdline);
err = NULL;
if (!g_spawn_command_line_sync (cmdline, NULL, NULL,
NULL, &err)) {
g_printerr ("Error: %s\n", err ? err->message : "?");
g_assert (0);
err = NULL;
if (!g_spawn_command_line_sync(cmdline, NULL, NULL, NULL, &err)) {
g_printerr("Error: %s\n", err ? err->message : "?");
g_assert(0);
}
g_free (cmdline);
g_free(cmdline);
return tmpdir;
}
static void
test_something (const char *what)
test_something(const char* what)
{
char *dir, *cmdline;
gint result;
gint result;
dir = fill_database ();
cmdline = g_strdup_printf (
"GUILE_AUTO_COMPILE=0 "
"LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH "
"%s -q -L %s -e main %s/test-mu-guile.scm "
"--muhome=%s --test=%s",
MU_GUILE_LIBRARY_PATH,
GUILE_BINARY,
MU_GUILE_MODULE_PATH,
ABS_SRCDIR,
dir,
what);
dir = fill_database();
cmdline = g_strdup_printf("GUILE_AUTO_COMPILE=0 "
"LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH "
"%s -q -L %s -e main %s/test-mu-guile.scm "
"--muhome=%s --test=%s",
MU_GUILE_LIBRARY_PATH,
GUILE_BINARY,
MU_GUILE_MODULE_PATH,
ABS_SRCDIR,
dir,
what);
if (g_test_verbose ())
g_print ("cmdline: %s\n", cmdline);
if (g_test_verbose())
g_print("cmdline: %s\n", cmdline);
result = system (cmdline);
g_assert (result == 0);
result = system(cmdline);
g_assert(result == 0);
g_free (dir);
g_free (cmdline);
g_free(dir);
g_free(cmdline);
}
static void
test_mu_guile_queries (void)
test_mu_guile_queries(void)
{
test_something ("queries");
test_something("queries");
}
static void
test_mu_guile_messages (void)
test_mu_guile_messages(void)
{
test_something ("message");
test_something("message");
}
static void
test_mu_guile_stats (void)
test_mu_guile_stats(void)
{
test_something ("stats");
test_something("stats");
}
int
main (int argc, char *argv[])
main(int argc, char* argv[])
{
int rv;
g_test_init (&argc, &argv, NULL);
g_test_init(&argc, &argv, NULL);
if (!set_en_us_utf8_locale())
return 0; /* don't error out... */
g_test_add_func ("/guile/queries", test_mu_guile_queries);
g_test_add_func ("/guile/message", test_mu_guile_messages);
g_test_add_func ("/guile/stats", test_mu_guile_stats);
g_test_add_func("/guile/queries", test_mu_guile_queries);
g_test_add_func("/guile/message", test_mu_guile_messages);
g_test_add_func("/guile/stats", test_mu_guile_stats);
g_log_set_handler (NULL,
(GLogLevelFlags)(G_LOG_LEVEL_MASK | G_LOG_LEVEL_WARNING|
G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION),
(GLogFunc)black_hole, NULL);
g_log_set_handler(NULL,
(GLogLevelFlags)(G_LOG_LEVEL_MASK | G_LOG_LEVEL_WARNING |
G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION),
(GLogFunc)black_hole,
NULL);
rv = g_test_run ();
rv = g_test_run();
return rv;
}