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

void dC23(){	uint32_t result;	while(1)	{		uint8_t s = read_uint8("start_dc_23");		__CrossProcess(X2,X3,CHUNK_SIZE,result);		write_uint32("result_dc_23", result);	}}

void dC33(){	uint32_t result;	while(1)	{		uint8_t s = read_uint8("start_dc_33");		__CrossProcess(X3,X3,0,result);		write_uint32("result_dc_33", result);	}}

void dC12(){	uint32_t result;	while(1)	{		uint8_t s = read_uint8("start_dc_12");		__CrossProcess(X1,X2,CHUNK_SIZE,result);		write_uint32("result_dc_12", result);	}}

void dC22(){	uint32_t result;	while(1)	{		uint8_t s = read_uint8("start_dc_22");		__CrossProcess(X2,X2,0,result);		write_uint32("result_dc_22", result);	}}

void dC01(){	uint32_t result;	while(1)	{		uint8_t s = read_uint8("start_dc_01");		__CrossProcess(X0,X1,CHUNK_SIZE,result);		write_uint32("result_dc_01", result);	}}

void dC11(){	uint32_t result;	while(1)	{		uint8_t s = read_uint8("start_dc_11");		__CrossProcess(X1,X1,0,result);		write_uint32("result_dc_11", result);	}}

int foo(int a){	int b;      	write_uint32(&(p1[0].id[0]),a);	b = read_uint32("pipe2");	return(b);}

// calculate all pairwise errors.void dC00(){	uint32_t result;	while(1)	{		uint8_t s = read_uint8("start_dc_00");		__CrossProcess(X0,X0,0,result);		write_uint32("result_dc_00", result);	}}

static int writer_uint32(lua_State* L){	writer_t* writer 	= lua_touserdata(L, 1);	lua_Integer integer = luaL_checkinteger(L, 2);	if(integer < 0 || integer > UINT32_MAX)		luaL_error(L, "unsigned overflow");		write_uint32(writer, (uint32_t)integer);	return 0;}

int main(int argc, char* argv[]){	signal(SIGINT,  Exit);  	signal(SIGTERM, Exit);	write_uint32("in_data", 16);	uint32_t v = read_uint32("out_data");		if(v != 16)		fprintf(stderr,"Error: received %d, expected %d/n", v, 16);	return(0);}

