xkb: Clean up warnings

Add const to lots of strings.

Signed-off-by: Keith Packard <keithp@keithp.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>

include/xkbrules.h

@@ -64,7 +64,7 @@ typedef struct _XkbRF_Rule {
 typedef struct _XkbRF_Group {
     int number;
     const char *name;
-    const char *words;
+    char *words;
 } XkbRF_GroupRec, *XkbRF_GroupPtr;
 
 #define	XkbRF_PendingMatch	(1L<<1)

include/xkbsrv.h

@@ -852,7 +852,7 @@ extern _X_EXPORT unsigned int XkbDDXLoadKeymapByNames(DeviceIntPtr /* keybd */ ,
     );
 
 extern _X_EXPORT Bool XkbDDXNamesFromRules(DeviceIntPtr /* keybd */ ,
-                                           char * /* rules */ ,
+                                           const char * /* rules */ ,
                                            XkbRF_VarDefsPtr /* defs */ ,
                                            XkbComponentNamesPtr /* names */
     );

xkb/ddxLoad.c

@@ -299,7 +299,7 @@ XkbDDXLoadKeymapByNames(DeviceIntPtr keybd,
 
 Bool
 XkbDDXNamesFromRules(DeviceIntPtr keybd,
-                     char *rules_name,
+                     const char *rules_name,
                      XkbRF_VarDefsPtr defs, XkbComponentNamesPtr names)
 {
     char buf[PATH_MAX];

xkb/maprules.c

@@ -218,10 +218,10 @@ typedef struct _FileSpec {
 } FileSpec;
 
 typedef struct {
-    char *model;
+    const char *model;
-    char *layout[XkbNumKbdGroups + 1];
+    const char *layout[XkbNumKbdGroups + 1];
-    char *variant[XkbNumKbdGroups + 1];
+    const char *variant[XkbNumKbdGroups + 1];
-    char *options;
+    const char *options;
 } XkbRF_MultiDefsRec, *XkbRF_MultiDefsPtr;
 
 #define NDX_BUFF_SIZE	4
@@ -343,9 +343,9 @@ SetUpRemap(InputLine * line, RemapSpec * remap)
 }
 
 static Bool
-MatchOneOf(char *wanted, char *vals_defined)
+MatchOneOf(const char *wanted, const char *vals_defined)
 {
-    char *str, *next;
+    const char *str, *next;
     int want_len = strlen(wanted);
 
     for (str = vals_defined, next = NULL; str != NULL; str = next) {
@@ -469,7 +469,7 @@ CheckLine(InputLine * line,
 }
 
 static char *
-_Concat(char *str1, char *str2)
+_Concat(char *str1, const char *str2)
 {
     int len;
 
@@ -498,12 +498,13 @@ squeeze_spaces(char *p1)
 static Bool
 MakeMultiDefs(XkbRF_MultiDefsPtr mdefs, XkbRF_VarDefsPtr defs)
 {
-
+    char *options;
     memset((char *) mdefs, 0, sizeof(XkbRF_MultiDefsRec));
     mdefs->model = defs->model;
-    mdefs->options = Xstrdup(defs->options);
+    options = Xstrdup(defs->options);
-    if (mdefs->options)
+    if (options)
-        squeeze_spaces(mdefs->options);
+        squeeze_spaces(options);
+    mdefs->options = options;
 
     if (defs->layout) {
         if (!strchr(defs->layout, ',')) {
@@ -511,13 +512,15 @@ MakeMultiDefs(XkbRF_MultiDefsPtr mdefs, XkbRF_VarDefsPtr defs)
         }
         else {
             char *p;
+            char *layout;
             int i;
 
-            mdefs->layout[1] = Xstrdup(defs->layout);
+            layout = Xstrdup(defs->layout);
-            if (mdefs->layout[1] == NULL)
+            if (layout == NULL)
                 return FALSE;
-            squeeze_spaces(mdefs->layout[1]);
+            squeeze_spaces(layout);
-            p = mdefs->layout[1];
+            mdefs->layout[1] = layout;
+            p = layout;
             for (i = 2; i <= XkbNumKbdGroups; i++) {
                 if ((p = strchr(p, ','))) {
                     *p++ = '\0';
@@ -538,13 +541,15 @@ MakeMultiDefs(XkbRF_MultiDefsPtr mdefs, XkbRF_VarDefsPtr defs)
         }
         else {
             char *p;
+            char *variant;
             int i;
 
-            mdefs->variant[1] = Xstrdup(defs->variant);
+            variant = Xstrdup(defs->variant);
-            if (mdefs->variant[1] == NULL)
+            if (variant == NULL)
                 return FALSE;
-            squeeze_spaces(mdefs->variant[1]);
+            squeeze_spaces(variant);
-            p = mdefs->variant[1];
+            mdefs->variant[1] = variant;
+            p = variant;
             for (i = 2; i <= XkbNumKbdGroups; i++) {
                 if ((p = strchr(p, ','))) {
                     *p++ = '\0';
@@ -564,13 +569,13 @@ MakeMultiDefs(XkbRF_MultiDefsPtr mdefs, XkbRF_VarDefsPtr defs)
 static void
 FreeMultiDefs(XkbRF_MultiDefsPtr defs)
 {
-    free(defs->options);
+    free((void *) defs->options);
-    free(defs->layout[1]);
+    free((void *) defs->layout[1]);
-    free(defs->variant[1]);
+    free((void *) defs->variant[1]);
 }
 
 static void
-Apply(char *src, char **dst)
+Apply(const char *src, char **dst)
 {
     if (src) {
         if (*src == '+' || *src == '!') {
@@ -596,7 +601,7 @@ XkbRF_ApplyRule(XkbRF_RulePtr rule, XkbComponentNamesPtr names)
 }
 
 static Bool
-CheckGroup(XkbRF_RulesPtr rules, char *group_name, char *name)
+CheckGroup(XkbRF_RulesPtr rules, const char *group_name, const char *name)
 {
     int i;
     char *p;
@@ -1013,15 +1018,15 @@ XkbRF_Free(XkbRF_RulesPtr rules, Bool freeRules)
         return;
     if (rules->rules) {
         for (i = 0, rule = rules->rules; i < rules->num_rules; i++, rule++) {
-            free(rule->model);
+            free((void *) rule->model);
-            free(rule->layout);
+            free((void *) rule->layout);
-            free(rule->variant);
+            free((void *) rule->variant);
-            free(rule->option);
+            free((void *) rule->option);
-            free(rule->keycodes);
+            free((void *) rule->keycodes);
-            free(rule->symbols);
+            free((void *) rule->symbols);
-            free(rule->types);
+            free((void *) rule->types);
-            free(rule->compat);
+            free((void *) rule->compat);
-            free(rule->geometry);
+            free((void *) rule->geometry);
             memset((char *) rule, 0, sizeof(XkbRF_RuleRec));
         }
         free(rules->rules);
@@ -1031,7 +1036,7 @@ XkbRF_Free(XkbRF_RulesPtr rules, Bool freeRules)
 
     if (rules->groups) {
         for (i = 0, group = rules->groups; i < rules->num_groups; i++, group++) {
-            free(group->name);
+            free((void *) group->name);
             free(group->words);
         }
         free(rules->groups);

xkb/xkbInit.c

@@ -129,11 +129,11 @@ XkbFreeRMLVOSet(XkbRMLVOSet * rmlvo, Bool freeRMLVO)
     if (!rmlvo)
         return;
 
-    free(rmlvo->rules);
+    free((void *) rmlvo->rules);
-    free(rmlvo->model);
+    free((void *) rmlvo->model);
-    free(rmlvo->layout);
+    free((void *) rmlvo->layout);
-    free(rmlvo->variant);
+    free((void *) rmlvo->variant);
-    free(rmlvo->options);
+    free((void *) rmlvo->options);
 
     if (freeRMLVO)
         free(rmlvo);