← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

Viewing changes to regex/split.c

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

Lines of Context:
regex/split.c
 
1
#include <stdio.h>
 
2
#include <string.h>
 
3
 
 
4
/*
 
5
 - split - divide a string into fields, like awk split()
 
6
 = int split(char *string, char *fields[], int nfields, char *sep);
 
7
 */
 
8
int                             /* number of fields, including overflow */
 
9
split(string, fields, nfields, sep)
 
10
char *string;
 
11
char *fields[];                 /* list is not NULL-terminated */
 
12
int nfields;                    /* number of entries available in fields[] */
 
13
char *sep;                      /* "" white, "c" single char, "ab" [ab]+ */
 
14
{
 
15
        register char *p = string;
 
16
        register char c;                        /* latest character */
 
17
        register char sepc = sep[0];
 
18
        register char sepc2;
 
19
        register int fn;
 
20
        register char **fp = fields;
 
21
        register char *sepp;
 
22
        register int trimtrail;
 
23
 
 
24
        /* white space */
 
25
        if (sepc == '\0') {
 
26
                while ((c = *p++) == ' ' || c == '\t')
 
27
                        continue;
 
28
                p--;
 
29
                trimtrail = 1;
 
30
                sep = (char*) " \t";    /* note, code below knows this is 2 long */
 
31
                sepc = ' ';
 
32
        } else
 
33
                trimtrail = 0;
 
34
        sepc2 = sep[1];         /* now we can safely pick this up */
 
35
 
 
36
        /* catch empties */
 
37
        if (*p == '\0')
 
38
                return(0);
 
39
 
 
40
        /* single separator */
 
41
        if (sepc2 == '\0') {
 
42
                fn = nfields;
 
43
                for (;;) {
 
44
                        *fp++ = p;
 
45
                        fn--;
 
46
                        if (fn == 0)
 
47
                                break;
 
48
                        while ((c = *p++) != sepc)
 
49
                                if (c == '\0')
 
50
                                        return(nfields - fn);
 
51
                        *(p-1) = '\0';
 
52
                }
 
53
                /* we have overflowed the fields vector -- just count them */
 
54
                fn = nfields;
 
55
                for (;;) {
 
56
                        while ((c = *p++) != sepc)
 
57
                                if (c == '\0')
 
58
                                        return(fn);
 
59
                        fn++;
 
60
                }
 
61
                /* not reached */
 
62
        }
 
63
 
 
64
        /* two separators */
 
65
        if (sep[2] == '\0') {
 
66
                fn = nfields;
 
67
                for (;;) {
 
68
                        *fp++ = p;
 
69
                        fn--;
 
70
                        while ((c = *p++) != sepc && c != sepc2)
 
71
                                if (c == '\0') {
 
72
                                        if (trimtrail && **(fp-1) == '\0')
 
73
                                                fn++;
 
74
                                        return(nfields - fn);
 
75
                                }
 
76
                        if (fn == 0)
 
77
                                break;
 
78
                        *(p-1) = '\0';
 
79
                        while ((c = *p++) == sepc || c == sepc2)
 
80
                                continue;
 
81
                        p--;
 
82
                }
 
83
                /* we have overflowed the fields vector -- just count them */
 
84
                fn = nfields;
 
85
                while (c != '\0') {
 
86
                        while ((c = *p++) == sepc || c == sepc2)
 
87
                                continue;
 
88
                        p--;
 
89
                        fn++;
 
90
                        while ((c = *p++) != '\0' && c != sepc && c != sepc2)
 
91
                                continue;
 
92
                }
 
93
                /* might have to trim trailing white space */
 
94
                if (trimtrail) {
 
95
                        p--;
 
96
                        while ((c = *--p) == sepc || c == sepc2)
 
97
                                continue;
 
98
                        p++;
 
99
                        if (*p != '\0') {
 
100
                                if (fn == nfields+1)
 
101
                                        *p = '\0';
 
102
                                fn--;
 
103
                        }
 
104
                }
 
105
                return(fn);
 
106
        }
 
107
 
 
108
        /* n separators */
 
109
        fn = 0;
 
110
        for (;;) {
 
111
                if (fn < nfields)
 
112
                        *fp++ = p;
 
113
                fn++;
 
114
                for (;;) {
 
115
                        c = *p++;
 
116
                        if (c == '\0')
 
117
                                return(fn);
 
118
                        sepp = sep;
 
119
                        while ((sepc = *sepp++) != '\0' && sepc != c)
 
120
                                continue;
 
121
                        if (sepc != '\0')       /* it was a separator */
 
122
                                break;
 
123
                }
 
124
                if (fn < nfields)
 
125
                        *(p-1) = '\0';
 
126
                for (;;) {
 
127
                        c = *p++;
 
128
                        sepp = sep;
 
129
                        while ((sepc = *sepp++) != '\0' && sepc != c)
 
130
                                continue;
 
131
                        if (sepc == '\0')       /* it wasn't a separator */
 
132
                                break;
 
133
                }
 
134
                p--;
 
135
        }
 
136
 
 
137
        /* not reached */
 
138
}
 
