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

// ------------------------------------------------------------------------------------------------// Reception test with interrupt handlingint radio_receive_test_int(spi_parms_t *spi_parms, arguments_t *arguments)// ------------------------------------------------------------------------------------------------{    uint8_t nb_rx, rx_bytes[RADIO_BUFSIZE];    init_radio_int(spi_parms, arguments);    PI_CC_SPIStrobe(spi_parms, PI_CCxxx0_SFRX); // Flush Rx FIFO    verbprintf(0, "Starting.../n");    while((arguments->repetition == 0) || (packets_received < arguments->repetition))    {        radio_init_rx(spi_parms, arguments); // Init for new packet to receive        radio_turn_rx(spi_parms);            // Put back into Rx        do        {            radio_wait_free(); // make sure no radio operation is in progress            nb_rx = radio_receive_packet(spi_parms, arguments, rx_bytes);        } while(nb_rx == 0);        rx_bytes[nb_rx] = '/0';        verbprintf(0,"/"%s/"/n", rx_bytes);    }}

/* FIXME it's a dirty hack, supporting VBOs would be the real thing */const GLubyte * glGetString( GLenum name ){    init();    static const GLubyte * (*func)(GLenum) = NULL;    if (!func)        func = (const GLubyte * (*)(GLenum)) dlsym(RTLD_NEXT, "glGetString");    verbprintf("glGetString( %d );/n", name);    switch (name) {    case GL_EXTENSIONS:        verbprintf("/tGL_EXTENSIONS:we return /"/" instead of %s/n",                   func(name));        return (const GLubyte *) "";        break;    case GL_VENDOR:        verbprintf("/tGL_VENDOR:we return /"/" instead of %s/n",                   func(name));        return (const GLubyte *) "";        break;    case GL_RENDERER:        verbprintf("/tGL_RENDERER:we return /"/" instead of %s/n",                   func(name));        return (const GLubyte *) "";        break;    case GL_VERSION:        verbprintf("/tGL_VERSION: we return /"/" instead of %s/n",                   func(name));        return (const GLubyte *) "1.2";        break;    default:        return func(name);    }}

static void disp_packet(struct demod_state *s, unsigned char *bp, unsigned int len){        unsigned char i,j;        if (!bp)		return;        if (!len) {                verbprintf(0, "/n");                return;        }        j = 0;        while (len) {                i = *bp++;                if ((i >= 32) && (i < 128))                        verbprintf(0, "%c",i);                else if (i == 13) {                        if (j)                                 verbprintf(0, "/n");                        j = 0;                } else                       verbprintf(0, "[0x%02X]",i);                if (i >= 32)                        j = 1;                len--;        }        if (j)                verbprintf(0, "/n");}

