~snowball-yiddish-dev/snowball-yiddish/trunk

« back to all changes in this revision

Viewing changes to snowball/compiler/space.c

  • Committer: richard
  • Date: 2003-03-30 12:08:09 UTC
  • Revision ID: svn-v4:633ccae0-01f4-0310-8c99-d3591da6f01f:trunk:216
This module will contain only the code and build system, and documentation
for building and running the stemming library.
All sample data will be in a separate module, and the website will be in
its own module too.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
 
 
2
#include <stdio.h>    /* for printf */
 
3
#include <stdlib.h>   /* malloc, free */
 
4
#include <string.h>   /* memmove */
 
5
 
 
6
#include "header.h"
 
7
 
 
8
#define HEAD 2*sizeof(int)
 
9
#define EXTENDER 40
 
10
#define DEBUG 0
 
11
 
 
12
 
 
13
/*  This modules provides a simple mechanism for arbitrary length writable
 
14
    strings, called 'blocks'. They are 'symbol *' items rather than 'char *'
 
15
    items however.
 
16
 
 
17
    The calls are:
 
18
 
 
19
        symbol * b = create_b(n);
 
20
            - create an empty block b with room for n symbols
 
21
        b = increase_capacity(b, n);
 
22
            - increase the capacity of block b by n symbols (b may change)
 
23
        b2 = copy_b(b)
 
24
            - copy block b into b2
 
25
        lose_b(b);
 
26
            - lose block b
 
27
        b = move_to_b(b, n, p);
 
28
            - set the data in b to be the n symbols at address p
 
29
        b = addto_to_b(b, n, p);
 
30
            - add the n symbols at address p to the end of the data in b
 
31
        SIZE(b)
 
32
            - is the number of symbols in b
 
33
        For example:
 
34
 
 
35
        symbol * b = create_b(0);
 
36
        {   int i;
 
37
            char p[10];
 
38
            for (i = 0; i < 100; i++) {
 
39
                sprintf(p, " %d", i);
 
40
                add_s_to_b(b, p);
 
41
            }
 
42
        }
 
43
 
 
44
    and b contains " 0 1 2 ... 99" spaced out as symbols.
 
45
*/
 
46
 
 
47
/*  For a block b, SIZE(b) is the number of symbols so far written into it,
 
48
    CAPACITY(b) the total number it can contain, so SIZE(b) <= CAPACITY(b).
 
49
    In fact blocks have 1 extra character over the promised capacity so
 
50
    they can be zero terminated by 'b[SIZE(b)] = 0;' without fear of
 
51
    overwriting.
 
52
*/
 
53
 
 
54
extern symbol * create_b(int n)
 
55
{   symbol * p = (symbol *) (HEAD + (char *) MALLOC(HEAD + (n + 1) * sizeof(symbol)));
 
56
    CAPACITY(p) = n;
 
57
    SIZE(p) = 0;
 
58
    if (DEBUG) printf("<-- %d\n", p);
 
59
    return p;
 
60
}
 
61
 
 
62
extern void report_b(FILE * out, symbol * p)
 
63
{   int i;
 
64
    for (i = 0; i < SIZE(p); i++) fprintf(out, "%c", p[i]);
 
65
}
 
66
 
 
67
extern void lose_b(symbol * p)
 
68
{   if (p == 0) return;
 
69
    if (DEBUG) printf("--> %d\n", p);
 
70
    FREE((char *) p - HEAD);
 
71
}
 
72
 
 
73
extern symbol * increase_capacity(symbol * p, int n)
 
74
{   symbol * q = create_b(CAPACITY(p) + n + EXTENDER);
 
75
    if (DEBUG) printf("%d --> %d\n", p, q);
 
76
    memmove(q, p, CAPACITY(p) * sizeof(symbol));
 
77
    SIZE(q) = SIZE(p);
 
78
    lose_b(p); return q;
 
79
}
 
80
 
 
81
extern symbol * move_to_b(symbol * p, int n, symbol * q)
 
82
{   int x = n - CAPACITY(p);
 
83
    if (x > 0) p = increase_capacity(p, x);
 
84
    memmove(p, q, n * sizeof(symbol)); SIZE(p) = n; return p;
 
85
}
 
86
 
 
87
extern symbol * add_to_b(symbol * p, int n, symbol * q)
 
88
{   int x = SIZE(p) + n - CAPACITY(p);
 
89
    if (x > 0) p = increase_capacity(p, x);
 
90
    memmove(p + SIZE(p), q, n * sizeof(symbol)); SIZE(p) += n; return p;
 
91
}
 