139
 
 
140
#ifdef TEST_SPLIT
 
141
 
 
142
 
 
143
/*
 
144
 * test program
 
145
 * pgm          runs regression
 
146
 * pgm sep      splits stdin lines by sep
 
147
 * pgm str sep  splits str by sep
 
148
 * pgm str sep n        splits str by sep n times
 
149
 */
 
150
int
 
151
main(argc, argv)
 
152
int argc;
 
153
char *argv[];
 
154
{
 
155
        char buf[512];
 
156
        register int n;
 
157
#       define  MNF     10
 
158
        char *fields[MNF];
 
159
 
 
160
        if (argc > 4)
 
161
                for (n = atoi(argv[3]); n > 0; n--) {
 
162
                        (void) strcpy(buf, argv[1]);
 
163
                }
 
164
        else if (argc > 3)
 
165
                for (n = atoi(argv[3]); n > 0; n--) {
 
166
                        (void) strcpy(buf, argv[1]);
 
167
                        (void) split(buf, fields, MNF, argv[2]);
 
168
                }
 
169
        else if (argc > 2)
 
170
                dosplit(argv[1], argv[2]);
 
171
        else if (argc > 1)
 
172
                while (fgets(buf, sizeof(buf), stdin) != NULL) {
 
173
                        buf[strlen(buf)-1] = '\0';      /* stomp newline */
 
174
                        dosplit(buf, argv[1]);
 
175
                }
 
176
        else
 
177
                regress();
 
178
 
 
179
        exit(0);
 
180
}
 
181
 
 
182
dosplit(string, seps)
 
183
char *string;
 
184
char *seps;
 
185
{
 
186
#       define  NF      5
 
187
        char *fields[NF];
 
188
        register int nf;
 
189
 
 
190
        nf = split(string, fields, NF, seps);
 
191
        print(nf, NF, fields);
 
192
}
 
193
 
 
194
print(nf, nfp, fields)
 
195
int nf;
 
196
int nfp;
 
197
char *fields[];
 
198
{
 
199
        register int fn;
 
200
        register int bound;
 
201
 
 
202
        bound = (nf > nfp) ? nfp : nf;
 
203
        printf("%d:\t", nf);
 
204
        for (fn = 0; fn < bound; fn++)
 
205
                printf("\"%s\"%s", fields[fn], (fn+1 < nf) ? ", " : "\n");
 
206
}
 
207
 
 
208
#define RNF     5               /* some table entries know this */
 
