Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/pcre2__dfa__match_8c_source.html below:

NCBI C++ ToolKit: src/util/regexp/pcre2_dfa_match.c Source File

cb->pattern_position = GET(

, 1 + extracode);

cb->next_item_length = GET(

, 1 +

+ extracode);

cb->callout_string_offset = 0;

cb->callout_string =

;

cb->callout_string_length = 0;

cb->callout_number = 0;

cb->callout_string_offset = GET(

, 1 + 3*

+ extracode);

cb->callout_string =

+ (1 + 4*

+ extracode) + 1;

cb->callout_string_length = *lengthptr - (1 + 4*

) - 2;

newsizeK = newsize/(1024/

(

));

newsize = newsizeK*(1024/

(

));

->size = newsize;

*active_states, *new_states, *temp_states;

*next_active_state, *next_new_state;

*ctypes, *lcc, *fcc;

active_count, new_count, match_count;

active_states = (

*)(workspace + 2);

next_new_state = new_states = active_states + wscount;

end_code = this_start_code;

(back > max_back) max_back = back;

end_code += GET(end_code, 1);

(*end_code ==

);

(gone_back = 0; gone_back < max_back; gone_back++)

(current_subject <= start_subject)

;

ACROSSCHAR(current_subject > start_subject, current_subject,

current_offset = (size_t)(current_subject - start_subject);

gone_back = (current_offset < max_back)? current_offset : max_back;

current_subject -= gone_back;

(current_subject < mb->start_used_ptr)

end_code = this_start_code;

back = (revlen == 0)? 0 : (

)

(end_code, 2+

);

(back <= gone_back)

bstate = (

)(end_code - start_code + 1 +

+ revlen);

end_code += GET(end_code, 1);

(*end_code ==

);

end_code = this_start_code;

{ end_code += GET(end_code, 1); }

(*end_code ==

);

new_count = workspace[1];

memcpy(new_states, active_states, (

)new_count *

(

));

((

)(end_code - start_code + length), 0);

end_code += GET(end_code, 1);

(*end_code ==

);

ptr = current_subject;

could_continue = reset_could_continue;

reset_could_continue =

;

temp_states = active_states;

active_states = new_states;

new_states = temp_states;

active_count = new_count;

workspace[1] = active_count;

next_active_state = active_states + active_count;

next_new_state = new_states;

(ptr < end_subject)

GETCHARLENTEST(c, ptr, clen);

(

= 0;

< active_count;

++)

state_offset = current_state->

;

(state_offset < 0)

(current_state->

> 0)

current_state->

- 1);

(could_continue) reset_could_continue =

;

current_state->

= state_offset = -state_offset;

(j = 0; j <

; j++)

(active_states[j].

== state_offset &&

active_states[j].

== current_state->

)

NEXT_ACTIVE_STATE;

= start_code + state_offset;

(clen == 0 &&

[codevalue] != 0)

could_continue =

;

(

!= end_code)

