Rewrite accent_table to dynamic array

Signed-off-by: Alexey Gladkov <gladkov.alexey@gmail.com>

diff --git a/src/libkeymap/common.c b/src/libkeymap/common.c
index 33795fe..7eea260 100644 (file)
--- a/src/libkeymap/common.c
+++ b/src/libkeymap/common.c
@@ -105,15 +105,17 @@ lk_init(struct keymap *kmap)
        lk_set_log_priority(kmap, LOG_ERR);
 
        kmap->keymap = malloc(sizeof(struct lk_array));
+       kmap->accent_table = malloc(sizeof(struct lk_array));
        kmap->key_constant = malloc(sizeof(struct lk_array));
        kmap->key_line = malloc(sizeof(struct lk_array));
 
-       if (!(kmap->keymap) || !(kmap->key_constant) || !(kmap->key_line)) {
+       if (!(kmap->keymap) || !(kmap->accent_table) || !(kmap->key_constant) || !(kmap->key_line)) {
                ERR(kmap, "out of memory");
                return -1;
        }
 
        lk_array_init(kmap->keymap, sizeof(void*), 0);
+       lk_array_init(kmap->accent_table, sizeof(void*), 0);
        lk_array_init(kmap->key_constant, sizeof(char), 0);
        lk_array_init(kmap->key_line, sizeof(int), 0);
 
@@ -151,6 +153,22 @@ lk_free(struct keymap *kmap)
                kmap->keymap = NULL;
        }
 
