---

JRegex.C

Go to the documentation of this file.

/***************************************************************************
 *cr
 *cr            (C) Copyright 1995-2019 The Board of Trustees of the
 *cr                        University of Illinois
 *cr                         All Rights Reserved
 *cr
 ***************************************************************************/

/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: JRegex.C,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.15 $       $Date: 2024/03/01 02:01:37 $
 *
 ***************************************************************************
 * DESCRIPTION:
 *  Interface for performing regular expression pattern matching, 
 *  encapsulating the PCRE regular expression package.
 ***************************************************************************/

//
// Online regex info and testing: 
//   https://regex101.com/
//
// PCRE regex library:
//   https://www.pcre.org/
//

#include "JRegex.h"
#include "Inform.h" 

#if defined(VMDUSEPCRE2)
#define  PCRE2_CODE_UNIT_WIDTH 8
#include "pcre2.h"
#else
#include "pcre.h"
#endif

JRegex::JRegex(const char *pattern, int) {
  if (pattern == NULL) {
    msgErr << "NULL pattern passed to JRegex!" << sendmsg;
  }
  else {
#if defined(VMDUSEPCRE2)
    //
    // PCRE2 API
    //   https://www.pcre.org/current/doc/html/pcre2api.html
    //   https://www.pcre.org/current/doc/html/pcre2demo.html
    //
    int errornumber=0;
    size_t erroroffset=0;
    md = NULL;
    JIT=0;
    rpat = pcre2_compile((PCRE2_SPTR) pattern,   // the regex pattern string
                         PCRE2_ZERO_TERMINATED,  // C style string
                         0,                      // default options
                         &errornumber,           // error number
                         &erroroffset,           // offset to error location
                         NULL);                  // use default compile context

    if (rpat == NULL) {
      PCRE2_UCHAR errbuf[256];
      pcre2_get_error_message(errornumber, errbuf, sizeof(errbuf));
      msgWarn << "JRegex: Error in pcre2_compile(), " << sendmsg;
      msgWarn << "Error in regex pattern begins with " << pattern+erroroffset
              << sendmsg;
    } else {
#if 1
      //
      // enable JIT compilation of the regex, for large selection traversals
      // https://www.pcre.org/current/doc/html/pcre2jit.html
      //
      int rc=0;
      rc=pcre2_jit_compile((pcre2_code *) rpat, PCRE2_JIT_COMPLETE); 
      if (rc && rc != PCRE2_ERROR_JIT_BADOPTION) 
        msgWarn << "JRegex: pcre2_jit_compile() returned an error." << sendmsg;

      // check that JIT succeeded so we can use the fast-path if possible
      if (!rc) {
        size_t len=0;
        pcre2_pattern_info((pcre2_code *) rpat, PCRE2_INFO_JITSIZE, &len);
//        msgInfo << "PCRE2 JIT size: " << len << sendmsg;
        if (len != 0)
          JIT=1;
      }
#endif

//      md = pcre2_match_data_create(1, NULL);
      md = pcre2_match_data_create_from_pattern((pcre2_code *) rpat, NULL);
    }
#else
    const char *errptr;
    int erroffset;
    rpat = vmdpcre_compile(pattern,    // the regex pattern string
                           0,          // options
                           &errptr,    // points to error message, if any
                           &erroffset, // offset to error location
                           NULL);      // Table pointer; NULL for use default
    if (rpat == NULL) {
      msgWarn << "JRegex: Error in pcre_compile(), " << errptr << sendmsg;
      msgWarn << "Error in regex pattern begins with " << pattern+erroffset
              << sendmsg;
    }
#endif
  }
}

JRegex::~JRegex() {
#if defined(VMDUSEPCRE2)
  if (md)
    pcre2_match_data_free((pcre2_match_data *) md);  
  if (rpat)
    pcre2_code_free((pcre2_code *) rpat);
#else
  vmdpcre_free(rpat);
#endif
}

int JRegex::match(const char *str, int len) const {
#if defined(VMDUSEPCRE2)
  if (rpat==NULL || md == NULL) {
//  msgWarn << "JRegex::match: bad regex pattern, no match" << sendmsg;
    return -1;
  } 

  int rc=0;

  // if the regular expression has successfully JITted, we call the 
  // JIT fast path to avoid overheads
  if (JIT) {
    rc=pcre2_jit_match((pcre2_code *) rpat,     // compiled regex pattern
                       (PCRE2_SPTR) str,        // subject of the search
                       len,                     // strlen of str
                       0,                       // match starting offset
                       0,                       // options
                       (pcre2_match_data *) md, // match data block
                       NULL);                   // match ctx, NULL for defaults
    return rc;
  }

  rc=pcre2_match((pcre2_code *) rpat,     // compiled regex pattern
                 (PCRE2_SPTR) str,        // subject of the search
                 len,                     // strlen of str
                 0,                       // match starting offset
                 0,                       // options
                 (pcre2_match_data *) md, // match data block
                 NULL);                   // match ctx, NULL for defaults
  return rc;
#else
  if (rpat==NULL) {
//  msgWarn << "JRegex::match: bad regex pattern, no match" << sendmsg;
    return -1;
  } 
  int retval;
  retval=vmdpcre_exec(rpat, // compiled regex pattern
                      NULL, // No extra study wisdom
                      str,  // subject of the search
                      len,  // strlen of str
                      0,    // offset at which to start finding substrings
                      0,    // options
                      NULL, // return vector for location of substrings
                      0);   // size of return vector
  return retval;
#endif
}

int JRegex::search(const char *str, int len, int &length, int start) {
#if defined(VMDUSEPCRE2)
  return -1; // not implemented 
#else
  if (rpat==NULL) {
//  msgWarn << "JRegex::search: bad regex pattern, no match" << sendmsg;
    return -1;
  } 
  int ovec[6], retval;
  retval=vmdpcre_exec(rpat, // my regex pattern
                      NULL, // No extra study wisdom
                      str,  // subject of the search
                      len,  // strlen of str
                      start,// offset at which to start finding substrings
                      0,    // options
                      ovec, // return vector for location of substrings
                      6);   // size of return vector
  if (retval < 0) 
    return retval;
  length = ovec[1]-ovec[0]; 
  return ovec[0]; 
#endif
}

---