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

« back to all changes in this revision

Viewing changes to snowball/compiler/header.h

  • 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
typedef unsigned char byte;
 
3
typedef unsigned short symbol;
 
4
 
 
5
#define true 1
 
6
#define false 0
 
7
#define repeat while(true)
 
8
#define unless(C) if(!(C))
 
9
#define until(C) while(!(C))
 
10
 
 
11
#define MALLOC check_malloc
 
12
#define FREE check_free
 
13
 
 
14
#define NEW(type, p) struct type * p = (struct type *) MALLOC(sizeof(struct type))
 
15
#define NEWVEC(type, p, n) struct type * p = (struct type *) MALLOC(sizeof(struct type) * n)
 
16
 
 
17
#define STARTSIZE   10
 
18
#define SIZE(p)     ((int *)(p))[-1]
 
19
#define CAPACITY(p) ((int *)(p))[-2]
 
20
 
 
21
extern symbol * create_b(int n);
 
22
extern void report_b(FILE * out, symbol * p);
 
23
extern void lose_b(symbol * p);
 
24
extern symbol * increase_capacity(symbol * p, int n);
 
25
extern symbol * move_to_b(symbol * p, int n, symbol * q);
 
26
extern symbol * add_to_b(symbol * p, int n, symbol * q);
 
27
extern symbol * copy_b(symbol * p);
 
28
extern char * b_to_s(symbol * p);
 
29
extern symbol * add_s_to_b(symbol * p, char * s);
 
30
 
 
31
struct str; /* defined in space.c */
 
32
 
 
33
extern struct str * str_new();
 
34
extern void str_delete(struct str * str);
 
35
extern void str_append(struct str * str, struct str * add);
 
36
extern void str_append_ch(struct str * str, char add);
 
37
extern void str_append_b(struct str * str, symbol * q);
 
38
extern void str_append_string(struct str * str, char * s);
 
39
extern void str_append_int(struct str * str, int i);
 
40
extern void str_clear(struct str * str);
 
41
extern void str_assign(struct str * str, char * s);
 
42
extern struct str * str_copy(struct str * old);
 
43
extern symbol * str_data(struct str * str);
 
44
extern int str_len(struct str * str);
 
45
 
 
46
extern void sort(void * p, void * p_end, int unit, int (*f)());
 
47
 
 
48
struct m_pair {
 
49
 
 
50
    struct m_pair * next;
 
51
    symbol * name;
 
52
    symbol * value;
 
53
 
 
54
};
 
55
 
 
56
struct input {
 
57
 
 
58
    struct input * next;
 
59
    symbol * p;
 
60
    int c;
 
61
    int line_number;
 
62
 
 
63
};
 
64
 
 
65
struct include {
 
66
 
 
67
    struct include * next;
 
68
    symbol * b;
 
69
 
 
70
};
 
71
 
 
72
struct tokeniser {
 
73
 
 
74
    struct input * next;
 
75
    symbol * p;
 
76
    int c;
 
77
    int line_number;
 
78
    symbol * b;
 
79
    symbol * b2;
 
80
    int number;
 
81
    int m_start;
 
82
    int m_end;
 
83
    struct m_pair * m_pairs;
 
84
    int get_depth;
 
85
    int error_count;
 
86
    int token;
 
87
    int previous_token;
 
88
    byte token_held;
 
89
    byte widechars;
 
90
 
 
91
    int omission;
 
92
    struct include * includes;
 
93
 
 
94
};
 
95
 
 
96
extern symbol * get_input(symbol * p);
 
97
extern struct tokeniser * create_tokeniser(symbol * b);
 
98
extern int read_token(struct tokeniser * t);
 
99
extern byte * name_of_token(int code);
 
100
extern void close_tokeniser(struct tokeniser * t);
 
101
 
 
102
enum token_codes {
 
103
 
 
104
#include "syswords2"
 
105
 
 
106
    c_mathassign,
 
107
    c_name,
 
108
    c_number,
 
109
    c_literalstring,
 
110
    c_neg,
 
111
    c_call,
 
112
    c_grouping,
 
113
    c_booltest
 
114
};
 
115
 
 
116
extern int space_count;
 
117
extern void * check_malloc(int n);
 
118
extern void check_free(void * p);
 
119
 
 
120
struct node;
 
121
 
 
122
struct name {
 
123
 
 
124
    struct name * next;
 
125
    symbol * b;
 
126
    int type;                   /* t_string etc */
 
127
    int mode;                   /*    )_  for routines, externals */
 
128
    struct node * definition;   /*    )                           */
 
129
    int count;                  /* 0, 1, 2 for each type */
 
130
    struct grouping * grouping; /* for grouping names */
 
131
    byte referenced;
 
132
    byte used;
 
133
 
 
134
};
 
135
 
 
136
struct literalstring {
 
137
 
 
138
    struct literalstring * next;
 
139
    symbol * b;
 
140
 
 
141
};
 
142
 
 
143
struct amongvec {
 
144
 
 
145
    symbol * b;      /* the string giving the case */
 
146
    int size;        /* - and its size */
 
147
    struct node * p; /* the corresponding command */
 
148
    int i;           /* the amongvec index of the longest substring of b */
 
149
    int result;      /* the numeric result for the case */
 
150
    struct name * function;
 
151
 
 
152
};
 
