vectorscan.c

/*
  +----------------------------------------------------------------------+
  | Vectorscan Extension for PHP                                         |
  +----------------------------------------------------------------------+
  | Copyright (c) 2024-present                                           |
  +----------------------------------------------------------------------+
  | This source file is subject to version 3.01 of the PHP license,      |
  | that is bundled with this package in the file LICENSE, and is         |
  | available through the world-wide-web at the following url:            |
  | https://www.php.net/license/3_01.txt                                 |
  | If you did not receive a copy of the PHP license and are unable to   |
  | obtain it through the world-wide-web, please send a note to          |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "zend_exceptions.h"
#include "php_vectorscan.h"
#include "vectorscan_arginfo.h"

/* Class entries */
zend_class_entry *vectorscan_database_ce;
zend_class_entry *vectorscan_scratch_ce;
zend_class_entry *vectorscan_stream_ce;
zend_class_entry *vectorscan_exception_ce;

/* Object handlers */
zend_object_handlers vectorscan_database_handlers;
zend_object_handlers vectorscan_scratch_handlers;
zend_object_handlers vectorscan_stream_handlers;

/* {{{ Database object create/free */
static zend_object *vectorscan_database_create(zend_class_entry *ce)
{
    vectorscan_database_object *intern = zend_object_alloc(sizeof(vectorscan_database_object), ce);
    intern->db = NULL;
    intern->scratch = NULL;
    intern->mode = HS_MODE_BLOCK;

    zend_object_std_init(&intern->std, ce);
    object_properties_init(&intern->std, ce);
    intern->std.handlers = &vectorscan_database_handlers;

    return &intern->std;
}

static void vectorscan_database_free(zend_object *object)
{
    vectorscan_database_object *intern = vectorscan_database_from_obj(object);
    if (intern->scratch) {
        hs_free_scratch(intern->scratch);
        intern->scratch = NULL;
    }
    if (intern->db) {
        hs_free_database(intern->db);
        intern->db = NULL;
    }
    zend_object_std_dtor(&intern->std);
}
/* }}} */

/* {{{ Scratch object create/free */
static zend_object *vectorscan_scratch_create(zend_class_entry *ce)
{
    vectorscan_scratch_object *intern = zend_object_alloc(sizeof(vectorscan_scratch_object), ce);
    intern->scratch = NULL;

    zend_object_std_init(&intern->std, ce);
    object_properties_init(&intern->std, ce);
    intern->std.handlers = &vectorscan_scratch_handlers;

    return &intern->std;
}

static void vectorscan_scratch_free(zend_object *object)
{
    vectorscan_scratch_object *intern = vectorscan_scratch_from_obj(object);
    if (intern->scratch) {
        hs_free_scratch(intern->scratch);
        intern->scratch = NULL;
    }
    zend_object_std_dtor(&intern->std);
}
/* }}} */

/* {{{ Stream object create/free */
static zend_object *vectorscan_stream_create(zend_class_entry *ce)
{
    vectorscan_stream_object *intern = zend_object_alloc(sizeof(vectorscan_stream_object), ce);
    intern->stream = NULL;
    intern->scratch = NULL;
    intern->db = NULL;
    ZVAL_UNDEF(&intern->callback);

    zend_object_std_init(&intern->std, ce);
    object_properties_init(&intern->std, ce);
    intern->std.handlers = &vectorscan_stream_handlers;

    return &intern->std;
}

static void vectorscan_stream_free(zend_object *object)
{
    vectorscan_stream_object *intern = vectorscan_stream_from_obj(object);
    if (intern->stream) {
        hs_close_stream(intern->stream, intern->scratch, NULL, NULL);
        intern->stream = NULL;
    }
    if (intern->scratch) {
        hs_free_scratch(intern->scratch);
        intern->scratch = NULL;
    }
    if (!Z_ISUNDEF(intern->callback)) {
        zval_ptr_dtor(&intern->callback);
        ZVAL_UNDEF(&intern->callback);
    }
    zend_object_std_dtor(&intern->std);
}
/* }}} */

