~ubuntu-branches/ubuntu/saucy/ruby-ferret/saucy

« back to all changes in this revision

Viewing changes to ext/STEMMER_stem_UTF_8_porter.c

  • Committer: Package Import Robot
  • Author(s): Cédric Boutillier
  • Date: 2012-06-14 23:04:48 UTC
  • mfrom: (2.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20120614230448-wd5se4ia1yz7dvms
Tags: 0.11.8.4+debian-1
* New upstream version from a new source
  + the new code fixes format security issues (Closes: #672069)
  + change homepage to https://github.com/jkraemer/ferret/
* Build for all Ruby versions (Closes: #655636)
  + change depends accordingly
  + do not set shebang of bin/ferret to ruby1.8
* Repack source to remove convenience copy of bzlib
  + build-dep on libbz2-dev
  + dversionmangle in debian/watch
  + add debian/README.source explaining how to clean the source
* debian/patches:
  + disable_load_path_manipulation.patch: do not override $LOAD_PATH
  + disable_test_causing_segfault.patch: temporarily disable a test known to
    cause segfaults
  + fix_compatibility_with_minitest.patch: fix a failing test with Ruby1.9
  + use_system_bzlib.patch: adapt the source to use system libbz2
  + fix_typos_in_source_code.patch: correct some spelling errors in the
    source code
  + block_variables_have_local_scopes.patch: fix syntax in
    bin/ferret-browser
* Override dh_auto_clean to remove test/temp when cleaning
* Bump Standards-Version to 3.9.3 (no changes needed)
* Set priority of transitional packages to extra
* Add myself to Uploaders:
* Update copyright to DEP-5 copyright-format/1.0
* Add TUTORIAL and debian/README.source to documents
* Override lintian warnings about duplicate descriptions of transitional
  packages

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
 
 
2
/* This file was generated automatically by the Snowball to ANSI C compiler */
 
3
 
 
4
#include "header.h"
 
5
 
 
6
#ifdef __cplusplus
 
7
extern "C" {
 
8
#endif
 
9
extern int porter_UTF_8_stem(struct SN_env * z);
 
10
#ifdef __cplusplus
 
11
}
 
12
#endif
 
13
static int r_Step_5b(struct SN_env * z);
 
14
static int r_Step_5a(struct SN_env * z);
 
15
static int r_Step_4(struct SN_env * z);
 
16
static int r_Step_3(struct SN_env * z);
 
17
static int r_Step_2(struct SN_env * z);
 
18
static int r_Step_1c(struct SN_env * z);
 
19
static int r_Step_1b(struct SN_env * z);
 
20
static int r_Step_1a(struct SN_env * z);
 
21
static int r_R2(struct SN_env * z);
 
22
static int r_R1(struct SN_env * z);
 
23
static int r_shortv(struct SN_env * z);
 
24
#ifdef __cplusplus
 
25
extern "C" {
 
26
#endif
 
27
 
 
28
 
 
29
extern struct SN_env * porter_UTF_8_create_env(void);
 
30
extern void porter_UTF_8_close_env(struct SN_env * z);
 
31
 
 
32
 
 
33
#ifdef __cplusplus
 
34
}
 
35
#endif
 
36
static const symbol s_0_0[1] = { 's' };
 
37
static const symbol s_0_1[3] = { 'i', 'e', 's' };
 
38
static const symbol s_0_2[4] = { 's', 's', 'e', 's' };
 
39
static const symbol s_0_3[2] = { 's', 's' };
 
40
 
 
41
static const struct among a_0[4] =
 
42
{
 
43
/*  0 */ { 1, s_0_0, -1, 3, 0},
 
44
/*  1 */ { 3, s_0_1, 0, 2, 0},
 
45
/*  2 */ { 4, s_0_2, 0, 1, 0},
 
46
/*  3 */ { 2, s_0_3, 0, -1, 0}
 
47
};
 
48
 
 
49
static const symbol s_1_1[2] = { 'b', 'b' };
 
50
static const symbol s_1_2[2] = { 'd', 'd' };
 
51
static const symbol s_1_3[2] = { 'f', 'f' };
 
52
static const symbol s_1_4[2] = { 'g', 'g' };
 
53
static const symbol s_1_5[2] = { 'b', 'l' };
 
54
static const symbol s_1_6[2] = { 'm', 'm' };
 
55
static const symbol s_1_7[2] = { 'n', 'n' };
 
56
static const symbol s_1_8[2] = { 'p', 'p' };
 
57
static const symbol s_1_9[2] = { 'r', 'r' };
 
58
static const symbol s_1_10[2] = { 'a', 't' };
 
59
static const symbol s_1_11[2] = { 't', 't' };
 
60
static const symbol s_1_12[2] = { 'i', 'z' };
 
61
 
 
62
static const struct among a_1[13] =
 
63
{
 
64
/*  0 */ { 0, 0, -1, 3, 0},
 
65
/*  1 */ { 2, s_1_1, 0, 2, 0},
 
66
/*  2 */ { 2, s_1_2, 0, 2, 0},
 
67
/*  3 */ { 2, s_1_3, 0, 2, 0},
 
68
/*  4 */ { 2, s_1_4, 0, 2, 0},
 
69
/*  5 */ { 2, s_1_5, 0, 1, 0},
 
70
/*  6 */ { 2, s_1_6, 0, 2, 0},
 
71
/*  7 */ { 2, s_1_7, 0, 2, 0},
 
72
/*  8 */ { 2, s_1_8, 0, 2, 0},
 
73
/*  9 */ { 2, s_1_9, 0, 2, 0},
 
74
/* 10 */ { 2, s_1_10, 0, 1, 0},
 
75
/* 11 */ { 2, s_1_11, 0, 2, 0},
 
76
/* 12 */ { 2, s_1_12, 0, 1, 0}
 
77
};
 
78
 
 
79
static const symbol s_2_0[2] = { 'e', 'd' };
 
80
static const symbol s_2_1[3] = { 'e', 'e', 'd' };
 
81
static const symbol s_2_2[3] = { 'i', 'n', 'g' };
 
82
 
 
83
static const struct among a_2[3] =
 
84
{
 
85
/*  0 */ { 2, s_2_0, -1, 2, 0},
 
86
/*  1 */ { 3, s_2_1, 0, 1, 0},
 
87
/*  2 */ { 3, s_2_2, -1, 2, 0}
 
88
};
 
89
 
 
90
static const symbol s_3_0[4] = { 'a', 'n', 'c', 'i' };
 
91
static const symbol s_3_1[4] = { 'e', 'n', 'c', 'i' };
 
92
static const symbol s_3_2[4] = { 'a', 'b', 'l', 'i' };
 
93
static const symbol s_3_3[3] = { 'e', 'l', 'i' };
 
94
static const symbol s_3_4[4] = { 'a', 'l', 'l', 'i' };
 
95
static const symbol s_3_5[5] = { 'o', 'u', 's', 'l', 'i' };
 
96
static const symbol s_3_6[5] = { 'e', 'n', 't', 'l', 'i' };
 
97
static const symbol s_3_7[5] = { 'a', 'l', 'i', 't', 'i' };
 
98
static const symbol s_3_8[6] = { 'b', 'i', 'l', 'i', 't', 'i' };
 
99
static const symbol s_3_9[5] = { 'i', 'v', 'i', 't', 'i' };
 
100
static const symbol s_3_10[6] = { 't', 'i', 'o', 'n', 'a', 'l' };
 
101
static const symbol s_3_11[7] = { 'a', 't', 'i', 'o', 'n', 'a', 'l' };
 
102
static const symbol s_3_12[5] = { 'a', 'l', 'i', 's', 'm' };
 
103
static const symbol s_3_13[5] = { 'a', 't', 'i', 'o', 'n' };
 
104
static const symbol s_3_14[7] = { 'i', 'z', 'a', 't', 'i', 'o', 'n' };
 
105
static const symbol s_3_15[4] = { 'i', 'z', 'e', 'r' };
 
106
static const symbol s_3_16[4] = { 'a', 't', 'o', 'r' };
 
107
static const symbol s_3_17[7] = { 'i', 'v', 'e', 'n', 'e', 's', 's' };
 
108
static const symbol s_3_18[7] = { 'f', 'u', 'l', 'n', 'e', 's', 's' };
 
109
static const symbol s_3_19[7] = { 'o', 'u', 's', 'n', 'e', 's', 's' };
 
110
 
 
111
static const struct among a_3[20] =
 
112
{
 
113
/*  0 */ { 4, s_3_0, -1, 3, 0},
 
114
/*  1 */ { 4, s_3_1, -1, 2, 0},
 
115
/*  2 */ { 4, s_3_2, -1, 4, 0},
 
116
/*  3 */ { 3, s_3_3, -1, 6, 0},
 
117
/*  4 */ { 4, s_3_4, -1, 9, 0},
 
118
/*  5 */ { 5, s_3_5, -1, 12, 0},
 
119
/*  6 */ { 5, s_3_6, -1, 5, 0},
 
120
/*  7 */ { 5, s_3_7, -1, 10, 0},
 
121
/*  8 */ { 6, s_3_8, -1, 14, 0},
 
122
/*  9 */ { 5, s_3_9, -1, 13, 0},
 
123
/* 10 */ { 6, s_3_10, -1, 1, 0},
 
124
/* 11 */ { 7, s_3_11, 10, 8, 0},
 
125
/* 12 */ { 5, s_3_12, -1, 10, 0},
 
126
/* 13 */ { 5, s_3_13, -1, 8, 0},
 
127
/* 14 */ { 7, s_3_14, 13, 7, 0},
 
128
/* 15 */ { 4, s_3_15, -1, 7, 0},
 
129
/* 16 */ { 4, s_3_16, -1, 8, 0},
 
130
/* 17 */ { 7, s_3_17, -1, 13, 0},
 
131
/* 18 */ { 7, s_3_18, -1, 11, 0},
 
132
/* 19 */ { 7, s_3_19, -1, 12, 0}
 
133
};
 
134
 
 
135
static const symbol s_4_0[5] = { 'i', 'c', 'a', 't', 'e' };
 
136
static const symbol s_4_1[5] = { 'a', 't', 'i', 'v', 'e' };
 
137
static const symbol s_4_2[5] = { 'a', 'l', 'i', 'z', 'e' };
 
138
static const symbol s_4_3[5] = { 'i', 'c', 'i', 't', 'i' };
 
139
static const symbol s_4_4[4] = { 'i', 'c', 'a', 'l' };
 
140
static const symbol s_4_5[3] = { 'f', 'u', 'l' };
 
141
static const symbol s_4_6[4] = { 'n', 'e', 's', 's' };
 
142
 
 
143
static const struct among a_4[7] =
 
144
{
 
145
/*  0 */ { 5, s_4_0, -1, 2, 0},
 
146
/*  1 */ { 5, s_4_1, -1, 3, 0},
 
147
/*  2 */ { 5, s_4_2, -1, 1, 0},
 
148
/*  3 */ { 5, s_4_3, -1, 2, 0},
 
149
/*  4 */ { 4, s_4_4, -1, 2, 0},
 
150
/*  5 */ { 3, s_4_5, -1, 3, 0},
 
151
/*  6 */ { 4, s_4_6, -1, 3, 0}
 
152
};
 
153
 
 
154
static const symbol s_5_0[2] = { 'i', 'c' };
 
155
static const symbol s_5_1[4] = { 'a', 'n', 'c', 'e' };
 
156
static const symbol s_5_2[4] = { 'e', 'n', 'c', 'e' };
 
157
static const symbol s_5_3[4] = { 'a', 'b', 'l', 'e' };
 
158
static const symbol s_5_4[4] = { 'i', 'b', 'l', 'e' };
 
159
static const symbol s_5_5[3] = { 'a', 't', 'e' };
 
160
static const symbol s_5_6[3] = { 'i', 'v', 'e' };
 
161
static const symbol s_5_7[3] = { 'i', 'z', 'e' };
 
162
static const symbol s_5_8[3] = { 'i', 't', 'i' };
 
163
static const symbol s_5_9[2] = { 'a', 'l' };
 
164
static const symbol s_5_10[3] = { 'i', 's', 'm' };
 
165
static const symbol s_5_11[3] = { 'i', 'o', 'n' };
 
166
static const symbol s_5_12[2] = { 'e', 'r' };
 
167
static const symbol s_5_13[3] = { 'o', 'u', 's' };
 
168
static const symbol s_5_14[3] = { 'a', 'n', 't' };
 
169
static const symbol s_5_15[3] = { 'e', 'n', 't' };
 
170
static const symbol s_5_16[4] = { 'm', 'e', 'n', 't' };
 
171
static const symbol s_5_17[5] = { 'e', 'm', 'e', 'n', 't' };
 
172
static const symbol s_5_18[2] = { 'o', 'u' };
 
173
 
 
174
static const struct among a_5[19] =
 
175
{
 
176
/*  0 */ { 2, s_5_0, -1, 1, 0},
 
177
/*  1 */ { 4, s_5_1, -1, 1, 0},
 
178
/*  2 */ { 4, s_5_2, -1, 1, 0},
 
179
/*  3 */ { 4, s_5_3, -1, 1, 0},
 
180
/*  4 */ { 4, s_5_4, -1, 1, 0},
 
181
/*  5 */ { 3, s_5_5, -1, 1, 0},
 
182
/*  6 */ { 3, s_5_6, -1, 1, 0},
 
183
/*  7 */ { 3, s_5_7, -1, 1, 0},
 
184
/*  8 */ { 3, s_5_8, -1, 1, 0},
 
185
/*  9 */ { 2, s_5_9, -1, 1, 0},
 
186
/* 10 */ { 3, s_5_10, -1, 1, 0},
 
187
/* 11 */ { 3, s_5_11, -1, 2, 0},
 
188
/* 12 */ { 2, s_5_12, -1, 1, 0},
 
189
/* 13 */ { 3, s_5_13, -1, 1, 0},
 
190
/* 14 */ { 3, s_5_14, -1, 1, 0},
 
191
/* 15 */ { 3, s_5_15, -1, 1, 0},
 
192
/* 16 */ { 4, s_5_16, 15, 1, 0},
 
193
/* 17 */ { 5, s_5_17, 16, 1, 0},
 
194
/* 18 */ { 2, s_5_18, -1, 1, 0}
 
195
};
 
196
 
 
197
static const unsigned char g_v[] = { 17, 65, 16, 1 };
 
198
 
 
199
static const unsigned char g_v_WXY[] = { 1, 17, 65, 208, 1 };
 
200
 
 
201
static const symbol s_0[] = { 's', 's' };
 
202
static const symbol s_1[] = { 'i' };
 
203
static const symbol s_2[] = { 'e', 'e' };
 
204
static const symbol s_3[] = { 'e' };
 
205
static const symbol s_4[] = { 'e' };
 
206
static const symbol s_5[] = { 'y' };
 
207
static const symbol s_6[] = { 'Y' };
 
208
static const symbol s_7[] = { 'i' };
 
209
static const symbol s_8[] = { 't', 'i', 'o', 'n' };
 
210
static const symbol s_9[] = { 'e', 'n', 'c', 'e' };
 
211
static const symbol s_10[] = { 'a', 'n', 'c', 'e' };
 
212
static const symbol s_11[] = { 'a', 'b', 'l', 'e' };
 
213
static const symbol s_12[] = { 'e', 'n', 't' };
 
214
static const symbol s_13[] = { 'e' };
 
215
static const symbol s_14[] = { 'i', 'z', 'e' };
 
216
static const symbol s_15[] = { 'a', 't', 'e' };
 
217
static const symbol s_16[] = { 'a', 'l' };
 
218
static const symbol s_17[] = { 'a', 'l' };
 
219
static const symbol s_18[] = { 'f', 'u', 'l' };
 
220
static const symbol s_19[] = { 'o', 'u', 's' };
 
221
static const symbol s_20[] = { 'i', 'v', 'e' };
 
222
static const symbol s_21[] = { 'b', 'l', 'e' };
 
223
static const symbol s_22[] = { 'a', 'l' };
 
224
static const symbol s_23[] = { 'i', 'c' };
 
225
static const symbol s_24[] = { 's' };
 
226
static const symbol s_25[] = { 't' };
 
227
static const symbol s_26[] = { 'e' };
 
228
static const symbol s_27[] = { 'l' };
 
229
static const symbol s_28[] = { 'l' };
 
230
static const symbol s_29[] = { 'y' };
 
231
static const symbol s_30[] = { 'Y' };
 
232
static const symbol s_31[] = { 'y' };
 
233
static const symbol s_32[] = { 'Y' };
 
234
static const symbol s_33[] = { 'Y' };
 
235
static const symbol s_34[] = { 'y' };
 
236
 
 
237
static int r_shortv(struct SN_env * z) {
 
238
    if (out_grouping_b_U(z, g_v_WXY, 89, 121, 0)) return 0;
 
239
    if (in_grouping_b_U(z, g_v, 97, 121, 0)) return 0;
 
240
    if (out_grouping_b_U(z, g_v, 97, 121, 0)) return 0;
 
241
    return 1;
 
242
}
 
243
 
 
244
static int r_R1(struct SN_env * z) {
 
245
    if (!(z->I[0] <= z->c)) return 0;
 
246
    return 1;
 
247
}
 
248
 
 
249
static int r_R2(struct SN_env * z) {
 
250
    if (!(z->I[1] <= z->c)) return 0;
 
251
    return 1;
 
252
}
 
253
 
 
254
static int r_Step_1a(struct SN_env * z) {
 
255
    int among_var;
 
256
    z->ket = z->c; /* [, line 25 */
 
257
    if (z->c <= z->lb || z->p[z->c - 1] != 115) return 0;
 
258
    among_var = find_among_b(z, a_0, 4); /* substring, line 25 */
 
259
    if (!(among_var)) return 0;
 
260
    z->bra = z->c; /* ], line 25 */
 
261
    switch(among_var) {
 
262
        case 0: return 0;
 
263
        case 1:
 
264
            {   int ret = slice_from_s(z, 2, s_0); /* <-, line 26 */
 
265
                if (ret < 0) return ret;
 
266
            }
 
267
            break;
 
268
        case 2:
 
269
            {   int ret = slice_from_s(z, 1, s_1); /* <-, line 27 */
 
270
                if (ret < 0) return ret;
 
271
            }
 
272
            break;
 
273
        case 3:
 
274
            {   int ret = slice_del(z); /* delete, line 29 */
 
275
                if (ret < 0) return ret;
 
276
            }
 
277
            break;
 
278
    }
 
279
    return 1;
 
280
}
 
281
 
 
282
static int r_Step_1b(struct SN_env * z) {
 
283
    int among_var;
 
284
    z->ket = z->c; /* [, line 34 */
 
285
    if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 100 && z->p[z->c - 1] != 103)) return 0;
 
286
    among_var = find_among_b(z, a_2, 3); /* substring, line 34 */
 
287
    if (!(among_var)) return 0;
 
288
    z->bra = z->c; /* ], line 34 */
 
289
    switch(among_var) {
 
290
        case 0: return 0;
 
291
        case 1:
 
292
            {   int ret = r_R1(z);
 
293
                if (ret == 0) return 0; /* call R1, line 35 */
 
294
                if (ret < 0) return ret;
 
295
            }
 
296
            {   int ret = slice_from_s(z, 2, s_2); /* <-, line 35 */
 
297
                if (ret < 0) return ret;
 
298
            }
 
299
            break;
 
300
        case 2:
 
301
            {   int m_test = z->l - z->c; /* test, line 38 */
 
302
                {    /* gopast */ /* grouping v, line 38 */
 
303
                    int ret = out_grouping_b_U(z, g_v, 97, 121, 1);
 
304
                    if (ret < 0) return 0;
 
305
                    z->c -= ret;
 
306
                }
 
307
                z->c = z->l - m_test;
 
308
            }
 
309
            {   int ret = slice_del(z); /* delete, line 38 */
 
310
                if (ret < 0) return ret;
 
311
            }
 
312
            {   int m_test = z->l - z->c; /* test, line 39 */
 
313
                if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((68514004 >> (z->p[z->c - 1] & 0x1f)) & 1)) among_var = 3; else
 
314
                among_var = find_among_b(z, a_1, 13); /* substring, line 39 */
 
315
                if (!(among_var)) return 0;
 
316
                z->c = z->l - m_test;
 
317
            }
 
318
            switch(among_var) {
 
319
                case 0: return 0;
 
320
                case 1:
 
321
                    {   int c_keep = z->c;
 
322
                        int ret = insert_s(z, z->c, z->c, 1, s_3); /* <+, line 41 */
 
323
                        z->c = c_keep;
 
324
                        if (ret < 0) return ret;
 
325
                    }
 
326
                    break;
 
327
                case 2:
 
328
                    z->ket = z->c; /* [, line 44 */
 
329
                    {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
 
330
                        if (ret < 0) return 0;
 
331
                        z->c = ret; /* next, line 44 */
 
332
                    }
 
333
                    z->bra = z->c; /* ], line 44 */
 
334
                    {   int ret = slice_del(z); /* delete, line 44 */
 
335
                        if (ret < 0) return ret;
 
336
                    }
 
337
                    break;
 
338
                case 3:
 
339
                    if (z->c != z->I[0]) return 0; /* atmark, line 45 */
 
340
                    {   int m_test = z->l - z->c; /* test, line 45 */
 
341
                        {   int ret = r_shortv(z);
 
342
                            if (ret == 0) return 0; /* call shortv, line 45 */
 
343
                            if (ret < 0) return ret;
 
344
                        }
 
345
                        z->c = z->l - m_test;
 
346
                    }
 
347
                    {   int c_keep = z->c;
 
348
                        int ret = insert_s(z, z->c, z->c, 1, s_4); /* <+, line 45 */
 
349
                        z->c = c_keep;
 
350
                        if (ret < 0) return ret;
 
351
                    }
 
352
                    break;
 
353
            }
 
354
            break;
 
355
    }
 
356
    return 1;
 
357
}
 
