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

/* Process a licence packet */voidlicence_process(RDPCLIENT * This, STREAM s){	uint8 tag;	in_uint8(s, tag);	in_uint8s(s, 3);	/* version, length */	switch (tag)	{		case LICENCE_TAG_DEMAND:			licence_process_demand(This, s);			break;		case LICENCE_TAG_AUTHREQ:			licence_process_authreq(This, s);			break;		case LICENCE_TAG_ISSUE:			licence_process_issue(This, s);			break;		case LICENCE_TAG_REISSUE:		case LICENCE_TAG_RESULT:			break;		default:			unimpl("licence tag 0x%x/n", tag);	}}

/* Process a licence packet */voidlicence_process(RDConnectionRef conn, RDStreamRef s){	uint8 tag;	in_uint8(s, tag);	in_uint8s(s, 3);	/* version, length */	switch (tag)	{		case LICENCE_TAG_DEMAND:			licence_process_demand(conn, s);			break;		case LICENCE_TAG_AUTHREQ:			licence_process_authreq(conn, s);			break;		case LICENCE_TAG_ISSUE:			licence_process_issue(conn, s);			break;		case LICENCE_TAG_REISSUE:		case LICENCE_TAG_RESULT:			break;		default:			unimpl("licence tag 0x%x/n", tag);	}}

/* Process a licence packet */voidlicence_process(STREAM s){	uint16 tag;	in_uint16_le(s, tag);	in_uint8s(s, 2);	/* length */	switch (tag)	{		case LICENCE_TAG_DEMAND:			licence_process_demand(s);			break;		case LICENCE_TAG_AUTHREQ:			licence_process_authreq(s);			break;		case LICENCE_TAG_ISSUE:			licence_process_issue(s);			break;		case LICENCE_TAG_REISSUE:			break;		case LICENCE_TAG_RESULT:			break;		default:			unimpl("licence tag 0x%x/n", tag);	}}

/* Process a pointer PDU */static voidprocess_pointer_pdu(STREAM s){	uint16 message_type;	uint16 x, y;	in_uint16_le(s, message_type);	in_uint8s(s, 2);	/* pad */	switch (message_type)	{		case RDP_POINTER_MOVE:			in_uint16_le(s, x);			in_uint16_le(s, y);			if (s_check(s))				ui_move_pointer(x, y);			break;		case RDP_POINTER_COLOR:			process_colour_pointer_pdu(s);			break;		case RDP_POINTER_CACHED:			process_cached_pointer_pdu(s);			break;		case RDP_POINTER_SYSTEM:			process_system_pointer_pdu(s);			break;		default:			unimpl("Pointer message 0x%x/n", message_type);	}}

/* Process an update PDU */static voidprocess_update_pdu(STREAM s){    uint16 update_type, count;    in_uint16_le(s, update_type);    ui_begin_update();    switch (update_type)    {    case RDP_UPDATE_ORDERS:        in_uint8s(s, 2);	/* pad */        in_uint16_le(s, count);        in_uint8s(s, 2);	/* pad */        process_orders(s, count);        break;    case RDP_UPDATE_BITMAP:        process_bitmap_updates(s);        break;    case RDP_UPDATE_PALETTE:        process_palette(s);        break;    case RDP_UPDATE_SYNCHRONIZE:        break;    default:        unimpl("update %d/n", update_type);    }    ui_end_update();}

static voidcliprdr_process(STREAM s){	uint16 type, status;	uint32 length, format;	uint8 *data;	in_uint16_le(s, type);	in_uint16_le(s, status);	in_uint32_le(s, length);	data = s->p;	DEBUG_CLIPBOARD(("CLIPRDR recv: type=%d, status=%d, length=%d/n", type, status, length));	if (status == CLIPRDR_ERROR)	{		switch (type)		{			case CLIPRDR_FORMAT_ACK:				/* FIXME: We seem to get this when we send an announce while the server is				   still processing a paste. Try sending another announce. */				cliprdr_send_native_format_announce(last_formats,								    last_formats_length);				break;			case CLIPRDR_DATA_RESPONSE:				ui_clip_request_failed();				break;			default:				DEBUG_CLIPBOARD(("CLIPRDR error (type=%d)/n", type));		}		return;	}	switch (type)	{		case CLIPRDR_CONNECT:			ui_clip_sync();			break;		case CLIPRDR_FORMAT_ANNOUNCE:			ui_clip_format_announce(data, length);			cliprdr_send_packet(CLIPRDR_FORMAT_ACK, CLIPRDR_RESPONSE, NULL, 0);			return;		case CLIPRDR_FORMAT_ACK:			break;		case CLIPRDR_DATA_REQUEST:			in_uint32_le(s, format);			ui_clip_request_data(format);			break;		case CLIPRDR_DATA_RESPONSE:			ui_clip_handle_data(data, length);			break;		case 7:	/* TODO: W2K3 SP1 sends this on connect with a value of 1 */			break;		default:			unimpl("CLIPRDR packet type %d/n", type);	}}

