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

static voidweston_xserver_cleanup(struct weston_process *process, int status){	struct weston_xserver *mxs =		container_of(process, struct weston_xserver, process);	mxs->process.pid = 0;	mxs->client = NULL;	mxs->resource = NULL;	mxs->abstract_source =		wl_event_loop_add_fd(mxs->loop, mxs->abstract_fd,				     WL_EVENT_READABLE,				     weston_xserver_handle_event, mxs);	mxs->unix_source =		wl_event_loop_add_fd(mxs->loop, mxs->unix_fd,				     WL_EVENT_READABLE,				     weston_xserver_handle_event, mxs);	if (mxs->wm) {		weston_log("xserver exited, code %d/n", status);		weston_wm_destroy(mxs->wm);		mxs->wm = NULL;	} else {		/* If the X server crashes before it binds to the		 * xserver interface, shut down and don't try		 * again. */		weston_log("xserver crashing too fast: %d/n", status);		weston_xserver_shutdown(mxs);	}}

static intevdev_configure_device(struct evdev_device *device){	if ((device->caps &	     (EVDEV_MOTION_ABS | EVDEV_MOTION_REL | EVDEV_BUTTON))) {		weston_seat_init_pointer(device->seat);		weston_log("input device %s, %s is a pointer caps =%s%s%s/n",			   device->devname, device->devnode,			   device->caps & EVDEV_MOTION_ABS ? " absolute-motion" : "",			   device->caps & EVDEV_MOTION_REL ? " relative-motion": "",			   device->caps & EVDEV_BUTTON ? " button" : "");	}	if ((device->caps & EVDEV_KEYBOARD)) {		if (weston_seat_init_keyboard(device->seat, NULL) < 0)			return -1;		weston_log("input device %s, %s is a keyboard/n",			   device->devname, device->devnode);	}	if ((device->caps & EVDEV_TOUCH)) {		weston_seat_init_touch(device->seat);		weston_log("input device %s, %s is a touch device/n",			   device->devname, device->devnode);	}	return 0;}

static voidweston_wm_send_incr_chunk(struct weston_wm *wm){	int length;	weston_log("property deleted/n");	wm->selection_property_set = 0;	if (wm->flush_property_on_delete) {		weston_log("setting new property, %zu bytes/n",			wm->source_data.size);		wm->flush_property_on_delete = 0;		length = weston_wm_flush_source_data(wm);		if (wm->data_source_fd >= 0) {			wm->property_source =				wl_event_loop_add_fd(wm->server->loop,						     wm->data_source_fd,						     WL_EVENT_READABLE,						     weston_wm_read_data_source,						     wm);		} else if (length > 0) {			/* Transfer is all done, but queue a flush for			 * the delete of the last chunk so we can set			 * the 0 sized propert to signal the end of			 * the transfer. */			wm->flush_property_on_delete = 1;			wl_array_release(&wm->source_data);		} else {			wm->selection_request.requestor = XCB_NONE;		}	}}

static voidcms_output_created(struct cms_static *cms, struct weston_output *o){	struct weston_color_profile *p;	struct weston_config_section *s;	char *profile;	weston_log("cms-static: output %i [%s] created/n", o->id, o->name);	if (o->name == NULL)		return;	s = weston_config_get_section(cms->ec->config,				      "output", "name", o->name);	if (s == NULL)		return;	if (weston_config_section_get_string(s, "icc_profile", &profile, NULL) < 0)		return;	p = weston_cms_load_profile(profile);	if (p == NULL) {		weston_log("cms-static: failed to load %s/n", profile);	} else {		weston_log("cms-static: loading %s for %s/n",			   profile, o->name);		weston_cms_set_color_profile(o, p);	}}

static voidrunner_run_handler(struct wl_client *client, struct wl_resource *resource,		   const char *test_name){	struct test_launcher *launcher;	const struct runner_test *t;	assert(static_context.runner_resource == NULL ||	       static_context.runner_resource == resource);	launcher = wl_resource_get_user_data(resource);	static_context.layout_interface = launcher->layout_interface;	static_context.runner_resource = resource;	t = find_runner_test(test_name);	if (!t) {		weston_log("Error: runner test /"%s/" not found./n",			   test_name);		wl_resource_post_error(resource,				       WESTON_TEST_RUNNER_ERROR_UNKNOWN_TEST,				       "weston_test_runner: unknown: '%s'",				       test_name);		return;	}	weston_log("weston_test_runner.run(/"%s/")/n", test_name);	t->run(&static_context);	weston_test_runner_send_finished(resource);}