/* {{{ Match event handler callback for block/vectored scanning */
static int vectorscan_match_handler(unsigned int id, unsigned long long from,
    unsigned long long to, unsigned int flags, void *context)
{
    vectorscan_match_context *ctx = (vectorscan_match_context *)context;
    zval match_info;

    if (ctx->terminated) {
        return 1;
    }

    array_init(&match_info);
    add_assoc_long(&match_info, "id", (zend_long)id);
    add_assoc_long(&match_info, "from", (zend_long)from);
    add_assoc_long(&match_info, "to", (zend_long)to);

    if (ctx->callback != NULL && Z_TYPE_P(ctx->callback) != IS_NULL) {
        zval retval;
        zval params[1];
        ZVAL_COPY_VALUE(&params[0], &match_info);

        if (call_user_function(NULL, NULL, ctx->callback, &retval, 1, params) == SUCCESS) {
            if (Z_TYPE(retval) == IS_FALSE) {
                ctx->terminated = 1;
                zval_ptr_dtor(&match_info);
                zval_ptr_dtor(&retval);
                return 1;
            }
            zval_ptr_dtor(&retval);
        }
    }

    add_next_index_zval(ctx->matches, &match_info);
    return 0;
}
/* }}} */

/* {{{ Stream match event handler */
static int vectorscan_stream_match_handler(unsigned int id, unsigned long long from,
    unsigned long long to, unsigned int flags, void *context)
{
    vectorscan_stream_object *intern = (vectorscan_stream_object *)context;
    zval match_info, retval;
    zval params[1];

    if (Z_ISUNDEF(intern->callback) || Z_TYPE(intern->callback) == IS_NULL) {
        return 0;
    }

    array_init(&match_info);
    add_assoc_long(&match_info, "id", (zend_long)id);
    add_assoc_long(&match_info, "from", (zend_long)from);
    add_assoc_long(&match_info, "to", (zend_long)to);

    ZVAL_COPY_VALUE(&params[0], &match_info);

    if (call_user_function(NULL, NULL, &intern->callback, &retval, 1, params) == SUCCESS) {
        if (Z_TYPE(retval) == IS_FALSE) {
            zval_ptr_dtor(&match_info);
            zval_ptr_dtor(&retval);
            return 1;
        }
        zval_ptr_dtor(&retval);
    }

    zval_ptr_dtor(&match_info);
    return 0;
}
/* }}} */


/* {{{ proto Vectorscan\Database Vectorscan\Database::compile(array $patterns, ?array $flags = null, ?array $ids = null, int $mode = VECTORSCAN_MODE_BLOCK)
   Compile one or more patterns into a database */
PHP_METHOD(VectorscanDatabase, compile)
{
    zval *patterns_zv, *flags_zv = NULL, *ids_zv = NULL;
    zend_long mode = HS_MODE_BLOCK;
    HashTable *patterns_ht, *flags_ht = NULL, *ids_ht = NULL;
    hs_compile_error_t *compile_err = NULL;
    hs_database_t *db = NULL;
    unsigned int count;
    const char **expressions = NULL;
    unsigned int *flag_arr = NULL;
    unsigned int *id_arr = NULL;
    hs_error_t err;
    zval *entry;
    unsigned int i;

    ZEND_PARSE_PARAMETERS_START(1, 4)
        Z_PARAM_ARRAY(patterns_zv)
        Z_PARAM_OPTIONAL
        Z_PARAM_ARRAY_OR_NULL(flags_zv)
        Z_PARAM_ARRAY_OR_NULL(ids_zv)
        Z_PARAM_LONG(mode)
    ZEND_PARSE_PARAMETERS_END();

    patterns_ht = Z_ARRVAL_P(patterns_zv);
    count = zend_hash_num_elements(patterns_ht);

    if (count == 0) {
        zend_throw_exception(vectorscan_exception_ce, "At least one pattern is required", 0);
        RETURN_THROWS();
    }

    if (flags_zv) {
        flags_ht = Z_ARRVAL_P(flags_zv);
        if (zend_hash_num_elements(flags_ht) != count) {
            zend_throw_exception(vectorscan_exception_ce, "Flags array must have the same number of elements as patterns", 0);
            RETURN_THROWS();
        }
    }

    if (ids_zv) {
        ids_ht = Z_ARRVAL_P(ids_zv);
        if (zend_hash_num_elements(ids_ht) != count) {
            zend_throw_exception(vectorscan_exception_ce, "IDs array must have the same number of elements as patterns", 0);
            RETURN_THROWS();
        }
    }

    expressions = (const char **)safe_emalloc(count, sizeof(char *), 0);
    flag_arr = (unsigned int *)safe_emalloc(count, sizeof(unsigned int), 0);
    id_arr = (unsigned int *)safe_emalloc(count, sizeof(unsigned int), 0);

    i = 0;
    ZEND_HASH_FOREACH_VAL(patterns_ht, entry) {
        if (Z_TYPE_P(entry) != IS_STRING) {
            convert_to_string(entry);
        }
        expressions[i] = Z_STRVAL_P(entry);
        flag_arr[i] = HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH;
        id_arr[i] = i;
        i++;
    } ZEND_HASH_FOREACH_END();

    if (flags_ht) {
        i = 0;
        ZEND_HASH_FOREACH_VAL(flags_ht, entry) {
            flag_arr[i] = (unsigned int)zval_get_long(entry);
            i++;
        } ZEND_HASH_FOREACH_END();
    }

    if (ids_ht) {
        i = 0;
        ZEND_HASH_FOREACH_VAL(ids_ht, entry) {
            id_arr[i] = (unsigned int)zval_get_long(entry);
            i++;
        } ZEND_HASH_FOREACH_END();
    }

    err = hs_compile_multi(expressions, flag_arr, id_arr, count,
                           (unsigned int)mode, NULL, &db, &compile_err);

    efree(expressions);
    efree(flag_arr);
    efree(id_arr);

    if (err != HS_SUCCESS) {
        char *error_msg;
        if (compile_err) {
            spprintf(&error_msg, 0, "Compilation failed: %s (expression #%d)",
                     compile_err->message, compile_err->expression);
            hs_free_compile_error(compile_err);
        } else {
            spprintf(&error_msg, 0, "Compilation failed with error code %d", err);
        }
        zend_throw_exception(vectorscan_exception_ce, error_msg, err);
        efree(error_msg);
        RETURN_THROWS();
    }

    object_init_ex(return_value, vectorscan_database_ce);
    vectorscan_database_object *intern = Z_VECTORSCAN_DATABASE_P(return_value);
    intern->db = db;
    intern->mode = (unsigned int)mode;

    /* Pre-allocate scratch space for this database */
    err = hs_alloc_scratch(db, &intern->scratch);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to allocate scratch space", err);
        RETURN_THROWS();
    }
}
/* }}} */

