xref: /dports/audio/fossmixer/detroit-0.2.3/engine/dynload_bind.c

#include "declarations.h"
#include "dsl_shr.h"
#include "dynload_str.h"
#include "dynload_bind.h"



__VISIBILITY_DEFAULT__ double dynload_clock_get_ticks(struct a_funcs *c) {
	if(dynload_clock_get_ticks_pre(c) != 0) return(0.0);

	return(clock_get_ticks());
}

__VISIBILITY_DEFAULT__ double dynload_clock_get_multiplier(struct a_funcs *c) {
	if(dynload_clock_get_multiplier_pre(c) != 0) return(0.0);

	return(clock_get_multiplier());
}

__VISIBILITY_DEFAULT__ double dynload_clock_set(struct a_funcs *c) {
	struct par_clock_set a;

	if(dynload_clock_set_pre(c, &a) != 0) return(0.0);

	return(clock_set(a.ticks));
}

__VISIBILITY_DEFAULT__ double dynload_clock_set_multiplier(struct a_funcs *c) {
	struct par_clock_set_multiplier a;

	if(dynload_clock_set_multiplier_pre(c, &a) != 0) return(0.0);

	return(clock_set_multiplier(a.multiplier));
}
#if ! defined(PROG_DISABLE_COLOR)
__VISIBILITY_DEFAULT__ float dynload_color_brightness(struct a_funcs *c) {
	struct par_color_brightness a;

	if(dynload_color_brightness_pre(c, &a) != 0) return(0.0);

	return(color_rgba_brightness(&a.color));
}

__VISIBILITY_DEFAULT__ void *dynload_color_bv_index(struct a_funcs *c) {
	struct par_color_bv_index a;

	if(dynload_color_bv_index_pre(c, &a) != 0) return(NULL);

	(void) color_bv_to_rgba(&a.value, a.index, a.magnitude);

	return(dynload_ret_color(&a.value));
}

__VISIBILITY_DEFAULT__ void *dynload_color_complement(struct a_funcs *c) {
	struct par_color_complement a;

	if(dynload_color_complement_pre(c, &a) != 0) return(NULL);

	(void) color_rgba_complement(&a.color, &a.value);

	return(dynload_ret_color(&a.value));
}

__VISIBILITY_DEFAULT__ void *dynload_color_mix(struct a_funcs *c) {
	struct par_color_mix a;

	if(dynload_color_mix_pre(c, &a) != 0) return(NULL);

	(void) color_rgba_mix(&a.color_a, &a.color_b, &a.value, a.factor);

	return(dynload_ret_color(&a.value));
}
#endif
#if ! defined(PROG_DISABLE_COORDS)
__VISIBILITY_DEFAULT__ double dynload_coords_mag_2d(struct a_funcs *c) {
	struct par_coords_mag a;

	if(dynload_coords_mag_pre(c, &a) != 0) return(0.0);

	return(coords_mag_2d(&a.pos));
}

__VISIBILITY_DEFAULT__ double dynload_coords_mag_3d(struct a_funcs *c) {
	struct par_coords_mag a;

	if(dynload_coords_mag_pre(c, &a) != 0) return(0.0);

	return(coords_mag_3d(&a.pos));
}

__VISIBILITY_DEFAULT__ void *dynload_coords_normalize_2d(struct a_funcs *c) {
	struct par_coords_normalize a;

	if(dynload_coords_normalize_pre(c, &a) != 0) return(NULL);

	(void) coords_normalize_2d(&a.pos, &a.value);

	return(dynload_ret_position(&a.value));
}

__VISIBILITY_DEFAULT__ void *dynload_coords_normalize_3d(struct a_funcs *c) {
	struct par_coords_normalize a;

	if(dynload_coords_normalize_pre(c, &a) != 0) return(NULL);

	(void) coords_normalize_3d(&a.pos, &a.value);

	return(dynload_ret_position(&a.value));
}

__VISIBILITY_DEFAULT__ double dynload_coords_difference_2d(struct a_funcs *c) {
	struct par_coords_difference a;

	if(dynload_coords_difference_pre(c, &a) != 0) return(0.0);

	return(coords_difference_2d(&a.pos_a, &a.pos_b));
}

__VISIBILITY_DEFAULT__ double dynload_coords_difference_3d(struct a_funcs *c) {
	struct par_coords_difference a;

	if(dynload_coords_difference_pre(c, &a) != 0) return(0.0);

	return(coords_difference_3d(&a.pos_a, &a.pos_b));
}

__VISIBILITY_DEFAULT__ double dynload_coords_get_angle(struct a_funcs *c) {
	struct par_coords_get_angle a;

	if(dynload_coords_get_angle_pre(c, &a) != 0) return(0.0);

	return(coords_position_to_angle(&a.pos));
}

__VISIBILITY_DEFAULT__ void *dynload_coords_get_pos(struct a_funcs *c) {
	struct par_coords_get_pos a;

	if(dynload_coords_get_pos_pre(c, &a) != 0) return(NULL);

	(void) coords_angle_distance_to_position(a.angle, a.distance, &a.value);

	return(dynload_ret_position(&a.value));
}

