src/knowledge/knowledge_finalize.c


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#include <stdlib.h>
#include <string.h>
#include <stdint.h> /* defines SIZE_MAX */

#include "../cli/cli.h"

#include "knowledge.h"

static void knowledge_sequence_collection_finalize
(
   struct ZoO_knowledge_sequence_collection c [const restrict static 1]
)
{
   ZoO_index i;

   if (c->sequences_ref != (ZoO_index *) NULL)
   {
      free((void *) c->sequences_ref);
      c->sequences_ref = (ZoO_index *) NULL;
   }

   if (c->sequences_ref_sorted != (ZoO_index *) NULL)
   {
      free((void *) c->sequences_ref_sorted);
      c->sequences_ref_sorted = (ZoO_index *) NULL;
   }

   if (c->occurrences != (ZoO_index *) NULL)
   {
      free((void *) c->occurrences);
      c->occurrences = (ZoO_index *) NULL;
   }

   for (i = 0; i < c->sequences_ref_length; ++i)
   {
      free((void *) c->targets[i]);
      free((void *) c->targets_occurrences[i]);
   }

   c->sequences_ref_length = 0;

   if (c->targets != (ZoO_index **) NULL)
   {
      free((void *) c->targets);
      c->targets != (ZoO_index **) NULL;
   }

   free((void *) c->targets_length);

   if (c->targets_occurrences != (ZoO_index **) NULL)
   {
      free((void *) c->targets_occurrences);
      c->targets_occurrences != (ZoO_index **) NULL;
   }
}

static void knowledge_word_finalize
(
   struct ZoO_knowledge_word w [const restrict static 1]
)
{
   w->word_size = 0;
   w->occurrences = 0;

   if (w->word != (ZoO_char *) NULL)
   {
      free((void *) w->word);

      w->word = (ZoO_char *) NULL;
   }

   knowledge_sequence_collection_finalize(&(w->followed));
   knowledge_sequence_collection_finalize(&(w->preceded));
}

/* See: "knowledge.h" */
void ZoO_knowledge_finalize (struct ZoO_knowledge k [const restrict static 1])
{
   ZoO_index i;

   for (i = 0; i < k->words_length; ++i)
   {
      knowledge_word_finalize(k->words + i);
   }

   k->words_length = 0;

   if (k->words != (struct ZoO_knowledge_word *) NULL)
   {
      free((void *) k->words);

      k->words = (struct ZoO_knowledge_word *) NULL;
   }

   if (k->words_sorted != (ZoO_index *) NULL)
   {
      free((void *) k->words_sorted);

      k->words_sorted = (ZoO_index *) NULL;
   }

   for (i = 0; i < k->sequences_length; ++i)
   {
      free((void *) k->sequences[i]);
   }

   k->sequences_length = 0;

   if (k->sequences != (ZoO_index **) NULL)
   {
      free((void *) k->sequences);

      k->sequences = (ZoO_index **) NULL;
   }

   if (k->sequences_sorted != (ZoO_index *) NULL)
   {
      free((void *) k->sequences_sorted);

      k->sequences_sorted = (ZoO_index *) NULL;
   }
}