C++ (Cpp) nxt_regex_match Examples

Example #1

File: njs_regexp.c Project: nginx/njs

nxt_int_t
njs_regexp_match(njs_vm_t *vm, nxt_regex_t *regex, u_char *subject, size_t len,
                 nxt_regex_match_data_t *match_data)
{
    nxt_int_t            ret;
    nxt_trace_handler_t  handler;

    handler = vm->trace.handler;
    vm->trace.handler = njs_regexp_match_trace_handler;

    ret = nxt_regex_match(regex, subject, len, match_data, vm->regex_context);

    vm->trace.handler = handler;

    return ret;
}

Example #2

File: njs_regexp.c Project: tperalta82/nginx-pagespeed-latest

static njs_ret_t
njs_regexp_prototype_test(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs,
    njs_index_t unused)
{
    njs_ret_t             ret;
    nxt_uint_t            n;
    njs_value_t           *value;
    const njs_value_t     *retval;
    njs_string_prop_t     string;
    njs_regexp_pattern_t  *pattern;

    if (!njs_is_regexp(&args[0])) {
        vm->exception = &njs_exception_type_error;
        return NXT_ERROR;
    }

    retval = &njs_value_false;

    if (nargs > 1) {
        value = &args[1];

    } else {
        value = (njs_value_t *) &njs_string_void;
    }

    (void) njs_string_prop(&string, value);

    n = (string.length != 0);

    pattern = args[0].data.u.regexp->pattern;

    if (nxt_regex_is_valid(&pattern->regex[n])) {
        ret = nxt_regex_match(&pattern->regex[n], string.start, string.size,
                              vm->single_match_data, vm->regex_context);
        if (ret >= 0) {
            retval = &njs_value_true;

        } else if (ret != NGX_REGEX_NOMATCH) {
            return njs_regexp_match_error(vm);
        }
    }

    vm->retval = *retval;

    return NXT_OK;
}

Example #3

File: njs_regexp.c Project: tperalta82/nginx-pagespeed-latest

njs_ret_t
njs_regexp_prototype_exec(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs,
    njs_index_t unused)
{
    njs_ret_t               ret;
    nxt_uint_t              n, utf8;
    njs_value_t             *value;
    njs_regexp_t            *regexp;
    njs_string_prop_t       string;
    njs_regexp_pattern_t    *pattern;
    nxt_regex_match_data_t  *match_data;

    if (!njs_is_regexp(&args[0])) {
        vm->exception = &njs_exception_type_error;
        return NXT_ERROR;
    }

    if (nargs > 1) {
        value = &args[1];

    } else {
        value = (njs_value_t *) &njs_string_void;
    }

    regexp = args[0].data.u.regexp;
    regexp->string = *value;

    (void) njs_string_prop(&string, value);

    /* Byte string. */
    utf8 = 0;
    n = 0;

    if (string.length != 0) {
        /* ASCII string. */
        utf8 = 1;
        n = 1;

        if (string.length != string.size) {
            /* UTF-8 string. */
            utf8 = 2;
        }
    }

    pattern = regexp->pattern;

    if (nxt_regex_is_valid(&pattern->regex[n])) {
        string.start += regexp->last_index;
        string.size -= regexp->last_index;

        match_data = nxt_regex_match_data(&pattern->regex[n],
                                          vm->regex_context);
        if (nxt_slow_path(match_data == NULL)) {
            return NXT_ERROR;
        }

        ret = nxt_regex_match(&pattern->regex[n], string.start, string.size,
                              match_data, vm->regex_context);
        if (ret >= 0) {
            return njs_regexp_exec_result(vm, regexp, string.start, match_data,
                                          utf8);
        }

        if (nxt_slow_path(ret != NGX_REGEX_NOMATCH)) {
            nxt_regex_match_data_free(match_data, vm->regex_context);

            return njs_regexp_match_error(vm);
        }
    }

    regexp->last_index = 0;
    vm->retval = njs_value_null;

    return NXT_OK;
}