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

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

void UmlCom::send_cmd(const void * id, OnInstanceCmd cmd, const UmlTypeSpec & arg){#ifdef TRACE  qDebug() << "UmlCom::send_cmd(id, " << cmd << ", UmlTypeSpec)/n";#endif    write_char(onInstanceCmd);  write_id(id);  write_char(cmd);  if (arg.type) {    write_id(arg.type->_identifier);    write_string("");  }  else {    write_id(0);    write_string(arg.explicit_type);  }  flush();}

void write_text(MPL *mpl, char *fmt, ...){     va_list arg;      char buf[OUTBUF_SIZE], *c;      va_start(arg, fmt);      vsprintf(buf, fmt, arg);      xassert(strlen(buf) < sizeof(buf));      va_end(arg);      for (c = buf; *c != '/0'; c++) write_char(mpl, *c);      return;}

static void		write_char(int key, t_line *line){  if (key >= 256)    {      write_char(key % 256, line);      write_char(key / 256, line);    }  else if (key != '/n')    {      if (line->line_len >= (BUFF_LINE * line->realloc_cpt))	line_realloc(line);      add_char_in_tab(key, line->line, line->pos);      CAP("nd");      line->pos++;      line->line_len++;      (line->line_len % get_cols()) == 0 ? clear_scr(line) :	clear_and_display(line);    }}

static void write_ccc(struct bt_scpp *scan, GAttrib *attrib, uint16_t handle,								void *user_data){	uint8_t value[2];	put_le16(GATT_CLIENT_CHARAC_CFG_NOTIF_BIT, value);	write_char(scan, attrib, handle, value, sizeof(value), ccc_written_cb,								user_data);}

bool wp_write(char ch){	int		i;	bool	ok;	if ((ch == TAB) || (ch == ' '))	{		if (proportional)		{			if  (ch == ' ')			{				char_pos++;				nr_spaces++;			}			else			{				char_pos += tab_size;				nr_spaces += tab_size;			}		}		else		{		  	if (ch == ' ')				ok = write_char(' ');			else			 	for (i = 1; i <= tab_size; i++)					ok = write_char(' ');		}	}	else	{		if (nr_spaces > 1)			ok = set_head();		else if (nr_spaces == 1)		{			ok = write_char(' ');			nr_spaces = 0;		}		ok = write_char(ch);	}	return ok;}

void temperature_timer_interrupt (void){	char buf[16];	u08 i;	short temperature;	if(conf->current_sector > mmcSectorCount) {		cbi(PORTA,PA0);		return;	}	else {		sbi(PORTA,PA0);	}  	do {		temperature = read_temperature();	} while(temperature>>TEMPERATURE_POINT < -200);	// Format temperature.	format_temperature(buf, temperature);	for (i = 0; buf[i] != '.'; i++);	if (buf[i + 2] >= '5')		buf[i + 1]++;	buf[i + 2] = '/0';	//cbi(PORTA, PA0);	if (mmc_buf_i != 0 || conf->current_sector != START_SECTOR)		write_char('/n');	for (i = 0; buf[i] != '/0'; i++)		write_char(buf[i]);	write_char('/0');	mmc_buf_i--;	// Write to sector.	mmcWrite(conf->current_sector, mmc_buf);	//sbi(PORTA, PA0);}

// TODO: Ugly, might want to revisit this ...int ulcd_sd_list(ulcd_dev *dev, const char *filter, char *buffer, int buflen) {    // Commands    write_char(dev, 0x40);    write_char(dev, 0x64);    serial_write(dev->port, filter, strlen(filter));    write_char(dev, 0x00);    // Some vars    int run = 1;    int pos = 0;    char last = 0;    char in;    // Get much data! MMMMmmmm.... daaaataaaaa....    while(run) {        if(pos > buflen) {            sprintf(errorstr, "Directory listing too long.");            break;        }        in = read_char(dev);        if(in == 0x06 && last == 0) {            return pos;        }        if(in == 0x06 && last == 0x0A) {            return pos;        }        if(in == 0x15 && (last == 0x0A || last == 0)) {            sprintf(errorstr, "Directory listing failed.");            return pos;        }        if(in == 0x0A) {            buffer[pos++] = ',';            last = in;            continue;        }        buffer[pos++] = in;        last = in;    }    return pos;}

void UmlCom::send_cmd(const void * id, OnInstanceCmd cmd, unsigned int arg1, const UmlTypeSpec & arg2){#ifdef TRACE    cout << "UmlCom::send_cmd(id, " << cmd << ", " << arg1 << ", UmlTypeSpec)/n";#endif    write_char(onInstanceCmd);    write_id(id);    write_char(cmd);    write_unsigned(arg1);    if (arg2.type) {        write_id(arg2.type->_identifier);        write_string("");    }    else {        write_id(0);        write_string(arg2.explicit_type);    }    flush();}

void close_output(MPL *mpl){     insist(mpl->out_fp != NULL);      if (mpl->out_cnt > 0) write_char(mpl, '/n');      if (mpl->out_fp != stdout) ufclose(mpl->out_fp);      ufree(mpl->out_buf);      mpl->out_fp = NULL;      mpl->out_file = NULL;      mpl->out_buf = NULL;      mpl->out_cnt = 0;      return;}

static voidwrite_string (const char * s){  while (1)    {      char c = (*s++);      if (c == '/0')	break;      write_char (c);    }}

void generic_terminal_device::term_write(uint8_t data){	if (data > 0x1f)	{		// printable char		if (data != 0x7f) write_char(data);	}	else	{		const uint16_t options = m_io_term_conf->read();		switch(data)		{		case 0x07: // bell			m_beeper->set_state(1);			m_bell_timer->reset(attotime::from_msec(250));			break;		case 0x08: // backspace			if (m_x_pos) m_x_pos--;			break;		case 0x09: // horizontal tab			m_x_pos = (std::min<uint8_t>)((m_x_pos & 0xf8) + 8, TERMINAL_WIDTH - 1);			break;		case 0x0d: // carriage return			m_x_pos = 0;			if (!(options & 0x080)) break;		case 0x0a: // linefeed			m_y_pos++;			if (m_y_pos >= TERMINAL_HEIGHT)			{				scroll_line();				m_y_pos = TERMINAL_HEIGHT - 1;			}			if (options & 0x040) m_x_pos = 0;			break;		case 0x0b: // vertical tab			if (m_y_pos) m_y_pos--;			break;		case 0x0c: // form feed			clear();			break;		case 0x1e: // record separator			m_x_pos = 0;			m_y_pos = 0;			break;		}	}}

void flush_output(MPL *mpl){     insist(mpl->out_fp != NULL);      if (mpl->out_cnt > 0) write_char(mpl, '/n');      if (mpl->out_fp != stdout)      {  fflush(mpl->out_fp);         if (ferror(mpl->out_fp))            error(mpl, "write error on %s - %s", mpl->out_file,               strerror(errno));      }      return;}

/****************************************************************** *		write_block * * WriteConsoleOutput helper: writes a block of non special characters * Block can spread on several lines, and wrapping, if needed, is * handled * */static int     	write_block(HANDLE hCon, CONSOLE_SCREEN_BUFFER_INFO* csbi,			    DWORD mode, LPWSTR ptr, int len){    int	blk;	/* number of chars to write on current line */    if (len <= 0) return 1;    if (mode & ENABLE_WRAP_AT_EOL_OUTPUT) /* writes remaining on next line */    {        int     done;        for (done = 0; done < len; done += blk)        {            blk = min(len - done, csbi->dwSize.X - csbi->dwCursorPosition.X);            if (write_char(hCon, ptr + done, blk, &csbi->dwCursorPosition) != blk)                return 0;            if (csbi->dwCursorPosition.X == csbi->dwSize.X && !next_line(hCon, csbi))                return 0;        }    }    else    {        blk = min(len, csbi->dwSize.X - csbi->dwCursorPosition.X);        if (write_char(hCon, ptr, blk, &csbi->dwCursorPosition) != blk)            return 0;        if (blk < len)        {            csbi->dwCursorPosition.X = csbi->dwSize.X - 1;            /* all remaining chars should be written on last column,             * so only overwrite the last column with last char in block             */            if (write_char(hCon, ptr + len - 1, 1, &csbi->dwCursorPosition) != 1)                return 0;            csbi->dwCursorPosition.X = csbi->dwSize.X - 1;        }    }    return 1;}

// CEA-608, Anex F 1.1.1. - Character Set Table / Special Charactersvoid handle_double(const unsigned char c1, const unsigned char c2, ccx_decoder_608_context *context){	unsigned char c;	if (context->channel != context->my_channel)		return;	if (c2>=0x30 && c2<=0x3f)	{		c=c2 + 0x50; // So if c>=0x80 && c<=0x8f, it comes from here		ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "/rDouble: %02X %02X  -->  %c/n", c1, c2, c);		write_char(c, context);	}}

void write_int(int num) {	idata char buf[32]; 	char *pbuf = buf; 	int bytes, cnt; 	init_lcd(); 	clear_lcd(); 	bytes = 0;	bytes += sprintf(buf + bytes, "U = %3.2f",5*(num/255.0));  	for (cnt = 0; cnt < bytes; cnt++) 	     write_char(pbuf++);}

void do_syscall(TrapFrame *tf){    switch(tf->eax) {        /* The ``add_irq_handle'' system call is artificial. We use it to         * let user program register its interrupt handlers. But this is         * very dangerous in a real operating system. Therefore such a         * system call never exists in GNU/Linux.         */        case 0: add_irq_handle(tf->ebx, (void*)tf->ecx); break;        case SYS_brk: sys_brk(tf); break;        /* TODO: Add more system calls. */        case SYS_write:                      tf->eax = fs_write(                              tf->ebx,                              (void *)(tf->ecx),                              tf->edx);                      break;        case SYS_open:                      tf->eax = fs_open((char *)tf->ebx, tf->ebx);                      break;        case SYS_read:                      tf->eax = fs_read(                              tf->ebx,                              (void *)(tf->ecx),                              tf->edx);                      break;        case SYS_lseek:                      tf->eax = fs_lseek(tf->ebx, tf->ecx, tf->edx);                      break;        case SYS_close:                      tf->eax = fs_close(tf->ebx);                      break;        case WRITE_INT:                        write_int((int)(tf->ebx));                        break;        case READ_INT:                        tf->eax = read_int((char *)(tf->ebx));                        break;        case WRITE_C:                        write_char(tf->ebx);                        break;        case READ_C:                        tf->eax = read_char();                        break;        default:                      panic("Unhandled system call: id = %d", tf->eax);    }}

static voidvidc_rawputchar(int c){    int		i;    if (c == '/t')	/* lame tab expansion */	for (i = 0; i < 8; i++)	    vidc_rawputchar(' ');    else {	/* Emulate AH=0eh (teletype output) */	switch(c) {	case '/a':	    beep();	    return;	case '/r':	    curx = 0;	    curs_move(curx, cury);	    return;	case '/n':	    cury++;	    if (cury > 24) {		scroll_up(1, fg_c, bg_c);		cury--;	    } else {		curs_move(curx, cury);	    }	    return;	case '/b':	    if (curx > 0) {		curx--;		curs_move(curx, cury);		/* write_char(' ', fg_c, bg_c); XXX destructive(!) */		return;	    }	    return;	default:	    write_char(c, fg_c, bg_c);	    curx++;	    if (curx > 79) {		curx = 0;		cury++;	    }	    if (cury > 24) {		curx = 0;		scroll_up(1, fg_c, bg_c);		cury--;	    }	}	curs_move(curx, cury);    }}

void bfm_bd1_t::shift_data(int data){	m_shift_data <<= 1;	if ( !data ) m_shift_data |= 1;	if ( ++m_shift_count >= 8 )	{		write_char(m_shift_data);		m_shift_count = 0;		m_shift_data  = 0;	}}

void write(char* str) {	size_t i = 0;	char c = str[0];	while(c != '/0') {		if(c == '/n') {			write_newline();		} else {			write_char(c);		}		++i;		c = str[i];	}}

static voidmangle_line (const char * line, const char * prefix){  const char * scan = (skip_name (line));  scan = (skip_lws (scan));  scan = (skip_fixed (scan, '('));  scan = (skip_lws (scan));  scan = (skip_fixed (scan, '"'));  write_string (prefix);  write_string (scan);  write_char ('/n');  fflush (stdout);}

ssize_t console_write(bool flush_to_drivers, const void *buf, size_t count){	/* We use recursive locking here as we can get called	 * from fairly deep debug path	 */	bool need_unlock = lock_recursive(&con_lock);	const char *cbuf = buf;	while(count--) {		char c = *(cbuf++);		if (c == 10)			write_char(13);		write_char(c);	}	__flush_console(flush_to_drivers);	if (need_unlock)		unlock(&con_lock);	return count;}

		int bencode_recursive(OutIt& out, const entry& e)		{			int ret = 0;			switch(e.type())			{			case entry::int_t:				write_char(out, 'i');				ret += write_integer(out, e.integer());				write_char(out, 'e');				ret += 2;				break;			case entry::string_t:				ret += write_integer(out, e.string().length());				write_char(out, ':');				ret += write_string(e.string(), out);				ret += 1;				break;			case entry::list_t:				write_char(out, 'l');				for (entry::list_type::const_iterator i = e.list().begin(); i != e.list().end(); ++i)					ret += bencode_recursive(out, *i);				write_char(out, 'e');				ret += 2;				break;			case entry::dictionary_t:				write_char(out, 'd');				for (entry::dictionary_type::const_iterator i = e.dict().begin();					i != e.dict().end(); ++i)				{					// write key					ret += write_integer(out, i->first.length());					write_char(out, ':');					ret += write_string(i->first, out);					// write value					ret += bencode_recursive(out, i->second);					ret += 1;				}				write_char(out, 'e');				ret += 2;				break;			case entry::undefined_t:				// trying to encode a structure with uninitialized values!//				TORRENT_ASSERT_VAL(false, e.type());				// do nothing				break;			}			return ret;		}

static void		print_ox(t_dt *data, t_av *av){	size_t		len;	int			print;	size_t		precision;	len = (data->flag.precision > av->len) ? data->flag.precision : av->len;	if (data->flag.hash && av->ui)		len += 2;	print = data->flag.zero && !data->flag.precision;	if (data->flag.hash && av->ui && data->flag.zero && print)		write_str(data, (*data->tail == 'x') ? "0x" : "0X", 2);	if (!data->flag.minus)	{		while (data->flag.min_width > len && data->flag.min_width--)			write_char(data, (print) ? '0' : ' ');	}	if (data->flag.hash && av->ui && !print)		write_str(data, (*data->tail == 'x') ? "0x" : "0X", 2);	precision = data->flag.precision;	while (precision > av->len && precision--)		write_char(data, '0');}

int con_write(struct tty_struct *tty){	char ch;	int res = 0;	cur_console = tty-tty_table-1;	irq_lock();	while (!isempty(tty->out)) {		GETCH(tty->out, ch);		if (ch == '/033') {			char tmp_x = 0, tmp_y = 0;			while (1) {				GETCH(tty->out, ch);				if (ch >= '0' && ch <= '9')					tmp_x = tmp_x * 10 + ch - '0';				else					break;			}			if (ch == ';') {				while (1) {					GETCH(tty->out, ch);					if (ch >= '0' && ch <= '9')						tmp_y = tmp_y * 10 + ch - '0';					else						break;				}			}			if (ch == 'P') {				if (tmp_x >= 80)					x = 79;				else					x = tmp_x;				if (tmp_y >= 25)					x = 24;				else					y = tmp_y;			} else if (ch == 'C')				color = ((tmp_x << 4) & 0xf0) | (tmp_y & 0xf);			else if (ch=='E')				__echo__=0;			else if (ch=='e')				__echo__=1;		} else			write_char(ch);		res++;	}	if (fg_console == cur_console)		set_cur();	irq_unlock();	return res;}

void rocvfd_t::shift_data(int data){	m_shift_data <<= 1;	if ( !data ) m_shift_data |= 1;	if ( ++m_shift_count >= 8 )	{		write_char(m_shift_data);		m_shift_count = 0;		m_shift_data  = 0;	}	update_display();}

/* If OBJ is a primitive object (roughly, immediate or number), write it to   PORT.  Assumes the caller locks the PORT.   Returns the # of characters written, or #f if OBJ is not a primitive object. */ScmObj Scm__WritePrimitive(ScmObj obj, ScmPort *port, ScmWriteContext *ctx){    const ScmWriteControls *wp = Scm_GetWriteControls(ctx, port->writeState);    #define CASE_ITAG_RET(obj, str)                 /    case SCM_ITAG(obj):                         /        Scm_PutzUnsafe(str, -1, port);          /        return SCM_MAKE_INT(sizeof(str)-1);    if (SCM_IMMEDIATEP(obj)) {        switch (SCM_ITAG(obj)) {            CASE_ITAG_RET(SCM_FALSE,     "#f");            CASE_ITAG_RET(SCM_TRUE,      "#t");            CASE_ITAG_RET(SCM_NIL,       "()");            CASE_ITAG_RET(SCM_EOF,       "#<eof>");            CASE_ITAG_RET(SCM_UNDEFINED, "#<undef>");            CASE_ITAG_RET(SCM_UNBOUND,   "#<unbound>");        default:            Scm_Panic("write: unknown itag object: %08x", SCM_WORD(obj));        }    }    else if (SCM_INTP(obj) && wp->printBase == 10 && !wp->printRadix) {        /* Shortcut to avoid allocation */        char buf[SPBUFSIZ];        int k = snprintf(buf, SPBUFSIZ, "%ld", SCM_INT_VALUE(obj));        Scm_PutzUnsafe(buf, -1, port);        return SCM_MAKE_INT(k);    }    else if (SCM_CHARP(obj)) {        size_t k = write_char(SCM_CHAR_VALUE(obj), port, ctx);        return SCM_MAKE_INT(k);    }    else if (SCM_NUMBERP(obj)) {        ScmNumberFormat fmt;        Scm_NumberFormatInit(&fmt);        fmt.radix = wp->printBase;        if (wp->printRadix) fmt.flags |= SCM_NUMBER_FORMAT_ALT_RADIX;        return SCM_MAKE_INT(Scm_PrintNumber(port, obj, &fmt));    }    /* PVREF only appears in pattern temlate in the current macro expander.       It will be go away once we rewrite the expander. */    else if (SCM_PVREF_P(obj)) {        char buf[SPBUFSIZ];        int k = snprintf(buf, SPBUFSIZ, "#<pvar %ld.%ld>",                         SCM_PVREF_LEVEL(obj), SCM_PVREF_COUNT(obj));        Scm_PutzUnsafe(buf, -1, port);        return SCM_MAKE_INT(k);    }    return SCM_FALSE;}