games/hangman/dict.c

   1 /*
   2  * This file is licensed under the GPLv2 license
   3  *
   4  * Luiz Fernando N. Capitulino
   5  * <lcapitulino@gmail.com>
   6  */
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <stdlib.h>
  10 #include <errno.h>
  11 #include <time.h>
  12
  13 #include "dict.h"
  14 #include "misc.h"
  15
  16 enum dictionary_menu_opt {
  17         DICT_PRINT = 1,
  18         DICT_SEARCH,
  19         DICT_INSERT,
  20         DICT_REMOVE,
  21         DICT_EXIT
  22 };
  23
  24 static const char dict_file_path[] = "dict.txt";
  25
  26 /*
  27  * Helpers
  28  */
  29
  30 /* skip_char(): skip a sequence of characters 'c' in 'file' */
  31 static void skip_char(FILE *file, int c)
  32 {
  33         int rc;
  34
  35         while ((rc = getc(file)) == c)
  36                 /* NOTHING */ ;
  37         ungetc(rc, file);
  38 }
  39
  40 /* skip_space(): skip spaces in 'file' */
  41 static void skip_space(FILE *file)
  42 {
  43         skip_char(file, ' ');
  44 }
  45
  46 /* seek_line_end(): go to the end of a dict line */
  47 static void seek_line_end(FILE *file)
  48 {
  49         int c;
  50
  51         for (;;) {
  52                 c = getc(file);
  53                 if (c == EOF || c == ':' || c == '\n')
  54                         break;
  55         }
  56 }
  57
  58 /* str_kill_nl(): kill a new-line character at end of line */
  59 static void str_kill_nl(char *line)
  60 {
  61         line[strlen(line) - 1] = '\0';
  62 }
  63
  64 /*
  65  * List functions
  66  */
  67
  68 /* list_empty(): Return 1 if 'list' is empty, 0 otherwise */
  69 static int list_empty(const struct dict_list *list)
  70 {
  71         return list->first == list->last;
  72 }
  73
  74 /* word_compare(): comparison function used by insertion_sort() */
  75 static int word_compare(const void *key1, const void *key2)
  76 {
  77         const char *str1 = ((const struct dict_line *) key1)->word;
  78         const char *str2 = ((const struct dict_line *) key2)->word;
  79
  80         return memcmp(str1, str2, DICT_WORD_MAX);
  81 }
  82
  83 /* insertion_sort(): sort data by using insertion sort algorithm */
  84 static int insertion_sort(void *data, int size, int esize,
  85                           int (*compare) (const void *key1, const void *key2))
  86 {
  87         char *a = data;
  88         void *key;
  89         int i, j;
  90
  91         key = (char *) malloc(esize);
  92         if (!key)
  93                 return -1;
  94
  95         for (j = 1; j < size; j++) {
  96                 memcpy(key, &a[j * esize], esize);
  97                 i = j - 1;
  98
  99                 while (i >= 0 && compare(&a[i * esize], key) > 0) {
 100                         memcpy(&a[(i + 1) * esize], &a[i * esize], esize);
 101                         i--;
 102                 }
 103
 104                 memcpy(&a[(i + 1) * esize], key, esize);
 105         }
 106
 107         free(key);
 108         return 0;
 109 }
 110
 111 /* list_sort(): sort list */
 112 static int list_sort(struct dict_list *list)
 113 {
 114         return insertion_sort(list->dict_line, list->last,
 115                               sizeof(struct dict_line), word_compare);
 116 }
 117
 118 /* list_init(): Initialize 'list' */
 119 static void list_init(struct dict_list *list)
 120 {
 121         list->first = list->last = 0;
 122 }
 123
 124 /* list_insert(): Insert element 'line' into 'list' */
 125 static int list_insert(struct dict_list *list, struct dict_line *line)
 126 {
 127         if (list->last == DICT_LIST_MAX) {
 128                 errno = ENOMEM;
 129                 return -1;
 130         }
 131
 132         list->dict_line[list->last] = *line;
 133         list->last++;
 134
 135         return 0;
 136 }
 137
 138 /* list_remove(): Removes element at position 'pos' from 'list', the
 139  * elements' address is returned in 'ret' */
 140 static int list_remove(int pos,
 141                        struct dict_list *list, struct dict_line *ret)
 142 {
 143         int i;
 144
 145         if (list_empty(list) || pos >= list->last)
 146                 return -1;
 147
 148         if (ret)
 149                 *ret = list->dict_line[pos];
 150
 151         list->last--;
 152
 153         for (i = pos; i < list->last; i++)
 154                 list->dict_line[i] = list->dict_line[i + 1];
 155
 156         return 0;
 157 }
 158
 159 /* list_write(): Write 'list' to the dict file */
 160 static int list_write(struct dict_list *list)
 161 {
 162         int i;
 163         FILE *dict;
 164
 165         dict = fopen(dict_file_path, "w");
 166         if (!dict)
 167                 return -1;
 168
 169         for (i = 0; i < list->last; i++) {
 170                 fprintf(dict, "%s: %s\n",
 171                         list->dict_line[i].word, list->dict_line[i].tip);
 172         }
 173
 174         fclose(dict);
 175         return 0;
 176 }
 177
 178 /* show_entry(): print 'entry' in a standard way */
 179 static void show_entry(int nr, const struct dict_line *entry)
 180 {
 181         printf("%d. word: %s\n", nr, entry->word);
 182         printf("    tip: %s\n", entry->tip);
 183         printf("\n");
 184 }
 185
 186 /* list_print(): Print 'list' to the standard output */
 187 static void list_print(const struct dict_list *list)
 188 {
 189         int i;
 190
 191         if (list_empty(list))
 192                 return;
 193
 194         printf("\n");
 195
 196         for (i = 0; i < list->last; i++)
 197                 show_entry(i, &list->dict_line[i]);
 198 }
 199
 200 static void handle_pattern(char *pattern,
 201                            const struct dict_list *list)
 202 {
 203         int i, showed;
 204
 205         if (pattern[0] == '\n') {
 206                 list_print(list);
 207                 return;
 208         }
 209
 210         showed = 0;
 211         pattern[strlen(pattern) - 1] = '\0';
 212
 213         for (i = 0; i < list->last; i++) {
 214                 if (strstr(list->dict_line[i].word, pattern)) {
 215                         show_entry(i, &list->dict_line[i]);
 216                         showed = 1;
 217                 }
 218         }
 219
 220         if (!showed)
 221                 printf("\n-> Nao encontrado\n");
 222 }
 223
 224 static void show_prompt(void)
 225 {
 226         clear_screen();
 227
 228         printf("Aperte <enter> para fazer a pesquisa e "
 229                "Ctrl-D para sair\n\n");
 230         printf(">>> ");
 231 }
 232
 233 static void list_search(const struct dict_list *list)
 234 {
 235         char *ret;
 236         char pattern[DICT_WORD_MAX];
 237
 238         for (;;) {
 239                 show_prompt();
 240
 241                 ret = fgets(pattern, sizeof(pattern), stdin);
 242                 if (!ret)
 243                         return;
 244
 245                 handle_pattern(pattern, list);
 246                 mprint("");
 247         }
 248 }
 249
 250 /*
 251  * Dict high level functions
 252  */
 253
 254 /* dict_read_line(): read a line from dict file 'file' and return it
 255  * in 'line' of size 'size' */
 256 static int dict_read_line(FILE *file, char *line, size_t size)
 257 {
 258         size_t i;
 259         int end, c;
 260
 261         end = 0;
 262         memset(line, 0, size);
 263
 264         skip_space(file);
 265
 266         for (i = 0; i < size; i++) {
 267                 c = getc(file);
 268                 if (c == EOF || c == ':' || c == '\n') {
 269                         end = 1;
 270                         break;
 271                 }
 272                 line[i] = c;
 273         }
 274
 275         if (!end) {
 276                 seek_line_end(file);
 277                 --i;
 278         }
 279
 280         line[i] = '\0';
 281         return c;
 282 }
 283
 284 /* dict_read_file(): read the entire dict file in the 'dict_line'
 285  * array, of elements 'size'. Return the number of read elements
 286  * in 'read' */
 287 static int dict_read_file(struct dict_line *dict_line, size_t size, int *read)
 288 {
 289         int ret;
 290         size_t i;
 291         FILE *dict;
 292
 293         *read = 0;
 294
 295         dict = fopen(dict_file_path, "r");
 296         if (!dict)
 297                 return -1;
 298
 299         for (i = 0; i < size; i++) {
 300                 ret = dict_read_line(dict, dict_line[i].word, DICT_WORD_MAX);
 301                 if (ret == EOF)
 302                         break;
 303
 304                 ret = dict_read_line(dict, dict_line[i].tip, DICT_TIP_MAX);
 305                 if (ret == EOF)
 306                         break;
 307         }
 308
 309         *read = i;
 310
 311         fclose(dict);
 312         return 0;
 313 }
 314
 315 /* dict_read_user(): Read a dict line from the user */
 316 static void dict_read_user(struct dict_line *line)
 317 {
 318
 319         line->word[0] = line->tip[0] = '\0';
 320
 321         fflush(stdin);
 322         printf("Entre com a palavra chave: ");
 323         fgets(line->word, DICT_WORD_MAX, stdin);
 324         str_kill_nl(line->word);
 325
 326         fflush(stdin);
 327         printf("Entre com a dica: ");
 328         fgets(line->tip, DICT_TIP_MAX, stdin);
 329         str_kill_nl(line->tip);
 330 }
 331
 332 /*
 333  * Main functions
 334  */
 335
 336 void dict_pick_up_word(struct dict_line *line)
 337 {
 338         int err;
 339         struct dict_list list;
 340
 341         list_init(&list);
 342
 343         err = dict_read_file(list.dict_line, DICT_LIST_MAX, &list.last);
 344         if (err && errno != ENOENT) {
 345                 eprint("dict_read_file() failed");
 346                 return;
 347         }
 348
 349         srand(time(NULL));
 350
 351         *line = list.dict_line[rand() % list.last];
 352 }
 353
 354 void dictionary_menu(void)
 355 {
 356         int op, pos, err;
 357         struct dict_line line;
 358         struct dict_list list;
 359
 360         list_init(&list);
 361
 362         err = dict_read_file(list.dict_line, DICT_LIST_MAX, &list.last);
 363         if (err && errno != ENOENT) {
 364                 eprint("dict_read_file() failed");
 365                 return;
 366         }
 367
 368         for (;;) {
 369                 err = list_sort(&list);
 370                 if (err) {
 371                         eprint("insertion_sort() failed");
 372                         return;
 373                 }
 374
 375                 clear_screen();
 376                 printf("\nManipular dicionario\n\n");
 377                 printf("1. Imprimir conteudo\n"
 378                        "2. Pesquisa\n"
 379                        "3. Inserir\n"
 380                        "4. Remover\n"
 381                        "5. Sair\n"
 382                        "\n-> opcao: ");
 383                 scanf("%d", (int *) &op);
 384                 flush_all();
 385
 386                 switch (op) {
 387                 case DICT_PRINT:
 388                         list_print(&list);
 389                         mprint("");
 390                         break;
 391                 case DICT_SEARCH:
 392                         list_search(&list);
 393                         break;
 394                 case DICT_INSERT:
 395                         dict_read_user(&line);
 396                         err = list_insert(&list, &line);
 397                         if (err)
 398                                 eprint("Failed\n");
 399                         else
 400                                 mprint("Success\n");
 401                         break;
 402                 case DICT_REMOVE:
 403                         list_print(&list);
 404                         printf("Digite o numero para remover: ");
 405                         scanf("%d", &pos);
 406                         flush_all();
 407                         err = list_remove(pos, &list, NULL);
 408                         if (err)
 409                                 eprint("Failed\n");
 410                         else
 411                                 mprint("Success\n");
 412                         break;
 413                 case DICT_EXIT:
 414                         goto out;
 415                 default:
 416                         errno = EINVAL;
 417                         eprint("Function not implemented");
 418                 }
 419         }
 420
 421 out:
 422         list_write(&list);
 423 }