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

int philos_fsm_save_info(void* entity, void* msg){    if (!entity || !msg) return FSM_FAIL;    if (!philos_dict){        philos_dict = fdict_create(MAX_PHILOS_NUM, philos_hash_match, philos_hash_calc);        if (!philos_dict){            LOG_NE("create fdict failed");            return FSM_FAIL;        }    }        philosopher* phi = (philosopher*) malloc(sizeof (philosopher));    if (!phi) return FSM_FAIL;    memcpy (phi, GET_DATA(msg), sizeof (philosopher));    if (FDICT_SUCCESS != fdict_insert(philos_dict, &phi->whoami, phi)){        LOG_NE("insert philosopher to dict failed");        free(phi);        return FSM_FAIL;    }    CVTTO_PHILOS(phifsm, entity);    phifsm->philos = phi;    philos_count += 1;    // 用于显示    show_addphilos(phi);    return  philos_think(entity);}

void remmina_rdp_cliprdr_request_data(GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, RemminaProtocolWidget* gp){	GdkAtom target;	gpointer data;	RDP_CB_DATA_REQUEST_EVENT* event;	rfContext* rfi = GET_DATA(gp);	target = gtk_selection_data_get_target(selection_data);	rfi->format = remmina_rdp_cliprdr_get_format_from_gdkatom(target);	rfi->clipboard_queue = g_async_queue_new();	/* Request Clipboard data of the server */	event = (RDP_CB_DATA_REQUEST_EVENT*)		freerdp_event_new(CliprdrChannel_Class, CliprdrChannel_DataRequest, NULL, NULL);	event->format = rfi->format;	freerdp_channels_send_event(rfi->instance->context->channels, (wMessage*) event);	data = g_async_queue_timeout_pop(rfi->clipboard_queue, 1000000);	if (data != NULL)	{		if (info == CB_FORMAT_PNG || info == CB_FORMAT_DIB || info == CB_FORMAT_JPEG)		{			gtk_selection_data_set_pixbuf(selection_data, data);			g_object_unref(data);		}		else		{			gtk_selection_data_set_text(selection_data, data, -1);		}	}}

// process incoming squadmate messaging info void multi_msg_process_squadmsg_packet(unsigned char *data, header *hinfo){		int command;	ushort net_sig;	short source_id;	int source_index;	char s_val;	int offset = HEADER_LENGTH;	// get all packet data	GET_INT(command);	GET_SHORT(source_id);	GET_USHORT(net_sig);	GET_DATA(s_val);	PACKET_SET_SIZE();	// determine who the order is from	source_index = find_player_id(source_id);	if(source_index == -1){		nprintf(("Network","Received squadmsg order packet from unknown player!!/n"));		return;	}	// display the squadmessage somehow	multi_msg_show_squadmsg(&Net_players[source_index],command,net_sig,(int)s_val);}

// FLTK::Widget#activate// Activate the widget.mrb_value mrb_fltk_widget_activate_instance_method( mrb_state *mrb, mrb_value self ) {  GET_DATA( fl_widget, Fl_Widget, self );  fl_widget->activate();  return self;}

static void remmina_rdp_call_feature(RemminaProtocolWidget* gp, const RemminaProtocolFeature* feature){    RemminaFile* remminafile;    rfContext* rfi;    rfi = GET_DATA(gp);    remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);    switch (feature->id)    {    case REMMINA_RDP_FEATURE_UNFOCUS:        remmina_rdp_event_unfocus(gp);        break;    case REMMINA_RDP_FEATURE_SCALE:        rfi->scale = remmina_plugin_service->file_get_int(remminafile, "scale", FALSE);        remmina_rdp_event_update_scale(gp);        break;    case REMMINA_RDP_FEATURE_TOOL_REFRESH:        gtk_widget_queue_draw_area(rfi->drawing_area, 0, 0,                                   remmina_plugin_service->protocol_plugin_get_width(gp),                                   remmina_plugin_service->protocol_plugin_get_height(gp));        break;    default:        break;    }}

int main(){    /*--- message ---*/  printf("*********************************/n");  printf("*** Use SGESV to solve Ax = B ***/n");  printf("*********************************/n");  printf("/n");          /*--- open files that store data ---*/  OPEN_FILE();    /*--- read data ---*/  GET_DATA();      /*--- call lapack subroutine SGESV, note: ---*/    /*--- (1) all the arguments must be pointers ---*/   /*--- (2) add an underscore to the routine name ---*/  /*--- (3) matrices must be transformed into their Fortran vector formats ---*/   SGESV_(&n, &nrhs, AT, &lda, IPIV, BT, &ldb, &info);     /*--- print the solution ---*/  PRINT_SOLUTION();      /*--- close files ---*/  fclose(fptA);  fclose(fptB);  return 0;}