(ptr > current_subject ||

(match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;

(match_count > 0 && ++match_count * 2 > (

)offsetcount)

= ((match_count == 0)? (

)offsetcount : match_count * 2) - 2;

(offsetcount >= 2)

(ptr >= end_subject)

(ptr == start_subject) {

(state_offset + 1, 0); }

(ptr == start_subject + start_offset) {

(state_offset + 1, 0); }

could_continue = partial_newline =

;

(state_offset + 1, 0);

{

(state_offset + 1, 0); }

(clen == 0 || (

(ptr) && ptr == end_subject - mb->

))

could_continue =

;

(clen == 0 ||

(ptr == end_subject - mb->

)

reset_could_continue =

;

could_continue = partial_newline =

;

could_continue =

;

(clen == 0 ||

reset_could_continue =

;

could_continue = partial_newline =

;

(clen > 0 && c < 256 &&

{

(state_offset + 1, 0); }

(clen > 0 && (c >= 256 ||

{

(state_offset + 1, 0); }

left_word, right_word;

(ptr > start_subject)

(

) { BACKCHAR(temp); }

category =

(ucp_gentype)[chartype];

left_word = (category ==

|| category ==

||

left_word = d < 256 && (ctypes[d] &

) != 0;

left_word =

;

category =

(ucp_gentype)[chartype];

right_word = (category ==

|| category ==

||

right_word = c < 256 && (ctypes[c] &

) != 0;

right_word =

;

((left_word == right_word) ==

OK =

(ucp_gentype)[chartype] ==

||

OK =

(ucp_gentype)[chartype] ==

||

(ucp_gentype)[chartype] ==

||

cp =

(ucd_caseless_sets) +

[2];

(c < *cp) { OK =

;

; }

(c == *cp++) { OK =

;

; }

(OK == (codevalue ==

)) {

(state_offset + 3, 0); }

could_continue = partial_newline =

;

next_active_state--;

could_continue = partial_newline =

;

next_active_state--;

(state_offset + 2, 0);

could_continue = partial_newline =

;

next_active_state--;

could_continue = partial_newline =

;

could_continue = partial_newline =

;

next_active_state--;

OK =

(ucp_gentype)[chartype] ==

||

OK =

(ucp_gentype)[chartype] ==

||

(ucp_gentype)[chartype] ==

||

cp =

(ucd_caseless_sets) +

[3];

(c < *cp) { OK =

;

; }

(c == *cp++) { OK =

;

; }

next_active_state--;

next_active_state--;

next_active_state--;

next_active_state--;

next_active_state--;

OK =

(ucp_gentype)[chartype] ==

||

OK =

(ucp_gentype)[chartype] ==

||

(ucp_gentype)[chartype] ==

||

cp =

(ucd_caseless_sets) +

[3];

(c < *cp) { OK =

;

; }

(c == *cp++) { OK =

;

; }

next_active_state--;

next_active_state--;

next_active_state--;

next_active_state--;

next_active_state--;

OK =

(ucp_gentype)[chartype] ==

||

OK =

(ucp_gentype)[chartype] ==

||

(ucp_gentype)[chartype] ==

||

(c < *cp) { OK =

;

; }

(c == *cp++) { OK =

;

; }

next_active_state--;

next_active_state--;

reset_could_continue =

;

next_active_state--;

next_active_state--;

next_active_state--;

(clen > 0 && c == d) {

(state_offset + dlen + 1, 0); }

(clen == 0)

;

(c == d) {

(state_offset + dlen + 1, 0); }

othercase;

(d == othercase) {

(state_offset + dlen + 1, 0); }

{

(state_offset + 2, 0); }

end_subject,

, &ncount);

reset_could_continue =

;

(clen > 0)

(c)

(state_offset + 1, 0);

(ptr + 1 >= end_subject)

(state_offset + 1, 0);

reset_could_continue =

;

(state_offset + 1, 0);

(clen > 0)

(c)

(state_offset + 1, 0);

(clen > 0)

(c)

(state_offset + 1, 0);

(clen > 0)

(c)

(state_offset + 1, 0);

(clen > 0)

(c)

(state_offset + 1, 0);

(clen > 0 && c != d) {

(state_offset + dlen + 1, 0); }

(utf_or_ucp && d >= 128)

(c != d && c != otherd)

{

(state_offset + dlen + 1, 0); }

(utf_or_ucp && d >= 128)

((c == d || c == otherd) == (codevalue <

))

next_active_state--;

(utf_or_ucp && d >= 128)

((c == d || c == otherd) == (codevalue <

))

next_active_state--;

(state_offset + dlen + 1, 0);

(utf_or_ucp && d >= 128)

((c == d || c == otherd) == (codevalue <

))

next_active_state--;

(utf_or_ucp && d >= 128)

((c == d || c == otherd) == (codevalue <

))

(utf_or_ucp && d >= 128)

((c == d || c == otherd) == (codevalue <

))

next_active_state--;

next_state_offset;

isinclass = (c > 255)? (codevalue ==

) :

((((

*)(

+ 1))[c/8] & (1u << (c&7))) != 0);

next_state_offset = (

)(ecode - start_code);

next_active_state--;

next_active_state--;

next_active_state--;

(next_state_offset + 1, 0);

next_active_state--;

(isinclass) {

(next_state_offset, 0); }

*local_workspace;

(rc != 0)

rc;

(*endasscode ==

) endasscode += GET(endasscode, 1);

codelink = (

)GET(

, 1);

(rrc < 0)

rrc;

(rrc > 0)

;

+= callout_length;

(condcode ==

)

(condcode ==

)

*local_workspace;

endasscode = asscode + GET(asscode, 1);

(rc != 0)

rc;

(*endasscode ==

) endasscode += GET(endasscode, 1);

*local_workspace;

(rc != 0)

rc;

(recno == ri->group_num && ptr == ri->subject_position &&

(rc = rc*2 - 2; rc >= 0; rc -= 2)

charcount = local_offsets[rc+1] - local_offsets[rc];

p = start_subject + local_offsets[rc];

pp = start_subject + local_offsets[rc+1];

(p < pp)

(NOT_FIRSTCU(*p++)) charcount--;

(

)(charcount - 1));

*local_workspace;

(rc != 0)

rc;

codevalue = *(++

);

allow_zero =

;

(matched_count = 0;; matched_count++)

charcount = local_offsets[1] - local_offsets[0];

(charcount == 0)

;

local_ptr += charcount;

(matched_count > 0 || allow_zero)

next_state_offset;

{ end_subpattern += GET(end_subpattern, 1); }

(*end_subpattern ==

);

(

+ 1 >= active_count && new_count == 0)

(next_state_offset, 0);

(

)

(p < pp)

(NOT_FIRSTCU(*p++)) charcount--;

(-next_state_offset, 0, (

)(charcount - 1));

*local_workspace;

(rc != 0)

rc;

charcount = local_offsets[1] - local_offsets[0];

next_state_offset, repeat_state_offset;

{ end_subpattern += GET(end_subpattern, 1); }

(*end_subpattern ==

);

repeat_state_offset = (*end_subpattern ==

||

(

)(end_subpattern - start_code - GET(end_subpattern, 1)) : -1;

(

+ 1 >= active_count && new_count == 0)

(next_state_offset, 0);

(repeat_state_offset >= 0)

next_active_state = active_states;

p = start_subject + local_offsets[0];

pp = start_subject + local_offsets[1];

(p < pp)

(NOT_FIRSTCU(*p++)) charcount--;

(-next_state_offset, 0, (

)(charcount - 1));

(repeat_state_offset >= 0)

{

(-repeat_state_offset, 0, (

)(charcount - 1)); }

(rrc < 0)

rrc;

{

(state_offset + (

)callout_length, 0); }

NEXT_ACTIVE_STATE:

;

(could_continue &&

forced_fail != workspace[1] &&

ptr >= end_subject &&

(match_count >= 0 &&

was_zero_terminated = 0;

, anchored, startline, firstline;

was_zero_terminated = 1;

options |= (re->

&

) / ((

& (~

+1)) / (

& (~

+1)));

((workspace[0] & (-2)) != 0 || workspace[1] < 1 ||

start_match =

+ start_offset;

end_subject =

+ length;

req_cu_ptr = start_match - 1;

bumpalong_limit = end_subject;

cb.callout_flags = 0;

cb.capture_last = 0;

(mcontext ==

)

bumpalong_limit =

+ mcontext->offset_limit;

mb->

= mcontext->callout;

mb->

= mcontext->memctl;

(start_offset > 0)

(start_match < end_subject && NOT_FIRSTCU(*start_match))

(check_subject >

&&

(*check_subject & 0xc0) == 0x80)

(*check_subject & 0xfc00) == 0xdc00)

has_first_cu =

;

ACROSSCHAR(

< end_subject,

,

++);

(has_first_cu || start_bits !=

)

= start_match < end_subject;

= has_first_cu && (c == first_cu || c == first_cu2);

(!

&& start_bits !=

)

(c > 255) c = 255;

= (start_bits[c/8] & (1u << (c&7))) != 0;

(first_cu != first_cu2)

(start_match < end_subject &&

searchlength = end_subject - start_match;

(memchr_found_first_cu ==

||

start_match > memchr_found_first_cu)

pp1 = memchr(start_match, first_cu, searchlength);

memchr_found_first_cu = (pp1 ==

)? end_subject : pp1;

pp1 = (memchr_found_first_cu == end_subject)?

:

memchr_found_first_cu;

(memchr_found_first_cu2 ==

||

start_match > memchr_found_first_cu2)

pp2 = memchr(start_match, first_cu2, searchlength);

memchr_found_first_cu2 = (pp2 ==

)? end_subject : pp2;

pp2 = (memchr_found_first_cu2 == end_subject)?

:

memchr_found_first_cu2;

start_match = (pp2 ==

)? end_subject : pp2;

start_match = (pp2 ==

|| pp1 < pp2)? pp1 : pp2;

(start_match < end_subject &&

(start_match) !=

start_match = memchr(start_match, first_cu, end_subject - start_match);

(start_match ==

) start_match = end_subject;

(start_match < end_subject && !

(start_match))

ACROSSCHAR(start_match < end_subject, start_match, start_match++);

(start_match < end_subject && !

(start_match))

(start_match[-1] ==

&&

start_match < end_subject &&

(start_bits !=

)

(start_match < end_subject)

(c > 255) c = 255;

((start_bits[c/8] & (1u << (c&7))) != 0)

;

(end_subject - start_match < re->minlength)

NOMATCH_EXIT;

p = start_match + (has_first_cu? 1:0);

(has_req_cu && p > req_cu_ptr)

check_length = end_subject - start_match;

(!anchored && check_length <

* 1000))

(req_cu != req_cu2)

(p < end_subject)

(pp == req_cu || pp == req_cu2) { p--;

; }

p = memchr(pp, req_cu, end_subject - pp);

p = memchr(pp, req_cu2, end_subject - pp);

(p ==

) p = end_subject;

(p < end_subject)

p = memchr(p, req_cu, end_subject - p);

(p ==

) p = end_subject;

(p >= end_subject)

;

(start_match > bumpalong_limit)

;

base_recursion_workspace);

length =

(length + was_zero_terminated);

(firstline &&

(start_match))

;

ACROSSCHAR(start_match < end_subject, start_match, start_match++);

(start_match > end_subject)

;

start_match < end_subject &&

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

unsigned int

A callback function used to compare two keys in a database.

const GenericPointer< typename T::ValueType > T2 value

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

#define PCRE2_DOLLAR_ENDONLY

#define PCRE2_ZERO_TERMINATED

#define PCRE2_NOTEMPTY_ATSTART

#define PCRE2_ENDANCHORED

#define PCRE2_ERROR_BADMODE

#define PCRE2_ERROR_DFA_UINVALID_UTF

#define PCRE2_ERROR_DFA_UCOND

#define PCRE2_BSR_ANYCRLF

#define PCRE2_ERROR_HEAPLIMIT

#define PCRE2_ERROR_BADOPTION

#define PCRE2_ERROR_NOMATCH

#define PCRE2_ERROR_INTERNAL

#define PCRE2_ERROR_DFA_UITEM

#define PCRE2_MATCH_INVALID_UTF

#define PCRE2_NEWLINE_ANYCRLF

#define PCRE2_COPY_MATCHED_SUBJECT

#define PCRE2_ERROR_BADMAGIC

#define PCRE2_ERROR_BADOFFSET

#define PCRE2_ERROR_RECURSELOOP

#define PCRE2_ERROR_BADOFFSETLIMIT

#define PCRE2_PARTIAL_SOFT

#define PCRE2_ERROR_DFA_BADRESTART

#define PCRE2_PARTIAL_HARD

#define pcre2_match_context

#define PCRE2_ERROR_DEPTHLIMIT

#define PCRE2_DFA_RESTART

#define PCRE2_USE_OFFSET_LIMIT

#define PCRE2_ERROR_MATCHLIMIT

#define PCRE2_ERROR_DFA_RECURSE

#define PCRE2_ERROR_DFA_WSSIZE

#define PCRE2_CALL_CONVENTION

#define PCRE2_ALT_CIRCUMFLEX

#define PCRE2_NEWLINE_CRLF

#define PCRE2_NEWLINE_NUL

#define PCRE2_NO_UTF_CHECK

#define PCRE2_NO_START_OPTIMIZE

#define pcre2_callout_block

#define PCRE2_ERROR_PARTIAL

#define PCRE2_DFA_SHORTEST

#define PCRE2_NEWLINE_ANY

#define PCRE2_ERROR_BADUTFOFFSET

#define PCRE2_ERROR_NOMEMORY

struct stateblock stateblock

static int internal_dfa_match(dfa_match_block *mb, PCRE2_SPTR this_start_code, PCRE2_SPTR current_subject, PCRE2_SIZE start_offset, PCRE2_SIZE *offsets, uint32_t offsetcount, int *workspace, int wscount, uint32_t rlevel, int *RWS)

static const uint8_t poptable[]

static int more_workspace(RWS_anchor **rwsptr, unsigned int ovecsize, dfa_match_block *mb)

struct RWS_anchor RWS_anchor

#define INTS_PER_STATEBLOCK

PCRE2_EXPORT int PCRE2_CALL_CONVENTION pcre2_dfa_match(const pcre2_code *code, PCRE2_SPTR subject, PCRE2_SIZE length, PCRE2_SIZE start_offset, uint32_t options, pcre2_match_data *match_data, pcre2_match_context *mcontext, int *workspace, PCRE2_SIZE wscount)

#define PUBLIC_DFA_MATCH_OPTIONS

static const uint8_t coptable[]

static const uint8_t toptable2[]

static int do_callout_dfa(PCRE2_SPTR code, PCRE2_SIZE *offsets, PCRE2_SPTR current_subject, PCRE2_SPTR ptr, dfa_match_block *mb, PCRE2_SIZE extracode, PCRE2_SIZE *lengthptr)

static const uint8_t toptable1[]

#define ADD_NEW_DATA(x, y, z)

#define PCRE2_CODE_UNIT_WIDTH

@ PCRE2_MATCHEDBY_DFA_INTERPRETER

#define PCRE2_FIRSTMAPSET

#define PCRE2_FIRSTCASELESS

#define CHAR_GRAVE_ACCENT

@ OP_NOT_UCP_WORD_BOUNDARY

#define PCRE2_LASTCASELESS

#define MAX_UTF_CODE_POINT

#define CHAR_COMMERCIAL_AT

#define PCRE2_MD_COPIED_SUBJECT

#define UCD_BIDICLASS(ch)

#define UCD_OTHERCASE(ch)

#define PCRE2_MATCH_EMPTY

#define UCD_SCRIPTX_PROP(prop)

#define UCD_BPROPS_PROP(prop)

#define UCHAR21TEST(eptr)

struct pcre2_real_code pcre2_real_code

#define TABLE_GET(c, table, default)

#define UCHAR21INCTEST(eptr)

#define GETCHARLEN(c, eptr, len)

#define GETCHARTEST(c, eptr)

static PCRE2_SIZE * offsets

static pcre2_match_data * match_data

int valid_utf(PCRE2_SPTR8, PCRE2_SIZE, PCRE2_SIZE *)

int(* callout)(pcre2_callout_block *, void *)

dfa_recursion_info * recursive

PCRE2_SPTR start_used_ptr

uint32_t match_call_count

uint32_t match_limit_depth

PCRE2_SPTR subject_position

struct dfa_recursion_info * prevrec

void *(* malloc)(size_t, void *)

void(* free)(void *, void *)

uint16_t newline_convention

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4