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

/* *  Output the message body with '^From ' escapes. *  Ensures that any line starting with a 'From ' gets a ' ' stuck *  in front of it. */static intm_escape(message *mp, Biobuf *fp){	char *p, *np;	char *end;	long offset;	int m, n;	char *start;	for(offset = 0; offset < mp->size; offset += n){		n = m_get(mp, offset, &start);		if(n < 0){			Bflush(fp);			return -1;		}		p = start;		for(end = p+n; p < end; p += m){			np = memchr(p, '/n', end-p);			if(np == 0){				Bwrite(fp, p, end-p);				break;			}			m = np - p + 1;			if(m > 5 && strncmp(p, "From ", 5) == 0)				Bputc(fp, ' ');			Bwrite(fp, p, m);		}	}	Bflush(fp);	return 0;}

voidthreadmain(int argc, char *argv[]){	int i;	int lineset;	int ifd;	lineset = 0;	Binit(&bout, 1, OWRITE);	while(argc > 1 && argv[1][0] == '-'){		--argc; argv++;		switch(argv[0][1]){		case '/0':			colonflag = 1;			break;		case 't':			tabflag = 0;			break;		default:			linewidth = atoi(&argv[0][1]);			if(linewidth <= 1)				linewidth = WIDTH;			lineset = 1;			break;		}	}	if(lineset == 0)		getwidth();	cbuf = cbufp = malloc(ALLOC_QUANTA*(sizeof *cbuf));	word = malloc(WORD_ALLOC_QUANTA*(sizeof *word));	if(word == 0 || cbuf == 0)		error("out of memory");	if(argc == 1)		readbuf(0);	else{		for(i = 1; i < argc; i++){			if((ifd = open(*++argv, OREAD)) == -1)				fprint(2, "mc: can't open %s (%r)/n", *argv);			else{				readbuf(ifd);				Bflush(&bin);				close(ifd);			}		}	}	columnate();	Bflush(&bout);	threadexitsall(0);}

intBprint(Biobuf *bb, char *fmt, ...){	va_list arg;	int n, pcol;	char *ip, *ep, *out;	Biobufhdr *bp = &bb->_h;	va_start(arg, fmt);	ep = (char*)bp->ebuf;	ip = ep + bp->ocount;	pcol = printcol;	out = doprint(ip, ep, fmt, arg);	if(out >= ep-UTFmax-1) {		Bflush(bb);		ip = ep + bp->ocount;		printcol = pcol;		out = doprint(ip, ep, fmt, arg);		if(out >= ep-UTFmax-1) {			va_end(arg);			return Beof;		}	}	n = out-ip;	bp->ocount += n;	va_end(arg);	return n;}

voidwinclean(Window *w){	if(w->body)		Bflush(w->body);	ctlprint(w->ctl, "clean/n");}

voidr_fl(int argc, Rune **argv){	USED(argc);	USED(argv);	Bflush(&bout);}

static intstlscmd(char*){	int fd;	TLSconn conn;	if(didtls)		return senderr("tls already started");	if(!tlscert)		return senderr("don't have any tls credentials");	sendok("");	Bflush(&out);	memset(&conn, 0, sizeof conn);	conn.cert = tlscert;	conn.certlen = ntlscert;	if(debug)		conn.trace = trace;	fd = tlsServer(0, &conn);	if(fd < 0)		sysfatal("tlsServer: %r");	dup(fd, 0);	dup(fd, 1);	close(fd);	Binit(&in, 0, OREAD);	Binit(&out, 1, OWRITE);	didtls = 1;	return 0;}

voidmk(char *target){	Node *node;	int did = 0;	nproc();		/* it can be updated dynamically */	nrep();			/* it can be updated dynamically */	runerrs = 0;	node = graph(target);	if(DEBUG(D_GRAPH)){		dumpn("new target/n", node);		Bflush(&bout);	}	clrmade(node);	while(node->flags&NOTMADE){		if(work(node, (Node *)0, (Arc *)0))			did = 1;	/* found something to do */		else {			if(waitup(1, (int *)0) > 0){				if(node->flags&(NOTMADE|BEINGMADE)){					assert(/*must be run errors*/ runerrs);					break;	/* nothing more waiting */				}			}		}	}	if(node->flags&BEINGMADE)		waitup(-1, (int *)0);	while(jobs)		waitup(-2, (int *)0);	assert(/*target didnt get done*/ runerrs || (node->flags&MADE));	if(did == 0)		Bprint(&bout, "mk: '%s' is up to date/n", node->name);}