/* {{{ proto array Vectorscan\Database::scan(string $data, ?callable $callback = null)
   Scan data against the compiled database */
PHP_METHOD(VectorscanDatabase, scan)
{
    char *data;
    size_t data_len;
    zval *callback_zv = NULL;
    vectorscan_database_object *intern;
    vectorscan_match_context ctx;
    hs_error_t err;
    zval matches;

    ZEND_PARSE_PARAMETERS_START(1, 2)
        Z_PARAM_STRING(data, data_len)
        Z_PARAM_OPTIONAL
        Z_PARAM_ZVAL_OR_NULL(callback_zv)
    ZEND_PARSE_PARAMETERS_END();

    intern = Z_VECTORSCAN_DATABASE_P(ZEND_THIS);

    if (!intern->db) {
        zend_throw_exception(vectorscan_exception_ce, "Database not compiled", 0);
        RETURN_THROWS();
    }

    if (!intern->scratch) {
        err = hs_alloc_scratch(intern->db, &intern->scratch);
        if (err != HS_SUCCESS) {
            zend_throw_exception(vectorscan_exception_ce, "Failed to allocate scratch space", err);
            RETURN_THROWS();
        }
    }

    array_init(&matches);
    ctx.callback = callback_zv;
    ctx.matches = &matches;
    ctx.terminated = 0;

    err = hs_scan(intern->db, data, (unsigned int)data_len, 0, intern->scratch, vectorscan_match_handler, &ctx);

    if (err != HS_SUCCESS && err != HS_SCAN_TERMINATED) {
        zval_ptr_dtor(&matches);
        zend_throw_exception(vectorscan_exception_ce, "Scan failed", err);
        RETURN_THROWS();
    }

    RETURN_ARR(Z_ARR(matches));
}
/* }}} */

/* {{{ Simple match handler that just sets a flag */
static int vectorscan_bool_match_handler(unsigned int id, unsigned long long from,
    unsigned long long to, unsigned int flags, void *context)
{
    *((zend_bool *)context) = 1;
    return 1; /* Stop scanning after first match */
}
/* }}} */

/* {{{ proto bool Vectorscan\Database::scanBool(string $data)
   Scan data and return true/false (no match details, maximum speed) */
