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

static void write_pointer( FILE *f, void *p, ptr_type_t type ) {    const save_ptr_t *ptr;    int i;    if( !p ) {        write_int( f, -1 );        return;    }    for( i = 0, ptr = save_ptrs; i < num_save_ptrs; i++, ptr++ ) {        if( ptr->type == type && ptr->ptr == p ) {            write_int( f, i );            return;        }    }    gi.error( "%s: unknown pointer: %p", __func__, p );}

static void write_index( FILE *f, void *p, size_t size, void *start, int max_index ) {    size_t diff;    if( !p ) {        write_int( f, -1 );        return;    }    if( p < start || ( byte * )p > ( byte * )start + max_index * size ) {        gi.error( "%s: pointer out of range: %p", __func__, p );    }    diff = p - start;    if( diff % size ) {        gi.error( "%s: misaligned pointer: %p", __func__, p );    }    write_int( f, ( int )( diff / size ) );}

 inline void write_int( LL n )  {     //recursive function to load the number to output buffer array(buf2)     if( n >= 10 )      {         write_int( n / 10 ) ;     }         write_char( '0' + n % 10 ) ; }

static void write_string(int fd, char* val) {    int len = strlen(val);    write_int(fd, len);    int written = write(fd, val, len);    if (written != len) {        PLOGE("unable to write string");        exit(-1);    }}

void UniformSymbolCoder<RAC>::write_int(int min, int max, int val) {        assert(max >= min);        if (min != 0) {            max -= min;            val -= min;        }        if (max == 0) return;        // split in [0..med] [med+1..max]        int med = max/2;        if (val > med) {            rac.write_bit(true);            write_int(med+1, max, val);        } else {            rac.write_bit(false);            write_int(0, med, val);        }        return;}

 inline void write_Int(int n) {     if(n<0)     {         write_char('-');         write_flush();         n *= (-1);     }     write_int(n); }

generator_callback *remote_completion(const char *line, int start){	if (write(server_completion_fd, "c", 1) != 1 ||		!write_int(server_completion_fd, start) ||		!write_string(server_completion_fd, line)) {		return NULL;	}	return remote_generator;}

/* stringlist: <# listitems>               <pos of listend (bytes)>               <string:(size)(aligned string)>*/static int bc_stringlist_emit(int fd, int *codep, bytecode_info_t *bc){    int len = bc->data[(*codep)++].len;    int i;    int ret;    int wrote = 2*sizeof(int);    int begin,end;    /* Write out number of items in the list */    if (write_int(fd, len)== -1) return -1 ;    /* skip one spot end of list position*/    begin=lseek(fd,0,SEEK_CUR);    lseek(fd,sizeof(int),SEEK_CUR);    /* Loop through all the items of the list, writing out length and string     * in sequence */    for(i=0; i < len; i++)    {        int datalen = bc->data[(*codep)++].len;        if(write_int(fd, datalen) == -1) return -1;        wrote += sizeof(int);        if(write(fd, bc->data[(*codep)++].str, datalen) == -1) return -1;        wrote += datalen;        ret = align_string(fd,datalen);        if(ret == -1) return -1;        wrote+=ret;    }    end=lseek(fd,0,SEEK_CUR);    if (end < 0) return -1;    /* go back and write end of list position */    lseek(fd,begin,SEEK_SET);    if(write_int(fd, end) == -1) return -1;    /* return to the end */    lseek(fd,end,SEEK_SET);    return wrote;}

static voidwrite_string (MonoCompile *cfg, const char *str){	size_t len = strnlen (str, 0x2000);	write_int (cfg, (int) len);	gunichar2 *u = u8to16 (str);	for (int i = 0; i < len; i++)		write_short (cfg, u[i]);}

void KfmServIpc::dirEntry(const char* _name, const char* _access, const char* _owner, const char* _group, const char* _date, int _size){	int len = 0;	len += len_string( _name );	len += len_string( _access );	len += len_string( _owner );	len += len_string( _group );	len += len_string( _date );	len += len_int( _size );	len += len_string("dirEntry");	write_int( data_sock->socket(), len );	write_string( data_sock->socket(), "dirEntry" );	write_string( data_sock->socket(), _name );	write_string( data_sock->socket(), _access );	write_string( data_sock->socket(), _owner );	write_string( data_sock->socket(), _group );	write_string( data_sock->socket(), _date );	write_int( data_sock->socket(), _size );}

HOT_INLINEstatic void write_endpList(    int size,     hot_endpt_t *ep) {    int i;    write_int(size);    for (i = 0; i < size; i++)	write_endpID(&ep[i]);}

static log_realloc (unsigned oldlen, unsigned newlen, unsigned bsize, char *addr){	write_string ("realloc of ");	write_int (oldlen);	write_string ("at ");	write_addr (addr);	write_string ("/n");	write_stack("x");	write_string ("realloc-to of ");	write_int (newlen);	write_string ("gets ");	write_int (bsize);	write_string ("at ");	write_addr (addr);	write_string ("/n");	write_stack("x");}

int main(void){    char mac_param[128];    write_int("/sys/devices/platform/msm_sdcc.3/polling", 1);        getmac(mac_param);    LOGI("Loading Libra.ko");    if ((insmod(DRIVER_MODULE_PATH, mac_param)) < 0){        rmmod("librasdioif");    } else {        usleep(WIFI_DRIVER_LOADER_DELAY);        property_set("wlan.driver.status", "ok");           }    write_int("/sys/devices/platform/msm_sdcc.3/polling", 0);    return 0;}

    void write_int(int min, int max, int val) {        assert(max >= min);        if (min != 0) {            max -= min;            val -= min;        }        if (max == 0) return;        // split in [0..med] [med+1..max]        int med = max/2;        if (val > med) {            rac.write(med+1, max+1, true);            write_int(med+1, max, val);        } else {            rac.write(med+1, max+1, false);            write_int(0, med, val);        }        return;    }

static print_free_list (unsigned heap){	int i;	struct freelist * top;	struct freelist * ptr;	write_string ("free list for heap ");	write_int(heap);	write_string(":/n");	for (i=0; i<BUCKETS; i++) {		top = &heaps[heap][i];		write_int (sizes[i]);		write_string (": ");		for (ptr = top->next ; ptr != top; ptr=ptr->next)			write_int (ptr->size);		write_string ("/n");	}}

/** * This function allows you to add an encoded video frame to the AVI file. * * @param gwavi Main gwavi structure initialized with gwavi_open()- * @param buffer Video buffer size. * @param len Video buffer length. * * @return 0 on success, -1 on error. */intgwavi_add_frame(struct gwavi_t *gwavi, unsigned char *buffer, size_t len){	size_t maxi_pad;  /* if your frame is raggin, give it some paddin' */	size_t t;	if (!gwavi || !buffer) {		(void)fputs("gwavi and/or buffer argument cannot be NULL",			    stderr);		return -1;	}	if (len < 256)		(void)fprintf(stderr, "WARNING: specified buffer len seems "			      "rather small: %d. Are you sure about this?/n",			      (int)len);	gwavi->offset_count++;	gwavi->stream_header_v.data_length++;	maxi_pad = len % 4;	if (maxi_pad > 0)		maxi_pad = 4 - maxi_pad;	if (gwavi->offset_count >= gwavi->offsets_len) {		gwavi->offsets_len += 1024;		gwavi->offsets = (unsigned int *)realloc(gwavi->offsets,					(size_t)gwavi->offsets_len *					sizeof(unsigned int));	}	gwavi->offsets[gwavi->offsets_ptr++] = (unsigned int)(len + maxi_pad);	if (write_chars_bin(gwavi->out, "00dc", 4) == -1) {		(void)fprintf(stderr, "gwavi_add_frame: write_chars_bin() "			      "failed/n");		return -1;	}	if (write_int(gwavi->out, (unsigned int)(len + maxi_pad)) == -1) {		(void)fprintf(stderr, "gwavi_add_frame: write_int() failed/n");		return -1;	}	if ((t = fwrite(buffer, 1, len, gwavi->out)) != len) {		(void)fprintf(stderr, "gwavi_add_frame: fwrite() failed/n");		return -1;	}	for (t = 0; t < maxi_pad; t++)		if (fputc(0, gwavi->out) == EOF) {			(void)fprintf(stderr, "gwavi_add_frame: fputc() failed/n");			return -1;		}	return 0;}

static FcBoolcache_print_set (FcFontSet *set, FcStrSet *dirs, const FcChar8 *base_name, FcBool verbose){    FcChar8	    *dir;    const FcChar8   *base;    int		    n;    int		    ndir = 0;    FcStrList	    *list;    list = FcStrListCreate (dirs);    if (!list)	goto bail2;        while ((dir = FcStrListNext (list)))    {	base = file_base_name (base_name, dir);	if (!write_string (stdout, base))	    goto bail3;	if (PUTC (' ', stdout) == EOF)	    goto bail3;	if (!write_int (stdout, 0))	    goto bail3;        if (PUTC (' ', stdout) == EOF)	    goto bail3;	if (!write_string (stdout, FC_FONT_FILE_DIR))	    goto bail3;	if (PUTC ('/n', stdout) == EOF)	    goto bail3;	ndir++;    }        for (n = 0; n < set->nfont; n++)    {	FcPattern   *font = set->fonts[n];	FcChar8 *s;	s = FcPatternFormat (font, (const FcChar8 *) "%{=fccat}/n");	if (s)	{	    printf ("%s", s);	    FcStrFree (s);	}    }    if (verbose && !set->nfont && !ndir)	printf ("<empty>/n");    FcStrListDone (list);    return FcTrue;bail3:    FcStrListDone (list);bail2:    return FcFalse;}

/* Join a group.  The group context is returned in *contextp.   */hot_err_t hot_ens_Join(    hot_ens_JoinOps_t *jops,    hot_context_t *contextp	/*OUT*/ ) {    hot_err_t err = HOT_OK ;    hot_context_t s ;    /* Initialize global state if not done so already.     */    if (!g.initialized) {	err = hot_ens_Init(jops->outboard, jops->argv); 	if (err != HOT_OK)	    return err;    }    begin_write(); {    	begin_critical(); {    	    /* Allocate a new group context 	     * Initialize the group record.	     */	    s = alloc_context();	    s->joining = 1 ;	    s->leaving = 0 ;	    s->conf = jops->conf;	    s->env = jops->env;	    s->view = NULL ;	    *contextp = s ;	} end_critical();		/* Write the downcall.	 */  	write_hdr(s,DN_JOIN);	write_int(jops->heartbeat_rate);	write_string(jops->transports);	write_string(jops->protocol);	write_string(jops->group_name);	write_string(jops->properties);	write_bool(jops->use_properties);	write_bool(jops->groupd);	write_string(jops->params);	write_bool(jops->client);	write_bool(jops->debug);	if (jops->endpt.name[0] != 0x0) {	    hot_sys_Warning("HOT_OUTBOARD does not support 'endpt' in join ops") ;	    jops->endpt.name[0] = 0x0;	}	write_string(jops->princ);	write_string(jops->key);	write_bool(jops->secure);    } end_write();    return HOT_OK;}

void KfmIpc::move(const char* _src, const char* _dest){	int len = 0;	len += len_string( _src );	len += len_string( _dest );	len += len_string("move");	write_int( sock->socket(), len );	write_string( sock->socket(), "move" );	write_string( sock->socket(), _src );	write_string( sock->socket(), _dest );}

void print_stats(int i){     struct stats st;     get_stats(getpid(), &st);     char b;          write(1, "/nStats for the process ", 23);     write_int(i);          write(1, "/nUser Ticks: ", 13);     write_int(st.user_ticks);     write(1, "/nSystem Ticks: ", 15);     write_int(st.system_ticks);     write(1, "/nBlocked Ticks: ", 16);     write_int(st.blocked_ticks);     write(1, "/nReady Ticks: ", 14);     write_int(st.ready_ticks);}

void Ctransaction::send_announce(data_ref r){	if (read_int(8, &r[uti_connection_id], r.end()) != connection_id())		return;	if (!m_server.config().m_anonymous_announce)	{		send_error(r, "access denied");		return;	}	Ctracker_input ti;	ti.m_downloaded = read_int(8, &r[utia_downloaded], r.end());	ti.m_event = static_cast<Ctracker_input::t_event>(read_int(4, &r[utia_event], r.end()));	ti.m_info_hash.assign(reinterpret_cast<const char*>(&r[utia_info_hash]), 20);	ti.m_ipa = read_int(4, &r[utia_ipa], r.end()) && is_private_ipa(m_a.sin_addr.s_addr)		? htonl(read_int(4, &r[utia_ipa], r.end()))		: m_a.sin_addr.s_addr;	ti.m_left = read_int(8, &r[utia_left], r.end());	ti.m_num_want = read_int(4, &r[utia_num_want], r.end());	ti.m_peer_id.assign(reinterpret_cast<const char*>(&r[utia_peer_id]), 20);	ti.m_port = htons(read_int(2, &r[utia_port], r.end()));	ti.m_uploaded = read_int(8, &r[utia_uploaded], r.end());	std::string error = m_server.insert_peer(ti, true, NULL);	if (!error.empty())	{		send_error(r, error);		return;	}	const Cserver::t_torrent* torrent = m_server.torrent(ti.m_info_hash);	if (!torrent)		return;	const int cb_d = 2 << 10;	char d[cb_d];	write_int(4, d + uto_action, uta_announce);	write_int(4, d + uto_transaction_id, read_int(4, &r[uti_transaction_id], r.end()));	write_int(4, d + utoa_interval, m_server.config().m_announce_interval);	write_int(4, d + utoa_leechers, torrent->leechers);	write_int(4, d + utoa_seeders, torrent->seeders);	std::string peers = torrent->select_peers(ti);	memcpy(d + utoa_size, peers.data(), peers.size());	send(data_ref(d, d + utoa_size + peers.size()));}

/* Privileged side. */static voidsetgid_io_close_priv (int outfd, int infd){  int fd;  int result;  fd = read_int (infd);  result = close (fd);  write_int (outfd, result);}

int main(){	int i;	int k;	int *l;	k = 10;	l = &k;		i = outprint(l);	write_int(k);	write_string("/n");}

static void write_field(FILE *f, const save_field_t *field, void *base){    void *p = (byte *)base + field->ofs;    int i;    switch (field->type) {    case F_BYTE:        write_data(p, field->size, f);        break;    case F_SHORT:        for (i = 0; i < field->size; i++) {            write_short(f, ((short *)p)[i]);        }        break;    case F_INT:        for (i = 0; i < field->size; i++) {            write_int(f, ((int *)p)[i]);        }        break;    case F_FLOAT:        for (i = 0; i < field->size; i++) {            write_float(f, ((float *)p)[i]);        }        break;    case F_VECTOR:        write_vector(f, (vec_t *)p);        break;    case F_ZSTRING:        write_string(f, (char *)p);        break;    case F_LSTRING:        write_string(f, *(char **)p);        break;    case F_EDICT:        write_index(f, *(void **)p, sizeof(edict_t), g_edicts, MAX_EDICTS - 1);        break;    case F_CLIENT:        write_index(f, *(void **)p, sizeof(gclient_t), game.clients, game.maxclients - 1);        break;    case F_ITEM:        write_index(f, *(void **)p, sizeof(gitem_t), itemlist, game.num_items - 1);        break;    case F_POINTER:        write_pointer(f, *(void **)p, field->size);        break;    default:        gi.error("%s: unknown field type", __func__);    }}

/** * This function allows you to add the audio track to your AVI file. * * @param gwavi Main gwavi structure initialized with gwavi_open()- * @param buffer Audio buffer size. * @param len Audio buffer length. * * @return 0 on success, -1 on error. */intgwavi_add_audio(struct gwavi_t *gwavi, unsigned char *buffer, size_t len){	size_t maxi_pad;  /* in case audio bleeds over the 4 byte boundary  */	size_t t;	if (!gwavi || !buffer) {		(void)fputs("gwavi and/or buffer argument cannot be NULL",			    stderr);		return -1;	}	gwavi->offset_count++;	maxi_pad = len % 4;	if (maxi_pad > 0)		maxi_pad = 4 - maxi_pad;	if (gwavi->offset_count >= gwavi->offsets_len) {		gwavi->offsets_len += 1024;		gwavi->offsets = (unsigned int *)realloc(gwavi->offsets,					(size_t)gwavi->offsets_len *					sizeof(unsigned int));	}	gwavi->offsets[gwavi->offsets_ptr++] =		(unsigned int)((len + maxi_pad) | 0x80000000);	if (write_chars_bin(gwavi->out,"01wb",4) == -1) {		(void)fprintf(stderr, "gwavi_add_audio: write_chars_bin() "			      "failed/n");		return -1;	}	if (write_int(gwavi->out,(unsigned int)(len + maxi_pad)) == -1) {		(void)fprintf(stderr, "gwavi_add_audio: write_int() failed/n");		return -1;	}	if ((t = fwrite(buffer, 1, len, gwavi->out)) != len ) {		(void)fprintf(stderr, "gwavi_add_audio: fwrite() failed/n");		return -1;	}	for (t = 0; t < maxi_pad; t++)		if (fputc(0,gwavi->out) == EOF) {			(void)fprintf(stderr, "gwavi_add_audio: fputc() failed/n");			return -1;		}	gwavi->stream_header_a.data_length += (unsigned int)(len + maxi_pad);	return 0;}

void indexed_force_tri_3D::save(std::ofstream& out){	// write the label string	write_label(out, label);	// write the point cloud indices for each vertex	for (int t=0; t<3; t++)		write_int(out, p[t]);	// write the target index	write_int(out, ds_index);	// write the index list - first the length	write_int(out, grid_indices.size());	// now write all the indices	for (std::list<grid_index>::iterator it=grid_indices.begin();		 it!=grid_indices.end(); it++)	{		write_int(out, it->i);		write_int(out, it->j);		write_vector(out, it->cart_coord);	}	// write the point and edge adjacency list	for (int a=0; a<2; a++)	{		write_int(out, adjacency[a].size());		for (LABEL_STORE::iterator it=adjacency[a].begin();			 it!= adjacency[a].end(); it++)			write_label(out, *it);	}}

static voidwrite_blocks (MonoCompile *cfg){	int block_size = 0;	MonoBasicBlock *bb;	for (bb = cfg->bb_entry; bb; bb = bb->next_bb)		block_size++;	write_int (cfg, block_size);	for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {		int insn_size = 0;		MonoInst *insn = NULL;		write_int (cfg, bb->block_num);		for (insn = bb->code; insn; insn = insn->next)			insn_size++;		write_int (cfg, insn_size);		for (insn = bb->code; insn; insn = insn->next) {			int *id = (int *) g_hash_table_lookup (cfg->gdump_ctx->insn2id, insn);			g_assert (id);			write_int (cfg, *id);		}		write_int (cfg, bb->out_count);		for (int i = 0; i < bb->out_count; i++)			write_int (cfg, bb->out_bb[i]->block_num);	}}