void slave_0(){	while(1)	{		uint8_t s = read_uint8("start_slave_0");		float bc;		int bi;#ifdef USE2		__correlatorBase(ref_vector_0, check_vectors_0, bc, bi, NUM_VECS_BY_2);		write_float32("best_correlation_0_pipe",bc);		write_uint32("best_index_0_pipe",bi);#else		__correlatorBase(ref_vector, check_vectors, bc, bi, NUM_VECS);		write_float32("best_correlation_0_pipe",bc);		write_uint32("best_index_0_pipe",bi);#endif	}}

int opus_header_to_packet(const OpusHeader *h, unsigned char *packet, int len){   int i;   Packet p;   unsigned char ch;   p.data = packet;   p.maxlen = len;   p.pos = 0;   if (len<19)return 0;   if (!write_chars(&p, (const unsigned char*)"OpusHead", 8))      return 0;   /* Version is 1 */   ch = 1;   if (!write_chars(&p, &ch, 1))      return 0;   ch = h->channels;   if (!write_chars(&p, &ch, 1))      return 0;   if (!write_uint16(&p, h->preskip))      return 0;   if (!write_uint32(&p, h->input_sample_rate))      return 0;   if (!write_uint16(&p, h->gain))      return 0;   ch = h->channel_mapping;   if (!write_chars(&p, &ch, 1))      return 0;   if (h->channel_mapping != 0)   {      ch = h->nb_streams;      if (!write_chars(&p, &ch, 1))         return 0;      ch = h->nb_coupled;      if (!write_chars(&p, &ch, 1))         return 0;      /* Multi-stream support */      for (i=0;i<h->channels;i++)      {         if (!write_chars(&p, &h->stream_map[i], 1))            return 0;      }   }   return p.pos;}

static int fill_command(stlink_t * sl, enum SCSI_Generic_Direction dir, uint32_t len) {    struct stlink_libusb * const slu = sl->backend_data;    unsigned char* const cmd = sl->c_buf;    int i = 0;    memset(cmd, 0, sizeof (sl->c_buf));    if(slu->protocoll == 1) {        fprintf(stderr, "This is never used..../n");        cmd[i++] = 'U';        cmd[i++] = 'S';        cmd[i++] = 'B';        cmd[i++] = 'C';        write_uint32(&cmd[i], slu->sg_transfer_idx);        write_uint32(&cmd[i + 4], len);        i += 8;        cmd[i++] = (dir == SG_DXFER_FROM_DEV)?0x80:0;        cmd[i++] = 0; /* Logical unit */        cmd[i++] = 0xa; /* Command length */    }    return i;}

void sendConstants(){	int I;	for(I = 0; I < 256; I++)		write_uint8("byte_constants_pipe", __E[I]);	for(I = 0; I < 256; I++)		write_uint8("byte_constants_pipe", __L[I]);	for(I = 0; I < 256; I++)		write_uint8("byte_constants_pipe", __fbsub[I]);	for(I = 0; I < 15; I++)		write_uint32("word_constants_pipe", __Rcon[I]);}

int key_value_write_lines(FILE *f, struct key_value_specification *kvs, void *base_address[]){	struct key_value_specification *k;	int rc;	int errs = 0;	for (k = kvs; k->key; k++) {		switch (k->type) {		case KVS_STRING:			rc = write_string(f, k, base_address);			break;		case KVS_INT64:			rc = write_int64(f, k, base_address);			break;		case KVS_INT32:			rc = write_int32(f, k, base_address);			break;		case KVS_INT16:			rc = write_int16(f, k, base_address);			break;		case KVS_INT8:			rc = write_int8(f, k, base_address);			break;		case KVS_UINT64:			rc = write_uint64(f, k, base_address);			break;		case KVS_UINT32:			rc = write_uint32(f, k, base_address);			break;		case KVS_UINT16:			rc = write_uint16(f, k, base_address);			break;		case KVS_UINT8:			rc = write_uint8(f, k, base_address);			break;		case KVS_DOUBLE:			rc = write_double(f, k, base_address);			break;		case KVS_FLOAT:			rc = write_float(f, k, base_address);			break;		default:			fprintf(stderr, "%s:%d: unknown key type '%c' for key '%s'/n",				__func__, __LINE__, k->type, k->key);			rc = -1;			break;		}		if (rc)			errs++;	}	return errs;}

void _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {    struct stlink_libusb * const slu = sl->backend_data;    unsigned char* const data = sl->q_buf;    unsigned char* const cmd  = sl->c_buf;    int i = fill_command(sl, SG_DXFER_TO_DEV, 0);    cmd[i++] = STLINK_DEBUG_COMMAND;    cmd[i++] = STLINK_DEBUG_WRITEMEM_8BIT;    write_uint32(&cmd[i], addr);    write_uint16(&cmd[i + 4], len);    send_only(slu, 0, cmd, slu->cmd_len);    send_only(slu, 1, data, len);}

		void write_address(address const& a, OutIt& out)		{			if (a.is_v4())			{				write_uint32(a.to_v4().to_ulong(), out);			}			else if (a.is_v6())			{				address_v6::bytes_type bytes					= a.to_v6().to_bytes();				std::copy(bytes.begin(), bytes.end(), out);			}		}

int crf1mmw_put_feature(crf1mmw_t* writer, int fid, const crf1mm_feature_t* f){    FILE *fp = writer->fp;    feature_header_t* hfeat = writer->hfeat;    /* Make sure that we are writing attribute feature references. */    if (writer->state != WSTATE_FEATURES) {        return CRFERR_INTERNAL_LOGIC;    }    /* We must put features #0, #1, ..., #(K-1) in this order. */    if (fid != hfeat->num) {        return CRFERR_INTERNAL_LOGIC;    }    write_uint32(fp, f->type);    write_uint32(fp, f->src);    write_uint32(fp, f->dst);    write_float(fp, f->weight);    ++hfeat->num;    return 0;}

static intwrite_footer_v1(struct save_data *save_data,                struct ipset_node_cache *cache, ipset_node_id root){    /* If the root is a terminal node, then we output the terminal value     * in place of the (nonexistent) list of nonterminal nodes. */    if (ipset_node_get_type(root) == IPSET_TERMINAL_NODE) {        ipset_value  value = ipset_terminal_value(root);        return write_uint32(save_data->stream, value);    }    return 0;}

void slave_1(){	while(1)	{		uint8_t s = read_uint8("start_slave_1");		float bc;		int bi;		__correlatorBase(ref_vector_1, check_vectors_1, bc, bi, NUM_VECS_BY_2);		write_float32("best_correlation_1_pipe",bc);		write_uint32("best_index_1_pipe",bi);	}}

// shows the use of the pipeHandler.int main(int argc, char* argv[]){	pth_init();	// must be initialized before doing anything        init_pipe_handler();	// register a FIFO pipe test_pipe with	// depth 32, word-width 32.	register_pipe("test_pipe",32,32,0);	register_pipe("test_pipe_64",1,64,0);	// write a integer to test_pipe.	write_uint32("test_pipe",1);	uint64_t tmp = 1;	tmp = tmp | (tmp << 32);	write_uint64("test_pipe_64",tmp);	// read back and print integer.	uint32_t v = read_uint32("test_pipe");	fprintf(stderr,"TEST: received uint32_t %d/n", v);	uint64_t v64 = read_uint64("test_pipe_64");	fprintf(stderr,"TEST: received uint64_t %llu/n", v64);	// write another integer	write_uint32("test_pipe",1);	// read back and print integer.	v = read_uint32("test_pipe");	fprintf(stderr,"TEST: received %d/n", v);	// close the handler.        close_pipe_handler();        return(0);}

int crf1mmw_close_attrrefs(crf1mmw_t* writer){    uint32_t i;    FILE *fp = writer->fp;    featureref_header_t* href = writer->href;    uint32_t begin = writer->header.off_attrrefs, end = 0;    /* Make sure that we are writing attribute feature references. */    if (writer->state != WSTATE_ATTRREFS) {        return CRFERR_INTERNAL_LOGIC;    }    /* Store the current offset position. */    end = (uint32_t)ftell(fp);    /* Compute the size of this chunk. */    href->size = (end - begin);    /* Write the chunk header and offset array. */    fseek(fp, begin, SEEK_SET);    write_uint8_array(fp, href->chunk, 4);    write_uint32(fp, href->size);    write_uint32(fp, href->num);    for (i = 0;i < href->num;++i) {        write_uint32(fp, href->offsets[i]);    }    /* Move the file pointer to the tail. */    fseek(fp, end, SEEK_SET);    /* Uninitialize. */    free(href);    writer->href = NULL;    writer->state = WSTATE_NONE;    return 0;}

int main(int argc, char* argv[]){	signal(SIGINT,  Exit);  	signal(SIGTERM, Exit);	uint8_t idx;		for(idx = 0; idx < ORDER; idx++)	{		write_uint32 ("in_data", idx);		uint32_t result = read_uint32("out_data");		fprintf(stdout,"Result = %x, expected = %x./n", result, idx);	}	return(0);}

		void write_address(address const& a, OutIt&& out)		{#if TORRENT_USE_IPV6			if (a.is_v4())			{#endif				write_uint32(a.to_v4().to_ulong(), out);#if TORRENT_USE_IPV6			}			else if (a.is_v6())			{				for (auto b : a.to_v6().to_bytes())					write_uint8(b, out);			}#endif		}

bool MCSessionWriteIndex(MCSessionIndexRef p_index){	bool t_success = true;		t_success = write_uint32(p_index->file, p_index->session_count);	for (uint32_t i = 0; t_success && i < p_index->session_count; i++)	{		t_success = write_cstring(p_index->file, p_index->session[i]->id) &&					write_cstring(p_index->file, p_index->session[i]->ip) &&					write_cstring(p_index->file, p_index->session[i]->filename) &&					write_real64(p_index->file, p_index->session[i]->expires);	}		return t_success;}

		void write_address(address const& a, OutIt& out)		{#if TORRENT_USE_IPV6			if (a.is_v4())			{#endif				write_uint32(a.to_v4().to_ulong(), out);#if TORRENT_USE_IPV6			}			else if (a.is_v6())			{				address_v6::bytes_type bytes					= a.to_v6().to_bytes();				std::copy(bytes.begin(), bytes.end(), out);			}#endif		}

static intwrite_bignum(FILE *f, mpz_t x){  unsigned size = nettle_mpz_sizeinbase_256_u(x);  uint8_t *p;  int res;    if (!write_uint32(f, size))    return 0;    p = xalloc(size);  nettle_mpz_get_str_256(size, p, x);  res = write_string(f, size, p);  free(p);  return res;}

int test_enc () {  char buf[1024];  char *buf_ptr = (char *) &buf;  char *res_enc = NULL;  char *res_dec = NULL;  uint8_t v8;  res_enc = write_uint8(buf_ptr, 42);  res_dec = read_uint8(buf_ptr, &v8);  assert(buf_ptr - res_dec == buf_ptr - res_enc);  assert(v8 == 42);  uint16_t v16;  res_enc = write_uint16(buf_ptr, 4200);  res_dec = read_uint16(buf_ptr, &v16);  assert(buf_ptr - res_dec == buf_ptr - res_enc);  assert(v16 == 4200);  uint32_t v32;  res_enc = write_uint32(buf_ptr, 420000);  res_dec = read_uint32(buf_ptr, &v32);  assert(buf_ptr - res_dec == buf_ptr - res_enc);  assert(v32 == 420000);  int32_t i32;  res_enc = write_int32(buf_ptr, -420000);  res_dec = read_int32(buf_ptr, &i32);  assert(buf_ptr - res_dec == buf_ptr - res_enc);  assert(i32 == -420000);  char* str = "hello world";  uint16_t str_len;  res_enc = write_string(buf_ptr, str, strlen(str));  res_dec = read_string(buf_ptr, &str, &str_len);  assert(buf_ptr - res_dec == buf_ptr - res_enc);  assert(!strcmp(str, "hello world"));  assert(strlen(str) == str_len);  char *tmp = "1234512345";  res_enc = write_buffer(buf_ptr, tmp, 10);  assert(res_enc - buf_ptr == 10);  for (int i = 0; i < 10; i++) assert(*(buf + i) == *(tmp + i));  return 0;}

static void save_state(struct server_context_t *s) {    //TODO: implement atomic operation    DBG_LOG(LOG_INFO, "[%s][%d] Saving state to disk", ss[s->state], s->current_term);    char *raftstate = path_join(s->basedir, RAFT_STATE);    if(raftstate) {#if defined(__unix__) || defined(__APPLE__)        int fd = open(raftstate, O_RDWR | O_CREAT, FILE_PERM);#else        int fd = open(raftstate, O_RDWR | O_CREAT);#endif        if(fd == -1 || !write_uint64(fd, s->current_term)                || !write_uint32(fd, s->current_leader)) {            log_fatal_and_exit(s, "error in saving state to file");        }        close(fd);        free(raftstate);    }}

		void write_address(address const& a, OutIt& out)		{#if TORRENT_USE_IPV6			if (a.is_v4())			{#endif				write_uint32(a.to_v4().to_ulong(), out);#if TORRENT_USE_IPV6			}			else if (a.is_v6())			{				typedef address_v6::bytes_type bytes_t;				bytes_t bytes = a.to_v6().to_bytes();				for (bytes_t::iterator i = bytes.begin()					, end(bytes.end()); i != end; ++i)					write_uint8(*i, out);			}#endif		}