358
 
 
359
static int r_Step_1c(struct SN_env * z) {
 
360
    z->ket = z->c; /* [, line 52 */
 
361
    {   int m1 = z->l - z->c; (void)m1; /* or, line 52 */
 
362
        if (!(eq_s_b(z, 1, s_5))) goto lab1;
 
363
        goto lab0;
 
364
    lab1:
 
365
        z->c = z->l - m1;
 
366
        if (!(eq_s_b(z, 1, s_6))) return 0;
 
367
    }
 
368
lab0:
 
369
    z->bra = z->c; /* ], line 52 */
 
370
    {    /* gopast */ /* grouping v, line 53 */
 
371
        int ret = out_grouping_b_U(z, g_v, 97, 121, 1);
 
372
        if (ret < 0) return 0;
 
373
        z->c -= ret;
 
374
    }
 
375
    {   int ret = slice_from_s(z, 1, s_7); /* <-, line 54 */
 
376
        if (ret < 0) return ret;
 
377
    }
 
378
    return 1;
 
379
}
 
380
 
 
381
static int r_Step_2(struct SN_env * z) {
 
382
    int among_var;
 
383
    z->ket = z->c; /* [, line 58 */
 
384
    if (z->c - 2 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((815616 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
 
385
    among_var = find_among_b(z, a_3, 20); /* substring, line 58 */
 
386
    if (!(among_var)) return 0;
 
387
    z->bra = z->c; /* ], line 58 */
 
388
    {   int ret = r_R1(z);
 
389
        if (ret == 0) return 0; /* call R1, line 58 */
 
390
        if (ret < 0) return ret;
 
391
    }
 
392
    switch(among_var) {
 
393
        case 0: return 0;
 
394
        case 1:
 
395
            {   int ret = slice_from_s(z, 4, s_8); /* <-, line 59 */
 
396
                if (ret < 0) return ret;
 
397
            }
 
398
            break;
 
399
        case 2:
 
400
            {   int ret = slice_from_s(z, 4, s_9); /* <-, line 60 */
 
401
                if (ret < 0) return ret;
 
402
            }
 
403
            break;
 
404
        case 3:
 
405
            {   int ret = slice_from_s(z, 4, s_10); /* <-, line 61 */
 
406
                if (ret < 0) return ret;
 
407
            }
 
408
            break;
 
409
        case 4:
 
410
            {   int ret = slice_from_s(z, 4, s_11); /* <-, line 62 */
 
411
                if (ret < 0) return ret;
 
412
            }
 
413
            break;
 
414
        case 5:
 
415
            {   int ret = slice_from_s(z, 3, s_12); /* <-, line 63 */
 
416
                if (ret < 0) return ret;
 
417
            }
 
418
            break;
 
419
        case 6:
 
420
            {   int ret = slice_from_s(z, 1, s_13); /* <-, line 64 */
 
421
                if (ret < 0) return ret;
 
422
            }
 
423
            break;
 
424
        case 7:
 
425
            {   int ret = slice_from_s(z, 3, s_14); /* <-, line 66 */
 
426
                if (ret < 0) return ret;
 
427
            }
 
428
            break;
 
429
        case 8:
 
430
            {   int ret = slice_from_s(z, 3, s_15); /* <-, line 68 */
 
431
                if (ret < 0) return ret;
 
432
            }
 
433
            break;
 
434
        case 9:
 
435
            {   int ret = slice_from_s(z, 2, s_16); /* <-, line 69 */
 
436
                if (ret < 0) return ret;
 
437
            }
 
438
            break;
 
439
        case 10:
 
440
            {   int ret = slice_from_s(z, 2, s_17); /* <-, line 71 */
 
441
                if (ret < 0) return ret;
 
442
            }
 
443
            break;
 
444
        case 11:
 
445
            {   int ret = slice_from_s(z, 3, s_18); /* <-, line 72 */
 
446
                if (ret < 0) return ret;
 
447
            }
 
448
            break;
 
449
        case 12:
 
450
            {   int ret = slice_from_s(z, 3, s_19); /* <-, line 74 */
 
451
                if (ret < 0) return ret;
 
452
            }
 
453
            break;
 
454
        case 13:
 
455
            {   int ret = slice_from_s(z, 3, s_20); /* <-, line 76 */
 
456
                if (ret < 0) return ret;
 
457
            }
 
458
            break;
 
459
        case 14:
 
460
            {   int ret = slice_from_s(z, 3, s_21); /* <-, line 77 */
 
461
                if (ret < 0) return ret;
 
462
            }
 
463
            break;
 
464
    }
 
465
    return 1;
 
466
}
 
467
 
 
468
static int r_Step_3(struct SN_env * z) {
 
469
    int among_var;
 
470
    z->ket = z->c; /* [, line 82 */
 
471
    if (z->c - 2 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((528928 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
 
472
    among_var = find_among_b(z, a_4, 7); /* substring, line 82 */
 
473
    if (!(among_var)) return 0;
 
474
    z->bra = z->c; /* ], line 82 */
 
475
    {   int ret = r_R1(z);
 
476
        if (ret == 0) return 0; /* call R1, line 82 */
 
477
        if (ret < 0) return ret;
 
478
    }
 
479
    switch(among_var) {
 
480
        case 0: return 0;
 
481
        case 1:
 
482
            {   int ret = slice_from_s(z, 2, s_22); /* <-, line 83 */
 
483
                if (ret < 0) return ret;
 
484
            }
 
485
            break;
 
486
        case 2:
 
487
            {   int ret = slice_from_s(z, 2, s_23); /* <-, line 85 */
 
488
                if (ret < 0) return ret;
 
489
            }
 
490
            break;
 
491
        case 3:
 
492
            {   int ret = slice_del(z); /* delete, line 87 */
 
493
                if (ret < 0) return ret;
 
494
            }
 
495
            break;
 
496
    }
 
497
    return 1;
 
498
}
 
499
 
 
500
static int r_Step_4(struct SN_env * z) {
 
501
    int among_var;
 
502
    z->ket = z->c; /* [, line 92 */
 
503
    if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((3961384 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
 
504
    among_var = find_among_b(z, a_5, 19); /* substring, line 92 */
 
505
    if (!(among_var)) return 0;
 
506
    z->bra = z->c; /* ], line 92 */
 
507
    {   int ret = r_R2(z);
 
508
        if (ret == 0) return 0; /* call R2, line 92 */
 
509
        if (ret < 0) return ret;
 
510
    }
 
511
    switch(among_var) {
 
512
        case 0: return 0;
 
513
        case 1:
 
514
            {   int ret = slice_del(z); /* delete, line 95 */
 
515
                if (ret < 0) return ret;
 
516
            }
 
517
            break;
 
518
        case 2:
 
519
            {   int m1 = z->l - z->c; (void)m1; /* or, line 96 */
 
520
                if (!(eq_s_b(z, 1, s_24))) goto lab1;
 
521
                goto lab0;
 
522
            lab1:
 
523
                z->c = z->l - m1;
 
524
                if (!(eq_s_b(z, 1, s_25))) return 0;
 
525
            }
 
526
        lab0:
 
527
            {   int ret = slice_del(z); /* delete, line 96 */
 
528
                if (ret < 0) return ret;
 
529
            }
 
530
            break;
 
531
    }
 
532
    return 1;
 
533
}
 
534
 
 
535
static int r_Step_5a(struct SN_env * z) {
 
536
    z->ket = z->c; /* [, line 101 */
 
537
    if (!(eq_s_b(z, 1, s_26))) return 0;
 
538
    z->bra = z->c; /* ], line 101 */
 
539
    {   int m1 = z->l - z->c; (void)m1; /* or, line 102 */
 
540
        {   int ret = r_R2(z);
 
541
            if (ret == 0) goto lab1; /* call R2, line 102 */
 
542
            if (ret < 0) return ret;
 
543
        }
 
544
        goto lab0;
 
545
    lab1:
 
546
        z->c = z->l - m1;
 
547
        {   int ret = r_R1(z);
 
548
            if (ret == 0) return 0; /* call R1, line 102 */
 
549
            if (ret < 0) return ret;
 
550
        }
 
551
        {   int m2 = z->l - z->c; (void)m2; /* not, line 102 */
 
552
            {   int ret = r_shortv(z);
 
553
                if (ret == 0) goto lab2; /* call shortv, line 102 */
 
554
                if (ret < 0) return ret;
 
555
            }
 
556
            return 0;
 
557
        lab2:
 
558
            z->c = z->l - m2;
 
559
        }
 
560
    }
 
561
lab0:
 
562
    {   int ret = slice_del(z); /* delete, line 103 */
 
563
        if (ret < 0) return ret;
 
564
    }
 
565
    return 1;
 
566
}
 
567
 
 
568
static int r_Step_5b(struct SN_env * z) {
 
569
    z->ket = z->c; /* [, line 107 */
 
570
    if (!(eq_s_b(z, 1, s_27))) return 0;
 
571
    z->bra = z->c; /* ], line 107 */
 
572
    {   int ret = r_R2(z);
 
573
        if (ret == 0) return 0; /* call R2, line 108 */
 
574
        if (ret < 0) return ret;
 
575
    }
 
576
    if (!(eq_s_b(z, 1, s_28))) return 0;
 
577
    {   int ret = slice_del(z); /* delete, line 109 */
 
578
        if (ret < 0) return ret;
 
579
    }
 
580
    return 1;
 
581
}
 
582
 
 
583
extern int porter_UTF_8_stem(struct SN_env * z) {
 
584
    z->B[0] = 0; /* unset Y_found, line 115 */
 
585
    {   int c1 = z->c; /* do, line 116 */
 
586
        z->bra = z->c; /* [, line 116 */
 
587
        if (!(eq_s(z, 1, s_29))) goto lab0;
 
588
        z->ket = z->c; /* ], line 116 */
 
589
        {   int ret = slice_from_s(z, 1, s_30); /* <-, line 116 */
 
590
            if (ret < 0) return ret;
 
591
        }
 
592
        z->B[0] = 1; /* set Y_found, line 116 */
 
593
    lab0:
 
594
        z->c = c1;
 
595
    }
 
596
    {   int c2 = z->c; /* do, line 117 */
 
597
        while(1) { /* repeat, line 117 */
 
598
            int c3 = z->c;
 
599
            while(1) { /* goto, line 117 */
 
600
                int c4 = z->c;
 
601
                if (in_grouping_U(z, g_v, 97, 121, 0)) goto lab3;
 
602
                z->bra = z->c; /* [, line 117 */
 
603
                if (!(eq_s(z, 1, s_31))) goto lab3;
 
604
                z->ket = z->c; /* ], line 117 */
 
605
                z->c = c4;
 
606
                break;
 
607
            lab3:
 
608
                z->c = c4;
 
609
                {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
 
610
                    if (ret < 0) goto lab2;
 
611
                    z->c = ret; /* goto, line 117 */
 
612
                }
 
613
            }
 
614
            {   int ret = slice_from_s(z, 1, s_32); /* <-, line 117 */
 
615
                if (ret < 0) return ret;
 
616
            }
 
617
            z->B[0] = 1; /* set Y_found, line 117 */
 
618
            continue;
 
619
        lab2:
 
620
            z->c = c3;
 
621
            break;
 
622
        }
 
623
        z->c = c2;
 
624
    }
 
625
    z->I[0] = z->l;
 
626
    z->I[1] = z->l;
 
627
    {   int c5 = z->c; /* do, line 121 */
 
628
        {    /* gopast */ /* grouping v, line 122 */
 
629
            int ret = out_grouping_U(z, g_v, 97, 121, 1);
 
630
            if (ret < 0) goto lab4;
 
631
            z->c += ret;
 
632
        }
 
633
        {    /* gopast */ /* non v, line 122 */
 
634
            int ret = in_grouping_U(z, g_v, 97, 121, 1);
 
635
            if (ret < 0) goto lab4;
 
636
            z->c += ret;
 
637
        }
 
638
        z->I[0] = z->c; /* setmark p1, line 122 */
 
639
        {    /* gopast */ /* grouping v, line 123 */
 
640
            int ret = out_grouping_U(z, g_v, 97, 121, 1);
 
641
            if (ret < 0) goto lab4;
 
642
            z->c += ret;
 
643
        }
 
644
        {    /* gopast */ /* non v, line 123 */
 
645
            int ret = in_grouping_U(z, g_v, 97, 121, 1);
 
646
            if (ret < 0) goto lab4;
 
647
            z->c += ret;
 
648
        }
 
649
        z->I[1] = z->c; /* setmark p2, line 123 */
 
650
    lab4:
 
651
        z->c = c5;
 
652
    }
 
653
    z->lb = z->c; z->c = z->l; /* backwards, line 126 */
 
654
 
 
655
    {   int m6 = z->l - z->c; (void)m6; /* do, line 127 */
 
656
        {   int ret = r_Step_1a(z);
 
657
            if (ret == 0) goto lab5; /* call Step_1a, line 127 */
 
658
            if (ret < 0) return ret;
 
659
        }
 
660
    lab5:
 
661
        z->c = z->l - m6;
 
662
    }
 
663
    {   int m7 = z->l - z->c; (void)m7; /* do, line 128 */
 
664
        {   int ret = r_Step_1b(z);
 
665
            if (ret == 0) goto lab6; /* call Step_1b, line 128 */
 
666
            if (ret < 0) return ret;
 
667
        }
 
668
    lab6:
 
669
        z->c = z->l - m7;
 
670
    }
 
671
    {   int m8 = z->l - z->c; (void)m8; /* do, line 129 */
 
672
        {   int ret = r_Step_1c(z);
 
673
            if (ret == 0) goto lab7; /* call Step_1c, line 129 */
 
674
            if (ret < 0) return ret;
 
675
        }
 
676
    lab7:
 
677
        z->c = z->l - m8;
 
678
    }
 
679
    {   int m9 = z->l - z->c; (void)m9; /* do, line 130 */
 
680
        {   int ret = r_Step_2(z);
 
681
            if (ret == 0) goto lab8; /* call Step_2, line 130 */
 
682
            if (ret < 0) return ret;
 
683
        }
 
684
    lab8:
 
685
        z->c = z->l - m9;
 
686
    }
 
687
    {   int m10 = z->l - z->c; (void)m10; /* do, line 131 */
 
688
        {   int ret = r_Step_3(z);
 
689
            if (ret == 0) goto lab9; /* call Step_3, line 131 */
 
690
            if (ret < 0) return ret;
 
691
        }
 
692
    lab9:
 
693
        z->c = z->l - m10;
 
694
    }
 
695
    {   int m11 = z->l - z->c; (void)m11; /* do, line 132 */
 
696
        {   int ret = r_Step_4(z);
 
697
            if (ret == 0) goto lab10; /* call Step_4, line 132 */
 
698
            if (ret < 0) return ret;
 
699
        }
 
700
    lab10:
 
701
        z->c = z->l - m11;
 
702
    }
 
703
    {   int m12 = z->l - z->c; (void)m12; /* do, line 133 */
 
704
        {   int ret = r_Step_5a(z);
 
705
            if (ret == 0) goto lab11; /* call Step_5a, line 133 */
 
706
            if (ret < 0) return ret;
 
707
        }
 
708
    lab11:
 
709
        z->c = z->l - m12;
 
710
    }
 
711
    {   int m13 = z->l - z->c; (void)m13; /* do, line 134 */
 
712
        {   int ret = r_Step_5b(z);
 
713
            if (ret == 0) goto lab12; /* call Step_5b, line 134 */
 
714
            if (ret < 0) return ret;
 
715
        }
 
716
    lab12:
 
717
        z->c = z->l - m13;
 
718
    }
 
719
    z->c = z->lb;
 
720
    {   int c14 = z->c; /* do, line 137 */
 
721
        if (!(z->B[0])) goto lab13; /* Boolean test Y_found, line 137 */
 
722
        while(1) { /* repeat, line 137 */
 
723
            int c15 = z->c;
 
724
            while(1) { /* goto, line 137 */
 
725
                int c16 = z->c;
 
726
                z->bra = z->c; /* [, line 137 */
 
727
                if (!(eq_s(z, 1, s_33))) goto lab15;
 
728
                z->ket = z->c; /* ], line 137 */
 
729
                z->c = c16;
 
730
                break;
 
731
            lab15:
 
732
                z->c = c16;
 
733
                {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
 
734
                    if (ret < 0) goto lab14;
 
735
                    z->c = ret; /* goto, line 137 */
 
736
                }
 
737
            }
 
738
            {   int ret = slice_from_s(z, 1, s_34); /* <-, line 137 */
 
739
                if (ret < 0) return ret;
 
740
            }
 
741
            continue;
 
742
        lab14:
 
743
            z->c = c15;
 
744
            break;
 
745
        }
 
746
    lab13:
 
747
        z->c = c14;
 
748
    }
 
749
    return 1;
 
750
}
 
751
 
 
752
extern struct SN_env * porter_UTF_8_create_env(void) { return SN_create_env(0, 2, 1); }
 
753
 
 
754
extern void porter_UTF_8_close_env(struct SN_env * z) { SN_close_env(z, 0); }
 
755