// FLTK::Widget#redrawmrb_value mrb_fltk_widget_redraw_instance_method( mrb_state *mrb, mrb_value self ) {  GET_DATA( fl_widget, Fl_Widget, self );  fl_widget->redraw();  return self;}

void remmina_rdp_event_update_scale(RemminaProtocolWidget* gp){	gint width, height;	gint hscale, vscale;	RemminaFile* remminafile;	rfContext* rfi;	rfi = GET_DATA(gp);	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);	width = remmina_plugin_service->protocol_plugin_get_width(gp);	height = remmina_plugin_service->protocol_plugin_get_height(gp);	hscale = remmina_plugin_service->file_get_int(remminafile, "hscale", 0);	vscale = remmina_plugin_service->file_get_int(remminafile, "vscale", 0);	if (rfi->scale)	{		gtk_widget_set_size_request(rfi->drawing_area,			(hscale > 0 ? width * hscale / 100 : -1),			(vscale > 0 ? height * vscale / 100 : -1));	}	else	{		gtk_widget_set_size_request(rfi->drawing_area, width, height);	}	remmina_plugin_service->protocol_plugin_emit_signal(gp, "update-align");}

Object obj_get(Object self, Object k) {    Object v;    switch (TM_TYPE(self)) {    case TYPE_STR: {        DictNode* node;        if (TM_TYPE(k) == TYPE_NUM) {            double d = GET_NUM(k);            int n = d;            if (n < 0) {                n += GET_STR_LEN(self);            }            if (n >= GET_STR_LEN(self) || n < 0)                tm_raise("String_get: index overflow ,len=%d,index=%d, str=%o",                        GET_STR_LEN(self), n, self);            return string_chr(0xff & GET_STR(self)[n]);        } else if ((node = dict_get_node(GET_DICT(tm->str_proto), k)) != NULL) {            return method_new(node->val, self);        }        break;    }    case TYPE_LIST:{        DictNode* node;        if (TM_TYPE(k) == TYPE_NUM) {            return list_get(GET_LIST(self), GET_NUM(k));        } else if ((node = dict_get_node(GET_DICT(tm->list_proto), k))!=NULL) {            return method_new(node->val, self);        }        break;    }    case TYPE_DICT:{        DictNode* node;        node = dict_get_node(GET_DICT(self), k);        if (node != NULL) {            return node->val;        } else if ((node = dict_get_node(GET_DICT(tm->dict_proto), k))!=NULL) {            return method_new(node->val, self);        }        break;    }    case TYPE_FUNCTION:        return get_func_attr(GET_FUNCTION(self), k);    case TYPE_DATA:        return GET_DATA(self)->get(GET_DATA(self), k);    }    tm_raise("keyError %o", k);    return NONE_OBJECT;}

static void remmina_rdp_event_update_cursor(RemminaProtocolWidget* gp, RemminaPluginRdpUiObject* ui){	rfContext* rfi;	rfi = GET_DATA(gp);	gdk_window_set_cursor(gtk_widget_get_window(rfi->drawing_area), ui->cursor.cursor);}

VALUE rb_outcome(VALUE rb_obj){	randvar_t *rv = NULL;		GET_DATA(rb_obj, rv);	return (*(outcome_func[RANDVAR_TYPE(rv)]))(rv);}

static gboolean remmina_rdp_close_connection(RemminaProtocolWidget* gp){	rfContext* rfi;	freerdp* instance;	rfi = GET_DATA(gp);	instance = rfi->instance;	if (rfi->thread)	{		pthread_cancel(rfi->thread);		if (rfi->thread)			pthread_join(rfi->thread, NULL);	}	pthread_mutex_destroy(&rfi->mutex);	g_mutex_free(rfi->gmutex);	g_cond_free(rfi->gcond);	remmina_rdp_event_uninit(gp);	remmina_plugin_service->protocol_plugin_emit_signal(gp, "disconnect");	if (instance)	{		if ( rfi->connected ) {			if (instance->context->channels)				freerdp_channels_close(instance->context->channels, instance);			freerdp_disconnect(instance);			rfi->connected = False;		}	}	if (rfi->rfx_context)	{		rfx_context_free(rfi->rfx_context);		rfi->rfx_context = NULL;	}	if (instance)	{		/* Remove instance->context from gp object data to avoid double free */		g_object_steal_data(G_OBJECT(gp), "plugin-data");		if (instance->context->channels) {			freerdp_channels_free(instance->context->channels);			instance->context->channels = NULL;		}		freerdp_context_free(instance); /* context is rfContext* rfi */		freerdp_free(instance);		rfi->instance = NULL;	}	return FALSE;}

		void testSendingResponse()		{			JsonQt::JsonRpc t;			QSignalSpy spy(&t, SIGNAL(sendJson(const QString&)));			t.sendResponse(QVariant(123), "foo");			GET_DATA();			QCOMPARE(data.value("result").toString(), QString("foo"));			QCOMPARE(data.value("id").toInt(), 123);		}

