summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
0f314c0)
C99 stdbool turned 18 this year. There really is no reason to use our
own, except in the library interface for backward
compatibility. Convert the lib internally to stdbool.
17 files changed:
_notmuch_database_link_message (notmuch_database_t *notmuch,
notmuch_message_t *message,
notmuch_message_file_t *message_file,
_notmuch_database_link_message (notmuch_database_t *notmuch,
notmuch_message_t *message,
notmuch_message_file_t *message_file,
- notmuch_bool_t is_ghost)
{
void *local = talloc_new (NULL);
notmuch_status_t status;
{
void *local = talloc_new (NULL);
notmuch_status_t status;
notmuch_message_t *message = NULL;
notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS, ret2;
notmuch_private_status_t private_status;
notmuch_message_t *message = NULL;
notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS, ret2;
notmuch_private_status_t private_status;
- notmuch_bool_t is_ghost = FALSE, is_new = FALSE;
+ bool is_ghost = false, is_new = false;
const char *date;
const char *from, *to, *subject;
const char *date;
const char *from, *to, *subject;
/* We cannot call notmuch_message_get_flag for a new message */
switch (private_status) {
case NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND:
/* We cannot call notmuch_message_get_flag for a new message */
switch (private_status) {
case NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND:
- is_ghost = FALSE;
- is_new = TRUE;
+ is_ghost = false;
+ is_new = true;
break;
case NOTMUCH_PRIVATE_STATUS_SUCCESS:
is_ghost = notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_GHOST);
break;
case NOTMUCH_PRIVATE_STATUS_SUCCESS:
is_ghost = notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_GHOST);
break;
default:
ret = COERCE_STATUS (private_status,
break;
default:
ret = COERCE_STATUS (private_status,
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred adding message: %s.\n",
error.get_msg().c_str());
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred adding message: %s.\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
goto DONE;
}
ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
goto DONE;
}
} else if (STRNCMP_LITERAL (name, "retry_lock") == 0) {
return HAVE_XAPIAN_DB_RETRY_LOCK;
} else {
} else if (STRNCMP_LITERAL (name, "retry_lock") == 0) {
return HAVE_XAPIAN_DB_RETRY_LOCK;
} else {
db->set_metadata (CONFIG_PREFIX + key, value);
} catch (const Xapian::Error &error) {
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
db->set_metadata (CONFIG_PREFIX + key, value);
} catch (const Xapian::Error &error) {
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
_notmuch_database_log (notmuch, "Error: A Xapian exception occurred setting metadata: %s\n",
error.get_msg().c_str());
}
_notmuch_database_log (notmuch, "Error: A Xapian exception occurred setting metadata: %s\n",
error.get_msg().c_str());
}
value = notmuch->xapian_db->get_metadata (CONFIG_PREFIX + key);
} catch (const Xapian::Error &error) {
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
value = notmuch->xapian_db->get_metadata (CONFIG_PREFIX + key);
} catch (const Xapian::Error &error) {
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
_notmuch_database_log (notmuch, "Error: A Xapian exception occurred getting metadata: %s\n",
error.get_msg().c_str());
}
_notmuch_database_log (notmuch, "Error: A Xapian exception occurred getting metadata: %s\n",
error.get_msg().c_str());
}
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred getting metadata iterator: %s.\n",
error.get_msg().c_str());
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred getting metadata iterator: %s.\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
notmuch_config_list_valid (notmuch_config_list_t *metadata)
{
if (metadata->iterator == metadata->notmuch->xapian_db->metadata_keys_end ())
notmuch_config_list_valid (notmuch_config_list_t *metadata)
{
if (metadata->iterator == metadata->notmuch->xapian_db->metadata_keys_end ())
Xapian::QueryParser::FLAG_PURE_NOT)
struct _notmuch_database {
Xapian::QueryParser::FLAG_PURE_NOT)
struct _notmuch_database {
- notmuch_bool_t exception_reported;
+ bool exception_reported;
char *path;
notmuch_database_mode_t mode;
int atomic_nesting;
char *path;
notmuch_database_mode_t mode;
int atomic_nesting;
- /* TRUE if changes have been made in this atomic section */
- notmuch_bool_t atomic_dirty;
+ /* true if changes have been made in this atomic section */
+ bool atomic_dirty;
Xapian::Database *xapian_db;
/* Bit mask of features used by this database. This is a
Xapian::Database *xapian_db;
/* Bit mask of features used by this database. This is a
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred finding message: %s.\n",
error.get_msg().c_str());
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred finding message: %s.\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
*message_ret = NULL;
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
*message_ret = NULL;
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
* committed revision number until we commit the atomic section.
*/
if (notmuch->atomic_nesting)
* committed revision number until we commit the atomic section.
*/
if (notmuch->atomic_nesting)
- notmuch->atomic_dirty = TRUE;
+ notmuch->atomic_dirty = true;
else
notmuch->revision = new_revision;
else
notmuch->revision = new_revision;
}
notmuch = talloc_zero (NULL, notmuch_database_t);
}
notmuch = talloc_zero (NULL, notmuch_database_t);
- notmuch->exception_reported = FALSE;
+ notmuch->exception_reported = false;
notmuch->status_string = NULL;
notmuch->path = talloc_strdup (notmuch, path);
notmuch->status_string = NULL;
notmuch->path = talloc_strdup (notmuch, path);
if (! notmuch->exception_reported) {
_notmuch_database_log (notmuch, "Error: A Xapian exception reopening database: %s\n",
error.get_msg ().c_str ());
if (! notmuch->exception_reported) {
_notmuch_database_log (notmuch, "Error: A Xapian exception reopening database: %s\n",
error.get_msg ().c_str ());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
}
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
}
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
notmuch_database_t *notmuch = NULL;
struct stat statbuf;
notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
notmuch_database_t *notmuch = NULL;
struct stat statbuf;
- notmuch_bool_t keep_backup;
char *message = NULL;
local = talloc_new (NULL);
char *message = NULL;
local = talloc_new (NULL);
ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
goto DONE;
}
}
if (stat (backup_path, &statbuf) != -1) {
}
if (stat (backup_path, &statbuf) != -1) {
Xapian::WritableDatabase *db;
struct sigaction action;
struct itimerval timerval;
Xapian::WritableDatabase *db;
struct sigaction action;
struct itimerval timerval;
- notmuch_bool_t timer_is_active = FALSE;
+ bool timer_is_active = false;
enum _notmuch_features target_features, new_features;
notmuch_status_t status;
notmuch_private_status_t private_status;
enum _notmuch_features target_features, new_features;
notmuch_status_t status;
notmuch_private_status_t private_status;
timerval.it_value.tv_usec = 0;
setitimer (ITIMER_REAL, &timerval, NULL);
timerval.it_value.tv_usec = 0;
setitimer (ITIMER_REAL, &timerval, NULL);
- timer_is_active = TRUE;
+ timer_is_active = true;
}
/* Figure out how much total work we need to do. */
}
/* Figure out how much total work we need to do. */
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred beginning transaction: %s.\n",
error.get_msg().c_str());
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred beginning transaction: %s.\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred committing transaction: %s.\n",
error.get_msg().c_str());
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred committing transaction: %s.\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
if (notmuch->atomic_dirty) {
++notmuch->revision;
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
if (notmuch->atomic_dirty) {
++notmuch->revision;
- notmuch->atomic_dirty = FALSE;
+ notmuch->atomic_dirty = false;
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred getting directory: %s.\n",
error.get_msg().c_str());
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "A Xapian exception occurred getting directory: %s.\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
return status;
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
return status;
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "Error: A Xapian exception occurred finding message by filename: %s\n",
error.get_msg().c_str());
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch, "Error: A Xapian exception occurred finding message by filename: %s\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
} catch (const Xapian::Error &error) {
_notmuch_database_log (db, "A Xapian exception occurred getting tags: %s.\n",
error.get_msg().c_str());
} catch (const Xapian::Error &error) {
_notmuch_database_log (db, "A Xapian exception occurred getting tags: %s.\n",
error.get_msg().c_str());
- db->exception_reported = TRUE;
+ db->exception_reported = true;
notmuch_directory_t *directory;
notmuch_private_status_t private_status;
const char *db_path;
notmuch_directory_t *directory;
notmuch_private_status_t private_status;
const char *db_path;
- notmuch_bool_t create = (flags & NOTMUCH_FIND_CREATE);
+ bool create = (flags & NOTMUCH_FIND_CREATE);
if (! (notmuch->features & NOTMUCH_FEATURE_DIRECTORY_DOCS)) {
*status_ret = NOTMUCH_STATUS_UPGRADE_REQUIRED;
if (! (notmuch->features & NOTMUCH_FEATURE_DIRECTORY_DOCS)) {
*status_ret = NOTMUCH_STATUS_UPGRADE_REQUIRED;
_notmuch_database_log (notmuch,
"A Xapian exception occurred creating a directory: %s.\n",
error.get_msg().c_str());
_notmuch_database_log (notmuch,
"A Xapian exception occurred creating a directory: %s.\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
notmuch_directory_destroy (directory);
directory = NULL;
*status_ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
notmuch_directory_destroy (directory);
directory = NULL;
*status_ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
_notmuch_database_log (notmuch,
"A Xapian exception occurred setting directory mtime: %s.\n",
error.get_msg().c_str());
_notmuch_database_log (notmuch,
"A Xapian exception occurred setting directory mtime: %s.\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
_notmuch_database_log (directory->notmuch,
"A Xapian exception occurred deleting directory entry: %s.\n",
error.get_msg().c_str());
_notmuch_database_log (directory->notmuch,
"A Xapian exception occurred deleting directory entry: %s.\n",
error.get_msg().c_str());
- directory->notmuch->exception_reported = TRUE;
+ directory->notmuch->exception_reported = true;
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
notmuch_directory_destroy (directory);
status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
notmuch_directory_destroy (directory);
notmuch_filenames_valid (notmuch_filenames_t *filenames)
{
if (filenames == NULL)
notmuch_filenames_valid (notmuch_filenames_t *filenames)
{
if (filenames == NULL)
return (filenames->iterator != NULL);
}
return (filenames->iterator != NULL);
}
- g_mime_filter_set_size (gmime_filter, inlen, FALSE);
+ g_mime_filter_set_size (gmime_filter, inlen, false);
outptr = gmime_filter->outbuf;
next = filter->state;
outptr = gmime_filter->outbuf;
next = filter->state;
byte_array = g_byte_array_new ();
stream = g_mime_stream_mem_new_with_byte_array (byte_array);
byte_array = g_byte_array_new ();
stream = g_mime_stream_mem_new_with_byte_array (byte_array);
- g_mime_stream_mem_set_owner (GMIME_STREAM_MEM (stream), FALSE);
+ g_mime_stream_mem_set_owner (GMIME_STREAM_MEM (stream), false);
filter = g_mime_stream_filter_new (stream);
filter = g_mime_stream_filter_new (stream);
g_object_unref (discard_non_term_filter);
g_byte_array_append (byte_array, (guint8 *) "\0", 1);
g_object_unref (discard_non_term_filter);
g_byte_array_append (byte_array, (guint8 *) "\0", 1);
- body = (char *) g_byte_array_free (byte_array, FALSE);
+ body = (char *) g_byte_array_free (byte_array, false);
if (body) {
_notmuch_message_gen_terms (message, NULL, body);
if (body) {
_notmuch_message_gen_terms (message, NULL, body);
_is_mbox (FILE *file)
{
char from_buf[5];
_is_mbox (FILE *file)
{
char from_buf[5];
- notmuch_bool_t ret = FALSE;
/* Is this mbox? */
if (fread (from_buf, sizeof (from_buf), 1, file) == 1 &&
strncmp (from_buf, "From ", 5) == 0)
/* Is this mbox? */
if (fread (from_buf, sizeof (from_buf), 1, file) == 1 &&
strncmp (from_buf, "From ", 5) == 0)
GMimeParser *parser;
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
static int initialized = 0;
GMimeParser *parser;
notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
static int initialized = 0;
- notmuch_bool_t is_mbox;
if (message->message)
return NOTMUCH_STATUS_SUCCESS;
if (message->message)
return NOTMUCH_STATUS_SUCCESS;
stream = g_mime_stream_file_new (message->file);
/* We'll own and fclose the FILE* ourselves. */
stream = g_mime_stream_file_new (message->file);
/* We'll own and fclose the FILE* ourselves. */
- g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream), FALSE);
+ g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream), false);
parser = g_mime_parser_new_with_stream (stream);
g_mime_parser_set_scan_from (parser, is_mbox);
parser = g_mime_parser_new_with_stream (stream);
g_mime_parser_set_scan_from (parser, is_mbox);
notmuch_string_map_t *
_notmuch_message_property_map (notmuch_message_t *message);
notmuch_string_map_t *
_notmuch_message_property_map (notmuch_message_t *message);
_notmuch_message_frozen (notmuch_message_t *message);
void
_notmuch_message_frozen (notmuch_message_t *message);
void
static notmuch_status_t
_notmuch_message_modify_property (notmuch_message_t *message, const char *key, const char *value,
static notmuch_status_t
_notmuch_message_modify_property (notmuch_message_t *message, const char *key, const char *value,
- notmuch_bool_t delete_it)
{
notmuch_private_status_t private_status;
notmuch_status_t status;
{
notmuch_private_status_t private_status;
notmuch_status_t status;
notmuch_status_t
notmuch_message_add_property (notmuch_message_t *message, const char *key, const char *value)
{
notmuch_status_t
notmuch_message_add_property (notmuch_message_t *message, const char *key, const char *value)
{
- return _notmuch_message_modify_property (message, key, value, FALSE);
+ return _notmuch_message_modify_property (message, key, value, false);
}
notmuch_status_t
notmuch_message_remove_property (notmuch_message_t *message, const char *key, const char *value)
{
}
notmuch_status_t
notmuch_message_remove_property (notmuch_message_t *message, const char *key, const char *value)
{
- return _notmuch_message_modify_property (message, key, value, TRUE);
+ return _notmuch_message_modify_property (message, key, value, true);
unsigned long lazy_flags;
/* Message document modified since last sync */
unsigned long lazy_flags;
/* Message document modified since last sync */
- notmuch_bool_t modified;
/* last view of database the struct is synced with */
unsigned long last_view;
/* last view of database the struct is synced with */
unsigned long last_view;
struct maildir_flag_tag {
char flag;
const char *tag;
struct maildir_flag_tag {
char flag;
const char *tag;
- notmuch_bool_t inverse;
};
/* ASCII ordered table of Maildir flags and associated tags */
static struct maildir_flag_tag flag2tag[] = {
};
/* ASCII ordered table of Maildir flags and associated tags */
static struct maildir_flag_tag flag2tag[] = {
- { 'D', "draft", FALSE},
- { 'F', "flagged", FALSE},
- { 'P', "passed", FALSE},
- { 'R', "replied", FALSE},
- { 'S', "unread", TRUE }
+ { 'D', "draft", false},
+ { 'F', "flagged", false},
+ { 'P', "passed", false},
+ { 'R', "replied", false},
+ { 'S', "unread", true }
};
/* We end up having to call the destructor explicitly because we had
};
/* We end up having to call the destructor explicitly because we had
} catch (const Xapian::Error &error) {
_notmuch_database_log(_notmuch_message_database (message), "A Xapian exception occurred creating message: %s\n",
error.get_msg().c_str());
} catch (const Xapian::Error &error) {
_notmuch_database_log(_notmuch_message_database (message), "A Xapian exception occurred creating message: %s\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
*status_ret = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION;
return NULL;
}
*status_ret = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION;
return NULL;
}
} catch (Xapian::Error &error) {
_notmuch_database_log(_notmuch_message_database (message), "A Xapian exception occurred when reading header: %s\n",
error.get_msg().c_str());
} catch (Xapian::Error &error) {
_notmuch_database_log(_notmuch_message_database (message), "A Xapian exception occurred when reading header: %s\n",
error.get_msg().c_str());
- message->notmuch->exception_reported = TRUE;
+ message->notmuch->exception_reported = true;
try {
message->doc.remove_term ((*i));
try {
message->doc.remove_term ((*i));
- message->modified = TRUE;
+ message->modified = true;
} catch (const Xapian::InvalidArgumentError) {
/* Ignore failure to remove non-existent term. */
}
} catch (const Xapian::InvalidArgumentError) {
/* Ignore failure to remove non-existent term. */
}
try {
message->doc.remove_term ((*i));
try {
message->doc.remove_term ((*i));
- message->modified = TRUE;
+ message->modified = true;
} catch (const Xapian::InvalidArgumentError) {
/* Ignore failure to remove non-existent term. */
} catch (const Xapian::Error &error) {
} catch (const Xapian::InvalidArgumentError) {
/* Ignore failure to remove non-existent term. */
} catch (const Xapian::Error &error) {
if (!notmuch->exception_reported) {
_notmuch_database_log(_notmuch_message_database (message), "A Xapian exception occurred creating message: %s\n",
error.get_msg().c_str());
if (!notmuch->exception_reported) {
_notmuch_database_log(_notmuch_message_database (message), "A Xapian exception occurred creating message: %s\n",
error.get_msg().c_str());
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
}
return NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION;
}
}
return NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION;
}
- message->modified = TRUE;
+ message->modified = true;
return NOTMUCH_STATUS_SUCCESS;
}
return NOTMUCH_STATUS_SUCCESS;
}
_notmuch_message_clear_data (notmuch_message_t *message)
{
message->doc.set_data ("");
_notmuch_message_clear_data (notmuch_message_t *message)
{
message->doc.set_data ("");
- message->modified = TRUE;
+ message->modified = true;
} catch (Xapian::Error &error) {
_notmuch_database_log(_notmuch_message_database (message), "A Xapian exception occurred when reading date: %s\n",
error.get_msg().c_str());
} catch (Xapian::Error &error) {
_notmuch_database_log(_notmuch_message_database (message), "A Xapian exception occurred when reading date: %s\n",
error.get_msg().c_str());
- message->notmuch->exception_reported = TRUE;
+ message->notmuch->exception_reported = true;
Xapian::sortable_serialise (time_value));
message->doc.add_value (NOTMUCH_VALUE_FROM, from);
message->doc.add_value (NOTMUCH_VALUE_SUBJECT, subject);
Xapian::sortable_serialise (time_value));
message->doc.add_value (NOTMUCH_VALUE_FROM, from);
message->doc.add_value (NOTMUCH_VALUE_SUBJECT, subject);
- message->modified = TRUE;
+ message->modified = true;
}
/* Upgrade a message to support NOTMUCH_FEATURE_LAST_MOD. The caller
}
/* Upgrade a message to support NOTMUCH_FEATURE_LAST_MOD. The caller
{
/* _notmuch_message_sync will update the last modification
* revision; we just have to ask it to. */
{
/* _notmuch_message_sync will update the last modification
* revision; we just have to ask it to. */
- message->modified = TRUE;
+ message->modified = true;
}
/* Synchronize changes made to message->doc out into the database. */
}
/* Synchronize changes made to message->doc out into the database. */
db = static_cast <Xapian::WritableDatabase *> (message->notmuch->xapian_db);
db->replace_document (message->doc_id, message->doc);
db = static_cast <Xapian::WritableDatabase *> (message->notmuch->xapian_db);
db->replace_document (message->doc_id, message->doc);
- message->modified = FALSE;
+ message->modified = false;
}
/* Delete a message document from the database, leaving a ghost
}
/* Delete a message document from the database, leaving a ghost
notmuch_database_t *notmuch;
notmuch_query_t *query;
unsigned int count = 0;
notmuch_database_t *notmuch;
notmuch_query_t *query;
unsigned int count = 0;
- notmuch_bool_t is_ghost;
mid = notmuch_message_get_message_id (message);
tid = notmuch_message_get_thread_id (message);
mid = notmuch_message_get_message_id (message);
tid = notmuch_message_get_thread_id (message);
return NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG;
message->doc.add_term (term, 0);
return NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG;
message->doc.add_term (term, 0);
- message->modified = TRUE;
+ message->modified = true;
try {
message->doc.remove_term (term);
try {
message->doc.remove_term (term);
- message->modified = TRUE;
+ message->modified = true;
} catch (const Xapian::InvalidArgumentError) {
/* We'll let the philosophers try to wrestle with the
* question of whether failing to remove that which was not
} catch (const Xapian::InvalidArgumentError) {
/* We'll let the philosophers try to wrestle with the
* question of whether failing to remove that which was not
_notmuch_message_has_term (notmuch_message_t *message,
const char *prefix_name,
const char *value,
_notmuch_message_has_term (notmuch_message_t *message,
const char *prefix_name,
const char *value,
- notmuch_bool_t *result)
- notmuch_bool_t out = FALSE;
notmuch_private_status_t status = NOTMUCH_PRIVATE_STATUS_SUCCESS;
if (value == NULL)
notmuch_private_status_t status = NOTMUCH_PRIVATE_STATUS_SUCCESS;
if (value == NULL)
i.skip_to (term);
if (i != message->doc.termlist_end () &&
!strcmp ((*i).c_str (), term))
i.skip_to (term);
if (i != message->doc.termlist_end () &&
!strcmp ((*i).c_str (), term))
} catch (Xapian::Error &error) {
status = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION;
}
} catch (Xapian::Error &error) {
status = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION;
}
-_ensure_maildir_flags (notmuch_message_t *message, notmuch_bool_t force)
+_ensure_maildir_flags (notmuch_message_t *message, bool force)
{
const char *flags;
notmuch_filenames_t *filenames;
{
const char *flags;
notmuch_filenames_t *filenames;
notmuch_bool_t
notmuch_message_has_maildir_flag (notmuch_message_t *message, char flag)
{
notmuch_bool_t
notmuch_message_has_maildir_flag (notmuch_message_t *message, char flag)
{
- _ensure_maildir_flags (message, FALSE);
+ _ensure_maildir_flags (message, false);
return message->maildir_flags && (strchr (message->maildir_flags, flag) != NULL);
}
return message->maildir_flags && (strchr (message->maildir_flags, flag) != NULL);
}
notmuch_status_t status;
unsigned i;
notmuch_status_t status;
unsigned i;
- _ensure_maildir_flags (message, TRUE);
+ _ensure_maildir_flags (message, true);
/* If none of the filenames have any maildir info field (not even
* an empty info with no flags set) then there's no information to
* go on, so do nothing. */
/* If none of the filenames have any maildir info field (not even
* an empty info with no flags set) then there's no information to
* go on, so do nothing. */
char *filename_new, *dir;
char flag_map[128];
int flags_in_map = 0;
char *filename_new, *dir;
char flag_map[128];
int flags_in_map = 0;
- notmuch_bool_t flags_changed = FALSE;
+ bool flags_changed = false;
if (flag_map[flag] == 0) {
flag_map[flag] = 1;
flags_in_map++;
if (flag_map[flag] == 0) {
flag_map[flag] = 1;
flags_in_map++;
if (flag_map[flag]) {
flag_map[flag] = 0;
flags_in_map--;
if (flag_map[flag]) {
flag_map[flag] = 0;
flags_in_map--;
return message->property_map;
}
return message->property_map;
}
_notmuch_message_frozen (notmuch_message_t *message)
{
return message->frozen;
_notmuch_message_frozen (notmuch_message_t *message)
{
return message->frozen;
if (unlikely (messages == NULL))
return NULL;
if (unlikely (messages == NULL))
return NULL;
- messages->is_of_list_type = TRUE;
+ messages->is_of_list_type = true;
messages->iterator = list->head;
return messages;
messages->iterator = list->head;
return messages;
notmuch_messages_valid (notmuch_messages_t *messages)
{
if (messages == NULL)
notmuch_messages_valid (notmuch_messages_t *messages)
{
if (messages == NULL)
if (! messages->is_of_list_type)
return _notmuch_mset_messages_valid (messages);
if (! messages->is_of_list_type)
return _notmuch_mset_messages_valid (messages);
#ifndef _GNU_SOURCE
#define _GNU_SOURCE /* For getline and asprintf */
#endif
#ifndef _GNU_SOURCE
#define _GNU_SOURCE /* For getline and asprintf */
#endif
#include <stdio.h>
#include "compat.h"
#include <stdio.h>
#include "compat.h"
_notmuch_message_has_term (notmuch_message_t *message,
const char *prefix_name,
const char *value,
_notmuch_message_has_term (notmuch_message_t *message,
const char *prefix_name,
const char *value,
- notmuch_bool_t *result);
notmuch_private_status_t
_notmuch_message_gen_terms (notmuch_message_t *message,
notmuch_private_status_t
_notmuch_message_gen_terms (notmuch_message_t *message,
* ignorance of that here. (See notmuch_mset_messages_t in query.cc)
*/
struct _notmuch_messages {
* ignorance of that here. (See notmuch_mset_messages_t in query.cc)
*/
struct _notmuch_messages {
- notmuch_bool_t is_of_list_type;
notmuch_doc_id_set_t *excluded_doc_ids;
notmuch_message_node_t *iterator;
};
notmuch_doc_id_set_t *excluded_doc_ids;
notmuch_message_node_t *iterator;
};
_notmuch_mset_messages_valid (notmuch_messages_t *messages);
notmuch_message_t *
_notmuch_mset_messages_valid (notmuch_messages_t *messages);
notmuch_message_t *
void
_notmuch_mset_messages_move_to_next (notmuch_messages_t *messages);
void
_notmuch_mset_messages_move_to_next (notmuch_messages_t *messages);
_notmuch_doc_id_set_contains (notmuch_doc_id_set_t *doc_ids,
unsigned int doc_id);
_notmuch_doc_id_set_contains (notmuch_doc_id_set_t *doc_ids,
unsigned int doc_id);
notmuch_string_map_iterator_t *
_notmuch_string_map_iterator_create (notmuch_string_map_t *map, const char *key,
notmuch_string_map_iterator_t *
_notmuch_string_map_iterator_create (notmuch_string_map_t *map, const char *key,
_notmuch_string_map_iterator_valid (notmuch_string_map_iterator_t *iter);
void
_notmuch_string_map_iterator_valid (notmuch_string_map_iterator_t *iter);
void
notmuch_sort_t sort;
notmuch_string_list_t *exclude_terms;
notmuch_exclude_t omit_excluded;
notmuch_sort_t sort;
notmuch_string_list_t *exclude_terms;
notmuch_exclude_t omit_excluded;
Xapian::Query xapian_query;
std::set<std::string> terms;
};
Xapian::Query xapian_query;
std::set<std::string> terms;
};
};
/* We need this in the message functions so forward declare. */
};
/* We need this in the message functions so forward declare. */
_notmuch_doc_id_set_init (void *ctx,
notmuch_doc_id_set_t *doc_ids,
GArray *arr);
_notmuch_doc_id_set_init (void *ctx,
notmuch_doc_id_set_t *doc_ids,
GArray *arr);
_debug_query (void)
{
char *env = getenv ("NOTMUCH_DEBUG_QUERY");
_debug_query (void)
{
char *env = getenv ("NOTMUCH_DEBUG_QUERY");
new (&query->xapian_query) Xapian::Query ();
new (&query->terms) std::set<std::string> ();
new (&query->xapian_query) Xapian::Query ();
new (&query->terms) std::set<std::string> ();
talloc_set_destructor (query, _notmuch_query_destructor);
talloc_set_destructor (query, _notmuch_query_destructor);
t != query->xapian_query.get_terms_end (); ++t)
query->terms.insert (*t);
t != query->xapian_query.get_terms_end (); ++t)
query->terms.insert (*t);
} catch (const Xapian::Error &error) {
if (!query->notmuch->exception_reported) {
} catch (const Xapian::Error &error) {
if (!query->notmuch->exception_reported) {
_notmuch_database_log_append (query->notmuch,
"Query string was: %s\n",
query->query_string);
_notmuch_database_log_append (query->notmuch,
"Query string was: %s\n",
query->query_string);
- query->notmuch->exception_reported = TRUE;
+ query->notmuch->exception_reported = true;
}
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
- messages->base.is_of_list_type = FALSE;
+ messages->base.is_of_list_type = false;
messages->base.iterator = NULL;
messages->notmuch = notmuch;
new (&messages->iterator) Xapian::MSetIterator ();
messages->base.iterator = NULL;
messages->notmuch = notmuch;
new (&messages->iterator) Xapian::MSetIterator ();
mset = enquire.get_mset (0, notmuch->xapian_db->get_doccount ());
mset = enquire.get_mset (0, notmuch->xapian_db->get_doccount ());
- GArray *excluded_doc_ids = g_array_new (FALSE, FALSE, sizeof (unsigned int));
+ GArray *excluded_doc_ids = g_array_new (false, false, sizeof (unsigned int));
for (iterator = mset.begin (); iterator != mset.end (); iterator++) {
unsigned int doc_id = *iterator;
for (iterator = mset.begin (); iterator != mset.end (); iterator++) {
unsigned int doc_id = *iterator;
switch (query->sort) {
case NOTMUCH_SORT_OLDEST_FIRST:
switch (query->sort) {
case NOTMUCH_SORT_OLDEST_FIRST:
- enquire.set_sort_by_value (NOTMUCH_VALUE_TIMESTAMP, FALSE);
+ enquire.set_sort_by_value (NOTMUCH_VALUE_TIMESTAMP, false);
break;
case NOTMUCH_SORT_NEWEST_FIRST:
break;
case NOTMUCH_SORT_NEWEST_FIRST:
- enquire.set_sort_by_value (NOTMUCH_VALUE_TIMESTAMP, TRUE);
+ enquire.set_sort_by_value (NOTMUCH_VALUE_TIMESTAMP, true);
break;
case NOTMUCH_SORT_MESSAGE_ID:
break;
case NOTMUCH_SORT_MESSAGE_ID:
- enquire.set_sort_by_value (NOTMUCH_VALUE_MESSAGE_ID, FALSE);
+ enquire.set_sort_by_value (NOTMUCH_VALUE_MESSAGE_ID, false);
break;
case NOTMUCH_SORT_UNSORTED:
break;
break;
case NOTMUCH_SORT_UNSORTED:
break;
"Query string was: %s\n",
query->query_string);
"Query string was: %s\n",
query->query_string);
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
talloc_free (messages);
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
}
talloc_free (messages);
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
}
_notmuch_mset_messages_valid (notmuch_messages_t *messages)
{
notmuch_mset_messages_t *mset_messages;
_notmuch_mset_messages_valid (notmuch_messages_t *messages)
{
notmuch_mset_messages_t *mset_messages;
if (messages->excluded_doc_ids &&
_notmuch_doc_id_set_contains (messages->excluded_doc_ids, doc_id))
if (messages->excluded_doc_ids &&
_notmuch_doc_id_set_contains (messages->excluded_doc_ids, doc_id))
- notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, TRUE);
+ notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, true);
mset_messages->iterator++;
}
mset_messages->iterator++;
}
_notmuch_doc_id_set_init (void *ctx,
notmuch_doc_id_set_t *doc_ids,
GArray *arr)
_notmuch_doc_id_set_init (void *ctx,
notmuch_doc_id_set_t *doc_ids,
GArray *arr)
bitmap = talloc_zero_array (ctx, unsigned char, DOCIDSET_WORD(max) + 1);
if (bitmap == NULL)
bitmap = talloc_zero_array (ctx, unsigned char, DOCIDSET_WORD(max) + 1);
if (bitmap == NULL)
doc_ids->bitmap = bitmap;
doc_ids->bound = max + 1;
doc_ids->bitmap = bitmap;
doc_ids->bound = max + 1;
bitmap[DOCIDSET_WORD(doc_id)] |= 1 << DOCIDSET_BIT(doc_id);
}
bitmap[DOCIDSET_WORD(doc_id)] |= 1 << DOCIDSET_BIT(doc_id);
}
_notmuch_doc_id_set_contains (notmuch_doc_id_set_t *doc_ids,
unsigned int doc_id)
{
if (doc_id >= doc_ids->bound)
_notmuch_doc_id_set_contains (notmuch_doc_id_set_t *doc_ids,
unsigned int doc_id)
{
if (doc_id >= doc_ids->bound)
return doc_ids->bitmap[DOCIDSET_WORD(doc_id)] & (1 << DOCIDSET_BIT(doc_id));
}
return doc_ids->bitmap[DOCIDSET_WORD(doc_id)] & (1 << DOCIDSET_BIT(doc_id));
}
- threads->doc_ids = g_array_new (FALSE, FALSE, sizeof (unsigned int));
+ threads->doc_ids = g_array_new (false, false, sizeof (unsigned int));
while (notmuch_messages_valid (messages)) {
unsigned int doc_id = _notmuch_mset_messages_get_doc_id (messages);
g_array_append_val (threads->doc_ids, doc_id);
while (notmuch_messages_valid (messages)) {
unsigned int doc_id = _notmuch_mset_messages_get_doc_id (messages);
g_array_append_val (threads->doc_ids, doc_id);
unsigned int doc_id;
if (! threads)
unsigned int doc_id;
if (! threads)
while (threads->doc_id_pos < threads->doc_ids->len) {
doc_id = g_array_index (threads->doc_ids, unsigned int,
while (threads->doc_id_pos < threads->doc_ids->len) {
doc_id = g_array_index (threads->doc_ids, unsigned int,
} notmuch_string_pair_t;
struct _notmuch_string_map {
} notmuch_string_pair_t;
struct _notmuch_string_map {
size_t length;
notmuch_string_pair_t *pairs;
};
struct _notmuch_string_map_iterator {
notmuch_string_pair_t *current;
size_t length;
notmuch_string_pair_t *pairs;
};
struct _notmuch_string_map_iterator {
notmuch_string_pair_t *current;
map->length = 0;
map->pairs = NULL;
map->length = 0;
map->pairs = NULL;
if (map->pairs)
map->pairs = talloc_realloc (map, map->pairs, notmuch_string_pair_t, map->length + 1);
if (map->pairs)
map->pairs = talloc_realloc (map, map->pairs, notmuch_string_pair_t, map->length + 1);
qsort (map->pairs, map->length, sizeof (notmuch_string_pair_t), cmppair);
qsort (map->pairs, map->length, sizeof (notmuch_string_pair_t), cmppair);
-static notmuch_bool_t
-string_cmp (const char *a, const char *b, notmuch_bool_t exact)
+static bool
+string_cmp (const char *a, const char *b, bool exact)
{
if (exact)
return (strcmp (a, b));
{
if (exact)
return (strcmp (a, b));
}
static notmuch_string_pair_t *
}
static notmuch_string_pair_t *
-bsearch_first (notmuch_string_pair_t *array, size_t len, const char *key, notmuch_bool_t exact)
+bsearch_first (notmuch_string_pair_t *array, size_t len, const char *key, bool exact)
{
size_t first = 0;
size_t last = len - 1;
{
size_t first = 0;
size_t last = len - 1;
/* this means that calling append invalidates iterators */
_notmuch_string_map_sort (map);
/* this means that calling append invalidates iterators */
_notmuch_string_map_sort (map);
- pair = bsearch_first (map->pairs, map->length, key, TRUE);
+ pair = bsearch_first (map->pairs, map->length, key, true);
notmuch_string_map_iterator_t *
_notmuch_string_map_iterator_create (notmuch_string_map_t *map, const char *key,
notmuch_string_map_iterator_t *
_notmuch_string_map_iterator_create (notmuch_string_map_t *map, const char *key,
{
notmuch_string_map_iterator_t *iter;
{
notmuch_string_map_iterator_t *iter;
_notmuch_string_map_iterator_valid (notmuch_string_map_iterator_t *iterator)
{
if (iterator->current == NULL)
_notmuch_string_map_iterator_valid (notmuch_string_map_iterator_t *iterator)
{
if (iterator->current == NULL)
/* sentinel */
if (iterator->current->key == NULL)
/* sentinel */
if (iterator->current->key == NULL)
return (0 == string_cmp (iterator->key, iterator->current->key, iterator->exact));
return (0 == string_cmp (iterator->key, iterator->current->key, iterator->exact));
g_hash_table_unref (thread->message_hash);
if (thread->authors_array) {
g_hash_table_unref (thread->message_hash);
if (thread->authors_array) {
- g_ptr_array_free (thread->authors_array, TRUE);
+ g_ptr_array_free (thread->authors_array, true);
thread->authors_array = NULL;
}
if (thread->matched_authors_array) {
thread->authors_array = NULL;
}
if (thread->matched_authors_array) {
- g_ptr_array_free (thread->matched_authors_array, TRUE);
+ g_ptr_array_free (thread->matched_authors_array, true);
thread->matched_authors_array = NULL;
}
thread->matched_authors_array = NULL;
}
first_non_matched_author = 0;
}
first_non_matched_author = 0;
}
- g_ptr_array_free (thread->authors_array, TRUE);
+ g_ptr_array_free (thread->authors_array, true);
thread->authors_array = NULL;
thread->authors_array = NULL;
- g_ptr_array_free (thread->matched_authors_array, TRUE);
+ g_ptr_array_free (thread->matched_authors_array, true);
thread->matched_authors_array = NULL;
}
thread->matched_authors_array = NULL;
}
InternetAddress *address;
const char *from, *author;
char *clean_author;
InternetAddress *address;
const char *from, *author;
char *clean_author;
- notmuch_bool_t message_excluded = FALSE;
+ bool message_excluded = false;
if (omit_exclude != NOTMUCH_EXCLUDE_FALSE) {
for (tags = notmuch_message_get_tags (message);
if (omit_exclude != NOTMUCH_EXCLUDE_FALSE) {
for (tags = notmuch_message_get_tags (message);
{
/* Check for an empty string, and then ignore initial 'K'. */
if (*(term->string) && strcmp(tag, (term->string + 1)) == 0) {
{
/* Check for an empty string, and then ignore initial 'K'. */
if (*(term->string) && strcmp(tag, (term->string + 1)) == 0) {
- message_excluded = TRUE;
+ message_excluded = true;
/* Mark excluded messages. */
if (message_excluded)
/* Mark excluded messages. */
if (message_excluded)
- notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, TRUE);
+ notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, true);