209
struct {
 
210
        char *str;
 
211
        char *seps;
 
212
        int nf;
 
213
        char *fi[RNF];
 
214
} tests[] = {
 
215
        "",             " ",    0,      { "" },
 
216
        " ",            " ",    2,      { "", "" },
 
217
        "x",            " ",    1,      { "x" },
 
218
        "xy",           " ",    1,      { "xy" },
 
219
        "x y",          " ",    2,      { "x", "y" },
 
220
        "abc def  g ",  " ",    5,      { "abc", "def", "", "g", "" },
 
221
        "  a bcd",      " ",    4,      { "", "", "a", "bcd" },
 
222
        "a b c d e f",  " ",    6,      { "a", "b", "c", "d", "e f" },
 
223
        " a b c d ",    " ",    6,      { "", "a", "b", "c", "d " },
 
224
 
 
225
        "",             " _",   0,      { "" },
 
226
        " ",            " _",   2,      { "", "" },
 
227
        "x",            " _",   1,      { "x" },
 
228
        "x y",          " _",   2,      { "x", "y" },
 
229
        "ab _ cd",      " _",   2,      { "ab", "cd" },
 
230
        " a_b  c ",     " _",   5,      { "", "a", "b", "c", "" },
 
231
        "a b c_d e f",  " _",   6,      { "a", "b", "c", "d", "e f" },
 
232
        " a b c d ",    " _",   6,      { "", "a", "b", "c", "d " },
 
233
 
 
234
        "",             " _~",  0,      { "" },
 
235
        " ",            " _~",  2,      { "", "" },
 
236
        "x",            " _~",  1,      { "x" },
 
237
        "x y",          " _~",  2,      { "x", "y" },
 
238
        "ab _~ cd",     " _~",  2,      { "ab", "cd" },
 
239
        " a_b  c~",     " _~",  5,      { "", "a", "b", "c", "" },
 
240
        "a b_c d~e f",  " _~",  6,      { "a", "b", "c", "d", "e f" },
 
241
        "~a b c d ",    " _~",  6,      { "", "a", "b", "c", "d " },
 
242
 
 
243
        "",             " _~-", 0,      { "" },
 
244
        " ",            " _~-", 2,      { "", "" },
 
245
        "x",            " _~-", 1,      { "x" },
 
246
        "x y",          " _~-", 2,      { "x", "y" },
 
247
        "ab _~- cd",    " _~-", 2,      { "ab", "cd" },
 
248
        " a_b  c~",     " _~-", 5,      { "", "a", "b", "c", "" },
 
249
        "a b_c-d~e f",  " _~-", 6,      { "a", "b", "c", "d", "e f" },
 
250
        "~a-b c d ",    " _~-", 6,      { "", "a", "b", "c", "d " },
 
251
 
 
252
        "",             "  ",   0,      { "" },
 
253
        " ",            "  ",   2,      { "", "" },
 
254
        "x",            "  ",   1,      { "x" },
 
255
        "xy",           "  ",   1,      { "xy" },
 
256
        "x y",          "  ",   2,      { "x", "y" },
 
257
        "abc def  g ",  "  ",   4,      { "abc", "def", "g", "" },
 
258
        "  a bcd",      "  ",   3,      { "", "a", "bcd" },
 
259
        "a b c d e f",  "  ",   6,      { "a", "b", "c", "d", "e f" },
 
260
        " a b c d ",    "  ",   6,      { "", "a", "b", "c", "d " },
 
261
 
 
262
        "",             "",     0,      { "" },
 
263
        " ",            "",     0,      { "" },
 
264
        "x",            "",     1,      { "x" },
 
265
        "xy",           "",     1,      { "xy" },
 
266
        "x y",          "",     2,      { "x", "y" },
 
267
        "abc def  g ",  "",     3,      { "abc", "def", "g" },
 
268
        "\t a bcd",     "",     2,      { "a", "bcd" },
 
269
        "  a \tb\t c ", "",     3,      { "a", "b", "c" },
 
270
        "a b c d e ",   "",     5,      { "a", "b", "c", "d", "e" },
 
271
        "a b\tc d e f", "",     6,      { "a", "b", "c", "d", "e f" },
 
272
        " a b c d e f ",        "",     6,      { "a", "b", "c", "d", "e f " },
 
273
 
 
274
        NULL,           NULL,   0,      { NULL },
 
275
};
 
276
 
 
277
regress()
 
278
{
 
279
        char buf[512];
 
280
        register int n;
 
281
        char *fields[RNF+1];
 
282
        register int nf;
 
283
        register int i;
 
284
        register int printit;
 
285
        register char *f;
 
286
 
 
287
        for (n = 0; tests[n].str != NULL; n++) {
 
288
                (void) strcpy(buf, tests[n].str);
 
289
                fields[RNF] = NULL;
 
290
                nf = split(buf, fields, RNF, tests[n].seps);
 
291
                printit = 0;
 
292
                if (nf != tests[n].nf) {
 
293
                        printf("split `%s' by `%s' gave %d fields, not %d\n",
 
294
                                tests[n].str, tests[n].seps, nf, tests[n].nf);
 
295
                        printit = 1;
 
296
                } else if (fields[RNF] != NULL) {
 
297
                        printf("split() went beyond array end\n");
 
298
                        printit = 1;
 
299
                } else {
 
300
                        for (i = 0; i < nf && i < RNF; i++) {
 
301
                                f = fields[i];
 
302
                                if (f == NULL)
 
303
                                        f = "(NULL)";
 
304
                                if (strcmp(f, tests[n].fi[i]) != 0) {
 
305
                                        printf("split `%s' by `%s', field %d is `%s', not `%s'\n",
 
306
                                                tests[n].str, tests[n].seps,
 
307
                                                i, fields[i], tests[n].fi[i]);
 
308
                                        printit = 1;
 
309
                                }
 
310
                        }
 
311
                }
 
312
                if (printit)
 
313
                        print(nf, RNF, fields);
 
314
        }
 
315
}
 
316
#endif