自学教程：C++ str_new函数代码示例

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 intdbox_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_TESTSTART_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_TESTSTART_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);}

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);  }}

intmain(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);}

SVecsvec_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);}

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;}