92
 
 
93
extern symbol * copy_b(symbol * p)
 
94
{   int n = SIZE(p);
 
95
    symbol * q = create_b(n);
 
96
    move_to_b(q, n, p);
 
97
    return q;
 
98
}
 
99
 
 
100
int space_count = 0;
 
101
 
 
102
extern void * check_malloc(int n)
 
103
{   space_count++;
 
104
    return malloc(n);
 
105
}
 
106
 
 
107
extern void check_free(void * p)
 
108
{   space_count--;
 
109
    free(p);
 
110
}
 
111
 
 
112
/* To convert a block to a zero terminated string:  */
 
113
 
 
114
extern char * b_to_s(symbol * p)
 
115
{   int n = SIZE(p);
 
116
    char * s = malloc(n + 1);
 
117
    {   int i;
 
118
        for (i = 0; i < n; i++) s[i] = p[i];
 
119
    }
 
120
    s[n] = 0;
 
121
    return s;
 
122
}
 
123
 
 
124
/* To add a zero terminated string to a block. If p = 0 the
 
125
   block is created. */
 
126
 
 
127
extern symbol * add_s_to_b(symbol * p, char * s)
 
128
{   int n = strlen(s);
 
129
    int k;
 
130
    if (p == 0) p = create_b(n);
 
131
    k = SIZE(p);
 
132
    {   int x = k + n - CAPACITY(p);
 
133
        if (x > 0) p = increase_capacity(p, x);
 
134
    }
 
135
    {   int i;
 
136
        for (i = 0; i < n; i++) p[i + k] = s[i];
 
137
    }
 
138
    SIZE(p) += n;
 
139
    return p;
 
140
}
 
141
 
 
142
/* The next section defines string handling capabilities in terms
 
143
   of the lower level block handling capabilities of space.c */
 
144
/* -------------------------------------------------------------*/
 
145
 
 
146
struct str {
 
147
    symbol * data;
 
148
};
 
149
 
 
150
/* Create a new string. */
 
151
extern struct str * str_new()
 
152
{
 
153
    struct str * output = (struct str *) malloc(sizeof(struct str));
 
154
    output->data = create_b(0);
 
155
    return output;
 
156
}
 
157
 
 
158
/* Delete a string. */
 
159
extern void str_delete(struct str * str)
 
160
{
 
161
    lose_b(str->data);
 
162
    free(str);
 
163
}
 
164
 
 
165
/* Append a str to this str. */
 
166
extern void str_append(struct str * str, struct str * add)
 
167
{
 
168
    symbol * q = add->data;
 
169
    str->data = add_to_b(str->data, SIZE(q), q);
 
170
}
 
171
 
 
172
/* Append a character to this str. */
 
173
extern void str_append_ch(struct str * str, char add)
 
174
{
 
175
    symbol q[1];
 
176
    q[0] = add;
 
177
    str->data = add_to_b(str->data, 1, q);
 
178
}
 
179
 
 
180
/* Append a low level block to a str. */
 
181
extern void str_append_b(struct str * str, symbol * q)
 
182
{
 
183
    str->data = add_to_b(str->data, SIZE(q), q);
 
184
}
 
185
 
 
186
/* Append a (char *, null teminated) string to a str. */
 
187
extern void str_append_string(struct str * str, char * s)
 
188
{
 
189
    str->data = add_s_to_b(str->data, s);
 
190
}
 
191
 
 
192
/* Append an integer to a str. */
 
193
extern void str_append_int(struct str * str, int i)
 
194
{
 
195
    char s[30];
 
196
    sprintf(s, "%d", i);
 
197
    str_append_string(str, s);
 
198
}
 
199
 
 
200
/* Clear a string */
 
201
extern void str_clear(struct str * str)
 
202
{
 
203
    SIZE(str->data) = 0;
 
204
}
 
205
 
 
206
/* Set a string */
 
207
extern void str_assign(struct str * str, char * s)
 
208
{
 
209
    str_clear(str);
 
210
    str_append_string(str, s);
 
211
}
 
212
 
 
213
/* Copy a string. */
 
214
extern struct str * str_copy(struct str * old)
 
215
{
 
216
    struct str * new = str_new();
 
217
    str_append(new, old);
 
218
    return new;
 
219
}
 
220
 
 
221
/* Get the data stored in this str. */
 
222
extern symbol * str_data(struct str * str)
 
223
{
 
224
    return str->data;
 
225
}
 
226
 
 
227
/* Get the length of the str. */
 
228
extern int str_len(struct str * str)
 
229
{
 
230
    return SIZE(str->data);
 
231
}
 
232