/* * Open the named file for read, create the cluster chain, return the * directory structure or NULL on error. */int makeit(char *dosname,	    char *longname,	    void *arg0,	    direntry_t *targetEntry){	Stream_t *Target;	CreateArg_t *arg = (CreateArg_t *) arg0;	int fat;	direntry_t subEntry;		/* will it fit? At least one cluster must be free */	if (!getfreeMinClusters(targetEntry->Dir, 1))		return -1;		mk_entry(dosname, ATTR_DIR, 1, 0, arg->mtime, &targetEntry->dir);	Target = OpenFileByDirentry(targetEntry);	if(!Target){		fprintf(stderr,"Could not open Target/n");		return -1;	}	/* this allocates the first cluster for our directory */	initializeDirentry(&subEntry, Target);	subEntry.entry = 1;	GET_DATA(targetEntry->Dir, 0, 0, 0, &fat);	if (fat == fat32RootCluster(targetEntry->Dir)) {	    fat = 0;	}	mk_entry("..         ", ATTR_DIR, fat, 0, arg->mtime, &subEntry.dir);	dir_write(&subEntry);	FLUSH((Stream_t *) Target);	subEntry.entry = 0;	GET_DATA(Target, 0, 0, 0, &fat);	mk_entry(".          ", ATTR_DIR, fat, 0, arg->mtime, &subEntry.dir);	dir_write(&subEntry);	mk_entry(dosname, ATTR_DIR | arg->attr, fat, 0, arg->mtime, 		 &targetEntry->dir);	arg->NewDir = Target;	return 0;}

intsftp_get_uint32(struct sftp_input *i, uint32_t *value){  uint8_t buf[4];  if (!GET_DATA(i, buf))    return 0;  *value = READ_UINT32(buf);  return 1;}

// FLTK::Widget#box=(value)// Sets the box type.// TODO: Tried to use IMPLEMENT_FIXNUM_ATTRIBUTE_ACCESSOR but got this://       candidate function not viable: no known conversion from 'int' to 'Fl_Boxtype' for 1st argumentmrb_value mrb_fltk_widget_box_setter_instance_method( mrb_state *mrb, mrb_value self ) {  GET_DATA( fl_widget, Fl_Widget, self );  mrb_value value;  mrb_get_args( mrb, "i", &value );  fl_widget->box( (Fl_Boxtype)mrb_fixnum( value ) );  return value;}

intsftp_get_uint64(struct sftp_input *i, off_t *value){  uint8_t buf[8];  if (!GET_DATA(i, buf))    return 0;  *value = READ_UINT64(buf);  return 1;}

// FLTK::Widget#x=(value)mrb_value mrb_fltk_widget_x_setter_instance_method( mrb_state *mrb, mrb_value self ) {  GET_DATA( fl_widget, Fl_Widget, self );  mrb_value x;  mrb_get_args( mrb, "i", &x );  fl_widget->position( mrb_fixnum( x ), fl_widget->y() );  return x;}

// FLTK::Widget#y=(value)mrb_value mrb_fltk_widget_y_setter_instance_method( mrb_state *mrb, mrb_value self ) {  GET_DATA( fl_widget, Fl_Widget, self );  mrb_value y;  mrb_get_args( mrb, "i", &y );  fl_widget->position( fl_widget->x(), mrb_fixnum( y ) );  return y;}

		void testSendingSimpleRequest()		{			JsonQt::JsonRpc t;			QSignalSpy spy(&t, SIGNAL(sendJson(const QString&)));			t.sendRequest(QVariant(123), "foo");			GET_DATA();			QCOMPARE(data.value("method").toString(), QString("foo"));			QCOMPARE(data.value("id").toInt(), 123);			QVERIFY(!data.contains("params"));		}

