stmtQueue.c
2.63 KB
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
123
#include <malloc.h>
#include <string.h>
#include <ident.h>
#include <statement.h>
#include <block.h>
#include <stmtQueue.h>
/* give the queue an initial size for 10 statements */
#define QUEUE_GROW_SIZE 10
struct stmtQueue
{
s_stmt ** stmts; /* a dynamically growing array of statements. */
unsigned int size; /* the actual size of the array in statements */
unsigned int maxIdx; /* the maximum index used in the array. */
};
s_stmtQueue *
stmtQueueNew(void)
{
s_stmtQueue * new = (s_stmtQueue*)malloc(sizeof(s_stmtQueue));
new->size = QUEUE_GROW_SIZE;
new->maxIdx = 0;
new->stmts = (s_stmt**)calloc(sizeof(s_stmt*), new->size);
memset(new->stmts, 0, sizeof(s_stmt *) * new->size);
return new;
}
/*
* This concat does not change a or b, as opposed to the c strcat function
*/
s_stmtQueue *
stmtQueueConcat(s_stmtQueue * a, s_stmtQueue * b)
{
s_stmtQueue * new = (s_stmtQueue*)malloc(sizeof(s_stmtQueue));
new->size = a->size + b->size;
new->maxIdx = a->maxIdx + b->maxIdx;
new->stmts = (s_stmt**)calloc(sizeof(s_stmt*), new->size);
memset(new->stmts, 0, sizeof(s_stmt*) * new->size);
memcpy(new->stmts, a->stmts, sizeof(s_stmt*) * a->maxIdx);
memcpy(&(new->stmts[a->maxIdx]), b->stmts, sizeof(s_stmt*) * b->maxIdx);
return new;
}
void
stmtQueueFree(s_stmtQueue * sQueue)
{
unsigned int i;
if (sQueue == NULL) return;
/* freeing the queue is the final step. All stmts should be freed too! */
for (i=0; i < sQueue->maxIdx; i++)
stmtFree(sQueue->stmts[i]);
free(sQueue->stmts);
free(sQueue);
}
void
stmtQueueEnqueue(s_stmtQueue * sQueue, s_stmt * stmt)
{
if (sQueue->maxIdx >= sQueue->size)
{
s_stmt ** stmtsOld = sQueue->stmts;
unsigned int newSize = sQueue->size + QUEUE_GROW_SIZE;
sQueue->stmts = (s_stmt**)calloc(sizeof(s_stmt*), newSize);
memcpy (sQueue->stmts, stmtsOld, sizeof(s_stmt**) * sQueue->size);
free(stmtsOld); /* free the old queue but keep the statements */
memset(
&(sQueue->stmts[sQueue->size]),
0,
sizeof(s_stmt**) * QUEUE_GROW_SIZE);
sQueue->size = newSize;
}
sQueue->stmts[sQueue->maxIdx++] = stmt;
}
s_stmt *
stmtQueueDequeue(s_stmtQueue * sQueue)
{
s_stmt * ret = sQueue->stmts[sQueue->maxIdx - 1];
sQueue->stmts[--sQueue->maxIdx] = NULL;
return ret;
}
s_stmt *
stmtQueueGet(s_stmtQueue * sQueue, unsigned int idx)
{
if (idx < sQueue->size) return sQueue->stmts[idx];
else return NULL;
}
void
stmtQueueDo(s_stmtQueue * sQueue)
{
int i;
if (sQueue == NULL) return;
for (i = 0; i < sQueue->maxIdx; i++)
stmtDo(sQueue->stmts[i], NULL /* !!!FIXME: give me a sane value!!! */);
}
unsigned
int
stmtQueueGetSize(s_stmtQueue * sQueue)
{
return sQueue->size;
}