src/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 = " \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