fixes by Art Haas <ahaas@airmail.net>:

rewritten with C99 struct initialization style.

src/control/control_hw.c

@@ -265,28 +265,28 @@ static int snd_ctl_hw_read(snd_ctl_t *handle, snd_ctl_event_t *event)
 }
 
 snd_ctl_ops_t snd_ctl_hw_ops = {
-	close: snd_ctl_hw_close,
+	.close = snd_ctl_hw_close,
-	nonblock: snd_ctl_hw_nonblock,
+	.nonblock = snd_ctl_hw_nonblock,
-	async: snd_ctl_hw_async,
+	.async = snd_ctl_hw_async,
-	subscribe_events: snd_ctl_hw_subscribe_events,
+	.subscribe_events = snd_ctl_hw_subscribe_events,
-	card_info: snd_ctl_hw_card_info,
+	.card_info = snd_ctl_hw_card_info,
-	element_list: snd_ctl_hw_elem_list,
+	.element_list = snd_ctl_hw_elem_list,
-	element_info: snd_ctl_hw_elem_info,
+	.element_info = snd_ctl_hw_elem_info,
-	element_read: snd_ctl_hw_elem_read,
+	.element_read = snd_ctl_hw_elem_read,
-	element_write: snd_ctl_hw_elem_write,
+	.element_write = snd_ctl_hw_elem_write,
-	element_lock: snd_ctl_hw_elem_lock,
+	.element_lock = snd_ctl_hw_elem_lock,
-	element_unlock: snd_ctl_hw_elem_unlock,
+	.element_unlock = snd_ctl_hw_elem_unlock,
-	hwdep_next_device: snd_ctl_hw_hwdep_next_device,
+	.hwdep_next_device = snd_ctl_hw_hwdep_next_device,
-	hwdep_info: snd_ctl_hw_hwdep_info,
+	.hwdep_info = snd_ctl_hw_hwdep_info,
-	pcm_next_device: snd_ctl_hw_pcm_next_device,
+	.pcm_next_device = snd_ctl_hw_pcm_next_device,
-	pcm_info: snd_ctl_hw_pcm_info,
+	.pcm_info = snd_ctl_hw_pcm_info,
-	pcm_prefer_subdevice: snd_ctl_hw_pcm_prefer_subdevice,
+	.pcm_prefer_subdevice = snd_ctl_hw_pcm_prefer_subdevice,
-	rawmidi_next_device: snd_ctl_hw_rawmidi_next_device,
+	.rawmidi_next_device = snd_ctl_hw_rawmidi_next_device,
-	rawmidi_info: snd_ctl_hw_rawmidi_info,
+	.rawmidi_info = snd_ctl_hw_rawmidi_info,
-	rawmidi_prefer_subdevice: snd_ctl_hw_rawmidi_prefer_subdevice,
+	.rawmidi_prefer_subdevice = snd_ctl_hw_rawmidi_prefer_subdevice,
-	set_power_state: snd_ctl_hw_set_power_state,
+	.set_power_state = snd_ctl_hw_set_power_state,
-	get_power_state: snd_ctl_hw_get_power_state,
+	.get_power_state = snd_ctl_hw_get_power_state,
-	read: snd_ctl_hw_read,
+	.read = snd_ctl_hw_read,
 };
 
 int snd_ctl_hw_open(snd_ctl_t **handle, const char *name, int card, int mode)

src/control/control_shm.c

@@ -396,28 +396,28 @@ static int snd_ctl_shm_read(snd_ctl_t *ctl, snd_ctl_event_t *event)
 }
 
 snd_ctl_ops_t snd_ctl_shm_ops = {
-	close: snd_ctl_shm_close,
+	.close = snd_ctl_shm_close,
-	nonblock: snd_ctl_shm_nonblock,
+	.nonblock = snd_ctl_shm_nonblock,
-	async: snd_ctl_shm_async,
+	.async = snd_ctl_shm_async,
-	subscribe_events: snd_ctl_shm_subscribe_events,
+	.subscribe_events = snd_ctl_shm_subscribe_events,
-	card_info: snd_ctl_shm_card_info,
+	.card_info = snd_ctl_shm_card_info,
-	element_list: snd_ctl_shm_elem_list,
+	.element_list = snd_ctl_shm_elem_list,
-	element_info: snd_ctl_shm_elem_info,
+	.element_info = snd_ctl_shm_elem_info,
-	element_read: snd_ctl_shm_elem_read,
+	.element_read = snd_ctl_shm_elem_read,
-	element_write: snd_ctl_shm_elem_write,
+	.element_write = snd_ctl_shm_elem_write,
-	element_lock: snd_ctl_shm_elem_lock,
+	.element_lock = snd_ctl_shm_elem_lock,
-	element_unlock: snd_ctl_shm_elem_unlock,
+	.element_unlock = snd_ctl_shm_elem_unlock,
-	hwdep_next_device: snd_ctl_shm_hwdep_next_device,
+	.hwdep_next_device = snd_ctl_shm_hwdep_next_device,
-	hwdep_info: snd_ctl_shm_hwdep_info,
+	.hwdep_info = snd_ctl_shm_hwdep_info,
-	pcm_next_device: snd_ctl_shm_pcm_next_device,
+	.pcm_next_device = snd_ctl_shm_pcm_next_device,
-	pcm_info: snd_ctl_shm_pcm_info,
+	.pcm_info = snd_ctl_shm_pcm_info,
-	pcm_prefer_subdevice: snd_ctl_shm_pcm_prefer_subdevice,
+	.pcm_prefer_subdevice = snd_ctl_shm_pcm_prefer_subdevice,
-	rawmidi_next_device: snd_ctl_shm_rawmidi_next_device,
+	.rawmidi_next_device = snd_ctl_shm_rawmidi_next_device,
-	rawmidi_info: snd_ctl_shm_rawmidi_info,
+	.rawmidi_info = snd_ctl_shm_rawmidi_info,
-	rawmidi_prefer_subdevice: snd_ctl_shm_rawmidi_prefer_subdevice,
+	.rawmidi_prefer_subdevice = snd_ctl_shm_rawmidi_prefer_subdevice,
-	set_power_state: snd_ctl_shm_set_power_state,
+	.set_power_state = snd_ctl_shm_set_power_state,
-	get_power_state: snd_ctl_shm_get_power_state,
+	.get_power_state = snd_ctl_shm_get_power_state,
-	read: snd_ctl_shm_read,
+	.read = snd_ctl_shm_read,
 };
 
 static int make_local_socket(const char *filename)

src/hwdep/hwdep_hw.c

@@ -95,12 +95,12 @@ static ssize_t snd_hwdep_hw_read(snd_hwdep_t *hwdep, void *buffer, size_t size)
 }
 
 static snd_hwdep_ops_t snd_hwdep_hw_ops = {
-	close: snd_hwdep_hw_close,
+	.close = snd_hwdep_hw_close,
-	nonblock: snd_hwdep_hw_nonblock,
+	.nonblock = snd_hwdep_hw_nonblock,
-	info: snd_hwdep_hw_info,
+	.info = snd_hwdep_hw_info,
-	ioctl: snd_hwdep_hw_ioctl,
+	.ioctl = snd_hwdep_hw_ioctl,
-	write: snd_hwdep_hw_write,
+	.write = snd_hwdep_hw_write,
-	read: snd_hwdep_hw_read,
+	.read = snd_hwdep_hw_read,
 };
 
 int snd_hwdep_hw_open(snd_hwdep_t **handle, const char *name, int card, int device, int mode)

src/input.c

@@ -158,11 +158,11 @@ static int snd_input_stdio_ungetc(snd_input_t *input, int c)
 }
 
 static snd_input_ops_t snd_input_stdio_ops = {
-	close: snd_input_stdio_close,
+	.close		= snd_input_stdio_close,
-	scan: snd_input_stdio_scan,
+	.scan		= snd_input_stdio_scan,
-	gets: snd_input_stdio_gets,
+	.gets		= snd_input_stdio_gets,
-	getch: snd_input_stdio_getc,
+	.getch		= snd_input_stdio_getc,
-	ungetch: snd_input_stdio_ungetc,
+	.ungetch	= snd_input_stdio_ungetc,
 };
 #endif
 
@@ -284,11 +284,11 @@ static int snd_input_buffer_ungetc(snd_input_t *input, int c)
 }
 
 static snd_input_ops_t snd_input_buffer_ops = {
-	close: snd_input_buffer_close,
+	.close		= snd_input_buffer_close,
-	scan: snd_input_buffer_scan,
+	.scan		= snd_input_buffer_scan,
-	gets: snd_input_buffer_gets,
+	.gets		= snd_input_buffer_gets,
-	getch: snd_input_buffer_getc,
+	.getch		= snd_input_buffer_getc,
-	ungetch: snd_input_buffer_ungetc,
+	.ungetch	= snd_input_buffer_ungetc,
 };
 #endif
 

src/output.c

@@ -166,11 +166,11 @@ static int snd_output_stdio_flush(snd_output_t *output)
 }
 
 static snd_output_ops_t snd_output_stdio_ops = {
-	close: snd_output_stdio_close,
+	.close		= snd_output_stdio_close,
-	print: snd_output_stdio_print,
+	.print		= snd_output_stdio_print,
-	puts: snd_output_stdio_puts,
+	.puts		= snd_output_stdio_puts,
-	putch: snd_output_stdio_putc,
+	.putch		= snd_output_stdio_putc,
-	flush: snd_output_stdio_flush,
+	.flush		= snd_output_stdio_flush,
 };
 
 #endif
@@ -318,11 +318,11 @@ static int snd_output_buffer_flush(snd_output_t *output ATTRIBUTE_UNUSED)
 }
 
 static snd_output_ops_t snd_output_buffer_ops = {
-	close: snd_output_buffer_close,
+	.close		= snd_output_buffer_close,
-	print: snd_output_buffer_print,
+	.print		= snd_output_buffer_print,
-	puts: snd_output_buffer_puts,
+	.puts		= snd_output_buffer_puts,
-	putch: snd_output_buffer_putc,
+	.putch		= snd_output_buffer_putc,
-	flush: snd_output_buffer_flush,
+	.flush		= snd_output_buffer_flush,
 };
 #endif
 

src/pcm/ext/pcm_jack.c