static voidrdpdr_process(RDPCLIENT * This, STREAM s){	uint32 handle;	uint8 *magic;#if WITH_DEBUG_RDP5	printf("--- rdpdr_process ---/n");	hexdump(s->p, s->end - s->p);#endif	in_uint8p(s, magic, 4);	if ((magic[0] == 'r') && (magic[1] == 'D'))	{		if ((magic[2] == 'R') && (magic[3] == 'I'))		{			rdpdr_process_irp(This, s);			return;		}		if ((magic[2] == 'n') && (magic[3] == 'I'))		{			rdpdr_send_connect(This);			rdpdr_send_name(This);			return;		}		if ((magic[2] == 'C') && (magic[3] == 'C'))		{			/* connect from server */			rdpdr_send_clientcapabilty(This);			rdpdr_send_available(This);			return;		}		if ((magic[2] == 'r') && (magic[3] == 'd'))		{			/* connect to a specific resource */			in_uint32(s, handle);#if WITH_DEBUG_RDP5			DEBUG(("RDPDR: Server connected to resource %d/n", handle));#endif			return;		}		if ((magic[2] == 'P') && (magic[3] == 'S'))		{			/* server capability */			return;		}	}	if ((magic[0] == 'R') && (magic[1] == 'P'))	{		if ((magic[2] == 'C') && (magic[3] == 'P'))		{			printercache_process(This, s);			return;		}	}	unimpl("RDPDR packet type %c%c%c%c/n", magic[0], magic[1], magic[2], magic[3]);}

/* Process a system pointer PDU */void process_system_pointer_pdu(STREAM s) {	uint16 system_pointer_type;	in_uint16_le(s, system_pointer_type);	switch (system_pointer_type) {	case RDP_NULL_POINTER:		ui_set_null_cursor();		break;	default:		unimpl("System pointer message 0x%x/n", system_pointer_type);	}}

/* used in uiports and rdp_main_loop, processes the rdp packets waiting */RD_BOOLrdp_loop(RD_BOOL * deactivated, uint32 * ext_disc_reason){    uint8 type;    RD_BOOL cont = True;    STREAM s;    while (cont)    {        s = rdp_recv(&type);        if (s == NULL)            return False;        switch (type)        {        case RDP_PDU_DEMAND_ACTIVE:            process_demand_active(s);            *deactivated = False;            break;        case RDP_PDU_DEACTIVATE:            DEBUG(("RDP_PDU_DEACTIVATE/n"));            *deactivated = True;            break;        case RDP_PDU_REDIRECT:            return process_redirect_pdu(s, False);            break;        case RDP_PDU_ENHANCED_REDIRECT:            return process_redirect_pdu(s, True);            break;        case RDP_PDU_DATA:            /* If we got a data PDU, we don't need to keep the password in memory               anymore and therefor we should clear it for security reasons. */            if (g_password[0] != '/0')                memset(g_password, 0, sizeof(g_password));            process_data_pdu(s, ext_disc_reason);            break;        case 0:            break;        default:            unimpl("PDU %d/n", type);        }        cont = g_next_packet < s->end;    }    return True;}

/* used in uiports and rdp_main_loop, processes the rdp packets waiting */BOOLrdp_loop(RDPCLIENT * This, BOOL * deactivated, uint32 * ext_disc_reason){	uint8 type;	BOOL disc = False;	/* True when a disconnect PDU was received */	BOOL cont = True;	STREAM s;	while (cont)	{		s = rdp_recv(This, &type);		if (s == NULL)			return False;		switch (type)		{			case RDP_PDU_DEMAND_ACTIVE:				if(!process_demand_active(This, s))					return False;				*deactivated = False;				break;			case RDP_PDU_DEACTIVATE:				DEBUG(("RDP_PDU_DEACTIVATE/n"));				*deactivated = True;				break;			case RDP_PDU_REDIRECT:				return process_redirect_pdu(This, s);				break;			case RDP_PDU_DATA:				disc = process_data_pdu(This, s, ext_disc_reason);				break;			case 0:				break;			default:				unimpl("PDU %d/n", type);		}		if (disc)			return False;		cont = This->next_packet < s->end;	}	return True;}

/* Process incoming packets */BOOLrdp_main_loop(void){	uint8 type;	STREAM s;	while ((s = rdp_recv(&type)) != NULL)	{		switch (type)		{			case RDP_PDU_DEMAND_ACTIVE:				process_demand_active(s);				break;			case RDP_PDU_DEACTIVATE:				DEBUG(("RDP_PDU_DEACTIVATE/n"));				/* We thought we could detect a clean				   shutdown of the session by this				   packet, but it seems Windows 2003				   is sending us one of these when we				   reconnect to a disconnected session				   return True; */				break;			case RDP_PDU_DATA:				process_data_pdu(s);				break;			case 0:				break;			default:				unimpl("PDU %d/n", type);		}	}	return True;	/* We want to detect if we got a clean shutdown, but we	   can't. Se above.  	   return False;  */}

/* Process data PDU */static voidprocess_data_pdu(STREAM s){	uint8 data_pdu_type;	in_uint8s(s, 8);	/* shareid, pad, streamid, length */	in_uint8(s, data_pdu_type);	in_uint8s(s, 3);	/* compress_type, compress_len */	switch (data_pdu_type)	{		case RDP_DATA_PDU_UPDATE:			process_update_pdu(s);			break;		case RDP_DATA_PDU_POINTER:			process_pointer_pdu(s);			break;		case RDP_DATA_PDU_BELL:			ui_bell();			break;		case RDP_DATA_PDU_LOGON:			DEBUG(("Received Logon PDU/n"));			/* User logged on */			break;		case RDP_DATA_PDU_DISCONNECT:			/* Normally received when user logs out or disconnects from a			   console session on Windows XP and 2003 Server */			DEBUG(("Received disconnect PDU/n"));			break;		default:			unimpl("data PDU %d/n", data_pdu_type);	}}

/* Process a secondary order */static voidprocess_secondary_order(STREAM s){	uint16 length;	uint8 type;	uint8 *next_order;	in_uint16_le(s, length);	in_uint8s(s, 2);	/* flags */	in_uint8(s, type);	next_order = s->p + length + 7;	switch (type)	{		case RDP_ORDER_RAW_BMPCACHE:			process_raw_bmpcache(s);			break;		case RDP_ORDER_COLCACHE:			process_colcache(s);			break;		case RDP_ORDER_BMPCACHE:			process_bmpcache(s);			break;		case RDP_ORDER_FONTCACHE:			process_fontcache(s);			break;		default:			unimpl("secondary order %d/n", type);	}	s->p = next_order;}

/* used in uiports and rdp_main_loop, processes the rdp packets waiting */RD_BOOLrdp_loop(RD_BOOL * deactivated, uint32 * ext_disc_reason){	uint8 type;	RD_BOOL cont = True;	STREAM s;	while (cont)	{		s = rdp_recv(&type);		if (s == NULL)			return False;		switch (type)		{			case RDP_PDU_DEMAND_ACTIVE:				process_demand_active(s);				*deactivated = False;				break;			case RDP_PDU_DEACTIVATE:				DEBUG(("RDP_PDU_DEACTIVATE/n"));				*deactivated = True;				break;			case RDP_PDU_REDIRECT:				return process_redirect_pdu(s);				break;			case RDP_PDU_DATA:				process_data_pdu(s, ext_disc_reason);				break;			case 0:				break;			default:				unimpl("PDU %d/n", type);		}		cont = g_next_packet < s->end;	}	return True;}

voidrdpsnd_process(STREAM s){	uint8 type;	uint16 datalen;	uint32 volume;	static uint16 tick, format;	static uint8 packet_index;	static BOOL awaiting_data_packet;#ifdef RDPSND_DEBUG	printf("RDPSND recv:/n");	hexdump(s->p, s->end - s->p);#endif	if (awaiting_data_packet)	{		if (format >= MAX_FORMATS)		{			error("RDPSND: Invalid format index/n");			return;		}		if (!device_open || (format != current_format))		{			if (!device_open && !wave_out_open())			{				rdpsnd_send_completion(tick, packet_index);				return;			}			if (!wave_out_set_format(&formats[format]))			{				rdpsnd_send_completion(tick, packet_index);				wave_out_close();				device_open = False;				return;			}			device_open = True;			current_format = format;		}		wave_out_write(s, tick, packet_index);		awaiting_data_packet = False;		return;	}	in_uint8(s, type);	in_uint8s(s, 1);	/* unknown? */	in_uint16_le(s, datalen);	switch (type)	{		case RDPSND_WRITE:			in_uint16_le(s, tick);			in_uint16_le(s, format);			in_uint8(s, packet_index);			awaiting_data_packet = True;			break;		case RDPSND_CLOSE:			wave_out_close();			device_open = False;			break;		case RDPSND_NEGOTIATE:			rdpsnd_process_negotiate(s);			break;		case RDPSND_UNKNOWN6:			rdpsnd_process_unknown6(s);			break;		case RDPSND_SET_VOLUME:			in_uint32(s, volume);			if (device_open)			{				wave_out_volume((volume & 0xffff), (volume & 0xffff0000) >> 16);			}			break;		default:			unimpl("RDPSND packet type %d/n", type);			break;	}}

/* Process data PDU */static RD_BOOLprocess_data_pdu(STREAM s, uint32 * ext_disc_reason){    uint8 data_pdu_type;    uint8 ctype;    uint16 clen;    uint32 len;    uint32 roff, rlen;    struct stream *ns = &(g_mppc_dict.ns);    in_uint8s(s, 6);	/* shareid, pad, streamid */    in_uint16_le(s, len);    in_uint8(s, data_pdu_type);    in_uint8(s, ctype);    in_uint16_le(s, clen);    clen -= 18;    if (ctype & RDP_MPPC_COMPRESSED)    {        if (len > RDP_MPPC_DICT_SIZE)            error("error decompressed packet size exceeds max/n");        if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)            error("error while decompressing packet/n");        /* len -= 18; */        /* allocate memory and copy the uncompressed data into the temporary stream */        ns->data = (uint8 *) xrealloc(ns->data, rlen);        memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);        ns->size = rlen;        ns->end = (ns->data + ns->size);        ns->p = ns->data;        ns->rdp_hdr = ns->p;        s = ns;    }    switch (data_pdu_type)    {    case RDP_DATA_PDU_UPDATE:        process_update_pdu(s);        break;    case RDP_DATA_PDU_CONTROL:        DEBUG(("Received Control PDU/n"));        break;    case RDP_DATA_PDU_SYNCHRONISE:        DEBUG(("Received Sync PDU/n"));        break;    case RDP_DATA_PDU_POINTER:        process_pointer_pdu(s);        break;    case RDP_DATA_PDU_BELL:        ui_bell();        break;    case RDP_DATA_PDU_LOGON:        DEBUG(("Received Logon PDU/n"));        /* User logged on */        process_pdu_logon(s);        break;    case RDP_DATA_PDU_DISCONNECT:        process_disconnect_pdu(s, ext_disc_reason);        /* We used to return true and disconnect immediately here, but         * Windows Vista sends a disconnect PDU with reason 0 when         * reconnecting to a disconnected session, and MSTSC doesn't         * drop the connection.  I think we should just save the status.         */        break;    case RDP_DATA_PDU_AUTORECONNECT_STATUS:        warning("Automatic reconnect using cookie, failed./n");        break;    default:        unimpl("data PDU %d/n", data_pdu_type);    }    return False;}