// FLTK::Widget#width=(value)mrb_value mrb_fltk_widget_width_setter_instance_method( mrb_state *mrb, mrb_value self ) {  GET_DATA( fl_widget, Fl_Widget, self );  mrb_value width;  mrb_get_args( mrb, "i", &width );  fl_widget->size( mrb_fixnum( width ), fl_widget->h() );  return width;}

// FLTK::Widget#height=(value)mrb_value mrb_fltk_widget_height_setter_instance_method( mrb_state *mrb, mrb_value self ) {  GET_DATA( fl_widget, Fl_Widget, self );  mrb_value height;  mrb_get_args( mrb, "i", &height );  fl_widget->size( fl_widget->w(), mrb_fixnum( height ) );  return height;}

		void testSendingSimpleNotification()		{			JsonQt::JsonRpc t;			QSignalSpy spy(&t, SIGNAL(sendJson(const QString&)));			t.sendNotification("foo");			GET_DATA();			QCOMPARE(data.value("method").toString(), QString("foo"));			QVERIFY(!data.contains("id"));			QVERIFY(!data.contains("params"));		}

// FLTK.focus=(widget)// Sets the current focused widget.mrb_value mrb_fltk_focus_setter_module_method( mrb_state *mrb, mrb_value self ) {  mrb_value mrb_widget;  mrb_get_args( mrb, "o", &mrb_widget );  // TODO: Raise error unless it is a FLTK::Widget  GET_DATA( fl_widget, Fl_Widget, mrb_widget );  Fl::focus( fl_widget );  return mrb_widget;}

// get data from multi_local_options structvoid get_local_options(ubyte *data, int *size, multi_local_options *mlo){	int offset = *size;	GET_DATA(*mlo);	mlo->flags = INTEL_INT(mlo->flags); //-V570	mlo->obj_update_level = INTEL_INT(mlo->obj_update_level); //-V570	*size = offset;}

void remmina_rdp_event_update_rect(RemminaProtocolWidget* gp, gint x, gint y, gint w, gint h){	rfContext* rfi;	rfi = GET_DATA(gp);	if (remmina_plugin_service->protocol_plugin_get_scale(gp))		remmina_rdp_event_scale_area(gp, &x, &y, &w, &h);	gtk_widget_queue_draw_area(rfi->drawing_area, x, y, w, h);}

// FLTK::Widget#type=(value)// Sets the widget type.mrb_value mrb_fltk_widget_type_setter_instance_method( mrb_state *mrb, mrb_value self ) {  GET_DATA( fl_widget, Fl_Widget, self );  mrb_value value;  mrb_get_args( mrb, "i", &value );  fl_widget->type( (int)mrb_fixnum( value ) );  Fl_Group::current( 0 ); // Prevent new widgets from being added to a group  return value;}

void rf_get_fds(RemminaProtocolWidget* gp, void** rfds, int* rcount){    rfContext* rfi;    rfi = GET_DATA(gp);    if (rfi->event_pipe[0] != -1)    {        rfds[*rcount] = GINT_TO_POINTER(rfi->event_pipe[0]);        (*rcount)++;    }}

		void testSendingComplexNotification()		{			JsonQt::JsonRpc t;			QSignalSpy spy(&t, SIGNAL(sendJson(const QString&)));			QVariantMap params;			params["bar"] = "baz";			t.sendNotification("foo", params);			GET_DATA();			QCOMPARE(data.value("method").toString(), QString("foo"));			QVERIFY(!data.contains("id"));			QCOMPARE(data.value("params").toMap(), params);		}

static gboolean remmina_rdp_close_connection(RemminaProtocolWidget* gp){    rfContext* rfi;    freerdp* instance;    rfi = GET_DATA(gp);    instance = rfi->instance;    if (rfi->thread)    {        pthread_cancel(rfi->thread);        if (rfi->thread)            pthread_join(rfi->thread, NULL);    }    pthread_mutex_destroy(&rfi->mutex);    g_mutex_free(rfi->gmutex);    g_cond_free(rfi->gcond);    remmina_rdp_event_uninit(gp);    remmina_plugin_service->protocol_plugin_emit_signal(gp, "disconnect");    if (instance)    {        if (rfi->channels)        {            //freerdp_channels_close(rfi->channels, instance);            freerdp_channels_free(rfi->channels);            rfi->channels = NULL;        }        if (freerdp_shall_disconnect(instance))        {            freerdp_disconnect(instance);        }    }    if (rfi->rfx_context)    {        rfx_context_free(rfi->rfx_context);        rfi->rfx_context = NULL;    }    if (instance)    {        //freerdp_context_free(instance); /* context is rfContext* rfi */        freerdp_free(instance);    }    return FALSE;}