Index

$#! · 0-9 · A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · X · Y · Z

W
	wait sysclock_t systimer_t
	wait_for_signal
	wait_iopoll, iopoll_t
	wait_process, process_t
	wait_semaphore, semaphore_t
	wait_signalrt, signalrt_t
	wait_systimer, systimer_t
	wait_waitlist, waitlist_t
	wait2queue_entry_t
	WAITFOR
	waitforevent_syncrun Global syncrun_t
	waitforexit_syncrun Global syncrun_t
	waitforlist_syncrun Global syncrun_t
	waitinfo, syncrun_t
	waiting_syncevent Global syncevent_t
	Waitlist
	Waitlist Linuximpl
	waitlist_FREE, waitlist_t
	waitlist_t api/platform/sync/waitlist.h platform/Linux/sync/waitlist.c
	waitms_ipsocketasync, ipsocket_async_t
	waitqueue_entry_t
	waitXRRScreenChangeNotify
	wakeup, syncrun_t
	wakeup_list, syncrun_t
	wakeupreader_rwlock
	wakeupwriter_rwlock
	wbuffer_FREE, wbuffer_t
	wbuffer_INIT_CSTRING, wbuffer_t
	wbuffer_INIT_MEMBLOCK, wbuffer_t
	wbuffer_INIT_OTHER, wbuffer_t
	wbuffer_INIT_STATIC, wbuffer_t
	wbuffer_it
	wbuffer_t api/memory/wbuffer.h memory/wbuffer.c
	Why do we need it
	width_in_pixel, x11videomode_t
	window_evh_DECLARE Global window_evh_t
	window_evh_INIT, window_evh_t
	window_evh_t
	window_FREE, window_t
	window_t api/graphic/window.h graphic/window.c
	windowconfig_e
	windowconfig_FRAME
	windowconfig_INIT_FRAME, windowconfig_t
	windowconfig_INIT_MAXSIZE, windowconfig_t
	windowconfig_INIT_MINSIZE, windowconfig_t
	windowconfig_INIT_NONE, windowconfig_t
	windowconfig_INIT_POS, windowconfig_t
	windowconfig_INIT_SIZE, windowconfig_t
	windowconfig_INIT_TITLE, windowconfig_t
	windowconfig_INIT_TRANSPARENCY, windowconfig_t
	windowconfig_MAXSIZE
	windowconfig_MINSIZE
	windowconfig_NONE
	windowconfig_NROFELEMENTS
	windowconfig_POS
	windowconfig_SIZE
	windowconfig_t
	windowconfig_TITLE
	windowconfig_TRANSPARENCY
	wlistentry_FREE, wlistentry_t
	wlistentry_t
	write directory_t api/io/filesystem/directory.h platform/Linux/io/directory.c textresource_writer_t
	write_file Global file_t
	write_iochannel, iochannel_t
	write_ipsocket, ipsocket_t
	write_logbuffer, logbuffer_t
	WriteBuffer
	WriteBuffer impl
	writelogfile_unittest, unittest_t
	writeoob_ipsocket, ipsocket_t
	writer, rwlock_t
	writers, rwlock_t
	writeto_ipsocket, ipsocket_t

static int wait_for_signal( int signr )

Waits for a blocked signal until it has been received.

int wait_iopoll( iopoll_t * iopoll,
/*out*/uint32_t * nr_events,
uint32_t queuesize,
/*out*/struct ioevent_t * eventqueue/*[queuesize]*/,
uint16_t timeout_ms )

Waits timeout_ms milliseconds for events and returns them.

int wait_process( process_t * process,
/*out*/process_result_t * result )

Waits until process has terminated.

int wait_semaphore( semaphore_t * semaobj )

Waits until a signal is received.

int wait_signalrt( signalrt_t nr,
/*out*/uintptr_t * value )

Waits for a realtime signal with number nr.

int wait_systimer( systimer_t timer )

Waits until timer expires.

int wait_waitlist( waitlist_t * wlist )

Suspends the calling thread until some other calls trywakeup_waitlist.

struct wait2queue_entry_t

Contains waiting thread (syncwait_t) and its exitevent.

Reads and handles window events until CONDITION is met.

#define waitforevent_syncrun(
srun,
syncevent
) ( __extension__ ({ __label__ waitlabel ; setstatewait_syncrun((srun), (syncevent), __extension__ && waitlabel) ; return 0 ; waitlabel: (void)0 ; }))