/* * Within the index range (into the array entries_address_ascending), find the * symbol with the maximal lifetime and split/truncate all symbols that overlap * with it (i.e. that there won't be any overlaps anymore). */static int handle_overlap_region(int start_idx, int end_idx){	int rc = OP_JIT_CONV_OK;	int idx;	struct jitentry * e;	int cnt;	char * name;	int i, j;	unsigned long long totaltime, pct;	if (debug) {		for (i = start_idx; i <= end_idx; i++) {			e = entries_address_ascending[i];			verbprintf(debug, "overlap idx=%i, name=%s, "				   "start=%llx, end=%llx, life_start=%lli, "				   "life_end=%lli, lifetime=%lli/n",				   i, e->symbol_name, e->vma,				   e->vma + e->code_size, e->life_start,				   e->life_end, e->life_end - e->life_start);		}	}	idx = select_one(start_idx, end_idx);	// This can't happen, but we check anyway, just to silence Coverity	if (idx == OP_JIT_CONV_FAIL) {		rc = OP_JIT_CONV_FAIL;		goto out;	}	totaltime = eliminate_overlaps(start_idx, end_idx, idx);	if (totaltime == ULONG_MAX) {		rc = OP_JIT_CONV_FAIL;		goto out;	}	e = entries_address_ascending[idx];	pct = (totaltime == 0) ? 100 : (e->life_end - e->life_start) * 100 / totaltime;	cnt = 1;	j = pct;	while ((j = j/10))		cnt++;	// Mark symbol name with a %% to indicate the overlap.	cnt += strlen(e->symbol_name) + 2 + 1;	name = xmalloc(cnt);	snprintf(name, cnt, "%s%%%llu", e->symbol_name, pct);	if (e->sym_name_malloced)		free(e->symbol_name);	e->symbol_name = name;	e->sym_name_malloced = 1;	verbprintf(debug, "selected idx=%i, name=%s/n", idx, e->symbol_name);out:	return rc;}

/* parse all entries in the jit dump file and build jitentry_list. * the code needs to check always whether there is enough * to read remaining. this is because the file may be written to * concurrently. */static int parse_entries(void const * ptr, void const * end,			 unsigned long long end_time){	int rc = OP_JIT_CONV_OK;	struct jr_prefix const * rec = ptr;	while ((void *)rec + sizeof(struct jr_prefix) < end) {		if (((void *) rec + rec->total_size) > end) {			verbprintf(debug, "record past end of file/n");			rc = OP_JIT_CONV_FAIL;			break;		}		switch (rec->id) {		case JIT_CODE_LOAD:			if (parse_code_load(rec, rec->total_size, end_time)) {				rc = OP_JIT_CONV_FAIL;				break;			}			break;		case JIT_CODE_UNLOAD:			parse_code_unload(rec, end_time);			break;				case JIT_CODE_CLOSE:			break;		case JIT_CODE_DEBUG_INFO:			if (rec->total_size == 0) {				rc = OP_JIT_CONV_FAIL;				break;			}			parse_code_debug_info(rec, end, end_time);			break;		default:			verbprintf(debug, "unknown record type/n");			rc = OP_JIT_CONV_FAIL;			break;		}				rec = (void *)rec + rec->total_size;	}	return rc;}

/* * Scans through the index range and splits/truncates entries that overlap * with the one indexed by keep_idx. Returns the total lifetime of the symbols * found to overlap. * Returns ULONG_MAX on error. */static unsigned long long eliminate_overlaps(int start_idx, int end_idx,					 int keep_idx){	unsigned long long retval;	struct jitentry const * keep = entries_address_ascending[keep_idx];	struct jitentry * e;	unsigned long long start_addr_keep = keep->vma;	unsigned long long end_addr_keep = keep->vma + keep->code_size;	unsigned long long start_addr_entry, end_addr_entry;	int i;	unsigned long long min_start = keep->life_start;	unsigned long long max_end = keep->life_end;	for (i = start_idx; i <= end_idx; i++) {		if (i == keep_idx)			continue;		e = entries_address_ascending[i];		start_addr_entry = e->vma;		end_addr_entry = e->vma + e->code_size;		if (debug) {			if (!(start_addr_entry <= end_addr_entry)) {				verbprintf(debug, "assert failed:"					   " start_addr_entry <="					   " end_addr_entry/n");				retval = ULONG_MAX;				goto out;			}			if (!(start_addr_keep <= end_addr_keep)) {				verbprintf(debug, "assert failed: "					   "start_addr_keep <="					   " end_addr_keep/n");				retval = ULONG_MAX;				goto out;			}		}		if (start_addr_entry < end_addr_keep &&		    end_addr_entry > start_addr_keep) {			if (e->life_start < min_start)				min_start = e->life_start;			if (e->life_end > max_end)				max_end = e->life_end;			split_entry(e, keep);		}	}	retval = max_end - min_start;out:	return retval;}

static void opd_shutdown(struct op_buffer_head * buf, size_t size, struct op_note * nbuf, size_t nsize){	ssize_t count = -1;	ssize_t ncount = -1;	if (fcntl(devfd, F_SETFL, fcntl(devfd, F_GETFL) | O_NONBLOCK) < 0) {		perror("Failed to set non-blocking read for device: ");		exit(EXIT_FAILURE);	}		while (ncount < 0)		ncount = op_read_device(notedevfd, nbuf, nsize);	if (ncount > 0)		opd_do_notes(nbuf, ncount);	while (1) {		count = op_read_device(devfd, buf, size);		if (count < 0 && errno == EAGAIN)			break;		verbprintf(vmisc, "Shutting down, state %d/n", buf->state);		opd_do_samples(buf);	}}

static int parse_code_load(void const * ptr_arg, int size,			   unsigned long long end_time){	struct jitentry * entry;	int rc = OP_JIT_CONV_OK;	char const * ptr = ptr_arg;	struct jr_code_load const * rec = ptr_arg;	char const * end;	size_t padding_count, rec_totalsize;	end = rec->code_addr ? ptr + size : NULL;	entry = xcalloc(1, sizeof(struct jitentry));		entry->next = NULL;	ptr += sizeof(*rec);		entry->symbol_name = (char *)ptr;	entry->sym_name_malloced = 0;	ptr += strlen(ptr) + 1;	entry->code = rec->code_addr ? ptr : NULL;	entry->vma = rec->vma;	entry->code_size = rec->code_size;	entry->section = NULL;	entry->life_start = rec->timestamp;		// sampling run, this value may be overwritten by an unload record1		entry->life_end = end_time;		entry->next = jitentry_list;	jitentry_list = entry;	rec_totalsize = sizeof(*rec) + strlen(entry->symbol_name) + 1 + entry->code_size;	padding_count = PADDING_8ALIGNED(rec_totalsize);	verbprintf(debug, "record0: name=%s, vma=%llx, code_size=%i, "		   "padding_count=%llu, life_start=%lli, life_end=%lli/n", entry->symbol_name,		   entry->vma, entry->code_size, (unsigned long long)padding_count, entry->life_start,		   entry->life_end);	if (end && (ptr + entry->code_size + padding_count != end)) {		verbprintf(debug, "record total size mismatch/n");		rc = OP_JIT_CONV_FAIL;	}	return rc;}

unsigned char disp_parm(unsigned char *bp, unsigned char param_len){        unsigned char i, len;        len=param_len;	while (len) {        	i = *bp++;		if ((i >= 32) && (i < 128))                         verbprintf(0, "%c",i);		else 		        verbprintf(0, ".");                len--;	}return param_len;}

/** * opd_do_samples - process a sample buffer * @param opd_buf  buffer to process * * Process a buffer of samples. * The signals specified by the global variable maskset are * masked. * * If the sample could be processed correctly, it is written * to the relevant sample file. Additionally mapping and * process notifications are handled here. */static void opd_do_samples(struct op_buffer_head const * opd_buf){	uint i;	struct op_sample const * buffer = opd_buf->buffer; 	opd_24_stats[OPD_DUMP_COUNT]++;	verbprintf(vmisc, "Read buffer of %d entries for cpu %d./n",		   (unsigned int)opd_buf->count, opd_buf->cpu_nr); 	if (separate_cpu)		cpu_number = opd_buf->cpu_nr;	for (i = 0; i < opd_buf->count; i++) {		verbprintf(vsamples, "%.6u: EIP: 0x%.8lx pid: %.6d/n",			i, buffer[i].eip, buffer[i].pid);		opd_put_sample(&buffer[i]);	}}

static void parse_code_unload(void const * ptr, unsigned long long end_time){	struct jr_code_unload const * rec = ptr;	struct jitentry * entry;	verbprintf(debug,"record1: vma=%llx, life_end=%lli/n",		   rec->vma, rec->timestamp);	if (rec->timestamp > 0 && rec->vma != 0) {		for (entry = jitentry_list; entry; entry = entry->next) {			if (entry->vma == rec->vma &&			    entry->life_end == end_time) {				entry->life_end = rec->timestamp;				verbprintf(debug,"matching record found/n");				break;			}		}	}}

int enough_remaining(struct transient * trans, size_t size){	if (trans->remaining >= size)		return 1;	verbprintf(vmisc, "Dangling ESCAPE_CODE./n");	opd_stats[OPD_DANGLING_CODE]++;	return 0;}

glvoid glBegin( GLenum mode ){    init();    static void (*func)(GLenum) = NULL;    if (!func)        func = (void (*)(GLenum)) dlsym(RTLD_NEXT, "glBegin");    if (dump_count)    {        verbprintf("glBegin(%s);", prim_type_name[mode]);        current_prim = new_prim(mode);        verbprintf(" /* [%d] *//n", nPrim-1);        dump_count--;    }    func(mode);}

void clip_rxbit(struct demod_state *s, int bit){	s->l2.uart.rxbitstream <<= 1;	s->l2.uart.rxbitstream |= !!bit;	if (!s->l2.uart.rxstate) {		switch (s->l2.uart.rxbitstream & 0x03) {			case 0x02:	/* start bit */				s->l2.uart.rxstate = 1;				s->l2.uart.rxbitbuf = 0x100;				break;			case 0x00:	/* no start bit */			case 0x03:	/* consecutive stop bits*/				if ((s->l2.uart.rxptr - s->l2.uart.rxbuf) >= 1)					clip_disp_packet(s, s->l2.uart.rxbuf, s->l2.uart.rxptr - s->l2.uart.rxbuf);				s->l2.uart.rxptr = s->l2.uart.rxbuf;				break;		}		return;	}	if (s->l2.uart.rxbitstream & 1)		s->l2.uart.rxbitbuf |= 0x200;//	verbprintf(7, "b=%c", '0'+(s->l2.uart.rxbitstream & 1));	if (s->l2.uart.rxbitbuf & 1) {		if (s->l2.uart.rxptr >= s->l2.uart.rxbuf+sizeof(s->l2.uart.rxbuf)) {			s->l2.uart.rxstate = 0;			clip_disp_packet(s, s->l2.uart.rxbuf, s->l2.uart.rxptr - s->l2.uart.rxbuf);			verbprintf(1, "Error: packet size too large/n");			return;		}                if ( !(s->l2.uart.rxbitstream & 1) ) {			s->l2.uart.rxstate = 0;			verbprintf(1, "Error: stop bit is 0. Bad framing/n");			return;		}		*s->l2.uart.rxptr++ = s->l2.uart.rxbitbuf >> 1;//		verbprintf(6, "B=%02X ", (s->l2.uart.rxbitbuf >> 1) & 0xff);//		verbprintf(5, "%c", (s->l2.uart.rxbitbuf >> 1) & 0xff);		s->l2.uart.rxbitbuf = 0x100;		s->l2.uart.rxstate = 0;		return;	}      	s->l2.uart.rxbitbuf >>= 1;}

glvoid glVertex2i( GLint x, GLint y ){    init();    static void (*func)(GLint, GLint) = NULL;    if (!func)        func = (void (*)(GLint, GLint)) dlsym(RTLD_NEXT, "glVertex2i");    verbprintf("glVertex2i(%d, %d);/n", x, y);    func(x, y);}

glvoid glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ){    init();    static void (*func)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;    if (!func)        func = (void (*)(GLdouble, GLdouble, GLdouble, GLdouble)) dlsym(RTLD_NEXT, "glVertex4d");    verbprintf("glVertex4d(%f, %f, %f, %f);/n", x, y, z, w);    func(x, y, z, w);}

glvoid glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ){    init();    static void (*func)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;    if (!func)        func = (void (*)(GLfloat, GLfloat, GLfloat, GLfloat)) dlsym(RTLD_NEXT, "glVertex4f");    verbprintf("glVertex4f(%f, %f, %f, %f);/n", x, y, z, w);    func(x, y, z, w);}

glvoid glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w ){    init();    static void (*func)(GLshort, GLshort, GLshort, GLshort) = NULL;    if (!func)        func = (void (*)(GLshort, GLshort, GLshort, GLshort)) dlsym(RTLD_NEXT, "glVertex4s");    verbprintf("glVertex4s(%d, %d, %d, %d);/n", x, y, z, w);    func(x, y, z, w);}