static intweston_timeline_do_open(void){	const char *prefix = "weston-timeline-";	const char *suffix = ".log";	char fname[1000];	timeline_.file = file_create_dated(prefix, suffix,					   fname, sizeof(fname));	if (!timeline_.file) {		const char *msg;		switch (errno) {		case ETIME:			msg = "failure in datetime formatting";			break;		default:			msg = strerror(errno);		}		weston_log("Cannot open '%s*%s' for writing: %s/n",			   prefix, suffix, msg);		return -1;	}	weston_log("Opened timeline file '%s'/n", fname);	return 0;}

static inttry_open_vt(struct tty *tty){	int tty0, fd;	char filename[16];	tty0 = open("/dev/tty0", O_WRONLY | O_CLOEXEC);	if (tty0 < 0) {		weston_log("could not open tty0: %m/n");		return -1;	}	if (ioctl(tty0, VT_OPENQRY, &tty->vt) < 0 || tty->vt == -1) {		weston_log("could not open tty0: %m/n");		close(tty0);		return -1;	}	close(tty0);	snprintf(filename, sizeof filename, "/dev/tty%d", tty->vt);	weston_log("compositor: using new vt %s/n", filename);	fd = open(filename, O_RDWR | O_NOCTTY | O_CLOEXEC);	if (fd < 0)		return fd;	return fd;}

static voididle_launch_client(void *data){	struct test_launcher *launcher = data;	pid_t pid;	sigset_t allsigs;	pid = fork();	if (pid == -1) {		weston_log("fatal: failed to fork '%s': %m/n", launcher->exe);		weston_compositor_exit_with_code(launcher->compositor,						 EXIT_FAILURE);		return;	}	if (pid == 0) {		sigfillset(&allsigs);		sigprocmask(SIG_UNBLOCK, &allsigs, NULL);		execl(launcher->exe, launcher->exe, NULL);		weston_log("compositor: executing '%s' failed: %m/n",			   launcher->exe);		_exit(EXIT_FAILURE);	}	launcher->process.pid = pid;	launcher->process.cleanup = test_client_sigchld;	weston_watch_process(&launcher->process);}

/*virtual*/InputEmulatorUInput::~InputEmulatorUInput(){	weston_log("weston-wfits: %s/n", BOOST_CURRENT_FUNCTION);	if (ioctl(fd_, UI_DEV_DESTROY) < 0) {		weston_log("weston-wfits: failed to destroy uinput device/n");	}}

static intweston_xserver_handle_event(int listen_fd, uint32_t mask, void *data){	struct weston_xserver *mxs = data;	char display[8], s[8];	int sv[2], client_fd;	if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {		weston_log("socketpair failed/n");		return 1;	}	mxs->process.pid = fork();	switch (mxs->process.pid) {	case 0:		/* SOCK_CLOEXEC closes both ends, so we need to unset		 * the flag on the client fd. */		client_fd = dup(sv[1]);		if (client_fd < 0)			return 1;		snprintf(s, sizeof s, "%d", client_fd);		setenv("WAYLAND_SOCKET", s, 1);		snprintf(display, sizeof display, ":%d", mxs->display);		if (execl(XSERVER_PATH,			  XSERVER_PATH,			  display,			  "-wayland",			  "-rootless",			  "-retro",			  "-nolisten", "all",			  "-terminate",			  NULL) < 0)			weston_log("exec failed: %m/n");		exit(-1);	default:		weston_log("forked X server, pid %d/n", mxs->process.pid);		close(sv[1]);		mxs->client = wl_client_create(mxs->wl_display, sv[0]);		weston_watch_process(&mxs->process);		wl_event_source_remove(mxs->abstract_source);		wl_event_source_remove(mxs->unix_source);		break;	case -1:		weston_log( "failed to fork/n");		break;	}	return 1;}