+       if (kmap->accent_table) {
+               for (i = 0; i < kmap->accent_table->total; i++) {
+                       struct lk_array *ptr;
+
+                       ptr = lk_array_get_ptr(kmap->accent_table, i);
+                       if (!ptr)
+                               continue;
+
+                       free(ptr);
+               }
+               lk_array_free(kmap->accent_table);
+               free(kmap->accent_table);
+
+               kmap->accent_table = NULL;
+       }
+
        if (kmap->key_constant) {
                lk_array_free(kmap->key_constant);
                free(kmap->key_constant);

diff --git a/src/libkeymap/dump.c b/src/libkeymap/dump.c
index da830f9..2d7a225 100644 (file)
--- a/src/libkeymap/dump.c
+++ b/src/libkeymap/dump.c
@@ -113,6 +113,7 @@ lk_dump_ctable(struct keymap *kmap, FILE *fd)
        unsigned int maxfunc;
        unsigned int func_table_offs[MAX_NR_FUNC];
        unsigned int func_buf_offset = 0;
+       struct kb_diacr *kddiac;
 
        if (lk_add_constants(kmap) < 0)
                return -1;
@@ -196,29 +197,30 @@ lk_dump_ctable(struct keymap *kmap, FILE *fd)
                fprintf(fd, "\t0,\n");
        fprintf(fd, "};\n");
 
-#ifdef KDSKBDIACRUC
        if (kmap->flags & LK_FLAG_PREFER_UNICODE) {
                fprintf(fd, "\nstruct kbdiacruc accent_table[MAX_DIACR] = {\n");
-               for (i = 0; i < kmap->accent_table_size; i++) {
+               for (i = 0; i < kmap->accent_table->count; i++) {
+                       kddiac = lk_array_get_ptr(kmap->accent_table, i);
+
                        fprintf(fd, "\t{");
-                       outchar(fd, kmap->accent_table[i].diacr, 1);
-                       outchar(fd, kmap->accent_table[i].base, 1);
-                       fprintf(fd, "0x%04x},", kmap->accent_table[i].result);
+                       outchar(fd, kddiac->diacr, 1);
+                       outchar(fd, kddiac->base, 1);
+                       fprintf(fd, "0x%04x},", kddiac->result);
                        if (i % 2)
                                fprintf(fd, "\n");
                }
                if (i % 2)
                        fprintf(fd, "\n");
                fprintf(fd, "};\n\n");
-       } else
-#endif
-       {
+       } else {
                fprintf(fd, "\nstruct kbdiacr accent_table[MAX_DIACR] = {\n");
-               for (i = 0; i < kmap->accent_table_size; i++) {
+               for (i = 0; i < kmap->accent_table->count; i++) {
+                       kddiac = lk_array_get_ptr(kmap->accent_table, i);
+
                        fprintf(fd, "\t{");
-                       outchar(fd, kmap->accent_table[i].diacr, 1);
-                       outchar(fd, kmap->accent_table[i].base, 1);
-                       outchar(fd, kmap->accent_table[i].result, 0);
+                       outchar(fd, kddiac->diacr, 1);
+                       outchar(fd, kddiac->base, 1);
+                       outchar(fd, kddiac->result, 0);
                        fprintf(fd, "},");
                        if (i % 2)
                                fprintf(fd, "\n");
@@ -227,7 +229,8 @@ lk_dump_ctable(struct keymap *kmap, FILE *fd)
                        fprintf(fd, "\n");
                fprintf(fd, "};\n\n");
        }
-       fprintf(fd, "unsigned int accent_table_size = %d;\n", kmap->accent_table_size);
+       fprintf(fd, "unsigned int accent_table_size = %u;\n",
+               (unsigned int) kmap->accent_table->count);
        return 0;
 }
 
@@ -271,25 +274,26 @@ void
 lk_dump_diacs(struct keymap *kmap, FILE *fd)
 {
        unsigned int i;
-#ifdef KDSKBDIACRUC
-       if (kmap->flags & LK_FLAG_PREFER_UNICODE) {
-               for (i = 0; i < kmap->accent_table_size; i++) {
-                       fprintf(fd, "compose ");
-                       dumpchar(fd, kmap->accent_table[i].diacr & 0xff, 0);
+       struct kb_diacr *ptr;
+
+       for (i = 0; i < kmap->accent_table->count; i++) {
+               ptr = lk_array_get_ptr(kmap->accent_table, i);
+               if (!ptr)
+                       continue;
+
+               fprintf(fd, "compose ");
+
+               if (kmap->flags & LK_FLAG_PREFER_UNICODE) {
+                       dumpchar(fd, ptr->diacr & 0xff, 0);
                        fprintf(fd, " ");
-                       dumpchar(fd, kmap->accent_table[i].base & 0xff, 0);
-                       fprintf(fd, " to U+%04x\n", kmap->accent_table[i].result);
-               }
-       } else
-#endif
-       {
-               for (i = 0; i < kmap->accent_table_size; i++) {
-                       fprintf(fd, "compose ");
-                       dumpchar(fd, kmap->accent_table[i].diacr, 0);
+                       dumpchar(fd, ptr->base & 0xff, 0);
+                       fprintf(fd, " to U+%04x\n", ptr->result);
+               } else {
+                       dumpchar(fd, ptr->diacr, 0);
                        fprintf(fd, " ");
-                       dumpchar(fd, kmap->accent_table[i].base, 0);
+                       dumpchar(fd, ptr->base, 0);
                        fprintf(fd, " to ");
-                       dumpchar(fd, kmap->accent_table[i].result, 0);
+                       dumpchar(fd, ptr->result, 0);
                        fprintf(fd, "\n");
                }
        }

diff --git a/src/libkeymap/keymap/data.h b/src/libkeymap/keymap/data.h
index 4edcde9..15a8f58 100644 (file)
--- a/src/libkeymap/keymap/data.h
+++ b/src/libkeymap/keymap/data.h
@@ -6,11 +6,9 @@
 #include <keymap/findfile.h>
 #include <keymap/array.h>
 
-#ifdef KDSKBDIACRUC
-typedef struct kbdiacruc accent_entry;
-#else
-typedef struct kbdiacr accent_entry;
-#endif
+struct kb_diacr {
+       unsigned int diacr, base, result;
+};
 
 typedef enum {
        LK_FLAG_UNICODE_MODE  = (1 << 1),
@@ -40,8 +38,7 @@ struct keymap {
        /* the kernel structures we want to set or print */
        char *func_table[MAX_NR_FUNC];
 
-       accent_entry accent_table[MAX_DIACR];
-       unsigned int accent_table_size;    
+       struct lk_array *accent_table;
 
        struct lk_array *key_constant;
 

diff --git a/src/libkeymap/kmap.c b/src/libkeymap/kmap.c
index 8b3681d..e4dd326 100644 (file)
--- a/src/libkeymap/kmap.c
+++ b/src/libkeymap/kmap.c
@@ -213,18 +213,20 @@ lk_add_func(struct keymap *kmap, struct kbsentry kbs)
 int
 lk_add_diacr(struct keymap *kmap, unsigned int diacr, unsigned int base, unsigned int res)
 {
-       accent_entry *ptr;
+       struct kb_diacr *ptr;
 
-       if (kmap->accent_table_size == MAX_DIACR) {
-               ERR(kmap, _("table overflow"));
+       ptr = malloc(sizeof(struct kb_diacr));
+       if (!ptr) {
+               ERR(kmap, _("out of memory"));
                return -1;
        }
 
-       ptr = &(kmap->accent_table[kmap->accent_table_size++]);
        ptr->diacr  = diacr;
        ptr->base   = base;
        ptr->result = res;
 
+       lk_array_append(kmap->accent_table, &ptr);
+
        return 0;
 }
 

diff --git a/src/libkeymap/loadkeys.c b/src/libkeymap/loadkeys.c
index 0358765..5b494fb 100644 (file)
--- a/src/libkeymap/loadkeys.c
+++ b/src/libkeymap/loadkeys.c
@@ -178,51 +178,61 @@ static int
 defdiacs(struct keymap *kmap, int fd)
 {
        unsigned int i, count;
-       struct kbdiacrs kd;
-#ifdef KDSKBDIACRUC
-       struct kbdiacrsuc kdu;
-#endif
+       struct kb_diacr *ptr;
 
-       count = kmap->accent_table_size;
+       count = kmap->accent_table->count;
        if (count > MAX_DIACR) {
                count = MAX_DIACR;
                ERR(kmap, _("too many compose definitions"));
        }
 #ifdef KDSKBDIACRUC
        if (kmap->flags & LK_FLAG_PREFER_UNICODE) {
+               struct kbdiacrsuc kdu;
+
                kdu.kb_cnt = count;
 
                for (i = 0; i < kdu.kb_cnt; i++) {
-                       kdu.kbdiacruc[i].diacr  = kmap->accent_table[i].diacr;
-                       kdu.kbdiacruc[i].base   = kmap->accent_table[i].base;
-                       kdu.kbdiacruc[i].result = kmap->accent_table[i].result;
+                       ptr = lk_array_get_ptr(kmap->accent_table, i);
+                       if (!ptr) {
+                               /* It can't be happen */
+                               ERR(kmap, _("unable to get compose definitions"));
+                               return -1;
+                       }
+
+                       kdu.kbdiacruc[i].diacr  = ptr->diacr;
+                       kdu.kbdiacruc[i].base   = ptr->base;
+                       kdu.kbdiacruc[i].result = ptr->result;
                }
 
-               if (ioctl(fd, KDSKBDIACRUC, (unsigned long)&kdu))
-                       goto fail2;
+               if (ioctl(fd, KDSKBDIACRUC, (unsigned long)&kdu)) {
+                       ERR(kmap, "KDSKBDIACRUC: %s", strerror(errno));
+                       return -1;
+               }
        } else
 #endif
        {
+               struct kbdiacrs kd;
+
                kd.kb_cnt = count;
+
                for (i = 0; i < kd.kb_cnt; i++) {
-                       kd.kbdiacr[i].diacr  = kmap->accent_table[i].diacr;
-                       kd.kbdiacr[i].base   = kmap->accent_table[i].base;
-                       kd.kbdiacr[i].result = kmap->accent_table[i].result;
+                       ptr = lk_array_get_ptr(kmap->accent_table, i);
+                       if (!ptr) {
+                               ERR(kmap, _("unable to get compose definitions"));
+                               return -1;
+                       }
+                       kd.kbdiacr[i].diacr  = ptr->diacr;
+                       kd.kbdiacr[i].base   = ptr->base;
+                       kd.kbdiacr[i].result = ptr->result;
                }
 
-               if (ioctl(fd, KDSKBDIACR, (unsigned long)&kd))
-                       goto fail1;
+               if (ioctl(fd, KDSKBDIACR, (unsigned long)&kd)) {
+                       ERR(kmap, "KDSKBDIACR: %s", strerror(errno));
+                       return -1;
+               }
        }
 
        return count;
-
- fail1:        ERR(kmap, "KDSKBDIACR: %s", strerror(errno));
-       return -1;
-
-#ifdef KDSKBDIACRUC
- fail2:        ERR(kmap, "KDSKBDIACRUC: %s", strerror(errno));
-       return -1;
-#endif
 }
 
 int
@@ -240,7 +250,7 @@ lk_load_keymap(struct keymap *kmap, int fd, int kbd_mode)
                keyct, (keyct == 1) ? _("key") : _("keys"),
                funcct, (funcct == 1) ? _("string") : _("strings"));
 
-       if (kmap->accent_table_size > 0 || kmap->flags & LK_FLAG_CLEAR_COMPOSE) {
+       if (kmap->accent_table->count > 0 || kmap->flags & LK_FLAG_CLEAR_COMPOSE) {
                diacct = defdiacs(kmap, fd);
 
                if (diacct < 0)

diff --git a/src/libkeymap/summary.c b/src/libkeymap/summary.c
index 933b7b8..632fa23 100644 (file)
--- a/src/libkeymap/summary.c
+++ b/src/libkeymap/summary.c
@@ -85,8 +85,8 @@ lk_dump_summary(struct keymap *kmap, FILE *fd, int console)
                MAX_NR_FUNC);
        fprintf(fd, _("max nr of compose definitions: %d\n"),
                MAX_DIACR);
-       fprintf(fd, _("nr of compose definitions in actual use: %d\n"),
-               kmap->accent_table_size);
+       fprintf(fd, _("nr of compose definitions in actual use: %u\n"),
+               (unsigned int) kmap->accent_table->count);
 }
 
 void

diff --git a/tests/libkeymap-keys.c b/tests/libkeymap-keys.c
index c401841..76860d4 100644 (file)
--- a/tests/libkeymap-keys.c
+++ b/tests/libkeymap-keys.c
@@ -98,7 +98,7 @@ END_TEST
 
 START_TEST(test_add_diacr_0)
 {
-       int i = MAX_DIACR;
+       int i = MAX_DIACR + 10;
        struct keymap kmap;
        lk_init(&kmap);
        kmap.log_fn = NULL;
@@ -109,9 +109,6 @@ START_TEST(test_add_diacr_0)
                i--;
        }
 
-       fail_if(lk_add_diacr(&kmap, 0, 0, 0) == 0,
-               "Possible to add diacr (MAX_DIACR)");
-
        lk_free(&kmap);
 }
 END_TEST