Implements syncrun_t.waitforevent_syncrun.

void waitforevent_syncrun( syncrun_t * srun,
struct syncevent_t * syncevent )

Waits for syncevent to be signaled.

#define waitforexit_syncrun(
srun
) ( __extension__ ({ __label__ waitlabel ; setstatewait_syncrun((srun), srun->running.laststarted, __extension__ && waitlabel) ; return 0 ; waitlabel: retcode_syncrun(srun) ; }))

Implements syncrun_t.waitforexit_syncrun.

int waitforexit_syncrun( syncrun_t * srun )

Waits for the last started thread to exit.

#define waitforlist_syncrun(
srun,
syncwlist
) ( __extension__ ({ __label__ waitlabel ; setstatewaitlist_syncrun((srun), (syncwlist), __extension__ && waitlabel) ; return 0 ; waitlabel: (void)0 ; }))

Implements syncrun_t.waitforlist_syncrun.

void waitforlist_syncrun( syncrun_t * srun,
struct syncwlist_t * syncwlist )

Waits for syncwlist to be signaled.

struct { struct syncwlist_t * wlist ; struct syncevent_t * event ; void * continuelabel ; } waitinfo

Stores waiting information of the running thread if its state is changed to syncrun_state_WAIT.

#define waiting_syncevent( syncevent ) ((syncevent)->waiting)

Implements syncevent_t.waiting_syncevent.

syncwait_t * waiting_syncevent( const syncevent_t * syncevent )

Returns the single thread which waits for this event.

Allows threads of a single process to wait for a certain condition.

Implements Waitlist.

#define waitlist_FREE { 0, 0, 0 }

Static initializer.

struct waitlist_t

Allows threads of a single process to wait for a certain condition.

int waitms_ipsocketasync( ipsocket_async_t * ipsockasync,
uint32_t millisec/*0 = > no timeout*/ )

Waits until operation completes.

struct waitqueue_entry_t

Contains waiting thread (syncwait_t).

static int waitXRRScreenChangeNotify( x11screen_t * x11screen,
x11videomode_t * xvidmode )

Wait for XRRScreenChangeNotify and checks that x11disp gets updated.

struct { void * continuelabel ; int retcode ; } wakeup

Stores information used during wakeup of a thread which waited for an event.

syncwlist_t wakeup_list

List of syncevent_t.

static inline void wakeupreader_rwlock( rwlock_t * rwlock )

Wakes up all readers waiting in rwlock->readers.

static inline void wakeupwriter_rwlock( rwlock_t * rwlock )

Wakes up the first writer stored in list rwlock->writers.

#define wbuffer_FREE { 0, 0, 0, 0 }

Static initializer for invalid wbuffer_t.

#define wbuffer_INIT_CSTRING(
cstring
) wbuffer_INIT_OTHER(allocatedsize_cstring(cstring), (uint8_t*)str_cstring(cstring), cstring, &g_wbuffer_cstring)

Static initializer which wraps a cstring_t object into a wbuffer_t.

#define wbuffer_INIT_MEMBLOCK(
memblock
) wbuffer_INIT_OTHER(size_memblock(memblock), addr_memblock(memblock), memblock, &g_wbuffer_memblock)

Static initializer which wraps a memblock_t object into a wbuffer_t.

#define wbuffer_INIT_OTHER(
    buffer_size,
    buffer,
    impl,
    iimpl_it
) { (buffer), (buffer) + (buffer_size), (impl), (iimpl_it) }

Static initializer to adapt wbuffer_t to own memory implementation object.

#define wbuffer_INIT_STATIC(
buffer_size,
buffer
) wbuffer_INIT_OTHER(buffer_size, buffer, buffer, &g_wbuffer_static)

Static initializer which wraps static memory into a wbuffer_t.

struct wbuffer_it

Defines implementation interface for wbuffer_t.

struct wbuffer_t

Supports construction of return values of unknown size.

To handle errors in functions which call multiple other functions is tricky cause for any action already done before an error we need to undo these changes.

uint32_t width_in_pixel

Pixel size in horizontal direction.

#define window_evh_DECLARE(
declared_evh_t,
subwindow_t
) typedef struct declared_evh_t declared_evh_t; struct declared_evh_t { void (* onclose) (subwindow_t * win); void (* ondestroy) (subwindow_t * win); void (* onredraw) (subwindow_t * win); void (* onreshape) (subwindow_t * win, uint32_t width, uint32_t height); void (* onvisible) (subwindow_t * win, bool isVisible); }