voidputfile(void){	int *a1;	Rune *lp;	long c;	a1 = addr1;	do {		lp = getline(*a1++);		for(;;) {			count++;			c = *lp++;			if(c == 0) {				if(Bputrune(&iobuf, '/n') < 0)					error(Q);				break;			}			if(Bputrune(&iobuf, c) < 0)				error(Q);		}	} while(a1 <= addr2);	if(Bflush(&iobuf) < 0)		error(Q);}

voidpatch(void){	vlong c, vexit;	Prog *p, *q;	Sym *s;	int a;	if(debug['v'])		Bprint(&bso, "%5.2f patch/n", cputime());	Bflush(&bso);	mkfwd();	s = lookup("exit", 0);	vexit = s->value;	for(p = firstp; p != P; p = p->link) {		a = p->as;		if(a == ATEXT)			curtext = p;		if((a == AJAL || a == AJMP || a == ARET) &&		   p->to.type != D_BRANCH && p->to.sym != S) {			s = p->to.sym;			if(s->type != STEXT) {				diag("undefined: %s/n%P", s->name, p);				s->type = STEXT;				s->value = vexit;			}			p->to.offset = s->value;			p->to.type = D_BRANCH;		}		if(p->to.type != D_BRANCH)			continue;		c = p->to.offset;		for(q = firstp; q != P;) {			if(q->forwd != P)			if(c >= q->forwd->pc) {				q = q->forwd;				continue;			}			if(c == q->pc)				break;			q = q->link;		}		if(q == P) {			diag("branch out of range %lld/n%P", c, p);			p->to.type = D_NONE;		}		p->cond = q;	}	for(p = firstp; p != P; p = p->link) {		if(p->as == ATEXT)			curtext = p;		if(p->cond != P) {			p->cond = brloop(p->cond);			if(p->cond != P)			if(p->to.type == D_BRANCH)				p->to.offset = p->cond->pc;		}	}}

voidwclean(Win *w){	if(w->body)		Bflush(w->body);	ctlwrite(w, "clean/n");}

voidthreadmain(int argc, char *argv[]){	char *errmsg;	int ac;	char *ap, *av[256];	Cmd *cp;	int32_t status;	if (argc > 3) {		print("usage: cifscmd [to [share]]/n");		exits("args");	}	smbglobalsguess(1);	errmsg = nil;	if (Binit(&bin, 0, OREAD) == Beof || Binit(&bout, 1, OWRITE) == Beof) {		fprint(2, "%s: can't init bio: %r/n", argv0);		threadexits("Binit");	}	if (argc > 1) {		c = smbconnect(argv[1], argc == 3 ? argv[2] : nil, &errmsg);		if (c == nil)			fprint(2, "failed to connect: %s/n", errmsg);	}	while (ap = Brdline(&bin, '/n')) {		ap[Blinelen(&bin) - 1] = 0;		switch (ac = parse(ap, av, nelem(av))) {		default:			for (cp = cmd; cp->name; cp++) {				if (strcmp(cp->name, av[0]) == 0)					break;			}			if (cp->name == 0) {				Bprint(&bout, "eh?/n");				break;			}			if (c == 0 && cp->connected) {				Bprint(&bout, "not currently connected/n");				break;			}			if ((status = (*cp->f)(c, ac - 1, &av[1])) != -1) {				if(verbose)					Bprint(&bout, "ok %ld/%ld/n", status >> 16, status & 0xffff);				break;			}			break;		case -1:			Bprint(&bout, "eh?/n");			break;		case 0:			break;		}		Bflush(&bout);	}	threadexits(0);}

