static void test_str_insert(void)
{
string_t *str = t_str_new(32);
test_begin("str_insert()");
str_insert(str, 0, "foo");
str_insert(str, 3, ">");
str_insert(str, 3, "bar");
str_insert(str, 0, "<");
test_assert(str->used == 8 && memcmp(str_data(str), "<foobar>", 8) == 0);
str_insert(str, 10, "!");
test_assert(str->used == 11 && memcmp(str_data(str), "<foobar>\0\0!", 11) == 0);
test_end();
}
/*
Converts a null-termiated C style string into a
list of characters (a Crema string)
@param s Pointer to a C character array
@return Returns the list_t equivalent of the given C string
*/
string_t * str_from_cstring(char * s)
{
string_t * str = list_create(sizeof(char));
list_resize(str, strlen(s) + 1);
strncpy(str->arr, s, strlen(s));
str->len = strlen(s);
str_insert(str, strlen(s), '\0');
return str;
}
ast_t * integer(input_t * in)
{
int start = in->start;
char c;
int i = 0, alloc = 0;
char * str = NULL;
ast_t * a;
skip_whitespace(in);
if ((c = read1(in)) >= '1' && c <= '9')
{
str_insert(str, c);
start = in->start;
while (isdigit(c = read1(in)))
{
str_insert(str, c);
start = in->start;
}
in->start = start;
str_insert(str, '\0');
a = new_ast(T_INT, NULL, NULL);
a->l = atol(str);
free(str);
return a;
} else if (c == '0')
{
str_insert(str, c);
str_insert(str, '\0');
a = new_ast(T_INT, NULL, NULL);
a->l = atol(str);
free(str);
return a;
}
in->start = start;
return NULL;
}
static void
dsync_fix_mailbox_name(struct mail_namespace *ns, string_t *vname,
char alt_char)
{
const char *old_vname;
char *p, list_sep = mailbox_list_get_hierarchy_sep(ns->list);
guid_128_t guid;
/* replace control chars */
for (p = str_c_modifiable(vname); *p != '\0'; p++) {
if ((unsigned char)*p < ' ')
*p = alt_char;
}
/* make it valid UTF8 */
if (!uni_utf8_str_is_valid(str_c(vname))) {
old_vname = t_strdup(str_c(vname));
str_truncate(vname, 0);
if (uni_utf8_get_valid_data((const void *)old_vname,
strlen(old_vname), vname))
i_unreached();
}
if (dsync_is_valid_name(ns, str_c(vname)))
return;
/* 1) change any real separators to alt separators (this wouldn't
be necessary with listescape, but don't bother detecting it) */
if (list_sep != mail_namespace_get_sep(ns)) {
for (p = str_c_modifiable(vname); *p != '\0'; p++) {
if (*p == list_sep)
*p = alt_char;
}
if (dsync_is_valid_name(ns, str_c(vname)))
return;
}
/* 2) '/' characters aren't valid without listescape */
if (mail_namespace_get_sep(ns) != '/' && list_sep != '/') {
for (p = str_c_modifiable(vname); *p != '\0'; p++) {
if (*p == '/')
*p = alt_char;
}
if (dsync_is_valid_name(ns, str_c(vname)))
return;
}
/* 3) probably some reserved name (e.g. dbox-Mails) */
str_insert(vname, ns->prefix_len, "_");
if (dsync_is_valid_name(ns, str_c(vname)))
return;
/* 4) name is too long? just give up and generate a unique name */
guid_128_generate(guid);
str_truncate(vname, 0);
str_append(vname, ns->prefix);
str_append(vname, guid_128_to_string(guid));
i_assert(dsync_is_valid_name(ns, str_c(vname)));
}
static void test_random_edits() {
// This string should always have the same content as the rope.
_string *str = str_create();
rope *r = rope_new();
const size_t max_stringsize = 1000;
uint8_t strbuffer[max_stringsize + 1];
for (int i = 0; i < 1000; i++) {
// First, some sanity checks.
check(r, (char *)str->mem);
rope *r2 = rope_copy(r);
check(r2, (char *)str->mem);
rope_free(r2);
// printf("String contains '%s'\n", str->mem);
test(rope_byte_count(r) == str->len);
size_t len = strlen_utf8(str->mem);
test(rope_char_count(r) == len);
test(str_num_chars(str) == len);
if (len == 0 || rand_float() < 0.5f) {
// Insert.
//uint8_t *text = random_ascii_string(11);
random_unicode_string(strbuffer, 1 + random() % max_stringsize);
size_t pos = random() % (len + 1);
// printf("inserting %s at %zd\n", strbuffer, pos);
rope_insert(r, pos, strbuffer);
str_insert(str, pos, strbuffer);
} else {
// Delete
size_t pos = random() % len;
size_t dellen = random() % 10;
dellen = MIN(len - pos, dellen);
// printf("deleting %zd chars at %zd\n", dellen, pos);
//deletedText = str[pos...pos + length]
//test.strictEqual deletedText, r.substring pos, length
rope_del(r, pos, dellen);
str_del(str, pos, dellen);
}
}
rope_free(r);
str_destroy(str);
}
/*
Returns a sub-string of a given string, given by a start index within the
string, and a length of the substring.
@param str The string to be operated on
@param start The starting index of the substring
@param len The number of characters after 'start' to be included in the substring
@return The substring
*/
string_t * str_substr(string_t * str, unsigned int start, unsigned int len)
{
string_t * nstr = list_create(sizeof(char));
if (start >= str->len)
return NULL;
if (len > str->len || len == 0)
len = str->len - start;
if (start == 0 && (len == 0 || len == str->len))
return str;
if (start >= str->len)
return NULL;
list_resize(nstr, len + 1);
strncpy(nstr->arr, (char*)str->arr + start, len);
nstr->len = len;
str_insert(nstr, len, '\0');
return nstr;
}
int main(int argc, char **args)
{
char *str = (char *) malloc(100);
str_copy(str, "Hello World!");
printf("%s\n", str);
int cmp0 = str_compare("abcde", "abcde");
int cmp1 = str_compare("abcde", "abcdf");
int cmp2 = str_compare("abcdf", "abcde");
int cmp3 = str_compare("abcde", "abcdef");
int cmp4 = str_compare("abcdef", "abcde");
printf("%d %d %d %d %d\n", cmp0, cmp1, cmp2, cmp3, cmp4);
str_concat(str, "Hello ", "World!");
printf("%s\n", str);
str_sub(str, "Hello World!", 7, 2);
printf("%s\n", str);
int ind0 = str_index("Hello World!", "o", 0);
int ind1 = str_index("Hello World!", "o", 5);
printf("%d %d\n", ind0, ind1);
str_copy(str, "Hello World!");
str_insert(str, "My Beautiful ", 6);
printf("%s\n", str);
str_delete(str, 6, 3);
printf("%s\n", str);
str_delete(str, 6, 10);
printf("%s\n", str);
free(str);
return 0;
}
void smtp_string_write(string_t *out, const char *value)
{
bool quoted = FALSE;
const unsigned char *p, *pend, *pblock;
size_t begin = str_len(out);
if (value == NULL)
return;
p = (const unsigned char *)value;
pend = p + strlen(value);
while (p < pend) {
pblock = p;
while (p < pend && smtp_char_is_atext(*p))
p++;
if (!quoted && p < pend) {
quoted = TRUE;
str_insert(out, begin, "\"");
}
str_append_n(out, pblock, p-pblock);
if (p >= pend)
break;
i_assert(quoted);
i_assert(smtp_char_is_qpair(*p));
if (!smtp_char_is_qtext(*p))
str_append_c(out, '\\');
str_append_c(out, *p);
p++;
}
if (quoted)
str_append_c(out, '\"');
}
/* ------------------------------------------------------------
-------------------------------------------------------------- */
void str_insert_at (int cline, int k, int ccol)
{
char *p;
int l;
l = max1 (strlen(lines[cline])+1, ccol+1);
p = malloc (l+1);
if (ccol < strlen(lines[cline]))
{
strcpy (p, lines[cline]);
str_insert (p, k, ccol);
}
else
{
strcpy (p, lines[cline]);
memset (p+strlen(lines[cline]), ' ', ccol-strlen(lines[cline]));
p[ccol] = k;
p[ccol+1] = '\0';
}
free (lines[cline]);
lines[cline] = p;
}
static void
mail_search_arg_to_cmdline(string_t *dest, const struct mail_search_arg *arg)
{
struct mail_search_arg new_arg;
const char *error;
if (arg->match_not)
str_append(dest, "NOT ");
switch (arg->type) {
case SEARCH_OR:
mail_search_subargs_to_cmdline(dest, arg->value.subargs, " OR ");
return;
case SEARCH_SUB:
mail_search_subargs_to_cmdline(dest, arg->value.subargs, " ");
return;
case SEARCH_FLAGS:
case SEARCH_KEYWORDS: {
size_t pos = str_len(dest);
new_arg = *arg;
new_arg.match_not = FALSE;
if (!mail_search_arg_to_imap(dest, &new_arg, &error))
i_unreached();
if (str_c(dest)[pos] == '(') {
str_insert(dest, pos+1, " ");
str_insert(dest, str_len(dest)-1, " ");
}
return;
}
case SEARCH_INTHREAD:
str_append(dest, "INTHREAD ");
imap_append_astring(dest, mail_thread_type_to_str(arg->value.thread_type));
str_append_c(dest, ' ');
mail_search_subargs_to_cmdline(dest, arg->value.subargs, " ");
break;
case SEARCH_MAILBOX:
case SEARCH_MAILBOX_GLOB:
str_append(dest, "MAILBOX ");
imap_append_astring(dest, arg->value.str);
return;
case SEARCH_MAILBOX_GUID:
str_append(dest, "MAILBOX-GUID ");
imap_append_astring(dest, arg->value.str);
return;
case SEARCH_ALL:
case SEARCH_SEQSET:
case SEARCH_UIDSET:
case SEARCH_BEFORE:
case SEARCH_ON:
case SEARCH_SINCE:
case SEARCH_SMALLER:
case SEARCH_LARGER:
case SEARCH_HEADER:
case SEARCH_HEADER_ADDRESS:
case SEARCH_HEADER_COMPRESS_LWSP:
case SEARCH_BODY:
case SEARCH_TEXT:
case SEARCH_MODSEQ:
case SEARCH_GUID:
case SEARCH_REAL_UID:
case SEARCH_MIMEPART:
break;
}
new_arg = *arg;
new_arg.match_not = FALSE;
if (!mail_search_arg_to_imap(dest, &new_arg, &error))
i_panic("mail_search_args_to_cmdline(): Missing handler: %s", error);
}
void fill_submenu (HWND h, struct _item *M)
{
int ni, i;
HWND hwndMenu;
char *p;
MENUITEM mi;
// count submenus
ni = 0;
while (M[ni].type != ITEM_TYPE_END) ni++;
// fill every submenu
for (i=0; i<ni; i++)
{
switch (M[i].type)
{
case ITEM_TYPE_ACTION:
case ITEM_TYPE_SWITCH:
mi.iPosition = MIT_END;
mi.afStyle = MIS_TEXT;
mi.afAttribute = 0;
mi.hwndSubMenu = 0;
mi.hItem = 0;
mi.id = M[i].body.action;
p = str_strdup1 (M[i].text, 64);
if (M[i].hotkey != 0)
str_insert (p, '~', M[i].hkpos);
if (M[i].keydesc[0] != '\0')
{
strcat (p, "\t");
strcat (p, M[i].keydesc);
}
WinSendMsg (h, MM_INSERTITEM, MPFROMP (&mi), p);
free (p);
break;
case ITEM_TYPE_SUBMENU:
hwndMenu = WinCreateMenu (HWND_OBJECT, NULL);
WinSetWindowUShort (hwndMenu, QWS_ID, i);
M[i].submenu_id = i;
fill_submenu (hwndMenu, M[i].body.submenu);
mi.iPosition = MIT_END;
mi.afStyle = MIS_TEXT | MIS_SUBMENU;
mi.afAttribute = 0;
mi.hwndSubMenu = hwndMenu;
mi.id = i;
p = str_strdup1 (M[i].text, 64);
if (M[i].hotkey != 0)
str_insert (p, '~', M[i].hkpos);
if (M[i].keydesc[0] != '\0')
{
strcat (p, "\t");
strcat (p, M[i].keydesc);
}
WinSendMsg (h, MM_INSERTITEM, MPFROMP (&mi), p);
free (p);
break;
case ITEM_TYPE_SEP:
mi.iPosition = MIT_END;
mi.afStyle = MIS_SEPARATOR;
mi.afAttribute = 0;
mi.hwndSubMenu = 0;
mi.hItem = 0;
mi.id = 0;
WinSendMsg (h, MM_INSERTITEM, MPFROMP (&mi), NULL);
break;
}
}
}
