Str *
str_new_str(const char *data, size_t n)
{
Str *s = str_new(n);
memcpy(s->data, data, n);
s->len = n;
return s;
}
static void print_help(struct menu *menu)
{
struct gstr help = str_new();
menu_get_ext_help(menu, &help);
printf("\n%s\n", str_get(&help));
str_free(&help);
}
/* buffer_new returns a new buffer */
Buffer *
buffer_new(size_t n) {
Buffer *b;
b = lmalloc(sizeof(Buffer));
b->off = 0;
b->s = str_new(n);
return b;
}
static void show_help(struct menu *menu)
{
struct gstr help = str_new();
menu_get_ext_help(menu, &help);
show_helptext(_(menu_get_prompt(menu)), str_get(&help));
str_free(&help);
}
static int
dbox_get_cached_metadata(struct dbox_mail *mail, enum dbox_metadata_key key,
enum index_cache_field cache_field,
const char **value_r)
{
struct index_mail *imail = &mail->imail;
struct index_mailbox_context *ibox =
INDEX_STORAGE_CONTEXT(imail->mail.mail.box);
const char *value;
string_t *str;
uint32_t order;
str = str_new(imail->mail.data_pool, 64);
if (mail_cache_lookup_field(imail->mail.mail.transaction->cache_view,
str, imail->mail.mail.seq,
ibox->cache_fields[cache_field].idx) > 0) {
if (cache_field == MAIL_CACHE_POP3_ORDER) {
i_assert(str_len(str) == sizeof(order));
memcpy(&order, str_data(str), sizeof(order));
str_truncate(str, 0);
if (order != 0)
str_printfa(str, "%u", order);
else {
/* order=0 means it doesn't exist. we don't
want to return "0" though, because then the
mails get ordered to beginning, while
nonexistent are supposed to be ordered at
the end. */
}
}
*value_r = str_c(str);
return 0;
}
if (dbox_mail_metadata_get(mail, key, &value) < 0)
return -1;
if (value == NULL)
value = "";
if (cache_field != MAIL_CACHE_POP3_ORDER) {
index_mail_cache_add_idx(imail, ibox->cache_fields[cache_field].idx,
value, strlen(value)+1);
} else {
if (str_to_uint(value, &order) < 0)
order = 0;
index_mail_cache_add_idx(imail, ibox->cache_fields[cache_field].idx,
&order, sizeof(order));
}
/* don't return pointer to dbox metadata directly, since it may
change unexpectedly */
str_truncate(str, 0);
str_append(str, value);
*value_r = str_c(str);
return 0;
}
END_TEST
START_TEST(test_str_add_file)
{
str_t *str = str_from_cstr("abc");
str_add_file(&str, "testdata/file.txt");
CHECK_STR(str, >= 13, == 13, "abc123456789\n");
str_free(str);
str = str_new(0);
str_add_file(&str, "testdata/file.txt");
CHECK_STR(str, >= 10, == 10, "123456789\n");
str_free(str);
str = str_new(0);
str_add_file(&str, "non-existent file");
CHECK_STR(str, == STR_DEFAULT_CAPACITY, == 0, "");
str_free(str);
}
static void show_help(struct menu *menu)
{
struct gstr help = str_new();
help.max_width = getmaxx(stdscr) - 10;
menu_get_ext_help(menu, &help);
show_helptext(_(menu_get_prompt(menu)), str_get(&help));
str_free(&help);
}
static string_script * _scr_new_str(const char * source) {
string_script * scr;
if(0 == (scr = mem_alloc(sizeof(file_script)))) { goto error; }
if(0 == (scr->s = str_new(source))) { goto error; }
scr->pos = 0;
return scr;
error:
_scr_del_str(scr);
return 0;
}
veBool str_newn(Str *str, char const* buf, size_t len)
{
str_new(str, len + 1, len + 1);
if (str->error)
return veFalse;
memcpy(str->data, buf, len);
str->data[len] = 0;
str_added(str, len);
return veTrue;
}
/* Create a trivial CategoryMap, with feature types equal to category
numbers (plus an optional prefix) and ranges all of size one. */
CategoryMap* cm_create_trivial(int ncats, char *feature_prefix) {
int i;
CategoryMap *retval = cm_new(ncats);
for (i = 0; i <= ncats; i++) {
String *type = str_new(STR_SHORT_LEN);
if (feature_prefix != NULL) str_append_charstr(type, feature_prefix);
str_append_int(type, i);
retval->ranges[i] = cm_new_category_range(type, i, i);
}
return retval;
}
END_TEST
START_TEST(append_chars_to_non_empty_string) {
s = str_new("a");
const char *t = "a";
str_append_chars(s, t);
ck_assert_msg(strcmp(s->str, "aa") == 0, "%s == %s", s->str, "aa");
ck_assert_msg(s->len == 2, "str's len member is %d", 2);
}
struct json_parser *json_parser_init(struct istream *input)
{
struct json_parser *parser;
parser = i_new(struct json_parser, 1);
parser->input = input;
parser->value = str_new(default_pool, 128);
i_array_init(&parser->nesting, 8);
i_stream_ref(input);
return parser;
}
strm_string*
strm_str_new(const char *p, size_t len)
{
if (!strm_event_loop_started) {
/* single thread mode */
if (p && (len < STRM_STR_INTERN_LIMIT || readonly_data_p(p))) {
return str_intern(p, len);
}
}
return str_new(p, len);
}
/*-----------------------------------------------------------------------------
* Init functions
*----------------------------------------------------------------------------*/
DEFINE_init_module()
{
input_buf = str_new(STR_SIZE);
p = str_data(input_buf);
input_stack = OBJ_NEW(List);
input_stack->free_data = m_free_compat;
init_sym();
utarray_new(scan_state, &ut_scan_state_icd);
}
END_TEST
START_TEST(append_chars_long) {
s = str_new(NULL);
const char *t = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
str_append_chars(s, t);
ck_assert_msg(strcmp(s->str, t) == 0, "%s == %s", s->str, t);
ck_assert_msg(s->len == strlen(t), "str's len member is %d", strlen(t));
}
struct gstr get_relations_str(struct symbol **sym_arr)
{
struct symbol *sym;
struct gstr res = str_new();
int i;
for (i = 0; sym_arr && (sym = sym_arr[i]); i++)
get_symbol_str(&res, sym);
if (!i)
str_append(&res, _("No matches found.\n"));
return res;
}
static void process_nodes(VALUE out, OSMPBF__PrimitiveGroup *group, OSMPBF__StringTable *string_table, int64_t lat_offset, int64_t lon_offset, int64_t granularity, int32_t ts_granularity)
{
double lat = 0;
double lon = 0;
unsigned j = 0;
size_t i = 0;
for(i = 0; i < group->n_nodes; i++)
{
OSMPBF__Node *node = group->nodes[i];
VALUE node_out = rb_hash_new();
lat = NANO_DEGREE * (lat_offset + (node->lat * granularity));
lon = NANO_DEGREE * (lon_offset + (node->lon * granularity));
rb_hash_aset(node_out, STR2SYM("id"), LL2NUM(node->id));
rb_hash_aset(node_out, STR2SYM("lat"), FIX7(rb_float_new(lat)));
rb_hash_aset(node_out, STR2SYM("lon"), FIX7(rb_float_new(lon)));
if(node->info)
add_info(node_out, node->info, string_table, ts_granularity);
VALUE tags = rb_hash_new();
for(j = 0; j < node->n_keys; j++)
{
char *key = parse_binary_str(string_table->s[node->keys[j]]);
char *value = parse_binary_str(string_table->s[node->vals[j]]);
rb_hash_aset(tags, str_new(key), str_new(value));
free(key);
free(value);
}
rb_hash_aset(node_out, STR2SYM("tags"), tags);
rb_ary_push(out, node_out);
}
}
int
main(int argc, char **argv) {
str_t str;
int ret;
str = str_new();
ret = str_write_file(str, "out.txt");
ASSERT(ret, "str_write_file");
return 0;
error:
return -1;
}
static struct maildir_list_context *
maildir_list_init(struct maildir_quota_root *root, struct mailbox_list *list)
{
struct maildir_list_context *ctx;
ctx = i_new(struct maildir_list_context, 1);
ctx->root = root;
ctx->path = str_new(default_pool, 512);
ctx->list = list;
ctx->iter = mailbox_list_iter_init(list, "*",
MAILBOX_LIST_ITER_SKIP_ALIASES |
MAILBOX_LIST_ITER_RETURN_NO_FLAGS);
return ctx;
}
void test_istream_tee(void)
{
string_t *str;
unsigned int i;
str = str_new(default_pool, TEST_STR_LEN);
for (i = 0; i < TEST_STR_LEN; i++)
str_append_c(str, 'a' + i%26);
test_istream_tee_tailing(str_c(str));
test_istream_tee_blocks(str_c(str));
str_free(&str);
}
END_TEST
START_TEST(test_str_trim)
{
str_t *str = str_from_cstr(" \n\r123 \n");
str_trim(str);
CHECK_STR(str, >= 3, == 3, "123");
str_free(str);
str = str_new(0);
str_trim(str);
CHECK_STR(str, == STR_DEFAULT_CAPACITY, == 0, "");
str_free(str);
}
SVec
svec_copy( SVec ov )
{
int i;
SVec nv;
nv = svec_new( ov->fSize );
for ( i=0 ; i < ov->fEntries ; i++ ) {
svec_add( nv, str_new(ov->fV[i]) );
}
return nv;
}
int
vformat(Str **str, const char *fmt, va_list ap)
{
int off, size;
const char *p = fmt;
char *item;
Str *s;
struct command cmd;
cmd.argv = NULL;
cmd.argc = 0;
cmd.len = 0;
off = 0;
/* debug
for(i = 0; p[i] != '\0'; i++) {
printf("fmt + %d: %p - `%c`\n", i, &fmt[i], fmt[i]);
} */
for(; *p != '\0'; p++) {
/* debug */
/* printf("--> %c %p ", *p, p); */
if (*p == '%') {
off += 2;
switch(*++p) {
case 'b':
item = va_arg(ap, char *);
size = va_arg(ap, size_t);
break;
case 's':
item = va_arg(ap, char *);
size = strlen(item);
break;
default:
goto error;
}
s = str_new(size);
s = str_append(s, item, size);
/* debug */
/* printf("found %c ... ", *p);
printf("%d ... ", size);
printf("%s ... ", s->data); */
} else {
if (*p == ' ') {
/**
* Create a string representation of the magnet resource.
*
* @return A newly allocated string via halloc().
*/
char *
magnet_to_string(const struct magnet_resource *res)
{
GSList *sl;
str_t *s;
g_return_val_if_fail(res, NULL);
s = str_new(0);
if (res->display_name) {
magnet_append_item(s, TRUE, "dn", res->display_name);
}
if (0 != res->size) {
char buf[UINT64_DEC_BUFLEN];
uint64_to_string_buf(res->size, buf, sizeof buf);
magnet_append_item(s, FALSE, "xl", buf);
}
if (res->sha1) {
magnet_append_item(s, FALSE, "xt",
bitprint_to_urn_string(res->sha1, res->tth));
}
if (res->parq_id) {
magnet_append_item(s, TRUE, "x.parq-id", res->parq_id);
}
if (res->vendor) {
magnet_append_item(s, TRUE, "x.vndr", res->vendor);
}
if (res->guid) {
magnet_append_item(s, TRUE, "x.guid", res->guid);
}
if (res->dht) {
magnet_append_item(s, TRUE, "x.dht", "1");
}
for (sl = res->sources; NULL != sl; sl = g_slist_next(sl)) {
char *url;
url = magnet_source_to_string(sl->data);
magnet_append_item(s, TRUE, "xs", url);
G_FREE_NULL(url);
}
for (sl = res->searches; NULL != sl; sl = g_slist_next(sl)) {
magnet_append_item(s, TRUE, "kt", sl->data);
}
return str_s2c_null(&s);
}
/**
* sprintf with dynamic memory.
*
* @note the return value must be released!
*/
void str_vnewf(Str *str, char const *format, va_list varArgs)
{
size_t length;
/* get the length of the string */
length = str_printfLength(format, varArgs);
str_new(str, length + 1, 100);
if (str->error)
return;
/* now it can safely be formatted */
vsprintf(str->data, format, varArgs);
str_added(str, length);
}
END_TEST
START_TEST(test_str_add_printf)
{
str_t *str = str_from_cstr("123");
str_add_printf(&str, "%d", 456);
CHECK_STR(str, >= 6, == 6, "123456");
str_free(str);
str = str_new(0);
str_add_printf(&str, "%d", 31337);
str_add_printf(&str, "%s", "31337");
CHECK_STR(str, >= 10, == 10, "3133731337");
str_free(str);
}
void http_client_request_add_header(struct http_client_request *req,
const char *key, const char *value)
{
i_assert(req->state == HTTP_REQUEST_STATE_NEW ||
/* allow calling for retries */
req->state == HTTP_REQUEST_STATE_GOT_RESPONSE ||
req->state == HTTP_REQUEST_STATE_ABORTED);
/* mark presence of special headers */
switch (key[0]) {
case 'a': case 'A':
if (strcasecmp(key, "Authorization") == 0)
req->have_hdr_authorization = TRUE;
break;
case 'c': case 'C':
if (strcasecmp(key, "Connection") == 0)
req->have_hdr_connection = TRUE;
else if (strcasecmp(key, "Content-Length") == 0)
req->have_hdr_body_spec = TRUE;
break;
case 'd': case 'D':
if (strcasecmp(key, "Date") == 0)
req->have_hdr_date = TRUE;
break;
case 'e': case 'E':
if (strcasecmp(key, "Expect") == 0)
req->have_hdr_expect = TRUE;
break;
case 'h': case 'H':
if (strcasecmp(key, "Host") == 0)
req->have_hdr_host = TRUE;
break;
case 'p': case 'P':
i_assert(strcasecmp(key, "Proxy-Authorization") != 0);
break;
case 't': case 'T':
if (strcasecmp(key, "Transfer-Encoding") == 0)
req->have_hdr_body_spec = TRUE;
break;
case 'u': case 'U':
if (strcasecmp(key, "User-Agent") == 0)
req->have_hdr_user_agent = TRUE;
break;
}
if (req->headers == NULL)
req->headers = str_new(default_pool, 256);
str_printfa(req->headers, "%s: %s\r\n", key, value);
}
struct json_parser *json_parser_init_flags(struct istream *input,
enum json_parser_flags flags)
{
struct json_parser *parser;
parser = i_new(struct json_parser, 1);
parser->input = input;
parser->flags = flags;
parser->value = str_new(default_pool, 128);
i_array_init(&parser->nesting, 8);
i_stream_ref(input);
if ((flags & JSON_PARSER_NO_ROOT_OBJECT) != 0)
parser->state = JSON_STATE_VALUE;
return parser;
}
int main(void)
{
int c;
string str;
if(str_new(&str, 255) == 0)
return 1;
while((c = getchar()) != EOF) {
if(c == '\n'){
sort(&str);
printf("%s\n-----\n", str.str);
str_clean(&str);
} else
str_push(&str, c);
}
return 0;
}
void SrcFile_init( SrcFile *self )
{
strpool_init();
self->filename = NULL;
self->line = str_new(STR_SIZE);
self->line_stack = OBJ_NEW( List );
OBJ_AUTODELETE( self->line_stack ) = FALSE;
self->line_stack->free_data = m_free_compat;
self->file_stack = OBJ_NEW( List );
OBJ_AUTODELETE( self->file_stack ) = FALSE;
self->file_stack->free_data = free_file_stack_elem;
}
