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

intparse_param(void *val, AVP_List** avps) {    char *p;    str *s, content;    AVP_List *mp = NULL;    //LM_DBG("%.*s/n", content.len, content.s);    content.s = (char*) val;    content.len = strlen(content.s);    p = (char*) pkg_malloc (content.len + 1);    CHECK_ALLOC(p);    p[content.len] = '/0';    memcpy(p, content.s, content.len);    s = (str*) pkg_malloc(sizeof(str));    CHECK_ALLOC(s);    for (;*p != '/0';) {        mp = (AVP_List*) pkg_malloc (sizeof(AVP_List));        CHECK_ALLOC(mp);        mp->next = *avps;        mp->pv = (pv_spec_p) pkg_malloc (sizeof(pv_spec_t));        CHECK_ALLOC(mp->pv);        for (; isspace(*p); p++);        CHECK_COND(*p != '/0');        mp->name.s = p;        for(; isgraph(*p) && *p != '='; p++)            CHECK_COND(*p != '/0');        mp->name.len = p - mp->name.s;        for (; isspace(*p); p++);        CHECK_COND(*p != '/0' && *p == '=');        p++;        //LM_DBG("%.*s/n", mp->name.len, mp->name.s);        for (; isspace(*p); p++);        CHECK_COND(*p != '/0' && *p == '$');        s->s = p;        s->len = strlen(p);        p = pv_parse_spec(s, mp->pv);        for (; isspace(*p); p++);        *avps = mp;    }    return 0;}

void matrix_map_row(matrix_t* mat, const matrix_row_t* row, const offset_t i) {    if( matrix_row( mat, i ) != NULL ) {        //printf(" problem, sir" );        return;    }    // allocate space to copy the row    size_t copy_size =  (mat->num_mapped_rows+1)*sizeof(mapped_row_t);    mat->mapped_rows = (mapped_row_t*)realloc( mat->mapped_rows, copy_size );    CHECK_ALLOC( mat->mapped_rows );    // setup the mapped row    copy_size = sizeof(matrix_row_t);    mapped_row_t* mapped_row = &(mat->mapped_rows[mat->num_mapped_rows]);    mapped_row->i = i;    memcpy( &(mapped_row->row), row, copy_size );    assert( row->num_cells >= 0 );    assert( row->num_cells <= mat->n );    // allocate space for the copied cells and copy them    copy_size = row->num_cells * sizeof(cell_t);    mapped_row->row.cells = (cell_t*)malloc( copy_size );    CHECK_ALLOC( mapped_row->row.cells );    memcpy( mapped_row->row.cells, row->cells, copy_size );    mat->num_mapped_rows++;    assert( mat->num_mapped_rows <= mat->m - matrix_num_rows( mat ) );}

int parse_sets_func(unsigned int type, void *val) {	rad_set_elem *elem;	char *p = (char*) val, *pp = NULL;	str content;	int nr;	elem = (rad_set_elem*) pkg_malloc (sizeof(rad_set_elem));	CHECK_ALLOC(elem);	for (; isspace(*p); p++);	CHECK_COND(*p != '/0');	elem->set_name.s = p;	for(;isgraph(*p) && *p != '='; p++)	CHECK_COND(*p != '/0');	elem->set_name.len = p - elem->set_name.s;	for (; isspace(*p); p++);	CHECK_COND(*p != '/0' && *p == '=');	p++;	for (; isspace(*p); p++);	CHECK_COND(*p != '/0' && *p == '(');	p++;	CHECK_COND(*p != '/0');	elem->parsed = NULL;	content.s = p;	nr = 1;	for (; *p != '/0'; p++) {		if (*p == '(')			nr++;		if (*p == ')')			pp = p, nr--;	}	CHECK_COND(pp && !nr);	content.len = (pp - content.s) * sizeof(char);	set_size++;	sets = (rad_set_elem**) pkg_realloc (sets, set_size * sizeof(rad_set_elem*));	CHECK_ALLOC(sets);	sets[set_size - 1] = elem;	if (parse_set_content(content, elem)) {		LM_ERR("malformed modparam %.*s/n",sets[set_size - 1]->set_name.len,				sets[set_size - 1]->set_name.s);		return -1;	}	return 0;}

/* * allocates hash tables labels and provides a pointer to the data structure * has to be freed using freeSenna */SENNA* sennaCreate(const char * opt_path) {    SENNA* senna = (SENNA*) malloc(sizeof(SENNA));    CHECK_ALLOC(senna);    senna->word_hash = SENNA_Hash_new(opt_path, "hash/words.lst");    senna->caps_hash = SENNA_Hash_new(opt_path, "hash/caps.lst");    senna->suff_hash = SENNA_Hash_new(opt_path, "hash/suffix.lst");    senna->gazt_hash = SENNA_Hash_new(opt_path, "hash/gazetteer.lst");    senna->gazl_hash = SENNA_Hash_new_with_admissible_keys(opt_path, "hash/ner.loc.lst", "data/ner.loc.dat");    senna->gazm_hash = SENNA_Hash_new_with_admissible_keys(opt_path, "hash/ner.msc.lst", "data/ner.msc.dat");    senna->gazo_hash = SENNA_Hash_new_with_admissible_keys(opt_path, "hash/ner.org.lst", "data/ner.org.dat");    senna->gazp_hash = SENNA_Hash_new_with_admissible_keys(opt_path, "hash/ner.per.lst", "data/ner.per.dat");    // labels    senna->pos_hash = SENNA_Hash_new(opt_path, "hash/pos.lst");    // senna->chk_hash = SENNA_Hash_new(opt_path, "hash/chk.lst");    // senna->pt0_hash = SENNA_Hash_new(opt_path, "hash/pt0.lst");    // senna->ner_hash = SENNA_Hash_new(opt_path, "hash/ner.lst");    // senna->vbs_hash = SENNA_Hash_new(opt_path, "hash/vbs.lst");    // senna->srl_hash = SENNA_Hash_new(opt_path, "hash/srl.lst");    senna->psg_left_hash = SENNA_Hash_new(opt_path, "hash/psg-left.lst");    senna->psg_right_hash = SENNA_Hash_new(opt_path, "hash/psg-right.lst");    senna->pos = SENNA_POS_new(opt_path, "data/pos.dat");    // senna->chk = SENNA_CHK_new(opt_path, "data/chk.dat");    // senna->pt0 = SENNA_PT0_new(opt_path, "data/pt0.dat");    // senna->ner = SENNA_NER_new(opt_path, "data/ner.dat");    // senna->vbs = SENNA_VBS_new(opt_path, "data/vbs.dat");    // senna->srl = SENNA_SRL_new(opt_path, "data/srl.dat");    senna->psg = SENNA_PSG_new(opt_path, "data/psg.dat");    senna->tokenizer = SENNA_Tokenizer_new(                           senna->word_hash,                           senna->caps_hash,                           senna->suff_hash,                           senna->gazt_hash,                           senna->gazl_hash,                           senna->gazm_hash,                           senna->gazo_hash,                           senna->gazp_hash,                           0);    senna->lastSentence.tokens = NULL;    senna->lastSentence.pos_labels = NULL;    senna->lastSentence.psg_labels = NULL;    senna->strbuf.ptr = (char *) malloc(sizeof(char) * 512);    CHECK_ALLOC(senna->strbuf.ptr);    senna->strbuf.length = 512;    senna->strbuf.pos = 0;    return senna;}

blargg_err_t Nes_Cart::load_patched_ines( Auto_File_Reader in, Auto_File_Reader patch ){	RETURN_ERR( in.open() );	RETURN_ERR( patch.open() );		// read file into memory	long size = in->remain();	byte* ines = (byte*) malloc( size );	CHECK_ALLOC( ines );	const char* err = in->read( ines, size );		// apply patch	if ( !err )		err = apply_ips_patch( *patch, &ines, &size );		// load patched file	if ( !err )	{		Mem_File_Reader patched( ines, size );		err = load_ines( patched );	}		free( ines );		return err;}

CVisualPin* CVisualNode::AddPin(bool fInput, LONG_PTR pData, const CAtlStringW& strLabel, int nPinId){    HRESULT hr;    CVisualPin* pPin = new CVisualPin(this,                             CVisualRect(0, 0, PIN_WIDTH, PIN_HEIGHT),                             (fInput) ? CVisualObject::INPUT : CVisualObject::OUTPUT, strLabel, nPinId);    CHECK_ALLOC( pPin );        pPin->SetData(pData);    if(fInput)    {        m_InputPins.Add(pPin);    }    else    {        m_OutputPins.Add(pPin);    }    pPin->SetHandler(ms_pPinHandler);       RecalcPins();Cleanup:    return pPin;}

gme_err_t gme_set_track_info( Music_Emu * me, gme_info_t* in, int track ){	track_info_t* info = BLARGG_NEW track_info_t;	CHECK_ALLOC( info );	#define COPY(name) info->name = in->name;		COPY( length );	COPY( intro_length );	COPY( loop_length );	#undef COPY#define COPY(name) if ( in->name ) strncpy( info->name, in->name, sizeof(info->name) - 1 ), info->name[sizeof(info->name)-1] = '/0'; else info->name[0] = '/0';    	COPY( system );	COPY( game );	COPY( song );	COPY( author );	COPY( copyright );	COPY( comment );	COPY( dumper );	#undef COPY		blargg_err_t err = me->set_track_info( info, track );        delete info;        return err;}

static inthttp_client_on_header_value(struct http_parser *p, const char *at, size_t sz) {	struct http_client *c = p->data;	size_t n = c->header_count;	/* Add data to the current header value. */	CHECK_ALLOC(c, c->headers[n-1].val = realloc(c->headers[n-1].val,			c->headers[n-1].val_sz + sz + 1));	memcpy(c->headers[n-1].val + c->headers[n-1].val_sz, at, sz);	c->headers[n-1].val_sz += sz;	c->headers[n-1].val[c->headers[n-1].val_sz] = 0;	c->last_cb = LAST_CB_VAL;	/* react to some values. */	if(strncmp("Expect", c->headers[n-1].key, c->headers[n-1].key_sz) == 0) {		if(sz == 12 && strncasecmp(at, "100-continue", sz) == 0) {			/* support HTTP file upload */			char http100[] = "HTTP/1.1 100 Continue/r/n/r/n";			int ret = write(c->fd, http100, sizeof(http100)-1);			(void)ret;		}	} else if(strncasecmp("Connection", c->headers[n-1].key, c->headers[n-1].key_sz) == 0) {		if(sz == 10 && strncasecmp(at, "Keep-Alive", sz) == 0) {			c->keep_alive = 1;		}	}	return 0;}

blargg_err_t Nes_Blitter::init(){	CHECK_ALLOC( ntsc = (nes_ntsc_emph_t*) malloc( sizeof *ntsc ) );	static setup_t const s = { };	setup_ = s;	setup_.ntsc = nes_ntsc_composite;	return setup( setup_ );}

void comm_schedule_init( comm_schedule_t* schedule, MPI_Comm comm ) {    rank_t p, r;    MPI_CALL( MPI_Comm_size(comm, &p) );    MPI_CALL( MPI_Comm_rank(comm, &r) );    schedule->comm = comm;    schedule->map_size = p*p*sizeof(offset_t);    schedule->comm_map = (offset_t*)malloc( schedule->map_size );    CHECK_ALLOC( schedule->comm_map );    memset( schedule->comm_map, 0, schedule->map_size );    schedule->map_size = p*sizeof(offset_t*);    schedule->recv_cols = (offset_t**)malloc( schedule->map_size );    CHECK_ALLOC(schedule->recv_cols);    memset( schedule->recv_cols, 0, schedule->map_size );}

static blargg_err_t new_opl_apu( Opl_Apu::type_t type, Opl_Apu** out ){	check( !*out );	CHECK_ALLOC( *out = BLARGG_NEW( Opl_Apu ) );	blip_time_t const period = 72;	int const rate = clock_rate / period;	return (*out)->init( rate * period, rate, period, type );}

void matrix_deserialize( matrix_t* mat, const char* buf ) {    size_t offset = 0;    size_t copy_size = 0;    // copy matrix    copy_size = sizeof(matrix_t);    memcpy( mat, buf, copy_size );    offset += copy_size;    // explicitly set this null to avoid problems.    mat->num_mapped_rows = 0;    mat->mapped_rows = NULL;    LOG(LOG_DEBUG, "deserializing matrix... from_i=%lu, to_i=%lu. #=%lu/n", mat->from_i, mat->to_i, matrix_num_rows(mat) );    // copy rows    copy_size = matrix_num_rows(mat) * sizeof(matrix_row_t);    mat->rows = (matrix_row_t*)malloc( copy_size );    CHECK_ALLOC( mat->rows );    memset( mat->rows, 0, copy_size );    memcpy( matrix_row(mat, mat->from_i), buf + offset, copy_size );    offset += copy_size;    LOG(LOG_DEBUG, "deserializing matrix... from_i=%lu, to_i=%lu/n", mat->from_i, mat->to_i );    // copy cells of each row    offset_t i;    for( i = mat->from_i; i <= mat->to_i; i++ ) {        matrix_row_t* row = matrix_row(mat, i);        assert( row != NULL );        assert( row->num_cells <= mat->n );        LOG(LOG_DEBUG, "(%lu) has %lu/n", i, row->num_cells);        if( row->num_cells > 0 ) {            copy_size = row->num_cells * sizeof(cell_t);            row->cells = (cell_t*)malloc( copy_size );            CHECK_ALLOC( row->cells );            memcpy( row->cells, buf + offset, row->num_cells * sizeof(cell_t) );            offset += copy_size;        }    }}

blargg_err_t Nes_Vrc7_Apu::init(){    CHECK_ALLOC( opll = ym2413_init( 3579545, 3579545 / 72, 1 ) );    set_output( 0 );    volume( 1.0 );    reset();    return 0;}

const char * Nes_State_Writer::end( Nes_Emu const& emu ){    Nes_State* state = BLARGG_NEW Nes_State;    CHECK_ALLOC( state );    emu.save_state( state );    const char * err = end( *state );    delete state;    return err;}

blargg_err_t Nes_Emu::save_state( Auto_File_Writer out ) const{    Nes_State* state = BLARGG_NEW Nes_State;    CHECK_ALLOC( state );    save_state( state );    blargg_err_t err = state->write( out );    delete state;    return err;}

// avoid using new []blargg_err_t Effects_Buffer::new_bufs( int size ){    bufs = (buf_t*) malloc( size * sizeof *bufs );    CHECK_ALLOC( bufs );    for ( int i = 0; i < size; i++ )        new (bufs + i) buf_t;    bufs_size = size;    return 0;}

/** Allocate a new memory pool to hold items of size <b>item_size</b>. We'll * try to fit about <b>chunk_capacity</b> bytes in each chunk. */mp_pool_t *mp_pool_new(size_t item_size, size_t chunk_capacity){  mp_pool_t *pool;  size_t alloc_size, new_chunk_cap;  tor_assert(item_size < SIZE_T_CEILING);  tor_assert(chunk_capacity < SIZE_T_CEILING);  tor_assert(SIZE_T_CEILING / item_size > chunk_capacity);  pool = ALLOC(sizeof(mp_pool_t));  CHECK_ALLOC(pool);  memset(pool, 0, sizeof(mp_pool_t));  /* First, we figure out how much space to allow per item.  We'll want to   * use make sure we have enough for the overhead plus the item size. */  alloc_size = (size_t)(STRUCT_OFFSET(mp_allocated_t, u.mem) + item_size);  /* If the item_size is less than sizeof(next_free), we need to make   * the allocation bigger. */  if (alloc_size < sizeof(mp_allocated_t))    alloc_size = sizeof(mp_allocated_t);  /* If we're not an even multiple of ALIGNMENT, round up. */  if (alloc_size % ALIGNMENT) {    alloc_size = alloc_size + ALIGNMENT - (alloc_size % ALIGNMENT);  }  if (alloc_size < ALIGNMENT)    alloc_size = ALIGNMENT;  ASSERT((alloc_size % ALIGNMENT) == 0);  /* Now we figure out how many items fit in each chunk.  We need to fit at   * least 2 items per chunk. No chunk can be more than MAX_CHUNK bytes long,   * or less than MIN_CHUNK. */  if (chunk_capacity > MAX_CHUNK)    chunk_capacity = MAX_CHUNK;  /* Try to be around a power of 2 in size, since that's what allocators like   * handing out. 512K-1 byte is a lot better than 512K+1 byte. */  chunk_capacity = (size_t) round_to_power_of_2(chunk_capacity);  while (chunk_capacity < alloc_size * 2 + CHUNK_OVERHEAD)    chunk_capacity *= 2;  if (chunk_capacity < MIN_CHUNK)    chunk_capacity = MIN_CHUNK;  new_chunk_cap = (chunk_capacity-CHUNK_OVERHEAD) / alloc_size;  tor_assert(new_chunk_cap < INT_MAX);  pool->new_chunk_capacity = (int)new_chunk_cap;  pool->item_alloc_size = alloc_size;  log_debug(LD_MM, "Capacity is %lu, item size is %lu, alloc size is %lu",            (unsigned long)pool->new_chunk_capacity,            (unsigned long)pool->item_alloc_size,            (unsigned long)(pool->new_chunk_capacity*pool->item_alloc_size));  return pool;}

inthttp_client_add_to_body(struct http_client *c, const char *at, size_t sz) {	CHECK_ALLOC(c, c->body = realloc(c->body, c->body_sz + sz + 1));	memcpy(c->body + c->body_sz, at, sz);	c->body_sz += sz;	c->body[c->body_sz] = 0;	return 0;}

char *get_device_name(cl_device_id device) {    size_t name_len;    CHECK(clGetDeviceInfo(device, CL_DEVICE_NAME, 0, NULL, &name_len));    char *device_name = (char *)malloc(name_len + 1);    CHECK_ALLOC(device_name);    CHECK(clGetDeviceInfo(device, CL_DEVICE_NAME, name_len, device_name,                NULL));    device_name[name_len] = '/0';    return device_name;}

blargg_err_t Sms_Fm_Apu::init( double clock_rate, double sample_rate ){	period_ = clock_rate / sample_rate + 0.5;	CHECK_ALLOC( !apu.set_rate( sample_rate, clock_rate ) );		set_output( 0 );	volume( 1.0 );	reset();	return blargg_ok;}

blargg_err_t Classic_Emu::set_sample_rate_( long rate ){	if ( !buf )	{		if ( !stereo_buffer )			CHECK_ALLOC( stereo_buffer = BLARGG_NEW Stereo_Buffer );		buf = stereo_buffer;	}	return buf->set_sample_rate( rate, 1000 / 20 );}

blargg_err_t Nes_Cart::resize_chr( long size ){	if ( size != chr_size_ )	{		void* p = realloc( chr_, round_to_bank_size( size ) );		CHECK_ALLOC( p || !size );		chr_ = (byte*) p;		chr_size_ = size;	}	return 0;}

blargg_err_t Nes_Vrc7_Apu::init(){	CHECK_ALLOC( opll = OPLL_new( 3579545, 3579545 / 72 ) );	OPLL_SetChipMode((OPLL *) opll, 1);	OPLL_setPatch((OPLL *) opll, vrc7_inst);	set_output( 0 );	volume( 1.0 );	reset();	return 0;}

const char * Nes_Core::init(){	if ( !impl )	{		CHECK_ALLOC( impl = BLARGG_NEW impl_t );		impl->apu.dmc_reader( read_dmc, this );		impl->apu.irq_notifier( apu_irq_changed, this );	}		return 0;}

static inthttp_client_on_url(struct http_parser *p, const char *at, size_t sz) {	struct http_client *c = p->data;	CHECK_ALLOC(c, c->path = realloc(c->path, c->path_sz + sz + 1));	memcpy(c->path + c->path_sz, at, sz);	c->path_sz += sz;	c->path[c->path_sz] = 0;	return 0;}

/* *  appTeardown() * *    Teardown all modules, close all files, and tidy up all *    application state. * *    This function is idempotent. */static voidappTeardown(    void){    static int teardownFlag = 0;    RBLIST *iter;    transfer_t *sndr;    if (teardownFlag) {        return;    }    teardownFlag = 1;    if (!daemonized) {        rbdestroy(transfers);        skDLListDestroy(duplicate_dirs);        skDLListDestroy(open_file_list);        skdaemonTeardown();        skAppUnregister();        return;    }    NOTICEMSG("Begin shutting down...");    shuttingdown = 1;    transferShutdown();    transferTeardown();    /* Destroy stuff */    iter = rbopenlist(transfers);    CHECK_ALLOC(iter);    while ((sndr = (transfer_t *)rbreadlist(iter)) != NULL) {        if (sndr->ident != NULL) {            free(sndr->ident);        }        if (sndr->addr) {            skSockaddrArrayDestroy(sndr->addr);        }        free(sndr);    }    rbcloselist(iter);    rbdestroy(transfers);    skDLListDestroy(duplicate_dirs);    skDLListDestroy(open_file_list);    NOTICEMSG("Finished shutting down.");    skdaemonTeardown();    skthread_teardown();    skAppUnregister();}

static blargg_err_t apply_ips_patch( Data_Reader& patch, byte** file, long* file_size ){	byte signature [5];	RETURN_ERR( patch.read( signature, sizeof signature ) );	if ( memcmp( signature, "PATCH", sizeof signature ) )		return "Not an IPS patch file";		while ( patch.remain() )	{		// read offset		byte buf [6];		RETURN_ERR( patch.read( buf, 3 ) );		long offset = buf [0] * 0x10000 + buf [1] * 0x100 + buf [2];		if ( offset == 0x454F46 ) // 'EOF'			break;				// read size		RETURN_ERR( patch.read( buf, 2 ) );		long size = buf [0] * 0x100 + buf [1];				// size = 0 signals a run of identical bytes		int fill = -1;		if ( size == 0 )		{			RETURN_ERR( patch.read( buf, 3 ) );			size = buf [0] * 0x100 + buf [1];			fill = buf [2];		}				// expand file if new data is at exact end of file		if ( offset == *file_size )		{			*file_size = offset + size;			void* p = realloc( *file, *file_size );			CHECK_ALLOC( p );			*file = (byte*) p;		}				//dprintf( "Patch offset: 0x%04X, size: 0x%04X/n", (int) offset, (int) size );				if ( offset < 0 || *file_size < offset + size )			return "IPS tried to patch past end of file";				// read/fill data		if ( fill < 0 )			RETURN_ERR( patch.read( *file + offset, size ) );		else			memset( *file + offset, fill, size );	}		return 0;}

static void connection_cb(uv_stream_t* s, int status) {  int err;  conn_t* conn;  CHECK_ALLOC(conn = malloc(sizeof(*conn)));  CHECK(uv_tcp_init(uv_default_loop(), &conn->tcp));  CHECK(uv_accept(s, (uv_stream_t*) &conn->tcp));  CHECK(uv_link_source_init(&conn->source, (uv_stream_t*) &conn->tcp));  CHECK(uv_link_observer_init(&conn->observer));  CHECK_ALLOC(conn->http = uv_http_create(request_cb, &err));  CHECK(err);  CHECK(uv_link_chain((uv_link_t*) &conn->source, (uv_link_t*) conn->http));  CHECK(uv_link_chain((uv_link_t*) conn->http,                      (uv_link_t*) &conn->observer));  conn->observer.observer_read_cb = read_cb;  conn->observer.data = conn;  CHECK(uv_link_read_start((uv_link_t*) &conn->observer));}