regex.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h> /* for bool */
#include <stddef.h>  /* for size_t */
#include <stdint.h>  /* for uint32_t */
#include <stdio.h>
 
/* Pull in PCRE2 with the 8-bit code unit width we target. */
#define PCRE2_CODE_UNIT_WIDTH 8
#include <pcre2.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ---------------------------------------------------------------------------
 * Limits & constants
 * ------------------------------------------------------------------------- */
 
#define REGEX_MAX_GROUPS 64
 
/* ---------------------------------------------------------------------------
 * Error codes
 * ------------------------------------------------------------------------- */
 
typedef enum {
    REGEX_OK = 0,           
    REGEX_NO_MATCH = 1,     
    REGEX_ERROR = -1,       
    REGEX_ERROR_NOMEM = -2, 
    REGEX_ERROR_ARGS = -3,  
    REGEX_ERROR_LIMIT = -4, 
} regex_status_t;
 
/* ---------------------------------------------------------------------------
 * Compile flags (thin alias over PCRE2_* options for API isolation)
 * ------------------------------------------------------------------------- */
 
typedef uint32_t regex_flags_t;
 
#define REGEX_FLAG_NONE      (0u)              /*< No special compilation flags.              */
#define REGEX_FLAG_CASELESS  (PCRE2_CASELESS)  
#define REGEX_FLAG_MULTILINE (PCRE2_MULTILINE) 
#define REGEX_FLAG_DOTALL    (PCRE2_DOTALL)    
#define REGEX_FLAG_EXTENDED  (PCRE2_EXTENDED)  
#define REGEX_FLAG_UTF       (PCRE2_UTF)       
#define REGEX_FLAG_UCP       (PCRE2_UCP)       
#define REGEX_FLAG_UNGREEDY  (PCRE2_UNGREEDY)  
#define REGEX_FLAG_ANCHORED  (PCRE2_ANCHORED)  
/* ---------------------------------------------------------------------------
 * Core types
 * ------------------------------------------------------------------------- */
 
typedef struct regex_s regex_t;
 
typedef struct regex_ctx_s regex_ctx_t;
 
typedef struct {
    size_t start; 
    size_t end;   
} regex_span_t;
 
typedef struct {
    regex_span_t group[REGEX_MAX_GROUPS]; 
    uint32_t count;                       
} regex_match_t;
 
typedef struct regex_iter_s regex_iter_t;
 
/* ---------------------------------------------------------------------------
 * Compilation
 * ------------------------------------------------------------------------- */
 
regex_status_t regex_compile(const char* pattern, regex_flags_t flags, regex_t** out, char* errbuf, size_t errbuf_len);
 
regex_t* regex_retain(regex_t* re);
 
void regex_free(regex_t* re);
 
/* ---------------------------------------------------------------------------
 * Execution context (per-thread)
 * ------------------------------------------------------------------------- */
 
regex_status_t regex_ctx_create(regex_ctx_t** out);
 
void regex_ctx_free(regex_ctx_t* ctx);
 
/* ---------------------------------------------------------------------------
 * Matching
 * ------------------------------------------------------------------------- */
 
regex_status_t regex_exec(const regex_t* re, regex_ctx_t* ctx, const char* subject, size_t len, size_t offset,
                          regex_match_t* match);
 
regex_status_t regex_match(const regex_t* re, regex_ctx_t* ctx, const char* subject, regex_match_t* match);
 
bool regex_is_match(const regex_t* re, regex_ctx_t* ctx, const char* subject, size_t len);
 
/* ---------------------------------------------------------------------------
 * Iterator: find all non-overlapping matches
 * ------------------------------------------------------------------------- */
 
regex_status_t regex_iter_init(regex_t* re, regex_ctx_t* ctx, const char* subject, size_t len, regex_iter_t** out);
 
regex_status_t regex_iter_next(regex_iter_t* iter, regex_match_t* match);
 
void regex_iter_free(regex_iter_t* iter);
 
/* ---------------------------------------------------------------------------
 * Substitution
 * ------------------------------------------------------------------------- */
 
regex_status_t regex_sub(const regex_t* re, regex_ctx_t* ctx, const char* subject, size_t subject_len,
                         const char* replacement, char* out_buf, size_t* out_len);
 
regex_status_t regex_gsub(const regex_t* re, regex_ctx_t* ctx, const char* subject, size_t subject_len,
                          const char* replacement, char* out_buf, size_t* out_len);
 
/* ---------------------------------------------------------------------------
 * Introspection
 * ------------------------------------------------------------------------- */
 
uint32_t regex_group_count(const regex_t* re);
 
const char* regex_pattern(const regex_t* re);
 
void regex_strerror(regex_status_t status, char* buf, size_t buf_len);
 
static inline regex_t* regex_must_compile(const char* pattern, regex_flags_t flags) {
    char errbuf[256];
    regex_t* re = NULL;
    regex_status_t st = regex_compile(pattern, flags, &re, errbuf, sizeof(errbuf));
    if (st != REGEX_OK) {
        fprintf(stderr, "%s:%d: regex_compile(\"%s\") failed: %s\n", __FILE__, __LINE__, pattern, errbuf);
        exit(1);
    }
    return re;
}
 
static inline regex_ctx_t* regex_ctx_must_create(void) {
    regex_ctx_t* ctx = NULL;
    regex_status_t st = regex_ctx_create(&ctx);
    if (st != REGEX_OK) {
        fprintf(stderr, "%s:%d: regex_ctx_create failed\n", __FILE__, __LINE__);
        exit(1);
    }
    return ctx;
}
 
#ifdef __cplusplus
}
#endif