static voidss_seat_handle_keymap(void *data, struct wl_keyboard *wl_keyboard,		      uint32_t format, int fd, uint32_t size){	struct ss_seat *seat = data;	struct xkb_keymap *keymap;	char *map_str;	if (!data)		goto error;	if (format == WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {		map_str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);		if (map_str == MAP_FAILED) {			weston_log("mmap failed: %m/n");			goto error;		}		keymap = xkb_keymap_new_from_string(seat->base.compositor->xkb_context,						    map_str,						    XKB_KEYMAP_FORMAT_TEXT_V1,						    0);		munmap(map_str, size);		if (!keymap) {			weston_log("failed to compile keymap/n");			goto error;		}		seat->keyboard_state_update = STATE_UPDATE_NONE;	} else if (format == WL_KEYBOARD_KEYMAP_FORMAT_NO_KEYMAP) {		weston_log("No keymap provided; falling back to default/n");		keymap = NULL;		seat->keyboard_state_update = STATE_UPDATE_AUTOMATIC;	} else {		weston_log("Invalid keymap/n");		goto error;	}	close(fd);	if (seat->base.keyboard_device_count)		weston_seat_update_keymap(&seat->base, keymap);	else		weston_seat_init_keyboard(&seat->base, keymap);	xkb_keymap_unref(keymap);	return;error:	wl_keyboard_release(seat->parent.keyboard);	close(fd);}

static intweston_wm_handle_xfixes_selection_notify(struct weston_wm *wm,				       xcb_generic_event_t *event){	xcb_xfixes_selection_notify_event_t *xfixes_selection_notify =		(xcb_xfixes_selection_notify_event_t *) event;	struct weston_compositor *compositor;	struct weston_seat *seat = weston_wm_pick_seat(wm);	uint32_t serial;	if (xfixes_selection_notify->selection != wm->atom.clipboard)		return 0;	weston_log("xfixes selection notify event: owner %d/n",	       xfixes_selection_notify->owner);	if (xfixes_selection_notify->owner == XCB_WINDOW_NONE) {		if (wm->selection_owner != wm->selection_window) {			/* A real X client selection went away, not our			 * proxy selection.  Clear the wayland selection. */			compositor = wm->server->compositor;			serial = wl_display_next_serial(compositor->wl_display);			weston_seat_set_selection(seat, NULL, serial);		}		wm->selection_owner = XCB_WINDOW_NONE;		return 1;	}	wm->selection_owner = xfixes_selection_notify->owner;	/* We have to use XCB_TIME_CURRENT_TIME when we claim the	 * selection, so grab the actual timestamp here so we can	 * answer TIMESTAMP conversion requests correctly. */	if (xfixes_selection_notify->owner == wm->selection_window) {		wm->selection_timestamp = xfixes_selection_notify->timestamp;		weston_log("our window, skipping/n");		return 1;	}	wm->incr = 0;	xcb_convert_selection(wm->conn, wm->selection_window,			      wm->atom.clipboard,			      wm->atom.targets,			      wm->atom.wl_selection,			      xfixes_selection_notify->timestamp);	xcb_flush(wm->conn);	return 1;}

static voidpixman_renderer_attach(struct weston_surface *es, struct weston_buffer *buffer){	struct pixman_surface_state *ps = get_surface_state(es);	struct wl_shm_buffer *shm_buffer;	pixman_format_code_t pixman_format;	weston_buffer_reference(&ps->buffer_ref, buffer);	if (ps->image) {		pixman_image_unref(ps->image);		ps->image = NULL;	}	if (!buffer)		return;		shm_buffer = wl_shm_buffer_get(buffer->resource);	if (! shm_buffer) {		weston_log("Pixman renderer supports only SHM buffers/n");		weston_buffer_reference(&ps->buffer_ref, NULL);		return;	}	switch (wl_shm_buffer_get_format(shm_buffer)) {	case WL_SHM_FORMAT_XRGB8888:		pixman_format = PIXMAN_x8r8g8b8;		break;	case WL_SHM_FORMAT_ARGB8888:		pixman_format = PIXMAN_a8r8g8b8;		break;	case WL_SHM_FORMAT_RGB565:		pixman_format = PIXMAN_r5g6b5;		break;	default:		weston_log("Unsupported SHM buffer format/n");		weston_buffer_reference(&ps->buffer_ref, NULL);		return;	break;	}	buffer->shm_buffer = shm_buffer;	buffer->width = wl_shm_buffer_get_width(shm_buffer);	buffer->height = wl_shm_buffer_get_height(shm_buffer);	ps->image = pixman_image_create_bits(pixman_format,		buffer->width, buffer->height,		wl_shm_buffer_get_data(shm_buffer),		wl_shm_buffer_get_stride(shm_buffer));}