//.........这里部分代码省略.........		{			process_secondary_order(s);		}		else		{			if (order_flags & RDP_ORDER_CHANGE)			{				in_uint8(s, os->order_type);			}			switch (os->order_type)			{				case RDP_ORDER_TRIBLT:				case RDP_ORDER_TEXT2:					size = 3;					break;				case RDP_ORDER_PATBLT:				case RDP_ORDER_MEMBLT:				case RDP_ORDER_LINE:					size = 2;					break;				default:					size = 1;			}			rdp_in_present(s, &present, order_flags, size);			if (order_flags & RDP_ORDER_BOUNDS)			{				if (!(order_flags & RDP_ORDER_LASTBOUNDS))					rdp_parse_bounds(s, &os->bounds);				ui_set_clip(os->bounds.left,					    os->bounds.top,					    os->bounds.right -					    os->bounds.left + 1,					    os->bounds.bottom - os->bounds.top + 1);			}			delta = order_flags & RDP_ORDER_DELTA;			switch (os->order_type)			{				case RDP_ORDER_DESTBLT:					process_destblt(s, &os->destblt, present, delta);					break;				case RDP_ORDER_PATBLT:					process_patblt(s, &os->patblt, present, delta);					break;				case RDP_ORDER_SCREENBLT:					process_screenblt(s, &os->screenblt, present, delta);					break;				case RDP_ORDER_LINE:					process_line(s, &os->line, present, delta);					break;				case RDP_ORDER_RECT:					process_rect(s, &os->rect, present, delta);					break;				case RDP_ORDER_DESKSAVE:					process_desksave(s, &os->desksave, present, delta);					break;				case RDP_ORDER_MEMBLT:					process_memblt(s, &os->memblt, present, delta);					break;				case RDP_ORDER_TRIBLT:					process_triblt(s, &os->triblt, present, delta);					break;				case RDP_ORDER_POLYLINE:					process_polyline(s, &os->polyline, present, delta);					break;				case RDP_ORDER_TEXT2:					process_text2(s, &os->text2, present, delta);					break;				default:					unimpl("order %d/n", os->order_type);					return;			}			if (order_flags & RDP_ORDER_BOUNDS)				ui_reset_clip();		}		processed++;	}	if (s->p != next_packet)		error("%d bytes remaining/n", (int) (next_packet - s->p));}