@@ -600,41 +600,41 @@ static void snd_pcm_jack_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_jack_ops = {
-	close: snd_pcm_jack_close,
+	.close = snd_pcm_jack_close,
-	info: snd_pcm_jack_info,
+	.info = snd_pcm_jack_info,
-	hw_refine: snd_pcm_jack_hw_refine,
+	.hw_refine = snd_pcm_jack_hw_refine,
-	hw_params: snd_pcm_jack_hw_params,
+	.hw_params = snd_pcm_jack_hw_params,
-	hw_free: snd_pcm_jack_hw_free,
+	.hw_free = snd_pcm_jack_hw_free,
-	sw_params: snd_pcm_jack_sw_params,
+	.sw_params = snd_pcm_jack_sw_params,
-	channel_info: snd_pcm_jack_channel_info,
+	.channel_info = snd_pcm_jack_channel_info,
-	dump: snd_pcm_jack_dump,
+	.dump = snd_pcm_jack_dump,
-	nonblock: snd_pcm_jack_nonblock,
+	.nonblock = snd_pcm_jack_nonblock,
-	async: snd_pcm_jack_async,
+	.async = snd_pcm_jack_async,
-	poll_revents: snd_pcm_jack_poll_revents,
+	.poll_revents = snd_pcm_jack_poll_revents,
-	mmap: snd_pcm_jack_mmap,
+	.mmap = snd_pcm_jack_mmap,
-	munmap: snd_pcm_jack_munmap,
+	.munmap = snd_pcm_jack_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_jack_fast_ops = {
-	status: snd_pcm_jack_status,
+	.status = snd_pcm_jack_status,
-	state: snd_pcm_jack_state,
+	.state = snd_pcm_jack_state,
-	hwsync: snd_pcm_jack_hwsync,
+	.hwsync = snd_pcm_jack_hwsync,
-	delay: snd_pcm_jack_delay,
+	.delay = snd_pcm_jack_delay,
-	prepare: snd_pcm_jack_prepare,
+	.prepare = snd_pcm_jack_prepare,
-	reset: snd_pcm_jack_reset,
+	.reset = snd_pcm_jack_reset,
-	start: snd_pcm_jack_start,
+	.start = snd_pcm_jack_start,
-	drop: snd_pcm_jack_drop,
+	.drop = snd_pcm_jack_drop,
-	drain: snd_pcm_jack_drain,
+	.drain = snd_pcm_jack_drain,
-	pause: snd_pcm_jack_pause,
+	.pause = snd_pcm_jack_pause,
-	rewind: snd_pcm_jack_rewind,
+	.rewind = snd_pcm_jack_rewind,
-	forward: snd_pcm_jack_forward,
+	.forward = snd_pcm_jack_forward,
-	resume: snd_pcm_jack_resume,
+	.resume = snd_pcm_jack_resume,
-	writei: snd_pcm_mmap_writei,
+	.writei = snd_pcm_mmap_writei,
-	writen: snd_pcm_mmap_writen,
+	.writen = snd_pcm_mmap_writen,
-	readi: snd_pcm_mmap_readi,
+	.readi = snd_pcm_mmap_readi,
-	readn: snd_pcm_mmap_readn,
+	.readn = snd_pcm_mmap_readn,
-	avail_update: snd_pcm_jack_avail_update,
+	.avail_update = snd_pcm_jack_avail_update,
-	mmap_commit: snd_pcm_jack_mmap_commit,
+	.mmap_commit = snd_pcm_jack_mmap_commit,
 };
 
 static int parse_ports(snd_config_t *conf,char*** ret_ports,int *ret_n)

src/pcm/pcm_adpcm.c

@@ -517,19 +517,19 @@ static void snd_pcm_adpcm_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_adpcm_ops = {
-	close: snd_pcm_plugin_close,
+	.close = snd_pcm_plugin_close,
-	info: snd_pcm_plugin_info,
+	.info = snd_pcm_plugin_info,
-	hw_refine: snd_pcm_adpcm_hw_refine,
+	.hw_refine = snd_pcm_adpcm_hw_refine,
-	hw_params: snd_pcm_adpcm_hw_params,
+	.hw_params = snd_pcm_adpcm_hw_params,
-	hw_free: snd_pcm_adpcm_hw_free,
+	.hw_free = snd_pcm_adpcm_hw_free,
-	sw_params: snd_pcm_plugin_sw_params,
+	.sw_params = snd_pcm_plugin_sw_params,
-	channel_info: snd_pcm_plugin_channel_info,
+	.channel_info = snd_pcm_plugin_channel_info,
-	dump: snd_pcm_adpcm_dump,
+	.dump = snd_pcm_adpcm_dump,
-	nonblock: snd_pcm_plugin_nonblock,
+	.nonblock = snd_pcm_plugin_nonblock,
-	async: snd_pcm_plugin_async,
+	.async = snd_pcm_plugin_async,
-	poll_revents: snd_pcm_plugin_poll_revents,
+	.poll_revents = snd_pcm_plugin_poll_revents,
-	mmap: snd_pcm_plugin_mmap,
+	.mmap = snd_pcm_plugin_mmap,
-	munmap: snd_pcm_plugin_munmap,
+	.munmap = snd_pcm_plugin_munmap,
 };
 
 /**

src/pcm/pcm_alaw.c

@@ -390,19 +390,19 @@ static void snd_pcm_alaw_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_alaw_ops = {
-	close: snd_pcm_plugin_close,
+	.close = snd_pcm_plugin_close,
-	info: snd_pcm_plugin_info,
+	.info = snd_pcm_plugin_info,
-	hw_refine: snd_pcm_alaw_hw_refine,
+	.hw_refine = snd_pcm_alaw_hw_refine,
-	hw_params: snd_pcm_alaw_hw_params,
+	.hw_params = snd_pcm_alaw_hw_params,
-	hw_free: snd_pcm_plugin_hw_free,
+	.hw_free = snd_pcm_plugin_hw_free,
-	sw_params: snd_pcm_plugin_sw_params,
+	.sw_params = snd_pcm_plugin_sw_params,
-	channel_info: snd_pcm_plugin_channel_info,
+	.channel_info = snd_pcm_plugin_channel_info,
-	dump: snd_pcm_alaw_dump,
+	.dump = snd_pcm_alaw_dump,
-	nonblock: snd_pcm_plugin_nonblock,
+	.nonblock = snd_pcm_plugin_nonblock,
-	async: snd_pcm_plugin_async,
+	.async = snd_pcm_plugin_async,
-	poll_revents: snd_pcm_plugin_poll_revents,
+	.poll_revents = snd_pcm_plugin_poll_revents,
-	mmap: snd_pcm_plugin_mmap,
+	.mmap = snd_pcm_plugin_mmap,
-	munmap: snd_pcm_plugin_munmap,
+	.munmap = snd_pcm_plugin_munmap,
 };
 
 /**

src/pcm/pcm_copy.c

@@ -153,19 +153,19 @@ static void snd_pcm_copy_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_copy_ops = {
-	close: snd_pcm_plugin_close,
+	.close = snd_pcm_plugin_close,
-	info: snd_pcm_plugin_info,
+	.info = snd_pcm_plugin_info,
-	hw_refine: snd_pcm_copy_hw_refine,
+	.hw_refine = snd_pcm_copy_hw_refine,
-	hw_params: snd_pcm_copy_hw_params,
+	.hw_params = snd_pcm_copy_hw_params,
-	hw_free: snd_pcm_plugin_hw_free,
+	.hw_free = snd_pcm_plugin_hw_free,
-	sw_params: snd_pcm_plugin_sw_params,
+	.sw_params = snd_pcm_plugin_sw_params,
-	channel_info: snd_pcm_plugin_channel_info,
+	.channel_info = snd_pcm_plugin_channel_info,
-	dump: snd_pcm_copy_dump,
+	.dump = snd_pcm_copy_dump,
-	nonblock: snd_pcm_plugin_nonblock,
+	.nonblock = snd_pcm_plugin_nonblock,
-	async: snd_pcm_plugin_async,
+	.async = snd_pcm_plugin_async,
-	poll_revents: snd_pcm_plugin_poll_revents,
+	.poll_revents = snd_pcm_plugin_poll_revents,
-	mmap: snd_pcm_plugin_mmap,
+	.mmap = snd_pcm_plugin_mmap,
-	munmap: snd_pcm_plugin_munmap,
+	.munmap = snd_pcm_plugin_munmap,
 };
 
 /**

src/pcm/pcm_dmix.c

@@ -832,41 +832,41 @@ static void snd_pcm_dmix_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_dmix_ops = {
-	close: snd_pcm_dmix_close,
+	.close = snd_pcm_dmix_close,
-	info: snd_pcm_dmix_info,
+	.info = snd_pcm_dmix_info,
-	hw_refine: snd_pcm_dmix_hw_refine,
+	.hw_refine = snd_pcm_dmix_hw_refine,
-	hw_params: snd_pcm_dmix_hw_params,
+	.hw_params = snd_pcm_dmix_hw_params,
-	hw_free: snd_pcm_dmix_hw_free,
+	.hw_free = snd_pcm_dmix_hw_free,
-	sw_params: snd_pcm_dmix_sw_params,
+	.sw_params = snd_pcm_dmix_sw_params,
-	channel_info: snd_pcm_dmix_channel_info,
+	.channel_info = snd_pcm_dmix_channel_info,
-	dump: snd_pcm_dmix_dump,
+	.dump = snd_pcm_dmix_dump,
-	nonblock: snd_pcm_dmix_nonblock,
+	.nonblock = snd_pcm_dmix_nonblock,
-	async: snd_pcm_dmix_async,
+	.async = snd_pcm_dmix_async,
-	poll_revents: snd_pcm_dmix_poll_revents,
+	.poll_revents = snd_pcm_dmix_poll_revents,
-	mmap: snd_pcm_dmix_mmap,
+	.mmap = snd_pcm_dmix_mmap,
-	munmap: snd_pcm_dmix_munmap,
+	.munmap = snd_pcm_dmix_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_dmix_fast_ops = {
-	status: snd_pcm_dmix_status,
+	.status = snd_pcm_dmix_status,
-	state: snd_pcm_dmix_state,
+	.state = snd_pcm_dmix_state,
-	hwsync: snd_pcm_dmix_hwsync,
+	.hwsync = snd_pcm_dmix_hwsync,
-	delay: snd_pcm_dmix_delay,
+	.delay = snd_pcm_dmix_delay,
-	prepare: snd_pcm_dmix_prepare,
+	.prepare = snd_pcm_dmix_prepare,
-	reset: snd_pcm_dmix_reset,
+	.reset = snd_pcm_dmix_reset,
-	start: snd_pcm_dmix_start,
+	.start = snd_pcm_dmix_start,
-	drop: snd_pcm_dmix_drop,
+	.drop = snd_pcm_dmix_drop,
-	drain: snd_pcm_dmix_drain,
+	.drain = snd_pcm_dmix_drain,
-	pause: snd_pcm_dmix_pause,
+	.pause = snd_pcm_dmix_pause,
-	rewind: snd_pcm_dmix_rewind,
+	.rewind = snd_pcm_dmix_rewind,
-	forward: snd_pcm_dmix_forward,
+	.forward = snd_pcm_dmix_forward,
-	resume: snd_pcm_dmix_resume,
+	.resume = snd_pcm_dmix_resume,
-	writei: snd_pcm_mmap_writei,
+	.writei = snd_pcm_mmap_writei,
-	writen: snd_pcm_mmap_writen,
+	.writen = snd_pcm_mmap_writen,
-	readi: snd_pcm_dmix_readi,
+	.readi = snd_pcm_dmix_readi,
-	readn: snd_pcm_dmix_readn,
+	.readn = snd_pcm_dmix_readn,
-	avail_update: snd_pcm_dmix_avail_update,
+	.avail_update = snd_pcm_dmix_avail_update,
-	mmap_commit: snd_pcm_dmix_mmap_commit,
+	.mmap_commit = snd_pcm_dmix_mmap_commit,
 };
 
 /**

src/pcm/pcm_dshare.c

@@ -622,41 +622,41 @@ static void snd_pcm_dshare_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_dshare_ops = {
-	close: snd_pcm_dshare_close,
+	.close = snd_pcm_dshare_close,
-	info: snd_pcm_dshare_info,
+	.info = snd_pcm_dshare_info,
-	hw_refine: snd_pcm_dshare_hw_refine,
+	.hw_refine = snd_pcm_dshare_hw_refine,
-	hw_params: snd_pcm_dshare_hw_params,
+	.hw_params = snd_pcm_dshare_hw_params,
-	hw_free: snd_pcm_dshare_hw_free,
+	.hw_free = snd_pcm_dshare_hw_free,
-	sw_params: snd_pcm_dshare_sw_params,
+	.sw_params = snd_pcm_dshare_sw_params,
-	channel_info: snd_pcm_dshare_channel_info,
+	.channel_info = snd_pcm_dshare_channel_info,
-	dump: snd_pcm_dshare_dump,
+	.dump = snd_pcm_dshare_dump,
-	nonblock: snd_pcm_dshare_nonblock,
+	.nonblock = snd_pcm_dshare_nonblock,
-	async: snd_pcm_dshare_async,
+	.async = snd_pcm_dshare_async,
-	poll_revents: snd_pcm_dshare_poll_revents,
+	.poll_revents = snd_pcm_dshare_poll_revents,
-	mmap: snd_pcm_dshare_mmap,
+	.mmap = snd_pcm_dshare_mmap,
-	munmap: snd_pcm_dshare_munmap,
+	.munmap = snd_pcm_dshare_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_dshare_fast_ops = {
-	status: snd_pcm_dshare_status,
+	.status = snd_pcm_dshare_status,
-	state: snd_pcm_dshare_state,
+	.state = snd_pcm_dshare_state,
-	hwsync: snd_pcm_dshare_hwsync,
+	.hwsync = snd_pcm_dshare_hwsync,
-	delay: snd_pcm_dshare_delay,
+	.delay = snd_pcm_dshare_delay,
-	prepare: snd_pcm_dshare_prepare,
+	.prepare = snd_pcm_dshare_prepare,
-	reset: snd_pcm_dshare_reset,
+	.reset = snd_pcm_dshare_reset,
-	start: snd_pcm_dshare_start,
+	.start = snd_pcm_dshare_start,
-	drop: snd_pcm_dshare_drop,
+	.drop = snd_pcm_dshare_drop,
-	drain: snd_pcm_dshare_drain,
+	.drain = snd_pcm_dshare_drain,
-	pause: snd_pcm_dshare_pause,
+	.pause = snd_pcm_dshare_pause,
-	rewind: snd_pcm_dshare_rewind,
+	.rewind = snd_pcm_dshare_rewind,
-	forward: snd_pcm_dshare_forward,
+	.forward = snd_pcm_dshare_forward,
-	resume: snd_pcm_dshare_resume,
+	.resume = snd_pcm_dshare_resume,
-	writei: snd_pcm_mmap_writei,
+	.writei = snd_pcm_mmap_writei,
-	writen: snd_pcm_mmap_writen,
+	.writen = snd_pcm_mmap_writen,
-	readi: snd_pcm_dshare_readi,
+	.readi = snd_pcm_dshare_readi,
-	readn: snd_pcm_dshare_readn,
+	.readn = snd_pcm_dshare_readn,
-	avail_update: snd_pcm_dshare_avail_update,
+	.avail_update = snd_pcm_dshare_avail_update,
-	mmap_commit: snd_pcm_dshare_mmap_commit,
+	.mmap_commit = snd_pcm_dshare_mmap_commit,
 };
 
 /**

src/pcm/pcm_dsnoop.c

@@ -590,41 +590,41 @@ static void snd_pcm_dsnoop_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_dsnoop_ops = {
-	close: snd_pcm_dsnoop_close,
+	.close = snd_pcm_dsnoop_close,
-	info: snd_pcm_dsnoop_info,
+	.info = snd_pcm_dsnoop_info,
-	hw_refine: snd_pcm_dsnoop_hw_refine,
+	.hw_refine = snd_pcm_dsnoop_hw_refine,
-	hw_params: snd_pcm_dsnoop_hw_params,
+	.hw_params = snd_pcm_dsnoop_hw_params,
-	hw_free: snd_pcm_dsnoop_hw_free,
+	.hw_free = snd_pcm_dsnoop_hw_free,
-	sw_params: snd_pcm_dsnoop_sw_params,
+	.sw_params = snd_pcm_dsnoop_sw_params,
-	channel_info: snd_pcm_dsnoop_channel_info,
+	.channel_info = snd_pcm_dsnoop_channel_info,
-	dump: snd_pcm_dsnoop_dump,
+	.dump = snd_pcm_dsnoop_dump,
-	nonblock: snd_pcm_dsnoop_nonblock,
+	.nonblock = snd_pcm_dsnoop_nonblock,
-	async: snd_pcm_dsnoop_async,
+	.async = snd_pcm_dsnoop_async,
-	poll_revents: snd_pcm_dsnoop_poll_revents,
+	.poll_revents = snd_pcm_dsnoop_poll_revents,
-	mmap: snd_pcm_dsnoop_mmap,
+	.mmap = snd_pcm_dsnoop_mmap,
-	munmap: snd_pcm_dsnoop_munmap,
+	.munmap = snd_pcm_dsnoop_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_dsnoop_fast_ops = {
-	status: snd_pcm_dsnoop_status,
+	.status = snd_pcm_dsnoop_status,
-	state: snd_pcm_dsnoop_state,
+	.state = snd_pcm_dsnoop_state,
-	hwsync: snd_pcm_dsnoop_hwsync,
+	.hwsync = snd_pcm_dsnoop_hwsync,
-	delay: snd_pcm_dsnoop_delay,
+	.delay = snd_pcm_dsnoop_delay,
-	prepare: snd_pcm_dsnoop_prepare,
+	.prepare = snd_pcm_dsnoop_prepare,
-	reset: snd_pcm_dsnoop_reset,
+	.reset = snd_pcm_dsnoop_reset,
-	start: snd_pcm_dsnoop_start,
+	.start = snd_pcm_dsnoop_start,
-	drop: snd_pcm_dsnoop_drop,
+	.drop = snd_pcm_dsnoop_drop,
-	drain: snd_pcm_dsnoop_drain,
+	.drain = snd_pcm_dsnoop_drain,
-	pause: snd_pcm_dsnoop_pause,
+	.pause = snd_pcm_dsnoop_pause,
-	rewind: snd_pcm_dsnoop_rewind,
+	.rewind = snd_pcm_dsnoop_rewind,
-	forward: snd_pcm_dsnoop_forward,
+	.forward = snd_pcm_dsnoop_forward,
-	resume: snd_pcm_dsnoop_resume,
+	.resume = snd_pcm_dsnoop_resume,
-	writei: snd_pcm_dsnoop_writei,
+	.writei = snd_pcm_dsnoop_writei,
-	writen: snd_pcm_dsnoop_writen,
+	.writen = snd_pcm_dsnoop_writen,
-	readi: snd_pcm_mmap_readi,
+	.readi = snd_pcm_mmap_readi,
-	readn: snd_pcm_mmap_readn,
+	.readn = snd_pcm_mmap_readn,
-	avail_update: snd_pcm_dsnoop_avail_update,
+	.avail_update = snd_pcm_dsnoop_avail_update,
-	mmap_commit: snd_pcm_dsnoop_mmap_commit,
+	.mmap_commit = snd_pcm_dsnoop_mmap_commit,
 };
 
 /**

src/pcm/pcm_file.c

@@ -413,40 +413,40 @@ static void snd_pcm_file_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_file_ops = {
-	close: snd_pcm_file_close,
+	.close = snd_pcm_file_close,
-	info: snd_pcm_file_info,
+	.info = snd_pcm_file_info,
-	hw_refine: snd_pcm_file_hw_refine,
+	.hw_refine = snd_pcm_file_hw_refine,
-	hw_params: snd_pcm_file_hw_params,
+	.hw_params = snd_pcm_file_hw_params,
-	hw_free: snd_pcm_file_hw_free,
+	.hw_free = snd_pcm_file_hw_free,
-	sw_params: snd_pcm_file_sw_params,
+	.sw_params = snd_pcm_file_sw_params,
-	channel_info: snd_pcm_file_channel_info,
+	.channel_info = snd_pcm_file_channel_info,
-	dump: snd_pcm_file_dump,
+	.dump = snd_pcm_file_dump,
-	nonblock: snd_pcm_file_nonblock,
+	.nonblock = snd_pcm_file_nonblock,
-	async: snd_pcm_file_async,
+	.async = snd_pcm_file_async,
-	mmap: snd_pcm_file_mmap,
+	.mmap = snd_pcm_file_mmap,
-	munmap: snd_pcm_file_munmap,
+	.munmap = snd_pcm_file_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_file_fast_ops = {
-	status: snd_pcm_file_status,
+	.status = snd_pcm_file_status,
-	state: snd_pcm_file_state,
+	.state = snd_pcm_file_state,
-	hwsync: snd_pcm_file_hwsync,
+	.hwsync = snd_pcm_file_hwsync,
-	delay: snd_pcm_file_delay,
+	.delay = snd_pcm_file_delay,
-	prepare: snd_pcm_file_prepare,
+	.prepare = snd_pcm_file_prepare,
-	reset: snd_pcm_file_reset,
+	.reset = snd_pcm_file_reset,
-	start: snd_pcm_file_start,
+	.start = snd_pcm_file_start,
-	drop: snd_pcm_file_drop,
+	.drop = snd_pcm_file_drop,
-	drain: snd_pcm_file_drain,
+	.drain = snd_pcm_file_drain,
-	pause: snd_pcm_file_pause,
+	.pause = snd_pcm_file_pause,
-	rewind: snd_pcm_file_rewind,
+	.rewind = snd_pcm_file_rewind,
-	forward: snd_pcm_file_forward,
+	.forward = snd_pcm_file_forward,
-	resume: snd_pcm_file_resume,
+	.resume = snd_pcm_file_resume,
-	writei: snd_pcm_file_writei,
+	.writei = snd_pcm_file_writei,
-	writen: snd_pcm_file_writen,
+	.writen = snd_pcm_file_writen,
-	readi: snd_pcm_file_readi,
+	.readi = snd_pcm_file_readi,
-	readn: snd_pcm_file_readn,
+	.readn = snd_pcm_file_readn,
-	avail_update: snd_pcm_file_avail_update,
+	.avail_update = snd_pcm_file_avail_update,
-	mmap_commit: snd_pcm_file_mmap_commit,
+	.mmap_commit = snd_pcm_file_mmap_commit,
 };
 
 /**

src/pcm/pcm_hooks.c

@@ -287,40 +287,40 @@ static void snd_pcm_hooks_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_hooks_ops = {
-	close: snd_pcm_hooks_close,
+	.close = snd_pcm_hooks_close,
-	info: snd_pcm_hooks_info,
+	.info = snd_pcm_hooks_info,
-	hw_refine: snd_pcm_hooks_hw_refine,
+	.hw_refine = snd_pcm_hooks_hw_refine,
-	hw_params: snd_pcm_hooks_hw_params,
+	.hw_params = snd_pcm_hooks_hw_params,
-	hw_free: snd_pcm_hooks_hw_free,
+	.hw_free = snd_pcm_hooks_hw_free,
-	sw_params: snd_pcm_hooks_sw_params,
+	.sw_params = snd_pcm_hooks_sw_params,
-	channel_info: snd_pcm_hooks_channel_info,
+	.channel_info = snd_pcm_hooks_channel_info,
-	dump: snd_pcm_hooks_dump,
+	.dump = snd_pcm_hooks_dump,
-	nonblock: snd_pcm_hooks_nonblock,
+	.nonblock = snd_pcm_hooks_nonblock,
-	async: snd_pcm_hooks_async,
+	.async = snd_pcm_hooks_async,
-	mmap: snd_pcm_hooks_mmap,
+	.mmap = snd_pcm_hooks_mmap,
-	munmap: snd_pcm_hooks_munmap,
+	.munmap = snd_pcm_hooks_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_hooks_fast_ops = {
-	status: snd_pcm_hooks_status,
+	.status = snd_pcm_hooks_status,
-	state: snd_pcm_hooks_state,
+	.state = snd_pcm_hooks_state,
-	hwsync: snd_pcm_hooks_hwsync,
+	.hwsync = snd_pcm_hooks_hwsync,
-	delay: snd_pcm_hooks_delay,
+	.delay = snd_pcm_hooks_delay,
-	prepare: snd_pcm_hooks_prepare,
+	.prepare = snd_pcm_hooks_prepare,
-	reset: snd_pcm_hooks_reset,
+	.reset = snd_pcm_hooks_reset,
-	start: snd_pcm_hooks_start,
+	.start = snd_pcm_hooks_start,
-	drop: snd_pcm_hooks_drop,
+	.drop = snd_pcm_hooks_drop,
-	drain: snd_pcm_hooks_drain,
+	.drain = snd_pcm_hooks_drain,
-	pause: snd_pcm_hooks_pause,
+	.pause = snd_pcm_hooks_pause,
-	rewind: snd_pcm_hooks_rewind,
+	.rewind = snd_pcm_hooks_rewind,
-	forward: snd_pcm_hooks_forward,
+	.forward = snd_pcm_hooks_forward,
-	resume: snd_pcm_hooks_resume,
+	.resume = snd_pcm_hooks_resume,
-	writei: snd_pcm_hooks_writei,
+	.writei = snd_pcm_hooks_writei,
-	writen: snd_pcm_hooks_writen,
+	.writen = snd_pcm_hooks_writen,
-	readi: snd_pcm_hooks_readi,
+	.readi = snd_pcm_hooks_readi,
-	readn: snd_pcm_hooks_readn,
+	.readn = snd_pcm_hooks_readn,
-	avail_update: snd_pcm_hooks_avail_update,
+	.avail_update = snd_pcm_hooks_avail_update,
-	mmap_commit: snd_pcm_hooks_mmap_commit,
+	.mmap_commit = snd_pcm_hooks_mmap_commit,
 };
 
 /**

src/pcm/pcm_hw.c

@@ -843,40 +843,40 @@ static void snd_pcm_hw_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_hw_ops = {
-	close: snd_pcm_hw_close,
+	.close = snd_pcm_hw_close,
-	info: snd_pcm_hw_info,
+	.info = snd_pcm_hw_info,
-	hw_refine: snd_pcm_hw_hw_refine,
+	.hw_refine = snd_pcm_hw_hw_refine,
-	hw_params: snd_pcm_hw_hw_params,
+	.hw_params = snd_pcm_hw_hw_params,
-	hw_free: snd_pcm_hw_hw_free,
+	.hw_free = snd_pcm_hw_hw_free,
-	sw_params: snd_pcm_hw_sw_params,
+	.sw_params = snd_pcm_hw_sw_params,
-	channel_info: snd_pcm_hw_channel_info,
+	.channel_info = snd_pcm_hw_channel_info,
-	dump: snd_pcm_hw_dump,
+	.dump = snd_pcm_hw_dump,
-	nonblock: snd_pcm_hw_nonblock,
+	.nonblock = snd_pcm_hw_nonblock,
-	async: snd_pcm_hw_async,
+	.async = snd_pcm_hw_async,
-	mmap: snd_pcm_hw_mmap,
+	.mmap = snd_pcm_hw_mmap,
-	munmap: snd_pcm_hw_munmap,
+	.munmap = snd_pcm_hw_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_hw_fast_ops = {
-	status: snd_pcm_hw_status,
+	.status = snd_pcm_hw_status,
-	state: snd_pcm_hw_state,
+	.state = snd_pcm_hw_state,
-	hwsync: snd_pcm_hw_hwsync,
+	.hwsync = snd_pcm_hw_hwsync,
-	delay: snd_pcm_hw_delay,
+	.delay = snd_pcm_hw_delay,
-	prepare: snd_pcm_hw_prepare,
+	.prepare = snd_pcm_hw_prepare,
-	reset: snd_pcm_hw_reset,
+	.reset = snd_pcm_hw_reset,
-	start: snd_pcm_hw_start,
+	.start = snd_pcm_hw_start,
-	drop: snd_pcm_hw_drop,
+	.drop = snd_pcm_hw_drop,
-	drain: snd_pcm_hw_drain,
+	.drain = snd_pcm_hw_drain,
-	pause: snd_pcm_hw_pause,
+	.pause = snd_pcm_hw_pause,
-	rewind: snd_pcm_hw_rewind,
+	.rewind = snd_pcm_hw_rewind,
-	forward: snd_pcm_hw_forward,
+	.forward = snd_pcm_hw_forward,
-	resume: snd_pcm_hw_resume,
+	.resume = snd_pcm_hw_resume,
-	writei: snd_pcm_hw_writei,
+	.writei = snd_pcm_hw_writei,
-	writen: snd_pcm_hw_writen,
+	.writen = snd_pcm_hw_writen,
-	readi: snd_pcm_hw_readi,
+	.readi = snd_pcm_hw_readi,
-	readn: snd_pcm_hw_readn,
+	.readn = snd_pcm_hw_readn,
-	avail_update: snd_pcm_hw_avail_update,
+	.avail_update = snd_pcm_hw_avail_update,
-	mmap_commit: snd_pcm_hw_mmap_commit,
+	.mmap_commit = snd_pcm_hw_mmap_commit,
 };
 
 /**

src/pcm/pcm_ladspa.c

@@ -697,19 +697,19 @@ static void snd_pcm_ladspa_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_ladspa_ops = {
-	close: snd_pcm_ladspa_close,
+	.close = snd_pcm_ladspa_close,
-	info: snd_pcm_plugin_info,
+	.info = snd_pcm_plugin_info,
-	hw_refine: snd_pcm_ladspa_hw_refine,
+	.hw_refine = snd_pcm_ladspa_hw_refine,
-	hw_params: snd_pcm_ladspa_hw_params,
+	.hw_params = snd_pcm_ladspa_hw_params,
-	hw_free: snd_pcm_ladspa_hw_free,
+	.hw_free = snd_pcm_ladspa_hw_free,
-	sw_params: snd_pcm_plugin_sw_params,
+	.sw_params = snd_pcm_plugin_sw_params,
-	channel_info: snd_pcm_plugin_channel_info,
+	.channel_info = snd_pcm_plugin_channel_info,
-	dump: snd_pcm_ladspa_dump,
+	.dump = snd_pcm_ladspa_dump,
-	nonblock: snd_pcm_plugin_nonblock,
+	.nonblock = snd_pcm_plugin_nonblock,
-	async: snd_pcm_plugin_async,
+	.async = snd_pcm_plugin_async,
-	poll_revents: snd_pcm_plugin_poll_revents,
+	.poll_revents = snd_pcm_plugin_poll_revents,
-	mmap: snd_pcm_plugin_mmap,
+	.mmap = snd_pcm_plugin_mmap,
-	munmap: snd_pcm_plugin_munmap,
+	.munmap = snd_pcm_plugin_munmap,
 };
 
 static int snd_pcm_ladspa_check_file(snd_pcm_ladspa_plugin_t * const plugin,

src/pcm/pcm_lfloat.c

@@ -350,19 +350,19 @@ static void snd_pcm_lfloat_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_lfloat_ops = {
-	close: snd_pcm_plugin_close,
+	.close = snd_pcm_plugin_close,
-	info: snd_pcm_plugin_info,
+	.info = snd_pcm_plugin_info,
-	hw_refine: snd_pcm_lfloat_hw_refine,
+	.hw_refine = snd_pcm_lfloat_hw_refine,
-	hw_params: snd_pcm_lfloat_hw_params,
+	.hw_params = snd_pcm_lfloat_hw_params,
-	hw_free: snd_pcm_plugin_hw_free,
+	.hw_free = snd_pcm_plugin_hw_free,
-	sw_params: snd_pcm_plugin_sw_params,
+	.sw_params = snd_pcm_plugin_sw_params,
-	channel_info: snd_pcm_plugin_channel_info,
+	.channel_info = snd_pcm_plugin_channel_info,
-	dump: snd_pcm_lfloat_dump,
+	.dump = snd_pcm_lfloat_dump,
-	nonblock: snd_pcm_plugin_nonblock,
+	.nonblock = snd_pcm_plugin_nonblock,
-	async: snd_pcm_plugin_async,
+	.async = snd_pcm_plugin_async,
-	poll_revents: snd_pcm_plugin_poll_revents,
+	.poll_revents = snd_pcm_plugin_poll_revents,
-	mmap: snd_pcm_plugin_mmap,
+	.mmap = snd_pcm_plugin_mmap,
-	munmap: snd_pcm_plugin_munmap,
+	.munmap = snd_pcm_plugin_munmap,
 };
 
 /**

src/pcm/pcm_linear.c

@@ -406,19 +406,19 @@ static void snd_pcm_linear_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_linear_ops = {
-	close: snd_pcm_plugin_close,
+	.close = snd_pcm_plugin_close,
-	info: snd_pcm_plugin_info,
+	.info = snd_pcm_plugin_info,
-	hw_refine: snd_pcm_linear_hw_refine,
+	.hw_refine = snd_pcm_linear_hw_refine,
-	hw_params: snd_pcm_linear_hw_params,
+	.hw_params = snd_pcm_linear_hw_params,
-	hw_free: snd_pcm_plugin_hw_free,
+	.hw_free = snd_pcm_plugin_hw_free,
-	sw_params: snd_pcm_plugin_sw_params,
+	.sw_params = snd_pcm_plugin_sw_params,
-	channel_info: snd_pcm_plugin_channel_info,
+	.channel_info = snd_pcm_plugin_channel_info,
-	dump: snd_pcm_linear_dump,
+	.dump = snd_pcm_linear_dump,
-	nonblock: snd_pcm_plugin_nonblock,
+	.nonblock = snd_pcm_plugin_nonblock,
-	async: snd_pcm_plugin_async,
+	.async = snd_pcm_plugin_async,
-	poll_revents: snd_pcm_plugin_poll_revents,
+	.poll_revents = snd_pcm_plugin_poll_revents,
-	mmap: snd_pcm_plugin_mmap,
+	.mmap = snd_pcm_plugin_mmap,
-	munmap: snd_pcm_plugin_munmap,
+	.munmap = snd_pcm_plugin_munmap,
 };
 
 

src/pcm/pcm_meter.c

@@ -591,40 +591,40 @@ static void snd_pcm_meter_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_meter_ops = {
-	close: snd_pcm_meter_close,
+	.close = snd_pcm_meter_close,
-	info: snd_pcm_meter_info,
+	.info = snd_pcm_meter_info,
-	hw_refine: snd_pcm_meter_hw_refine,
+	.hw_refine = snd_pcm_meter_hw_refine,
-	hw_params: snd_pcm_meter_hw_params,
+	.hw_params = snd_pcm_meter_hw_params,
-	hw_free: snd_pcm_meter_hw_free,
+	.hw_free = snd_pcm_meter_hw_free,
-	sw_params: snd_pcm_meter_sw_params,
+	.sw_params = snd_pcm_meter_sw_params,
-	channel_info: snd_pcm_meter_channel_info,
+	.channel_info = snd_pcm_meter_channel_info,
-	dump: snd_pcm_meter_dump,
+	.dump = snd_pcm_meter_dump,
-	nonblock: snd_pcm_meter_nonblock,
+	.nonblock = snd_pcm_meter_nonblock,
-	async: snd_pcm_meter_async,
+	.async = snd_pcm_meter_async,
-	mmap: snd_pcm_meter_mmap,
+	.mmap = snd_pcm_meter_mmap,
-	munmap: snd_pcm_meter_munmap,
+	.munmap = snd_pcm_meter_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_meter_fast_ops = {
-	status: snd_pcm_meter_status,
+	.status = snd_pcm_meter_status,
-	state: snd_pcm_meter_state,
+	.state = snd_pcm_meter_state,
-	hwsync: snd_pcm_meter_hwsync,
+	.hwsync = snd_pcm_meter_hwsync,
-	delay: snd_pcm_meter_delay,
+	.delay = snd_pcm_meter_delay,
-	prepare: snd_pcm_meter_prepare,
+	.prepare = snd_pcm_meter_prepare,
-	reset: snd_pcm_meter_reset,
+	.reset = snd_pcm_meter_reset,
-	start: snd_pcm_meter_start,
+	.start = snd_pcm_meter_start,
-	drop: snd_pcm_meter_drop,
+	.drop = snd_pcm_meter_drop,
-	drain: snd_pcm_meter_drain,
+	.drain = snd_pcm_meter_drain,
-	pause: snd_pcm_meter_pause,
+	.pause = snd_pcm_meter_pause,
-	rewind: snd_pcm_meter_rewind,
+	.rewind = snd_pcm_meter_rewind,
-	forward: snd_pcm_meter_forward,
+	.forward = snd_pcm_meter_forward,
-	resume: snd_pcm_meter_resume,
+	.resume = snd_pcm_meter_resume,
-	writei: snd_pcm_mmap_writei,
+	.writei = snd_pcm_mmap_writei,
-	writen: snd_pcm_mmap_writen,
+	.writen = snd_pcm_mmap_writen,
-	readi: snd_pcm_mmap_readi,
+	.readi = snd_pcm_mmap_readi,
-	readn: snd_pcm_mmap_readn,
+	.readn = snd_pcm_mmap_readn,
-	avail_update: snd_pcm_meter_avail_update,
+	.avail_update = snd_pcm_meter_avail_update,
-	mmap_commit: snd_pcm_meter_mmap_commit,
+	.mmap_commit = snd_pcm_meter_mmap_commit,
 };
 
 /**
@@ -1220,13 +1220,13 @@ static void s16_reset(snd_pcm_scope_t *scope)
 }
 
 snd_pcm_scope_ops_t s16_ops = {
-	enable: s16_enable,
+	.enable = s16_enable,
-	disable: s16_disable,
+	.disable = s16_disable,
-	close: s16_close,
+	.close = s16_close,
-	start: s16_start,
+	.start = s16_start,
-	stop: s16_stop,
+	.stop = s16_stop,
-	update: s16_update,
+	.update = s16_update,
-	reset: s16_reset,
+	.reset = s16_reset,
 };
 
 #endif

src/pcm/pcm_mulaw.c

@@ -405,19 +405,19 @@ static void snd_pcm_mulaw_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_mulaw_ops = {
-	close: snd_pcm_plugin_close,
+	.close = snd_pcm_plugin_close,
-	info: snd_pcm_plugin_info,
+	.info = snd_pcm_plugin_info,
-	hw_refine: snd_pcm_mulaw_hw_refine,
+	.hw_refine = snd_pcm_mulaw_hw_refine,
-	hw_params: snd_pcm_mulaw_hw_params,
+	.hw_params = snd_pcm_mulaw_hw_params,
-	hw_free: snd_pcm_plugin_hw_free,
+	.hw_free = snd_pcm_plugin_hw_free,
-	sw_params: snd_pcm_plugin_sw_params,
+	.sw_params = snd_pcm_plugin_sw_params,
-	channel_info: snd_pcm_plugin_channel_info,
+	.channel_info = snd_pcm_plugin_channel_info,
-	dump: snd_pcm_mulaw_dump,
+	.dump = snd_pcm_mulaw_dump,
-	nonblock: snd_pcm_plugin_nonblock,
+	.nonblock = snd_pcm_plugin_nonblock,
-	async: snd_pcm_plugin_async,
+	.async = snd_pcm_plugin_async,
-	poll_revents: snd_pcm_plugin_poll_revents,
+	.poll_revents = snd_pcm_plugin_poll_revents,
-	mmap: snd_pcm_plugin_mmap,
+	.mmap = snd_pcm_plugin_mmap,
-	munmap: snd_pcm_plugin_munmap,
+	.munmap = snd_pcm_plugin_munmap,
 };
 
 /**

src/pcm/pcm_multi.c

@@ -614,40 +614,40 @@ static void snd_pcm_multi_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_multi_ops = {
-	close: snd_pcm_multi_close,
+	.close = snd_pcm_multi_close,
-	info: snd_pcm_multi_info,
+	.info = snd_pcm_multi_info,
-	hw_refine: snd_pcm_multi_hw_refine,
+	.hw_refine = snd_pcm_multi_hw_refine,
-	hw_params: snd_pcm_multi_hw_params,
+	.hw_params = snd_pcm_multi_hw_params,
-	hw_free: snd_pcm_multi_hw_free,
+	.hw_free = snd_pcm_multi_hw_free,
-	sw_params: snd_pcm_multi_sw_params,
+	.sw_params = snd_pcm_multi_sw_params,
-	channel_info: snd_pcm_multi_channel_info,
+	.channel_info = snd_pcm_multi_channel_info,
-	dump: snd_pcm_multi_dump,
+	.dump = snd_pcm_multi_dump,
-	nonblock: snd_pcm_multi_nonblock,
+	.nonblock = snd_pcm_multi_nonblock,
-	async: snd_pcm_multi_async,
+	.async = snd_pcm_multi_async,
-	mmap: snd_pcm_multi_mmap,
+	.mmap = snd_pcm_multi_mmap,
-	munmap: snd_pcm_multi_munmap,
+	.munmap = snd_pcm_multi_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_multi_fast_ops = {
-	status: snd_pcm_multi_status,
+	.status = snd_pcm_multi_status,
-	state: snd_pcm_multi_state,
+	.state = snd_pcm_multi_state,
-	hwsync: snd_pcm_multi_hwsync,
+	.hwsync = snd_pcm_multi_hwsync,
-	delay: snd_pcm_multi_delay,
+	.delay = snd_pcm_multi_delay,
-	prepare: snd_pcm_multi_prepare,
+	.prepare = snd_pcm_multi_prepare,
-	reset: snd_pcm_multi_reset,
+	.reset = snd_pcm_multi_reset,
-	start: snd_pcm_multi_start,
+	.start = snd_pcm_multi_start,
-	drop: snd_pcm_multi_drop,
+	.drop = snd_pcm_multi_drop,
-	drain: snd_pcm_multi_drain,
+	.drain = snd_pcm_multi_drain,
-	pause: snd_pcm_multi_pause,
+	.pause = snd_pcm_multi_pause,
-	writei: snd_pcm_mmap_writei,
+	.writei = snd_pcm_mmap_writei,
-	writen: snd_pcm_mmap_writen,
+	.writen = snd_pcm_mmap_writen,
-	readi: snd_pcm_mmap_readi,
+	.readi = snd_pcm_mmap_readi,
-	readn: snd_pcm_mmap_readn,
+	.readn = snd_pcm_mmap_readn,
-	rewind: snd_pcm_multi_rewind,
+	.rewind = snd_pcm_multi_rewind,
-	forward: snd_pcm_multi_forward,
+	.forward = snd_pcm_multi_forward,
-	resume: snd_pcm_multi_resume,
+	.resume = snd_pcm_multi_resume,
-	avail_update: snd_pcm_multi_avail_update,
+	.avail_update = snd_pcm_multi_avail_update,
-	mmap_commit: snd_pcm_multi_mmap_commit,
+	.mmap_commit = snd_pcm_multi_mmap_commit,
 };
 
 /**

src/pcm/pcm_null.c

@@ -312,40 +312,40 @@ static void snd_pcm_null_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_null_ops = {
-	close: snd_pcm_null_close,
+	.close = snd_pcm_null_close,
-	info: snd_pcm_null_info,
+	.info = snd_pcm_null_info,
-	hw_refine: snd_pcm_null_hw_refine,
+	.hw_refine = snd_pcm_null_hw_refine,
-	hw_params: snd_pcm_null_hw_params,
+	.hw_params = snd_pcm_null_hw_params,
-	hw_free: snd_pcm_null_hw_free,
+	.hw_free = snd_pcm_null_hw_free,
-	sw_params: snd_pcm_null_sw_params,
+	.sw_params = snd_pcm_null_sw_params,
-	channel_info: snd_pcm_null_channel_info,
+	.channel_info = snd_pcm_null_channel_info,
-	dump: snd_pcm_null_dump,
+	.dump = snd_pcm_null_dump,
-	nonblock: snd_pcm_null_nonblock,
+	.nonblock = snd_pcm_null_nonblock,
-	async: snd_pcm_null_async,
+	.async = snd_pcm_null_async,
-	mmap: snd_pcm_null_mmap,
+	.mmap = snd_pcm_null_mmap,
-	munmap: snd_pcm_null_munmap,
+	.munmap = snd_pcm_null_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_null_fast_ops = {
-	status: snd_pcm_null_status,
+	.status = snd_pcm_null_status,
-	state: snd_pcm_null_state,
+	.state = snd_pcm_null_state,
-	hwsync: snd_pcm_null_hwsync,
+	.hwsync = snd_pcm_null_hwsync,
-	delay: snd_pcm_null_delay,
+	.delay = snd_pcm_null_delay,
-	prepare: snd_pcm_null_prepare,
+	.prepare = snd_pcm_null_prepare,
-	reset: snd_pcm_null_reset,
+	.reset = snd_pcm_null_reset,
-	start: snd_pcm_null_start,
+	.start = snd_pcm_null_start,
-	drop: snd_pcm_null_drop,
+	.drop = snd_pcm_null_drop,
-	drain: snd_pcm_null_drain,
+	.drain = snd_pcm_null_drain,
-	pause: snd_pcm_null_pause,
+	.pause = snd_pcm_null_pause,
-	rewind: snd_pcm_null_rewind,
+	.rewind = snd_pcm_null_rewind,
-	forward: snd_pcm_null_forward,
+	.forward = snd_pcm_null_forward,
-	resume: snd_pcm_null_resume,
+	.resume = snd_pcm_null_resume,
-	writei: snd_pcm_null_writei,
+	.writei = snd_pcm_null_writei,
-	writen: snd_pcm_null_writen,
+	.writen = snd_pcm_null_writen,
-	readi: snd_pcm_null_readi,
+	.readi = snd_pcm_null_readi,
-	readn: snd_pcm_null_readn,
+	.readn = snd_pcm_null_readn,
-	avail_update: snd_pcm_null_avail_update,
+	.avail_update = snd_pcm_null_avail_update,
-	mmap_commit: snd_pcm_null_mmap_commit,
+	.mmap_commit = snd_pcm_null_mmap_commit,
 };
 
 /**

src/pcm/pcm_params.c

@@ -1731,143 +1731,143 @@ static int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params,
 
 static snd_pcm_hw_rule_t refine_rules[] = {
 	{
-		var: SND_PCM_HW_PARAM_FORMAT,
+		.var = SND_PCM_HW_PARAM_FORMAT,
-		func: snd_pcm_hw_rule_format,
+		.func = snd_pcm_hw_rule_format,
-		deps: { SND_PCM_HW_PARAM_SAMPLE_BITS, -1 },
+		.deps = { SND_PCM_HW_PARAM_SAMPLE_BITS, -1 },
-		private_data: 0,
+		.private_data = 0,
 	},
 	{
-		var: SND_PCM_HW_PARAM_SAMPLE_BITS, 
+		.var = SND_PCM_HW_PARAM_SAMPLE_BITS, 
-		func: snd_pcm_hw_rule_sample_bits,
+		.func = snd_pcm_hw_rule_sample_bits,
-		deps: { SND_PCM_HW_PARAM_FORMAT, 
+		.deps = { SND_PCM_HW_PARAM_FORMAT, 
 			SND_PCM_HW_PARAM_SAMPLE_BITS, -1 },
-		private_data: 0,
+		.private_data = 0,
 	},
 	{
-		var: SND_PCM_HW_PARAM_SAMPLE_BITS, 
+		.var = SND_PCM_HW_PARAM_SAMPLE_BITS, 
-		func: snd_pcm_hw_rule_div,
+		.func = snd_pcm_hw_rule_div,
-		deps: { SND_PCM_HW_PARAM_FRAME_BITS,
+		.deps = { SND_PCM_HW_PARAM_FRAME_BITS,
 			SND_PCM_HW_PARAM_CHANNELS, -1 },
-		private_data: 0,
+		.private_data = 0,
 	},
 	{
-		var: SND_PCM_HW_PARAM_FRAME_BITS, 
+		.var = SND_PCM_HW_PARAM_FRAME_BITS, 
-		func: snd_pcm_hw_rule_mul,
+		.func = snd_pcm_hw_rule_mul,
-		deps: { SND_PCM_HW_PARAM_SAMPLE_BITS,
+		.deps = { SND_PCM_HW_PARAM_SAMPLE_BITS,
 			SND_PCM_HW_PARAM_CHANNELS, -1 },
-		private_data: 0,
+		.private_data = 0,
 	},
 	{
-		var: SND_PCM_HW_PARAM_FRAME_BITS, 
+		.var = SND_PCM_HW_PARAM_FRAME_BITS, 
-		func: snd_pcm_hw_rule_mulkdiv,
+		.func = snd_pcm_hw_rule_mulkdiv,
-		deps: { SND_PCM_HW_PARAM_PERIOD_BYTES,
+		.deps = { SND_PCM_HW_PARAM_PERIOD_BYTES,
 			SND_PCM_HW_PARAM_PERIOD_SIZE, -1 },
-		private_data: (void*) 8,
+		.private_data = (void*) 8,
 	},
 	{
-		var: SND_PCM_HW_PARAM_FRAME_BITS, 
+		.var = SND_PCM_HW_PARAM_FRAME_BITS, 
-		func: snd_pcm_hw_rule_mulkdiv,
+		.func = snd_pcm_hw_rule_mulkdiv,
-		deps: { SND_PCM_HW_PARAM_BUFFER_BYTES,
+		.deps = { SND_PCM_HW_PARAM_BUFFER_BYTES,
 			SND_PCM_HW_PARAM_BUFFER_SIZE, -1 },
-		private_data: (void*) 8,
+		.private_data = (void*) 8,
 	},
 	{
-		var: SND_PCM_HW_PARAM_CHANNELS, 
+		.var = SND_PCM_HW_PARAM_CHANNELS, 
-		func: snd_pcm_hw_rule_div,
+		.func = snd_pcm_hw_rule_div,
-		deps: { SND_PCM_HW_PARAM_FRAME_BITS,
+		.deps = { SND_PCM_HW_PARAM_FRAME_BITS,
 			SND_PCM_HW_PARAM_SAMPLE_BITS, -1 },
-		private_data: 0,
+		.private_data = 0,
 	},
 	{
-		var: SND_PCM_HW_PARAM_RATE, 
+		.var = SND_PCM_HW_PARAM_RATE, 
-		func: snd_pcm_hw_rule_mulkdiv,
+		.func = snd_pcm_hw_rule_mulkdiv,
-		deps: { SND_PCM_HW_PARAM_PERIOD_SIZE,
+		.deps = { SND_PCM_HW_PARAM_PERIOD_SIZE,
 			SND_PCM_HW_PARAM_PERIOD_TIME, -1 },
-		private_data: (void*) 1000000,
+		.private_data = (void*) 1000000,
 	},
 	{
-		var: SND_PCM_HW_PARAM_RATE, 
+		.var = SND_PCM_HW_PARAM_RATE, 
-		func: snd_pcm_hw_rule_mulkdiv,
+		.func = snd_pcm_hw_rule_mulkdiv,
-		deps: { SND_PCM_HW_PARAM_BUFFER_SIZE,
+		.deps = { SND_PCM_HW_PARAM_BUFFER_SIZE,
 			SND_PCM_HW_PARAM_BUFFER_TIME, -1 },
-		private_data: (void*) 1000000,
+		.private_data = (void*) 1000000,
 	},
 	{
-		var: SND_PCM_HW_PARAM_PERIODS, 
+		.var = SND_PCM_HW_PARAM_PERIODS, 
-		func: snd_pcm_hw_rule_div,
+		.func = snd_pcm_hw_rule_div,
-		deps: { SND_PCM_HW_PARAM_BUFFER_SIZE,
+		.deps = { SND_PCM_HW_PARAM_BUFFER_SIZE,
 			SND_PCM_HW_PARAM_PERIOD_SIZE, -1 },
-		private_data: 0,
+		.private_data = 0,
 	},
 	{
-		var: SND_PCM_HW_PARAM_PERIOD_SIZE, 
+		.var = SND_PCM_HW_PARAM_PERIOD_SIZE, 
-		func: snd_pcm_hw_rule_div,
+		.func = snd_pcm_hw_rule_div,
-		deps: { SND_PCM_HW_PARAM_BUFFER_SIZE,
+		.deps = { SND_PCM_HW_PARAM_BUFFER_SIZE,
 			SND_PCM_HW_PARAM_PERIODS, -1 },
-		private_data: 0,
+		.private_data = 0,
 	},
 	{
-		var: SND_PCM_HW_PARAM_PERIOD_SIZE, 
+		.var = SND_PCM_HW_PARAM_PERIOD_SIZE, 
-		func: snd_pcm_hw_rule_mulkdiv,
+		.func = snd_pcm_hw_rule_mulkdiv,
-		deps: { SND_PCM_HW_PARAM_PERIOD_BYTES,
+		.deps = { SND_PCM_HW_PARAM_PERIOD_BYTES,
 			SND_PCM_HW_PARAM_FRAME_BITS, -1 },
-		private_data: (void*) 8,
+		.private_data = (void*) 8,
 	},
 	{
-		var: SND_PCM_HW_PARAM_PERIOD_SIZE, 
+		.var = SND_PCM_HW_PARAM_PERIOD_SIZE, 
-		func: snd_pcm_hw_rule_muldivk,
+		.func = snd_pcm_hw_rule_muldivk,
-		deps: { SND_PCM_HW_PARAM_PERIOD_TIME,
+		.deps = { SND_PCM_HW_PARAM_PERIOD_TIME,
 			SND_PCM_HW_PARAM_RATE, -1 },
-		private_data: (void*) 1000000,
+		.private_data = (void*) 1000000,
 	},
 	{
-		var: SND_PCM_HW_PARAM_BUFFER_SIZE, 
+		.var = SND_PCM_HW_PARAM_BUFFER_SIZE, 
-		func: snd_pcm_hw_rule_mul,
+		.func = snd_pcm_hw_rule_mul,
-		deps: { SND_PCM_HW_PARAM_PERIOD_SIZE,
+		.deps = { SND_PCM_HW_PARAM_PERIOD_SIZE,
 			SND_PCM_HW_PARAM_PERIODS, -1 },
-		private_data: 0,
+		.private_data = 0,
 	},
 	{
-		var: SND_PCM_HW_PARAM_BUFFER_SIZE, 
+		.var = SND_PCM_HW_PARAM_BUFFER_SIZE, 
-		func: snd_pcm_hw_rule_mulkdiv,
+		.func = snd_pcm_hw_rule_mulkdiv,
-		deps: { SND_PCM_HW_PARAM_BUFFER_BYTES,
+		.deps = { SND_PCM_HW_PARAM_BUFFER_BYTES,
 			SND_PCM_HW_PARAM_FRAME_BITS, -1 },
-		private_data: (void*) 8,
+		.private_data = (void*) 8,
 	},
 	{
-		var: SND_PCM_HW_PARAM_BUFFER_SIZE, 
+		.var = SND_PCM_HW_PARAM_BUFFER_SIZE, 
-		func: snd_pcm_hw_rule_muldivk,
+		.func = snd_pcm_hw_rule_muldivk,
-		deps: { SND_PCM_HW_PARAM_BUFFER_TIME,
+		.deps = { SND_PCM_HW_PARAM_BUFFER_TIME,
 			SND_PCM_HW_PARAM_RATE, -1 },
-		private_data: (void*) 1000000,
+		.private_data = (void*) 1000000,
 	},
 	{
-		var: SND_PCM_HW_PARAM_PERIOD_BYTES, 
+		.var = SND_PCM_HW_PARAM_PERIOD_BYTES, 
-		func: snd_pcm_hw_rule_muldivk,
+		.func = snd_pcm_hw_rule_muldivk,
-		deps: { SND_PCM_HW_PARAM_PERIOD_SIZE,
+		.deps = { SND_PCM_HW_PARAM_PERIOD_SIZE,
 			SND_PCM_HW_PARAM_FRAME_BITS, -1 },
-		private_data: (void*) 8,
+		.private_data = (void*) 8,
 	},
 	{
-		var: SND_PCM_HW_PARAM_BUFFER_BYTES, 
+		.var = SND_PCM_HW_PARAM_BUFFER_BYTES, 
-		func: snd_pcm_hw_rule_muldivk,
+		.func = snd_pcm_hw_rule_muldivk,
-		deps: { SND_PCM_HW_PARAM_BUFFER_SIZE,
+		.deps = { SND_PCM_HW_PARAM_BUFFER_SIZE,
 			SND_PCM_HW_PARAM_FRAME_BITS, -1 },
-		private_data: (void*) 8,
+		.private_data = (void*) 8,
 	},
 	{
-		var: SND_PCM_HW_PARAM_PERIOD_TIME, 
+		.var = SND_PCM_HW_PARAM_PERIOD_TIME, 
-		func: snd_pcm_hw_rule_mulkdiv,
+		.func = snd_pcm_hw_rule_mulkdiv,
-		deps: { SND_PCM_HW_PARAM_PERIOD_SIZE,
+		.deps = { SND_PCM_HW_PARAM_PERIOD_SIZE,
 			SND_PCM_HW_PARAM_RATE, -1 },
-		private_data: (void*) 1000000,
+		.private_data = (void*) 1000000,
 	},
 	{
-		var: SND_PCM_HW_PARAM_BUFFER_TIME, 
+		.var = SND_PCM_HW_PARAM_BUFFER_TIME, 
-		func: snd_pcm_hw_rule_mulkdiv,
+		.func = snd_pcm_hw_rule_mulkdiv,
-		deps: { SND_PCM_HW_PARAM_BUFFER_SIZE,
+		.deps = { SND_PCM_HW_PARAM_BUFFER_SIZE,
 			SND_PCM_HW_PARAM_RATE, -1 },
-		private_data: (void*) 1000000,
+		.private_data = (void*) 1000000,
 	},
 };
 
@@ -1875,64 +1875,64 @@ static snd_pcm_hw_rule_t refine_rules[] = {
 
 static snd_mask_t refine_masks[SND_PCM_HW_PARAM_LAST_MASK - SND_PCM_HW_PARAM_FIRST_MASK + 1] = {
 	[SND_PCM_HW_PARAM_ACCESS - SND_PCM_HW_PARAM_FIRST_MASK] = {
-		bits: { 0x1f },
+		.bits = { 0x1f },
 	},
 	[SND_PCM_HW_PARAM_FORMAT - SND_PCM_HW_PARAM_FIRST_MASK] = {
-		bits: { 0x81ffffff, 0xfff},
+		.bits = { 0x81ffffff, 0xfff},
 	},
 	[SND_PCM_HW_PARAM_SUBFORMAT - SND_PCM_HW_PARAM_FIRST_MASK] = {
-		bits: { 0x1 },
+		.bits = { 0x1 },
 	},
 };
   
 static snd_interval_t refine_intervals[SND_PCM_HW_PARAM_LAST_INTERVAL - SND_PCM_HW_PARAM_FIRST_INTERVAL + 1] = {
 	[SND_PCM_HW_PARAM_SAMPLE_BITS - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 1, max: UINT_MAX,
+		.min = 1, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 1, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 1, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_FRAME_BITS - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 1, max: UINT_MAX,
+		.min = 1, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 1, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 1, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_CHANNELS - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 1, max: UINT_MAX,
+		.min = 1, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 1, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 1, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_RATE - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 1, max: UINT_MAX,
+		.min = 1, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 0, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 0, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_PERIOD_TIME - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 0, max: UINT_MAX,
+		.min = 0, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 0, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 0, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_PERIOD_SIZE - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 0, max: UINT_MAX,
+		.min = 0, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 0, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 0, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_PERIOD_BYTES - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 0, max: UINT_MAX,
+		.min = 0, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 0, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 0, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_PERIODS - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 0, max: UINT_MAX,
+		.min = 0, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 0, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 0, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_BUFFER_TIME - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 1, max: UINT_MAX,
+		.min = 1, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 0, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 0, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_BUFFER_SIZE - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 1, max: UINT_MAX,
+		.min = 1, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 1, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 1, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_BUFFER_BYTES - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 1, max: UINT_MAX,
+		.min = 1, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 1, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 1, .empty = 0,
 	},
 	[SND_PCM_HW_PARAM_TICK_TIME - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
-		min: 0, max: UINT_MAX,
+		.min = 0, .max = UINT_MAX,
-		openmin: 0, openmax: 0, integer: 0, empty: 0,
+		.openmin = 0, .openmax = 0, .integer = 0, .empty = 0,
 	},
 };
 

src/pcm/pcm_plug.c

@@ -955,19 +955,19 @@ static void snd_pcm_plug_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_plug_ops = {
-	close: snd_pcm_plug_close,
+	.close = snd_pcm_plug_close,
-	info: snd_pcm_plug_info,
+	.info = snd_pcm_plug_info,
-	hw_refine: snd_pcm_plug_hw_refine,
+	.hw_refine = snd_pcm_plug_hw_refine,
-	hw_params: snd_pcm_plug_hw_params,
+	.hw_params = snd_pcm_plug_hw_params,
-	hw_free: snd_pcm_plug_hw_free,
+	.hw_free = snd_pcm_plug_hw_free,
-	sw_params: snd_pcm_plug_sw_params,
+	.sw_params = snd_pcm_plug_sw_params,
-	channel_info: snd_pcm_plug_channel_info,
+	.channel_info = snd_pcm_plug_channel_info,
-	dump: snd_pcm_plug_dump,
+	.dump = snd_pcm_plug_dump,
-	nonblock: snd_pcm_plug_nonblock,
+	.nonblock = snd_pcm_plug_nonblock,
-	async: snd_pcm_plug_async,
+	.async = snd_pcm_plug_async,
-	poll_revents: snd_pcm_plug_poll_revents,
+	.poll_revents = snd_pcm_plug_poll_revents,
-	mmap: snd_pcm_plug_mmap,
+	.mmap = snd_pcm_plug_mmap,
-	munmap: snd_pcm_plug_munmap,
+	.munmap = snd_pcm_plug_munmap,
 };
 
 /**

src/pcm/pcm_plugin.c

@@ -646,25 +646,25 @@ int snd_pcm_plugin_hw_params_slave(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 }
 
 snd_pcm_fast_ops_t snd_pcm_plugin_fast_ops = {
-	status: snd_pcm_plugin_status,
+	.status = snd_pcm_plugin_status,
-	state: snd_pcm_plugin_state,
+	.state = snd_pcm_plugin_state,
-	hwsync: snd_pcm_plugin_hwsync,
+	.hwsync = snd_pcm_plugin_hwsync,
-	delay: snd_pcm_plugin_delay,
+	.delay = snd_pcm_plugin_delay,
-	prepare: snd_pcm_plugin_prepare,
+	.prepare = snd_pcm_plugin_prepare,
-	reset: snd_pcm_plugin_reset,
+	.reset = snd_pcm_plugin_reset,
-	start: snd_pcm_plugin_start,
+	.start = snd_pcm_plugin_start,
-	drop: snd_pcm_plugin_drop,
+	.drop = snd_pcm_plugin_drop,
-	drain: snd_pcm_plugin_drain,
+	.drain = snd_pcm_plugin_drain,
-	pause: snd_pcm_plugin_pause,
+	.pause = snd_pcm_plugin_pause,
-	rewind: snd_pcm_plugin_rewind,
+	.rewind = snd_pcm_plugin_rewind,
-	forward: snd_pcm_plugin_forward,
+	.forward = snd_pcm_plugin_forward,
-	resume: snd_pcm_plugin_resume,
+	.resume = snd_pcm_plugin_resume,
-	writei: snd_pcm_plugin_writei,
+	.writei = snd_pcm_plugin_writei,
-	writen: snd_pcm_plugin_writen,
+	.writen = snd_pcm_plugin_writen,
-	readi: snd_pcm_plugin_readi,
+	.readi = snd_pcm_plugin_readi,
-	readn: snd_pcm_plugin_readn,
+	.readn = snd_pcm_plugin_readn,
-	avail_update: snd_pcm_plugin_avail_update,
+	.avail_update = snd_pcm_plugin_avail_update,
-	mmap_commit: snd_pcm_plugin_mmap_commit,
+	.mmap_commit = snd_pcm_plugin_mmap_commit,
 };
 
 

src/pcm/pcm_rate.c

@@ -568,19 +568,19 @@ static void snd_pcm_rate_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_rate_ops = {
-	close: snd_pcm_plugin_close,
+	.close = snd_pcm_plugin_close,
-	info: snd_pcm_plugin_info,
+	.info = snd_pcm_plugin_info,
-	hw_refine: snd_pcm_rate_hw_refine,
+	.hw_refine = snd_pcm_rate_hw_refine,
-	hw_params: snd_pcm_rate_hw_params,
+	.hw_params = snd_pcm_rate_hw_params,
-	hw_free: snd_pcm_rate_hw_free,
+	.hw_free = snd_pcm_rate_hw_free,
-	sw_params: snd_pcm_rate_sw_params,
+	.sw_params = snd_pcm_rate_sw_params,
-	channel_info: snd_pcm_plugin_channel_info,
+	.channel_info = snd_pcm_plugin_channel_info,
-	dump: snd_pcm_rate_dump,
+	.dump = snd_pcm_rate_dump,
-	nonblock: snd_pcm_plugin_nonblock,
+	.nonblock = snd_pcm_plugin_nonblock,
-	async: snd_pcm_plugin_async,
+	.async = snd_pcm_plugin_async,
-	poll_revents: snd_pcm_plugin_poll_revents,
+	.poll_revents = snd_pcm_plugin_poll_revents,
-	mmap: snd_pcm_plugin_mmap,
+	.mmap = snd_pcm_plugin_mmap,
-	munmap: snd_pcm_plugin_munmap,
+	.munmap = snd_pcm_plugin_munmap,
 };
 
 

src/pcm/pcm_route.c

@@ -722,19 +722,19 @@ static void snd_pcm_route_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_route_ops = {
-	close: snd_pcm_route_close,
+	.close = snd_pcm_route_close,
-	info: snd_pcm_plugin_info,
+	.info = snd_pcm_plugin_info,
-	hw_refine: snd_pcm_route_hw_refine,
+	.hw_refine = snd_pcm_route_hw_refine,
-	hw_params: snd_pcm_route_hw_params,
+	.hw_params = snd_pcm_route_hw_params,
-	hw_free: snd_pcm_plugin_hw_free,
+	.hw_free = snd_pcm_plugin_hw_free,
-	sw_params: snd_pcm_plugin_sw_params,
+	.sw_params = snd_pcm_plugin_sw_params,
-	channel_info: snd_pcm_plugin_channel_info,
+	.channel_info = snd_pcm_plugin_channel_info,
-	dump: snd_pcm_route_dump,
+	.dump = snd_pcm_route_dump,
-	nonblock: snd_pcm_plugin_nonblock,
+	.nonblock = snd_pcm_plugin_nonblock,
-	async: snd_pcm_plugin_async,
+	.async = snd_pcm_plugin_async,
-	poll_revents: snd_pcm_plugin_poll_revents,
+	.poll_revents = snd_pcm_plugin_poll_revents,
-	mmap: snd_pcm_plugin_mmap,
+	.mmap = snd_pcm_plugin_mmap,
-	munmap: snd_pcm_plugin_munmap,
+	.munmap = snd_pcm_plugin_munmap,
 };
 
 static int route_load_ttable(snd_pcm_route_params_t *params, snd_pcm_stream_t stream,

src/pcm/pcm_share.c

@@ -1264,40 +1264,40 @@ static void snd_pcm_share_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_share_ops = {
-	close: snd_pcm_share_close,
+	.close = snd_pcm_share_close,
-	info: snd_pcm_share_info,
+	.info = snd_pcm_share_info,
-	hw_refine: snd_pcm_share_hw_refine,
+	.hw_refine = snd_pcm_share_hw_refine,
-	hw_params: snd_pcm_share_hw_params,
+	.hw_params = snd_pcm_share_hw_params,
-	hw_free: snd_pcm_share_hw_free,
+	.hw_free = snd_pcm_share_hw_free,
-	sw_params: snd_pcm_share_sw_params,
+	.sw_params = snd_pcm_share_sw_params,
-	channel_info: snd_pcm_share_channel_info,
+	.channel_info = snd_pcm_share_channel_info,
-	dump: snd_pcm_share_dump,
+	.dump = snd_pcm_share_dump,
-	nonblock: snd_pcm_share_nonblock,
+	.nonblock = snd_pcm_share_nonblock,
-	async: snd_pcm_share_async,
+	.async = snd_pcm_share_async,
-	mmap: snd_pcm_share_mmap,
+	.mmap = snd_pcm_share_mmap,
-	munmap: snd_pcm_share_munmap,
+	.munmap = snd_pcm_share_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_share_fast_ops = {
-	status: snd_pcm_share_status,
+	.status = snd_pcm_share_status,
-	state: snd_pcm_share_state,
+	.state = snd_pcm_share_state,
-	hwsync: snd_pcm_share_hwsync,
+	.hwsync = snd_pcm_share_hwsync,
-	delay: snd_pcm_share_delay,
+	.delay = snd_pcm_share_delay,
-	prepare: snd_pcm_share_prepare,
+	.prepare = snd_pcm_share_prepare,
-	reset: snd_pcm_share_reset,
+	.reset = snd_pcm_share_reset,
-	start: snd_pcm_share_start,
+	.start = snd_pcm_share_start,
-	drop: snd_pcm_share_drop,
+	.drop = snd_pcm_share_drop,
-	drain: snd_pcm_share_drain,
+	.drain = snd_pcm_share_drain,
-	pause: snd_pcm_share_pause,
+	.pause = snd_pcm_share_pause,
-	writei: snd_pcm_mmap_writei,
+	.writei = snd_pcm_mmap_writei,
-	writen: snd_pcm_mmap_writen,
+	.writen = snd_pcm_mmap_writen,
-	readi: snd_pcm_mmap_readi,
+	.readi = snd_pcm_mmap_readi,
-	readn: snd_pcm_mmap_readn,
+	.readn = snd_pcm_mmap_readn,
-	rewind: snd_pcm_share_rewind,
+	.rewind = snd_pcm_share_rewind,
-	forward: snd_pcm_share_forward,
+	.forward = snd_pcm_share_forward,
-	resume: snd_pcm_share_resume,
+	.resume = snd_pcm_share_resume,
-	avail_update: snd_pcm_share_avail_update,
+	.avail_update = snd_pcm_share_avail_update,
-	mmap_commit: snd_pcm_share_mmap_commit,
+	.mmap_commit = snd_pcm_share_mmap_commit,
 };
 
 /**

src/pcm/pcm_shm.c

@@ -574,40 +574,40 @@ static void snd_pcm_shm_dump(snd_pcm_t *pcm, snd_output_t *out)
 }
 
 static snd_pcm_ops_t snd_pcm_shm_ops = {
-	close: snd_pcm_shm_close,
+	.close = snd_pcm_shm_close,
-	info: snd_pcm_shm_info,
+	.info = snd_pcm_shm_info,
-	hw_refine: snd_pcm_shm_hw_refine,
+	.hw_refine = snd_pcm_shm_hw_refine,
-	hw_params: snd_pcm_shm_hw_params,
+	.hw_params = snd_pcm_shm_hw_params,
-	hw_free: snd_pcm_shm_hw_free,
+	.hw_free = snd_pcm_shm_hw_free,
-	sw_params: snd_pcm_shm_sw_params,
+	.sw_params = snd_pcm_shm_sw_params,
-	channel_info: snd_pcm_shm_channel_info,
+	.channel_info = snd_pcm_shm_channel_info,
-	dump: snd_pcm_shm_dump,
+	.dump = snd_pcm_shm_dump,
-	nonblock: snd_pcm_shm_nonblock,
+	.nonblock = snd_pcm_shm_nonblock,
-	async: snd_pcm_shm_async,
+	.async = snd_pcm_shm_async,
-	mmap: snd_pcm_shm_mmap,
+	.mmap = snd_pcm_shm_mmap,
-	munmap: snd_pcm_shm_munmap,
+	.munmap = snd_pcm_shm_munmap,
 };
 
 static snd_pcm_fast_ops_t snd_pcm_shm_fast_ops = {
-	status: snd_pcm_shm_status,
+	.status = snd_pcm_shm_status,
-	state: snd_pcm_shm_state,
+	.state = snd_pcm_shm_state,
-	hwsync: snd_pcm_shm_hwsync,
+	.hwsync = snd_pcm_shm_hwsync,
-	delay: snd_pcm_shm_delay,
+	.delay = snd_pcm_shm_delay,
-	prepare: snd_pcm_shm_prepare,
+	.prepare = snd_pcm_shm_prepare,
-	reset: snd_pcm_shm_reset,
+	.reset = snd_pcm_shm_reset,
-	start: snd_pcm_shm_start,
+	.start = snd_pcm_shm_start,
-	drop: snd_pcm_shm_drop,
+	.drop = snd_pcm_shm_drop,
-	drain: snd_pcm_shm_drain,
+	.drain = snd_pcm_shm_drain,
-	pause: snd_pcm_shm_pause,
+	.pause = snd_pcm_shm_pause,
-	rewind: snd_pcm_shm_rewind,
+	.rewind = snd_pcm_shm_rewind,
-	forward: snd_pcm_shm_forward,
+	.forward = snd_pcm_shm_forward,
-	resume: snd_pcm_shm_resume,
+	.resume = snd_pcm_shm_resume,
-	writei: snd_pcm_mmap_writei,
+	.writei = snd_pcm_mmap_writei,
-	writen: snd_pcm_mmap_writen,
+	.writen = snd_pcm_mmap_writen,
-	readi: snd_pcm_mmap_readi,
+	.readi = snd_pcm_mmap_readi,
-	readn: snd_pcm_mmap_readn,
+	.readn = snd_pcm_mmap_readn,
-	avail_update: snd_pcm_shm_avail_update,
+	.avail_update = snd_pcm_shm_avail_update,
-	mmap_commit: snd_pcm_shm_mmap_commit,
+	.mmap_commit = snd_pcm_shm_mmap_commit,
 };
 
 static int make_local_socket(const char *filename)

src/pcm/scopes/level.c

@@ -170,13 +170,13 @@ static void level_reset(snd_pcm_scope_t *scope)
 }
 
 snd_pcm_scope_ops_t level_ops = {
-	enable: level_enable,
+	.enable = level_enable,
-	disable: level_disable,
+	.disable = level_disable,
-	close: level_close,
+	.close = level_close,
-	start: level_start,
+	.start = level_start,
-	stop: level_stop,
+	.stop = level_stop,
-	update: level_update,
+	.update = level_update,
-	reset: level_reset,
+	.reset = level_reset,
 };
 
 int snd_pcm_scope_level_open(snd_pcm_t *pcm, const char *name,

src/rawmidi/rawmidi_hw.c

@@ -153,15 +153,15 @@ static ssize_t snd_rawmidi_hw_read(snd_rawmidi_t *rmidi, void *buffer, size_t si
 }
 
 snd_rawmidi_ops_t snd_rawmidi_hw_ops = {
-	close: snd_rawmidi_hw_close,
+	.close = snd_rawmidi_hw_close,
-	nonblock: snd_rawmidi_hw_nonblock,
+	.nonblock = snd_rawmidi_hw_nonblock,
-	info: snd_rawmidi_hw_info,
+	.info = snd_rawmidi_hw_info,
-	params: snd_rawmidi_hw_params,
+	.params = snd_rawmidi_hw_params,
-	status: snd_rawmidi_hw_status,
+	.status = snd_rawmidi_hw_status,
-	drop: snd_rawmidi_hw_drop,
+	.drop = snd_rawmidi_hw_drop,
-	drain: snd_rawmidi_hw_drain,
+	.drain = snd_rawmidi_hw_drain,
-	write: snd_rawmidi_hw_write,
+	.write = snd_rawmidi_hw_write,
-	read: snd_rawmidi_hw_read,
+	.read = snd_rawmidi_hw_read,
 };
 
 

src/seq/seq_hw.c

@@ -378,38 +378,38 @@ static int snd_seq_hw_query_next_port(snd_seq_t *seq, snd_seq_port_info_t *info)
 }
 
 snd_seq_ops_t snd_seq_hw_ops = {
-	close: snd_seq_hw_close,
+	.close = snd_seq_hw_close,
-	nonblock: snd_seq_hw_nonblock,
+	.nonblock = snd_seq_hw_nonblock,
-	system_info: snd_seq_hw_system_info,
+	.system_info = snd_seq_hw_system_info,
-	get_client_info: snd_seq_hw_get_client_info,
+	.get_client_info = snd_seq_hw_get_client_info,
-	set_client_info: snd_seq_hw_set_client_info,
+	.set_client_info = snd_seq_hw_set_client_info,
-	create_port: snd_seq_hw_create_port,
+	.create_port = snd_seq_hw_create_port,
-	delete_port: snd_seq_hw_delete_port,
+	.delete_port = snd_seq_hw_delete_port,
-	get_port_info: snd_seq_hw_get_port_info,
+	.get_port_info = snd_seq_hw_get_port_info,
-	set_port_info: snd_seq_hw_set_port_info,
+	.set_port_info = snd_seq_hw_set_port_info,
-	get_port_subscription: snd_seq_hw_get_port_subscription,
+	.get_port_subscription = snd_seq_hw_get_port_subscription,
-	subscribe_port: snd_seq_hw_subscribe_port,
+	.subscribe_port = snd_seq_hw_subscribe_port,
-	unsubscribe_port: snd_seq_hw_unsubscribe_port,
+	.unsubscribe_port = snd_seq_hw_unsubscribe_port,
-	query_port_subscribers: snd_seq_hw_query_port_subscribers,
+	.query_port_subscribers = snd_seq_hw_query_port_subscribers,
-	get_queue_status: snd_seq_hw_get_queue_status,
+	.get_queue_status = snd_seq_hw_get_queue_status,
-	get_queue_tempo: snd_seq_hw_get_queue_tempo,
+	.get_queue_tempo = snd_seq_hw_get_queue_tempo,
-	set_queue_tempo: snd_seq_hw_set_queue_tempo,
+	.set_queue_tempo = snd_seq_hw_set_queue_tempo,
-	get_queue_timer: snd_seq_hw_get_queue_timer,
+	.get_queue_timer = snd_seq_hw_get_queue_timer,
-	set_queue_timer: snd_seq_hw_set_queue_timer,
+	.set_queue_timer = snd_seq_hw_set_queue_timer,
-	get_queue_client: snd_seq_hw_get_queue_client,
+	.get_queue_client = snd_seq_hw_get_queue_client,
-	set_queue_client: snd_seq_hw_set_queue_client,
+	.set_queue_client = snd_seq_hw_set_queue_client,
-	create_queue: snd_seq_hw_create_queue,
+	.create_queue = snd_seq_hw_create_queue,
-	delete_queue: snd_seq_hw_delete_queue,
+	.delete_queue = snd_seq_hw_delete_queue,
-	get_queue_info: snd_seq_hw_get_queue_info,
+	.get_queue_info = snd_seq_hw_get_queue_info,
-	set_queue_info: snd_seq_hw_set_queue_info,
+	.set_queue_info = snd_seq_hw_set_queue_info,
-	get_named_queue: snd_seq_hw_get_named_queue,
+	.get_named_queue = snd_seq_hw_get_named_queue,
-	write: snd_seq_hw_write,
+	.write = snd_seq_hw_write,
-	read: snd_seq_hw_read,
+	.read = snd_seq_hw_read,
-	remove_events: snd_seq_hw_remove_events,
+	.remove_events = snd_seq_hw_remove_events,
-	get_client_pool: snd_seq_hw_get_client_pool,
+	.get_client_pool = snd_seq_hw_get_client_pool,
-	set_client_pool: snd_seq_hw_set_client_pool,
+	.set_client_pool = snd_seq_hw_set_client_pool,
-	query_next_client: snd_seq_hw_query_next_client,
+	.query_next_client = snd_seq_hw_query_next_client,
-	query_next_port: snd_seq_hw_query_next_port,
+	.query_next_port = snd_seq_hw_query_next_port,
 };
 
 int snd_seq_hw_open(snd_seq_t **handle, const char *name, int streams, int mode)

src/timer/timer_query_hw.c

@@ -82,11 +82,11 @@ static int snd_timer_query_hw_status(snd_timer_query_t *handle, snd_timer_gstatu
 }
 
 static snd_timer_query_ops_t snd_timer_query_hw_ops = {
-	close: snd_timer_query_hw_close,
+	.close = snd_timer_query_hw_close,
-	next_device: snd_timer_query_hw_next_device,
+	.next_device = snd_timer_query_hw_next_device,
-	info: snd_timer_query_hw_info,
+	.info = snd_timer_query_hw_info,
-	params: snd_timer_query_hw_params,
+	.params = snd_timer_query_hw_params,
-	status: snd_timer_query_hw_status
+	.status = snd_timer_query_hw_status
 };
 
 int snd_timer_query_hw_open(snd_timer_query_t **handle, const char *name, int mode)