static pid_tspawn_xserver(struct weston_xserver *wxs){    int sv[2], wm[2];    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {        weston_log("wl connection socketpair failed/n");        return 1;    }    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, wm) < 0) {        weston_log("X wm connection socketpair failed/n");        return 1;    }    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();    env.insert(QStringLiteral("WAYLAND_SOCKET"), QString::number(dup(sv[1])));    QString display = QStringLiteral(":%1").arg(wxs->display);    QString abstract_fd = QString::number(dup(wxs->abstract_fd));    QString unix_fd = QString::number(dup(wxs->unix_fd));    QString wm_fd = QString::number(dup(wm[1]));    s_process = new Process;    s_process->setProcessChannelMode(QProcess::ForwardedChannels);    s_process->setProcessEnvironment(env);    s_process->connect(s_process, (void (QProcess::*)(int))&QProcess::finished, [wxs](int exitCode) {        weston_xserver_exited(wxs, exitCode);        if (s_process) {            delete s_process;            s_process = nullptr;        }    });    s_process->start(QStringLiteral("Xwayland"), {              display,              QStringLiteral("-rootless"),              QStringLiteral("-listen"), abstract_fd,              QStringLiteral("-listen"), unix_fd,              QStringLiteral("-wm"), wm_fd,              QStringLiteral("-terminate") });    close(sv[1]);    wxs->client = wl_client_create(wxs->wl_display, sv[0]);    close(wm[1]);    wxs->wm_fd = wm[0];    return s_process->processId();}

WL_EXPORT voidweston_timeline_point(const char *name, ...){	va_list argp;	struct timespec ts;	enum timeline_type otype;	void *obj;	char buf[512];	struct timeline_emit_context ctx;	clock_gettime(timeline_.clk_id, &ts);	ctx.out = timeline_.file;	ctx.cur = fmemopen(buf, sizeof(buf), "w");	ctx.series = timeline_.series;	if (!ctx.cur) {		weston_log("Timeline error in fmemopen, closing./n");		weston_timeline_close();		return;	}	fprintf(ctx.cur, "{ /"T/":[%" PRId64 ", %ld], /"N/":/"%s/"",		(int64_t)ts.tv_sec, ts.tv_nsec, name);	va_start(argp, name);	while (1) {		otype = va_arg(argp, enum timeline_type);		if (otype == TLT_END)			break;		obj = va_arg(argp, void *);		if (type_dispatch[otype]) {			fprintf(ctx.cur, ", ");			type_dispatch[otype](&ctx, obj);		}	}	va_end(argp);	fprintf(ctx.cur, " }/n");	fflush(ctx.cur);	if (ferror(ctx.cur)) {		weston_log("Timeline error in constructing entry, closing./n");		weston_timeline_close();	} else {		fprintf(ctx.out, "%s", buf);	}	fclose(ctx.cur);}

static intlauncher_logind_take_control(struct launcher_logind *wl){	DBusError err;	DBusMessage *m, *reply;	dbus_bool_t force;	bool b;	int r;	dbus_error_init(&err);	m = dbus_message_new_method_call("org.freedesktop.login1",					 wl->spath,					 "org.freedesktop.login1.Session",					 "TakeControl");	if (!m)		return -ENOMEM;	force = false;	b = dbus_message_append_args(m,				     DBUS_TYPE_BOOLEAN, &force,				     DBUS_TYPE_INVALID);	if (!b) {		r = -ENOMEM;		goto err_unref;	}	reply = dbus_connection_send_with_reply_and_block(wl->dbus,							  m, -1, &err);	if (!reply) {		if (dbus_error_has_name(&err, DBUS_ERROR_UNKNOWN_METHOD))			weston_log("logind: old systemd version detected/n");		else			weston_log("logind: cannot take control over session %s/n", wl->sid);		dbus_error_free(&err);		r = -EIO;		goto err_unref;	}	dbus_message_unref(reply);	dbus_message_unref(m);	return 0;err_unref:	dbus_message_unref(m);	return r;}

