fixing gcc 2.95 compilation

8 files changed, 110 insertions, 76 deletions

diff --git a/ChangeLog b/ChangeLog
index a1a82c6..509f4e3 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2006-04-22 svu
+
+	* libxklavier/*.c:
+	* tests/*.c: fixing gcc 2.95 compilation,
+	thanks to Jens Granseuer
+
 2006-04-18 svu
 
 	* NEWS: preparing 2.91
diff --git a/libxklavier/xklavier.c b/libxklavier/xklavier.c
index aec31bb..f7106eb 100644
--- a/libxklavier/xklavier.c
+++ b/libxklavier/xklavier.c
@@ -579,6 +579,10 @@ xkl_engine_constructor(GType type,
 		       GObjectConstructParam * construct_properties)
 {
 	GObject *obj;
+	XklEngine *engine;
+	Display *display;
+	int scr;
+	gint rv;
 
 	{
 		/* Invoke parent constructor. */
@@ -590,16 +594,14 @@ xkl_engine_constructor(GType type,
 					      construct_properties);
 	}
 
-	XklEngine *engine = XKL_ENGINE(obj);
+	engine = XKL_ENGINE(obj);
 
-	Display *display =
+	display =
 	    (Display *) g_value_peek_pointer(construct_properties[0].
 					     value);
 
 	xkl_engine_priv(engine, display) = display;
 
-	int scr;
-
 	xkl_engine_priv(engine, default_error_handler) =
 	    XSetErrorHandler((XErrorHandler) xkl_process_error);
 
