pcrs.c

   1 const char pcrs_rcs[] = "$Id: pcrs.c,v 1.1 2001/05/13 21:57:07 administrator Exp $";
   2
   3 /*********************************************************************
   4  *
   5  * File        :  $Source: /home/administrator/cvs/ijb/pcrs.c,v $
   6  *
   7  * Purpose     :  This is the pre-pre-alpha realease of libpcrs. It is only
   8  *                published at this (ugly) stage of development, because it is
   9  *                needed for a new feature in JunkBuster.
  10  *
  11  *                Apart from the code being quite a mess, no inconsistencies,
  12  *                memory leaks or functional bugs **should** be present.
  13  *
  14  *                While you ROTFL at the code, you could just as well mail me
  15  *                (andreas@oesterhelt.org) with advice for improvement.
  16  *
  17  *                pcrs is a supplement to the brilliant pcre library by Philip
  18  *                Hazel (ph10@cam.ac.uk) and adds Perl-style substitution. That
  19  *                is, it mimics Perl's 's' operator.
  20  *
  21  *                Currently, there's no documentation besides comments and the
  22  *                source itself ;-)
  23  *
  24  * Copyright   :  Written and copyright by andreas@oesterhelt.org
  25  *
  26  * Revisions   :
  27  *    $Log: pcrs.c,v $
  28  *
  29  *********************************************************************/
  30 \f
  31
  32 #include <pcre.h>
  33 #include <string.h>
  34 #include "pcrs.h"
  35 const char pcrs_h_rcs[] = PCRS_H_VERSION;
  36
  37
  38 /*********************************************************************
  39  *
  40  * Function    :  my_strsep
  41  *
  42  * Description :  Convenience function. It acts like strsep, except that
  43  *                it respects quoting of the delimiter character with the
  44  *                quote character. (And, of course, quoting the quote char
  45  *                with itself.)  Called from `pcrs_make_job'.
  46  *
  47  * Parameters  :
  48  *          1  :  token = current token
  49  *          2  :  text = string to tokenize
  50  *          3  :  delimiter = single character deliminter
  51  *          4  :  quote_char = character to cause quoting
  52  *
  53  * Returns     :  -1 => failure, else the length of the token found.
  54  *                In the latter case, *text is the token's start.
  55  *
  56  *********************************************************************/
  57 int my_strsep(char *token, char **text, char delimiter, char quote_char)
  58 {
  59    int i, k=0, limit, quoted = FALSE;
  60
  61    limit = strlen(*text);
  62    if ( 0 == limit )
  63    {
  64       return -1;
  65    }
  66
  67    token[0] = '\0';
  68
  69    for (i=0; i < limit; i++)
  70    {
  71       if (text[0][i] == delimiter && !quoted)
  72       {
  73          *text += 1;
  74          break;
  75       }
  76       else if (text[0][i] == quote_char && !quoted && i+1 < limit && text[0][i+1] == delimiter)
  77       {
  78          quoted = TRUE;
  79          continue;
  80       }
  81       token[k++] = text[0][i];
  82       quoted = FALSE;
  83    }
  84    token[k] = '\0';
  85    *text += i;
  86    return k;
  87
  88 }
  89
  90
  91 /*********************************************************************
  92  *
  93  * Function    :  pcrs_compile_perl_options
  94  *
  95  * Description :  This function parses a string containing the options to
  96  *                Perl's s/// operator. It returns an integer that is the
  97  *                pcre equivalent of the symbolic optstring.
  98  *                Since pcre doesn't know about Perl's 'g' (global) option,
  99  *                but pcrs needs it, the globalflag integer is set if 'g'
 100  *                is encountered.
 101  *
 102  * Parameters  :
 103  *          1  :  optstring = string with options in perl syntax
 104  *          2  :  globalflag = see description
 105  *
 106  * Returns     :  option integer suitable for pcre
 107  *
 108  *********************************************************************/
 109 int pcrs_compile_perl_options(char *optstring, int *globalflag)
 110 {
 111    int i, rc = 0;
 112    *globalflag = 0;
 113    for (i=0; i < strlen(optstring); i++)
 114    {
 115       switch(optstring[i])
 116       {
 117          case 'e': break;
 118          case 'g': *globalflag = 1; break;
 119          case 'i': rc |= PCRE_CASELESS; break;
 120          case 'm': rc |= PCRE_MULTILINE; break;
 121          case 'o': break;
 122          case 's': rc |= PCRE_DOTALL; break;
 123          case 'x': rc |= PCRE_EXTENDED; break;
 124          default:  break;
 125       }
 126    }
 127    return rc;
 128
 129 }
 130
 131
 132 /*********************************************************************
 133  *
 134  * Function    :  pcrs_compile_replacement
 135  *
 136  * Description :  This function takes a Perl-style replacement (2nd argument
 137  *                to the s/// operator and returns a compiled pcrs_substitute,
 138  *                or NULL if memory allocation for the substitute structure
 139  *                fails.
 140  *
 141  * Parameters  :
 142  *          1  :  replacement = replacement part of s/// operator
 143  *                              in perl syntax
 144  *          2  :  errptr = pointer to an integer in which error
 145  *                         conditions can be returned.
 146  *
 147  * Returns     :  pcrs_substitute data structure, or NULL if an
 148  *                error is encountered. In that case, *errptr has
 149  *                the reason.
 150  *
 151  *********************************************************************/
 152 pcrs_substitute *pcrs_compile_replacement(char *replacement, int *errptr)
 153 {
 154    int length, i, k = 0, l = 0, quoted = 0, idx;
 155    char *text, *num_ptr, *numbers = "0123456789";
 156    pcrs_substitute *r;
 157
 158    r = (pcrs_substitute *)malloc(sizeof(pcrs_substitute));
 159    if (r == NULL) return NULL;
 160    memset(r, '\0', sizeof(pcrs_substitute));
 161
 162    text = strdup(replacement);      /* must be free()d by caller */
 163    if (text  == NULL)
 164    {
 165       *errptr = PCRS_ERR_NOMEM;
 166       free(r);
 167       return NULL;
 168    }
 169
 170    length = strlen(replacement);
 171
 172    for (i=0; i < length; i++)
 173    {
 174       /* Backslash treatment */
 175       if (replacement[i] == '\\')
 176       {
 177          if (quoted)
 178          {
 179             text[k++] = replacement[i];
 180             quoted = 0;
 181          }
 182          else
 183          {
 184             quoted = 1;
 185          }
 186          continue;
 187       }
 188
 189       /* Dollar treatment */
 190       if (replacement[i] == '$' && !quoted && i < length - 1)
 191       {
 192          if (strchr("0123456789&", replacement[i + 1]) == NULL)
 193          {
 194             text[k++] = replacement[i];
 195          }
 196          else
 197          {
 198             r->block_length[l] = k - r->block_offset[l];
 199             r->backref[l] = 0;
 200             if (replacement[i + 1] != '&')
 201             {
 202                while ((num_ptr = strchr(numbers, replacement[++i])) != NULL && i < length)
 203                {
 204                   idx = num_ptr - numbers;
 205                   r->backref[l] = r->backref[l] * 10 + idx;
 206                }
 207                i--;
 208             }
 209             else
 210                i++;
 211             if (r->backref[l] < PCRS_MAX_SUBMATCHES)
 212                r->backref_count[r->backref[l]] += 1;
 213             l++;
 214             r->block_offset[l] = k;
 215          }
 216          continue;
 217       }
 218
 219       /* Plain char treatment */
 220       text[k++] = replacement[i];
 221       quoted = 0;
 222    }
 223
 224    text[k] = '\0';
 225    r->text = text;
 226    r->backrefs = l;
 227    r->block_length[l] = k - r->block_offset[l];
 228    return r;
 229
 230 }
 231
 232
 233 /*********************************************************************
 234  *
 235  * Function    :  pcrs_free_job
 236  *
 237  * Description :  Frees the memory used by a pcrs_job struct and its
 238  *                dependant structures. Returns a pointer to the next
 239  *                job, if there was any, or NULL otherwise.
 240  *
 241  * Parameters  :
 242  *          1  :  job = pointer to the pcrs_job structure to be freed
 243  *
 244  * Returns     : a pointer to the next job, if there was any, or
 245  *               NULL otherwise.
 246  *
 247  *********************************************************************/
 248 pcrs_job *pcrs_free_job(pcrs_job *job)
 249 {
 250    pcrs_job *next;
 251
 252    if (job == NULL)
 253    {
 254       return NULL;
 255    }
 256    else
 257    {
 258       next = job->next;
 259       if (job->pattern != NULL) free(job->pattern);
 260       if (job->hints != NULL) free(job->hints);
 261       if (job->substitute != NULL)
 262       {
 263          if (job->substitute->text != NULL) free(job->substitute->text);
 264          free(job->substitute);
 265       }
 266       free(job);
 267    }
 268    return next;
 269
 270 }
 271
 272
 273 /*********************************************************************
 274  *
 275  * Function    :  pcrs_make_job
 276  *
 277  * Description :  Main entry point. Takes a string with a Perl-style
 278  *                s/// command and returns a corresponding pcrs_job,
 279  *                or NULL if compiling the job fails at any stage.
 280  *                Diagnostics could obviously be improved.
 281  *
 282  * Parameters  :
 283  *          1  :  command = string with perl-style s/// command
 284  *          2  :  errptr = pointer to an integer in which error
 285  *                         conditions can be returned.
 286  *
 287  * Returns     :  a corresponding pcrs_job data structure, or NULL
 288  *                if an error was encountered. In that case, *errptr
 289  *                has the reason.
 290  *
 291  *********************************************************************/
 292 pcrs_job *pcrs_make_job(char *command, int *errptr)
 293 {
 294    char *dummy, *token, delimiter;
 295    const char *error;
 296    int i = 0, globalflag;
 297    pcrs_job *newjob;
 298
 299    /* Get and init memory */
 300    if ((newjob = (pcrs_job *)malloc(sizeof(pcrs_job))) == NULL)
 301    {
 302       *errptr = PCRS_ERR_NOMEM;
 303       return NULL;
 304    }
 305    memset(newjob, '\0', sizeof(pcrs_job));
 306
 307    /* Command too short? */
 308    if (strlen(command) < 4)
 309    {
 310       *errptr = PCRS_ERR_CMDSYNTAX;
 311       pcrs_free_job(newjob);
 312       return NULL;
 313    }
 314
 315    /* Split command into tokens and handle them */
 316    delimiter = command[1];
 317    token = (char *)malloc(strlen(command)); /* current token */
 318    dummy = (char *)malloc(strlen(command)); /* must store pattern, since we can't */
 319                                             /* use it until the options are known */
 320    while (my_strsep(token, &command, delimiter, '\\') >= 0)
 321    {
 322       switch (i)
 323       {
 324   /* We don't care about the command and assume 's' */
 325          case 0:
 326             break;
 327
 328          /* The pattern */
 329          case 1:
 330             strcpy(dummy, token);
 331             break;
 332
 333          /* The substitute */
 334          case 2:
 335             newjob->substitute = pcrs_compile_replacement(token, errptr);
 336             if (newjob->substitute == NULL)
 337             {
 338                pcrs_free_job(newjob);
 339                return NULL;
 340             }
 341             break;
 342
 343          /* The options */
 344          case 3:
 345             newjob->options = pcrs_compile_perl_options(token, &globalflag);
 346             newjob->globalflag = globalflag;
 347             break;
 348
 349          /* There shouldn't be anything else! */
 350          default:
 351             *errptr = PCRS_ERR_CMDSYNTAX;
 352             pcrs_free_job(newjob);
 353             return NULL;
 354       }
 355       i++;
 356    }
 357    free(token);
 358
 359    /* Compile the pattern */
 360    newjob->pattern = pcre_compile(dummy, newjob->options, &error, errptr, NULL);
 361    if (newjob->pattern == NULL)
 362    {
 363       pcrs_free_job(newjob);
 364       return NULL;
 365    }
 366    free(dummy);
 367
 368    /*
 369     * Generate hints. This has little overhead, since the
 370     * hints will be NULL for a boring pattern anyway.
 371     */
 372    newjob->hints = pcre_study(newjob->pattern, 0, &error);
 373    if (error != NULL)
 374    {
 375       *errptr = PCRS_ERR_STUDY;
 376       pcrs_free_job(newjob);
 377       return NULL;
 378    }
 379
 380    return newjob;
 381
 382 }
 383
 384
 385 /*********************************************************************
 386  *
 387  * Function    :  create_pcrs_job
 388  *
 389  * Description :  Create a job from all its components, if you don't
 390  *                have a Perl command to start from. Rather boring.
 391  *
 392  * Parameters  :
 393  *          1  :  pattern = pointer to pcre pattern
 394  *          2  :  hints = pointer to pcre hints
 395  *          3  :  options = options in pcre format
 396  *          4  :  globalflag = flag that indicates if global matching is desired
 397  *          5  :  substitute = pointer to pcrs_substitute data structure
 398  *          2  :  errptr = pointer to an integer in which error
 399  *                         conditions can be returned.
 400  *
 401  * Returns     :  pcrs_job structure, or NULL if an error was encountered.
 402  *                In that case, *errptr has the reason why.
 403  *
 404  *********************************************************************/
 405 pcrs_job *create_pcrs_job(pcre *pattern, pcre_extra *hints, int options, int globalflag, pcrs_substitute *substitute, int *errptr)
 406 {
 407    pcrs_job *newjob;
 408
 409    if ((newjob = (pcrs_job *)malloc(sizeof(pcrs_job))) == NULL)
 410    {
 411       *errptr = PCRS_ERR_NOMEM;
 412       return NULL;
 413    }
 414    memset(newjob, '\0', sizeof(pcrs_job));
 415
 416    newjob->pattern = pattern;
 417    newjob->hints = hints;
 418    newjob->options = options;
 419    newjob->globalflag = globalflag;
 420    newjob->substitute = substitute;
 421
 422    return(newjob);
 423
 424 }
 425
 426
 427 /*********************************************************************
 428  *
 429  * Function    :  pcrs_exec_substitution
 430  *
 431  * Description :  Modify the subject by executing the regular substitution
 432  *                defined by the job. Since the result may be longer than
 433  *                the subject, its space requirements are precalculated in
 434  *                the matching phase and new memory is allocated accordingly.
 435  *                It is the caller's responsibility to free the result when
 436  *                it's no longer needed.
 437  *
 438  * Parameters  :
 439  *          1  :  job = the pcrs_job to be executed
 440  *          2  :  subject = the subject (== original) string
 441  *          3  :  subject_length = the subject's length
 442  *          4  :  result = char** for returning  the result
 443  *          5  :  result_length = int* for returning the result's length
 444  *
 445  * Returns     :  the number of substitutions that were made. May be > 1
 446  *                if job->globalflag was set
 447  *
 448  *********************************************************************/
 449 int pcrs_exec_substitution(pcrs_job *job, char *subject, int subject_length, char **result, int *result_length)
 450 {
 451    int offsets[3 * PCRS_MAX_SUBMATCHES],
 452       offset = 0, i=0, k, matches_found, newsize, submatches;
 453    pcrs_match matches[PCRS_MAX_MATCHES];
 454    char *result_offset;
 455
 456    newsize=subject_length;
 457
 458    /* Find.. */
 459    while ((submatches = pcre_exec(job->pattern, job->hints, subject, subject_length, offset, 0, offsets, 99)) > 0)
 460    {
 461       matches[i].submatches = submatches;
 462       for (k=0; k < submatches; k++)
 463       {
 464          matches[i].submatch_offset[k] = offsets[2 * k];
 465          matches[i].submatch_length[k] = offsets[2 * k + 1] - offsets[2 * k]; /* Non-found optional submatches have length -1-(-1)==0 */
 466          newsize += matches[i].submatch_length[k] * job->substitute->backref_count[k]; /* reserve mem for each submatch as often as it is ref'd */
 467       }
 468       newsize += strlen(job->substitute->text) - matches[i].submatch_length[0]; /* plus replacement text size minus match text size */
 469
 470       /* Non-global search or limit reached? */
 471       if (++i >= PCRS_MAX_MATCHES || !job->globalflag ) break;
 472
 473       /* Don't loop on empty matches */
 474       if (offsets[1] == offset)
 475          if (offset < subject_length)
 476             offset++;
 477          else
 478             break;
 479       /* Go find the next one */
 480       else
 481          offset = offsets[1];
 482    }
 483    if (submatches < -1) return submatches;   /* Pass pcre error through */
 484    matches_found = i;
 485
 486    /* ..get memory ..*/
 487    if ((*result = (char *)malloc(newsize)) == NULL)   /* must be free()d by caller */
 488    {
 489       return PCRS_ERR_NOMEM;
 490    }
 491
 492    /* ..and replace */
 493    offset = 0;
 494    result_offset = *result;
 495
 496    for (i=0; i < matches_found; i++)
 497    {
 498       memcpy(result_offset, subject + offset, matches[i].submatch_offset[0] - offset); /* copy the chunk preceding the match */
 499       result_offset += matches[i].submatch_offset[0] - offset;
 500
 501       /* For every segment of the substitute.. */
 502       for (k=0; k <= job->substitute->backrefs; k++)
 503       {
 504          /* ...copy its text.. */
 505          memcpy(result_offset, job->substitute->text + job->substitute->block_offset[k], job->substitute->block_length[k]);
 506          result_offset += job->substitute->block_length[k];
 507
 508          /* ..plus, if it's not the last chunk (i.e.: There IS a backref).. */
 509          if (k != job->substitute->backrefs
 510              /* ..and a nonempty match.. */
 511              && matches[i].submatch_length[job->substitute->backref[k]] > 0
 512              /* ..and in legal range, ... */
 513              && job->substitute->backref[k] <= PCRS_MAX_SUBMATCHES)
 514          {
 515             /* copy the submatch that is ref'd. */
 516             memcpy(
 517                result_offset,
 518                subject + matches[i].submatch_offset[job->substitute->backref[k]],
 519                matches[i].submatch_length[job->substitute->backref[k]]
 520             );
 521             result_offset += matches[i].submatch_length[job->substitute->backref[k]];
 522          }
 523       }
 524       offset =  matches[i].submatch_offset[0] + matches[i].submatch_length[0];
 525    }
 526
 527    /* Copy the rest. */
 528    memcpy(result_offset, subject + offset, subject_length - offset);
 529
 530    *result_length = newsize;
 531    return matches_found;
 532
 533 }
 534
 535
 536 /*
 537   Local Variables:
 538   tab-width: 3
 539   end:
 540 */