~cryo/bitmatch - Binary pattern matching on bits and bytes - sourcehut git

#include <stdio.h>
#include <string.h>
#include "bitmatch.h"

#define MAX_MATCHES 1
#define MAX_MEM     256

int main(int argc, char **argv)
{
    int match;
    bm_context bm;
    bm_match *m;
    bm_match matches[MAX_MATCHES];
    unsigned char mem[MAX_MEM];

    const char *pattern = "m8 (1 _5 #110 _6 #10) | "
                             "(2 _4 #1110 _6 #10 _6 #10) | "
                             "(3 _3 #11110 _6 #10 _6 #10 _6 #10)";

    /* lambda as 2-byte UTF-8: 0xCE 0xBB */
    unsigned char bin[] = { 'l', 'a', 'm', 'b', 'd', 'a', ' ', 0xCE, 0xBB, '!' }; 

    bm_init(&bm, &mem[0], sizeof(mem));
    bm_compile(&bm, pattern, strlen(pattern));

    match = bm_exec(&bm, &bin[0], sizeof(bin), &matches[0], MAX_MATCHES);

    if (match == 1)
    {
        m = &matches[0];
        printf("match id: %u pos: %lu, bit_count: %u, value: 0x%lX\n",
               m->id, m->bit_pos, m->bit_count, m->value);
    }

    return 0;
}

/** Entry for a bitmatch match.
 *
 * Needs to be allocated by the user on the stack
 * as array of expected matches.
 */
typedef struct
{
    unsigned long value;   /* value of a capture group */
    unsigned long bit_pos; /* position in the bit stream */
    unsigned bit_count;    /* count of bits in value */
    unsigned id;           /* id of the respective capture group */
} bm_match;

/** The bitmatch context.
 *
 * Needs to be allocated by the application on the stack.
 */
typedef struct
{
    unsigned instr_pos;
    unsigned instr_size;
    bm_word *instr;

    bm_status status;
} bm_context;

/** Initialize bitmatch context.
 *
 * The memory buffer needs to be supplied by the application,
 * when a pattern is compiled via bm_compile() the instructions
 * are stored in there. For simple patterns 128-256 bytes are
 * enough.
 *
 * \param bm the bitmatch context.
 * \param mem pointer to a memory buffer.
 * \param mem_size size of the mem buffer.
 */
void bm_init(bm_context *bm, void *mem, unsigned long mem_size);

/** Compile a pattern.
 *
 * \param bm the bitmatch context.
 * \param pattern the pattern.
 * \param size size of the pattern aka strlen(pattern).
 * \return 1 on success
 *         0 on failure with bm->status set to an error code
 */
int bm_compile(bm_context *bm, const char *pattern, unsigned size);

/** Execute a compiled binary pattern.
 *
 * \param bm the bitmatch context.
 * \param bin data to match against.
 * \param bin_size size of bin in bytes.
 * \param matches a buffer for keeping results.
 * \param matches_size number of maximum matches to return.
 * \return >0 on success, this is the number of matches
 *          0 on failure with bm->status set to an error code
 */
int bm_exec(bm_context *bm, const void *bin, unsigned long bin_size,
            bm_match *matches, unsigned matches_size);