@@ -624,7 +626,7 @@ xkl_engine_constructor(GType type,
 
 	xkl_engine_one_switch_to_secondary_group_performed(engine);
 
-	gint rv = -1;
+	rv = -1;
 	xkl_debug(150, "Trying all backends:\n");
 #ifdef ENABLE_XKB_SUPPORT
 	xkl_debug(150, "Trying XKB backend\n");
@@ -719,6 +721,7 @@ static void
 xkl_engine_finalize(GObject * obj)
 {
 	XklEngine *engine = (XklEngine *) obj;
+	gpointer backend;
 
 	XSetErrorHandler((XErrorHandler)
 			 xkl_engine_priv(engine, default_error_handler));
@@ -728,7 +731,7 @@ xkl_engine_finalize(GObject * obj)
 
 	xkl_engine_vcall(engine, finalize) (engine);
 
-	gpointer backend = xkl_engine_priv(engine, backend);
+	backend = xkl_engine_priv(engine, backend);
 	if (backend != NULL)
 		g_free(backend);
 	g_free(engine->priv);
@@ -759,6 +762,18 @@ xkl_engine_class_init(XklEngineClass * klass)
 	};
 
 	GObjectClass *object_class;
+	GParamSpec *display_param_spec;
+	GParamSpec *backend_name_param_spec;
+	GParamSpec *features_param_spec;
+	GParamSpec *max_num_groups_param_spec;
+	GParamSpec *num_groups_param_spec;
+	GParamSpec *default_group_param_spec;
+	GParamSpec *secondary_groups_mask_param_spec;
+	GParamSpec *indicators_handling_param_spec;
+	GType features_type;
+	GType state_change_type;
+
+	const gchar *sdl;
 
 	object_class = (GObjectClass *) klass;
 	parent_class = g_type_class_peek_parent(object_class);
@@ -768,61 +783,58 @@ xkl_engine_class_init(XklEngineClass * klass)
 	object_class->set_property = xkl_engine_set_property;
 	object_class->get_property = xkl_engine_get_property;
 
-	GParamSpec *display_param_spec = g_param_spec_pointer("display",
-							      "Display",
-							      "X Display pointer",
-							      G_PARAM_CONSTRUCT_ONLY
-							      |
-							      G_PARAM_READWRITE);
+	display_param_spec = g_param_spec_pointer("display",
+						  "Display",
+						  "X Display pointer",
+						  G_PARAM_CONSTRUCT_ONLY
+						  |
+						  G_PARAM_READWRITE);
 
-	GParamSpec *backend_name_param_spec =
-	    g_param_spec_string("backendName",
-				"backendName",
-				"Backend name",
-				NULL,
-				G_PARAM_READABLE);
+	backend_name_param_spec = g_param_spec_string("backendName",
+						      "backendName",
+						      "Backend name",
+						      NULL,
+						      G_PARAM_READABLE);
 
-	GType features_type = g_flags_register_static("XklEngineFeatures",
-						      feature_flags);
+	features_type = g_flags_register_static("XklEngineFeatures",
+						feature_flags);
 
-	GType state_change_type =
+	state_change_type =
 	    g_enum_register_static("XklEngineStateChangeType",
 				   state_change_values);
 
-	GParamSpec *features_param_spec = g_param_spec_flags("features",
-							     "Features",
-							     "Backend features",
-							     features_type,
-							     0,
-							     G_PARAM_READABLE);
-	GParamSpec *max_num_groups_param_spec =
-	    g_param_spec_uint("max-num-groups",
-			      "maxNumGroups",
-			      "Max number of groups",
-			      0, 0x100, 0,
-			      G_PARAM_READABLE);
-
-	GParamSpec *num_groups_param_spec = g_param_spec_uint("num-groups",
-							      "numGroups",
-							      "Current number of groups",
-							      0, 0x100, 0,
-							      G_PARAM_READABLE);
-
-	GParamSpec *default_group_param_spec =
-	    g_param_spec_uint("default-group",
-			      "defaultGroup",
-			      "Default group",
-			      0, 0x100, 0,
-			      G_PARAM_READABLE);
-
-	GParamSpec *secondary_groups_mask_param_spec =
+	features_param_spec = g_param_spec_flags("features",
+						 "Features",
+						 "Backend features",
+					 	 features_type,
+						 0,
+						 G_PARAM_READABLE);
+	max_num_groups_param_spec = g_param_spec_uint("max-num-groups",
+						      "maxNumGroups",
+						      "Max number of groups",
+						      0, 0x100, 0,
+						      G_PARAM_READABLE);
+
+	num_groups_param_spec = g_param_spec_uint("num-groups",
+						  "numGroups",
+						  "Current number of groups",
+						  0, 0x100, 0,
+						  G_PARAM_READABLE);
+
+	default_group_param_spec = g_param_spec_uint("default-group",
+						     "defaultGroup",
+						     "Default group",
+						     0, 0x100, 0,
+						     G_PARAM_READABLE);
+
+	secondary_groups_mask_param_spec =
 	    g_param_spec_uint("secondary-groups-mask",
 			      "secondaryGroupsMask",
 			      "Secondary groups mask",
 			      0, 0x100, 0,
 			      G_PARAM_READABLE);
 
-	GParamSpec *indicators_handling_param_spec =
+	indicators_handling_param_spec =
 	    g_param_spec_boolean("indicators-handling",
 				 "indicatorsHandling",
 				 "Whether engine should handle indicators",
@@ -872,7 +884,7 @@ xkl_engine_class_init(XklEngineClass * klass)
 	/* 2 Windows passed */
 	/* static stuff initialized */
 
-	const gchar *sdl = g_getenv("XKL_DEBUG");
+	sdl = g_getenv("XKL_DEBUG");
 
 	if (sdl != NULL) {
 		xkl_set_debug_level(atoi(sdl));
diff --git a/libxklavier/xklavier_config.c b/libxklavier/xklavier_config.c
index 5aa21e7..9949bc8 100644
--- a/libxklavier/xklavier_config.c
+++ b/libxklavier/xklavier_config.c
@@ -329,13 +329,15 @@ xkl_engine_get_ruleset_name(XklEngine * engine,
 XklConfigRegistry *
 xkl_config_registry_get_instance(XklEngine * engine)
 {
+	XklConfigRegistry *config;
+
 	if (!engine) {
 		xkl_debug(10,
 			  "xkl_config_registry_get_instance : engine is NULL ?\n");
 		return NULL;
 	}
 
-	XklConfigRegistry *config =
+	config =
 	    XKL_CONFIG_REGISTRY(g_object_new
 				(xkl_config_registry_get_type(), "engine",
 				 engine, NULL));
@@ -548,8 +550,10 @@ xkl_config_rec_activate(const XklConfigRec * data, XklEngine * engine)
 gboolean
 xkl_config_registry_load(XklConfigRegistry * config)
 {
+	XklEngine *engine;
+
 	xkl_config_registry_free(config);
-	XklEngine *engine = xkl_config_registry_get_engine(config);
+	engine = xkl_config_registry_get_engine(config);
 	xkl_engine_ensure_vtable_inited(engine);
 	return xkl_engine_vcall(engine, load_config_registry) (config);
 }
@@ -585,8 +589,8 @@ xkl_config_rec_dump(FILE * file, XklConfigRec * data)
 	fprintf(file, "  layouts:\n");
 #define OUTPUT_ARRZ(arrz) \
   { \
-    fprintf( file, "  " #arrz ":\n" ); \
     gchar **p = data->arrz; \
+    fprintf( file, "  " #arrz ":\n" ); \
     if ( p != NULL ) \
       for( j = 0; *p != NULL; ) \
         fprintf( file, "  %d: [%s]\n", j++, *p++ ); \
@@ -606,6 +610,8 @@ xkl_config_registry_constructor(GType type,
 				construct_properties)
 {
 	GObject *obj;
+	XklConfigRegistry *config;
+	XklEngine *engine;
 
 	{
 		/* Invoke parent constructor. */
@@ -618,11 +624,10 @@ xkl_config_registry_constructor(GType type,
 					      construct_properties);
 	}
 
-	XklConfigRegistry *config = XKL_CONFIG_REGISTRY(obj);
+	config = XKL_CONFIG_REGISTRY(obj);
 
-	XklEngine *engine =
-	    XKL_ENGINE(g_value_peek_pointer
-		       (construct_properties[0].value));
+	engine = XKL_ENGINE(g_value_peek_pointer
+			    (construct_properties[0].value));
 	xkl_config_registry_get_engine(config) = engine;
 
 	xkl_engine_ensure_vtable_inited(engine);
@@ -699,6 +704,7 @@ static void
 xkl_config_registry_class_init(XklConfigRegistryClass * klass)
 {
 	GObjectClass *object_class;
+	GParamSpec *engine_param_spec;
 
 	object_class = (GObjectClass *) klass;
 	parent_class = g_type_class_peek_parent(object_class);
@@ -707,13 +713,13 @@ xkl_config_registry_class_init(XklConfigRegistryClass * klass)
 	object_class->set_property = xkl_config_registry_set_property;
 	object_class->get_property = xkl_config_registry_get_property;
 
-	GParamSpec *engine_param_spec = g_param_spec_object("engine",
-							    "Engine",
-							    "XklEngine",
-							    XKL_TYPE_ENGINE,
-							    G_PARAM_CONSTRUCT_ONLY
-							    |
-							    G_PARAM_READWRITE);
+	engine_param_spec = g_param_spec_object("engine",
+						"Engine",
+						"XklEngine",
+						XKL_TYPE_ENGINE,
+						G_PARAM_CONSTRUCT_ONLY
+						|
+						G_PARAM_READWRITE);
 
 	g_object_class_install_property(object_class,
 					PROP_ENGINE, engine_param_spec);
diff --git a/libxklavier/xklavier_props.c b/libxklavier/xklavier_props.c
index 2355e0c..55adbd0 100644
--- a/libxklavier/xklavier_props.c
+++ b/libxklavier/xklavier_props.c
@@ -387,6 +387,7 @@ xkl_config_rec_set_to_root_window_property(const XklConfigRec * data,
 	gchar *all_layouts = xkl_config_rec_merge_layouts(data);
 	gchar *all_variants = xkl_config_rec_merge_variants(data);
 	gchar *all_options = xkl_config_rec_merge_options(data);
+	Display *display;
 
 	len = (rules_file ? strlen(rules_file) : 0);
 	len += (data->model ? strlen(data->model) : 0);
@@ -455,7 +456,7 @@ xkl_config_rec_set_to_root_window_property(const XklConfigRec * data,
 		return FALSE;
 	}
 
-	Display *display = xkl_engine_get_display(engine);
+	display = xkl_engine_get_display(engine);
 	rv = XChangeProperty(display, xkl_engine_priv(engine, root_window),
 			     rules_atom, XA_STRING, 8, PropModeReplace,
 			     (unsigned char *) pval, len);
diff --git a/libxklavier/xklavier_xkb.c b/libxklavier/xklavier_xkb.c
index ebb473a..8c1dfe9 100644
--- a/libxklavier/xklavier_xkb.c
+++ b/libxklavier/xklavier_xkb.c
@@ -96,12 +96,14 @@ xkl_xkb_free_all_info(XklEngine * engine)
 {
 	gint i;
 	gchar **pi = xkl_engine_backend(engine, XklXkb, indicator_names);
+	XkbDescPtr desc;
+
 	for (i = 0; i < XkbNumIndicators; i++, pi++) {
 		/* only free non-empty ones */
 		if (*pi && **pi)
 			XFree(*pi);
 	}
-	XkbDescPtr desc = xkl_engine_backend(engine, XklXkb, cached_desc);
+	desc = xkl_engine_backend(engine, XklXkb, cached_desc);
 	if (desc != NULL) {
 		int i;
 		char **group_name =
@@ -219,6 +221,7 @@ xkl_xkb_load_all_info(XklEngine * engine)
 	Display *display = xkl_engine_get_display(engine);
 	XkbDescPtr actual =
 	    xkl_engine_backend(engine, XklXkb, actual_desc);
+	XkbDescPtr cached;
 
 	if (actual == NULL)
 		if (!xkl_xkb_load_actual_desc(engine)) {
@@ -227,8 +230,7 @@ xkl_xkb_load_all_info(XklEngine * engine)
 		}
 
 	/* take it from the cache (in most cases LoadAll is called from ResetAll which in turn ...) */
-	XkbDescPtr cached = actual =
-	    xkl_engine_backend(engine, XklXkb, actual_desc);
+	cached = actual = xkl_engine_backend(engine, XklXkb, actual_desc);
 	xkl_engine_backend(engine, XklXkb, cached_desc) =
 	    xkl_engine_backend(engine, XklXkb, actual_desc);
 	xkl_engine_backend(engine, XklXkb, actual_desc) = NULL;
diff --git a/libxklavier/xklavier_xmm.c b/libxklavier/xklavier_xmm.c
index e37b3d8..88ff889 100755
--- a/libxklavier/xklavier_xmm.c
+++ b/libxklavier/xklavier_xmm.c
@@ -254,13 +254,14 @@ void
 xkl_xmm_lock_group(XklEngine * engine, gint group)
 {
 	CARD32 propval;
+	Display *display;
 
 	if (xkl_xmm_get_num_groups(engine) < group)
 		return;
 
 	/* updating the status property */
 	propval = group;
-	Display *display = xkl_engine_get_display(engine);
+	display = xkl_engine_get_display(engine);
 	XChangeProperty(display, xkl_engine_priv(engine, root_window),
 			xkl_engine_backend(engine, XklXmm, state_atom),
 			XA_INTEGER, 32, PropModeReplace,
@@ -277,6 +278,8 @@ xkl_xmm_set_indicators(XklEngine * engine, const XklState * window_state)
 gint
 xkl_xmm_init(XklEngine * engine)
 {
+	Display *display;
+
 	xkl_engine_priv(engine, backend_id) = "xmodmap";
 	xkl_engine_priv(engine, features) =
 	    XKLF_MULTIPLE_LAYOUTS_SUPPORTED |
@@ -311,7 +314,7 @@ xkl_xmm_init(XklEngine * engine)
 	if (getenv("XKL_XMODMAP_DISABLE") != NULL)
 		return -1;
 
-	Display *display = xkl_engine_get_display(engine);
+	display = xkl_engine_get_display(engine);
 	xkl_engine_priv(engine, base_config_atom) =
 	    XInternAtom(display, "_XMM_NAMES", False);
 	xkl_engine_priv(engine, backup_config_atom) =
diff --git a/tests/test_config.c b/tests/test_config.c
index 2d0c44a..457da67 100644
--- a/tests/test_config.c
+++ b/tests/test_config.c
@@ -98,6 +98,7 @@ main(int argc, char *const argv[])
 	int debug_level = -1;
 	int binary = 0;
 	Display *dpy;
+	XklEngine *engine;
 
 	g_type_init_with_debug_flags(G_TYPE_DEBUG_OBJECTS |
 				     G_TYPE_DEBUG_SIGNALS);
@@ -161,12 +162,13 @@ main(int argc, char *const argv[])
 	}
 	if (debug_level != -1)
 		xkl_set_debug_level(debug_level);
-	XklEngine *engine = xkl_engine_get_instance(dpy);
+	engine = xkl_engine_get_instance(dpy);
 	if (engine != NULL) {
 		XklConfigRec *current_config, *r2;
+		XklConfigRegistry *config;
+
 		xkl_debug(0, "Xklavier initialized\n");
-		XklConfigRegistry *config =
-		    xkl_config_registry_get_instance(engine);
+		config = xkl_config_registry_get_instance(engine);
 		xkl_config_registry_load(config);
 		xkl_debug(0, "Xklavier registry loaded\n");
 		xkl_debug(0, "Backend: [%s]\n",
diff --git a/tests/test_monitor.c b/tests/test_monitor.c
index e9f229d..de1dd3a 100644
--- a/tests/test_monitor.c
+++ b/tests/test_monitor.c
@@ -37,6 +37,7 @@ main(int argc, char *argv[])
 	int debug_level = -1;
 	XkbEvent ev;
 	Display *dpy;
+	XklEngine *engine;
 	int listener_type = 0, lt;
 	int listener_types[] = { XKLL_MANAGE_LAYOUTS,
 		XKLL_MANAGE_WINDOW_STATES,
@@ -81,12 +82,13 @@ main(int argc, char *argv[])
 	}
 	if (debug_level != -1)
 		xkl_set_debug_level(debug_level);
-	XklEngine *engine = xkl_engine_get_instance(dpy);
+	engine = xkl_engine_get_instance(dpy);
 	if (engine != NULL) {
 		XklConfigRec *current_config;
+		XklConfigRegistry *config;
+
 		xkl_debug(0, "Xklavier initialized\n");
-		XklConfigRegistry *config =
-		    xkl_config_registry_get_instance(engine);
+		config = xkl_config_registry_get_instance(engine);
 		xkl_config_registry_load(config);
 		xkl_debug(0, "Xklavier registry loaded\n");