Implements window_evh_t.window_evh_DECLARE.

void window_evh_DECLARE( TYPENAME declared_evh_t,
TYPENAME subwindow_t )

Declares an interface to handle window events.

#define window_evh_INIT(
subwindow_fct_suffix
) { & onclose ## subwindow_fct_suffix, & ondestroy ## subwindow_fct_suffix, & onredraw ## subwindow_fct_suffix, & onreshape ## subwindow_fct_suffix, & onvisible ## subwindow_fct_suffix }

Static initializer.

struct window_evh_t

Callback interface for handling generic window events.

#define window_FREE { x11window_FREE, surface_FREE_EMBEDDED }

Static initializer.

struct window_t

Wraps a native window and its OpenGL specific wrapper (if needed).

Sets window frame border flag to true.

#define windowconfig_INIT_FRAME { .i32 = windowconfig_FRAME }

Static initializer to switch on window frame drawn by the window manager.

#define windowconfig_INIT_MAXSIZE(
maxwidth,
maxheight
) { .i32 = windowconfig_MAXSIZE }, { .u16 = maxwidth }, { .u16 = maxheight }

Static initializer to set maximum possible size (width, height) of window.

#define windowconfig_INIT_MINSIZE(
minwidth,
minheight
) { .i32 = windowconfig_MINSIZE }, { .u16 = minwidth }, { .u16 = minheight }

Static initializer to set minimum possible size (width, height) of window.

#define windowconfig_INIT_NONE { .i32 = windowconfig_NONE }

Static initializer to mark end of configuration list.

#define windowconfig_INIT_POS(
x,
y
) { .i32 = windowconfig_POS }, { .i32 = x }, { .i32 = y }

Static initializer to set initial position (x,y) of window.

#define windowconfig_INIT_SIZE(
width,
height
) { .i32 = windowconfig_SIZE }, { .u16 = width }, { .u16 = height }

Static initializer to set initial size (width, height) of window.

#define windowconfig_INIT_TITLE(
title
) { .i32 = windowconfig_TITLE }, { .str = title }

Static initializer to set initial size of window.

#define windowconfig_INIT_TRANSPARENCY(
alpha
) { .i32 = windowconfig_TRANSPARENCY }, { .u8 = alpha/*only 0..255*/ }

Static initializer to set transparency of window.

Sets the maximum window size.

Sets the minimum window size.

Marks end of attribute list.

Gives the number of all valid configuration options excluding windowconfig_NROFELEMENTS.

Sets the window position.

Sets the window size.

struct windowconfig_t

Type of a single window configuration attribute.

Sets the title string of the window utf8.

Sets a transparency value for the whole window.

#define wlistentry_FREE { 0, 0, syncevent_FREE }

Static initializer.

struct wlistentry_t

Type of entry stored in syncwlist_t.

Implements file_t.write_file.

int write_file( file_t fileobj,
size_t size,
const void * buffer/*[size]*/,
size_t * bytes_written )

Writes size bytes from buffer to file referenced by fileobj.

int write_iochannel( iochannel_t ioc,
size_t size,
const void * buffer/*[size]*/,
/*out*/size_t * bytes_written )

Writes size bytes from buffer to the data stream referenced by ioc.

int write_ipsocket( ipsocket_t * ipsock,
size_t maxdata_len,
const uint8_t data[maxdata_len],
/*out*/size_t * bytes_written )

Transfers maxdata_len bytes into internal write (send) queue.

int write_logbuffer( logbuffer_t * logbuf )

Writes (flushes) the buffer to the configured io channel.

Implements a simple write buffer.

Implements WriteBuffer.

static int writelogfile_unittest( const char * testname )

Writes errlog to s_unittest_singleton.log_files_directory + “/” + testname.

int writeoob_ipsocket( ipsocket_t * ipsock,
uint8_t data )

Writes a single byte of “out of band” data (urgent data).

struct thread_t * writer

The thread which holds entrylock.

struct { struct slist_node_t * last ; } writers

Points to last entry in list of waiting writers.

int writeto_ipsocket( ipsocket_t * ipsock,
const struct ipaddr_t * remoteaddr,
size_t maxdata_len,
const uint8_t data[maxdata_len],
/*out*/size_t * bytes_written )

Same as write_ipsocket but for unconnected (UDP) sockets.