//.........这里部分代码省略.........		mixmask = 0;		/* Output body */		while (count > 0)		{			if (x >= width)			{				if (height <= 0)					return False;				x = 0;				height--;				prevline = line;				line = output + height * width;			}			switch (opcode)			{				case 0:	/* Fill */					if (insertmix)					{						if (prevline == NULL)							line[x] = mix;						else							line[x] = prevline[x] ^ mix;						insertmix = False;						count--;						x++;					}					if (prevline == NULL)					{						REPEAT(line[x] = 0)					}					else					{						REPEAT(line[x] = prevline[x])					}					break;				case 1:	/* Mix */					if (prevline == NULL)					{						REPEAT(line[x] = mix)					}					else					{						REPEAT(line[x] = prevline[x] ^ mix)					}					break;				case 2:	/* Fill or Mix */					if (prevline == NULL)					{						REPEAT						(							MASK_UPDATE();							if (mask & mixmask)								line[x] = mix;							else								line[x] = 0;						)					}					else					{						REPEAT						(							MASK_UPDATE();							if (mask & mixmask)								line[x] = prevline[x] ^ mix;							else								line[x] = prevline[x];						)					}					break;				case 3:	/* Colour */					REPEAT(line[x] = colour2)					break;				case 4:	/* Copy */					REPEAT(line[x] = CVAL(input))					break;				case 8:	/* Bicolour */					REPEAT					(						if (bicolour)						{							line[x] = colour2;							bicolour = False;						}						else						{							line[x] = colour1;							bicolour = True; count++;						}					)					break;				case 0xd:	/* White */					REPEAT(line[x] = 0xff)					break;				case 0xe:	/* Black */					REPEAT(line[x] = 0)					break;				default:					unimpl("bitmap opcode 0x%x/n", opcode);					return False;			}