__VISIBILITY_DEFAULT__ double dynload_coords_dot_product(struct a_funcs *c) {
	struct par_coords_dot_product a;

	if(dynload_coords_dot_product_pre(c, &a) != 0) return(0.0);

	return(coords_dot(&a.pos_a, &a.pos_b));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_linear_x(struct a_funcs *c) {
	struct par_coords_intp_linear a;

	if(dynload_coords_intp_linear_pre(c, &a) != 0) return(0.0);

	return(coords_intp_linear_x(&a.pos_a, &a.pos_b, a.point));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_linear_y(struct a_funcs *c) {
	struct par_coords_intp_linear a;

	if(dynload_coords_intp_linear_pre(c, &a) != 0) return(0.0);

	return(coords_intp_linear_y(&a.pos_a, &a.pos_b, a.point));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_linear_z(struct a_funcs *c) {
	struct par_coords_intp_linear a;

	if(dynload_coords_intp_linear_pre(c, &a) != 0) return(0.0);

	return(coords_intp_linear_z(&a.pos_a, &a.pos_b, a.point));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_cubic_x(struct a_funcs *c) {
	struct par_coords_intp_cubic a;

	if(dynload_coords_intp_cubic_pre(c, &a) != 0) return(0.0);

	return(coords_intp_cubic_x(&a.pos_a, &a.pos_b, &a.pos_c, &a.pos_d, a.point));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_cubic_y(struct a_funcs *c) {
	struct par_coords_intp_cubic a;

	if(dynload_coords_intp_cubic_pre(c, &a) != 0) return(0.0);

	return(coords_intp_cubic_y(&a.pos_a, &a.pos_b, &a.pos_c, &a.pos_d, a.point));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_cubic_z(struct a_funcs *c) {
	struct par_coords_intp_cubic a;

	if(dynload_coords_intp_cubic_pre(c, &a) != 0) return(0.0);

	return(coords_intp_cubic_z(&a.pos_a, &a.pos_b, &a.pos_c, &a.pos_d, a.point));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_catmull_x(struct a_funcs *c) {
	struct par_coords_intp_catmull a;

	if(dynload_coords_intp_catmull_pre(c, &a) != 0) return(0.0);

	return(coords_intp_catmull_x(&a.pos_a, &a.pos_b, &a.pos_c, &a.pos_d, a.point));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_catmull_y(struct a_funcs *c) {
	struct par_coords_intp_catmull a;

	if(dynload_coords_intp_catmull_pre(c, &a) != 0) return(0.0);

	return(coords_intp_catmull_y(&a.pos_a, &a.pos_b, &a.pos_c, &a.pos_d, a.point));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_catmull_z(struct a_funcs *c) {
	struct par_coords_intp_catmull a;

	if(dynload_coords_intp_catmull_pre(c, &a) != 0) return(0.0);

	return(coords_intp_catmull_z(&a.pos_a, &a.pos_b, &a.pos_c, &a.pos_d, a.point));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_hermite_x(struct a_funcs *c) {
	struct par_coords_intp_hermite a;

	if(dynload_coords_intp_hermite_pre(c, &a) != 0) return(0.0);

	return(coords_intp_hermite_x(&a.pos_a, &a.pos_b, &a.pos_c, &a.pos_d, a.point, a.bias, a.tension));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_hermite_y(struct a_funcs *c) {
	struct par_coords_intp_hermite a;

	if(dynload_coords_intp_hermite_pre(c, &a) != 0) return(0.0);

	return(coords_intp_hermite_y(&a.pos_a, &a.pos_b, &a.pos_c, &a.pos_d, a.point, a.bias, a.tension));
}

__VISIBILITY_DEFAULT__ double dynload_coords_intp_hermite_z(struct a_funcs *c) {
	struct par_coords_intp_hermite a;

	if(dynload_coords_intp_hermite_pre(c, &a) != 0) return(0.0);

	return(coords_intp_hermite_z(&a.pos_a, &a.pos_b, &a.pos_c, &a.pos_d, a.point, a.bias, a.tension));
}
#endif
#if ! defined(PROG_DISABLE_MATH)
__VISIBILITY_DEFAULT__ double dynload_math_clamp(struct a_funcs *c) {
	struct par_math_clamp a;

	if(dynload_math_clamp_pre(c, &a) != 0) return(0.0);

	return(maths_clamp(a.clamp, a.min, a.max));
}

__VISIBILITY_DEFAULT__ double dynload_math_map(struct a_funcs *c) {
	struct par_math_map a;

	if(dynload_math_map_pre(c, &a) != 0) return(0.0);

	return(maths_map(a.map, a.cur_min, a.cur_max, a.map_min, a.map_max));
}

__VISIBILITY_DEFAULT__ double dynload_math_get_hcf(struct a_funcs *c) {
	struct par_math_get_hcf a;

	if(dynload_math_get_hcf_pre(c, &a) != 0) return(0.0);

	return(maths_hcf(a.hcf_a, a.hcf_b));
}

__VISIBILITY_DEFAULT__ double dynload_math_get_luminance(struct a_funcs *c) {
	struct par_math_get_luminance a;

	if(dynload_math_get_luminance_pre(c, &a) != 0) return(0.0);

	return(maths_luminance_by_radius_temperature(a.radius, a.temperature));
}

__VISIBILITY_DEFAULT__ double dynload_math_get_parsec(struct a_funcs *c) {
	struct par_math_get_parsec a;

	if(dynload_math_get_parsec_pre(c, &a) != 0) return(0.0);

	return(maths_parsec_by_parallax(a.parallax));
}

__VISIBILITY_DEFAULT__ double dynload_math_get_radius(struct a_funcs *c) {
	struct par_math_get_radius a;

	if(dynload_math_get_radius_pre(c, &a) != 0) return(0.0);

	return(maths_radius_by_amag_temperature(a.amag, a.temperature));
}

__VISIBILITY_DEFAULT__ double dynload_math_btvt_to_bv(struct a_funcs *c) {
	struct par_math_btvt_to_bv a;

	if(dynload_math_btvt_to_bv_pre(c, &a) != 0) return(0.0);

	return(maths_btvt_to_bv(a.btvt));
}

__VISIBILITY_DEFAULT__ double dynload_math_bv_to_temp(struct a_funcs *c) {
	struct par_math_bv_to_temp a;

	if(dynload_math_bv_to_temp_pre(c, &a) != 0) return(0.0);

	return(maths_bv_to_temperature(a.bv));
}

__VISIBILITY_DEFAULT__ double dynload_math_hp_to_vmag(struct a_funcs *c) {
	struct par_math_hp_to_vmag a;

	if(dynload_math_hp_to_vmag_pre(c, &a) != 0) return(0.0);

	return(maths_hp_to_vmag(a.hp, a.btvt));
}

__VISIBILITY_DEFAULT__ double dynload_math_vt_to_vmag(struct a_funcs *c) {
	struct par_math_vt_to_vmag a;

	if(dynload_math_vt_to_vmag_pre(c, &a) != 0) return(0.0);

	return(maths_vt_to_vmag(a.vt, a.btvt));
}

__VISIBILITY_DEFAULT__ double dynload_math_vmag_to_alpha(struct a_funcs *c) {
	struct par_math_vmag_to_alpha a;

	if(dynload_math_vmag_to_alpha_pre(c, &a) != 0) return(0.0);

	return(maths_vmag_to_alpha(a.vmag));
}
#endif
#if ! defined(PROG_DISABLE_GUI) && ! defined(PROG_DISABLE_DRAW)
__VISIBILITY_DEFAULT__ void dynload_draw_pixel(struct a_funcs *c) {
	struct par_draw_pixel a;

	if(dynload_draw_pixel_pre(c, &a) != 0) return;

	(void) gui_draw_pixel(a.handle, &a.pixel);
}

__VISIBILITY_DEFAULT__ void dynload_draw_pixel_alpha(struct a_funcs *c) {
	struct par_draw_pixel a;

	if(dynload_draw_pixel_pre(c, &a) != 0) return;

	(void) gui_draw_pixel_alpha(a.handle, &a.pixel);
}

__VISIBILITY_DEFAULT__ void dynload_draw_subpixel(struct a_funcs *c) {
	struct par_draw_subpixel a;

	if(dynload_draw_subpixel_pre(c, &a) != 0) return;

	(void) gui_draw_subpixel(a.handle, &a.subpixel);
}

__VISIBILITY_DEFAULT__ void dynload_draw_subpixel_alpha(struct a_funcs *c) {
	struct par_draw_subpixel a;

	if(dynload_draw_subpixel_pre(c, &a) != 0) return;

	(void) gui_draw_subpixel_alpha(a.handle, &a.subpixel);
}

__VISIBILITY_DEFAULT__ void dynload_draw_line(struct a_funcs *c) {
	struct par_draw_line a;

	if(dynload_draw_line_pre(c, &a) != 0) return;

	(void) gui_draw_line(a.handle, &a.line);
}

__VISIBILITY_DEFAULT__ void dynload_draw_line_aa(struct a_funcs *c) {
	struct par_draw_line a;

	if(dynload_draw_line_pre(c, &a) != 0) return;

	(void) gui_draw_line_aa(a.handle, &a.line);
}

__VISIBILITY_DEFAULT__ void dynload_draw_line_alpha(struct a_funcs *c) {
	struct par_draw_line a;

	if(dynload_draw_line_pre(c, &a) != 0) return;

	(void) gui_draw_line_alpha(a.handle, &a.line);
}

__VISIBILITY_DEFAULT__ void dynload_draw_circle(struct a_funcs *c) {
	struct par_draw_circle a;

	if(dynload_draw_circle_pre(c, &a) != 0) return;

	(void) gui_draw_circle(a.handle, &a.circle);
}

__VISIBILITY_DEFAULT__ void dynload_draw_circle_aa(struct a_funcs *c) {
	struct par_draw_circle a;

	if(dynload_draw_circle_pre(c, &a) != 0) return;

	(void) gui_draw_circle_aa(a.handle, &a.circle);
}

__VISIBILITY_DEFAULT__ void dynload_draw_circle_alpha(struct a_funcs *c) {
	struct par_draw_circle a;

	if(dynload_draw_circle_pre(c, &a) != 0) return;

	(void) gui_draw_circle_alpha(a.handle, &a.circle);
}

__VISIBILITY_DEFAULT__ void dynload_draw_text(struct a_funcs *c) {
	struct par_draw_text a;

	if(dynload_draw_text_pre(c, &a) != 0) return;

	(void) gui_draw_text(a.handle, &a.text);
}

__VISIBILITY_DEFAULT__ void dynload_draw_set(struct a_funcs *c) {
	struct par_draw_set a;

	if(dynload_draw_set_pre(c, &a) != 0) return;

	(void) gui_draw_set(a.handle, &a.set);
}

__VISIBILITY_DEFAULT__ void dynload_draw_set_alpha(struct a_funcs *c) {
	struct par_draw_set a;

	if(dynload_draw_set_pre(c, &a) != 0) return;

	(void) gui_draw_set_alpha(a.handle, &a.set);
}

__VISIBILITY_DEFAULT__ void dynload_draw_border(struct a_funcs *c) {
	struct par_draw_border a;

	if(dynload_draw_border_pre(c, &a) != 0) return;

	(void) gui_draw_border(a.handle, &a.border);
}

__VISIBILITY_DEFAULT__ void dynload_draw_border_alpha(struct a_funcs *c) {
	struct par_draw_border a;

	if(dynload_draw_border_pre(c, &a) != 0) return;

	(void) gui_draw_border_alpha(a.handle, &a.border);
}

__VISIBILITY_DEFAULT__ void dynload_draw_copy(struct a_funcs *c) {
	struct par_draw_copy a;

	if(dynload_draw_copy_pre(c, &a) != 0) return;

	(void) gui_draw_copy(a.handle, &a.copy);
}

__VISIBILITY_DEFAULT__ void dynload_draw_copy_alpha(struct a_funcs *c) {
	struct par_draw_copy a;

	if(dynload_draw_copy_pre(c, &a) != 0) return;

	(void) gui_draw_copy_alpha(a.handle, &a.copy);
}

__VISIBILITY_DEFAULT__ void dynload_draw_wipe(struct a_funcs *c) {
	struct par_draw_wipe a;

	if(dynload_draw_wipe_pre(c, &a) != 0) return;

	(void) gui_draw_wipe(a.handle);
}
#endif
#if ! defined(PROG_DISABLE_GUI)
__VISIBILITY_DEFAULT__ unsigned int dynload_font_open(struct a_funcs *c) {
	struct par_font_open a;

	if(dynload_font_open_pre(c, &a) != 0) return(0);

	return(fonts_open(a.font, a.height, a.resolution));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_font_open_copy(struct a_funcs *c) {
	struct par_font_open_copy a;

	if(dynload_font_open_copy_pre(c, &a) != 0) return(0);

	return(fonts_open_copy(a.handle));
}

__VISIBILITY_DEFAULT__ void dynload_font_close(struct a_funcs *c) {
	struct par_font_close a;

	if(dynload_font_close_pre(c, &a) != 0) return;

	(void) fonts_close(a.handle);
}

__VISIBILITY_DEFAULT__ void dynload_font_render(struct a_funcs *c) {
	struct par_font_render a;

	if(dynload_font_render_pre(c, &a) != 0) return;

	(void) fonts_render(a.handle, a.charset, a.string, a.length, &a.color, 0);
}

__VISIBILITY_DEFAULT__ unsigned int dynload_font_get_width(struct a_funcs *c) {
	struct par_font_get_width a;

	if(dynload_font_get_width_pre(c, &a) != 0) return(0);

	return(fonts_get_width(a.handle));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_font_get_height(struct a_funcs *c) {
	struct par_font_get_height a;

	if(dynload_font_get_height_pre(c, &a) != 0) return(0);

	return(fonts_get_height(a.handle));
}
#endif
__VISIBILITY_DEFAULT__ void dynload_thread_spawn(struct a_funcs *c) {
	struct par_thread_spawn a;

	if(dynload_thread_spawn_pre(c, &a, worker_dsl_thread) != 0) return;

	(void) thread_spawn(a.name, worker_dsl, a.cb_thread, &a.par_thread);
}

__VISIBILITY_DEFAULT__ void dynload_thread_affinity(struct a_funcs *c) {
	struct par_thread_affinity a;

	if(dynload_thread_affinity_pre(c, &a) != 0) return;

	(void) thread_affinity(a.cpu);
}

__VISIBILITY_DEFAULT__ void dynload_numa_affinity(struct a_funcs *c) {
	struct par_thread_numa_affinity a;

	if(dynload_thread_numa_affinity_pre(c, &a) != 0) return;

	(void) thread_numa_affinity(a.domain, a.policy);
}
#if ! defined(PROG_DISABLE_GUI)
__VISIBILITY_DEFAULT__ void dynload_window_refresh(struct a_funcs *c) {
	struct par_window_refresh a;

	if(dynload_window_refresh_pre(c, &a) != 0) return;

	(void) gui_window_refresh(a.handle, &a.area);
}

__VISIBILITY_DEFAULT__ void dynload_window_open(struct a_funcs *c) {
	struct par_window_open *a;

	APP_MALLOC_RET_VOID(a, sizeof(struct par_window_open));

	if(dynload_window_open_pre(c, a) != 0) {
		(void) free(a);

		return;
	}

	(void) gui_window_open(&a->window);
	(void) free(a);
}

__VISIBILITY_DEFAULT__ void dynload_window_icon(struct a_funcs *c) {
	struct par_window_icon a;

	if(dynload_window_icon_pre(c, &a) != 0) return;

	(void) gui_window_icon(a.handle, a.icon);
}

__VISIBILITY_DEFAULT__ void dynload_window_close(struct a_funcs *c) {
	struct par_window_close a;

	if(dynload_window_close_pre(c, &a) != 0) return;

	(void) gui_window_close(a.handle);
}

__VISIBILITY_DEFAULT__ void dynload_window_map(struct a_funcs *c) {
	struct par_window_map a;

	if(dynload_window_map_pre(c, &a) != 0) return;

	(void) gui_window_map(a.handle);
}

__VISIBILITY_DEFAULT__ void dynload_window_unmap(struct a_funcs *c) {
	struct par_window_unmap a;

	if(dynload_window_unmap_pre(c, &a) != 0) return;

	(void) gui_window_unmap(a.handle);
}

__VISIBILITY_DEFAULT__ void dynload_window_set_attrs(struct a_funcs *c) {
	struct par_window_attrs a;

	if(dynload_window_attrs_pre(c, &a) != 0) return;

	(void) gui_window_set_attrs(a.handle, &a.attribute);
}

__VISIBILITY_DEFAULT__ void dynload_window_init(struct a_funcs *c) {
	if(dynload_window_init_pre(c) != 0) return;
#if defined(PROG_HAS_X11)
	/* Thread worker_draw() must be spawned first */
	(void) thread_spawn(NULL, worker_draw, NULL, NULL);
#if ! defined(PROG_DISABLE_MENU)
	(void) thread_spawn(NULL, worker_menu, NULL, NULL);
#endif
#endif
}
#endif
#if ! defined(PROG_DISABLE_GUI) && ! defined(PROG_DISABLE_MENU)
__VISIBILITY_DEFAULT__ void dynload_menu_bar_hide(struct a_funcs *c) {
	struct par_menu_bar_disp a;

	if(dynload_menu_bar_disp_pre(c, &a) != 0) return;
#if defined(PROG_HAS_X11)
	(void) menu_hide(a.handle);
#else
	(void) a;
#endif
}

__VISIBILITY_DEFAULT__ void dynload_menu_bar_show(struct a_funcs *c) {
	struct par_menu_bar_disp a;

	if(dynload_menu_bar_disp_pre(c, &a) != 0) return;
#if defined(PROG_HAS_X11)
	(void) menu_show(a.handle);
#else
	(void) a;
#endif
}

__VISIBILITY_DEFAULT__ void dynload_menu_item_disable(struct a_funcs *c) {
	struct par_menu_item_state a;

	if(dynload_menu_item_state_pre(c, &a) != 0) return;
#if defined(PROG_HAS_X11)
	(void) menu_disable(a.handle, a.tag);
#else
	(void) a;
#endif
}

__VISIBILITY_DEFAULT__ void dynload_menu_item_enable(struct a_funcs *c) {
	struct par_menu_item_state a;

	if(dynload_menu_item_state_pre(c, &a) != 0) return;
#if defined(PROG_HAS_X11)
	(void) menu_enable(a.handle, a.tag);
#else
	(void) a;
#endif
}
#endif
#if ! defined(PROG_DISABLE_AUDIO)
__VISIBILITY_DEFAULT__ unsigned int dynload_audio_create_noise_white(struct a_funcs *c) {
	struct par_audio_create_noise_white a;

	if(dynload_audio_create_noise_white_pre(c, &a) != 0) return(0);

	return(mixer_create_noise_white(a.secs));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_audio_create_wave_sine(struct a_funcs *c) {
	struct par_audio_create_wave_sine a;

	if(dynload_audio_create_wave_sine_pre(c, &a) != 0) return(0);

	return(mixer_create_wave_sine(a.secs, a.freq));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_audio_create_wave_square(struct a_funcs *c) {
	struct par_audio_create_wave_square a;

	if(dynload_audio_create_wave_square_pre(c, &a) != 0) return(0);

	return(mixer_create_wave_square(a.secs, a.freq));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_audio_create_wave_random(struct a_funcs *c) {
	struct par_audio_create_wave_random a;

	if(dynload_audio_create_wave_random_pre(c, &a) != 0) return(0);

	return(mixer_create_wave_random(a.secs, a.freq, a.amplitude));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_audio_open(struct a_funcs *c) {
	struct par_audio_open a;

	if(dynload_audio_open_pre(c, &a) != 0) return(0);

	return(mixer_open(a.audio));
}

__VISIBILITY_DEFAULT__ void dynload_audio_close(struct a_funcs *c) {
	struct par_audio_close a;

	if(dynload_audio_close_pre(c, &a) != 0) return;

	(void) mixer_close(a.handle);
}

__VISIBILITY_DEFAULT__ void dynload_audio_play(struct a_funcs *c) {
	struct par_audio_play a;

	if(dynload_audio_play_pre(c, &a) != 0) return;

	(void) mixer_play(a.handle, a.vol, a.pan);
}

__VISIBILITY_DEFAULT__ void dynload_audio_wait(struct a_funcs *c) {
	struct par_audio_wait a;

	if(dynload_audio_wait_pre(c, &a) != 0) return;

	(void) mixer_wait(a.handle);
}

__VISIBILITY_DEFAULT__ void dynload_audio_cut(struct a_funcs *c) {
	struct par_audio_cut a;

	if(dynload_audio_cut_pre(c, &a) != 0) return;

	(void) mixer_cut(a.handle);
}

__VISIBILITY_DEFAULT__ void dynload_audio_solo(struct a_funcs *c) {
	struct par_audio_solo a;

	if(dynload_audio_solo_pre(c, &a) != 0) return;

	(void) mixer_solo(a.handle);
}

__VISIBILITY_DEFAULT__ void dynload_audio_hold(struct a_funcs *c) {
	struct par_audio_hold a;

	if(dynload_audio_hold_pre(c, &a) != 0) return;

	(void) mixer_hold(a.handle);
}

__VISIBILITY_DEFAULT__ void dynload_audio_cancel(struct a_funcs *c) {
	struct par_audio_cancel a;

	if(dynload_audio_cancel_pre(c, &a) != 0) return;

	(void) mixer_cancel(a.handle);
}

__VISIBILITY_DEFAULT__ float dynload_audio_pan_get(struct a_funcs *c) {
	struct par_audio_pan_get a;

	if(dynload_audio_pan_get_pre(c, &a) != 0) return(0.0);

	return(mixer_pan_get(a.handle));
}

__VISIBILITY_DEFAULT__ void dynload_audio_pan_set(struct a_funcs *c) {
	struct par_audio_pan_set a;

	if(dynload_audio_pan_set_pre(c, &a) != 0) return;

	(void) mixer_pan_set(a.handle, a.pan);
}

__VISIBILITY_DEFAULT__ void dynload_audio_pan_inc(struct a_funcs *c) {
	struct par_audio_pan_inc a;

	if(dynload_audio_pan_inc_pre(c, &a) != 0) return;

	(void) mixer_pan_inc(a.handle, a.pan);
}

__VISIBILITY_DEFAULT__ void dynload_audio_pan_dec(struct a_funcs *c) {
	struct par_audio_pan_dec a;

	if(dynload_audio_pan_dec_pre(c, &a) != 0) return;

	(void) mixer_pan_dec(a.handle, a.pan);
}

__VISIBILITY_DEFAULT__ float dynload_audio_vol_get(struct a_funcs *c) {
	struct par_audio_vol_get a;

	if(dynload_audio_vol_get_pre(c, &a) != 0) return(0.0);

	return(mixer_vol_get(a.handle));
}

__VISIBILITY_DEFAULT__ void dynload_audio_vol_set(struct a_funcs *c) {
	struct par_audio_vol_set a;

	if(dynload_audio_vol_set_pre(c, &a) != 0) return;

	(void) mixer_vol_set(a.handle, a.vol);
}

__VISIBILITY_DEFAULT__ void dynload_audio_vol_inc(struct a_funcs *c) {
	struct par_audio_vol_inc a;

	if(dynload_audio_vol_inc_pre(c, &a) != 0) return;

	(void) mixer_vol_inc(a.handle, a.vol);
}

__VISIBILITY_DEFAULT__ void dynload_audio_vol_dec(struct a_funcs *c) {
	struct par_audio_vol_dec a;

	if(dynload_audio_vol_dec_pre(c, &a) != 0) return;

	(void) mixer_vol_dec(a.handle, a.vol);
}

__VISIBILITY_DEFAULT__ float dynload_audio_master_get(struct a_funcs *c) {
	if(dynload_audio_master_get_pre(c) != 0) return(0.0);

	return(mixer_master_get());
}

__VISIBILITY_DEFAULT__ void dynload_audio_master_set(struct a_funcs *c) {
	struct par_audio_master_set a;

	if(dynload_audio_master_set_pre(c, &a) != 0) return;

	(void) mixer_master_set(a.vol);
}

__VISIBILITY_DEFAULT__ void dynload_audio_master_inc(struct a_funcs *c) {
	struct par_audio_master_inc a;

	if(dynload_audio_master_inc_pre(c, &a) != 0) return;

	(void) mixer_master_inc(a.vol);
}

__VISIBILITY_DEFAULT__ void dynload_audio_master_dec(struct a_funcs *c) {
	struct par_audio_master_dec a;

	if(dynload_audio_master_dec_pre(c, &a) != 0) return;

	(void) mixer_master_dec(a.vol);
}

__VISIBILITY_DEFAULT__ void dynload_audio_init(struct a_funcs *c) {
	if(dynload_audio_init_pre(c) != 0) return;

	(void) thread_spawn(NULL, worker_play, NULL, NULL);
}
#endif
__VISIBILITY_DEFAULT__ void dynload_sleep(struct a_funcs *c) {
	struct par_system_sleep a;

	if(dynload_system_sleep_pre(c, &a) != 0) return;

	(void) timer_wait(a.secs, a.nsecs);
}

__VISIBILITY_DEFAULT__ void dynload_exit(__UNUSED__ struct a_funcs *c) {
	(void) main_stop();
}

__VISIBILITY_DEFAULT__ int dynload_fork(struct a_funcs *c) {
	if(dynload_system_fork_pre(c) != 0) return(-1);

	return(system_fork());
}

__VISIBILITY_DEFAULT__ void dynload_exec(struct a_funcs *c) {
	struct par_system_exec a;

	if(dynload_system_exec_pre(c, &a) != 0) return;

	(void) system_exec(a.command, a.params);

	(void) dynload_system_exec_pre_free(a.params, c->c);
}

__VISIBILITY_DEFAULT__ void dynload_system(struct a_funcs *c) {
	struct par_system_system a;

	if(dynload_system_system_pre(c, &a) != 0) return;

	(void) system_system(a.command);
}

__VISIBILITY_DEFAULT__ uint64_t dynload_time(struct a_funcs *c) {
	if(dynload_system_time_pre(c) != 0) return(0);

	return((uint64_t) timer_get_secs());
}

__VISIBILITY_DEFAULT__ int dynload_timer(struct a_funcs *c) {
	struct par_system_timer a;

	if(dynload_system_timer_pre(c, &a, worker_dsl_timer) != 0) return(-1);

	if(worker_dsl_timer_par(&a.par_timer) != 0) return(-1);

	return(timer_init(a.secs, a.nsecs, (void *) a.cb_timer));
}
#if ! defined(PROG_DISABLE_GUI) && ! defined(PROG_DISABLE_WIDGET)
__VISIBILITY_DEFAULT__ void dynload_widget_refresh(struct a_funcs *c) {
	struct par_widget_refresh a;

	struct w_stack *w;

	if(dynload_widget_refresh_pre(c, &a) != 0) return;

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return;

	(void) widget_refresh(w);
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_block(struct a_funcs *c) {
	struct par_widget_create_block a;

	struct w_stack *w;

	if(dynload_widget_create_block_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_block(w, a.name,
		a.x, a.y, a.width, a.height));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_label(struct a_funcs *c) {
	struct par_widget_create_label a;

	struct w_stack *w;

	if(dynload_widget_create_label_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_label(w, a.name,
		a.x, a.y));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_lamp(struct a_funcs *c) {
	struct par_widget_create_lamp a;

	struct w_stack *w;

	if(dynload_widget_create_lamp_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_lamp(w, a.name,
		a.x, a.y, a.subtype, a.titlepos, a.u, a.v));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_led_1(struct a_funcs *c) {
	struct par_widget_create_led a;

	struct w_stack *w;

	if(dynload_widget_create_led_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_led_1(w, a.name,
		a.x, a.y, a.subtype, a.titlepos, a.u, a.v));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_led_2(struct a_funcs *c) {
	struct par_widget_create_led a;

	struct w_stack *w;

	if(dynload_widget_create_led_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_led_2(w, a.name,
		a.x, a.y, a.subtype, a.titlepos, a.u, a.v));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_led_3(struct a_funcs *c) {
	struct par_widget_create_led a;

	struct w_stack *w;

	if(dynload_widget_create_led_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_led_3(w, a.name,
		a.x, a.y, a.subtype, a.titlepos, a.u, a.v));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_pushbutton_1(struct a_funcs *c) {
	struct par_widget_create_pushbutton a;

	struct w_stack *w;

	if(dynload_widget_create_pushbutton_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_pushbutton_1(w, a.name,
		a.x, a.y, a.subtype, a.titlepos, a.u, a.v, a.sticky));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_pushbutton_2(struct a_funcs *c) {
	struct par_widget_create_pushbutton a;

	struct w_stack *w;

	if(dynload_widget_create_pushbutton_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_pushbutton_2(w, a.name,
		a.x, a.y, a.subtype, a.titlepos, a.u, a.v, a.sticky));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_pushbutton_3(struct a_funcs *c) {
	struct par_widget_create_pushbutton a;

	struct w_stack *w;

	if(dynload_widget_create_pushbutton_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_pushbutton_3(w, a.name,
		a.x, a.y, a.subtype, a.titlepos, a.u, a.v, a.sticky));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_slideswitch(struct a_funcs *c) {
	struct par_widget_create_slideswitch a;

	struct w_stack *w;

	if(dynload_widget_create_slideswitch_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_slideswitch(w, a.name,
		a.x, a.y, a.subtype, a.titlepos, a.u, a.v, a.length, a.steps, a.startstep));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_toggleswitch(struct a_funcs *c) {
	struct par_widget_create_toggleswitch a;

	struct w_stack *w;

	if(dynload_widget_create_toggleswitch_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_toggleswitch(w, a.name,
		a.x, a.y, a.subtype, a.titlepos, a.u, a.v, a.steps, a.startstep));
}

__VISIBILITY_DEFAULT__ int dynload_widget_create_turnswitch(struct a_funcs *c) {
	struct par_widget_create_turnswitch a;

	struct w_stack *w;

	if(dynload_widget_create_turnswitch_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_create_turnswitch(w, a.name,
		a.x, a.y, a.subtype, a.titlepos, a.u, a.v, a.minangle, a.maxangle, a.steps, a.startstep));
}

__VISIBILITY_DEFAULT__ int dynload_widget_delete(struct a_funcs *c) {
	struct par_widget_delete a;

	struct w_stack *w;

	if(dynload_widget_delete_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_delete(w, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_widget_disable(struct a_funcs *c) {
	struct par_widget_state a;

	struct w_stack *w;

	if(dynload_widget_state_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_disable(w, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_widget_enable(struct a_funcs *c) {
	struct par_widget_state a;

	struct w_stack *w;

	if(dynload_widget_state_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_enable(w, a.name));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_widget_change_set(struct a_funcs *c) {
	struct par_widget_change_set a;

	struct w_stack *w;

	if(dynload_widget_change_set_pre(c, &a) != 0) return(0);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(0);

	return(widget_change_set(w, a.set));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_widget_step_get(struct a_funcs *c) {
	unsigned int r;

	struct par_widget_step_get a;

	struct w_stack *w;

	if(dynload_widget_step_get_pre(c, &a) != 0) return(0);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(0);
	if((r = widget_step_get(w, a.name, &r)) != 0) return(0);

	return(r);
}

__VISIBILITY_DEFAULT__ unsigned int dynload_widget_step_get_min(struct a_funcs *c) {
	unsigned int r;

	struct par_widget_step_get a;

	struct w_stack *w;

	if(dynload_widget_step_get_pre(c, &a) != 0) return(0);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(0);
	if((r = widget_step_get_min(w, a.name, &r)) != 0) return(0);

	return(r);
}

__VISIBILITY_DEFAULT__ unsigned int dynload_widget_step_get_max(struct a_funcs *c) {
	unsigned int r;

	struct par_widget_step_get a;

	struct w_stack *w;

	if(dynload_widget_step_get_pre(c, &a) != 0) return(0);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(0);
	if((r = widget_step_get_max(w, a.name, &r)) != 0) return(0);

	return(r);
}

__VISIBILITY_DEFAULT__ int dynload_widget_step_set(struct a_funcs *c) {
	struct par_widget_step_set a;

	struct w_stack *w;

	if(dynload_widget_step_set_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_step_set(w, a.name,
		a.step));
}

__VISIBILITY_DEFAULT__ int dynload_widget_trigger_set(struct a_funcs *c) {
	struct par_widget_trigger_set a;

	struct w_stack *w;

	if(dynload_widget_trigger_set_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_trigger_set(w, a.name,
		a.trigger));
}

__VISIBILITY_DEFAULT__ int dynload_widget_indicator_set(struct a_funcs *c) {
	struct par_widget_indicator_set a;

	struct w_stack *w;

	if(dynload_widget_indicator_set_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_indicator_set(w, a.name,
		a.charset, a.font, a.font_size, a.font_res, a.mode, a.offset, &a.color));
}

__VISIBILITY_DEFAULT__ int dynload_widget_update_border(struct a_funcs *c) {
	struct par_widget_update_border a;

	struct w_stack *w;

	if(dynload_widget_update_border_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_update_border(w, a.name,
		&a.color, a.thickness));
}

__VISIBILITY_DEFAULT__ int dynload_widget_update_color(struct a_funcs *c) {
	struct par_widget_update_color a;

	struct w_stack *w;

	if(dynload_widget_update_color_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_update_color(w, a.name,
		&a.color));
}

__VISIBILITY_DEFAULT__ int dynload_widget_update_image(struct a_funcs *c) {
	struct par_widget_update_image a;

	struct w_stack *w;

	if(dynload_widget_update_image_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_update_image(w, a.name,
		a.image, a.x, a.y, a.width, a.height));
}

__VISIBILITY_DEFAULT__ int dynload_widget_update_image_file(struct a_funcs *c) {
	struct par_widget_update_image_file a;

	struct w_stack *w;

	if(dynload_widget_update_image_file_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_update_image_file(w, a.name,
		a.image));
}

__VISIBILITY_DEFAULT__ int dynload_widget_update_label(struct a_funcs *c) {
	struct par_widget_update_label a;

	struct w_stack *w;

	if(dynload_widget_update_label_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_update_label(w, a.name,
		a.label, a.charset, a.font, a.font_size, a.font_res, a.font_just, &a.color));
}

__VISIBILITY_DEFAULT__ int dynload_widget_update_scale_bars(struct a_funcs *c) {
	struct par_widget_update_scale a;

	struct w_stack *w;

	if(dynload_widget_update_scale_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_update_scale_bars(w, a.name,
		a.charset, a.font, a.font_size, a.font_res, NULL, a.start, a.end, a.bars, &a.color));
}

__VISIBILITY_DEFAULT__ int dynload_widget_update_scale_dots(struct a_funcs *c) {
	struct par_widget_update_scale a;

	struct w_stack *w;

	if(dynload_widget_update_scale_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_update_scale_dots(w, a.name,
		a.charset, a.font, a.font_size, a.font_res, NULL, a.start, a.end, a.bars, &a.color));
}

__VISIBILITY_DEFAULT__ int dynload_widget_update_scale_nude(struct a_funcs *c) {
	struct par_widget_update_scale a;

	struct w_stack *w;

	if(dynload_widget_update_scale_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_update_scale_nude(w, a.name,
		a.charset, a.font, a.font_size, a.font_res, NULL, a.start, a.end, a.bars, &a.color));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_add_pushbutton_push(struct a_funcs *c) {
	struct par_widget_cb_add a;

	struct w_stack *w;

	if(dynload_widget_cb_add_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_add_pushbutton_push(w, a.name,
		a.cb));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_add_slideswitch_slide(struct a_funcs *c) {
	struct par_widget_cb_add a;

	struct w_stack *w;

	if(dynload_widget_cb_add_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_add_slideswitch_slide(w, a.name,
		a.cb));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_add_toggleswitch_toggle(struct a_funcs *c) {
	struct par_widget_cb_add a;

	struct w_stack *w;

	if(dynload_widget_cb_add_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_add_toggleswitch_toggle(w, a.name,
		a.cb));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_add_turnswitch_turn(struct a_funcs *c) {
	struct par_widget_cb_add a;

	struct w_stack *w;

	if(dynload_widget_cb_add_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_add_turnswitch_turn(w, a.name,
		a.cb));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_add_key_press(struct a_funcs *c) {
	struct par_widget_cb_add a;

	struct w_stack *w;

	if(dynload_widget_cb_add_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_add_key_press(w, a.name,
		a.cb));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_add_key_release(struct a_funcs *c) {
	struct par_widget_cb_add a;

	struct w_stack *w;

	if(dynload_widget_cb_add_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_add_key_release(w, a.name,
		a.cb));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_add_button_press(struct a_funcs *c) {
	struct par_widget_cb_add a;

	struct w_stack *w;

	if(dynload_widget_cb_add_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_add_button_press(w, a.name,
		a.cb));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_add_button_release(struct a_funcs *c) {
	struct par_widget_cb_add a;

	struct w_stack *w;

	if(dynload_widget_cb_add_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_add_button_release(w, a.name,
		a.cb));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_delete_pushbutton_push(struct a_funcs *c) {
	struct par_widget_cb_delete a;

	struct w_stack *w;

	if(dynload_widget_cb_delete_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_delete_pushbutton_push(w, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_delete_slideswitch_slide(struct a_funcs *c) {
	struct par_widget_cb_delete a;

	struct w_stack *w;

	if(dynload_widget_cb_delete_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_delete_slideswitch_slide(w, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_delete_toggleswitch_toggle(struct a_funcs *c) {
	struct par_widget_cb_delete a;

	struct w_stack *w;

	if(dynload_widget_cb_delete_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_delete_toggleswitch_toggle(w, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_delete_turnswitch_turn(struct a_funcs *c) {
	struct par_widget_cb_delete a;

	struct w_stack *w;

	if(dynload_widget_cb_delete_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_delete_turnswitch_turn(w, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_delete_key_press(struct a_funcs *c) {
	struct par_widget_cb_delete a;

	struct w_stack *w;

	if(dynload_widget_cb_delete_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_delete_key_press(w, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_delete_key_release(struct a_funcs *c) {
	struct par_widget_cb_delete a;

	struct w_stack *w;

	if(dynload_widget_cb_delete_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_delete_key_release(w, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_delete_button_press(struct a_funcs *c) {
	struct par_widget_cb_delete a;

	struct w_stack *w;

	if(dynload_widget_cb_delete_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_delete_button_press(w, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_widget_cb_delete_button_release(struct a_funcs *c) {
	struct par_widget_cb_delete a;

	struct w_stack *w;

	if(dynload_widget_cb_delete_pre(c, &a) != 0) return(-1);

	if((w = window_get_widget_by_handle(a.handle)) == NULL) return(-1);

	return(widget_cb_delete_button_release(w, a.name));
}
#endif
#if ! defined(PROG_DISABLE_GUI) && ! defined(PROG_DISABLE_BOB)
__VISIBILITY_DEFAULT__ unsigned int dynload_bob_get_altitude(struct a_funcs *c) {
	struct par_bob_get_altitude a;

	if(dynload_bob_get_altitude_pre(c, &a) != 0) return(0);

	return(bob_get_altitude(a.container, a.bob));
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_altitude(struct a_funcs *c) {
	struct par_bob_set_altitude a;

	if(dynload_bob_set_altitude_pre(c, &a) != 0) return;

	(void) bob_set_altitude(a.container, a.bob, a.altitude);
}

__VISIBILITY_DEFAULT__ void dynload_bob_add_altitude(struct a_funcs *c) {
	struct par_bob_add_altitude a;

	if(dynload_bob_add_altitude_pre(c, &a) != 0) return;

	(void) bob_add_altitude(a.container, a.bob, a.altitude);
}

__VISIBILITY_DEFAULT__ void dynload_bob_sub_altitude(struct a_funcs *c) {
	struct par_bob_sub_altitude a;

	if(dynload_bob_sub_altitude_pre(c, &a) != 0) return;

	(void) bob_sub_altitude(a.container, a.bob, a.altitude);
}

__VISIBILITY_DEFAULT__ int dynload_bob_get_x_position(struct a_funcs *c) {
	struct par_bob_get_x_position a;

	if(dynload_bob_get_x_position_pre(c, &a) != 0) return(0);

	return(bob_get_x_position(a.container, a.bob));
}

__VISIBILITY_DEFAULT__ int dynload_bob_get_y_position(struct a_funcs *c) {
	struct par_bob_get_y_position a;

	if(dynload_bob_get_y_position_pre(c, &a) != 0) return(0);

	return(bob_get_y_position(a.container, a.bob));
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_position(struct a_funcs *c) {
	struct par_bob_set_position a;

	if(dynload_bob_set_position_pre(c, &a) != 0) return;

	(void) bob_set_position(a.container, a.bob, a.x, a.y);
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_x_position(struct a_funcs *c) {
	struct par_bob_set_x_position a;

	if(dynload_bob_set_x_position_pre(c, &a) != 0) return;

	(void) bob_set_x_position(a.container, a.bob, a.x);
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_y_position(struct a_funcs *c) {
	struct par_bob_set_y_position a;

	if(dynload_bob_set_y_position_pre(c, &a) != 0) return;

	(void) bob_set_y_position(a.container, a.bob, a.y);
}

__VISIBILITY_DEFAULT__ void dynload_bob_add_x_position(struct a_funcs *c) {
	struct par_bob_add_x_position a;

	if(dynload_bob_add_x_position_pre(c, &a) != 0) return;

	(void) bob_add_x_position(a.container, a.bob, a.x);
}

__VISIBILITY_DEFAULT__ void dynload_bob_add_y_position(struct a_funcs *c) {
	struct par_bob_add_y_position a;

	if(dynload_bob_add_y_position_pre(c, &a) != 0) return;

	(void) bob_add_y_position(a.container, a.bob, a.y);
}

__VISIBILITY_DEFAULT__ void dynload_bob_sub_x_position(struct a_funcs *c) {
	struct par_bob_sub_x_position a;

	if(dynload_bob_sub_x_position_pre(c, &a) != 0) return;

	(void) bob_sub_x_position(a.container, a.bob, a.x);
}

__VISIBILITY_DEFAULT__ void dynload_bob_sub_y_position(struct a_funcs *c) {
	struct par_bob_sub_y_position a;

	if(dynload_bob_sub_y_position_pre(c, &a) != 0) return;

	(void) bob_sub_y_position(a.container, a.bob, a.y);
}

__VISIBILITY_DEFAULT__ double dynload_bob_get_angle(struct a_funcs *c) {
	struct par_bob_get_angle a;

	if(dynload_bob_get_angle_pre(c, &a) != 0) return(0.0);

	return(bob_get_angle(a.container, a.bob));
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_angle_position(struct a_funcs *c) {
	struct par_bob_set_angle_position a;

	if(dynload_bob_set_angle_position_pre(c, &a) != 0) return;

	(void) bob_set_angle_position(a.container, a.bob, a.angle, a.distance);
}

__VISIBILITY_DEFAULT__ int dynload_bob_get_depth(struct a_funcs *c) {
	struct par_bob_get_depth a;

	if(dynload_bob_get_depth_pre(c, &a) != 0) return(0);

	return(bob_get_depth(a.container, a.bob));
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_depth(struct a_funcs *c) {
	struct par_bob_set_depth a;

	if(dynload_bob_set_depth_pre(c, &a) != 0) return;

	(void) bob_set_depth(a.container, a.bob, a.depth);
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_get_distance(struct a_funcs *c) {
	struct par_bob_get_distance a;

	if(dynload_bob_get_distance_pre(c, &a) != 0) return(0);

	return(bob_get_distance(a.a_container, a.a_bob, a.b_container, a.b_bob));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_get_measure(struct a_funcs *c) {
	struct par_bob_get_measure a;

	if(dynload_bob_get_measure_pre(c, &a) != 0) return(0);

	return(bob_get_measure(a.container, a.bob, a.x, a.y));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_get_map(struct a_funcs *c) {
	struct par_bob_get_map a;

	if(dynload_bob_get_map_pre(c, &a) != 0) return(0);

	return(bob_get_map(a.container, a.bob));
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_map(struct a_funcs *c) {
	struct par_bob_set_map a;

	if(dynload_bob_set_map_pre(c, &a) != 0) return;

	(void) bob_set_map(a.container, a.bob, a.map);
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_get_playdirection(struct a_funcs *c) {
	struct par_bob_get_playdirection a;

	if(dynload_bob_get_playdirection_pre(c, &a) != 0) return(0);

	return(bob_get_playdirection(a.container, a.bob));
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_playdirection(struct a_funcs *c) {
	struct par_bob_set_playdirection a;

	if(dynload_bob_set_playdirection_pre(c, &a) != 0) return;

	(void) bob_set_playdirection(a.container, a.bob, a.playdirection);
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_get_playmode(struct a_funcs *c) {
	struct par_bob_get_playmode a;

	if(dynload_bob_get_playmode_pre(c, &a) != 0) return(0);

	return(bob_get_playmode(a.container, a.bob));
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_playmode(struct a_funcs *c) {
	struct par_bob_set_playmode a;

	if(dynload_bob_set_playmode_pre(c, &a) != 0) return;

	(void) bob_set_playmode(a.container, a.bob, a.playmode);
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_get_playskip(struct a_funcs *c) {
	struct par_bob_get_playskip a;

	if(dynload_bob_get_playskip_pre(c, &a) != 0) return(0);

	return(bob_get_playskip(a.container, a.bob));
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_playskip(struct a_funcs *c) {
	struct par_bob_set_playskip a;

	if(dynload_bob_set_playskip_pre(c, &a) != 0) return;

	(void) bob_set_playskip(a.container, a.bob, a.playskip);
}

__VISIBILITY_DEFAULT__ double dynload_bob_get_playspeed(struct a_funcs *c) {
	struct par_bob_get_playspeed a;

	if(dynload_bob_get_playspeed_pre(c, &a) != 0) return(0.0);

	return(bob_get_playspeed(a.container, a.bob));
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_playspeed(struct a_funcs *c) {
	struct par_bob_set_playspeed a;

	if(dynload_bob_set_playspeed_pre(c, &a) != 0) return;

	(void) bob_set_playspeed(a.container, a.bob, a.playspeed);
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_frame(struct a_funcs *c) {
	struct par_bob_set_frame a;

	if(dynload_bob_set_frame_pre(c, &a) != 0) return;

	(void) bob_set_frame(a.container, a.bob, a.frame);
}

__VISIBILITY_DEFAULT__ void dynload_bob_add_frame(struct a_funcs *c) {
	struct par_bob_add_frame a;

	if(dynload_bob_add_frame_pre(c, &a) != 0) return;

	(void) bob_add_frame(a.container, a.bob, a.frame);
}

__VISIBILITY_DEFAULT__ void dynload_bob_sub_frame(struct a_funcs *c) {
	struct par_bob_sub_frame a;

	if(dynload_bob_sub_frame_pre(c, &a) != 0) return;

	(void) bob_sub_frame(a.container, a.bob, a.frame);
}

__VISIBILITY_DEFAULT__ int dynload_bob_get_container_depth(struct a_funcs *c) {
	struct par_bob_get_container_depth a;

	if(dynload_bob_get_container_depth_pre(c, &a) != 0) return(0);

	return(bob_get_container_depth(a.container));
}

__VISIBILITY_DEFAULT__ void dynload_bob_set_container_depth(struct a_funcs *c) {
	struct par_bob_set_container_depth a;

	if(dynload_bob_set_container_depth_pre(c, &a) != 0) return;

	(void) bob_set_container_depth(a.container, a.depth);
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_create(struct a_funcs *c) {
	struct par_bob_create a;

	if(dynload_bob_create_pre(c, &a) != 0) return(0);

	return(bob_create(a.file, a.container, a.altitude, a.x, a.y, a.depth));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_create_background(struct a_funcs *c) {
	struct par_bob_create_background a;

	if(dynload_bob_create_background_pre(c, &a) != 0) return(0);

	return(bob_create_background(a.file, a.container, a.opaque, a.depth));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_create_container(struct a_funcs *c) {
	struct par_bob_create_container a;

	if(dynload_bob_create_container_pre(c, &a) != 0) return(0);

	return(bob_create_container(a.handle, a.depth));
}

__VISIBILITY_DEFAULT__ void dynload_bob_delete(struct a_funcs *c) {
	struct par_bob_delete a;

	if(dynload_bob_delete_pre(c, &a) != 0) return;

	(void) bob_delete(a.container, a.bob);
}

__VISIBILITY_DEFAULT__ void dynload_bob_delete_container(struct a_funcs *c) {
	struct par_bob_delete_container a;

	if(dynload_bob_delete_container_pre(c, &a) != 0) return;

	(void) bob_delete_container(a.container);
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_init_file(struct a_funcs *c) {
	struct par_bob_init_file a;

	if(dynload_bob_init_file_pre(c, &a) != 0) return(0);

	return(bob_init_file(a.name));
}

__VISIBILITY_DEFAULT__ unsigned int dynload_bob_init_image(struct a_funcs *c) {
	struct par_bob_init_image a;

	if(dynload_bob_init_image_pre(c, &a) != 0) return(0);

	return(bob_init_image(a.width, a.height));
}

__VISIBILITY_DEFAULT__ void dynload_bob_free_file(struct a_funcs *c) {
	struct par_bob_free_file a;

	if(dynload_bob_free_file_pre(c, &a) != 0) return;

	(void) bob_free_file(a.file);
}

__VISIBILITY_DEFAULT__ void dynload_bob_free_image(struct a_funcs *c) {
	struct par_bob_free_image a;

	if(dynload_bob_free_image_pre(c, &a) != 0) return;

	(void) bob_free_image(a.image);
}
#endif
#if ! defined(PROG_DISABLE_IMAGE)
__VISIBILITY_DEFAULT__ void *dynload_image_read(struct a_funcs *c) {
	struct par_image_read a;

	struct t_img *t;

	if(dynload_image_read_pre(c, &a) != 0) return(NULL);

	if((t = image_read(a.name, 1)) == NULL) return(NULL);

	(void) dynload_image_read_op(&a, t);

	return(dynload_ret_image(&a.image));
}

__VISIBILITY_DEFAULT__ void *dynload_image_read_bmp(struct a_funcs *c) {
	struct par_image_read a;

	struct t_img *t;

	if(dynload_image_read_pre(c, &a) != 0) return(NULL);

	if((t = image_bmp_read(a.name, 1)) == NULL) return(NULL);

	(void) dynload_image_read_op(&a, t);

	return(dynload_ret_image(&a.image));
}

__VISIBILITY_DEFAULT__ void *dynload_image_read_tga(struct a_funcs *c) {
	struct par_image_read a;

	struct t_img *t;

	if(dynload_image_read_pre(c, &a) != 0) return(NULL);

	if((t = image_tga_read(a.name, 1)) == NULL) return(NULL);

	(void) dynload_image_read_op(&a, t);

	return(dynload_ret_image(&a.image));
}

static void dynload_image_read_op(struct par_image_read *a, struct t_img *t) {
	a->image.image.w = (unsigned int) t->w;
	a->image.image.h = (unsigned int) t->h;

	a->image.image.s = t->p;

	a->image.s = NULL;
}

__VISIBILITY_DEFAULT__ int dynload_image_write_bmp(struct a_funcs *c) {
	struct par_image_write a;

	if(dynload_image_write_pre(c, &a) != 0) return(-1);

	return(image_bmp_write_32(a.image, a.width, a.height, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_image_write_cel(struct a_funcs *c) {
	struct par_image_write a;

	if(dynload_image_write_pre(c, &a) != 0) return(-1);

	return(image_cel_write_32(a.image, a.width, a.height, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_image_write_pix(struct a_funcs *c) {
	struct par_image_write a;

	if(dynload_image_write_pre(c, &a) != 0) return(-1);

	return(image_pix_write_32(a.image, a.width, a.height, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_image_write_ppm(struct a_funcs *c) {
	struct par_image_write a;

	if(dynload_image_write_pre(c, &a) != 0) return(-1);

	return(image_ppm_write_32(a.image, a.width, a.height, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_image_write_ras(struct a_funcs *c) {
	struct par_image_write a;

	if(dynload_image_write_pre(c, &a) != 0) return(-1);

	return(image_ras_write_32(a.image, a.width, a.height, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_image_write_rgb(struct a_funcs *c) {
	struct par_image_write a;

	if(dynload_image_write_pre(c, &a) != 0) return(-1);

	return(image_rgb_write_32(a.image, a.width, a.height, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_image_write_rla(struct a_funcs *c) {
	struct par_image_write a;

	if(dynload_image_write_pre(c, &a) != 0) return(-1);

	return(image_rla_write_32(a.image, a.width, a.height, a.name));
}

__VISIBILITY_DEFAULT__ int dynload_image_write_tga(struct a_funcs *c) {
	struct par_image_write a;

	if(dynload_image_write_pre(c, &a) != 0) return(-1);

	return(image_tga_write_32(a.image, a.width, a.height, a.name));
}
#endif
#if ! defined(PROG_DISABLE_REMOTE)
__VISIBILITY_DEFAULT__ void dynload_remote_init(struct a_funcs *c) {
	if(dynload_remote_init_pre(c) != 0) return;

	(void) thread_spawn(NULL, worker_remote, NULL, NULL);
}
#endif
__VISIBILITY_DEFAULT__ void *dynload_node_get_system(struct a_funcs *c) {
	if(dynload_node_get_pre(c) != 0) return(NULL);

	return(dynload_ret_string((void *) node_get_system()));
}

__VISIBILITY_DEFAULT__ void *dynload_node_get_release(struct a_funcs *c) {
	if(dynload_node_get_pre(c) != 0) return(NULL);

	return(dynload_ret_string((void *) node_get_release()));
}

__VISIBILITY_DEFAULT__ void *dynload_node_get_machine(struct a_funcs *c) {
	if(dynload_node_get_pre(c) != 0) return(NULL);

	return(dynload_ret_string((void *) node_get_machine()));
}

__VISIBILITY_DEFAULT__ void *dynload_node_get_hostname(struct a_funcs *c) {
	if(dynload_node_get_pre(c) != 0) return(NULL);

	return(dynload_ret_string((void *) node_get_node()));
}

__VISIBILITY_DEFAULT__ void *dynload_node_get_username(struct a_funcs *c) {
	if(dynload_node_get_pre(c) != 0) return(NULL);

	return(dynload_ret_string((void *) node_get_user()));
}

__VISIBILITY_DEFAULT__ void *dynload_node_get_groupname(struct a_funcs *c) {
	if(dynload_node_get_pre(c) != 0) return(NULL);

	return(dynload_ret_string((void *) node_get_group()));
}

__VISIBILITY_DEFAULT__ void *dynload_node_get_homedir(struct a_funcs *c) {
	if(dynload_node_get_pre(c) != 0) return(NULL);

	return(dynload_ret_string((void *) node_get_homedir()));
}

static int dynload_clock_get_ticks_pre(struct a_funcs *c) {
	if(c->c != DYNLOAD_CLOCK_GET_TICKS_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_CLOCK_GET_TICKS_PARAMS);

		return(-1);
	}

	return(0);
}

static int dynload_clock_get_multiplier_pre(struct a_funcs *c) {
	if(c->c != DYNLOAD_CLOCK_GET_MULTIPLIER_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_CLOCK_GET_MULTIPLIER_PARAMS);

		return(-1);
	}

	return(0);
}

static int dynload_clock_set_pre(struct a_funcs *c, struct par_clock_set *a) {
	if(c->c != DYNLOAD_CLOCK_SET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_CLOCK_SET_PARAMS);

		return(-1);
	}

	/* Pass parameters to clock_set() */
	a->ticks = dynload_param_get_number(&c->p[0]);

	return(0);
}

static int dynload_clock_set_multiplier_pre(struct a_funcs *c, struct par_clock_set_multiplier *a) {
	if(c->c != DYNLOAD_CLOCK_SET_MULTIPLIER_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_CLOCK_SET_MULTIPLIER_PARAMS);

		return(-1);
	}

	/* Pass parameters to clock_set_multiplier() */
	a->multiplier = dynload_param_get_number(&c->p[0]);

	return(0);
}
#if ! defined(PROG_DISABLE_COLOR)
static int dynload_color_brightness_pre(struct a_funcs *c, struct par_color_brightness *a) {
	if(c->c != DYNLOAD_COLOR_BRIGHTNESS_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COLOR_BRIGHTNESS_PARAMS);

		return(-1);
	}

	/* Pass parameters to color_rgba_brightness() */
	a->color.pixel.p = dynload_pre_color(c, 0);

	return(0);
}

static int dynload_color_bv_index_pre(struct a_funcs *c, struct par_color_bv_index *a) {
	if(c->c != DYNLOAD_COLOR_BV_INDEX_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COLOR_BV_INDEX_PARAMS);

		return(-1);
	}

	/* Pass parameters to color_bv_to_rgba() */
	a->index = dynload_param_get_number(&c->p[0]);
	a->magnitude = dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_color_complement_pre(struct a_funcs *c, struct par_color_complement *a) {
	if(c->c != DYNLOAD_COLOR_COMPLEMENT_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COLOR_COMPLEMENT_PARAMS);

		return(-1);
	}

	/* Pass parameters to color_rgba_complement() */
	a->color.pixel.p = dynload_pre_color(c, 0);

	return(0);
}

static int dynload_color_mix_pre(struct a_funcs *c, struct par_color_mix *a) {
	if(c->c != DYNLOAD_COLOR_MIX_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COLOR_MIX_PARAMS);

		return(-1);
	}

	/* Pass parameters to color_rgba_mix() */
	a->color_a.pixel.p = dynload_pre_color(c, 0);
	a->color_b.pixel.p = dynload_pre_color(c, 1);

	a->factor = dynload_param_get_number(&c->p[2]);

	return(0);
}
#endif
#if ! defined(PROG_DISABLE_COORDS)
static int dynload_coords_mag_pre(struct a_funcs *c, struct par_coords_mag *a) {
	if(c->c != DYNLOAD_COORDS_MAG_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COORDS_MAG_PARAMS);

		return(-1);
	}

	/* Pass parameters to coords_mag_[2d|3d]() */
	(void) dynload_pre_point(c, 0, &a->pos.x, &a->pos.y, &a->pos.z);

	return(0);
}

static int dynload_coords_normalize_pre(struct a_funcs *c, struct par_coords_normalize *a) {
	if(c->c != DYNLOAD_COORDS_NORMALIZE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COORDS_NORMALIZE_PARAMS);

		return(-1);
	}

	/* Pass parameters to coords_normalize_[2d|3d]() */
	(void) dynload_pre_point(c, 0, &a->pos.x, &a->pos.y, &a->pos.z);

	return(0);
}

static int dynload_coords_difference_pre(struct a_funcs *c, struct par_coords_difference *a) {
	if(c->c != DYNLOAD_COORDS_DIFFERENCE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COORDS_DIFFERENCE_PARAMS);

		return(-1);
	}

	/* Pass parameters to coords_difference_[2d|3d]() */
	(void) dynload_pre_point(c, 0, &a->pos_a.x, &a->pos_a.y, &a->pos_a.z);
	(void) dynload_pre_point(c, 1, &a->pos_b.x, &a->pos_b.y, &a->pos_b.z);

	return(0);
}

static int dynload_coords_get_angle_pre(struct a_funcs *c, struct par_coords_get_angle *a) {
	if(c->c != DYNLOAD_COORDS_GET_ANGLE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COORDS_GET_ANGLE_PARAMS);

		return(-1);
	}

	/* Pass parameters to coords_position_to_angle() */
	(void) dynload_pre_point(c, 0, &a->pos.x, &a->pos.y, &a->pos.z);

	return(0);
}

static int dynload_coords_get_pos_pre(struct a_funcs *c, struct par_coords_get_pos *a) {
	if(c->c != DYNLOAD_COORDS_GET_POS_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COORDS_GET_POS_PARAMS);

		return(-1);
	}

	/* Pass parameters to coords_angle_distance_to_position() */
	a->angle = dynload_param_get_number(&c->p[0]);
	a->distance = dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_coords_dot_product_pre(struct a_funcs *c, struct par_coords_dot_product *a) {
	if(c->c != DYNLOAD_COORDS_DOT_PRODUCT_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COORDS_DOT_PRODUCT_PARAMS);

		return(-1);
	}

	/* Pass parameters to coords_dot() */
	(void) dynload_pre_point(c, 0, &a->pos_a.x, &a->pos_a.y, &a->pos_a.z);
	(void) dynload_pre_point(c, 1, &a->pos_b.x, &a->pos_b.y, &a->pos_b.z);

	return(0);
}

static int dynload_coords_intp_linear_pre(struct a_funcs *c, struct par_coords_intp_linear *a) {
	if(c->c != DYNLOAD_COORDS_INTP_LINEAR_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COORDS_INTP_LINEAR_PARAMS);

		return(-1);
	}

	/* Pass parameters to coords_intp_linear_[x|y|z]() */
	(void) dynload_pre_point(c, 0, &a->pos_a.x, &a->pos_a.y, &a->pos_a.z);
	(void) dynload_pre_point(c, 1, &a->pos_b.x, &a->pos_b.y, &a->pos_b.z);

	a->point = dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_coords_intp_cubic_pre(struct a_funcs *c, struct par_coords_intp_cubic *a) {
	if(c->c != DYNLOAD_COORDS_INTP_CUBIC_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COORDS_INTP_CUBIC_PARAMS);

		return(-1);
	}

	/* Pass parameters to coords_intp_cubic_[x|y|z]() */
	(void) dynload_pre_point(c, 0, &a->pos_a.x, &a->pos_a.y, &a->pos_a.z);
	(void) dynload_pre_point(c, 1, &a->pos_b.x, &a->pos_b.y, &a->pos_b.z);
	(void) dynload_pre_point(c, 2, &a->pos_c.x, &a->pos_c.y, &a->pos_c.z);
	(void) dynload_pre_point(c, 3, &a->pos_d.x, &a->pos_d.y, &a->pos_d.z);

	a->point = dynload_param_get_number(&c->p[4]);

	return(0);
}

static int dynload_coords_intp_catmull_pre(struct a_funcs *c, struct par_coords_intp_catmull *a) {
	if(c->c != DYNLOAD_COORDS_INTP_CATMULL_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COORDS_INTP_CATMULL_PARAMS);

		return(-1);
	}

	/* Pass parameters to coords_intp_catmull_[x|y|z]() */
	(void) dynload_pre_point(c, 0, &a->pos_a.x, &a->pos_a.y, &a->pos_a.z);
	(void) dynload_pre_point(c, 1, &a->pos_b.x, &a->pos_b.y, &a->pos_b.z);
	(void) dynload_pre_point(c, 2, &a->pos_c.x, &a->pos_c.y, &a->pos_c.z);
	(void) dynload_pre_point(c, 3, &a->pos_d.x, &a->pos_d.y, &a->pos_d.z);

	a->point = dynload_param_get_number(&c->p[4]);

	return(0);
}

static int dynload_coords_intp_hermite_pre(struct a_funcs *c, struct par_coords_intp_hermite *a) {
	if(c->c != DYNLOAD_COORDS_INTP_HERMITE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_COORDS_INTP_HERMITE_PARAMS);

		return(-1);
	}

	/* Pass parameters to coords_intp_hermite_[x|y|z]() */
	(void) dynload_pre_point(c, 0, &a->pos_a.x, &a->pos_a.y, &a->pos_a.z);
	(void) dynload_pre_point(c, 1, &a->pos_b.x, &a->pos_b.y, &a->pos_b.z);
	(void) dynload_pre_point(c, 2, &a->pos_c.x, &a->pos_c.y, &a->pos_c.z);
	(void) dynload_pre_point(c, 3, &a->pos_d.x, &a->pos_d.y, &a->pos_d.z);

	a->point = dynload_param_get_number(&c->p[4]);
	a->bias = dynload_param_get_number(&c->p[5]);
	a->tension = dynload_param_get_number(&c->p[6]);

	return(0);
}
#endif
#if ! defined(PROG_DISABLE_MATH)
static int dynload_math_clamp_pre(struct a_funcs *c, struct par_math_clamp *a) {
	if(c->c != DYNLOAD_MATH_CLAMP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_CLAMP_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_clamp() */
	a->clamp = dynload_param_get_number(&c->p[0]);

	a->min = dynload_param_get_number(&c->p[1]);
	a->max = dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_math_map_pre(struct a_funcs *c, struct par_math_map *a) {
	if(c->c != DYNLOAD_MATH_MAP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_MAP_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_map() */
	a->map = dynload_param_get_number(&c->p[0]);

	a->cur_min = dynload_param_get_number(&c->p[1]);
	a->cur_max = dynload_param_get_number(&c->p[2]);
	a->map_min = dynload_param_get_number(&c->p[3]);
	a->map_max = dynload_param_get_number(&c->p[4]);

	return(0);
}

static int dynload_math_get_hcf_pre(struct a_funcs *c, struct par_math_get_hcf *a) {
	if(c->c != DYNLOAD_MATH_GET_HCF_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_GET_HCF_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_hcf() */
	a->hcf_a = dynload_param_get_number(&c->p[0]);
	a->hcf_b = dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_math_get_luminance_pre(struct a_funcs *c, struct par_math_get_luminance *a) {
	if(c->c != DYNLOAD_MATH_GET_LUMINANCE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_GET_LUMINANCE_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_luminance_by_radius_temperature() */
	a->radius = dynload_param_get_number(&c->p[0]);
	a->temperature = dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_math_get_parsec_pre(struct a_funcs *c, struct par_math_get_parsec *a) {
	if(c->c != DYNLOAD_MATH_GET_PARSEC_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_GET_PARSEC_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_parsec_by_parallax() */
	a->parallax = dynload_param_get_number(&c->p[0]);

	return(0);
}

static int dynload_math_get_radius_pre(struct a_funcs *c, struct par_math_get_radius *a) {
	if(c->c != DYNLOAD_MATH_GET_RADIUS_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_GET_RADIUS_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_radius_by_amag_temperature() */
	a->amag = dynload_param_get_number(&c->p[0]);
	a->temperature = dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_math_btvt_to_bv_pre(struct a_funcs *c, struct par_math_btvt_to_bv *a) {
	if(c->c != DYNLOAD_MATH_BTVT_TO_BV_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_BTVT_TO_BV_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_btvt_to_bv() */
	a->btvt = dynload_param_get_number(&c->p[0]);

	return(0);
}

static int dynload_math_bv_to_temp_pre(struct a_funcs *c, struct par_math_bv_to_temp *a) {
	if(c->c != DYNLOAD_MATH_BV_TO_TEMP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_BV_TO_TEMP_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_bv_to_temperature() */
	a->bv = dynload_param_get_number(&c->p[0]);

	return(0);
}

static int dynload_math_hp_to_vmag_pre(struct a_funcs *c, struct par_math_hp_to_vmag *a) {
	if(c->c != DYNLOAD_MATH_HP_TO_VMAG_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_HP_TO_VMAG_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_hp_to_vmag() */
	a->hp = dynload_param_get_number(&c->p[0]);
	a->btvt = dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_math_vt_to_vmag_pre(struct a_funcs *c, struct par_math_vt_to_vmag *a) {
	if(c->c != DYNLOAD_MATH_VT_TO_VMAG_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_VT_TO_VMAG_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_vt_to_vmag() */
	a->vt = dynload_param_get_number(&c->p[0]);
	a->btvt = dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_math_vmag_to_alpha_pre(struct a_funcs *c, struct par_math_vmag_to_alpha *a) {
	if(c->c != DYNLOAD_MATH_VMAG_TO_ALPHA_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MATH_VMAG_TO_ALPHA_PARAMS);

		return(-1);
	}

	/* Pass parameters to maths_vmag_to_alpha() */
	a->vmag = dynload_param_get_number(&c->p[0]);

	return(0);
}
#endif
#if ! defined(PROG_DISABLE_GUI) && ! defined(PROG_DISABLE_DRAW)
static int dynload_draw_pixel_pre(struct a_funcs *c, struct par_draw_pixel *a) {
	if(c->c != DYNLOAD_DRAW_PIXEL_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_DRAW_PIXEL_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_draw_pixel[_alpha]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->pixel.x = (int) dynload_param_get_number(&c->p[1]);
	a->pixel.y = (int) dynload_param_get_number(&c->p[2]);

	a->pixel.p.pixel.p = dynload_pre_color(c, 3);

	return(0);
}

static int dynload_draw_subpixel_pre(struct a_funcs *c, struct par_draw_subpixel *a) {
	if(c->c != DYNLOAD_DRAW_SUBPIXEL_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_DRAW_SUBPIXEL_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_draw_subpixel[_alpha]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->subpixel.x = dynload_param_get_number(&c->p[1]);
	a->subpixel.y = dynload_param_get_number(&c->p[2]);

	a->subpixel.p.pixel.p = dynload_pre_color(c, 3);

	return(0);
}

static int dynload_draw_line_pre(struct a_funcs *c, struct par_draw_line *a) {
	if(c->c != DYNLOAD_DRAW_LINE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_DRAW_LINE_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_draw_line[_aa|_alpha]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->line.x1 = (int) dynload_param_get_number(&c->p[1]);
	a->line.y1 = (int) dynload_param_get_number(&c->p[2]);
	a->line.x2 = (int) dynload_param_get_number(&c->p[3]);
	a->line.y2 = (int) dynload_param_get_number(&c->p[4]);

	a->line.p.pixel.p = dynload_pre_color(c, 5);

	return(0);
}

static int dynload_draw_circle_pre(struct a_funcs *c, struct par_draw_circle *a) {
	if(c->c != DYNLOAD_DRAW_CIRCLE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_DRAW_CIRCLE_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_draw_circle[_aa|_alpha]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->circle.x = (int) dynload_param_get_number(&c->p[1]);
	a->circle.y = (int) dynload_param_get_number(&c->p[2]);

	a->circle.n = (unsigned int) dynload_param_get_number(&c->p[3]);

	a->circle.r = dynload_param_get_number(&c->p[4]);

	a->circle.p.pixel.p = dynload_pre_color(c, 5);

	a->circle.f = 0.0;
	a->circle.d = 360.0;

	return(0);
}

static int dynload_draw_text_pre(struct a_funcs *c, struct par_draw_text *a) {
	if(c->c != DYNLOAD_DRAW_TEXT_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_DRAW_TEXT_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_draw_text() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->text.f = dynload_param_get_handle(&c->p[1]);

	a->text.x = (int) dynload_param_get_number(&c->p[2]);
	a->text.y = (int) dynload_param_get_number(&c->p[3]);

	return(0);
}

static int dynload_draw_set_pre(struct a_funcs *c, struct par_draw_set *a) {
	if(c->c != DYNLOAD_DRAW_SET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_DRAW_SET_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_draw_set[_alpha]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->set.x1 = (int) dynload_param_get_number(&c->p[1]);
	a->set.y1 = (int) dynload_param_get_number(&c->p[2]);
	a->set.x2 = (int) dynload_param_get_number(&c->p[3]);
	a->set.y2 = (int) dynload_param_get_number(&c->p[4]);

	a->set.p.pixel.p = dynload_pre_color(c, 5);

	return(0);
}

static int dynload_draw_border_pre(struct a_funcs *c, struct par_draw_border *a) {
	if(c->c != DYNLOAD_DRAW_BORDER_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_DRAW_BORDER_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_draw_border[_alpha]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->border.x = (int) dynload_param_get_number(&c->p[1]);
	a->border.y = (int) dynload_param_get_number(&c->p[2]);

	a->border.w = (unsigned int) dynload_param_get_number(&c->p[3]);
	a->border.h = (unsigned int) dynload_param_get_number(&c->p[4]);

	a->border.t = (unsigned int) dynload_param_get_number(&c->p[5]);

	a->border.p.pixel.p = dynload_pre_color(c, 6);

	return(0);
}

static int dynload_draw_copy_pre(struct a_funcs *c, struct par_draw_copy *a) {
	if(c->c != DYNLOAD_DRAW_COPY_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_DRAW_COPY_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_draw_copy[_alpha]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->copy.sx = (int) dynload_param_get_number(&c->p[1]);
	a->copy.sy = (int) dynload_param_get_number(&c->p[2]);
	a->copy.dx = (int) dynload_param_get_number(&c->p[3]);
	a->copy.dy = (int) dynload_param_get_number(&c->p[4]);

	a->copy.c.width = (unsigned int) dynload_param_get_number(&c->p[5]);
	a->copy.c.height = (unsigned int) dynload_param_get_number(&c->p[6]);

	a->copy.s.width = 0;
	a->copy.s.height = 0;

	a->copy.p = NULL;

	return(0);
}

static int dynload_draw_wipe_pre(struct a_funcs *c, struct par_draw_wipe *a) {
	if(c->c != DYNLOAD_DRAW_WIPE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_DRAW_WIPE_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_draw_wipe() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}
#endif
#if ! defined(PROG_DISABLE_GUI)
static int dynload_font_open_pre(struct a_funcs *c, struct par_font_open *a) {
	if(c->c != DYNLOAD_FONT_OPEN_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_FONT_OPEN_PARAMS);

		return(-1);
	}

	/* Pass parameters to fonts_open() */
	a->font = (char *) dynload_param_get_string(&c->p[0]);

	a->height = (unsigned int) dynload_param_get_number(&c->p[1]);
	a->resolution = (unsigned int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_font_open_copy_pre(struct a_funcs *c, struct par_font_open_copy *a) {
	if(c->c != DYNLOAD_FONT_OPEN_COPY_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_FONT_OPEN_COPY_PARAMS);

		return(-1);
	}

	/* Pass parameters to fonts_copy_copy() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_font_close_pre(struct a_funcs *c, struct par_font_close *a) {
	if(c->c != DYNLOAD_FONT_CLOSE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_FONT_CLOSE_PARAMS);

		return(-1);
	}

	/* Pass parameters to fonts_close() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_font_render_pre(struct a_funcs *c, struct par_font_render *a) {
	struct pixel_rgba_8 p;

	if(c->c != DYNLOAD_FONT_RENDER_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_FONT_RENDER_PARAMS);

		return(-1);
	}

	/* Pass parameters to fonts_render() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->charset = (char *) dynload_param_get_string(&c->p[1]);
	a->string = (char *) dynload_param_get_string(&c->p[2]);

	a->length = (size_t) dynload_param_get_number(&c->p[3]);

	if(a->length == 0) a->length = str_len(a->string, STRING_UTF8);

	p.pixel.p = dynload_pre_color(c, 4);

	a->color.r = p.pixel.r;
	a->color.g = p.pixel.g;
	a->color.b = p.pixel.b;

	return(0);
}

static int dynload_font_get_width_pre(struct a_funcs *c, struct par_font_get_width *a) {
	if(c->c != DYNLOAD_FONT_GET_WIDTH_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_FONT_GET_WIDTH_PARAMS);

		return(-1);
	}

	/* Pass parameters to fonts_get_width() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_font_get_height_pre(struct a_funcs *c, struct par_font_get_height *a) {
	if(c->c != DYNLOAD_FONT_GET_HEIGHT_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_FONT_GET_HEIGHT_PARAMS);

		return(-1);
	}

	/* Pass parameters to fonts_get_height() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}
#endif
static int dynload_system_sleep_pre(struct a_funcs *c, struct par_system_sleep *a) {
	if(c->c != DYNLOAD_SYSTEM_SLEEP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_SYSTEM_SLEEP_PARAMS);

		return(-1);
	}

	a->secs = (time_t) dynload_param_get_number(&c->p[0]);
	a->nsecs = (long) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_system_fork_pre(struct a_funcs *c) {
	if(c->c != DYNLOAD_SYSTEM_FORK_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_SYSTEM_FORK_PARAMS);

		return(-1);
	}

	return(0);
}

static int dynload_system_exec_pre(struct a_funcs *c, struct par_system_exec *a) {
	unsigned int i;

	char *s;
	char **t;

	size_t u;

	if(c->c < DYNLOAD_SYSTEM_EXEC_PARAMS || c->c > DYNLOAD_PARAM_MAX) {
		(void) dynload_error_params(c, DYNLOAD_SYSTEM_EXEC_PARAMS);

		return(-1);
	}

	a->command = (char *) dynload_param_get_string(&c->p[0]);

	/* Copy program name to run to parameter array */
	if((a->params = malloc(sizeof(char *) * 2)) == NULL) return(-1);

	u = str_len(a->command, STRING_ASCII);

	if((a->params[0] = malloc(u + sizeof(char))) == NULL) {
		LOGWARN(
			ERROR_SLIGHT, SUBSYSTEM,
			_("Failed to allocate %lu bytes of memory"),
			(unsigned long) (u + sizeof(char))
		);

		(void) free(a->params);

		return(-1);
	}

	(void) memcpy((void *) a->params[0], (const void *) a->command, u);

	a->params[0][u] = 0;

	/* Copy rest of the parameters to parameter array */
	for(i = 1; i < c->c; i++) {
		/* Parameter type must be string, no auto conversion here */
		s = (char *) dynload_param_get_string(&c->p[i]);

		if((t = realloc(a->params, (size_t) (sizeof(char *) * (i + 2)))) == NULL) {
			LOGWARN(
				ERROR_SLIGHT, SUBSYSTEM,
				_("Failed to allocate %lu bytes of memory"),
				(unsigned long) (sizeof(char *) * (i + 2))
			);

			(void) dynload_system_exec_pre_free(a->params, i);

			return(-1);
		}

		a->params = t;

		u = str_len(s, STRING_ASCII);

		if((a->params[i] = malloc(u + sizeof(char))) == NULL) {
			LOGWARN(
				ERROR_SLIGHT, SUBSYSTEM,
				_("Failed to allocate %lu bytes of memory"),
				(unsigned long) (u + sizeof(char))
			);

			(void) dynload_system_exec_pre_free(a->params, i);

			return(-1);
		}

		(void) memcpy((void *) a->params[i], (const void *) s, u);

		a->params[i][u] = 0;
	}

	a->params[i] = NULL;

	return(0);
}

static void dynload_system_exec_pre_free(char **s, unsigned int n) {
	unsigned int i;

	for(i = 0; i < n; i++) (void) free(s[i]);

	(void) free(s);
}

static int dynload_system_system_pre(struct a_funcs *c, struct par_system_system *a) {
	if(c->c != DYNLOAD_SYSTEM_SYSTEM_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_SYSTEM_SYSTEM_PARAMS);

		return(-1);
	}

	a->command = (char *) dynload_param_get_string(&c->p[0]);

	return(0);
}

static int dynload_system_time_pre(struct a_funcs *c) {
	if(c->c != DYNLOAD_SYSTEM_TIME_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_SYSTEM_TIME_PARAMS);

		return(-1);
	}

	return(0);
}

static int dynload_system_timer_pre(struct a_funcs *c, struct par_system_timer *a, void *cb) {
	if(c->c != DYNLOAD_SYSTEM_TIMER_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_SYSTEM_TIMER_PARAMS);

		return(-1);
	}

	a->secs = (time_t) dynload_param_get_number(&c->p[0]);
	a->nsecs = (long) dynload_param_get_number(&c->p[1]);

	a->par_timer.s = (char *) dynload_param_get_string(&c->p[2]);
	a->par_timer.n = 0;

	a->cb_timer = cb;

	return(0);
}

static int dynload_thread_spawn_pre(struct a_funcs *c, struct par_thread_spawn *a, void *cb) {
	if(c->c != DYNLOAD_THREAD_SPAWN_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_THREAD_SPAWN_PARAMS);

		return(-1);
	}

	a->name = (char *) dynload_param_get_string(&c->p[0]);

	a->par_thread.s = (char *) dynload_param_get_string(&c->p[1]);
	a->par_thread.n = 0;

	a->cb_thread = cb;

	return(0);
}

static int dynload_thread_affinity_pre(struct a_funcs *c, struct par_thread_affinity *a) {
	if(c->c != DYNLOAD_THREAD_AFFINITY_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_THREAD_AFFINITY_PARAMS);

		return(-1);
	}

	a->cpu = (int) dynload_param_get_number(&c->p[0]);

	return(0);
}

static int dynload_thread_numa_affinity_pre(struct a_funcs *c, struct par_thread_numa_affinity *a) {
	if(c->c != DYNLOAD_THREAD_NUMA_AFFINITY_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_THREAD_NUMA_AFFINITY_PARAMS);

		return(-1);
	}

	a->domain = (int) dynload_param_get_number(&c->p[0]);
	a->policy = (int) dynload_param_get_number(&c->p[1]);

	return(0);
}
#if ! defined(PROG_DISABLE_GUI)
static int dynload_window_refresh_pre(struct a_funcs *c, struct par_window_refresh *a) {
	if(c->c != DYNLOAD_WINDOW_REFRESH_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WINDOW_REFRESH_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_window_refresh() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->area.x = (int) dynload_param_get_number(&c->p[1]);
	a->area.y = (int) dynload_param_get_number(&c->p[2]);

	a->area.s.width = (unsigned int) dynload_param_get_number(&c->p[3]);
	a->area.s.height = (unsigned int) dynload_param_get_number(&c->p[4]);

	return(0);
}

static int dynload_window_open_pre(struct a_funcs *c, struct par_window_open *a) {
	if(c->c != DYNLOAD_WINDOW_OPEN_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WINDOW_OPEN_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_window_open(), it makes copy of all this */
	a->window.s = (char *) dynload_param_get_string(&c->p[0]);
	a->window.c = (char *) dynload_param_get_string(&c->p[1]);

	a->window.r = dynload_param_get_handle(&c->p[2]);
	a->window.p = (unsigned int) dynload_param_get_number(&c->p[3]);
	a->window.e = (unsigned int) dynload_param_get_number(&c->p[4]);
	a->window.m = (unsigned int) dynload_param_get_number(&c->p[5]);

	a->window.x = (int) dynload_param_get_number(&c->p[6]);
	a->window.y = (int) dynload_param_get_number(&c->p[7]);

	a->window.w = (unsigned int) dynload_param_get_number(&c->p[8]);
	a->window.h = (unsigned int) dynload_param_get_number(&c->p[9]);

	a->window.par_main_loop.s = (char *) dynload_param_get_string(&c->p[10]);
	a->window.par_main_loop.n = 0;

	a->window.par_expose.s = (char *) dynload_param_get_string(&c->p[11]);
	a->window.par_expose.n = 0;

	a->window.par_key_press.s = (char *) dynload_param_get_string(&c->p[12]);
	a->window.par_key_press.n = 0;
	a->window.par_key_release.s = (char *) dynload_param_get_string(&c->p[13]);
	a->window.par_key_release.n = 0;
	a->window.par_button_press.s = (char *) dynload_param_get_string(&c->p[14]);
	a->window.par_button_press.n = 0;
	a->window.par_button_release.s = (char *) dynload_param_get_string(&c->p[15]);
	a->window.par_button_release.n = 0;

	a->window.par_client_message.s = (char *) dynload_param_get_string(&c->p[16]);
	a->window.par_client_message.n = 0;

	a->window.par_configure_notify.s = (char *) dynload_param_get_string(&c->p[17]);
	a->window.par_configure_notify.n = 0;
	a->window.par_destroy_notify.s = (char *) dynload_param_get_string(&c->p[18]);
	a->window.par_destroy_notify.n = 0;
	a->window.par_motion_notify.s = (char *) dynload_param_get_string(&c->p[19]);
	a->window.par_motion_notify.n = 0;
	a->window.par_map_notify.s = (char *) dynload_param_get_string(&c->p[20]);
	a->window.par_map_notify.n = 0;
	a->window.par_unmap_notify.s = (char *) dynload_param_get_string(&c->p[21]);
	a->window.par_unmap_notify.n = 0;

	a->window.par_open_notify.s = (char *) dynload_param_get_string(&c->p[22]);
	a->window.par_open_notify.n = 0;

	a->window.cb_main_loop = dsl_cb_main_loop;

	a->window.cb_expose = dsl_cb_expose;

	a->window.cb_key_press = dsl_cb_key_press;
	a->window.cb_key_release = dsl_cb_key_release;
	a->window.cb_button_press = dsl_cb_button_press;
	a->window.cb_button_release = dsl_cb_button_release;

	a->window.cb_client_message = dsl_cb_client_message;

	a->window.cb_configure_notify = dsl_cb_configure_notify;
	a->window.cb_destroy_notify = dsl_cb_destroy_notify;
	a->window.cb_motion_notify = dsl_cb_motion_notify;
	a->window.cb_map_notify = dsl_cb_map_notify;
	a->window.cb_unmap_notify = dsl_cb_unmap_notify;

	a->window.cb_open_notify = dsl_cb_open_notify;

	return(0);
}

static int dynload_window_icon_pre(struct a_funcs *c, struct par_window_icon *a) {
	if(c->c != DYNLOAD_WINDOW_ICON_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WINDOW_ICON_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_window_icon() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->icon = (char *) dynload_param_get_string(&c->p[1]);

	return(0);
}

static int dynload_window_close_pre(struct a_funcs *c, struct par_window_close *a) {
	if(c->c != DYNLOAD_WINDOW_CLOSE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WINDOW_CLOSE_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_window_close() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_window_map_pre(struct a_funcs *c, struct par_window_map *a) {
	if(c->c != DYNLOAD_WINDOW_MAP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WINDOW_MAP_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_window_map() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_window_unmap_pre(struct a_funcs *c, struct par_window_unmap *a) {
	if(c->c != DYNLOAD_WINDOW_UNMAP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WINDOW_UNMAP_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_window_unmap() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_window_attrs_pre(struct a_funcs *c, struct par_window_attrs *a) {
	if(c->c != DYNLOAD_WINDOW_SET_ATTRS_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WINDOW_SET_ATTRS_PARAMS);

		return(-1);
	}

	/* Pass parameters to gui_window_set_attrs() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->attribute.c = (unsigned int) dynload_param_get_number(&c->p[1]);

	a->attribute.v = dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_window_init_pre(struct a_funcs *c) {
	if(c->c != DYNLOAD_WINDOW_INIT_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WINDOW_INIT_PARAMS);

		return(-1);
	}

	return(0);
}
#endif
#if ! defined(PROG_DISABLE_GUI) && ! defined(PROG_DISABLE_MENU)
static int dynload_menu_bar_disp_pre(struct a_funcs *c, struct par_menu_bar_disp *a) {
	if(c->c != DYNLOAD_MENU_BAR_DISP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MENU_BAR_DISP_PARAMS);

		return(-1);
	}

	/* Pass parameters to menu_[hide|show]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_menu_item_state_pre(struct a_funcs *c, struct par_menu_item_state *a) {
	if(c->c != DYNLOAD_MENU_ITEM_STATE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_MENU_ITEM_STATE_PARAMS);

		return(-1);
	}

	/* Pass parameters to menu_[disable|enable]() */
	a->handle = dynload_param_get_handle(&c->p[0]);
	a->tag = dynload_param_get_handle(&c->p[1]);

	return(0);
}
#endif
#if ! defined(PROG_DISABLE_AUDIO)
static int dynload_audio_create_noise_white_pre(struct a_funcs *c, struct par_audio_create_noise_white *a) {
	if(c->c != DYNLOAD_AUDIO_CREATE_NOISE_WHITE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_CREATE_NOISE_WHITE_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_create_noise_white() */
	a->secs = dynload_param_get_number(&c->p[0]);

	return(0);
}

static int dynload_audio_create_wave_sine_pre(struct a_funcs *c, struct par_audio_create_wave_sine *a) {
	if(c->c != DYNLOAD_AUDIO_CREATE_WAVE_SINE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_CREATE_WAVE_SINE_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_create_wave_sine() */
	a->secs = dynload_param_get_number(&c->p[0]);
	a->freq = dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_audio_create_wave_square_pre(struct a_funcs *c, struct par_audio_create_wave_square *a) {
	if(c->c != DYNLOAD_AUDIO_CREATE_WAVE_SQUARE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_CREATE_WAVE_SQUARE_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_create_wave_square() */
	a->secs = dynload_param_get_number(&c->p[0]);
	a->freq = dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_audio_create_wave_random_pre(struct a_funcs *c, struct par_audio_create_wave_random *a) {
	if(c->c != DYNLOAD_AUDIO_CREATE_WAVE_RANDOM_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_CREATE_WAVE_RANDOM_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_create_wave_random() */
	a->secs = dynload_param_get_number(&c->p[0]);
	a->freq = dynload_param_get_number(&c->p[1]);
	a->amplitude = dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_audio_open_pre(struct a_funcs *c, struct par_audio_open *a) {
	if(c->c != DYNLOAD_AUDIO_OPEN_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_OPEN_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_open() */
	a->audio = (char *) dynload_param_get_string(&c->p[0]);

	return(0);
}

static int dynload_audio_close_pre(struct a_funcs *c, struct par_audio_close *a) {
	if(c->c != DYNLOAD_AUDIO_CLOSE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_CLOSE_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_close() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_audio_play_pre(struct a_funcs *c, struct par_audio_play *a) {
	if(c->c != DYNLOAD_AUDIO_PLAY_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_PLAY_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_play() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->vol = (float) dynload_param_get_number(&c->p[1]);
	a->pan = (float) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_audio_wait_pre(struct a_funcs *c, struct par_audio_wait *a) {
	if(c->c != DYNLOAD_AUDIO_WAIT_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_WAIT_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_wait() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_audio_cut_pre(struct a_funcs *c, struct par_audio_cut *a) {
	if(c->c != DYNLOAD_AUDIO_CUT_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_CUT_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_cut() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_audio_solo_pre(struct a_funcs *c, struct par_audio_solo *a) {
	if(c->c != DYNLOAD_AUDIO_SOLO_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_SOLO_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_solo() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_audio_hold_pre(struct a_funcs *c, struct par_audio_hold *a) {
	if(c->c != DYNLOAD_AUDIO_HOLD_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_HOLD_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_hold() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_audio_cancel_pre(struct a_funcs *c, struct par_audio_cancel *a) {
	if(c->c != DYNLOAD_AUDIO_CANCEL_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_CANCEL_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_cancel() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_audio_pan_get_pre(struct a_funcs *c, struct par_audio_pan_get *a) {
	if(c->c != DYNLOAD_AUDIO_PAN_GET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_PAN_GET_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_pan_get() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_audio_pan_set_pre(struct a_funcs *c, struct par_audio_pan_set *a) {
	if(c->c != DYNLOAD_AUDIO_PAN_SET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_PAN_SET_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_pan_set() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->pan = (float) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_audio_pan_inc_pre(struct a_funcs *c, struct par_audio_pan_inc *a) {
	if(c->c != DYNLOAD_AUDIO_PAN_INC_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_PAN_INC_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_pan_inc() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->pan = (float) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_audio_pan_dec_pre(struct a_funcs *c, struct par_audio_pan_dec *a) {
	if(c->c != DYNLOAD_AUDIO_PAN_DEC_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_PAN_DEC_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_pan_dec() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->pan = (float) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_audio_vol_get_pre(struct a_funcs *c, struct par_audio_vol_get *a) {
	if(c->c != DYNLOAD_AUDIO_VOL_GET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_VOL_GET_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_vol_get() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_audio_vol_set_pre(struct a_funcs *c, struct par_audio_vol_set *a) {
	if(c->c != DYNLOAD_AUDIO_VOL_SET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_VOL_SET_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_vol_set() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->vol = (float) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_audio_vol_inc_pre(struct a_funcs *c, struct par_audio_vol_inc *a) {
	if(c->c != DYNLOAD_AUDIO_VOL_INC_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_VOL_INC_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_vol_inc() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->vol = (float) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_audio_vol_dec_pre(struct a_funcs *c, struct par_audio_vol_dec *a) {
	if(c->c != DYNLOAD_AUDIO_VOL_DEC_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_VOL_DEC_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_vol_dec() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->vol = (float) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_audio_master_get_pre(struct a_funcs *c) {
	if(c->c != DYNLOAD_AUDIO_MASTER_GET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_MASTER_GET_PARAMS);

		return(-1);
	}

	return(0);
}

static int dynload_audio_master_set_pre(struct a_funcs *c, struct par_audio_master_set *a) {
	if(c->c != DYNLOAD_AUDIO_MASTER_SET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_MASTER_SET_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_master_set() */
	a->vol = (float) dynload_param_get_number(&c->p[0]);

	return(0);
}

static int dynload_audio_master_inc_pre(struct a_funcs *c, struct par_audio_master_inc *a) {
	if(c->c != DYNLOAD_AUDIO_MASTER_INC_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_MASTER_INC_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_master_inc() */
	a->vol = (float) dynload_param_get_number(&c->p[0]);

	return(0);
}

static int dynload_audio_master_dec_pre(struct a_funcs *c, struct par_audio_master_dec *a) {
	if(c->c != DYNLOAD_AUDIO_MASTER_DEC_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_MASTER_DEC_PARAMS);

		return(-1);
	}

	/* Pass parameters to mixer_master_dec() */
	a->vol = (float) dynload_param_get_number(&c->p[0]);

	return(0);
}

static int dynload_audio_init_pre(struct a_funcs *c) {
	if(c->c != DYNLOAD_AUDIO_INIT_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_AUDIO_INIT_PARAMS);

		return(-1);
	}

	return(0);
}
#endif
#if ! defined(PROG_DISABLE_GUI) && ! defined(PROG_DISABLE_WIDGET)
static int dynload_widget_refresh_pre(struct a_funcs *c, struct par_widget_refresh *a) {
	if(c->c != DYNLOAD_WIDGET_REFRESH_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_REFRESH_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_refresh() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_widget_create_block_pre(struct a_funcs *c, struct par_widget_create_block *a) {
	if(c->c != DYNLOAD_WIDGET_CREATE_BLOCK_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CREATE_BLOCK_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_create_block() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);
	a->width = (unsigned int) dynload_param_get_number(&c->p[4]);
	a->height = (unsigned int) dynload_param_get_number(&c->p[5]);

	return(0);
}

static int dynload_widget_create_label_pre(struct a_funcs *c, struct par_widget_create_label *a) {
	if(c->c != DYNLOAD_WIDGET_CREATE_LABEL_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CREATE_LABEL_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_create_label() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);

	return(0);
}

static int dynload_widget_create_lamp_pre(struct a_funcs *c, struct par_widget_create_lamp *a) {
	if(c->c != DYNLOAD_WIDGET_CREATE_LAMP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CREATE_LAMP_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_create_lamp() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);
	a->u = (int) dynload_param_get_number(&c->p[4]);
	a->v = (int) dynload_param_get_number(&c->p[5]);

	a->subtype = (unsigned int) dynload_param_get_number(&c->p[6]);
	a->titlepos = (unsigned int) dynload_param_get_number(&c->p[7]);

	return(0);
}

static int dynload_widget_create_led_pre(struct a_funcs *c, struct par_widget_create_led *a) {
	if(c->c != DYNLOAD_WIDGET_CREATE_LED_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CREATE_LED_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_create_led_[1|2|3]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);
	a->u = (int) dynload_param_get_number(&c->p[4]);
	a->v = (int) dynload_param_get_number(&c->p[5]);

	a->subtype = (unsigned int) dynload_param_get_number(&c->p[6]);
	a->titlepos = (unsigned int) dynload_param_get_number(&c->p[7]);

	return(0);
}

static int dynload_widget_create_pushbutton_pre(struct a_funcs *c, struct par_widget_create_pushbutton *a) {
	if(c->c != DYNLOAD_WIDGET_CREATE_PUSHBUTTON_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CREATE_PUSHBUTTON_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_create_pushbutton() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);
	a->u = (int) dynload_param_get_number(&c->p[4]);
	a->v = (int) dynload_param_get_number(&c->p[5]);

	a->subtype = (unsigned int) dynload_param_get_number(&c->p[6]);
	a->titlepos = (unsigned int) dynload_param_get_number(&c->p[7]);
	a->sticky = (unsigned int) dynload_param_get_number(&c->p[8]);

	return(0);
}

static int dynload_widget_create_slideswitch_pre(struct a_funcs *c, struct par_widget_create_slideswitch *a) {
	if(c->c != DYNLOAD_WIDGET_CREATE_SLIDESWITCH_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CREATE_SLIDESWITCH_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_create_slideswitch() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);
	a->u = (int) dynload_param_get_number(&c->p[4]);
	a->v = (int) dynload_param_get_number(&c->p[5]);

	a->subtype = (unsigned int) dynload_param_get_number(&c->p[6]);
	a->titlepos = (unsigned int) dynload_param_get_number(&c->p[7]);

	a->length = (unsigned int) dynload_param_get_number(&c->p[8]);
	a->steps = (unsigned int) dynload_param_get_number(&c->p[9]);
	a->startstep = (unsigned int) dynload_param_get_number(&c->p[10]);

	return(0);
}

static int dynload_widget_create_toggleswitch_pre(struct a_funcs *c, struct par_widget_create_toggleswitch *a) {
	if(c->c != DYNLOAD_WIDGET_CREATE_TOGGLESWITCH_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CREATE_TOGGLESWITCH_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_create_toggleswitch() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);
	a->u = (int) dynload_param_get_number(&c->p[4]);
	a->v = (int) dynload_param_get_number(&c->p[5]);

	a->subtype = (unsigned int) dynload_param_get_number(&c->p[6]);
	a->titlepos = (unsigned int) dynload_param_get_number(&c->p[7]);

	a->steps = (unsigned int) dynload_param_get_number(&c->p[8]);
	a->startstep = (unsigned int) dynload_param_get_number(&c->p[9]);

	return(0);
}

static int dynload_widget_create_turnswitch_pre(struct a_funcs *c, struct par_widget_create_turnswitch *a) {
	if(c->c != DYNLOAD_WIDGET_CREATE_TURNSWITCH_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CREATE_TURNSWITCH_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_create_turnswitch() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);
	a->u = (int) dynload_param_get_number(&c->p[4]);
	a->v = (int) dynload_param_get_number(&c->p[5]);

	a->subtype = (unsigned int) dynload_param_get_number(&c->p[6]);
	a->titlepos = (unsigned int) dynload_param_get_number(&c->p[7]);

	a->minangle = (unsigned int) dynload_param_get_number(&c->p[8]);
	a->maxangle = (unsigned int) dynload_param_get_number(&c->p[9]);

	a->steps = (unsigned int) dynload_param_get_number(&c->p[10]);
	a->startstep = (unsigned int) dynload_param_get_number(&c->p[11]);

	return(0);
}

static int dynload_widget_delete_pre(struct a_funcs *c, struct par_widget_delete *a) {
	if(c->c != DYNLOAD_WIDGET_DELETE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_DELETE_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_delete() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	return(0);
}

static int dynload_widget_state_pre(struct a_funcs *c, struct par_widget_state *a) {
	if(c->c != DYNLOAD_WIDGET_STATE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_STATE_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_[disable|enable]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	return(0);
}

static int dynload_widget_change_set_pre(struct a_funcs *c, struct par_widget_change_set *a) {
	if(c->c != DYNLOAD_WIDGET_CHANGE_SET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CHANGE_SET_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_change_set() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->set = (unsigned int) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_widget_step_get_pre(struct a_funcs *c, struct par_widget_step_get *a) {
	if(c->c != DYNLOAD_WIDGET_STEP_GET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_STEP_GET_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_step_[get|get_min|get_max]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	return(0);
}

static int dynload_widget_step_set_pre(struct a_funcs *c, struct par_widget_step_set *a) {
	if(c->c != DYNLOAD_WIDGET_STEP_SET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_STEP_SET_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_step_set() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->step = (unsigned int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_widget_trigger_set_pre(struct a_funcs *c, struct par_widget_trigger_set *a) {
	if(c->c != DYNLOAD_WIDGET_TRIGGER_SET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_TRIGGER_SET_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_trigger_set() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->trigger = (unsigned int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_widget_indicator_set_pre(struct a_funcs *c, struct par_widget_indicator_set *a) {
	if(c->c != DYNLOAD_WIDGET_INDICATOR_SET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_INDICATOR_SET_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_indicator_set() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->font = (char *) dynload_param_get_string(&c->p[2]);
	a->charset = (char *) dynload_param_get_string(&c->p[3]);

	a->font_size = (unsigned int) dynload_param_get_number(&c->p[4]);
	a->font_res = (unsigned int) dynload_param_get_number(&c->p[5]);

	a->color.pixel.p = dynload_pre_color(c, 6);

	a->mode = (unsigned int) dynload_param_get_number(&c->p[7]);
	a->offset = (int) dynload_param_get_number(&c->p[8]);

	return(0);
}

static int dynload_widget_update_border_pre(struct a_funcs *c, struct par_widget_update_border *a) {
	if(c->c != DYNLOAD_WIDGET_UPDATE_BORDER_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_UPDATE_BORDER_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_update_border() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->color.pixel.p = dynload_pre_color(c, 2);

	a->thickness = (unsigned int) dynload_param_get_number(&c->p[3]);

	return(0);
}

static int dynload_widget_update_color_pre(struct a_funcs *c, struct par_widget_update_color *a) {
	if(c->c != DYNLOAD_WIDGET_UPDATE_COLOR_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_UPDATE_COLOR_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_update_color() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->color.pixel.p = dynload_pre_color(c, 2);

	return(0);
}

static int dynload_widget_update_image_pre(struct a_funcs *c, struct par_widget_update_image *a) {
	if(c->c != DYNLOAD_WIDGET_UPDATE_IMAGE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_UPDATE_IMAGE_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_update_image() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);

	(void) dynload_pre_image(c, 4, &a->width, &a->height, &a->image);

	return(0);
}

static int dynload_widget_update_image_file_pre(struct a_funcs *c, struct par_widget_update_image_file *a) {
	if(c->c != DYNLOAD_WIDGET_UPDATE_IMAGE_FILE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_UPDATE_IMAGE_FILE_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_update_image_file() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->image = (char *) dynload_param_get_string(&c->p[2]);

	return(0);
}

static int dynload_widget_update_label_pre(struct a_funcs *c, struct par_widget_update_label *a) {
	if(c->c != DYNLOAD_WIDGET_UPDATE_LABEL_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_UPDATE_LABEL_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_update_label() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->label = (char *) dynload_param_get_string(&c->p[2]);
	a->charset = (char *) dynload_param_get_string(&c->p[3]);
	a->font = (char *) dynload_param_get_string(&c->p[4]);

	a->font_size = (unsigned int) dynload_param_get_number(&c->p[5]);
	a->font_res = (unsigned int) dynload_param_get_number(&c->p[6]);
	a->font_just = (unsigned int) dynload_param_get_number(&c->p[7]);

	a->color.pixel.p = dynload_pre_color(c, 8);

	return(0);
}

static int dynload_widget_update_scale_pre(struct a_funcs *c, struct par_widget_update_scale *a) {
	if(c->c != DYNLOAD_WIDGET_UPDATE_SCALE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_UPDATE_SCALE_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_update_scale_[bars|dots|nude]() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->font = (char *) dynload_param_get_string(&c->p[2]);
	a->charset = (char *) dynload_param_get_string(&c->p[3]);

	a->array = NULL;

	a->font_size = (unsigned int) dynload_param_get_number(&c->p[4]);
	a->font_res = (unsigned int) dynload_param_get_number(&c->p[5]);

	a->start = dynload_param_get_number(&c->p[6]);
	a->end = dynload_param_get_number(&c->p[7]);

	a->bars = (unsigned int) dynload_param_get_number(&c->p[8]);

	a->color.pixel.p = dynload_pre_color(c, 9);

	return(0);
}

static int dynload_widget_cb_add_pre(struct a_funcs *c, struct par_widget_cb_add *a) {
	if(c->c != DYNLOAD_WIDGET_CB_ADD_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CB_ADD_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_cb_add_*() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	a->cb = (char *) dynload_param_get_string(&c->p[2]);

	return(0);
}

static int dynload_widget_cb_delete_pre(struct a_funcs *c, struct par_widget_cb_delete *a) {
	if(c->c != DYNLOAD_WIDGET_CB_DELETE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_WIDGET_CB_DELETE_PARAMS);

		return(-1);
	}

	/* Pass parameters to widget_cb_delete_*() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->name = (char *) dynload_param_get_string(&c->p[1]);

	return(0);
}
#endif
#if ! defined(PROG_DISABLE_GUI) && ! defined(PROG_DISABLE_BOB)
static int dynload_bob_get_altitude_pre(struct a_funcs *c, struct par_bob_get_altitude *a) {
	if(c->c != DYNLOAD_BOB_GET_ALTITUDE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_ALTITUDE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_altitude() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_set_altitude_pre(struct a_funcs *c, struct par_bob_set_altitude *a) {
	if(c->c != DYNLOAD_BOB_SET_ALTITUDE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_ALTITUDE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_altitude() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->altitude = (unsigned int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_add_altitude_pre(struct a_funcs *c, struct par_bob_add_altitude *a) {
	if(c->c != DYNLOAD_BOB_ADD_ALTITUDE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_ADD_ALTITUDE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_add_altitude() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->altitude = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_sub_altitude_pre(struct a_funcs *c, struct par_bob_sub_altitude *a) {
	if(c->c != DYNLOAD_BOB_SUB_ALTITUDE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SUB_ALTITUDE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_sub_altitude() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->altitude = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_get_x_position_pre(struct a_funcs *c, struct par_bob_get_x_position *a) {
	if(c->c != DYNLOAD_BOB_GET_X_POSITION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_X_POSITION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_x_position() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_get_y_position_pre(struct a_funcs *c, struct par_bob_get_y_position *a) {
	if(c->c != DYNLOAD_BOB_GET_Y_POSITION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_Y_POSITION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_y_position() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_set_position_pre(struct a_funcs *c, struct par_bob_set_position *a) {
	if(c->c != DYNLOAD_BOB_SET_POSITION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_POSITION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_position() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);

	return(0);
}

static int dynload_bob_set_x_position_pre(struct a_funcs *c, struct par_bob_set_x_position *a) {
	if(c->c != DYNLOAD_BOB_SET_X_POSITION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_X_POSITION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_x_position() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_set_y_position_pre(struct a_funcs *c, struct par_bob_set_y_position *a) {
	if(c->c != DYNLOAD_BOB_SET_Y_POSITION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_Y_POSITION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_y_position() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->y = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_add_x_position_pre(struct a_funcs *c, struct par_bob_add_x_position *a) {
	if(c->c != DYNLOAD_BOB_ADD_X_POSITION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_ADD_X_POSITION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_add_x_position() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_add_y_position_pre(struct a_funcs *c, struct par_bob_add_y_position *a) {
	if(c->c != DYNLOAD_BOB_ADD_Y_POSITION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_ADD_Y_POSITION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_add_y_position() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->y = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_sub_x_position_pre(struct a_funcs *c, struct par_bob_sub_x_position *a) {
	if(c->c != DYNLOAD_BOB_SUB_X_POSITION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SUB_X_POSITION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_sub_x_position() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_sub_y_position_pre(struct a_funcs *c, struct par_bob_sub_y_position *a) {
	if(c->c != DYNLOAD_BOB_SUB_Y_POSITION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SUB_Y_POSITION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_sub_y_position() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->y = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_get_angle_pre(struct a_funcs *c, struct par_bob_get_angle *a) {
	if(c->c != DYNLOAD_BOB_GET_ANGLE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_ANGLE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_angle() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_set_angle_position_pre(struct a_funcs *c, struct par_bob_set_angle_position *a) {
	if(c->c != DYNLOAD_BOB_SET_ANGLE_POSITION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_ANGLE_POSITION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_angle_position() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->angle = dynload_param_get_number(&c->p[2]);
	a->distance = dynload_param_get_number(&c->p[3]);

	return(0);
}

static int dynload_bob_get_depth_pre(struct a_funcs *c, struct par_bob_get_depth *a) {
	if(c->c != DYNLOAD_BOB_GET_DEPTH_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_DEPTH_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_depth() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_set_depth_pre(struct a_funcs *c, struct par_bob_set_depth *a) {
	if(c->c != DYNLOAD_BOB_SET_DEPTH_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_DEPTH_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_depth() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->depth = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_get_distance_pre(struct a_funcs *c, struct par_bob_get_distance *a) {
	if(c->c != DYNLOAD_BOB_GET_DISTANCE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_DISTANCE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_distance() */
	a->a_container = dynload_param_get_handle(&c->p[0]);
	a->a_bob = dynload_param_get_handle(&c->p[1]);

	a->b_container = dynload_param_get_handle(&c->p[2]);
	a->b_bob = dynload_param_get_handle(&c->p[3]);

	return(0);
}

static int dynload_bob_get_measure_pre(struct a_funcs *c, struct par_bob_get_measure *a) {
	if(c->c != DYNLOAD_BOB_GET_MEASURE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_MEASURE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_measure() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->x = (int) dynload_param_get_number(&c->p[2]);
	a->y = (int) dynload_param_get_number(&c->p[3]);

	return(0);
}

static int dynload_bob_get_map_pre(struct a_funcs *c, struct par_bob_get_map *a) {
	if(c->c != DYNLOAD_BOB_GET_MAP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_MAP_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_map() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_set_map_pre(struct a_funcs *c, struct par_bob_set_map *a) {
	if(c->c != DYNLOAD_BOB_SET_MAP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_MAP_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_map() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->map = (unsigned int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_get_playdirection_pre(struct a_funcs *c, struct par_bob_get_playdirection *a) {
	if(c->c != DYNLOAD_BOB_GET_PLAYDIRECTION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_PLAYDIRECTION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_playdirection() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_set_playdirection_pre(struct a_funcs *c, struct par_bob_set_playdirection *a) {
	if(c->c != DYNLOAD_BOB_SET_PLAYDIRECTION_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_PLAYDIRECTION_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_playdirection() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->playdirection = (unsigned int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_get_playmode_pre(struct a_funcs *c, struct par_bob_get_playmode *a) {
	if(c->c != DYNLOAD_BOB_GET_PLAYMODE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_PLAYMODE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_playmode() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_set_playmode_pre(struct a_funcs *c, struct par_bob_set_playmode *a) {
	if(c->c != DYNLOAD_BOB_SET_PLAYMODE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_PLAYMODE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_playmode() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->playmode = (unsigned int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_get_playskip_pre(struct a_funcs *c, struct par_bob_get_playskip *a) {
	if(c->c != DYNLOAD_BOB_GET_PLAYSKIP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_PLAYSKIP_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_playskip() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_set_playskip_pre(struct a_funcs *c, struct par_bob_set_playskip *a) {
	if(c->c != DYNLOAD_BOB_SET_PLAYSKIP_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_PLAYSKIP_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_playskip() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->playskip = (unsigned int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_get_playspeed_pre(struct a_funcs *c, struct par_bob_get_playspeed *a) {
	if(c->c != DYNLOAD_BOB_GET_PLAYSPEED_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_PLAYSPEED_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_playspeed() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_set_playspeed_pre(struct a_funcs *c, struct par_bob_set_playspeed *a) {
	if(c->c != DYNLOAD_BOB_SET_PLAYSPEED_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_PLAYSPEED_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_playspeed() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->playspeed = dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_set_frame_pre(struct a_funcs *c, struct par_bob_set_frame *a) {
	if(c->c != DYNLOAD_BOB_SET_FRAME_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_FRAME_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_frame() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->frame = (unsigned int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_add_frame_pre(struct a_funcs *c, struct par_bob_add_frame *a) {
	if(c->c != DYNLOAD_BOB_ADD_FRAME_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_ADD_FRAME_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_add_frame() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->frame = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_sub_frame_pre(struct a_funcs *c, struct par_bob_sub_frame *a) {
	if(c->c != DYNLOAD_BOB_SUB_FRAME_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SUB_FRAME_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_sub_frame() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	a->frame = (int) dynload_param_get_number(&c->p[2]);

	return(0);
}

static int dynload_bob_get_container_depth_pre(struct a_funcs *c, struct par_bob_get_container_depth *a) {
	if(c->c != DYNLOAD_BOB_GET_CONTAINER_DEPTH_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_GET_CONTAINER_DEPTH_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_get_container_depth() */
	a->container = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_bob_set_container_depth_pre(struct a_funcs *c, struct par_bob_set_container_depth *a) {
	if(c->c != DYNLOAD_BOB_SET_CONTAINER_DEPTH_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_SET_CONTAINER_DEPTH_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_set_container_depth() */
	a->container = dynload_param_get_handle(&c->p[0]);

	a->depth = (int) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_bob_create_pre(struct a_funcs *c, struct par_bob_create *a) {
	if(c->c != DYNLOAD_BOB_CREATE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_CREATE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_create() */
	a->file = dynload_param_get_handle(&c->p[0]);
	a->container = dynload_param_get_handle(&c->p[1]);

	a->altitude = (unsigned int) dynload_param_get_number(&c->p[2]);

	a->x = (int) dynload_param_get_number(&c->p[3]);
	a->y = (int) dynload_param_get_number(&c->p[4]);

	a->depth = (int) dynload_param_get_number(&c->p[5]);

	return(0);
}

static int dynload_bob_create_background_pre(struct a_funcs *c, struct par_bob_create_background *a) {
	if(c->c != DYNLOAD_BOB_CREATE_BACKGROUND_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_CREATE_BACKGROUND_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_create_background() */
	a->file = dynload_param_get_handle(&c->p[0]);
	a->container = dynload_param_get_handle(&c->p[1]);

	a->opaque = (unsigned int) dynload_param_get_number(&c->p[2]);
	a->depth = (int) dynload_param_get_number(&c->p[3]);

	return(0);
}

static int dynload_bob_create_container_pre(struct a_funcs *c, struct par_bob_create_container *a) {
	if(c->c != DYNLOAD_BOB_CREATE_CONTAINER_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_CREATE_CONTAINER_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_create_container() */
	a->handle = dynload_param_get_handle(&c->p[0]);

	a->depth = (int) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_bob_delete_pre(struct a_funcs *c, struct par_bob_delete *a) {
	if(c->c != DYNLOAD_BOB_DELETE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_DELETE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_delete() */
	a->container = dynload_param_get_handle(&c->p[0]);
	a->bob = dynload_param_get_handle(&c->p[1]);

	return(0);
}

static int dynload_bob_delete_container_pre(struct a_funcs *c, struct par_bob_delete_container *a) {
	if(c->c != DYNLOAD_BOB_DELETE_CONTAINER_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_DELETE_CONTAINER_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_delete_container() */
	a->container = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_bob_init_file_pre(struct a_funcs *c, struct par_bob_init_file *a) {
	if(c->c != DYNLOAD_BOB_INIT_FILE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_INIT_FILE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_init_file() */
	a->name = (char *) dynload_param_get_string(&c->p[0]);

	return(0);
}

static int dynload_bob_init_image_pre(struct a_funcs *c, struct par_bob_init_image *a) {
	if(c->c != DYNLOAD_BOB_INIT_IMAGE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_INIT_IMAGE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_init_image() */
	a->width = (unsigned int) dynload_param_get_number(&c->p[0]);
	a->height = (unsigned int) dynload_param_get_number(&c->p[1]);

	return(0);
}

static int dynload_bob_free_file_pre(struct a_funcs *c, struct par_bob_free_file *a) {
	if(c->c != DYNLOAD_BOB_FREE_FILE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_FREE_FILE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_free_file() */
	a->file = dynload_param_get_handle(&c->p[0]);

	return(0);
}

static int dynload_bob_free_image_pre(struct a_funcs *c, struct par_bob_free_image *a) {
	if(c->c != DYNLOAD_BOB_FREE_IMAGE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_BOB_FREE_IMAGE_PARAMS);

		return(-1);
	}

	/* Pass parameters to bob_free_image() */
	a->image = dynload_param_get_handle(&c->p[0]);

	return(0);
}
#endif
static int dynload_node_get_pre(struct a_funcs *c) {
	if(c->c != DYNLOAD_NODE_GET_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_NODE_GET_PARAMS);

		return(-1);
	}

	return(0);
}
#if ! defined(PROG_DISABLE_IMAGE)
static int dynload_image_read_pre(struct a_funcs *c, struct par_image_read *a) {
	if(c->c != DYNLOAD_IMAGE_READ_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_IMAGE_READ_PARAMS);

		return(-1);
	}

	/* Pass parameters to image_read() */
	a->name = (char *) dynload_param_get_string(&c->p[0]);

	return(0);
}

static int dynload_image_write_pre(struct a_funcs *c, struct par_image_write *a) {
	if(c->c != DYNLOAD_IMAGE_WRITE_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_IMAGE_WRITE_PARAMS);

		return(-1);
	}

	/* Pass parameters to image_[format]_write_32() */
	a->name = (char *) dynload_param_get_string(&c->p[0]);

	(void) dynload_pre_image(c, 1, &a->width, &a->height, &a->image);

	return(0);
}
#endif
#if ! defined(PROG_DISABLE_REMOTE)
static int dynload_remote_init_pre(struct a_funcs *c) {
	if(c->c != DYNLOAD_REMOTE_INIT_PARAMS) {
		(void) dynload_error_params(c, DYNLOAD_REMOTE_INIT_PARAMS);

		return(-1);
	}

	return(0);
}
#endif
static uint32_t dynload_pre_color(struct a_funcs *c, unsigned int n) {
	struct dsl_clr a;

	(void) dynload_param_get_color(&c->p[n], &a);

	return(a.color.pixel.p);
}
#if ! defined(PROG_DISABLE_IMAGE) || ! defined(PROG_DISABLE_WIDGET)
static void dynload_pre_image(struct a_funcs *c, unsigned int n, unsigned int *w, unsigned int *h, struct pixel_rgba_8 **p) {
	struct dsl_img *a;

	a = (struct dsl_img *) dynload_param_get_image(&c->p[n]);

	*w = a->image.w;
	*h = a->image.h;
	*p = a->image.s;
}
#endif
#if ! defined(PROG_DISABLE_COORDS)
static void dynload_pre_point(struct a_funcs *c, unsigned int n, double *x, double *y, double *z) {
	struct dsl_pnt *a;

	a = (struct dsl_pnt *) dynload_param_get_point(&c->p[n]);

	*x = a->point.x;
	*y = a->point.y;
	*z = a->point.z;
}
#endif
void *dynload_ret_string(void *c) {
	char *r;

	size_t t;

	if(c == NULL) return(NULL);

	t = str_len((const char *) c, STRING_ASCII);

	APP_MALLOC_RET_VALUE(r, t + sizeof(char), NULL);

	(void) memcpy((void *) r, (const void *) c, t);

	r[t] = 0;

	return((void *) r);
}

void *dynload_ret_color(void *c) {
	void *r;

	APP_MALLOC_RET_VALUE(r, sizeof(struct pixel_rgba_8), NULL);

	(void) memcpy((void *) r, (const void *) c, sizeof(struct pixel_rgba_8));

	return(r);
}

void *dynload_ret_image(void *c) {
	void *r;

	APP_MALLOC_RET_VALUE(r, sizeof(struct dsl_img), NULL);

	(void) memcpy((void *) r, (const void *) c, sizeof(struct dsl_img));

	return(r);
}

void *dynload_ret_position(void *c) {
	void *r;

	APP_MALLOC_RET_VALUE(r, sizeof(struct position), NULL);

	(void) memcpy((void *) r, (const void *) c, sizeof(struct position));

	return(r);
}