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

int C2F(db2int)(int *typ, int *n, double *dx, int *incx, int *dy, int *incy){    int i1;    static int i, ix, iy;    --dx;    i1 = *n;    if (i1 <= 0)    {        return 0;    }    switch (*typ)    {        case 1:            CONV(integer1);            break;        case 2:            CONV(integer2);            break;        case 4:            CONV(int) ;            break;    }    return 0;}

	void BoneNode::generateBoneLine( std::vector< Vector3 >& lineVec , Matrix4 const& trans , int frame )	{#if 0		Matrix4 nextMat;		calcFrameTransform( nextMat , trans , frame );		Vector3 org = motionData[0].pos * trans;		for( NodeList::iterator iter ( mChildren.begin() ) , end( mChildren.end() );			iter != end ; ++iter )		{			BoneNode* bone = static_cast< BoneNode* >( CONV(iter) );			Vector3 pos =  bone->motionData[0].pos * nextMat;			lineVec.push_back( org );			lineVec.push_back( pos );		}		for( NodeList::iterator iter ( mChildren.begin() ) , end( mChildren.end() );			iter != end ; ++iter )		{			castBone( CONV(iter) )->generateBoneLine( lineVec , nextMat , frame );		}#endif	}

static voidipclose(Chan* c){	Fs *f;	f = ipfs[c->dev];	switch(TYPE(c->qid)) {	default:		break;	case Qlog:		if(c->flag & COPEN)			netlogclose(f);		break;	case Qdata:	case Qctl:	case Qerr:		if(c->flag & COPEN)			closeconv(f->p[PROTO(c->qid)]->conv[CONV(c->qid)]);		break;	case Qsnoop:		if(c->flag & COPEN)			decref(&f->p[PROTO(c->qid)]->conv[CONV(c->qid)]->snoopers);		break;	}	free(((IPaux*)c->aux)->owner);	free(c->aux);}

static void to_PCM_double(NeAACDecHandle hDecoder, real_t **input,                          uint8_t channels, uint16_t frame_len,                          double **sample_buffer){    uint8_t ch, ch1;    uint16_t i;    switch (CONV(channels,hDecoder->downMatrix))    {    case CONV(1,0):    case CONV(1,1):        for(i = 0; i < frame_len; i++)        {            real_t inp = input[hDecoder->internal_channel[0]][i];            (*sample_buffer)[i] = (double)inp*FLOAT_SCALE;        }        break;    case CONV(2,0):        if (hDecoder->upMatrix)        {            ch = hDecoder->internal_channel[0];            for(i = 0; i < frame_len; i++)            {                real_t inp0 = input[ch][i];                (*sample_buffer)[(i*2)+0] = (double)inp0*FLOAT_SCALE;                (*sample_buffer)[(i*2)+1] = (double)inp0*FLOAT_SCALE;            }        } else {            ch  = hDecoder->internal_channel[0];            ch1 = hDecoder->internal_channel[1];            for(i = 0; i < frame_len; i++)            {                real_t inp0 = input[ch ][i];                real_t inp1 = input[ch1][i];                (*sample_buffer)[(i*2)+0] = (double)inp0*FLOAT_SCALE;                (*sample_buffer)[(i*2)+1] = (double)inp1*FLOAT_SCALE;            }        }        break;    default:        for (ch = 0; ch < channels; ch++)        {            for(i = 0; i < frame_len; i++)            {                real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);                (*sample_buffer)[(i*channels)+ch] = (double)inp*FLOAT_SCALE;            }        }        break;    }}

static longcmdread(Chan *ch, void *a, long n, vlong offset){	Conv *c;	char *p, *cmds;	int fd;	USED(offset);	p = a;	switch(TYPE(ch->qid)) {	default:		error(Eperm);	case Qcmd:	case Qtopdir:	case Qconvdir:		return devdirread(ch, a, n, 0, 0, cmdgen);	case Qctl:		sprint(up->genbuf, "%ld", CONV(ch->qid));		return readstr(offset, p, n, up->genbuf);	case Qstatus:		c = cmd.conv[CONV(ch->qid)];		cmds = "";		if(c->cmd != nil)			cmds = c->cmd->f[1];		snprint(up->genbuf, sizeof(up->genbuf), "cmd/%d %d %s %q %q/n",			c->x, c->inuse, c->state, c->dir, cmds);		return readstr(offset, p, n, up->genbuf);	case Qdata:	case Qstderr:		fd = 1;		if(TYPE(ch->qid) == Qstderr)			fd = 2;		c = cmd.conv[CONV(ch->qid)];		qlock(&c->l);		if(c->fd[fd] == -1){			qunlock(&c->l);			return 0;		}		qunlock(&c->l);		osenter();		n = read(c->fd[fd], a, n);		osleave();		if(n < 0)			oserror();		return n;	case Qwait:		c = cmd.conv[CONV(ch->qid)];		return qread(c->waitq, a, n);	}}