glvoid glVertex2fv( const GLfloat *v ){    init();    static void (*func)(const GLfloat *) = NULL;    if (!func)        func = (void (*)(const GLfloat *)) dlsym(RTLD_NEXT, "glVertex2fv");    verbprintf("glVertex2fv(%f, %f);/n", v[0], v[1]);    func(v);}

glvoid glVertex4dv( const GLdouble *v ){    init();    static void (*func)(const GLdouble *) = NULL;    if (!func)        func = (void (*)(const GLdouble *)) dlsym(RTLD_NEXT, "glVertex4dv");    verbprintf("glVertex4dv(%f, %f, %f, %f);/n", v[0], v[1], v[2], v[4]);    func(v);}

glvoid glVertex4sv( const GLshort *v ){    init();    static void (*func)(const GLshort *) = NULL;    if (!func)        func = (void (*)(const GLshort *)) dlsym(RTLD_NEXT, "glVertex4sv");    verbprintf("glVertex4sv(%d, %d, %d, %d);/n", v[0], v[1], v[2], v[4]);    func(v);}

glvoid glNewList( GLuint list, GLenum mode ){    init();    static void (*func)(GLuint, GLenum) = NULL;    if (!func)        func = (void (*)(GLuint, GLenum)) dlsym(RTLD_NEXT, "glNewList");    verbprintf("glNewList(%d, %d);/n", list, mode);    func(list, mode);}

