]> git.wh0rd.org Git - ICEs.git/blob - 154175/dictionary.c
initial import
[ICEs.git] / 154175 / dictionary.c
1 #define STARTOFHASHSOURCE 97
2 #define AANTAL ((*d).aantal[hashfunctie])
3 #define INHOUD ((*d).inhoud[hashfunctie])
4 /* Ik definieer AANTAL hier als het aantal keywords, beginnend met de 
5  * eerste letter van het opgegeven woord.
6  * INHOUD verwijst naar de tabel met pointers die de <K, V> elementen bevat.
7  */
8 #include "dictionary.h"
9
10 int hash(char* word);
11
12 dictionary* dictionary_create(void) {
13         dictionary* dic = calloc(1, sizeof(dictionary));
14         return dic;
15 }
16
17 void dictionary_add(dictionary *d,char* word1,char* word2) {
18         int hashfunctie = hash(word1);
19         /* vanaf hier zijn de INHOUD en AANTAL macro's gedefinieerd; ze 
20          * worden heel veel gebruikt om de leesbaarheid te vergroten */ 
21         element** backup = INHOUD;
22         AANTAL++;
23         INHOUD = (element**) realloc(INHOUD, AANTAL * sizeof(element*));
24         if(INHOUD == NULL) {
25                 /* Als de realloc mislukt, zet alles dan terug zoals het 
26                  * was, en print een foutmelding */
27                 INHOUD = backup;
28                 AANTAL--;
29                 printf("memory error. element not added \n");
30         }
31         else {
32                 INHOUD[AANTAL - 1] = (element*) calloc(1, sizeof(element));
33                 printf("element %s stored at %p \n", word1, INHOUD[AANTAL -1]);
34                 (*INHOUD)[AANTAL-1].keyword = word1;
35                 (*INHOUD)[AANTAL-1].alternative = word2;
36         }
37 }
38
39 void dictionary_remove(dictionary *d,char* word1) {
40         register int index;
41         int hashfunctie = hash(word1);
42         for(index = 0;(index < AANTAL) && (strcmp(((*INHOUD)[index]).keyword, word1) != 0); index++);
43         if(index < AANTAL)  {
44                 /* verwissel het gevonden element met het laatste, en 
45                  * laat realloc de tabel met 1 verkleinen */
46                 printf("deleting element at %p \n", INHOUD[index]);
47                 INHOUD[index] = (element*) INHOUD[index];
48                 free(INHOUD[index]);
49                 INHOUD[index] = INHOUD[AANTAL -1];
50                 AANTAL--;
51                 printf("element freed");
52                 INHOUD = realloc(INHOUD, AANTAL);
53         }
54 }
55
56 void dictionary_print(dictionary *d) {
57         int hashfunctie = 0;
58         int woord_index;
59         while(hashfunctie != 26) {
60                 for(woord_index=0; woord_index < AANTAL; woord_index++) {
61                 printf("Keyword: %s \n", ((*INHOUD)[woord_index]).keyword);
62                 printf("Synoniem: %s \n", ((*INHOUD)[woord_index]).alternative);
63                 }
64                 hashfunctie++;
65         }
66 }
67
68 char* dictionary_find(dictionary *d,char* word1) {
69         int hashfunctie = hash(word1);
70         register int index;
71         for(index = 0; index < AANTAL; index++) {
72                 if(strcmp((*INHOUD[index]).keyword, word1) == 0) return (((*INHOUD)[index]).alternative);
73         }
74         return NULL;
75 }
76
77 void dictionary_findall(dictionary *d,char* word1,char** syn) {
78         int aantal_gevonden_woorden = 0;
79         register int index;
80         int hashfunctie = hash(word1);
81         // syn = realloc(syn, AANTAL * sizeof(char*));
82         /* Dit vraagt misschien wat uitleg: 
83          * De syn pointer wijst naar de tabel met strings.  Er moet dus zo'n tabel gedeclareerd / geinitialiseerd worden.
84          * Hiervoor is geheugen nodig.  We weten niet op voorhand hoeveel, maar beter te veel dan te weinig uiteraard.
85          * Er kunnen maximum evenveel synoniemen gevonden worden als dat er keywords met dezelfde letter in de tabel zitten.
86          * We vragen dus een blok om AL die alternatives in te kunnen opslaan, de geheugenruimte die niet nodig is geven we op het einde weer vrij 
87          */
88         for(index = 0; index < AANTAL; index++) {
89                 // printf("now looking at: %x \n", INHOUD[index]);
90                 if(strcmp((*INHOUD)[index].keyword, word1) == 0) {
91                         // printf("adding %s \n", ((*INHOUD)[index].alternative));
92                         syn[aantal_gevonden_woorden] = ((*INHOUD)[index]).alternative;
93                         // printf("%d : %d \n", syn[aantal_gevonden_woorden], aantal_gevonden_woorden);
94                         aantal_gevonden_woorden++;
95                 }
96         }
97 /*      if(aantal_gevonden_woorden <= AANTAL) {
98         syn = realloc(syn, aantal_gevonden_woorden * sizeof(char*));
99         }*/
100         /* Dit vraagt wederom om wat uitleg:
101          * We hebben een blok geheugen gealloceerd om de maximaal mogelijke hoeveelheid strings in op te slaan.
102          * We hebben ondertussen gevonden hoeveel strings er zijn, die steken al in de array.
103          * Nu moet de overbodige ruimte terug vrijgegeven worden.
104          */
105 }
106
107 void dictionary_destroy(dictionary *d) {
108         int hashfunctie = 0;
109         register int index_lijst;
110         while(hashfunctie < 26) {
111                 index_lijst = 0;
112                 while(index_lijst < AANTAL) {
113                         free((&INHOUD)[index_lijst]);
114                         index_lijst++;
115                 }
116                 hashfunctie++;
117         }
118         free(d);
119 }
120
121 int hash(char* word) {
122         return (int) ((*word) - STARTOFHASHSOURCE);
123 }
124
125 int main(void) {
126         dictionary* d = dictionary_create();
127         char** syn = malloc(2 * sizeof(char*));
128         int hashfunctie = hash("test");
129         dictionary_add(d, "test", "tettn");
130         dictionary_add(d, "test2", "ooktettn");
131         dictionary_add(d, "test", "nogmeertettn");
132         dictionary_add(d, "vierendelen", "doodgaan");
133         dictionary_add(d, "proberen", "test");
134         printf("%s \n", dictionary_find(d, "test"));
135         dictionary_findall(d, "test", syn);
136         printf("findall woord1: %s \n", syn[0]);
137         printf("findall woord2: %s \n", syn[1]);
138         printf("removing memory ... \n");
139         dictionary_remove(d, "test2");
140         dictionary_print(d);
141         dictionary_destroy(d); 
142         return 0;
143 }