if (MoreArgs(s))
{
- struct Buffer temporary = { 0 };
+ struct Buffer temporary = mutt_buffer_make(0);
mutt_extract_token(&temporary, s, MUTT_TOKEN_NO_FLAGS);
mutt_str_atoui(temporary.data, &match);
FREE(&temporary.data);
if ((mutt_get_field(":", buf, sizeof(buf), MUTT_COMMAND) != 0) || !buf[0])
return;
- struct Buffer err = { 0 };
- mutt_buffer_alloc(&err, 256);
- struct Buffer token = { 0 };
- mutt_buffer_alloc(&token, 256);
+ struct Buffer err = mutt_buffer_make(256);
+ struct Buffer token = mutt_buffer_make(256);
/* check if buf is a valid icommand, else fall back quietly to parse_rc_lines */
enum CommandResult rc = mutt_parse_icommand(buf, &err);
bool result = true;
- struct Buffer value = { 0 };
- mutt_buffer_alloc(&value, 256);
- struct Buffer initial = { 0 };
- mutt_buffer_alloc(&initial, 256);
- struct Buffer tmp = { 0 };
- mutt_buffer_alloc(&tmp, 256);
+ struct Buffer value = mutt_buffer_make(256);
+ struct Buffer initial = mutt_buffer_make(256);
+ struct Buffer tmp = mutt_buffer_make(256);
for (size_t i = 0; list[i]; i++)
{
if (!cs || !vars)
return false;
- struct Buffer err = { 0 };
+ struct Buffer err = mutt_buffer_make(0);
bool rc = true;
if (enc == ENC_QUOTED_PRINTABLE)
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
for (; it < end; it++)
{
if (*it == '_')
if (!pd || !*pd)
return;
- struct Buffer buf = { 0 }; /* Output buffer */
- char *s = *pd; /* Read pointer */
- char *beg = NULL; /* Begin of encoded word */
- enum ContentEncoding enc; /* ENC_BASE64 or ENC_QUOTED_PRINTABLE */
- char *charset = NULL; /* Which charset */
- size_t charsetlen; /* Length of the charset */
- char *text = NULL; /* Encoded text */
- size_t textlen; /* Length of encoded text */
+ struct Buffer buf = mutt_buffer_make(0); /* Output buffer */
+ char *s = *pd; /* Read pointer */
+ char *beg = NULL; /* Begin of encoded word */
+ enum ContentEncoding enc; /* ENC_BASE64 or ENC_QUOTED_PRINTABLE */
+ char *charset = NULL; /* Which charset */
+ size_t charsetlen; /* Length of the charset */
+ char *text = NULL; /* Encoded text */
+ size_t textlen; /* Length of encoded text */
/* Keep some state in case the next decoded word is using the same charset
* and it happens to be split in the middle of a multibyte character.
* See https://github.com/neomutt/neomutt/issues/1015 */
- struct Buffer prev = { 0 }; /* Previously decoded word */
+ struct Buffer prev = mutt_buffer_make(0); /* Previously decoded word */
char *prev_charset = NULL; /* Previously used charset */
size_t prev_charsetlen = 0; /* Length of the previously used charset */
void mutt_startup_shutdown_hook(HookFlags type)
{
struct Hook *hook = NULL;
- struct Buffer token = { 0 };
- struct Buffer err = { 0 };
+ struct Buffer token = mutt_buffer_make(0);
+ struct Buffer err = mutt_buffer_make(0);
char buf[256];
err.data = buf;
enum CommandResult rc = MUTT_CMD_ERROR;
struct Buffer *token = mutt_buffer_pool_get();
- struct Buffer expn = { 0 };
+ struct Buffer expn = mutt_buffer_make(0);
mutt_buffer_addstr(&expn, line);
expn.dptr = expn.data;
char key_binding[MAX_SEQ];
km_expand_key(key_binding, MAX_SEQ, map);
- struct Buffer tmp = { 0 };
+ struct Buffer tmp = mutt_buffer_make(0);
escape_string(&tmp, map->macro);
if (map->desc)
return MUTT_CMD_ERROR;
}
- struct Buffer filebuf = { 0 };
- mutt_buffer_alloc(&filebuf, 4096);
+ struct Buffer filebuf = mutt_buffer_make(4096);
if (dump_all || (mutt_str_strcasecmp(buf->data, "all") == 0))
{
dump_all_menus(&filebuf, bind);
{
char c;
bool r = false;
- struct Buffer buf = { 0 };
+ struct Buffer buf = { 0 }; // Do not allocate, maybe it won't be used
if (C_DebugLevel >= IMAP_LOG_LTRL)
mutt_buffer_alloc(&buf, bytes + 10);
int rc;
int count = 0;
- struct Buffer cmd = { 0 };
+ struct Buffer cmd = mutt_buffer_make(0);
/* We make a copy of the headers just in case resorting doesn't give
exactly the original order (duplicate messages?), because other parts of
if (imap_adata_find(dest, &dest_adata, &dest_mdata) < 0)
return -1;
- struct Buffer sync_cmd = { 0 };
+ struct Buffer sync_cmd = mutt_buffer_make(0);
/* check that the save-to folder is in the same account */
if (!mutt_account_match(&(adata->conn->account), &(dest_adata->conn->account)))
/* Remove old custom flags */
if (imap_edata_get(e)->flags_remote)
{
- struct Buffer cmd = { 0 };
+ struct Buffer cmd = mutt_buffer_make(128); // just a guess
mutt_buffer_addstr(&cmd, "UID STORE ");
mutt_buffer_addstr(&cmd, uid);
mutt_buffer_addstr(&cmd, " -FLAGS.SILENT (");
/* Add new custom flags */
if (buf)
{
- struct Buffer cmd = { 0 };
+ struct Buffer cmd = mutt_buffer_make(128); // just a guess
mutt_buffer_addstr(&cmd, "UID STORE ");
mutt_buffer_addstr(&cmd, uid);
mutt_buffer_addstr(&cmd, " +FLAGS.SILENT (");
return -1;
/* The seqset is likely large. Preallocate to reduce reallocs */
- struct Buffer b = { 0 };
- mutt_buffer_alloc(&b, 8192);
+ struct Buffer b = mutt_buffer_make(8192);
imap_msn_index_to_uid_seqset(&b, mdata);
int rc = mutt_hcache_store_raw(mdata->hcache, "/UIDSEQSET", 10, b.data,
unsigned long data, struct Buffer *err)
{
struct ReplaceList *list = (struct ReplaceList *) data;
- struct Buffer templ = { 0 };
+ struct Buffer templ = mutt_buffer_make(0);
/* First token is a regex. */
if (!MoreArgs(s))
static enum CommandResult parse_ifdef(struct Buffer *buf, struct Buffer *s,
unsigned long data, struct Buffer *err)
{
- struct Buffer token = { 0 };
+ struct Buffer token = mutt_buffer_make(0);
mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
{
char buf[1024];
int need_pause = 0;
- struct Buffer err = { 0 };
-
- mutt_buffer_alloc(&err, 256);
+ struct Buffer err = mutt_buffer_make(256);
mutt_grouplist_init();
/* reverse alias keys need to be strdup'ed because of idna conversions */
int i;
enum CommandResult rc = MUTT_CMD_SUCCESS;
- struct Buffer expn = { 0 };
+ struct Buffer expn = mutt_buffer_make(0);
mutt_buffer_addstr(&expn, line);
expn.dptr = expn.data;
*/
int mutt_query_variables(struct ListHead *queries)
{
- struct Buffer value = { 0 };
- mutt_buffer_alloc(&value, 256);
- struct Buffer tmp = { 0 };
- mutt_buffer_alloc(&tmp, 256);
+ struct Buffer value = mutt_buffer_make(256);
+ struct Buffer tmp = mutt_buffer_make(256);
int rc = 0;
struct ListNode *np = NULL;
myvarval = myvar_get(var);
if (myvarval)
{
- struct Buffer pretty = { 0 };
- mutt_buffer_alloc(&pretty, 256);
+ struct Buffer pretty = mutt_buffer_make(256);
pretty_var(myvarval, &pretty);
snprintf(pt, buflen - (pt - buf), "%s=%s", var, pretty.data);
mutt_buffer_dealloc(&pretty);
}
else
{
- struct Buffer value = { 0 };
- mutt_buffer_alloc(&value, 256);
- struct Buffer pretty = { 0 };
- mutt_buffer_alloc(&pretty, 256);
+ struct Buffer value = mutt_buffer_make(256);
+ struct Buffer pretty = mutt_buffer_make(256);
int rc = cs_he_string_get(Config, he, &value);
if (CSR_RESULT(rc) == CSR_SUCCESS)
{
"%s inv%s=42", "%s inv%s?", "%s &%s", "%s &%s=42", "%s &%s?",
};
- struct Buffer tmp = { 0 };
- mutt_buffer_alloc(&tmp, 256);
- struct Buffer err = { 0 };
- mutt_buffer_alloc(&err, 256);
+ struct Buffer tmp = mutt_buffer_make(256);
+ struct Buffer err = mutt_buffer_make(256);
char line[64];
for (size_t v = 0; v < mutt_array_size(vars); v++)
"record", "signature",
};
- struct Buffer value = { 0 };
- mutt_buffer_alloc(&value, 256);
+ struct Buffer value = mutt_buffer_make(256);
for (size_t i = 0; i < mutt_array_size(names); i++)
{
struct HashElem *he = cs_get_elem(cs, names[i]);
int double_dash = argc, nargc = 1;
int rc = 1;
bool repeat_error = false;
- struct Buffer folder = { 0 };
+ struct Buffer folder = mutt_buffer_make(0);
MuttLogger = log_disp_terminal;
if (new_magic)
{
- struct Buffer err = { 0 };
+ struct Buffer err = mutt_buffer_make(0);
int r = cs_str_initial_set(Config, "mbox_type", new_magic, &err);
if (CSR_RESULT(r) != CSR_SUCCESS)
{
return buf;
}
+/**
+ * mutt_buffer_make - Make a new buffer on the stack
+ * @param size Initial size
+ * @retval buf Initialized buffer
+ *
+ * The buffer must be released using mutt_buffer_dealloc
+ */
+struct Buffer mutt_buffer_make(size_t size)
+{
+ struct Buffer buf = { 0 };
+ if (size != 0)
+ {
+ buf.dptr = buf.data = mutt_mem_calloc(1, size);
+ buf.dsize = size;
+ }
+ return buf;
+}
+
/**
* mutt_buffer_reset - Reset an existing Buffer
* @param buf Buffer to reset
if (!buf || !buf->data)
return;
+ buf->dptr = NULL;
+ buf->dsize = 0;
FREE(&buf->data);
}
struct Buffer *mutt_buffer_init (struct Buffer *buf);
bool mutt_buffer_is_empty (const struct Buffer *buf);
size_t mutt_buffer_len (const struct Buffer *buf);
+struct Buffer mutt_buffer_make (size_t size);
void mutt_buffer_reset (struct Buffer *buf);
// Functions that APPEND to a Buffer
const char *basename = NULL;
int rc = 0;
- struct Buffer parent = { 0 };
- mutt_buffer_alloc(&parent, PATH_MAX);
+ struct Buffer parent = mutt_buffer_make(PATH_MAX);
mutt_buffer_strcpy(&parent, NONULL(path));
char *p = strrchr(parent.data, '/');
}
else
{
- struct Buffer abs_oldpath = { 0 };
- mutt_buffer_alloc(&abs_oldpath, PATH_MAX);
+ struct Buffer abs_oldpath = mutt_buffer_make(PATH_MAX);
if (!mutt_path_getcwd(&abs_oldpath))
{
/* We avoid using the buffer pool for this function, because it
* invokes recursively to an unknown depth. */
- struct Buffer cur = { 0 };
- mutt_buffer_alloc(&cur, PATH_MAX);
+ struct Buffer cur = mutt_buffer_make(PATH_MAX);
while ((de = readdir(dirp)))
{
struct stat osb, nsb;
int fd;
- struct Buffer safe_file = { 0 };
- struct Buffer safe_dir = { 0 };
+ struct Buffer safe_file = mutt_buffer_make(0);
+ struct Buffer safe_dir = mutt_buffer_make(0);
if (flags & O_EXCL)
{
*/
void mutt_buffer_file_expand_fmt_quote(struct Buffer *dest, const char *fmt, const char *src)
{
- struct Buffer tmp = { 0 };
- mutt_buffer_alloc(&tmp, PATH_MAX);
+ struct Buffer tmp = mutt_buffer_make(PATH_MAX);
mutt_buffer_quote_filename(&tmp, src, true);
mutt_file_expand_fmt(dest, fmt, mutt_b2s(&tmp));
char *p = *s;
mbstate_t mbstate1, mbstate2;
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
memset(&mbstate1, 0, sizeof(mbstate1));
memset(&mbstate2, 0, sizeof(mbstate2));
for (; (k = mbrtowc(&wc, p, MB_LEN_MAX, &mbstate1)); p += k)
mutt_str_strncat(buf, sizeof(buf), " ", 1);
}
- struct Buffer expn = { 0 };
+ struct Buffer expn = mutt_buffer_make(0);
expn.data = buf;
expn.dptr = buf;
expn.dsize = mutt_str_strlen(buf);
struct ConfigDef *cdef = he->data;
int rc = 0;
- struct Buffer err = { 0 };
- mutt_buffer_alloc(&err, 256);
+ struct Buffer err = mutt_buffer_make(256);
switch (DTYPE(cdef->type))
{
case DT_SORT:
case DT_STRING:
{
- struct Buffer value = { 0 };
- mutt_buffer_alloc(&value, 256);
+ struct Buffer value = mutt_buffer_make(256);
int rc = cs_he_string_get(Config, he, &value);
if (CSR_RESULT(rc) != CSR_SUCCESS)
{
return -1;
}
- struct Buffer escaped = { 0 };
- mutt_buffer_alloc(&escaped, 256);
+ struct Buffer escaped = mutt_buffer_make(256);
escape_string(&escaped, value.data);
lua_pushstring(l, escaped.data);
mutt_buffer_dealloc(&value);
srccopy[n - 1] = '\0';
/* prepare Buffers */
- struct Buffer srcbuf = { 0 };
+ struct Buffer srcbuf = mutt_buffer_make(0);
mutt_buffer_addstr(&srcbuf, srccopy);
/* note: we are resetting dptr and *reading* from the buffer, so we don't
* want to use mutt_buffer_reset(). */
srcbuf.dptr = srcbuf.data;
- struct Buffer word = { 0 };
- struct Buffer cmd = { 0 };
+ struct Buffer word = mutt_buffer_make(0);
+ struct Buffer cmd = mutt_buffer_make(0);
/* Iterate expansions across successive arguments */
do
(rd.line_info[i].syntax)[0].last = -1;
}
- struct Buffer helpstr = { 0 };
+ struct Buffer helpstr = mutt_buffer_make(0);
mutt_compile_help(buf, sizeof(buf), MENU_PAGER, PagerHelp);
mutt_buffer_strcpy(&helpstr, buf);
if (IsEmail(extra))
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_b64_buffer_decode(&buf, NULL) != 0);
}
}
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_b64_buffer_encode(&buf, NULL, 10) == 0);
mutt_buffer_dealloc(&buf);
}
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_add_printf(&buf, NULL) != 0);
}
{
TEST_CASE("Empty");
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_add_printf(&buf, "") == 0);
TEST_CHECK(strlen(mutt_b2s(&buf)) == 0);
mutt_buffer_dealloc(&buf);
{
TEST_CASE("Static");
const char *str = "apple";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_add_printf(&buf, str) == 5);
TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
mutt_buffer_dealloc(&buf);
"apple banana cherry damson elderberry fig guava hawthorn ilama "
"jackfruit kumquat lemon mango nectarine olive papaya quince raspberry "
"strawberry tangerine ugli vanilla wolfberry xigua yew ziziphus";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_add_printf(&buf, str) == 195);
TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
mutt_buffer_dealloc(&buf);
TEST_CASE("Varargs");
const char *str = "apple";
const char *result = "app 1234567 3.1416";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_add_printf(&buf, "%.3s %ld %3.4f", str, 1234567, 3.141592654) == 18);
TEST_CHECK(strcmp(mutt_b2s(&buf), result) == 0);
mutt_buffer_dealloc(&buf);
{
TEST_CASE("Empty");
const char *str = "test";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, str);
TEST_CHECK(mutt_buffer_add_printf(&buf, "") == 0);
TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
TEST_CASE("Static");
const char *str = "apple";
const char *result = "testapple";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
TEST_CHECK(mutt_buffer_add_printf(&buf, str) == 5);
TEST_CHECK(strcmp(mutt_b2s(&buf), result) == 0);
"testapple banana cherry damson elderberry fig guava hawthorn ilama "
"jackfruit kumquat lemon mango nectarine olive papaya quince raspberry "
"strawberry tangerine ugli vanilla wolfberry xigua yew ziziphus";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
TEST_CHECK(mutt_buffer_add_printf(&buf, str) == 195);
TEST_CHECK(strcmp(mutt_b2s(&buf), result) == 0);
TEST_CASE("Varargs");
const char *str = "apple";
const char *result = "testapp 1234567 3.1416";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
TEST_CHECK(mutt_buffer_add_printf(&buf, "%.3s %ld %3.4f", str, 1234567, 3.141592654) == 18);
TEST_CHECK(strcmp(mutt_b2s(&buf), result) == 0);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_addch(&buf, 'a') == 1);
TEST_CHECK(strcmp(mutt_b2s(&buf), "a") == 0);
mutt_buffer_dealloc(&buf);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
TEST_CHECK(mutt_buffer_addch(&buf, 'a') == 1);
TEST_CHECK(strcmp(mutt_b2s(&buf), "testa") == 0);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_addstr(&buf, NULL) == 0);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_addstr(&buf, "apple") == 5);
TEST_CHECK(strcmp(mutt_b2s(&buf), "apple") == 0);
mutt_buffer_dealloc(&buf);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
TEST_CHECK(mutt_buffer_addstr(&buf, "apple") == 5);
TEST_CHECK(strcmp(mutt_b2s(&buf), "testapple") == 0);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_addstr_n(&buf, NULL, 10) == 0);
}
for (size_t i = 0; i < mutt_array_size(sizes); i++)
{
TEST_CASE_("%ld", sizes[i]);
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_addstr_n(&buf, str, sizes[i]) == sizes[i]);
TEST_CHECK(strlen(mutt_b2s(&buf)) == MIN(len, sizes[i]));
TEST_CHECK(strncmp(mutt_b2s(&buf), str, sizes[i]) == 0);
for (size_t i = 0; i < mutt_array_size(sizes); i++)
{
TEST_CASE_("%ld", sizes[i]);
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, base);
TEST_CHECK(mutt_buffer_addstr_n(&buf, str, sizes[i]) == sizes[i]);
TEST_CHECK(strlen(mutt_b2s(&buf)) == (base_len + MIN(len, sizes[i])));
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_alloc(&buf, 10);
TEST_CHECK_(1, "mutt_buffer_alloc(buf, 10)");
mutt_buffer_dealloc(&buf);
for (size_t i = 0; i < mutt_array_size(sizes); i++)
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_alloc(&buf, orig_size);
TEST_CASE_("%d", sizes[i]);
mutt_buffer_alloc(&buf, sizes[i]);
TEST_CASE_("DIR: '%s' FILE: '%s'", NONULL(concat_test[i][0]),
NONULL(concat_test[i][1]));
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_concat_path(&buf, concat_test[i][0], concat_test[i][1]);
if (concat_test[i][2])
{
{
const char *str = "test";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, str);
mutt_buffer_concat_path(&buf, concat_test[i][0], concat_test[i][1]);
if (concat_test[i][2])
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_fix_dptr(&buf);
TEST_CHECK(mutt_buffer_len(&buf) == 0);
}
{
const char *str = "a quick brown fox";
- struct Buffer buf ={ 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, str);
mutt_buffer_fix_dptr(&buf);
TEST_CHECK(mutt_buffer_len(&buf) == (strlen(str)));
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_init(&buf) != NULL);
}
}
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_is_empty(&buf));
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
TEST_CHECK(!mutt_buffer_is_empty(&buf));
mutt_buffer_dealloc(&buf);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_len(&buf) == 0);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
TEST_CHECK(mutt_buffer_len(&buf) != 0);
mutt_buffer_dealloc(&buf);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_printf(&buf, NULL) != 0);
}
{
TEST_CASE("Empty");
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_printf(&buf, "") == 0);
TEST_CHECK(strlen(mutt_b2s(&buf)) == 0);
mutt_buffer_dealloc(&buf);
{
TEST_CASE("Static");
const char *str = "apple";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_printf(&buf, str) == 5);
TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
mutt_buffer_dealloc(&buf);
TEST_CASE("Varargs");
const char *str = "apple";
const char *result = "app 1234567 3.1416";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_buffer_printf(&buf, "%.3s %ld %3.4f", str, 1234567, 3.141592654) == 18);
TEST_CHECK(strcmp(mutt_b2s(&buf), result) == 0);
mutt_buffer_dealloc(&buf);
{
TEST_CASE("Empty");
const char *str = "test";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, str);
TEST_CHECK(mutt_buffer_printf(&buf, "") == 0);
TEST_CHECK(strcmp(mutt_b2s(&buf), "") == 0);
{
TEST_CASE("Static");
const char *str = "apple";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
TEST_CHECK(mutt_buffer_printf(&buf, str) == 5);
TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
"apple banana cherry damson elderberry fig guava hawthorn ilama "
"jackfruit kumquat lemon mango nectarine olive papaya quince raspberry "
"strawberry tangerine ugli vanilla wolfberry xigua yew ziziphus";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
TEST_CHECK(mutt_buffer_printf(&buf, str) == 195);
TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
TEST_CASE("Varargs");
const char *str = "apple";
const char *result = "app 1234567 3.1416";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
TEST_CHECK(mutt_buffer_printf(&buf, "%.3s %ld %3.4f", str, 1234567, 3.141592654) == 18);
TEST_CHECK(strcmp(mutt_b2s(&buf), result) == 0);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_reset(&buf);
TEST_CHECK_(1, "mutt_buffer_reset(buf)");
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
mutt_buffer_reset(&buf);
TEST_CHECK_(1, "mutt_buffer_reset(buf)");
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_strcpy(&buf, NULL);
TEST_CHECK_(1, "mutt_buffer_strcpy(&buf, NULL)");
}
{
TEST_CASE("Empty");
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_strcpy(&buf, "");
TEST_CHECK(strcmp(mutt_b2s(&buf), "") == 0);
mutt_buffer_dealloc(&buf);
{
TEST_CASE("String");
const char *str = "test";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_strcpy(&buf, str);
TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
mutt_buffer_dealloc(&buf);
{
TEST_CASE("Empty");
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
mutt_buffer_strcpy(&buf, "");
TEST_CHECK(strcmp(mutt_b2s(&buf), "") == 0);
{
TEST_CASE("String");
const char *str = "apple";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, "test");
mutt_buffer_strcpy(&buf, str);
TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_strcpy_n(&buf, NULL, 3);
TEST_CHECK_(1, "mutt_buffer_strcpy_n(&buf, NULL, 3)");
}
for (size_t i = 0; i < mutt_array_size(sizes); i++)
{
TEST_CASE_("%ld", sizes[i]);
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_strcpy_n(&buf, str, sizes[i]);
TEST_CHECK(strlen(mutt_b2s(&buf)) == MIN(len, sizes[i]));
TEST_CHECK(strncmp(mutt_b2s(&buf), str, sizes[i]) == 0);
for (size_t i = 0; i < mutt_array_size(sizes); i++)
{
TEST_CASE_("%ld", sizes[i]);
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_addstr(&buf, base);
mutt_buffer_strcpy_n(&buf, str, sizes[i]);
TEST_CHECK(strlen(mutt_b2s(&buf)) == MIN(len, sizes[i]));
// bool mutt_ch_lookup_add(enum LookupType type, const char *pat, const char *replace, struct Buffer *err);
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(!mutt_ch_lookup_add(0, NULL, "banana", &buf));
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(!mutt_ch_lookup_add(0, "apple", NULL, &buf));
}
// size_t pretty_var(const char *str, struct Buffer *buf);
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
if (!TEST_CHECK(pretty_var(NULL, &buf) == 0))
return false;
}
}
{
- struct Buffer buf = { 0 };
- mutt_buffer_alloc(&buf, 64);
+ struct Buffer buf = mutt_buffer_make(64);
if (!TEST_CHECK(pretty_var("apple", &buf) > 0))
{
mutt_buffer_dealloc(&buf);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
if (!TEST_CHECK(escape_string(&buf, NULL) == 0))
return false;
}
const char *before = "apple\nbanana\rcherry\tdamson\\endive\"fig'grape";
const char *after =
"apple\\nbanana\\rcherry\\tdamson\\\\endive\\\"fig'grape";
- struct Buffer buf = { 0 };
- mutt_buffer_alloc(&buf, 256);
+ struct Buffer buf = mutt_buffer_make(256);
if (!TEST_CHECK(escape_string(&buf, before) > 0))
{
mutt_buffer_dealloc(&buf);
struct HashElem *he = cs_get_elem(cs, "Banana");
- struct Buffer buf_val = { 0 };
+ struct Buffer buf_val = mutt_buffer_make(0);
mutt_buffer_addstr(&buf_val, "yes");
- struct Buffer buf_init = { 0 };
+ struct Buffer buf_init = mutt_buffer_make(0);
mutt_buffer_addstr(&buf_init, "yes");
FILE *fp = fopen("/dev/null", "w");
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_file_expand_fmt_quote(&buf, NULL, "banana");
TEST_CHECK_(1, "mutt_buffer_file_expand_fmt_quote(&buf, NULL, \"banana\")");
}
{
- struct Buffer buf = { 0 };
- mutt_buffer_alloc(&buf, 32);
+ struct Buffer buf = mutt_buffer_make(32);
mutt_buffer_file_expand_fmt_quote(&buf, "apple", NULL);
TEST_CHECK_(1, "mutt_buffer_file_expand_fmt_quote(&buf, \"apple\", NULL)");
mutt_buffer_dealloc(&buf);
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_buffer_quote_filename(&buf, NULL, false);
TEST_CHECK_(1, "mutt_buffer_quote_filename(&buf, NULL, false)");
}
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_file_expand_fmt(&buf, NULL, "banana");
TEST_CHECK_(1, "mutt_file_expand_fmt(&buf, NULL, \"banana\")");
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_file_expand_fmt(&buf, "apple", NULL);
TEST_CHECK_(1, "mutt_file_expand_fmt(&buf, \"apple\", NULL)");
}
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_file_sanitize_regex(&buf, NULL) != 0);
}
}
// int mutt_grouplist_add_regex(struct GroupList *head, const char *s, int flags, struct Buffer *err);
{
- struct Buffer err = { 0 };
+ struct Buffer err = mutt_buffer_make(0);
TEST_CHECK(mutt_grouplist_add_regex(NULL, "apple", 0, &err) == -1);
}
{
struct GroupList head = { 0 };
- struct Buffer err = { 0 };
+ struct Buffer err = mutt_buffer_make(0);
TEST_CHECK(mutt_grouplist_add_regex(&head, NULL, 0, &err) == -1);
}
}
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
mutt_path_getcwd(&buf);
TEST_CHECK(buf.data[0] == '/');
mutt_buffer_dealloc(&buf);
void test_mutt_pattern_comp(void)
{
- struct Buffer err = { 0 };
- mutt_buffer_alloc(&err, 1024);
+ struct Buffer err = mutt_buffer_make(1024);
{ /* empty */
char *s = "";
{
log_line(__func__);
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
{ /* handle edge cases */
struct Regex *rx = regex_new("hello bob", 0, &buf);
const char *bob_line = "definitely bob haha";
const char *not_bob_line = "john dave marty nothing else here";
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
{
// from: if (regexec(C_PgpGoodSign->regex, bob_line, 0, NULL, 0) == 0)
// to: if (mutt_regex_match(C_PgpGoodSign, bob_line))
// struct Regex *mutt_regex_new(const char *str, int flags, struct Buffer *err);
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(!mutt_regex_new(NULL, 0, &buf));
}
// int mutt_regexlist_add(struct RegexList *rl, const char *str, int flags, struct Buffer *err);
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_regexlist_add(NULL, "apple", 0, &buf) == 0);
}
{
struct RegexList regexlist = { 0 };
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_regexlist_add(®exlist, NULL, 0, &buf) == 0);
}
// int mutt_replacelist_add(struct ReplaceList *rl, const char *pat, const char *templ, struct Buffer *err);
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_replacelist_add(NULL, "apple", "banana", &buf) == 0);
}
{
struct ReplaceList replacelist = { 0 };
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_replacelist_add(&replacelist, NULL, "banana", &buf) == 0);
}
{
struct ReplaceList replacelist = { 0 };
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(mutt_replacelist_add(&replacelist, "apple", NULL, &buf) == 0);
}
// int url_tobuffer(struct Url *u, struct Buffer *buf, int flags);
{
- struct Buffer buf = { 0 };
+ struct Buffer buf = mutt_buffer_make(0);
TEST_CHECK(url_tobuffer(NULL, &buf, 0) != 0);
}
projects / neomutt / commitdiff