/** * opd_do_samples - process a sample buffer * @param opd_buf  buffer to process * * Process a buffer of samples. * * If the sample could be processed correctly, it is written * to the relevant sample file. */static void opd_do_samples(char const * opd_buf, ssize_t count){	size_t num = count / kernel_pointer_size; 	opd_stats[OPD_DUMP_COUNT]++;	verbprintf(vmisc, "Read buffer of %d entries./n", (unsigned int)num); 	opd_process_samples(opd_buf, num);	complete_dump();}

/* SIGCHLD received from JIT dump child process. */static void opd_sigchild(void){	int child_status;	wait(&child_status);	jit_conversion_running = 0;	if (WIFEXITED(child_status) && (!WEXITSTATUS(child_status))) {		verbprintf(vmisc, "JIT dump processing complete./n");	} else {		printf("JIT dump processing exited abnormally: %d/n",		       WEXITSTATUS(child_status));	}}

/** * opd_do_read - enter processing loop * @param buf  buffer to read into * @param size  size of buffer * * Read some of a buffer from the device and process * the contents. */static void opd_do_read(char * buf, size_t size){	opd_open_pipe();	while (1) {		ssize_t count = -1;		/* loop to handle EINTR */		while (count < 0) {			count = op_read_device(devfd, buf, size);			/* we can lose an alarm or a hup but			 * we don't care.			 */			if (signal_alarm) {				signal_alarm = 0;				opd_alarm();			}			if (signal_hup) {				signal_hup = 0;				opd_sighup();			}			if (signal_term)				opd_sigterm();			if (signal_child)				opd_sigchild();			if (signal_usr1) {				signal_usr1 = 0;				perfmon_start();			}			if (signal_usr2) {				signal_usr2 = 0;				perfmon_stop();			}			if (is_jitconv_requested()) {				verbprintf(vmisc, "Start opjitconv was triggered/n");				opd_do_jitdumps();			}		}		opd_do_samples(buf, count);	}		opd_close_pipe();}