longipread(Chan *ch, void *a, long n, vlong offset){	int r;	Conv *c;	Proto *x;	uchar ip[4];	char buf[128], *p;/*print("ipread %s %lux/n", c2name(ch), (long)ch->qid.path);*/	p = a;	switch(TYPE(ch->qid)) {	default:		error(Eperm);	case Qcs:		return csread(ch, a, n, offset);	case Qprotodir:	case Qtopdir:	case Qconvdir:		return devdirread(ch, a, n, 0, 0, ipgen);	case Qctl:		sprint(buf, "%d", CONV(ch->qid));		return readstr(offset, p, n, buf);	case Qremote:		c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)];		hnputl(ip, c->raddr);		sprint(buf, "%I!%d/n", ip, c->rport);		return readstr(offset, p, n, buf);	case Qlocal:		c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)];		hnputl(ip, c->laddr);		sprint(buf, "%I!%d/n", ip, c->lport);		return readstr(offset, p, n, buf);	case Qstatus:		x = &proto[PROTO(ch->qid)];		c = x->conv[CONV(ch->qid)];		sprint(buf, "%s/%d %d %s /n",			c->p->name, c->x, c->r.ref, c->state);		return readstr(offset, p, n, buf);	case Qdata:		c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)];		r = so_recv(c->sfd, a, n, 0);		if(r < 0){			oserrstr();			nexterror();		}		return r;	}}

static intcmdwstat(Chan *c, uchar *dp, int n){	Dir *d;	Conv *cv;	switch(TYPE(c->qid)){	default:		error(Eperm);	case Qctl:	case Qdata:	case Qstderr:		d = malloc(sizeof(*d)+n);		if(d == nil)			error(Enomem);		if(waserror()){			free(d);			nexterror();		}		n = convM2D(dp, n, d, (char*)&d[1]);		if(n == 0)			error(Eshortstat);		cv = cmd.conv[CONV(c->qid)];		if(!iseve() && strcmp(up->env->user, cv->owner) != 0)			error(Eperm);		if(!emptystr(d->uid))			kstrdup(&cv->owner, d->uid);		if(d->mode != ~0UL)			cv->perm = d->mode & 0777;		poperror();		free(d);		break;	}	return n;}

static intipwstat(Chan *c, uchar *dp, int n){	Dir d;	Conv *cv;	Fs *f;	Proto *p;	f = ipfs[c->dev];	switch(TYPE(c->qid)) {	default:		error(Eperm);		break;	case Qctl:	case Qdata:		break;	}	n = convM2D(dp, n, &d, nil);	if(n > 0){		p = f->p[PROTO(c->qid)];		cv = p->conv[CONV(c->qid)];		if(!iseve() && strcmp(ATTACHER(c), cv->owner) != 0)			error(Eperm);		if(d.uid[0])			kstrdup(&cv->owner, d.uid);		cv->perm = d.mode & 0777;	}	return n;}

static longipbwrite(Chan* ch, Block* bp, ulong offset){	Conv *c;	Proto *x;	Fs *f;	int n;	switch(TYPE(ch->qid)){	case Qdata:		f = ipfs[ch->dev];		x = f->p[PROTO(ch->qid)];		c = x->conv[CONV(ch->qid)];		if(c->wq == nil)			error(Eperm);		if(bp->next)			bp = concatblock(bp);		n = BLEN(bp);		qbwrite(c->wq, bp);		return n;	default:		return devbwrite(ch, bp, offset);	}}

voidipclose(Chan *c){	Conv *cc;	switch(TYPE(c->qid)) {	case Qcs:		csclose(c);		break;	case Qdata:	case Qctl:		if((c->flag & COPEN) == 0)			break;		cc = proto[PROTO(c->qid)].conv[CONV(c->qid)];		if(decref(&cc->r) != 0)			break;		strcpy(cc->owner, "network");		cc->perm = 0666;		cc->state = "Closed";		cc->laddr = 0;		cc->raddr = 0;		cc->lport = 0;		cc->rport = 0;		close(cc->sfd);		break;	}}