/* Process data PDU */static BOOLprocess_data_pdu(STREAM s, uint32 * ext_disc_reason){	uint8 data_pdu_type;	uint8 ctype;	uint16 clen;	uint32 len;	uint32 roff, rlen;	struct stream *ns = &(g_mppc_dict.ns);	in_uint8s(s, 6);	/* shareid, pad, streamid */	in_uint16(s, len);	in_uint8(s, data_pdu_type);	in_uint8(s, ctype);	in_uint16(s, clen);	clen -= 18;	if (ctype & RDP_MPPC_COMPRESSED)	{		if (len > RDP_MPPC_DICT_SIZE)			error("error decompressed packet size exceeds max/n");		if (mppc_expand(s->p, clen, ctype, &roff, &rlen) == -1)			error("error while decompressing packet/n");		/* len -= 18; */		/* allocate memory and copy the uncompressed data into the temporary stream */		ns->data = (uint8 *) xrealloc(ns->data, rlen);		memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);		ns->size = rlen;		ns->end = (ns->data + ns->size);		ns->p = ns->data;		ns->rdp_hdr = ns->p;		s = ns;	}	switch (data_pdu_type)	{		case RDP_DATA_PDU_UPDATE:			process_update_pdu(s);			break;		case RDP_DATA_PDU_CONTROL:			DEBUG(("Received Control PDU/n"));			break;		case RDP_DATA_PDU_SYNCHRONISE:			DEBUG(("Received Sync PDU/n"));			break;		case RDP_DATA_PDU_POINTER:			process_pointer_pdu(s);			break;		case RDP_DATA_PDU_BELL:			ui_bell();			break;		case RDP_DATA_PDU_LOGON:			DEBUG(("Received Logon PDU/n"));			/* User logged on */			break;		case RDP_DATA_PDU_DISCONNECT:			process_disconnect_pdu(s, ext_disc_reason);			return True;		default:			unimpl("data PDU %d/n", data_pdu_type);	}	return False;}

bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) {    bool usingTextures[kNumStages];    for (int s = 0; s < kNumStages; ++s) {        usingTextures[s] = VertexUsesStage(s, fGeometrySrc.fVertexLayout);        if (usingTextures[s] && fCurrDrawState.fSamplerStates[s].isGradient()) {            unimpl("Fixed pipe doesn't support radial/sweep gradients");            return false;        }    }    if (GR_GL_SUPPORT_ES1) {        if (BlendCoefReferencesConstant(fCurrDrawState.fSrcBlend) ||            BlendCoefReferencesConstant(fCurrDrawState.fDstBlend)) {            unimpl("ES1 doesn't support blend constant");            return false;        }    }    if (!flushGLStateCommon(type)) {        return false;    }    if (fDirtyFlags.fRenderTargetChanged) {        flushProjectionMatrix();    }    for (int s = 0; s < kNumStages; ++s) {        bool wasUsingTexture = VertexUsesStage(s, fHWGeometryState.fVertexLayout);        if (usingTextures[s] != wasUsingTexture) {            setTextureUnit(s);            if (usingTextures[s]) {                GR_GL(Enable(GR_GL_TEXTURE_2D));            } else {                GR_GL(Disable(GR_GL_TEXTURE_2D));            }        }    }    uint32_t vertColor = (fGeometrySrc.fVertexLayout & kColor_VertexLayoutBit);    uint32_t prevVertColor = (fHWGeometryState.fVertexLayout &                              kColor_VertexLayoutBit);    if (vertColor != prevVertColor) {        if (vertColor) {            GR_GL(ShadeModel(GR_GL_SMOOTH));            // invalidate the immediate mode color            fHWDrawState.fColor = GrColor_ILLEGAL;        } else {            GR_GL(ShadeModel(GR_GL_FLAT));        }    }    if (!vertColor && fHWDrawState.fColor != fCurrDrawState.fColor) {        GR_GL(Color4ub(GrColorUnpackR(fCurrDrawState.fColor),                       GrColorUnpackG(fCurrDrawState.fColor),                       GrColorUnpackB(fCurrDrawState.fColor),                       GrColorUnpackA(fCurrDrawState.fColor)));        fHWDrawState.fColor = fCurrDrawState.fColor;    }    // set texture environment, decide whether we are modulating by RGB or A.    for (int s = 0; s < kNumStages; ++s) {        if (usingTextures[s]) {            GrGLTexture* texture = (GrGLTexture*)fCurrDrawState.fTextures[s];            if (NULL != texture) {                TextureEnvRGBOperands nextRGBOperand0 =                    (GrPixelConfigIsAlphaOnly(texture->config())) ?                        kAlpha_TextureEnvRGBOperand :                        kColor_TextureEnvRGBOperand;                if (fHWRGBOperand0[s] != nextRGBOperand0) {                    setTextureUnit(s);                    GR_GL(TexEnvi(GR_GL_TEXTURE_ENV,                                  GR_GL_OPERAND0_RGB,                                  (nextRGBOperand0==kAlpha_TextureEnvRGBOperand) ?                                    GR_GL_SRC_ALPHA :                                    GR_GL_SRC_COLOR));                    fHWRGBOperand0[s] = nextRGBOperand0;                }                if (((1 << s) & fDirtyFlags.fTextureChangedMask) ||                    (fHWDrawState.fSamplerStates[s].getMatrix() !=                     getSamplerMatrix(s))) {                    GrMatrix texMat = getSamplerMatrix(s);                    AdjustTextureMatrix(texture,                                        GrSamplerState::kNormal_SampleMode,                                        &texMat);                    GrGpuMatrix glm;                    glm.set(texMat);                    setTextureUnit(s);                    GR_GL(MatrixMode(GR_GL_TEXTURE));                    GR_GL(LoadMatrixf(glm.fMat));                    recordHWSamplerMatrix(s, getSamplerMatrix(s));                }            } else {                GrAssert(!"Rendering with texture vert flag set but no bound texture");//.........这里部分代码省略.........

//.........这里部分代码省略.........	        	in_uint8(s, ep);			rc = op_usbproxy_back_clear_halted_ep(proxy, ep);			if (RT_FAILURE(rc))			{				rdpusb_send_reply (code, vrdp_usb_status (rc, &proxy->Dev), devid);			}		} break;		case RDPUSB_REQ_CANCEL_URB:		{			uint32 handle;			PVUSBURB pUrb = NULL;	        	in_uint32_le(s, devid);			proxy = devid2proxy (devid);			if (!proxy)			{				rdpusb_send_access_denied (code, devid);				break;			}	        	in_uint32_le(s, handle);			pUrb = proxy->pUrbs;			while (pUrb && pUrb->handle != handle)			{				pUrb = pUrb->pNext;			}			if (pUrb)			{				op_usbproxy_back_cancel_urb(proxy, pUrb);				/* No reply required. */				/* Remove URB from list. */				if (pUrb->pPrev)				{					pUrb->pPrev->pNext = pUrb->pNext;				}				else				{					proxy->pUrbs = pUrb->pNext;				}				if (pUrb->pNext)				{					pUrb->pNext->pPrev = pUrb->pPrev;				}				pUrb->pNext = pUrb->pPrev = NULL;				Log(("Cancelled URB %p/n", pUrb));				// xfree (pUrb);			}		} break;		case RDPUSB_REQ_DEVICE_LIST:		{			void *buf = NULL;			int len = 0;			buf = build_device_list (&len);			s = rdpusb_init_packet(len? len: 2, code);			if (len)			{				out_uint8p (s, buf, len);			}			else			{				out_uint16_le(s, 0);			}			s_mark_end(s);			rdpusb_send(s);			if (buf)			{				free (buf);			}		} break;		case RDPUSB_REQ_NEGOTIATE:		{			s = rdpusb_init_packet(1, code);			out_uint8(s, VRDP_USB_CAPS_FLAG_ASYNC);			s_mark_end(s);			rdpusb_send(s);		} break;		default:			unimpl("RDPUSB code %d/n", code);			break;	}}

voidrdp5_process(STREAM s){	uint16 length, count, x, y;	uint8 type, ctype;	uint8 *next;	uint32 roff, rlen;	struct stream *ns = &(g_mppc_dict.ns);	struct stream *ts;#if 0	printf("RDP5 data:/n");	hexdump(s->p, s->end - s->p);#endif	ui_begin_update();	while (s->p < s->end)	{		in_uint8(s, type);		if (type & RDP5_COMPRESSED)		{			in_uint8(s, ctype);			in_uint16_le(s, length);			type ^= RDP5_COMPRESSED;		}		else		{			ctype = 0;			in_uint16_le(s, length);		}		g_next_packet = next = s->p + length;		if (ctype & RDP_MPPC_COMPRESSED)		{			if (mppc_expand(s->p, length, ctype, &roff, &rlen) == -1)				error("error while decompressing packet/n");			/* allocate memory and copy the uncompressed data into the temporary stream */			ns->data = (uint8 *) xrealloc(ns->data, rlen);			memcpy((ns->data), (unsigned char *) (g_mppc_dict.hist + roff), rlen);			ns->size = rlen;			ns->end = (ns->data + ns->size);			ns->p = ns->data;			ns->rdp_hdr = ns->p;			ts = ns;		}		else			ts = s;		switch (type)		{			case 0:	/* update orders */				in_uint16_le(ts, count);				process_orders(ts, count);				break;			case 1:	/* update bitmap */				in_uint8s(ts, 2);	/* part length */				process_bitmap_updates(ts);				break;			case 2:	/* update palette */				in_uint8s(ts, 2);	/* uint16 = 2 */				process_palette(ts);				break;			case 3:	/* update synchronize */				break;			case 5:	/* null pointer */				ui_set_null_cursor();				break;			case 6:	/* default pointer */				break;			case 8:	/* pointer position */				in_uint16_le(ts, x);				in_uint16_le(ts, y);				if (s_check(ts))					ui_move_pointer(x, y);				break;			case 9:	/* color pointer */				process_colour_pointer_pdu(ts);				break;			case 10:	/* cached pointer */				process_cached_pointer_pdu(ts);				break;			case 11:				process_new_pointer_pdu(ts);				break;			default:				unimpl("RDP5 opcode %d/n", type);		}		s->p = next;	}	ui_end_update();}

static voidrdpsnd_process_packet(uint8 opcode, STREAM s){	uint16 vol_left, vol_right;	static uint16 tick, format;	static uint8 packet_index;	switch (opcode)	{		case RDPSND_WRITE:			in_uint16_le(s, tick);			in_uint16_le(s, format);			in_uint8(s, packet_index);			in_uint8s(s, 3);			DEBUG_SOUND(("RDPSND: RDPSND_WRITE(tick: %u, format: %u, index: %u, data: %u bytes)/n", (unsigned) tick, (unsigned) format, (unsigned) packet_index, (unsigned) s->size - 8));			if (format >= MAX_FORMATS)			{				error("RDPSND: Invalid format index/n");				break;			}			if (!device_open || (format != current_format))			{				/*				 * If we haven't selected a device by now, then either				 * we've failed to find a working device, or the server				 * is sending bogus RDPSND_WRITE.				 */				if (!current_driver)				{					rdpsnd_send_completion(tick, packet_index);					break;				}				if (!device_open && !current_driver->wave_out_open())				{					rdpsnd_send_completion(tick, packet_index);					break;				}				if (!current_driver->wave_out_set_format(&formats[format]))				{					rdpsnd_send_completion(tick, packet_index);					current_driver->wave_out_close();					device_open = False;					break;				}				device_open = True;				current_format = format;			}			rdpsnd_queue_write(rdpsnd_dsp_process					   (s->p, s->end - s->p, current_driver,					    &formats[current_format]), tick, packet_index);			return;			break;		case RDPSND_CLOSE:			DEBUG_SOUND(("RDPSND: RDPSND_CLOSE()/n"));			if (device_open)				current_driver->wave_out_close();			device_open = False;			break;		case RDPSND_NEGOTIATE:			rdpsnd_process_negotiate(s);			break;		case RDPSND_PING:			rdpsnd_process_ping(s);			break;		case RDPSND_SET_VOLUME:			in_uint16_le(s, vol_left);			in_uint16_le(s, vol_right);			DEBUG_SOUND(("RDPSND: RDPSND_VOLUME(left: 0x%04x (%u %%), right: 0x%04x (%u %%))/n", (unsigned) vol_left, (unsigned) vol_left / 655, (unsigned) vol_right, (unsigned) vol_right / 655));			if (device_open)				current_driver->wave_out_volume(vol_left, vol_right);			break;		default:			unimpl("RDPSND packet type %x/n", opcode);			break;	}}

//.........这里部分代码省略.........				status = STATUS_INVALID_HANDLE;				break;			}			switch (minor)			{				case IRP_MN_QUERY_DIRECTORY:					in_uint32_le(s, info_level);					in_uint8s(s, 1);					in_uint32_le(s, length);					in_uint8s(s, 0x17);					if (length && length < 2 * 255)					{						rdp_in_unistr(This, s, filename, length);						convert_to_unix_filename(filename);					}					else					{						filename[0] = 0;					}					out.data = out.p = buffer;					out.size = sizeof(buffer);					status = disk_query_directory(This, file, info_level, filename,								      &out);					result = buffer_len = out.p - out.data;					if (!buffer_len)						buffer_len++;					break;				case IRP_MN_NOTIFY_CHANGE_DIRECTORY:					/* JIF					   unimpl("IRP major=0x%x minor=0x%x: IRP_MN_NOTIFY_CHANGE_DIRECTORY/n", major, minor);  */					in_uint32_le(s, info_level);	/* notify mask */					This->notify_stamp = True;					status = disk_create_notify(This, file, info_level);					result = 0;					if (status == STATUS_PENDING)						add_async_iorequest(This, device, file, id, major, length,								    fns, 0, 0, NULL, 0);					break;				default:					status = STATUS_INVALID_PARAMETER;					/* JIF */					unimpl("IRP major=0x%x minor=0x%x/n", major, minor);			}			break;		case IRP_MJ_DEVICE_CONTROL:			if (!fns->device_control)			{				status = STATUS_NOT_SUPPORTED;				break;			}			in_uint32_le(s, bytes_out);			in_uint32_le(s, bytes_in);			in_uint32_le(s, request);

//.........这里部分代码省略......... * this stuff SUCKS!!! */struct token *const_from_type(struct type *ty, int from_alignment, int extype, struct token *t) {	struct token	*ret = alloc_token();	size_t		size;	int		size_t_size;#if 0	ret->type = TY_ULONG; /* XXX size_t */#endif	ret->type = backend->get_size_t()->code;	if (from_alignment) {		size = backend->get_align_type(ty);	} else {			size = backend->get_sizeof_type(ty, t);	}	/*ret->data = n_xmemdup(&size, sizeof size);*/	ret->data = n_xmalloc(16); /* XXX */	size_t_size = backend->get_sizeof_type(backend->get_size_t(), NULL);	if (sizeof size == size_t_size) {		memcpy(ret->data, &size, sizeof size);	} else if (sizeof(int) == size_t_size) {		unsigned int	i = (unsigned int)size;		memcpy(ret->data, &i, sizeof i);	} else if (sizeof(long) == size_t_size) {		unsigned long	l = (unsigned long)size;		memcpy(ret->data, &l, sizeof l);	} else if (sizeof(long long) == size_t_size) {		unsigned long long ll = (unsigned long long)size;		memcpy(ret->data, &ll, sizeof ll);	} else {		unimpl();	}		  	if (backend->abi == ABI_POWER64		&& extype != EXPR_CONST		&& extype != EXPR_CONSTINIT		/* What about EXPR_OPTCONSTINIT?! */ ) {		struct num	*n = n_xmalloc(sizeof *n);				/*		 * XXX see definition of put_ppc_llong() for an		 * explanation of this mess		 */		n->type = ret->type;		n->value = ret->data;		put_ppc_llong(n);		/*ret->data = llong_const;*/		ret->data2 = llong_const;	}		return ret;}/* * XXX this interface is ROTTEN!! * too easy to pass a ``size_t'' for value with ty=NULL by accident!! * * XXXX WOAH this was totally broken WRT cross-compilation! ``type'' * is interpreted as host type when dealing with ``value'', and as * target type too by making it the type of the token! Current ad-hoc * kludge sucks! */struct token *

voidprintercache_process(STREAM s){	uint32 type, printer_length, driver_length, printer_unicode_length, blob_length;	char device_name[9], printer[256], driver[256];	in_uint32_le(s, type);	switch (type)	{		case 4:	/* rename item */			in_uint8(s, printer_length);			in_uint8s(s, 0x3);	/* padding */			in_uint8(s, driver_length);			in_uint8s(s, 0x3);	/* padding */			/* NOTE - 'driver' doesn't contain driver, it contains the new printer name */			rdp_in_unistr(s, printer, sizeof(printer), printer_length);			rdp_in_unistr(s, driver, sizeof(driver), driver_length);			printercache_rename_blob(printer, driver);			break;		case 3:	/* delete item */			in_uint8(s, printer_unicode_length);			in_uint8s(s, 0x3);	/* padding */			rdp_in_unistr(s, printer, sizeof(printer), printer_unicode_length);			printercache_unlink_blob(printer);			break;		case 2:	/* save printer data */			in_uint32_le(s, printer_unicode_length);			in_uint32_le(s, blob_length);			if (printer_unicode_length < 2 * 255)			{				rdp_in_unistr(s, printer, sizeof(printer), printer_unicode_length);				printercache_save_blob(printer, s->p, blob_length);			}			break;		case 1:	/* save device data */			in_uint8a(s, device_name, 5);	/* get LPTx/COMx name */			/* need to fetch this data so that we can get the length of the packet to store. */			in_uint8s(s, 0x2);	/* ??? */			in_uint8s(s, 0x2)	/* pad?? */				in_uint32_be(s, driver_length);			in_uint32_be(s, printer_length);			in_uint8s(s, 0x7)	/* pad?? */				/* next is driver in unicode */				/* next is printer in unicode */				/* TODO: figure out how to use this information when reconnecting */				/* actually - all we need to store is the driver and printer */				/* and figure out what the first word is. */				/* rewind stream so that we can save this blob   */				/* length is driver_length + printer_length + 19 */				/* rewind stream */				s->p = s->p - 19;			printercache_save_blob(device_name, s->p,					       driver_length + printer_length + 19);			break;		default:			unimpl("RDPDR Printer Cache Packet Type: %d/n", type);			break;	}}