]>
Commit | Line | Data |
---|---|---|
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 | } |