PHP_METHOD(VectorscanDatabase, scanBool)
{
    char *data;
    size_t data_len;
    vectorscan_database_object *intern;
    hs_error_t err;
    zend_bool found = 0;

    ZEND_PARSE_PARAMETERS_START(1, 1)
        Z_PARAM_STRING(data, data_len)
    ZEND_PARSE_PARAMETERS_END();

    intern = Z_VECTORSCAN_DATABASE_P(ZEND_THIS);

    if (!intern->db) {
        zend_throw_exception(vectorscan_exception_ce, "Database not compiled", 0);
        RETURN_THROWS();
    }

    if (!intern->scratch) {
        err = hs_alloc_scratch(intern->db, &intern->scratch);
        if (err != HS_SUCCESS) {
            zend_throw_exception(vectorscan_exception_ce, "Failed to allocate scratch space", err);
            RETURN_THROWS();
        }
    }

    err = hs_scan(intern->db, data, (unsigned int)data_len, 0, intern->scratch, vectorscan_bool_match_handler, &found);

    if (err != HS_SUCCESS && err != HS_SCAN_TERMINATED) {
        zend_throw_exception(vectorscan_exception_ce, "Scan failed", err);
        RETURN_THROWS();
    }

    RETURN_BOOL(found);
}
/* }}} */

/* {{{ proto string Vectorscan\Database::serialize()
   Serialize the database to a string */
PHP_METHOD(VectorscanDatabase, serialize)
{
    vectorscan_database_object *intern;
    char *bytes = NULL;
    size_t length = 0;
    hs_error_t err;

    ZEND_PARSE_PARAMETERS_NONE();

    intern = Z_VECTORSCAN_DATABASE_P(ZEND_THIS);

    if (!intern->db) {
        zend_throw_exception(vectorscan_exception_ce, "Database not compiled", 0);
        RETURN_THROWS();
    }

    err = hs_database_size(intern->db, &length);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to get database size", err);
        RETURN_THROWS();
    }

    err = hs_serialize_database(intern->db, &bytes, &length);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to serialize database", err);
        RETURN_THROWS();
    }

    zend_string *result = zend_string_init(bytes, length, 0);
    free(bytes);
    RETURN_NEW_STR(result);
}
/* }}} */

/* {{{ proto Vectorscan\Database Vectorscan\Database::unserialize(string $data)
   Deserialize a database from a string */
PHP_METHOD(VectorscanDatabase, unserialize)
{
    char *data;
    size_t data_len;
    hs_database_t *db = NULL;
    hs_error_t err;

    ZEND_PARSE_PARAMETERS_START(1, 1)
        Z_PARAM_STRING(data, data_len)
    ZEND_PARSE_PARAMETERS_END();

    err = hs_deserialize_database(data, data_len, &db);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to deserialize database", err);
        RETURN_THROWS();
    }

    object_init_ex(return_value, vectorscan_database_ce);
    vectorscan_database_object *intern = Z_VECTORSCAN_DATABASE_P(return_value);
    intern->db = db;

    /* Pre-allocate scratch for the deserialized database */
    err = hs_alloc_scratch(db, &intern->scratch);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to allocate scratch space", err);
        RETURN_THROWS();
    }
}
/* }}} */

/* {{{ proto int Vectorscan\Database::size()
   Get the size of the compiled database in bytes */
PHP_METHOD(VectorscanDatabase, size)
{
    vectorscan_database_object *intern;
    size_t size = 0;
    hs_error_t err;

    ZEND_PARSE_PARAMETERS_NONE();

    intern = Z_VECTORSCAN_DATABASE_P(ZEND_THIS);

    if (!intern->db) {
        zend_throw_exception(vectorscan_exception_ce, "Database not compiled", 0);
        RETURN_THROWS();
    }

    err = hs_database_size(intern->db, &size);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to get database size", err);
        RETURN_THROWS();
    }

    RETURN_LONG((zend_long)size);
}
/* }}} */

/* {{{ proto string Vectorscan\Database::info()
   Get information about the compiled database */
PHP_METHOD(VectorscanDatabase, info)
{
    vectorscan_database_object *intern;
    char *info = NULL;
    hs_error_t err;

    ZEND_PARSE_PARAMETERS_NONE();

    intern = Z_VECTORSCAN_DATABASE_P(ZEND_THIS);

    if (!intern->db) {
        zend_throw_exception(vectorscan_exception_ce, "Database not compiled", 0);
        RETURN_THROWS();
    }

    err = hs_database_info(intern->db, &info);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to get database info", err);
        RETURN_THROWS();
    }

    RETVAL_STRING(info);
    free(info);
}
/* }}} */


/* {{{ proto Vectorscan\Scratch Vectorscan\Scratch::__construct(Vectorscan\Database $database)
   Create a scratch space for the given database */