static int parse_header(char const ** ptr, char const * end){	int rc = OP_JIT_CONV_OK;	struct jitheader const * header;	if (*ptr + sizeof(struct jitheader) >= end) {		verbprintf(debug,			   "opjitconv: EOF in jitdump file, no header/n");		rc = OP_JIT_CONV_FAIL;		goto out;	}	header = (struct jitheader *)*ptr;	if (header->magic != JITHEADER_MAGIC) {		verbprintf(debug, "opjitconv: Wrong jitdump file magic/n");		rc = OP_JIT_CONV_FAIL;		goto out;	}	if (header->version != JITHEADER_VERSION) {		verbprintf(debug, "opjitconv: Wrong jitdump file version/n");		rc = OP_JIT_CONV_FAIL;		goto out;	}	if (*ptr + header->totalsize > end) {		verbprintf(debug, "opjitconv: EOF in jitdump file, not enough "			   "data for header/n");		rc = OP_JIT_CONV_FAIL;		goto out;	}	dump_bfd_arch = header->bfd_arch;	dump_bfd_mach = header->bfd_mach;	dump_bfd_target_name = header->bfd_target;	verbprintf(debug, "header: bfd-arch=%i, bfd-mach=%i,"		   " bfd_target_name=%s/n", dump_bfd_arch, dump_bfd_mach,		   dump_bfd_target_name);	*ptr = *ptr + header->totalsize;out:	return rc;}

