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 }