static voiddevice_resumed(struct launcher_logind *wl, DBusMessage *m){	bool r;	uint32_t major;	r = dbus_message_get_args(m, NULL,				  DBUS_TYPE_UINT32, &major,				  /*DBUS_TYPE_UINT32, &minor,				  DBUS_TYPE_UNIX_FD, &fd,*/				  DBUS_TYPE_INVALID);	if (!r) {		weston_log("logind: cannot parse ResumeDevice dbus signal/n");		return;	}	/* DeviceResumed messages provide us a new file-descriptor for	 * resumed devices. For DRM devices it's the same as before, for evdev	 * devices it's a new open-file. As we reopen evdev devices, anyway,	 * there is no need for us to handle this event for evdev. For DRM, we	 * notify the compositor to wake up. */	if (wl->sync_drm && major == DRM_MAJOR)		launcher_logind_set_active(wl, true);}

WL_EXPORT intbackend_init(struct weston_compositor *compositor,	     int *argc, char *argv[],	     struct weston_config *wc,	     struct weston_backend_config *config_base){	struct headless_backend *b;	struct weston_headless_backend_config config = {{ 0, }};	if (config_base == NULL ||	    config_base->struct_version != WESTON_HEADLESS_BACKEND_CONFIG_VERSION ||	    config_base->struct_size > sizeof(struct weston_headless_backend_config)) {		weston_log("headless backend config structure is invalid/n");		return -1;	}	config_init_to_defaults(&config);	memcpy(&config, config_base, config_base->struct_size);	b = headless_backend_create(compositor, &config);	if (b == NULL)		return -1;	return 0;}

static voidweston_wm_get_incr_chunk(struct weston_wm *wm){	xcb_get_property_cookie_t cookie;	xcb_get_property_reply_t *reply;	cookie = xcb_get_property(wm->conn,				  0, /* delete */				  wm->selection_window,				  wm->atom.wl_selection,				  XCB_GET_PROPERTY_TYPE_ANY,				  0, /* offset */				  0x1fffffff /* length */);	reply = xcb_get_property_reply(wm->conn, cookie, NULL);	dump_property(wm, wm->atom.wl_selection, reply);	if (xcb_get_property_value_length(reply) > 0) {		weston_wm_write_property(wm, reply);	} else {		weston_log("transfer complete/n");		close(wm->data_source_fd);		free(reply);	}}

static voidweston_wm_send_data(struct weston_wm *wm, xcb_atom_t target, const char *mime_type){	struct weston_data_source *source;	struct weston_seat *seat = weston_wm_pick_seat(wm);	int p[2];	if (pipe2(p, O_CLOEXEC | O_NONBLOCK) == -1) {		weston_log("pipe2 failed: %m/n");		weston_wm_send_selection_notify(wm, XCB_ATOM_NONE);		return;	}	wl_array_init(&wm->source_data);	wm->selection_target = target;	wm->data_source_fd = p[0];	wm->property_source = wl_event_loop_add_fd(wm->server->loop,						   wm->data_source_fd,						   WL_EVENT_READABLE,						   weston_wm_read_data_source,						   wm);	source = seat->selection_data_source;	source->send(source, mime_type, p[1]);	close(p[1]);}

static GLuint CreateShader(GLenum type, const char *shader_src){  GLuint shader = glCreateShader(type);  if(!shader)    return 0;  glShaderSource(shader, 1, &shader_src, NULL);  glCompileShader(shader);  GLint compiled = 0;  glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);  if(!compiled)  {    GLint info_len = 0;    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_len);    if(info_len > 1)    {      char *info_log = (char *)malloc(sizeof(char) * info_len);      glGetShaderInfoLog(shader, info_len, NULL, info_log);      weston_log("/tError compiling shader:/n/t%s/n", info_log);      free(info_log);    }    glDeleteShader(shader);    return 0;  }  return shader;}