PHP_METHOD(VectorscanScratch, __construct)
{
    zval *db_zv;
    vectorscan_database_object *db_intern;
    vectorscan_scratch_object *intern;
    hs_error_t err;

    ZEND_PARSE_PARAMETERS_START(1, 1)
        Z_PARAM_OBJECT_OF_CLASS(db_zv, vectorscan_database_ce)
    ZEND_PARSE_PARAMETERS_END();

    db_intern = Z_VECTORSCAN_DATABASE_P(db_zv);
    intern = Z_VECTORSCAN_SCRATCH_P(ZEND_THIS);

    if (!db_intern->db) {
        zend_throw_exception(vectorscan_exception_ce, "Database not compiled", 0);
        RETURN_THROWS();
    }

    err = hs_alloc_scratch(db_intern->db, &intern->scratch);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to allocate scratch space", err);
        RETURN_THROWS();
    }
}
/* }}} */

/* {{{ proto int Vectorscan\Scratch::size()
   Get the size of the scratch space in bytes */
PHP_METHOD(VectorscanScratch, size)
{
    vectorscan_scratch_object *intern;
    size_t size = 0;
    hs_error_t err;

    ZEND_PARSE_PARAMETERS_NONE();

    intern = Z_VECTORSCAN_SCRATCH_P(ZEND_THIS);

    if (!intern->scratch) {
        zend_throw_exception(vectorscan_exception_ce, "Scratch space not allocated", 0);
        RETURN_THROWS();
    }

    err = hs_scratch_size(intern->scratch, &size);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to get scratch size", err);
        RETURN_THROWS();
    }

    RETURN_LONG((zend_long)size);
}
/* }}} */

/* {{{ proto Vectorscan\Stream Vectorscan\Stream::open(Vectorscan\Database $database, callable $callback)
   Open a new stream for streaming mode scanning */
PHP_METHOD(VectorscanStream, open)
{
    zval *db_zv;
    zval *callback_zv;
    vectorscan_database_object *db_intern;
    vectorscan_stream_object *intern;
    hs_error_t err;

    ZEND_PARSE_PARAMETERS_START(2, 2)
        Z_PARAM_OBJECT_OF_CLASS(db_zv, vectorscan_database_ce)
        Z_PARAM_ZVAL(callback_zv)
    ZEND_PARSE_PARAMETERS_END();

    if (!zend_is_callable(callback_zv, 0, NULL)) {
        zend_throw_exception(vectorscan_exception_ce, "Callback must be callable", 0);
        RETURN_THROWS();
    }

    db_intern = Z_VECTORSCAN_DATABASE_P(db_zv);

    if (!db_intern->db) {
        zend_throw_exception(vectorscan_exception_ce, "Database not compiled", 0);
        RETURN_THROWS();
    }

    object_init_ex(return_value, vectorscan_stream_ce);
    intern = Z_VECTORSCAN_STREAM_P(return_value);

    /* Allocate scratch for this stream */
    err = hs_alloc_scratch(db_intern->db, &intern->scratch);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to allocate scratch space", err);
        RETURN_THROWS();
    }

    /* Open the stream */
    err = hs_open_stream(db_intern->db, 0, &intern->stream);
    if (err != HS_SUCCESS) {
        hs_free_scratch(intern->scratch);
        intern->scratch = NULL;
        zend_throw_exception(vectorscan_exception_ce, "Failed to open stream", err);
        RETURN_THROWS();
    }

    intern->db = db_intern->db;
    ZVAL_COPY(&intern->callback, callback_zv);
}
/* }}} */

/* {{{ proto void Vectorscan\Stream::scan(string $data)
   Scan a chunk of data in streaming mode */
PHP_METHOD(VectorscanStream, scan)
{
    char *data;
    size_t data_len;
    vectorscan_stream_object *intern;
    hs_error_t err;

    ZEND_PARSE_PARAMETERS_START(1, 1)
        Z_PARAM_STRING(data, data_len)
    ZEND_PARSE_PARAMETERS_END();

    intern = Z_VECTORSCAN_STREAM_P(ZEND_THIS);

    if (!intern->stream) {
        zend_throw_exception(vectorscan_exception_ce, "Stream is not open", 0);
        RETURN_THROWS();
    }

    err = hs_scan_stream(intern->stream, data, (unsigned int)data_len, 0,
                         intern->scratch, vectorscan_stream_match_handler, intern);

    if (err != HS_SUCCESS && err != HS_SCAN_TERMINATED) {
        zend_throw_exception(vectorscan_exception_ce, "Stream scan failed", err);
        RETURN_THROWS();
    }
}
/* }}} */

/* {{{ proto void Vectorscan\Stream::close()
   Close the stream, flushing any remaining matches */