voidsyswrite(int64_t offset){	int fd;	uint32_t size, a;	char *buf;	int n;	fd = getmem_w(reg.r[13]+4);	a = getmem_w(reg.r[13]+8);	size = getmem_w(reg.r[13]+12);	Bflush(bioout);	buf = memio(0, a, size, MemRead);	n = pwrite(fd, buf, size, offset);	if(n < 0)		errstr(errbuf, sizeof errbuf);		if(sysdbg)		itrace("write(%d, %lux, %d, 0x%llx) = %d", fd, a, size, offset, n);	free(buf);	reg.r[REGRET] = n;}

voiderror(char *fmt, ...){	int i;	char buf[2048];	va_list arg;	/* Unstack io channels */	if(iop != 0) {		for(i = 1; i < iop; i++)			Bterm(io[i]);		bout = io[0];		iop = 0;	}	ret = 0;	gotint = 0;	Bflush(bout);	if(silent)		silent = 0;	else {		va_start(arg, fmt);		vseprint(buf, buf+sizeof(buf), fmt, arg);		va_end(arg);		fprint(2, "%L: (error) %s/n", buf);	}	while(popio())		;	interactive = 1;	longjmp(err, 1);}

voidpipifc(void){	Ipifc *ip, *nip;	Iplifc *lifc;	char buf[100];	int l, i;	fmtinstall('I', eipfmt);	fmtinstall('M', eipfmt);	ip = readipifc(netroot, nil, -1);	l = 7;	for(nip = ip; nip; nip = nip->next){		for(lifc = nip->lifc; lifc; lifc = lifc->next){			i = snprint(buf, sizeof buf, "%I", lifc->ip);			if(i > l)				l = i;			i = snprint(buf, sizeof buf, "%I", lifc->net);			if(i > l)				l = i;		}	}	for(nip = ip; nip; nip = nip->next){		for(lifc = nip->lifc; lifc; lifc = lifc->next)			Bprint(&out, "%-12s %5d %-*I %5M %-*I %8lud %8lud %8lud %8lud/n",				nip->dev, nip->mtu, 				l, lifc->ip, lifc->mask, l, lifc->net,				nip->pktin, nip->pktout,				nip->errin, nip->errout);	}	Bflush(&out);}

voidcclean(void){	outcode(AEND, Always, &nullgen, NREG, &nullgen);	Bflush(&obuf);}

voidcodeblk(int64 addr, int64 size){	LSym *sym;	int64 eaddr, n;	uchar *q;	if(debug['a'])		Bprint(&bso, "codeblk [%#x,%#x) at offset %#llx/n", addr, addr+size, cpos());	blk(ctxt->textp, addr, size);	/* again for printing */	if(!debug['a'])		return;	for(sym = ctxt->textp; sym != nil; sym = sym->next) {		if(!sym->reachable)			continue;		if(sym->value >= addr)			break;	}	eaddr = addr + size;	for(; sym != nil; sym = sym->next) {		if(!sym->reachable)			continue;		if(sym->value >= eaddr)			break;		if(addr < sym->value) {			Bprint(&bso, "%-20s %.8llux|", "_", (vlong)addr);			for(; addr < sym->value; addr++)				Bprint(&bso, " %.2ux", 0);			Bprint(&bso, "/n");		}		Bprint(&bso, "%.6llux/t%-20s/n", (vlong)addr, sym->name);		n = sym->size;		q = sym->p;		while(n >= 16) {			Bprint(&bso, "%.6ux/t%-20.16I/n", addr, q);			addr += 16;			q += 16;			n -= 16;		}		if(n > 0)			Bprint(&bso, "%.6ux/t%-20.*I/n", addr, (int)n, q);		addr += n;	}	if(addr < eaddr) {		Bprint(&bso, "%-20s %.8llux|", "_", (vlong)addr);		for(; addr < eaddr; addr++)			Bprint(&bso, " %.2ux", 0);	}	Bflush(&bso);}