void show_error_(const char *file, int line){  GLenum error = GL_NO_ERROR;  error = glGetError();  if(error != GL_NO_ERROR)  {    switch(error)    {      case GL_INVALID_OPERATION: weston_log("/tGL Error: GL_INVALID_OPERATION - %s : %i/n", file, line); break;      case GL_INVALID_ENUM: weston_log("/tGL Error: GL_INVALID_ENUM - %s : %i/n", file, line); break;      case GL_INVALID_VALUE: weston_log("/tGL Error: GL_INVALID_VALUE - %s : %i/n", file, line); break;      case GL_OUT_OF_MEMORY: weston_log("/tGL Error: GL_OUT_OF_MEMORY - %s : %i/n", file, line); break;      case GL_INVALID_FRAMEBUFFER_OPERATION: weston_log("/tGL Error: GL_INVALID_FRAMEBUFFER_OPERATION - %s : %i/n", file, line); break;    }  }}

static intbind_to_abstract_socket(int display){	struct sockaddr_un addr;	socklen_t size, name_size;	int fd;	fd = socket(PF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);	if (fd < 0)		return -1;	addr.sun_family = AF_LOCAL;	name_size = snprintf(addr.sun_path, sizeof addr.sun_path,			     "%c/tmp/.X11-unix/X%d", 0, display);	size = offsetof(struct sockaddr_un, sun_path) + name_size;	if (bind(fd, (struct sockaddr *) &addr, size) < 0) {		weston_log("failed to bind to @%s: %m/n", addr.sun_path + 1);		close(fd);		return -1;	}	if (listen(fd, 1) < 0) {		close(fd);		return -1;	}	return fd;}

WL_EXPORT intbackend_init(struct weston_compositor *compositor,	     int *argc, char *argv[],	     struct weston_config *config,	     struct weston_backend_config *config_base){	int width = 1024, height = 640;	char *display_name = NULL;	struct headless_parameters param = { 0, };	const char *transform = "normal";	struct headless_backend *b;	const struct weston_option headless_options[] = {		{ WESTON_OPTION_INTEGER, "width", 0, &width },		{ WESTON_OPTION_INTEGER, "height", 0, &height },		{ WESTON_OPTION_BOOLEAN, "use-pixman", 0, &param.use_pixman },		{ WESTON_OPTION_STRING, "transform", 0, &transform },	};	parse_options(headless_options,		      ARRAY_LENGTH(headless_options), argc, argv);	param.width = width;	param.height = height;	if (weston_parse_transform(transform, &param.transform) < 0)		weston_log("Invalid transform /"%s/"/n", transform);	b = headless_backend_create(compositor, &param, display_name);	if (b == NULL)		return -1;	return 0;}

static intbind_to_unix_socket(int display){	struct sockaddr_un addr;	socklen_t size, name_size;	int fd;	fd = socket(PF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);	if (fd < 0)		return -1;	addr.sun_family = AF_LOCAL;	name_size = snprintf(addr.sun_path, sizeof addr.sun_path,			     "/tmp/.X11-unix/X%d", display) + 1;	size = offsetof(struct sockaddr_un, sun_path) + name_size;	unlink(addr.sun_path);	if (bind(fd, (struct sockaddr *) &addr, size) < 0) {		weston_log("failed to bind to %s (%s)/n",			addr.sun_path, strerror(errno));		close(fd);		return -1;	}	if (listen(fd, 1) < 0) {		unlink(addr.sun_path);		close(fd);		return -1;	}	return fd;}

static voidbind_runner(struct wl_client *client, void *data,	    uint32_t version, uint32_t id){	struct test_launcher *launcher = data;	struct wl_resource *resource;	resource = wl_resource_create(client, &weston_test_runner_interface,				      1, id);	if (!resource) {		wl_client_post_no_memory(client);		return;	}	wl_resource_set_implementation(resource, &runner_implementation,				       launcher, destroy_runner);	if (static_context.runner_resource != NULL) {		weston_log("test FATAL: "			   "attempting to run several tests in parallel./n");		wl_resource_post_error(resource,				       WESTON_TEST_RUNNER_ERROR_TEST_FAILED,				       "attempt to run parallel tests");	}}