PHP_METHOD(VectorscanStream, close)
{
    vectorscan_stream_object *intern;
    hs_error_t err;

    ZEND_PARSE_PARAMETERS_NONE();

    intern = Z_VECTORSCAN_STREAM_P(ZEND_THIS);

    if (!intern->stream) {
        zend_throw_exception(vectorscan_exception_ce, "Stream is not open", 0);
        RETURN_THROWS();
    }

    err = hs_close_stream(intern->stream, intern->scratch, vectorscan_stream_match_handler, intern);
    intern->stream = NULL;

    if (err != HS_SUCCESS && err != HS_SCAN_TERMINATED) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to close stream", err);
        RETURN_THROWS();
    }
}
/* }}} */

/* {{{ proto void Vectorscan\Stream::reset()
   Reset the stream to its initial state */
PHP_METHOD(VectorscanStream, reset)
{
    vectorscan_stream_object *intern;
    hs_error_t err;

    ZEND_PARSE_PARAMETERS_NONE();

    intern = Z_VECTORSCAN_STREAM_P(ZEND_THIS);

    if (!intern->stream) {
        zend_throw_exception(vectorscan_exception_ce, "Stream is not open", 0);
        RETURN_THROWS();
    }

    err = hs_reset_stream(intern->stream, 0, intern->scratch, NULL, NULL);
    if (err != HS_SUCCESS) {
        zend_throw_exception(vectorscan_exception_ce, "Failed to reset stream", err);
        RETURN_THROWS();
    }
}
/* }}} */


/* {{{ Procedural API functions */

/* {{{ proto string vectorscan_version()
   Get the version string of the vectorscan library */
PHP_FUNCTION(vectorscan_version)
{
    ZEND_PARSE_PARAMETERS_NONE();
    RETURN_STRING(hs_version());
}
/* }}} */

/* {{{ proto bool vectorscan_valid_platform()
   Check if the current platform supports vectorscan */
PHP_FUNCTION(vectorscan_valid_platform)
{
    hs_error_t err;
    ZEND_PARSE_PARAMETERS_NONE();

    err = hs_valid_platform();
    RETURN_BOOL(err == HS_SUCCESS);
}
/* }}} */

/* {{{ proto array vectorscan_scan(array $patterns, string $data, ?array $flags = null, ?callable $callback = null)
   Compile patterns and scan data in one call (convenience function) */
PHP_FUNCTION(vectorscan_scan)
{
    zval *patterns_zv, *flags_zv = NULL, *callback_zv = NULL;
    char *data;
    size_t data_len;
    HashTable *patterns_ht, *flags_ht = NULL;
    hs_compile_error_t *compile_err = NULL;
    hs_database_t *db = NULL;
    hs_scratch_t *scratch = NULL;
    unsigned int count;
    const char **expressions = NULL;
    unsigned int *flag_arr = NULL;
    unsigned int *id_arr = NULL;
    hs_error_t err;
    zval *entry;
    unsigned int i;
    vectorscan_match_context ctx;
    zval matches;

    ZEND_PARSE_PARAMETERS_START(2, 4)
        Z_PARAM_ARRAY(patterns_zv)
        Z_PARAM_STRING(data, data_len)
        Z_PARAM_OPTIONAL
        Z_PARAM_ARRAY_OR_NULL(flags_zv)
        Z_PARAM_ZVAL_OR_NULL(callback_zv)
    ZEND_PARSE_PARAMETERS_END();

    patterns_ht = Z_ARRVAL_P(patterns_zv);
    count = zend_hash_num_elements(patterns_ht);

    if (count == 0) {
        zend_throw_exception(vectorscan_exception_ce, "At least one pattern is required", 0);
        RETURN_THROWS();
    }

    if (flags_zv) {
        flags_ht = Z_ARRVAL_P(flags_zv);
    }

    expressions = (const char **)safe_emalloc(count, sizeof(char *), 0);
    flag_arr = (unsigned int *)safe_emalloc(count, sizeof(unsigned int), 0);
    id_arr = (unsigned int *)safe_emalloc(count, sizeof(unsigned int), 0);

    i = 0;
    ZEND_HASH_FOREACH_VAL(patterns_ht, entry) {
        if (Z_TYPE_P(entry) != IS_STRING) {
            convert_to_string(entry);
        }
        expressions[i] = Z_STRVAL_P(entry);
        flag_arr[i] = HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH;
        id_arr[i] = i;
        i++;
    } ZEND_HASH_FOREACH_END();

    if (flags_ht) {
        i = 0;
        ZEND_HASH_FOREACH_VAL(flags_ht, entry) {
            flag_arr[i] = (unsigned int)zval_get_long(entry);
            i++;
        } ZEND_HASH_FOREACH_END();
    }

    err = hs_compile_multi(expressions, flag_arr, id_arr, count,
                           HS_MODE_BLOCK, NULL, &db, &compile_err);

    efree(expressions);
    efree(flag_arr);
    efree(id_arr);

    if (err != HS_SUCCESS) {
        char *error_msg;
        if (compile_err) {
            spprintf(&error_msg, 0, "Compilation failed: %s (expression #%d)",
                     compile_err->message, compile_err->expression);
            hs_free_compile_error(compile_err);
        } else {
            spprintf(&error_msg, 0, "Compilation failed with error code %d", err);
        }
        zend_throw_exception(vectorscan_exception_ce, error_msg, err);
        efree(error_msg);
        RETURN_THROWS();
    }

    err = hs_alloc_scratch(db, &scratch);
    if (err != HS_SUCCESS) {
        hs_free_database(db);
        zend_throw_exception(vectorscan_exception_ce, "Failed to allocate scratch space", err);
        RETURN_THROWS();
    }

    array_init(&matches);
    ctx.callback = callback_zv;
    ctx.matches = &matches;
    ctx.terminated = 0;

    err = hs_scan(db, data, (unsigned int)data_len, 0, scratch, vectorscan_match_handler, &ctx);

    hs_free_scratch(scratch);
    hs_free_database(db);

    if (err != HS_SUCCESS && err != HS_SCAN_TERMINATED) {
        zval_ptr_dtor(&matches);
        zend_throw_exception(vectorscan_exception_ce, "Scan failed", err);
        RETURN_THROWS();
    }

    RETURN_ARR(Z_ARR(matches));
}
/* }}} */

