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

int git_stransport_stream_new(git_stream **out, const char *host, const char *port){	stransport_stream *st;	int error;	OSStatus ret;	assert(out && host);	st = git__calloc(1, sizeof(stransport_stream));	GITERR_CHECK_ALLOC(st);#ifdef GIT_CURL	error = git_curl_stream_new(&st->io, host, port);#else	error = git_socket_stream_new(&st->io, host, port);#endif	if (error < 0){		git__free(st);		return error;	}	st->ctx = SSLCreateContext(NULL, kSSLClientSide, kSSLStreamType);	if (!st->ctx) {		giterr_set(GITERR_NET, "failed to create SSL context");		return -1;	}	if ((ret = SSLSetIOFuncs(st->ctx, read_cb, write_cb)) != noErr ||	    (ret = SSLSetConnection(st->ctx, st->io)) != noErr ||	    (ret = SSLSetSessionOption(st->ctx, kSSLSessionOptionBreakOnServerAuth, true)) != noErr ||	    (ret = SSLSetProtocolVersionMin(st->ctx, kTLSProtocol1)) != noErr ||	    (ret = SSLSetProtocolVersionMax(st->ctx, kTLSProtocol12)) != noErr ||	    (ret = SSLSetPeerDomainName(st->ctx, host, strlen(host))) != noErr) {		git_stream_free((git_stream *)st);		return stransport_error(ret);	}	st->parent.version = GIT_STREAM_VERSION;	st->parent.encrypted = 1;	st->parent.proxy_support = git_stream_supports_proxy(st->io);	st->parent.connect = stransport_connect;	st->parent.certificate = stransport_certificate;	st->parent.set_proxy = stransport_set_proxy;	st->parent.read = stransport_read;	st->parent.write = stransport_write;	st->parent.close = stransport_close;	st->parent.free = stransport_free;	*out = (git_stream *) st;	return 0;}

/* Try to store the delta so we can try to resolve it later */static int store_delta(git_indexer *idx){	struct delta_info *delta;	delta = (delta_info*) git__calloc(1, sizeof(struct delta_info));	GITERR_CHECK_ALLOC(delta);	delta->delta_off = idx->entry_start;	if (git_vector_insert(&idx->deltas, delta) < 0)		return -1;	return 0;}

int git_remote_set_pushurl(git_remote *remote, const char* url){	assert(remote);	git__free(remote->pushurl);	if (url) {		remote->pushurl = git__strdup(url);		GITERR_CHECK_ALLOC(remote->pushurl);	} else {		remote->pushurl = NULL;	}	return 0;}

int git_transaction_config_new(git_transaction **out, git_config *cfg){	git_transaction *tx;	assert(out && cfg);	tx = git__calloc(1, sizeof(git_transaction));	GITERR_CHECK_ALLOC(tx);	tx->type = TRANSACTION_CONFIG;	tx->cfg = cfg;	*out = tx;	return 0;}

int git_blob_create_fromchunks(	git_oid *oid,	git_repository *repo,	const char *hintpath,	int (*source_cb)(char *content, size_t max_length, void *payload),	void *payload){	int error = -1, read_bytes;	char *content = NULL;	git_filebuf file = GIT_FILEBUF_INIT;	git_buf path = GIT_BUF_INIT;	if (git_buf_join_n(		&path, '/', 3, 		git_repository_path(repo),		GIT_OBJECTS_DIR, 		"streamed") < 0)			goto cleanup;	content = git__malloc(BUFFER_SIZE);	GITERR_CHECK_ALLOC(content);	if (git_filebuf_open(&file, git_buf_cstr(&path), GIT_FILEBUF_TEMPORARY) < 0)		goto cleanup;	while (1) {		read_bytes = source_cb(content, BUFFER_SIZE, payload);		assert(read_bytes <= BUFFER_SIZE);		if (read_bytes <= 0)			break;		if (git_filebuf_write(&file, content, read_bytes) < 0)			goto cleanup;	}	if (read_bytes < 0)		goto cleanup;	if (git_filebuf_flush(&file) < 0)		goto cleanup;	error = blob_create_internal(oid, repo, file.path_lock, hintpath, hintpath != NULL);cleanup:	git_buf_free(&path);	git_filebuf_cleanup(&file);	git__free(content);	return error;}

int git_cred_ssh_key_new(	git_cred **cred,	const char *username,	const char *publickey,	const char *privatekey,	const char *passphrase){	git_cred_ssh_key *c;	assert(cred && privatekey);	c = git__calloc(1, sizeof(git_cred_ssh_key));	GITERR_CHECK_ALLOC(c);	c->parent.credtype = GIT_CREDTYPE_SSH_KEY;	c->parent.free = ssh_key_free;	if (username) {		c->username = git__strdup(username);		GITERR_CHECK_ALLOC(c->username);	}	c->privatekey = git__strdup(privatekey);	GITERR_CHECK_ALLOC(c->privatekey);	if (publickey) {		c->publickey = git__strdup(publickey);		GITERR_CHECK_ALLOC(c->publickey);	}	if (passphrase) {		c->passphrase = git__strdup(passphrase);		GITERR_CHECK_ALLOC(c->passphrase);	}	*cred = &c->parent;	return 0;}

int git_blob_create_fromstream(git_writestream **out, git_repository *repo, const char *hintpath){	int error;	git_buf path = GIT_BUF_INIT;	blob_writestream *stream;	assert(out && repo);	stream = git__calloc(1, sizeof(blob_writestream));	GITERR_CHECK_ALLOC(stream);	if (hintpath) {		stream->hintpath = git__strdup(hintpath);		GITERR_CHECK_ALLOC(stream->hintpath);	}	stream->repo = repo;	stream->parent.write = blob_writestream_write;	stream->parent.close = blob_writestream_close;	stream->parent.free  = blob_writestream_free;	if ((error = git_repository_item_path(&path, repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0		|| (error = git_buf_joinpath(&path, path.ptr, "streamed")) < 0)		goto cleanup;	if ((error = git_filebuf_open_withsize(&stream->fbuf, git_buf_cstr(&path), GIT_FILEBUF_TEMPORARY,					       0666, 2 * 1024 * 1024)) < 0)		goto cleanup;	*out = (git_writestream *) stream;cleanup:	if (error < 0)		blob_writestream_free((git_writestream *) stream);	git_buf_dispose(&path);	return error;}

static int annotated_commit_init(	git_annotated_commit **out,	git_repository *repo,	const git_oid *id,	const char *ref_name,	const char *remote_url){	git_annotated_commit *annotated_commit;	int error = 0;	assert(out && id);	*out = NULL;	annotated_commit = git__calloc(1, sizeof(git_annotated_commit));	GITERR_CHECK_ALLOC(annotated_commit);	if (ref_name) {		annotated_commit->ref_name = git__strdup(ref_name);		GITERR_CHECK_ALLOC(annotated_commit->ref_name);	}	if (remote_url) {		annotated_commit->remote_url = git__strdup(remote_url);		GITERR_CHECK_ALLOC(annotated_commit->remote_url);	}	git_oid_fmt(annotated_commit->id_str, id);	annotated_commit->id_str[GIT_OID_HEXSZ] = '/0';	if ((error = git_commit_lookup(&annotated_commit->commit, repo, id)) < 0) {		git_annotated_commit_free(annotated_commit);		return error;	}	*out = annotated_commit;	return error;}

int git_odb_open_wstream(	git_odb_stream **stream, git_odb *db, size_t size, git_otype type){	size_t i, writes = 0;	int error = GIT_ERROR;	git_hash_ctx *ctx = NULL;	assert(stream && db);	for (i = 0; i < db->backends.length && error < 0; ++i) {		backend_internal *internal = (backend_internal *) git_vector_get(&db->backends, i);		git_odb_backend *b = internal->backend;		/* we don't write in alternates! */		if (internal->is_alternate)			continue;		if (b->writestream != NULL) {			++writes;			error = b->writestream(stream, b, size, type);		} else if (b->write != NULL) {			++writes;			error = init_fake_wstream(stream, b, size, type);		}	}	if (error < 0) {		if (error == GIT_PASSTHROUGH)			error = 0;		else if (!writes)			error = git_odb__error_unsupported_in_backend("write object");		goto done;	}	ctx = (git_hash_ctx*) git__malloc(sizeof(git_hash_ctx));	GITERR_CHECK_ALLOC(ctx);	if ((error = git_hash_ctx_init(ctx)) < 0)		goto done;	hash_header(ctx, size, type);	(*stream)->hash_ctx = ctx;	(*stream)->declared_size = size;	(*stream)->received_bytes = 0;done:	return error;}

static int note_new(	git_note **out,	git_oid *note_oid,	git_commit *commit,	git_blob *blob){	git_note *note = NULL;	note = (git_note *)git__malloc(sizeof(git_note));	GITERR_CHECK_ALLOC(note);	git_oid_cpy(&note->id, note_oid);	if (git_signature_dup(&note->author, git_commit_author(commit)) < 0 ||		git_signature_dup(&note->committer, git_commit_committer(commit)) < 0)		return -1;	note->message = git__strndup(git_blob_rawcontent(blob), git_blob_rawsize(blob));	GITERR_CHECK_ALLOC(note->message);	*out = note;	return 0;}

static int ok_pkt(git_pkt **out, const char *line, size_t len){	git_pkt_ok *pkt;	const char *ptr;	pkt = git__malloc(sizeof(*pkt));	GITERR_CHECK_ALLOC(pkt);	pkt->type = GIT_PKT_OK;	line += 3; /* skip "ok " */	ptr = strchr(line, '/n');	len = ptr - line;	pkt->ref = git__malloc(len + 1);	GITERR_CHECK_ALLOC(pkt->ref);	memcpy(pkt->ref, line, len);	pkt->ref[len] = '/0';	*out = (git_pkt *)pkt;	return 0;}

static int find_by_path(const git_config_entry *entry, void *payload){	fbp_data *data = payload;	if (!strcmp(entry->value, data->path)) {		const char *fdot, *ldot;		fdot = strchr(entry->name, '.');		ldot = strrchr(entry->name, '.');		data->name = git__strndup(fdot + 1, ldot - fdot - 1);		GITERR_CHECK_ALLOC(data->name);	}	return 0;}

int git_signature__pdup(git_signature **dest, const git_signature *source, git_pool *pool){	git_signature *signature;	if (source == NULL)		return 0;	signature = git_pool_mallocz(pool, sizeof(git_signature));	GITERR_CHECK_ALLOC(signature);	signature->name = git_pool_strdup(pool, source->name);	GITERR_CHECK_ALLOC(signature->name);	signature->email = git_pool_strdup(pool, source->email);	GITERR_CHECK_ALLOC(signature->email);	signature->when.time = source->when.time;	signature->when.offset = source->when.offset;	*dest = signature;	return 0;}

int git_signature_dup(git_signature **dest, const git_signature *source){	git_signature *signature;	if (source == NULL)		return 0;	signature = git__calloc(1, sizeof(git_signature));	GITERR_CHECK_ALLOC(signature);	signature->name = git__strdup(source->name);	GITERR_CHECK_ALLOC(signature->name);	signature->email = git__strdup(source->email);	GITERR_CHECK_ALLOC(signature->email);	signature->when.time = source->when.time;	signature->when.offset = source->when.offset;	*dest = signature;	return 0;}

int git_cred_ssh_custom_new(	git_cred **cred,	const char *username,	const char *publickey,	size_t publickey_len,	git_cred_sign_callback sign_callback,	void *sign_data){	git_cred_ssh_custom *c;	assert(cred);	c = git__calloc(1, sizeof(git_cred_ssh_custom));	GITERR_CHECK_ALLOC(c);	c->parent.credtype = GIT_CREDTYPE_SSH_CUSTOM;	c->parent.free = ssh_custom_free;	if (username) {		c->username = git__strdup(username);		GITERR_CHECK_ALLOC(c->username);	}	if (publickey_len > 0) {		c->publickey = git__malloc(publickey_len);		GITERR_CHECK_ALLOC(c->publickey);		memcpy(c->publickey, publickey, publickey_len);	}	c->publickey_len = publickey_len;	c->sign_callback = sign_callback;	c->sign_data = sign_data;	*cred = &c->parent;	return 0;}

static int negotiate_set_challenge(    git_http_auth_context *c,    const char *challenge){    http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c;    assert(ctx && ctx->configured && challenge);    git__free(ctx->challenge);    ctx->challenge = git__strdup(challenge);    GITERR_CHECK_ALLOC(ctx->challenge);    return 0;}

int git_cred_default_new(git_cred **cred){	git_cred_default *c;	assert(cred);	c = git__calloc(1, sizeof(git_cred_default));	GITERR_CHECK_ALLOC(c);	c->credtype = GIT_CREDTYPE_DEFAULT;	c->free = default_free;	*cred = c;	return 0;}

static int rebase_init_merge(	git_rebase *rebase,	git_repository *repo,	const git_annotated_commit *branch,	const git_annotated_commit *upstream,	const git_annotated_commit *onto){	if (rebase_init_operations(rebase, repo, branch, upstream, onto) < 0)		return -1;	rebase->onto_name = git__strdup(rebase_onto_name(onto));	GITERR_CHECK_ALLOC(rebase->onto_name);	return 0;}

int git_proxy_options_dup(git_proxy_options *tgt, const git_proxy_options *src){	if (!src) {		git_proxy_init_options(tgt, GIT_PROXY_OPTIONS_VERSION);		return 0;	}	memcpy(tgt, src, sizeof(git_proxy_options));	if (src->url) {		tgt->url = git__strdup(src->url);		GITERR_CHECK_ALLOC(tgt->url);	}	return 0;}

int git_reader_for_tree(git_reader **out, git_tree *tree){	tree_reader *reader;	assert(out && tree);	reader = git__calloc(1, sizeof(tree_reader));	GITERR_CHECK_ALLOC(reader);	reader->reader.read = tree_reader_read;	reader->tree = tree;	*out = (git_reader *)reader;	return 0;}

int git_refdb_new(git_refdb **out, git_repository *repo){	git_refdb *db;	assert(out && repo);	db = git__calloc(1, sizeof(*db));	GITERR_CHECK_ALLOC(db);	db->repo = repo;	*out = db;	GIT_REFCOUNT_INC(db);	return 0;}

static int rebase_alloc(git_rebase **out, const git_rebase_options *rebase_opts){	git_rebase *rebase = git__calloc(1, sizeof(git_rebase));	GITERR_CHECK_ALLOC(rebase);	*out = NULL;	if (rebase_opts)		memcpy(&rebase->options, rebase_opts, sizeof(git_rebase_options));	else		git_rebase_init_options(&rebase->options, GIT_REBASE_OPTIONS_VERSION);	if (rebase_opts && rebase_opts->rewrite_notes_ref) {		rebase->options.rewrite_notes_ref = git__strdup(rebase_opts->rewrite_notes_ref);		GITERR_CHECK_ALLOC(rebase->options.rewrite_notes_ref);	}	if ((rebase->options.checkout_options.checkout_strategy & (GIT_CHECKOUT_SAFE | GIT_CHECKOUT_FORCE)) == 0)		rebase->options.checkout_options.checkout_strategy = GIT_CHECKOUT_SAFE;	*out = rebase;	return 0;}

int git_odb_new(git_odb **out){	git_odb *db = (git_odb*) git__calloc(1, sizeof(*db));	GITERR_CHECK_ALLOC(db);	if (git_cache_init(&db->own_cache) < 0 ||		git_vector_init(&db->backends, 4, backend_sort_cmp) < 0) {		git__free(db);		return -1;	}	*out = db;	GIT_REFCOUNT_INC(db);	return 0;}

int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_signature *committer, const char *msg){	git_reflog_entry *entry;	const git_reflog_entry *previous;	const char *newline;	assert(reflog && new_oid && committer);	entry = git__calloc(1, sizeof(git_reflog_entry));	GITERR_CHECK_ALLOC(entry);	if ((git_signature_dup(&entry->committer, committer)) < 0)		goto cleanup;	if (msg != NULL) {		if ((entry->msg = git__strdup(msg)) == NULL)			goto cleanup;		newline = strchr(msg, '/n');		if (newline) {			if (newline[1] != '/0') {				giterr_set(GITERR_INVALID, "Reflog message cannot contain newline");				goto cleanup;			}			entry->msg[newline - msg] = '/0';		}	}	previous = git_reflog_entry_byindex(reflog, 0);	if (previous == NULL)		git_oid_fromstr(&entry->oid_old, GIT_OID_HEX_ZERO);	else		git_oid_cpy(&entry->oid_old, &previous->oid_cur);	git_oid_cpy(&entry->oid_cur, new_oid);	if (git_vector_insert(&reflog->entries, entry) < 0)		goto cleanup;	return 0;cleanup:	git_reflog_entry__free(entry);	return -1;}

static int init_bio_method(void){	/* Set up the BIO_METHOD we use for wrapping our own stream implementations */	git_stream_bio_method = BIO_meth_new(BIO_TYPE_SOURCE_SINK | BIO_get_new_index(), "git_stream");	GITERR_CHECK_ALLOC(git_stream_bio_method);	BIO_meth_set_write(git_stream_bio_method, bio_write);	BIO_meth_set_read(git_stream_bio_method, bio_read);	BIO_meth_set_puts(git_stream_bio_method, bio_puts);	BIO_meth_set_gets(git_stream_bio_method, bio_gets);	BIO_meth_set_ctrl(git_stream_bio_method, bio_ctrl);	BIO_meth_set_create(git_stream_bio_method, bio_create);	BIO_meth_set_destroy(git_stream_bio_method, bio_destroy);	return 0;}

static int tag_list_cb(const char *tag_name, git_oid *oid, void *data){    tag_filter_data *filter = (tag_filter_data *)data;    GIT_UNUSED(oid);    if (!*filter->pattern ||            p_fnmatch(filter->pattern, tag_name + GIT_REFS_TAGS_DIR_LEN, 0) == 0)    {        char *matched = git__strdup(tag_name + GIT_REFS_TAGS_DIR_LEN);        GITERR_CHECK_ALLOC(matched);        return git_vector_insert(filter->taglist, matched);    }    return 0;}

int git_curl_stream_new(git_stream **out, const char *host, const char *port){	curl_stream *st;	CURL *handle;	int iport = 0, error;	st = git__calloc(1, sizeof(curl_stream));	GITERR_CHECK_ALLOC(st);	handle = curl_easy_init();	if (handle == NULL) {		giterr_set(GITERR_NET, "failed to create curl handle");		git__free(st);		return -1;	}	if ((error = git__strtol32(&iport, port, NULL, 10)) < 0) {		git__free(st);		return error;	}	curl_easy_setopt(handle, CURLOPT_URL, host);	curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, st->curl_error);	curl_easy_setopt(handle, CURLOPT_PORT, iport);	curl_easy_setopt(handle, CURLOPT_CONNECT_ONLY, 1);	curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 1);	curl_easy_setopt(handle, CURLOPT_CERTINFO, 1);	curl_easy_setopt(handle, CURLOPT_HTTPPROXYTUNNEL, 1);	curl_easy_setopt(handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY);	/* curl_easy_setopt(handle, CURLOPT_VERBOSE, 1); */	st->parent.version = GIT_STREAM_VERSION;	st->parent.encrypted = 0; /* we don't encrypt ourselves */	st->parent.proxy_support = 1;	st->parent.connect = curls_connect;	st->parent.certificate = curls_certificate;	st->parent.set_proxy = curls_set_proxy;	st->parent.read = curls_read;	st->parent.write = curls_write;	st->parent.close = curls_close;	st->parent.free = curls_free;	st->handle = handle;	*out = (git_stream *) st;	return 0;}

int git_patch_from_buffer(	git_patch **out,	const char *content,	size_t content_len,	const git_patch_options *opts){	git_patch_parse_ctx *ctx;	int error;	ctx = git_patch_parse_ctx_init(content, content_len, opts);	GITERR_CHECK_ALLOC(ctx);	error = git_patch_parse(out, ctx);	git_patch_parse_ctx_free(ctx);	return error;}

int git_smart_subtransport_git(git_smart_subtransport **out, git_transport *owner){	git_subtransport *t;	if (!out)		return -1;	t = (git_subtransport *)git__calloc(sizeof(git_subtransport), 1);	GITERR_CHECK_ALLOC(t);	t->owner = owner;	t->parent.action = _git_action;	t->parent.free = _git_free;	*out = (git_smart_subtransport *) t;	return 0;}