lib/slre.c

   1 /*
   2  * Copyright (c) 2004-2005 Sergey Lyubka <valenok@gmail.com>
   3  * All rights reserved
   4  *
   5  * "THE BEER-WARE LICENSE" (Revision 42):
   6  * Sergey Lyubka wrote this file.  As long as you retain this notice you
   7  * can do whatever you want with this stuff. If we meet some day, and you think
   8  * this stuff is worth it, you can buy me a beer in return.
   9  */
  10
  11 /*
  12  * Downloaded Sat Nov  5 17:43:06 CET 2011 at
  13  * http://slre.sourceforge.net/1.0/slre.c
  14  */
  15
  16 #ifdef SLRE_TEST
  17 #include <stdio.h>
  18 #include <assert.h>
  19 #include <ctype.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #else
  23 #include <common.h>
  24 #include <linux/ctype.h>
  25 #endif /* SLRE_TEST */
  26
  27 #include <errno.h>
  28
  29 #include <slre.h>
  30
  31 enum {END, BRANCH, ANY, EXACT, ANYOF, ANYBUT, OPEN, CLOSE, BOL, EOL,
  32         STAR, PLUS, STARQ, PLUSQ, QUEST, SPACE, NONSPACE, DIGIT};
  33
  34 #ifdef SLRE_TEST
  35 static struct {
  36         const char      *name;
  37         int             narg;
  38         const char      *flags;
  39 } opcodes[] = {
  40         {"END",         0, ""},         /* End of code block or program */
  41         {"BRANCH",      2, "oo"},       /* Alternative operator, "|"    */
  42         {"ANY",         0, ""},         /* Match any character, "."     */
  43         {"EXACT",       2, "d"},        /* Match exact string           */
  44         {"ANYOF",       2, "D"},        /* Match any from set, "[]"     */
  45         {"ANYBUT",      2, "D"},        /* Match any but from set, "[^]"*/
  46         {"OPEN ",       1, "i"},        /* Capture start, "("           */
  47         {"CLOSE",       1, "i"},        /* Capture end, ")"             */
  48         {"BOL",         0, ""},         /* Beginning of string, "^"     */
  49         {"EOL",         0, ""},         /* End of string, "$"           */
  50         {"STAR",        1, "o"},        /* Match zero or more times "*" */
  51         {"PLUS",        1, "o"},        /* Match one or more times, "+" */
  52         {"STARQ",       1, "o"},        /* Non-greedy STAR,  "*?"       */
  53         {"PLUSQ",       1, "o"},        /* Non-greedy PLUS, "+?"        */
  54         {"QUEST",       1, "o"},        /* Match zero or one time, "?"  */
  55         {"SPACE",       0, ""},         /* Match whitespace, "\s"       */
  56         {"NONSPACE",    0, ""},         /* Match non-space, "\S"        */
  57         {"DIGIT",       0, ""}          /* Match digit, "\d"            */
  58 };
  59 #endif /* SLRE_TEST */
  60
  61 /*
  62  * Commands and operands are all unsigned char (1 byte long). All code offsets
  63  * are relative to current address, and positive (always point forward). Data
  64  * offsets are absolute. Commands with operands:
  65  *
  66  * BRANCH offset1 offset2
  67  *      Try to match the code block that follows the BRANCH instruction
  68  *      (code block ends with END). If no match, try to match code block that
  69  *      starts at offset1. If either of these match, jump to offset2.
  70  *
  71  * EXACT data_offset data_length
  72  *      Try to match exact string. String is recorded in data section from
  73  *      data_offset, and has length data_length.
  74  *
  75  * OPEN capture_number
  76  * CLOSE capture_number
  77  *      If the user have passed 'struct cap' array for captures, OPEN
  78  *      records the beginning of the matched substring (cap->ptr), CLOSE
  79  *      sets the length (cap->len) for respective capture_number.
  80  *
  81  * STAR code_offset
  82  * PLUS code_offset
  83  * QUEST code_offset
  84  *      *, +, ?, respectively. Try to gobble as much as possible from the
  85  *      matched buffer, until code block that follows these instructions
  86  *      matches. When the longest possible string is matched,
  87  *      jump to code_offset
  88  *
  89  * STARQ, PLUSQ are non-greedy versions of STAR and PLUS.
  90  */
  91
  92 static const char *meta_chars = "|.^$*+?()[\\";
  93
  94 #ifdef SLRE_TEST
  95
  96 static void
  97 print_character_set(FILE *fp, const unsigned char *p, int len)
  98 {
  99         int     i;
 100
 101         for (i = 0; i < len; i++) {
 102                 if (i > 0)
 103                         (void) fputc(',', fp);
 104                 if (p[i] == 0) {
 105                         i++;
 106                         if (p[i] == 0)
 107                                 (void) fprintf(fp, "\\x%02x", p[i]);
 108                         else
 109                                 (void) fprintf(fp, "%s", opcodes[p[i]].name);
 110                 } else if (isprint(p[i])) {
 111                         (void) fputc(p[i], fp);
 112                 } else {
 113                         (void) fprintf(fp, "\\x%02x", p[i]);
 114                 }
 115         }
 116 }
 117
 118 void
 119 slre_dump(const struct slre *r, FILE *fp)
 120 {
 121         int     i, j, ch, op, pc;
 122
 123         for (pc = 0; pc < r->code_size; pc++) {
 124
 125                 op = r->code[pc];
 126                 (void) fprintf(fp, "%3d %s ", pc, opcodes[op].name);
 127
 128                 for (i = 0; opcodes[op].flags[i] != '\0'; i++)
 129                         switch (opcodes[op].flags[i]) {
 130                         case 'i':
 131                                 (void) fprintf(fp, "%d ", r->code[pc + 1]);
 132                                 pc++;
 133                                 break;
 134                         case 'o':
 135                                 (void) fprintf(fp, "%d ",
 136                                     pc + r->code[pc + 1] - i);
 137                                 pc++;
 138                                 break;
 139                         case 'D':
 140                                 print_character_set(fp, r->data +
 141                                     r->code[pc + 1], r->code[pc + 2]);
 142                                 pc += 2;
 143                                 break;
 144                         case 'd':
 145                                 (void) fputc('"', fp);
 146                                 for (j = 0; j < r->code[pc + 2]; j++) {
 147                                         ch = r->data[r->code[pc + 1] + j];
 148                                         if (isprint(ch)) {
 149                                                 (void) fputc(ch, fp);
 150                                         } else {
 151                                                 (void) fprintf(fp,
 152                                                         "\\x%02x", ch);
 153                                         }
 154                                 }
 155                                 (void) fputc('"', fp);
 156                                 pc += 2;
 157                                 break;
 158                         }
 159
 160                 (void) fputc('\n', fp);
 161         }
 162 }
 163 #endif /* SLRE_TEST */
 164
 165 static void
 166 set_jump_offset(struct slre *r, int pc, int offset)
 167 {
 168         assert(offset < r->code_size);
 169
 170         if (r->code_size - offset > 0xff)
 171                 r->err_str = "Jump offset is too big";
 172         else
 173                 r->code[pc] = (unsigned char) (r->code_size - offset);
 174 }
 175
 176 static void
 177 emit(struct slre *r, int code)
 178 {
 179         if (r->code_size >= (int) (sizeof(r->code) / sizeof(r->code[0])))
 180                 r->err_str = "RE is too long (code overflow)";
 181         else
 182                 r->code[r->code_size++] = (unsigned char) code;
 183 }
 184
 185 static void
 186 store_char_in_data(struct slre *r, int ch)
 187 {
 188         if (r->data_size >= (int) sizeof(r->data))
 189                 r->err_str = "RE is too long (data overflow)";
 190         else
 191                 r->data[r->data_size++] = ch;
 192 }
 193
 194 static void
 195 exact(struct slre *r, const char **re)
 196 {
 197         int     old_data_size = r->data_size;
 198
 199         while (**re != '\0' && (strchr(meta_chars, **re)) == NULL)
 200                 store_char_in_data(r, *(*re)++);
 201
 202         emit(r, EXACT);
 203         emit(r, old_data_size);
 204         emit(r, r->data_size - old_data_size);
 205 }
 206
 207 static int
 208 get_escape_char(const char **re)
 209 {
 210         int     res;
 211
 212         switch (*(*re)++) {
 213         case 'n':
 214                 res = '\n';
 215                 break;
 216         case 'r':
 217                 res = '\r';
 218                 break;
 219         case 't':
 220                 res = '\t';
 221                 break;
 222         case '0':
 223                 res = 0;
 224                 break;
 225         case 'S':
 226                 res = NONSPACE << 8;
 227                 break;
 228         case 's':
 229                 res = SPACE << 8;
 230                 break;
 231         case 'd':
 232                 res = DIGIT << 8;
 233                 break;
 234         default:
 235                 res = (*re)[-1];
 236                 break;
 237         }
 238
 239         return res;
 240 }
 241
 242 static void
 243 anyof(struct slre *r, const char **re)
 244 {
 245         int     esc, old_data_size = r->data_size, op = ANYOF;
 246
 247         if (**re == '^') {
 248                 op = ANYBUT;
 249                 (*re)++;
 250         }
 251
 252         while (**re != '\0')
 253
 254                 switch (*(*re)++) {
 255                 case ']':
 256                         emit(r, op);
 257                         emit(r, old_data_size);
 258                         emit(r, r->data_size - old_data_size);
 259                         return;
 260                         /* NOTREACHED */
 261                         break;
 262                 case '\\':
 263                         esc = get_escape_char(re);
 264                         if ((esc & 0xff) == 0) {
 265                                 store_char_in_data(r, 0);
 266                                 store_char_in_data(r, esc >> 8);
 267                         } else {
 268                                 store_char_in_data(r, esc);
 269                         }
 270                         break;
 271                 default:
 272                         store_char_in_data(r, (*re)[-1]);
 273                         break;
 274                 }
 275
 276         r->err_str = "No closing ']' bracket";
 277 }
 278
 279 static void
 280 relocate(struct slre *r, int begin, int shift)
 281 {
 282         emit(r, END);
 283         memmove(r->code + begin + shift, r->code + begin, r->code_size - begin);
 284         r->code_size += shift;
 285 }
 286
 287 static void
 288 quantifier(struct slre *r, int prev, int op)
 289 {
 290         if (r->code[prev] == EXACT && r->code[prev + 2] > 1) {
 291                 r->code[prev + 2]--;
 292                 emit(r, EXACT);
 293                 emit(r, r->code[prev + 1] + r->code[prev + 2]);
 294                 emit(r, 1);
 295                 prev = r->code_size - 3;
 296         }
 297         relocate(r, prev, 2);
 298         r->code[prev] = op;
 299         set_jump_offset(r, prev + 1, prev);
 300 }
 301
 302 static void
 303 exact_one_char(struct slre *r, int ch)
 304 {
 305         emit(r, EXACT);
 306         emit(r, r->data_size);
 307         emit(r, 1);
 308         store_char_in_data(r, ch);
 309 }
 310
 311 static void
 312 fixup_branch(struct slre *r, int fixup)
 313 {
 314         if (fixup > 0) {
 315                 emit(r, END);
 316                 set_jump_offset(r, fixup, fixup - 2);
 317         }
 318 }
 319
 320 static void
 321 compile(struct slre *r, const char **re)
 322 {
 323         int     op, esc, branch_start, last_op, fixup, cap_no, level;
 324
 325         fixup = 0;
 326         level = r->num_caps;
 327         branch_start = last_op = r->code_size;
 328
 329         for (;;)
 330                 switch (*(*re)++) {
 331                 case '\0':
 332                         (*re)--;
 333                         return;
 334                         /* NOTREACHED */
 335                         break;
 336                 case '^':
 337                         emit(r, BOL);
 338                         break;
 339                 case '$':
 340                         emit(r, EOL);
 341                         break;
 342                 case '.':
 343                         last_op = r->code_size;
 344                         emit(r, ANY);
 345                         break;
 346                 case '[':
 347                         last_op = r->code_size;
 348                         anyof(r, re);
 349                         break;
 350                 case '\\':
 351                         last_op = r->code_size;
 352                         esc = get_escape_char(re);
 353                         if (esc & 0xff00)
 354                                 emit(r, esc >> 8);
 355                         else
 356                                 exact_one_char(r, esc);
 357                         break;
 358                 case '(':
 359                         last_op = r->code_size;
 360                         cap_no = ++r->num_caps;
 361                         emit(r, OPEN);
 362                         emit(r, cap_no);
 363
 364                         compile(r, re);
 365                         if (*(*re)++ != ')') {
 366                                 r->err_str = "No closing bracket";
 367                                 return;
 368                         }
 369
 370                         emit(r, CLOSE);
 371                         emit(r, cap_no);
 372                         break;
 373                 case ')':
 374                         (*re)--;
 375                         fixup_branch(r, fixup);
 376                         if (level == 0) {
 377                                 r->err_str = "Unbalanced brackets";
 378                                 return;
 379                         }
 380                         return;
 381                         /* NOTREACHED */
 382                         break;
 383                 case '+':
 384                 case '*':
 385                         op = (*re)[-1] == '*' ? STAR : PLUS;
 386                         if (**re == '?') {
 387                                 (*re)++;
 388                                 op = op == STAR ? STARQ : PLUSQ;
 389                         }
 390                         quantifier(r, last_op, op);
 391                         break;
 392                 case '?':
 393                         quantifier(r, last_op, QUEST);
 394                         break;
 395                 case '|':
 396                         fixup_branch(r, fixup);
 397                         relocate(r, branch_start, 3);
 398                         r->code[branch_start] = BRANCH;
 399                         set_jump_offset(r, branch_start + 1, branch_start);
 400                         fixup = branch_start + 2;
 401                         r->code[fixup] = 0xff;
 402                         break;
 403                 default:
 404                         (*re)--;
 405                         last_op = r->code_size;
 406                         exact(r, re);
 407                         break;
 408                 }
 409 }
 410
 411 int
 412 slre_compile(struct slre *r, const char *re)
 413 {
 414         r->err_str = NULL;
 415         r->code_size = r->data_size = r->num_caps = r->anchored = 0;
 416
 417         if (*re == '^')
 418                 r->anchored++;
 419
 420         emit(r, OPEN);  /* This will capture what matches full RE */
 421         emit(r, 0);
 422
 423         while (*re != '\0')
 424                 compile(r, &re);
 425
 426         if (r->code[2] == BRANCH)
 427                 fixup_branch(r, 4);
 428
 429         emit(r, CLOSE);
 430         emit(r, 0);
 431         emit(r, END);
 432
 433         return (r->err_str == NULL ? 1 : 0);
 434 }
 435
 436 static int match(const struct slre *, int,
 437                 const char *, int, int *, struct cap *);
 438
 439 static void
 440 loop_greedy(const struct slre *r, int pc, const char *s, int len, int *ofs)
 441 {
 442         int     saved_offset, matched_offset;
 443
 444         matched_offset = *ofs;
 445
 446         while (match(r, pc + 2, s, len, ofs, NULL)) {
 447                 saved_offset = *ofs;
 448                 if (match(r, pc + r->code[pc + 1], s, len, ofs, NULL))
 449                         matched_offset = saved_offset;
 450                 *ofs = saved_offset;
 451         }
 452
 453         *ofs = matched_offset;
 454 }
 455
 456 static void
 457 loop_non_greedy(const struct slre *r, int pc, const char *s, int len, int *ofs)
 458 {
 459         int     saved_offset = *ofs;
 460
 461         while (match(r, pc + 2, s, len, ofs, NULL)) {
 462                 saved_offset = *ofs;
 463                 if (match(r, pc + r->code[pc + 1], s, len, ofs, NULL))
 464                         break;
 465         }
 466
 467         *ofs = saved_offset;
 468 }
 469
 470 static int
 471 is_any_of(const unsigned char *p, int len, const char *s, int *ofs)
 472 {
 473         int     i, ch;
 474
 475         ch = s[*ofs];
 476
 477         for (i = 0; i < len; i++)
 478                 if (p[i] == ch) {
 479                         (*ofs)++;
 480                         return 1;
 481                 }
 482
 483         return 0;
 484 }
 485
 486 static int
 487 is_any_but(const unsigned char *p, int len, const char *s, int *ofs)
 488 {
 489         int     i, ch;
 490
 491         ch = s[*ofs];
 492
 493         for (i = 0; i < len; i++) {
 494                 if (p[i] == ch)
 495                         return 0;
 496         }
 497
 498         (*ofs)++;
 499         return 1;
 500 }
 501
 502 static int
 503 match(const struct slre *r, int pc, const char *s, int len,
 504                 int *ofs, struct cap *caps)
 505 {
 506         int     n, saved_offset, res = 1;
 507
 508         while (res && r->code[pc] != END) {
 509
 510                 assert(pc < r->code_size);
 511                 assert(pc < (int) (sizeof(r->code) / sizeof(r->code[0])));
 512
 513                 switch (r->code[pc]) {
 514                 case BRANCH:
 515                         saved_offset = *ofs;
 516                         res = match(r, pc + 3, s, len, ofs, caps);
 517                         if (res == 0) {
 518                                 *ofs = saved_offset;
 519                                 res = match(r, pc + r->code[pc + 1],
 520                                     s, len, ofs, caps);
 521                         }
 522                         pc += r->code[pc + 2];
 523                         break;
 524                 case EXACT:
 525                         res = 0;
 526                         n = r->code[pc + 2];    /* String length */
 527                         if (n <= len - *ofs && !memcmp(s + *ofs, r->data +
 528                             r->code[pc + 1], n)) {
 529                                 (*ofs) += n;
 530                                 res = 1;
 531                         }
 532                         pc += 3;
 533                         break;
 534                 case QUEST:
 535                         res = 1;
 536                         saved_offset = *ofs;
 537                         if (!match(r, pc + 2, s, len, ofs, caps))
 538                                 *ofs = saved_offset;
 539                         pc += r->code[pc + 1];
 540                         break;
 541                 case STAR:
 542                         res = 1;
 543                         loop_greedy(r, pc, s, len, ofs);
 544                         pc += r->code[pc + 1];
 545                         break;
 546                 case STARQ:
 547                         res = 1;
 548                         loop_non_greedy(r, pc, s, len, ofs);
 549                         pc += r->code[pc + 1];
 550                         break;
 551                 case PLUS:
 552                         res = match(r, pc + 2, s, len, ofs, caps);
 553                         if (res == 0)
 554                                 break;
 555
 556                         loop_greedy(r, pc, s, len, ofs);
 557                         pc += r->code[pc + 1];
 558                         break;
 559                 case PLUSQ:
 560                         res = match(r, pc + 2, s, len, ofs, caps);
 561                         if (res == 0)
 562                                 break;
 563
 564                         loop_non_greedy(r, pc, s, len, ofs);
 565                         pc += r->code[pc + 1];
 566                         break;
 567                 case SPACE:
 568                         res = 0;
 569                         if (*ofs < len && isspace(((unsigned char *)s)[*ofs])) {
 570                                 (*ofs)++;
 571                                 res = 1;
 572                         }
 573                         pc++;
 574                         break;
 575                 case NONSPACE:
 576                         res = 0;
 577                         if (*ofs < len &&
 578                                         !isspace(((unsigned char *)s)[*ofs])) {
 579                                 (*ofs)++;
 580                                 res = 1;
 581                         }
 582                         pc++;
 583                         break;
 584                 case DIGIT:
 585                         res = 0;
 586                         if (*ofs < len && isdigit(((unsigned char *)s)[*ofs])) {
 587                                 (*ofs)++;
 588                                 res = 1;
 589                         }
 590                         pc++;
 591                         break;
 592                 case ANY:
 593                         res = 0;
 594                         if (*ofs < len) {
 595                                 (*ofs)++;
 596                                 res = 1;
 597                         }
 598                         pc++;
 599                         break;
 600                 case ANYOF:
 601                         res = 0;
 602                         if (*ofs < len)
 603                                 res = is_any_of(r->data + r->code[pc + 1],
 604                                         r->code[pc + 2], s, ofs);
 605                         pc += 3;
 606                         break;
 607                 case ANYBUT:
 608                         res = 0;
 609                         if (*ofs < len)
 610                                 res = is_any_but(r->data + r->code[pc + 1],
 611                                         r->code[pc + 2], s, ofs);
 612                         pc += 3;
 613                         break;
 614                 case BOL:
 615                         res = *ofs == 0 ? 1 : 0;
 616                         pc++;
 617                         break;
 618                 case EOL:
 619                         res = *ofs == len ? 1 : 0;
 620                         pc++;
 621                         break;
 622                 case OPEN:
 623                         if (caps != NULL)
 624                                 caps[r->code[pc + 1]].ptr = s + *ofs;
 625                         pc += 2;
 626                         break;
 627                 case CLOSE:
 628                         if (caps != NULL)
 629                                 caps[r->code[pc + 1]].len = (s + *ofs) -
 630                                     caps[r->code[pc + 1]].ptr;
 631                         pc += 2;
 632                         break;
 633                 case END:
 634                         pc++;
 635                         break;
 636                 default:
 637                         printf("unknown cmd (%d) at %d\n", r->code[pc], pc);
 638                         assert(0);
 639                         break;
 640                 }
 641         }
 642
 643         return res;
 644 }
 645
 646 int
 647 slre_match(const struct slre *r, const char *buf, int len,
 648                 struct cap *caps)
 649 {
 650         int     i, ofs = 0, res = 0;
 651
 652         if (r->anchored) {
 653                 res = match(r, 0, buf, len, &ofs, caps);
 654         } else {
 655                 for (i = 0; i < len && res == 0; i++) {
 656                         ofs = i;
 657                         res = match(r, 0, buf, len, &ofs, caps);
 658                 }
 659         }
 660
 661         return res;
 662 }
 663
 664 #ifdef SLRE_TEST
 665 #define N_CAPS  5
 666
 667 int main(int argc, char *argv[])
 668 {
 669         struct slre     slre;
 670         struct cap      caps[N_CAPS];
 671         unsigned char   data[1 * 1024 * 1024];
 672         FILE            *fp;
 673         int             i, res, len;
 674
 675         if (argc < 2) {
 676                 fprintf(stderr, "Usage: %s 'slre' <file>\n", argv[0]);
 677                 return 1;
 678         }
 679
 680         fp = fopen(argv[2], "rb");
 681         if (fp == NULL) {
 682                 fprintf(stderr, "Error: cannot open %s:%s\n",
 683                         argv[2], strerror(errno));
 684                 return 1;
 685         }
 686
 687         if (!slre_compile(&slre, argv[1])) {
 688                 fprintf(stderr, "Error compiling slre: %s\n", slre.err_str);
 689                 return 1;
 690         }
 691
 692         slre_dump(&slre, stderr);
 693
 694         while (fgets(data, sizeof(data), fp) != NULL) {
 695                 len = strlen(data);
 696
 697                 if ((len > 0) && (data[len-1] == '\n')) {
 698                         data[len-1] = '\0';
 699                         --len;
 700                 }
 701
 702                 printf("Data = \"%s\"\n", data);
 703
 704                 (void) memset(caps, 0, sizeof(caps));
 705
 706                 res = 0;
 707
 708                 res = slre_match(&slre, data, len, caps);
 709                 printf("Result [%d]: %d\n", i, res);
 710
 711                 for (i = 0; i < N_CAPS; i++) {
 712                         if (caps[i].len > 0) {
 713                                 printf("Substring %d: len=%d  [%.*s]\n", i,
 714                                         caps[i].len,
 715                                         caps[i].len, caps[i].ptr);
 716                         }
 717                 }
 718                 printf("----------------------------------------------------\n");
 719         }
 720         (void) fclose(fp);
 721
 722         return 0;
 723 }
 724 #endif /* SLRE_TEST */