/*  BAD  Sheets need work  */void parse_sheet (int fd){    char localbuf[1000];    char filename[1000];    char filetext[1000];    int size;    int index;    int n;    int x1,y1,x2,y2;    size = read_block(fd,localbuf,15,sizeof(localbuf));    // fprintf(stderr,"Sheet %d bytes/n",size);    x1=CONVX(CONV16(localbuf,0));    y1=CONVY(CONV16(localbuf,2));    x2=CONV(CONV16(localbuf,4));    y2=CONV(CONV16(localbuf,6));    index = 8;    /* BAD 5 bytes - dunno? */    index += 5;    n = 1+read_string(filename,sizeof(filename),localbuf+index);    index += n;    n = 1+read_string(filetext,sizeof(filetext),localbuf+index);    index += n;    /* BAD Implement Hierarchy properly! */    fprintf(stderr,"Hierarchy/n");    fprintf(stderr,"xy = %d %d %d %d/n",x1,y1,x2,y2);    for (n=8; n<13; ++n) fprintf(stderr,"%02x ",localbuf[n] & 0xff);    fprintf(stderr,"/nfile = %s/n",filename);    fprintf(stderr,"text = %s/n",filetext);    /* BAD not the way to do it... */    fprintf(stdout,"C %d %d 0 0 0 include-1.sym/n",x1,y1-y2);    fprintf(stdout,"{/n");    fprintf(stdout,"B %d %d %d %d %d 0 0 0 -1 -1 0 -1 -1 -1 -1 -1/n",					x1,y1-y2,x2,y2,GRAPHIC_COLOR);    fprintf(stdout,"T %d %d %d %d 0 1 0 0/n"		   "source=%s/n",x1,y1-y2,ATTRIBUTE_COLOR,TEXTSIZE,filename);    fprintf(stdout,"T %d %d %d %d 1 1 0 0/n"		   "%s/n",x1,(y1-y2)-scale,ATTRIBUTE_COLOR,TEXTSIZE,filetext);    fprintf(stdout,"}/n");}

static intip3gen(Chan *c, int i, Dir *dp){	Qid q;	Conv *cv;	char *p;	cv = ipfs[c->dev]->p[PROTO(c->qid)]->conv[CONV(c->qid)];	if(cv->owner == nil)		kstrdup(&cv->owner, eve);	mkqid(&q, QID(PROTO(c->qid), CONV(c->qid), i), 0, QTFILE);	switch(i) {	default:		return -1;	case Qctl:		devdir(c, q, "ctl", 0, cv->owner, cv->perm, dp);		return 1;	case Qdata:		devdir(c, q, "data", qlen(cv->rq), cv->owner, cv->perm, dp);		return 1;	case Qerr:		devdir(c, q, "err", qlen(cv->eq), cv->owner, cv->perm, dp);		return 1;	case Qlisten:		devdir(c, q, "listen", 0, cv->owner, cv->perm, dp);		return 1;	case Qlocal:		p = "local";		break;	case Qremote:		p = "remote";		break;	case Qsnoop:		if(strcmp(cv->p->name, "ipifc") != 0)			return -1;		devdir(c, q, "snoop", qlen(cv->sq), cv->owner, 0400, dp);		return 1;	case Qstatus:		p = "status";		break;	}	devdir(c, q, p, 0, cv->owner, 0444, dp);	return 1;}

void convert_packet (struct rtp_packet_t *packet, enum conversion conv_dir){  if (conv_dir == NTOH)  {#define CONV(var) var = ntohs ((uint16_t) var);  }  else  {#define CONV(var) var = ntohs ((uint16_t) var);  }  CONV (packet->connection_id);  CONV (packet->type);  CONV (packet->status);  char tmp[PATH_LEN];  string_byte_order_convert (tmp, packet->buffer, PATH_LEN, conv_dir);  strcpy (packet->buffer, tmp);}

// qemu seems to use 24-hour GWT and the values are BCD encodedvoidcmostime(struct rtcdate *r){  struct rtcdate t1, t2;  int sb, bcd;  sb = cmos_read(CMOS_STATB);  bcd = (sb & (1 << 2)) == 0;  // make sure CMOS doesn't modify time while we read it  for(;;) {    fill_rtcdate(&t1);    if(cmos_read(CMOS_STATA) & CMOS_UIP)        continue;    fill_rtcdate(&t2);    if(memcmp(&t1, &t2, sizeof(t1)) == 0)      break;  }  // convert  if(bcd) {#define    CONV(x)     (t1.x = ((t1.x >> 4) * 10) + (t1.x & 0xf))    CONV(second);    CONV(minute);    CONV(hour  );    CONV(day   );    CONV(month );    CONV(year  );#undef     CONV  }  *r = t1;  r->year += 2000;}

static intcmd3gen(Chan *c, int i, Dir *dp){	Qid q;	Conv *cv;	cv = cmd.conv[CONV(c->qid)];	switch(i){	default:		return -1;	case Qdata:		mkqid(&q, QID(CONV(c->qid), Qdata), 0, QTFILE);		devdir(c, q, "data", 0, cv->owner, cv->perm, dp);		return 1;	case Qstderr:		mkqid(&q, QID(CONV(c->qid), Qstderr), 0, QTFILE);		devdir(c, q, "stderr", 0, cv->owner, 0444, dp);		return 1;	case Qctl:		mkqid(&q, QID(CONV(c->qid), Qctl), 0, QTFILE);		devdir(c, q, "ctl", 0, cv->owner, cv->perm, dp);		return 1;	case Qstatus:		mkqid(&q, QID(CONV(c->qid), Qstatus), 0, QTFILE);		devdir(c, q, "status", 0, cv->owner, 0444, dp);		return 1;	case Qwait:		mkqid(&q, QID(CONV(c->qid), Qwait), 0, QTFILE);		devdir(c, q, "wait", 0, cv->owner, 0444, dp);		return 1;	}}

static voidipclose(Chan *c){	Fs *f;	f = ipfs[c->dev];	switch(TYPE(c->qid)) {	case Qdata:	case Qctl:		if(c->flag & COPEN)			closeconv(f->p[PROTO(c->qid)]->conv[CONV(c->qid)]);		break;	}}

static Block*ipbread(Chan* ch, long n, ulong offset){	Conv *c;	Proto *x;	Fs *f;	switch(TYPE(ch->qid)){	case Qdata:		f = ipfs[ch->dev];		x = f->p[PROTO(ch->qid)];		c = x->conv[CONV(ch->qid)];		return qbread(c->rq, n);	default:		return devbread(ch, n, offset);	}}

static voidcmdclose(Chan *c){	Conv *cc;	int r;	if((c->flag & COPEN) == 0)		return;	switch(TYPE(c->qid)) {	case Qctl:	case Qalloc:	case Qexec:	case Qdata:	case Qstderr:	case Qwait:		cc = cmd.conv[CONV(c->qid)];		qlock(&cc->l);		if(TYPE(c->qid) == Qdata){			if(c->mode == OWRITE || c->mode == ORDWR)				cmdfdclose(cc, 0);			if(c->mode == OREAD || c->mode == ORDWR)				cmdfdclose(cc, 1);		}else if(TYPE(c->qid) == Qstderr)			cmdfdclose(cc, 2);		r = --cc->inuse;		if(cc->child != nil){			if(!cc->killed)			if(r == 0 || (cc->killonclose && TYPE(c->qid) == Qctl)){				// oscmdkill(cc->child);				cc->killed = 1;			}		}else if(r == 0)			closeconv(cc);		qunlock(&cc->l);		break;	}}

static intipwstat(Chan *c, uchar *dp, int n){	Dir *d;	Conv *cv;	Proto *p;	Fs *f;	f = ipfs[c->dev];	switch(TYPE(c->qid)) {	default:		error(Eperm);		break;	case Qctl:	case Qdata:		break;	}	d = smalloc(sizeof(*d)+n);	if(waserror()){		free(d);		nexterror();	}	n = convM2D(dp, n, d, (char*)&d[1]);	if(n == 0)		error(Eshortstat);	p = f->p[PROTO(c->qid)];	cv = p->conv[CONV(c->qid)];	if(!iseve() && strcmp(up->env->user, cv->owner) != 0)		error(Eperm);	if(!emptystr(d->uid))		kstrdup(&cv->owner, d->uid);	if(d->mode != ~0UL)		cv->perm = d->mode & 0777;	poperror();	free(d);	return n;}

int main(int argc, char **argv){	FILE *in = stdin, *out = stdout;	progname = basename(*argv);	if (*(argv+1)) {		in = fopen(*(argv+1), "rb");		if (!in) return 1;	}	if (*(argv+1) && *(argv+2)) {		out = fopen(*(argv+2), "wb");		if (!out) return 2;	}	if (0) {}/* host to target functions */	CONV(htobe16, x16)	CONV(htole16, x16)	CONV(htobe32, x32)	CONV(htole32, x32)	CONV(htobe64, x64)	CONV(htole64, x64)/* from target to host functions */	CONV(be16toh, x16)	CONV(le16toh, x16)	CONV(be32toh, x32)	CONV(le32toh, x32)	CONV(be64toh, x64)	CONV(le64toh, x64)	else usage();	fclose(in);	fclose(out);	return 0;}

int find(buffer * const b, const char *pattern, const bool skip_first) {	bool recompile_string;	if (!pattern) {		pattern = b->find_string;		recompile_string = b->find_string_changed || b->last_was_regexp;	}	else recompile_string = true;	const int m = strlen(pattern);	if (!pattern || !m) return ERROR;	if (recompile_string) for(int i = 0; i < sizeof d / sizeof *d; i++) d[i] = m;	const unsigned char * const up_case = b->encoding == ENC_UTF8 ? ascii_up_case : localised_up_case;	const bool sense_case = (b->opt.case_search != 0);	line_desc *ld = b->cur_line_desc;	int64_t y = b->cur_line;	stop = false;	if (! b->opt.search_back) {		if (recompile_string) {			for(int i = 0; i < m - 1; i++) d[CONV((unsigned char)pattern[i])] = m - i-1;			b->find_string_changed = 0;		}		char * p = ld->line + b->cur_pos + m - 1 + (skip_first ? 1 : 0);		const unsigned char first_char = CONV((unsigned char)pattern[m - 1]);		while(y < b->num_lines && !stop) {			assert(ld->ld_node.next != NULL);			if (ld->line_len >= m) {				while((p - ld->line) < ld->line_len) {					const unsigned char c = CONV((unsigned char)*p);					if (c != first_char) p += d[c];					else {						int i;						for (i = 1; i < m; i++)							if (CONV((unsigned char)*(p - i)) != CONV((unsigned char)pattern[m - i-1])) {								p += d[c];								break;							}						if (i == m) {							goto_line(b, y);							goto_pos(b, (p - ld->line) - m + 1);							return OK;						}					}				}			}			ld = (line_desc *)ld->ld_node.next;			if (ld->ld_node.next) p = ld->line + m-1;			y++;		}	}	else {		if (recompile_string) {			for(int i = m - 1; i > 0; i--) d[CONV((unsigned char)pattern[i])] = i;			b->find_string_changed = 0;		}		char * p = ld->line + (b->cur_pos > ld->line_len - m ? ld->line_len - m : b->cur_pos + (skip_first ? -1 : 0));		const unsigned char first_char = CONV((unsigned char)pattern[0]);		while(y >= 0 && !stop) {			assert(ld->ld_node.prev != NULL);			if (ld->line_len >= m) {				while((p - ld->line) >= 0) {					const unsigned char c = CONV((unsigned char)*p);					if (c != first_char) p -= d[c];					else {						int i;						for (i = 1; i < m; i++)							if (CONV((unsigned char)*(p + i)) != CONV((unsigned char)pattern[i])) {								p -= d[c];								break;							}						if (i == m) {							goto_line(b, y);							goto_pos(b, p - ld->line);							return OK;						}					}				}			}			ld = (line_desc *)ld->ld_node.prev;			if (ld->ld_node.prev) p = ld->line + ld->line_len - m;			y--;//.........这里部分代码省略.........

//.........这里部分代码省略.........    BufferSize = BufferHeight * BufferWidth;    II = (icvDerProduct*) cvAlloc(BufferSize * sizeof(icvDerProduct));    WII = (icvDerProduct*) cvAlloc(BufferSize * sizeof(icvDerProduct));    if ((II == NULL) || (WII == NULL)) {        NoMem = 1;    }    if (NoMem) {        for (k = 0; k < 2; k++) {            if (MemX[k]) {                cvFree(&MemX[k]);            }            if (MemY[k]) {                cvFree(&MemY[k]);            }        }        if (II) {            cvFree(&II);        }        if (WII) {            cvFree(&WII);        }        return CV_OUTOFMEM_ERR;    }    /****************************************************************************************/    /*        Calculate first line of memX and memY                                         */    /****************************************************************************************/    MemY[0][0] = MemY[1][0] = CONV(imgA[0], imgA[0], imgA[1]);    MemX[0][0] = MemX[1][0] = CONV(imgA[0], imgA[0], imgA[imgStep]);    for (j = 1; j < imageWidth - 1; j++) {        MemY[0][j] = MemY[1][j] = CONV(imgA[j - 1], imgA[j], imgA[j + 1]);    }    pixNumber = imgStep;    for (i = 1; i < imageHeight - 1; i++) {        MemX[0][i] = MemX[1][i] = CONV(imgA[pixNumber - imgStep],                                       imgA[pixNumber], imgA[pixNumber + imgStep]);        pixNumber += imgStep;    }    MemY[0][imageWidth - 1] =        MemY[1][imageWidth - 1] = CONV(imgA[imageWidth - 2],                                       imgA[imageWidth - 1], imgA[imageWidth - 1]);    MemX[0][imageHeight - 1] =        MemX[1][imageHeight - 1] = CONV(imgA[pixNumber - imgStep],                                        imgA[pixNumber], imgA[pixNumber]);    /****************************************************************************************/    /*    begin scan image, calc derivatives and solve system                               */    /****************************************************************************************/    PixelLine = -VerRadius;    ConvLine = 0;    BufferAddress = -BufferWidth;    while (PixelLine < imageHeight) {        if (ConvLine < imageHeight) {

static void to_PCM_16bit(NeAACDecHandle hDecoder, real_t **input,                         uint8_t channels, uint16_t frame_len,                         int16_t **sample_buffer){    uint8_t ch, ch1;    uint16_t i;    switch (CONV(channels,hDecoder->downMatrix))    {    case CONV(1,0):    case CONV(1,1):        for(i = 0; i < frame_len; i++)        {            real_t inp = input[hDecoder->internal_channel[0]][i];            CLIP(inp, 32767.0f, -32768.0f);            (*sample_buffer)[i] = (int16_t)lrintf(inp);        }        break;    case CONV(2,0):        if (hDecoder->upMatrix)        {            ch  = hDecoder->internal_channel[0];            for(i = 0; i < frame_len; i++)            {                real_t inp0 = input[ch][i];                CLIP(inp0, 32767.0f, -32768.0f);                (*sample_buffer)[(i*2)+0] = (int16_t)lrintf(inp0);                (*sample_buffer)[(i*2)+1] = (int16_t)lrintf(inp0);            }        } else {            ch  = hDecoder->internal_channel[0];            ch1 = hDecoder->internal_channel[1];            for(i = 0; i < frame_len; i++)            {                real_t inp0 = input[ch ][i];                real_t inp1 = input[ch1][i];                CLIP(inp0, 32767.0f, -32768.0f);                CLIP(inp1, 32767.0f, -32768.0f);                (*sample_buffer)[(i*2)+0] = (int16_t)lrintf(inp0);                (*sample_buffer)[(i*2)+1] = (int16_t)lrintf(inp1);            }        }        break;    default:        for (ch = 0; ch < channels; ch++)        {            for(i = 0; i < frame_len; i++)            {                real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);                CLIP(inp, 32767.0f, -32768.0f);                (*sample_buffer)[(i*channels)+ch] = (int16_t)lrintf(inp);            }        }        break;    }}

static Chan *ipopen(Chan *c, int omode){	Conv *cv, *nc;	Proto *p;	uchar raddr[IPaddrlen];	ushort rport;	int perm, sfd;	Fs *f;	perm = m2p[omode&3];	f = ipfs[c->dev];	switch(TYPE(c->qid)) {	default:		break;	case Qtopdir:	case Qprotodir:	case Qconvdir:	case Qstatus:	case Qremote:	case Qlocal:	case Qstats:	/* case Qipselftab: */		if(omode != OREAD)			error(Eperm);		break;	case Qndb:		if(omode & (OWRITE|OTRUNC) && !iseve())			error(Eperm);		if((omode & (OWRITE|OTRUNC)) == (OWRITE|OTRUNC)){			f->ndb[0] = 0;			f->ndbvers++;		}		break;	case Qclone:		p = f->p[PROTO(c->qid)];		cv = protoclone(p, up->env->user, -1);		if(cv == 0)			error(Enodev);		mkqid(&c->qid, QID(p->x, cv->x, Qctl), 0, QTFILE);		break;	case Qdata:	case Qctl:		p = f->p[PROTO(c->qid)];		qlock(&p->l);		cv = p->conv[CONV(c->qid)];		qlock(&cv->l);		if(waserror()){			qunlock(&cv->l);			qunlock(&p->l);			nexterror();		}		if((perm & (cv->perm>>6)) != perm) {			if(strcmp(up->env->user, cv->owner) != 0)				error(Eperm);			if((perm & cv->perm) != perm)				error(Eperm);		}		cv->inuse++;		if(cv->inuse == 1) {			kstrdup(&cv->owner, up->env->user);			cv->perm = 0660;			if(cv->sfd < 0)				cv->sfd = so_socket(p->stype);		}		poperror();		qunlock(&cv->l);		qunlock(&p->l);		break;	case Qlisten:		p = f->p[PROTO(c->qid)];		cv = p->conv[CONV(c->qid)];		if((perm & (cv->perm>>6)) != perm){			if(strcmp(up->env->user, cv->owner) != 0)				error(Eperm);			if((perm & cv->perm) != perm)				error(Eperm);		}		if(cv->state != Announced)			error("not announced");		qlock(&cv->listenq);		if(waserror()){			qunlock(&cv->listenq);			nexterror();		}		sfd = so_accept(cv->sfd, raddr, &rport);		nc = protoclone(p, up->env->user, sfd);		if(nc == 0) {			so_close(sfd);			error(Enodev);		}		memmove(nc->raddr, raddr, IPaddrlen);		nc->rport = rport;		setladdr(nc);//.........这里部分代码省略.........

static longipread(Chan *ch, void *a, long n, vlong off){	int r;	Conv *c;	Proto *x;	char *p, *s;	Fs *f;	ulong offset = off;	f = ipfs[ch->dev];	p = a;	switch(TYPE(ch->qid)) {	default:		error(Eperm);	case Qprotodir:	case Qtopdir:	case Qconvdir:		return devdirread(ch, a, n, 0, 0, ipgen);	case Qarp:		error(Eperm);	/* TO DO */	case Qndb:		return readstr(off, a, n, f->ndb);	case Qctl:		sprint(up->genbuf, "%lud", CONV(ch->qid));		return readstr(offset, p, n, up->genbuf);	case Qremote:		x = f->p[PROTO(ch->qid)];		c = x->conv[CONV(ch->qid)];		sprint(up->genbuf, "%I!%d/n", c->raddr, c->rport);		return readstr(offset, p, n, up->genbuf);	case Qlocal:		x = f->p[PROTO(ch->qid)];		c = x->conv[CONV(ch->qid)];		sprint(up->genbuf, "%I!%d/n", c->laddr, c->lport);		return readstr(offset, p, n, up->genbuf);	case Qstatus:		x = f->p[PROTO(ch->qid)];		c = x->conv[CONV(ch->qid)];		s = smalloc(Statelen);		if(waserror()){			free(s);			nexterror();		}		snprint(s, Statelen, "%s/n", ipstates[c->state]);		n = readstr(offset, p, n, s);		poperror();		free(s);		return n;	case Qdata:		x = f->p[PROTO(ch->qid)];		c = x->conv[CONV(ch->qid)];		if(c->sfd < 0)			error(Ehungup);		if(c->headers) {			if(n < c->headers)				error(Ebadarg);			p = a;			r = so_recv(c->sfd, p + c->headers, n - c->headers, p, c->headers);			if(r > 0)				r += c->headers;		} else			r = so_recv(c->sfd, a, n, nil, 0);		if(r < 0)			oserror();		return r;	case Qstats:		error("stats not implemented");		return n;	}}

static longipwrite(Chan *ch, void *a, long n, vlong off){	Conv *c;	Proto *x;	char *p;	Cmdbuf *cb;	Fs *f;	f = ipfs[ch->dev];	switch(TYPE(ch->qid)) {	default:		error(Eperm);	case Qdata:		x = f->p[PROTO(ch->qid)];		c = x->conv[CONV(ch->qid)];		if(c->sfd < 0)			error(Ehungup);		qlock(&c->wlock);		if(waserror()){			qunlock(&c->wlock);			nexterror();		}		if(c->headers) {			if(n < c->headers)				error(Eshort);			p = a;			n = so_send(c->sfd, p + c->headers, n - c->headers, p, c->headers);			if(n >= 0)				n += c->headers;		} else			n = so_send(c->sfd, a, n, nil, 0);		poperror();		qunlock(&c->wlock);		if(n < 0)			oserror();		break;	case Qarp:		return arpwrite(a, n);	case Qndb:		if(off > strlen(f->ndb))			error(Eio);		if(off+n >= sizeof(f->ndb)-1)			error(Eio);		memmove(f->ndb+off, a, n);		f->ndb[off+n] = 0;		f->ndbvers++;		f->ndbmtime = seconds();		break;	case Qctl:		x = f->p[PROTO(ch->qid)];		c = x->conv[CONV(ch->qid)];		cb = parsecmd(a, n);		qlock(&c->l);		if(waserror()){			qunlock(&c->l);			free(cb);			nexterror();		}		if(cb->nf < 1)			error("short control request");		if(strcmp(cb->f[0], "connect") == 0)			connectctlmsg(x, c, cb);		else if(strcmp(cb->f[0], "announce") == 0)			announcectlmsg(x, c, cb);		else if(strcmp(cb->f[0], "bind") == 0)			bindctlmsg(x, c, cb);		else if(strcmp(cb->f[0], "ttl") == 0){			/* ignored */		} else if(strcmp(cb->f[0], "tos") == 0){			/* ignored */		} else if(strcmp(cb->f[0], "ignoreadvice") == 0){			/* ignored */		} else if(strcmp(cb->f[0], "headers4") == 0){			if(c->p->stype != S_UDP)				error(Enoctl);			c->headers = OUdphdrlenv4;		} else if(strcmp(cb->f[0], "oldheaders") == 0){			if(c->p->stype != S_UDP)				error(Enoctl);			c->headers = OUdphdrlen;		} else if(strcmp(cb->f[0], "headers") == 0){			if(c->p->stype != S_UDP)				error(Enoctl);			c->headers = Udphdrlen;		} else if(strcmp(cb->f[0], "hangup") == 0){			if(c->p->stype != S_TCP)				error(Enoctl);			qunlock(&c->l);			if(waserror()){				qlock(&c->l);				nexterror();			}			/* TO DO: check fd status if socket close/hangup interrupted */			if(c->sfd >= 0 && so_hangup(c->sfd, 1) < 0)				oserror();			qlock(&c->l);			poperror();			c->sfd = -1;//.........这里部分代码省略.........

intinit (void){#if defined(USE_SSE2)  const Babl *rgbaF_linear = babl_format_new (    babl_model ("RGBA"),    babl_type ("float"),    babl_component ("R"),    babl_component ("G"),    babl_component ("B"),    babl_component ("A"),    NULL);  const Babl *rgbAF_linear = babl_format_new (    babl_model ("RaGaBaA"),    babl_type ("float"),    babl_component ("Ra"),    babl_component ("Ga"),    babl_component ("Ba"),    babl_component ("A"),    NULL);  const Babl *rgba16_linear = babl_format_new (    babl_model ("RGBA"),    babl_type ("u16"),    babl_component ("R"),    babl_component ("G"),    babl_component ("B"),    babl_component ("A"),    NULL);  const Babl *rgbaF_gamma = babl_format_new (    babl_model ("R'G'B'A"),    babl_type ("float"),    babl_component ("R'"),    babl_component ("G'"),    babl_component ("B'"),    babl_component ("A"),    NULL);  const Babl *rgbAF_gamma = babl_format_new (    babl_model ("R'aG'aB'aA"),    babl_type ("float"),    babl_component ("R'a"),    babl_component ("G'a"),    babl_component ("B'a"),    babl_component ("A"),    NULL);  const Babl *rgba16_gamma = babl_format_new (    babl_model ("R'G'B'A"),    babl_type ("u16"),    babl_component ("R'"),    babl_component ("G'"),    babl_component ("B'"),    babl_component ("A"),    NULL);#define CONV(src, dst) /{ /  babl_conversion_new (src ## _linear, dst ## _linear, "linear", conv_ ## src ## _ ## dst, NULL); /  babl_conversion_new (src ## _gamma, dst ## _gamma, "linear", conv_ ## src ## _ ## dst, NULL); /}  if ((babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE) &&      (babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE2))    {      CONV (rgba16, rgbaF);      CONV (rgba16, rgbAF);    }#endif /* defined(USE_SSE2) */  return 0;}

static Chan *cmdopen(Chan *c, int omode){	int perm;	Conv *cv;	char *user;	perm = 0;	omode = openmode(omode);	switch(omode) {	case OREAD:		perm = 4;		break;	case OWRITE:		perm = 2;		break;	case ORDWR:		perm = 6;		break;	}	switch(TYPE(c->qid)) {	default:		break;	case Qtopdir:	case Qcmd:	case Qconvdir:	case Qstatus:		if(omode != OREAD)			error(Eperm);		break;	case Qclonus:		qlock(&cmd.l);		if(waserror()){			qunlock(&cmd.l);			nexterror();		}		cv = cmdclone(up->env->user);		poperror();		qunlock(&cmd.l);		if(cv == 0)			error(Enodev);		mkqid(&c->qid, QID(cv->x, Qctl), 0, QTFILE);		break;	case Qdata:	case Qstderr:	case Qctl:	case Qwait:		qlock(&cmd.l);		cv = cmd.conv[CONV(c->qid)];		qlock(&cv->l);		if(waserror()){			qunlock(&cv->l);			qunlock(&cmd.l);			nexterror();		}		user = up->env->user;		if((perm & (cv->perm>>6)) != perm) {			if(strcmp(user, cv->owner) != 0 ||		 	  (perm & cv->perm) != perm)				error(Eperm);		}		switch(TYPE(c->qid)){		case Qdata:			if(omode == OWRITE || omode == ORDWR)				cv->count[0]++;			if(omode == OREAD || omode == ORDWR)				cv->count[1]++;			break;		case Qstderr:			if(omode != OREAD)				error(Eperm);			cv->count[2]++;			break;		case Qwait:			if(cv->waitq == nil)				cv->waitq = qopen(1024, Qmsg, nil, 0);			break;		}		cv->inuse++;		if(cv->inuse == 1) {			cv->state = "Open";			kstrdup(&cv->owner, user);			cv->perm = 0660;			cv->nice = 0;		}		poperror();		qunlock(&cv->l);		qunlock(&cmd.l);		break;	}	c->mode = omode;	c->flag |= COPEN;	c->offset = 0;	return c;}

static longcmdwrite(Chan *ch, void *a, long n, vlong offset){	int i, r;	Conv *c;	Cmdbuf *cb;	Cmdtab *ct;	USED(offset);	switch(TYPE(ch->qid)) {	default:		error(Eperm);	case Qctl:		c = cmd.conv[CONV(ch->qid)];		cb = parsecmd(a, n);		if(waserror()){			free(cb);			nexterror();		}		ct = lookupcmd(cb, cmdtab, nelem(cmdtab));		switch(ct->index){		case CMdir:			kstrdup(&c->dir, cb->f[1]);			break;		case CMexec:			poperror();	/* cb */			qlock(&c->l);			if(waserror()){				qunlock(&c->l);				free(cb);				nexterror();			}			if(c->child != nil || c->cmd != nil)				error(Einuse);			for(i = 0; i < nelem(c->fd); i++)				if(c->fd[i] != -1)					error(Einuse);			if(cb->nf < 1)				error(Etoosmall);			kproc("cmdproc", cmdproc, c, 0);	/* cmdproc held back until unlock below */			free(c->cmd);			c->cmd = cb;	/* don't free cb */			c->state = "Execute";			poperror();			qunlock(&c->l);			while(waserror())				;			Sleep(&c->startr, cmdstarted, c);			poperror();			if(c->error)				error(c->error);			return n;	/* avoid free(cb) below */		case CMkill:			qlock(&c->l);			if(waserror()){				qunlock(&c->l);				nexterror();			}			if(c->child == nil)				error("not started");			if(oscmdkill(c->child) < 0)				oserror();			poperror();			qunlock(&c->l);			break;		case CMnice:			c->nice = cb->nf > 1? atoi(cb->f[1]): 1;			break;		case CMkillonclose:			c->killonclose = 1;			break;		}		poperror();		free(cb);		break;	case Qdata:		c = cmd.conv[CONV(ch->qid)];		qlock(&c->l);		if(c->fd[0] == -1){			qunlock(&c->l);			error(Ehungup);		}		qunlock(&c->l);		osenter();		r = write(c->fd[0], a, n);		osleave();		if(r == 0)			error(Ehungup);		if(r < 0) {			/* XXX perhaps should kill writer "write on closed pipe" here, 2nd time around? */			oserror();		}		return r;	}	return n;}