/* }}} End procedural API */

/* {{{ Method entries */
static const zend_function_entry vectorscan_database_methods[] = {
    PHP_ME(VectorscanDatabase, compile, arginfo_class_Vectorscan_Database_compile, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(VectorscanDatabase, scan, arginfo_class_Vectorscan_Database_scan, ZEND_ACC_PUBLIC)
    PHP_ME(VectorscanDatabase, scanBool, arginfo_class_Vectorscan_Database_scanBool, ZEND_ACC_PUBLIC)
    PHP_ME(VectorscanDatabase, serialize, arginfo_class_Vectorscan_Database_serialize, ZEND_ACC_PUBLIC)
    PHP_ME(VectorscanDatabase, unserialize, arginfo_class_Vectorscan_Database_unserialize, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(VectorscanDatabase, size, arginfo_class_Vectorscan_Database_size, ZEND_ACC_PUBLIC)
    PHP_ME(VectorscanDatabase, info, arginfo_class_Vectorscan_Database_info, ZEND_ACC_PUBLIC)
    PHP_FE_END
};

static const zend_function_entry vectorscan_scratch_methods[] = {
    PHP_ME(VectorscanScratch, __construct, arginfo_class_Vectorscan_Scratch___construct, ZEND_ACC_PUBLIC)
    PHP_ME(VectorscanScratch, size, arginfo_class_Vectorscan_Scratch_size, ZEND_ACC_PUBLIC)
    PHP_FE_END
};

static const zend_function_entry vectorscan_stream_methods[] = {
    PHP_ME(VectorscanStream, open, arginfo_class_Vectorscan_Stream_open, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(VectorscanStream, scan, arginfo_class_Vectorscan_Stream_scan, ZEND_ACC_PUBLIC)
    PHP_ME(VectorscanStream, close, arginfo_class_Vectorscan_Stream_close, ZEND_ACC_PUBLIC)
    PHP_ME(VectorscanStream, reset, arginfo_class_Vectorscan_Stream_reset, ZEND_ACC_PUBLIC)
    PHP_FE_END
};

static const zend_function_entry vectorscan_functions[] = {
    PHP_FE(vectorscan_version, arginfo_vectorscan_version)
    PHP_FE(vectorscan_valid_platform, arginfo_vectorscan_valid_platform)
    PHP_FE(vectorscan_scan, arginfo_vectorscan_scan)
    PHP_FE_END
};
/* }}} */

/* {{{ PHP_MINIT_FUNCTION */
PHP_MINIT_FUNCTION(vectorscan)
{
    zend_class_entry ce;

    /* Register Vectorscan\Exception */
    INIT_NS_CLASS_ENTRY(ce, "Vectorscan", "Exception", NULL);
    vectorscan_exception_ce = zend_register_internal_class_ex(&ce, zend_ce_exception);

    /* Register Vectorscan\Database */
    INIT_NS_CLASS_ENTRY(ce, "Vectorscan", "Database", vectorscan_database_methods);
    vectorscan_database_ce = zend_register_internal_class(&ce);
    vectorscan_database_ce->create_object = vectorscan_database_create;
    memcpy(&vectorscan_database_handlers, &std_object_handlers, sizeof(zend_object_handlers));
    vectorscan_database_handlers.offset = XtOffsetOf(vectorscan_database_object, std);
    vectorscan_database_handlers.free_obj = vectorscan_database_free;
    vectorscan_database_handlers.clone_obj = NULL;

    /* Register Vectorscan\Scratch */
    INIT_NS_CLASS_ENTRY(ce, "Vectorscan", "Scratch", vectorscan_scratch_methods);
    vectorscan_scratch_ce = zend_register_internal_class(&ce);
    vectorscan_scratch_ce->create_object = vectorscan_scratch_create;
    memcpy(&vectorscan_scratch_handlers, &std_object_handlers, sizeof(zend_object_handlers));
    vectorscan_scratch_handlers.offset = XtOffsetOf(vectorscan_scratch_object, std);
    vectorscan_scratch_handlers.free_obj = vectorscan_scratch_free;
    vectorscan_scratch_handlers.clone_obj = NULL;

    /* Register Vectorscan\Stream */
    INIT_NS_CLASS_ENTRY(ce, "Vectorscan", "Stream", vectorscan_stream_methods);
    vectorscan_stream_ce = zend_register_internal_class(&ce);
    vectorscan_stream_ce->create_object = vectorscan_stream_create;
    memcpy(&vectorscan_stream_handlers, &std_object_handlers, sizeof(zend_object_handlers));
    vectorscan_stream_handlers.offset = XtOffsetOf(vectorscan_stream_object, std);
    vectorscan_stream_handlers.free_obj = vectorscan_stream_free;
    vectorscan_stream_handlers.clone_obj = NULL;

    /* Register constants - Mode flags */
    REGISTER_LONG_CONSTANT("VECTORSCAN_MODE_BLOCK", HS_MODE_BLOCK, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("VECTORSCAN_MODE_STREAM", HS_MODE_STREAM, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("VECTORSCAN_MODE_VECTORED", HS_MODE_VECTORED, CONST_CS | CONST_PERSISTENT);

    /* Register constants - Pattern flags */
    REGISTER_LONG_CONSTANT("VECTORSCAN_FLAG_CASELESS", HS_FLAG_CASELESS, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("VECTORSCAN_FLAG_DOTALL", HS_FLAG_DOTALL, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("VECTORSCAN_FLAG_MULTILINE", HS_FLAG_MULTILINE, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("VECTORSCAN_FLAG_SINGLEMATCH", HS_FLAG_SINGLEMATCH, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("VECTORSCAN_FLAG_ALLOWEMPTY", HS_FLAG_ALLOWEMPTY, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("VECTORSCAN_FLAG_UTF8", HS_FLAG_UTF8, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("VECTORSCAN_FLAG_UCP", HS_FLAG_UCP, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("VECTORSCAN_FLAG_SOM_LEFTMOST", HS_FLAG_SOM_LEFTMOST, CONST_CS | CONST_PERSISTENT);

    return SUCCESS;
}
/* }}} */

/* {{{ PHP_MSHUTDOWN_FUNCTION */
PHP_MSHUTDOWN_FUNCTION(vectorscan)
{
    return SUCCESS;
}
/* }}} */

/* {{{ PHP_MINFO_FUNCTION */
PHP_MINFO_FUNCTION(vectorscan)
{
    php_info_print_table_start();
    php_info_print_table_header(2, "vectorscan support", "enabled");
    php_info_print_table_row(2, "Extension version", PHP_VECTORSCAN_VERSION);
    php_info_print_table_row(2, "Library version", hs_version());
    php_info_print_table_end();
}
/* }}} */

/* {{{ vectorscan_module_entry */
zend_module_entry vectorscan_module_entry = {
    STANDARD_MODULE_HEADER,
    "vectorscan",
    vectorscan_functions,
    PHP_MINIT(vectorscan),
    PHP_MSHUTDOWN(vectorscan),
    NULL, /* RINIT */
    NULL, /* RSHUTDOWN */
    PHP_MINFO(vectorscan),
    PHP_VECTORSCAN_VERSION,
    STANDARD_MODULE_PROPERTIES
};
/* }}} */

#ifdef COMPILE_DL_VECTORSCAN
# ifdef ZTS
ZEND_TSRMLS_CACHE_DEFINE()
# endif
ZEND_GET_MODULE(vectorscan)
#endif