153
 
 
154
struct among {
 
155
 
 
156
    struct among * next;
 
157
    struct amongvec * b;      /* pointer to the amongvec */
 
158
    int number;               /* amongs are numbered 0, 1, 2 ... */
 
159
    int literalstring_count;  /* in this among */
 
160
    int command_count;        /* in this among */
 
161
    struct node * starter;    /* i.e. among( (starter) 'string' ... ) */
 
162
    struct node * substring;  /* i.e. substring ... among ( ... ) */
 
163
};
 
164
 
 
165
struct grouping {
 
166
 
 
167
    struct grouping * next;
 
168
    int number;               /* groupings are numbered 0, 1, 2 ... */
 
169
    symbol * b;               /* the characters of this group */
 
170
    int largest_ch;           /* character with max code */
 
171
    int smallest_ch;          /* character with min code */
 
172
    byte no_gaps;             /* no gaps between min and max codes */
 
173
    struct name * name;       /* so g->name->grouping == g */
 
174
};
 
175
 
 
176
struct node {
 
177
 
 
178
    struct node * next;
 
179
    struct node * left;
 
180
    struct node * aux;     /* used in setlimit */
 
181
    struct among * among;  /* used in among */
 
182
    struct node * right;
 
183
    int type;
 
184
    int mode;
 
185
    struct node * AE;
 
186
    struct name * name;
 
187
    symbol * literalstring;
 
188
    int number;
 
189
    int line_number;
 
190
    int amongvar_needed;   /* used in routine definitions */
 
191
};
 
192
 
 
193
enum name_types {
 
194
 
 
195
    t_size = 6,
 
196
 
 
197
    t_string = 0, t_boolean = 1, t_integer = 2, t_routine = 3, t_external = 4,
 
198
    t_grouping = 5
 
199
 
 
200
/*  If this list is extended, adjust wvn in generator.c  */
 
201
};
 
202
 
 
203
/*  In name_count[i] below, remember that
 
204
    type   is
 
205
    ----+----
 
206
      0 |  string
 
207
      1 |  boolean
 
208
      2 |  integer
 
209
      3 |  routine
 
210
      4 |  external
 
211
      5 |  grouping
 
212
*/
 
213
 
 
214
struct analyser {
 
215
 
 
216
    struct tokeniser * tokeniser;
 
217
    struct node * nodes;
 
218
    struct name * names;
 
219
    struct literalstring * literalstrings;
 
220
    int mode;
 
221
    byte modifyable;          /* false inside reverse(...) */
 
222
    struct node * program;
 
223
    struct node * program_end;
 
224
    int name_count[t_size];   /* name_count[i] counts the number of names of type i */
 
225
    struct among * amongs;
 
226
    struct among * amongs_end;
 
227
    int among_count;
 
228
    int amongvar_needed;      /* used in reading routine definitions */
 
229
    struct grouping * groupings;
 
230
    struct grouping * groupings_end;
 
231
    struct node * substring;  /* pending 'substring' in current routine definition */
 
232
 
 
233
};
 
234
 
 
235
enum analyser_modes {
 
236
 
 
237
    m_forward = 0, m_backward /*, m_integer */
 
238
 
 
239
};
 
240
 
 
241
extern void print_program(struct analyser * a);
 
242
extern struct analyser * create_analyser(struct tokeniser * t);
 
243
extern void close_analyser(struct analyser * a);
 
244
 
 
245
extern void read_program(struct analyser * a);
 
246
 
 
247
struct generator {
 
248
 
 
249
    struct analyser * analyser;
 
250
    struct options * options;
 
251
    int unreachable;           /* 0 if code can be reached, 1 if current code
 
252
                                * is unreachable. */
 
253
    int var_number;            /* Number of next variable to use. */
 
254
    struct str * outbuf;       /* temporary str to store output */
 
255
    struct str * declarations; /* str storing variable declarations */
 
256
    int next_label;
 
257
    int margin;
 
258
 
 
259
    char * failure_string;     /* String to output in case of a failure. */
 
260
    struct str * failure_str;  /* This is used by the java generator instead of failure_string */
 
261
 
 
262
    int failure_label;
 
263
    int debug_count;
 
264
 
 
265
    char * S[10];        /* strings */
 
266
    symbol * B[10];      /* blocks */
 
267
    int I[10];           /* integers */
 
268
    struct name * V[5];  /* variables */
 
269
    symbol * L[5];       /* literals, used in formatted write */
 
270
 
 
271
    int line_count;      /* counts number of lines output */
 
272
    int line_labelled;   /* in ANSI C, will need extra ';' if it is a block end */
 
273
    int literalstring_count;
 
274
};
 
275
 
 
276
struct options {
 
277
 
 
278
    /* for the command line: */
 
279
 
 
280
    char * output_file;
 
281
    char * name;
 
282
    FILE * output_c;
 
283
    FILE * output_h;
 
284
    FILE * output_java;
 
285
    byte syntax_tree;
 
286
    byte make_java;
 
287
    byte make_c;
 
288
    byte widechars;
 
289
    char * externals_prefix;
 
290
    char * variables_prefix;
 
291
    struct include * includes;
 
292
    struct include * includes_end;
 
293
 
 
294
};
 
295
 
 
296
/* Generator for C code. */
 
297
extern struct generator * create_generator_c(struct analyser * a, struct options * o);
 
298
extern void close_generator_c(struct generator * g);
 
299
 
 
300
extern void generate_program_c(struct generator * g);
 
301
 
 
302
/* Generator for Java code. */
 
303
extern struct generator * create_generator_java(struct analyser * a, struct options * o);
 
304
extern void close_generator_java(struct generator * g);
 
305
 
 
306
extern void generate_program_java(struct generator * g);
 
307