voidevdev_notify_keyboard_focus(struct weston_seat *seat,			    struct wl_list *evdev_devices){	struct evdev_device *device;	struct wl_array keys;	unsigned int i, set;	char evdev_keys[(KEY_CNT + 7) / 8];	char all_keys[(KEY_CNT + 7) / 8];	uint32_t *k;	int ret;	if (!seat->keyboard)		return;	memset(all_keys, 0, sizeof all_keys);	wl_list_for_each(device, evdev_devices, link) {		memset(evdev_keys, 0, sizeof evdev_keys);		ret = ioctl(device->fd,			    EVIOCGKEY(sizeof evdev_keys), evdev_keys);		if (ret < 0) {			weston_log("failed to get keys for device %s/n",				device->devnode);			continue;		}		for (i = 0; i < ARRAY_LENGTH(evdev_keys); i++)			all_keys[i] |= evdev_keys[i];	}

static voiddata_source_accept(struct weston_data_source *base,		   uint32_t time, const char *mime_type){	struct dnd_data_source *source = (struct dnd_data_source *) base;	xcb_client_message_event_t client_message;	struct weston_wm *wm = source->wm;	weston_log("got accept, mime-type %s/n", mime_type);	/* FIXME: If we rewrote UTF8_STRING to	 * text/plain;charset=utf-8 and the source doesn't support the	 * mime-type, we'll have to rewrite the mime-type back to	 * UTF8_STRING here. */	client_message.response_type = XCB_CLIENT_MESSAGE;	client_message.format = 32;	client_message.window = wm->dnd_window;	client_message.type = wm->atom.xdnd_status;	client_message.data.data32[0] = wm->dnd_window;	client_message.data.data32[1] = 2;	if (mime_type)		client_message.data.data32[1] |= 1;	client_message.data.data32[2] = 0;	client_message.data.data32[3] = 0;	client_message.data.data32[4] = wm->atom.xdnd_action_copy;	xcb_send_event(wm->conn, 0, wm->dnd_owner,			       XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,			       (char *) &client_message);}

WL_EXPORT intmodule_init(struct weston_compositor *ec,	    int *argc, char *argv[]){	struct cms_static *cms;	struct weston_output *output;	weston_log("cms-static: initialized/n");	/* create local state object */	cms = malloc(sizeof *cms);	if (cms == NULL)		return -1;	memset(cms, 0, sizeof *cms);	cms->ec = ec;	cms->destroy_listener.notify = cms_notifier_destroy;	wl_signal_add(&ec->destroy_signal, &cms->destroy_listener);	cms->output_created_listener.notify = cms_notifier_output_created;	wl_signal_add(&ec->output_created_signal, &cms->output_created_listener);	/* discover outputs */	wl_list_for_each(output, &ec->output_list, link)		cms_output_created(cms, output);	return 0;}

WL_EXPORT voidweston_spring_update(struct weston_spring *spring, uint32_t msec){	double force, v, current, step;	/* Limit the number of executions of the loop below by ensuring that	 * the timestamp for last update of the spring is no more than 1s ago.	 * This handles the case where time moves backwards or forwards in	 * large jumps.	 */	if (msec - spring->timestamp > 1000) {		weston_log("unexpectedly large timestamp jump (from %u to %u)/n",			   spring->timestamp, msec);		spring->timestamp = msec - 1000;	}	step = 0.01;	while (4 < msec - spring->timestamp) {		current = spring->current;		v = current - spring->previous;		force = spring->k * (spring->target - current) / 10.0 +			(spring->previous - current) - v * spring->friction;		spring->current =			current + (current - spring->previous) +			force * step * step;		spring->previous = current;		switch (spring->clip) {		case WESTON_SPRING_OVERSHOOT:			break;		case WESTON_SPRING_CLAMP:			if (spring->current > spring->max) {				spring->current = spring->max;				spring->previous = spring->max;			} else if (spring->current < 0.0) {				spring->current = spring->min;				spring->previous = spring->min;			}			break;		case WESTON_SPRING_BOUNCE:			if (spring->current > spring->max) {				spring->current =					2 * spring->max - spring->current;				spring->previous =					2 * spring->max - spring->previous;			} else if (spring->current < spring->min) {				spring->current =					2 * spring->min - spring->current;				spring->previous =					2 * spring->min - spring->previous;			}			break;		}		spring->timestamp += 4;	}}