// ------------------------------------------------------------------------------------------------// Transmission test with interrupt handlingint radio_transmit_test_int(spi_parms_t *spi_parms, arguments_t *arguments)// ------------------------------------------------------------------------------------------------{    init_radio_int(spi_parms, arguments);    PI_CC_SPIStrobe(spi_parms, PI_CCxxx0_SFTX); // Flush Tx FIFO    verbprintf(0, "Sending %d test packets of size %d/n", arguments->repetition, arguments->packet_length);    while(packets_sent < arguments->repetition)    {        radio_wait_free(); // make sure no radio operation is in progress        radio_send_packet(spi_parms, arguments, arguments->test_phrase, strlen(arguments->test_phrase));        radio_wait_a_bit(arguments->packet_length / 4);    }}

// ------------------------------------------------------------------------------------------------// Check if the KISS block is a command block and interpret the command // Returns 1 if this is a command block// Returns 0 it this is a data blockuint8_t kiss_command(uint8_t *block)// ------------------------------------------------------------------------------------------------{    uint8_t command_code = block[1] & 0x0F;    uint8_t kiss_port = (block[1] & 0xF0)>>4;    uint8_t command_arg = block[2];    verbprintf(4, "KISS: command %02X %02X/n", block[1], block[2]);    switch (command_code)    {        case 0: // data block            return 0;        case 1: // TXDELAY            tnc_tx_keyup_delay = command_arg * 10000; // these are tenths of ms            break;        case 2: // Persistence parameter            kiss_persistence = (command_arg + 1) / 256.0;            break;        case 3: // Slot time            kiss_slot_time = command_arg * 10000; // these are tenths of ms            break;        case 4: // Tx tail            kiss_tx_tail = command_arg * 10000; // these are tenths of ms            break;        case 15:            verbprintf(1, "KISS: received aborting command/n");            abort();            break;        default:            break;    }    verbprintf(1, "KISS: command received for port %d: (%d,%d)/n", kiss_port, command_code, command_arg);    return 1;}

void opd_parse_events(char const * events){	char * ev = xstrdup(events);	char * c;	size_t cur = 0;	if (cpu_type == CPU_TIMER_INT) {		struct opd_event * event = &opd_events[0];		event->name = xstrdup("TIMER");		event->value = event->counter			= event->count = event->um = 0;		event->kernel = 1;		event->user = 1;		return;	}	if (!ev || !strlen(ev)) {		fprintf(stderr, "oprofiled: no events passed./n");		exit(EXIT_FAILURE);	}	verbprintf(vmisc, "Events: %s/n", ev);	c = ev;	while (*c && cur < op_nr_counters) {		struct opd_event * event = &opd_events[cur];		if (!(event->name = copy_token(&c, ':')))			malformed_events();		event->value = copy_ulong(&c, ':');		event->counter = copy_ulong(&c, ':');		event->count = copy_ulong(&c, ':');		event->um = copy_ulong(&c, ':');		event->kernel = copy_ulong(&c, ':');		event->user = copy_ulong(&c, ',');		++cur;	}	if (*c) {		fprintf(stderr, "oprofiled: too many events passed./n");		exit(EXIT_FAILURE);	}	free(ev);	cpu_speed = op_cpu_frequency();}