voiddoprof1(void){#if 0	Sym *s;	int32 n;	Prog *p, *q;	if(debug['v'])		Bprint(&bso, "%5.2f profile 1/n", cputime());	Bflush(&bso);	s = lookup("__mcount", 0);	n = 1;	for(cursym = textp; cursym != nil; cursym = cursym->next) {		p = cursym->text;		q = prg();		q->line = p->line;		q->link = datap;		datap = q;		q->as = ADATA;		q->from.type = D_EXTERN;		q->from.offset = n*4;		q->from.sym = s;		q->from.scale = 4;		q->to = p->from;		q->to.type = D_CONST;		q = prg();		q->line = p->line;		q->pc = p->pc;		q->link = p->link;		p->link = q;		p = q;		p->as = AADDL;		p->from.type = D_CONST;		p->from.offset = 1;		p->to.type = D_EXTERN;		p->to.sym = s;		p->to.offset = n*4 + 4;		n += 2;	}	q = prg();	q->line = 0;	q->link = datap;	datap = q;	q->as = ADATA;	q->from.type = D_EXTERN;	q->from.sym = s;	q->from.scale = 4;	q->to.type = D_CONST;	q->to.offset = n;	s->type = SBSS;	s->size = n*4;#endif}

voidCwrite(Cdimg *cd, void *buf, int n){	assert(Boffset(&cd->bwr) >= 16*Blocksize);	if(Bwrite(&cd->bwr, buf, n) != n)		sysfatal("Bwrite: %r");	Bflush(&cd->brd);}

voidBclean(Buffer *b){	if(b->dirty){		Bflush(b);		b->c1 = b->c2 = 0;		Strzero(&b->cache);	}}

voidvncflush(Vnc *v){	if(Bflush(&v->out) < 0){		if(verbose > 1)			fprint(2, "hungup while sending flush: %r/n");		vnchungup(v);	}}

/* output the message body without ^From escapes */static intm_noescape(message *mp, Biobuf *fp){	long offset;	int n;	char *p;	for(offset = 0; offset < mp->size; offset += n){		n = m_get(mp, offset, &p);		if(n <= 0){			Bflush(fp);			return -1;		}		if(Bwrite(fp, p, n) < 0)			return -1;	}	return Bflush(fp);}

voidSsyscall(uint32_t){	int call;	call = reg.r[REGARG];	if(call < 0 || call >= nelem(systab) || systab[call] == nil) {		Bprint(bioout, "bad system call %d (%#ux)/n", call, call);		dumpreg();		Bflush(bioout);		return;	}	if(trace)		itrace("SWI/t%s", sysctab[call]);	(*systab[call])();	Bflush(bioout);}

/* * print accumulated error reports */voiderrprint(void){	Bflush(&bout);	for(; err != 0; err = err->e_nextp) {		cerror(err->e_mess);		fprint(2, "/n");	}}

intdBprint(char *fmt, ...){	char buf[SIZE], *out;	va_list arg;	int n;	va_start(arg, fmt);	out = vseprint(buf, buf+SIZE, fmt, arg);	va_end(arg);	if(debug){		Bwrite(&berr, buf, (long)(out-buf));		Bflush(&berr);	}	n = Bwrite(&bout, buf, (long)(out-buf));	Bflush(&bout);	return n;}

voidwwritebody(Win *w, char *s, int n){	if(w->body == nil)		openbody(w, OWRITE);	if(Bwrite(w->body, s, n) != n)		  fprint(2,"write error to window: %r");	Bflush(w->body);}

voidastro(char *flags, int initial){	int p[2];	int i, n, np;	char cmd[256], buf[4096], *lines[20], *fld[10];	snprint(cmd, sizeof cmd, "/bin/astro -p %s", flags);	if(pipe(p) < 0){		fprint(2, "can't pipe: %r/n");		return;	}	if(runcommand(cmd, p) < 0){		close(p[0]);		close(p[1]);		fprint(2, "can't run astro: %r");		return;	}	close(p[1]);	n = readn(p[0], buf, sizeof buf-1);	if(n <= 0){		fprint(2, "no data from astro/n");		return;	}	if(!initial)		Bwrite(&bout, buf, n);	buf[n] = '/0';	np = getfields(buf, lines, nelem(lines), 0, "/n");	if(np <= 1){		fprint(2, "astro: not enough output/n");		return;	}	Bprint(&bout, "%s/n", lines[0]);	Bflush(&bout);	/* get latitude and longitude */	if(getfields(lines[0], fld, nelem(fld), 1, " ") < 8)		fprint(2, "astro: can't read longitude: too few fields/n");	else{		mysid = getra(fld[5])*180./PI;		mylat = getra(fld[6])*180./PI;		mylon = getra(fld[7])*180./PI;	}	/*	 * Each time we run astro, we generate a new planet list	 * so multiple appearances of a planet may exist as we plot	 * its motion over time.	 */	planet = malloc(NPlanet*sizeof planet[0]);	if(planet == nil){		fprint(2, "astro: malloc failed: %r/n");		exits("malloc");	}	memset(planet, 0, NPlanet*sizeof planet[0]);	for(i=1; i<np; i++)		parseplanet(lines[i], &planet[i-1]);}

uchar*getrange(Block *b){	uchar *data;	char *status;	int netfd;	static Biobuf netbio;	b->len = Blocksize;	if(b->off + b->len > size)		b->len = size - b->off;	if(debug)		print("getrange: %lld %lld/n", b->off, b->len);	netfd = dialhttp(&netbio);	fprint(netfd, 		"GET %s HTTP/1.1/r/n"		"Host: %s/r/n"		"Accept-Encoding:/r/n"		"Range: bytes=%lld-%lld/r/n"		"/r/n",		get, host, b->off, b->off+b->len);	Bflush(&netbio);	status = readhttphdr(&netbio, nil);	if(status == nil)		return nil;	/*	 * Some servers (e.g., www.google.com) return 200 OK	 * when you ask for the entire page in one range.	 */	if(strstr(status, "206 Partial Content")==nil	&& (b->off!=0 || b->len!=size || strstr(status, "200 OK")==nil)){		free(status);		close(netfd);		werrstr("did not get requested range");		return nil;	}	free(status);	data = emalloc9p(b->len);	if(Bread(&netbio, data, b->len) != b->len){		free(data);		close(netfd);		werrstr("not enough bytes read");		return nil;	}	b->p = data;	close(netfd);	return data;}

voidcclean(void){	Gen2 g2;	g2.from = nullgen;	g2.to = nullgen;	outcode(AEND, &g2);	Bflush(&obuf);}

voidwarning(char *s,...){	va_list argl;	va_start(argl, s);	printerr("Warning", s, argl);	va_end(argl);	Bflush(&fout);}

voidmain(int argc, char **argv){	int fd, ofd;	char diffout[40], idiffout[40];	Biobuf *b1, *b2, bdiff, bout, bstdout;	Dir *d;	ARGBEGIN{	default:		usage();	case 'b':		diffbflag++;		break;	case 'w':		diffwflag++;		break;	}ARGEND	if(argc != 2)		usage();	if((d = dirstat(argv[0])) == nil)		sysfatal("stat %s: %r", argv[0]);	if(d->mode&DMDIR)		sysfatal("%s is a directory", argv[0]);	free(d);	if((d = dirstat(argv[1])) == nil)		sysfatal("stat %s: %r", argv[1]);	if(d->mode&DMDIR)		sysfatal("%s is a directory", argv[1]);	free(d);	if((b1 = Bopen(argv[0], OREAD)) == nil)		sysfatal("open %s: %r", argv[0]);	if((b2 = Bopen(argv[1], OREAD)) == nil)		sysfatal("open %s: %r", argv[1]);	strcpy(diffout, "/tmp/idiff.XXXXXX");	fd = opentemp(diffout, ORDWR|ORCLOSE, 0);	strcpy(idiffout, "/tmp/idiff.XXXXXX");	ofd = opentemp(idiffout, ORDWR|ORCLOSE, 0);	rundiff(argv[0], argv[1], fd);	seek(fd, 0, 0);	Binit(&bdiff, fd, OREAD);	Binit(&bout, ofd, OWRITE);	idiff(b1, argv[0], b2, argv[1], &bdiff, diffout, &bout, idiffout);	Bterm(&bdiff);	Bflush(&bout);	seek(ofd, 0, 0);	Binit(&bout, ofd, OREAD);	Binit(&bstdout, 1, OWRITE);	copy(&bout, idiffout, &bstdout, "<stdout>");	exits(nil);}