A RetroSearch Logo

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

Search Query:

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

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

53 #define MAX_CACHE_BACKREF 128 57 #define SET_BIT(c) re->start_bitmap[(c)/8] |= (1u << ((c)&7)) 108 int

branchlength = 0;

109 int

prev_cap_recno = -1;

111 int

prev_recurse_recno = -1;

112 int

prev_recurse_d = 0;

130 if

((*countptr)++ > 1000)

return

-1;

158

cs = cc + GET(cc, 1);

164  goto

PROCESS_NON_CAPTURE;

190  do

cc += GET(cc, 1);

while

(*cc ==

OP_ALT

);

204  if

(dupcapused || recno != prev_cap_recno)

206

prev_cap_recno = recno;

209  if

(prev_cap_d < 0)

return

prev_cap_d;

211

branchlength += prev_cap_d;

212  do

cc += GET(cc, 1);

while

(*cc ==

OP_ALT

);

236  if

(length < 0 || (!had_recurse && branchlength < length))

237

length = branchlength;

238  if

(op !=

OP_ALT

|| length == 0)

return

length;

239

nextbranch = cc + GET(cc, 1);

242

had_recurse =

FALSE

;

253  do

cc += GET(cc, 1);

while

(*cc ==

OP_ALT

);

293  do

cc += GET(cc, 1);

while

(*cc ==

OP_ALT

);

317 #ifdef SUPPORT_UNICODE 318  if

(

utf

&& HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);

336

branchlength +=

GET2

(cc,1);

338 #ifdef SUPPORT_UNICODE 339  if

(

utf

&& HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);

344

branchlength +=

GET2

(cc,1);

386 #ifdef SUPPORT_UNICODE 387  if

(

utf

)

return

-1;

418 #ifdef SUPPORT_WIDE_CHARS 450

branchlength +=

GET2

(cc,1);

490  while

(

count

-- > 0)

493

recno =

GET2

(slot, 0);

495  if

(recno <= backref_cache[0] && backref_cache[recno] >= 0)

496

dd = backref_cache[recno];

500  if

(cs ==

NULL

)

return

-2;

501  do

ce += GET(ce, 1);

while

(*ce ==

OP_ALT

);

507  if

(cc > cs && cc < ce)

514  for

(

r

= recurses;

r

!=

NULL

;

r

=

r

->prev)

515  if

(

r

->group == cs)

break

;

522

this_recurse.

prev

= recurses;

523

this_recurse.

group

= cs;

525

countptr, backref_cache);

526  if

(dd < 0)

return

dd;

531

backref_cache[recno] = dd;

532  for

(

i

= backref_cache[0] + 1;

i

< recno;

i

++) backref_cache[

i

] = -1;

533

backref_cache[0] = recno;

543  goto

REPEAT_BACK_REFERENCE;

550

recno =

GET2

(cc, 1);

551  if

(recno <= backref_cache[0] && backref_cache[recno] >= 0)

552

d = backref_cache[recno];

561  if

(cs ==

NULL

)

return

-2;

562  do

ce += GET(ce, 1);

while

(*ce ==

OP_ALT

);

567  if

(cc > cs && cc < ce)

574  for

(

r

= recurses;

r

!=

NULL

;

r

=

r

->prev)

if

(

r

->group == cs)

break

;

581

this_recurse.

prev

= recurses;

582

this_recurse.

group

= cs;

591

backref_cache[recno] = d;

592  for

(

i

= backref_cache[0] + 1;

i

< recno;

i

++) backref_cache[

i

] = -1;

593

backref_cache[0] = recno;

600

REPEAT_BACK_REFERENCE:

638  else

branchlength +=

min

* d;

648  if

(recno == prev_recurse_recno)

650

branchlength += prev_recurse_d;

654  do

ce += GET(ce, 1);

while

(*ce ==

OP_ALT

);

655  if

(cc > cs && cc < ce)

660  for

(

r

= recurses;

r

!=

NULL

;

r

=

r

->prev)

if

(

r

->group == cs)

break

;

665

this_recurse.

prev

= recurses;

666

this_recurse.

group

= cs;

668

countptr, backref_cache);

669  if

(prev_recurse_d < 0)

return

prev_recurse_d;

670

prev_recurse_recno = recno;

671

branchlength += prev_recurse_d;

727 #ifdef SUPPORT_UNICODE 728  if

(

utf

&& HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);

795 #if PCRE2_CODE_UNIT_WIDTH != 8 796 if

(c > 0xff)

SET_BIT

(0xff);

else 804 #ifdef SUPPORT_UNICODE 807 #if PCRE2_CODE_UNIT_WIDTH == 8 809 #elif PCRE2_CODE_UNIT_WIDTH == 16 810  if

((c & 0xfc00) == 0xd800) GETUTF16INC(c, p);

819 #ifdef SUPPORT_UNICODE 823 #if PCRE2_CODE_UNIT_WIDTH == 8 827

(void)

PRIV

(ord2utf)(c, buff);

872 for

(c = 0; c < table_limit; c++)

875 if

(table_limit == 32)

return

;

876 for

(c = 128; c < 256; c++)

881

(void)

PRIV

(ord2utf)(c, buff);

913 for

(c = 0; c < table_limit; c++)

915 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 916 if

(table_limit != 32)

for

(c = 24; c < 32; c++) re->

start_bitmap

[c] = 0xff;

962 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 963 int

table_limit =

utf

? 16:32;

965 int

table_limit = 32;

984 #ifdef SUPPORT_WIDE_CHARS 1088  const uint32_t

*p =

PRIV

(ucd_caseless_sets) + tcode[2];

1091 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 1095

(void)

PRIV

(ord2utf)(c, buff);

1121

ncode = tcode + GET(tcode, 1);

1122  while

(*ncode ==

OP_ALT

) ncode += GET(ncode, 1);

1137

ncode += GET(ncode, 1);

1138  while

(*ncode ==

OP_ALT

) ncode += GET(ncode, 1);

1221  do

tcode += GET(tcode, 1);

while

(*tcode ==

OP_ALT

);

1261  do

tcode += GET(tcode, 1);

while

(*tcode ==

OP_ALT

);

1272  do

tcode += GET(tcode,1);

while

(*tcode ==

OP_ALT

);

1280  do

tcode += GET(tcode,1);

while

(*tcode ==

OP_ALT

);

1355 #if PCRE2_CODE_UNIT_WIDTH != 8 1362 #ifdef SUPPORT_UNICODE 1394 #if PCRE2_CODE_UNIT_WIDTH != 8 1401 #ifdef SUPPORT_UNICODE 1494 #if PCRE2_CODE_UNIT_WIDTH != 8 1501 #ifdef SUPPORT_UNICODE 1531 #if PCRE2_CODE_UNIT_WIDTH != 8 1538 #ifdef SUPPORT_UNICODE 1588 #ifdef SUPPORT_WIDE_CHARS 1598

classmap = ((xclassflags &

XCL_MAP

) == 0)?

NULL

:

1604 #if PCRE2_CODE_UNIT_WIDTH == 8 1609

tcode += GET(tcode, 1);

1611  for

(;;)

switch

(*p++)

1615  while

((*p & 0xc0) == 0x80) p++;

1621  while

((*p & 0xc0) == 0x80) p++;

1623  while

((*p & 0xc0) == 0x80) p++;

1624  for

(;

b

<= e;

b

++)

1629  goto

HANDLE_CLASSMAP;

1650 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 1656 #elif PCRE2_CODE_UNIT_WIDTH != 8 1666  if

(*tcode ==

OP_XCLASS

) tcode += GET(tcode, 1);

else 1668

classmap = (

uint8_t

*)(++tcode);

1679 #if defined SUPPORT_WIDE_CHARS && PCRE2_CODE_UNIT_WIDTH == 8 1682  if

(classmap !=

NULL

)

1684 #if defined SUPPORT_UNICODE && PCRE2_CODE_UNIT_WIDTH == 8 1687  for

(c = 0; c < 16; c++) re->

start_bitmap

[c] |= classmap[c];

1688  for

(c = 128; c < 256; c++)

1690  if

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

1692  int

d = (c >> 6) | 0xc0;

1694

c = (c & 0xc0) + 0x40 - 1;

1703  for

(c = 0; c < 32; c++) re->

start_bitmap

[c] |= classmap[c];

1725  else

try_next =

FALSE

;

1772

re->name_entry_size * re->name_count;

1797  uint8_t

*p = re->start_bitmap;

1800  for

(

i

= 0;

i

< 256; p++,

i

+= 8)

1807  if

(y != x)

goto DONE

;

1812 #if PCRE2_CODE_UNIT_WIDTH != 8 1813  if

(

i

== 248 && x == 0x80)

goto DONE

;

1822  case

2: c += 1;

break

;

case

4: c += 2;

break

;

1823  case

8: c += 3;

break

;

case

16: c += 4;

break

;

1824  case

32: c += 5;

break

;

case

64: c += 6;

break

;

1825  case

128: c += 7;

break

;

1832 #if PCRE2_CODE_UNIT_WIDTH == 8 1833  if

(

utf

&& c > 127)

goto DONE

;

1840 #ifdef SUPPORT_UNICODE 1848  if

(d !=

a

)

goto DONE

;

1866

(b < 0 || re->last_codeunit != (

uint32_t

)

b

)

1870

re->first_codeunit =

a

;

1876

re->flags |=

flags

;

1893

backref_cache[0] = 0;

static unsigned char depth[2 *(256+1+29)+1]

unsigned int

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

for(len=0;yy_str[len];++len)

if(yy_accept[yy_current_state])

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

#define PCRE2_MATCH_UNSET_BACKREF

#define PCRE2_CODE_UNIT_WIDTH

#define PCRE2_FIRSTMAPSET

#define GETUTF8INC(c, eptr)

#define PCRE2_FIRSTCASELESS

@ OP_NOT_UCP_WORD_BOUNDARY

#define UCD_OTHERCASE(ch)

#define PCRE2_MATCH_EMPTY

struct pcre2_real_code pcre2_real_code

#define TABLE_GET(c, table, default)

static int find_minlength(const pcre2_real_code *re, PCRE2_SPTR code, PCRE2_SPTR startcode, BOOL utf, recurse_check *recurses, int *countptr, int *backref_cache)

static void set_nottype_bits(pcre2_real_code *re, int cbit_type, unsigned int table_limit)

static int set_start_bits(pcre2_real_code *re, PCRE2_SPTR code, BOOL utf, BOOL ucp, int *depthptr)

#define MAX_CACHE_BACKREF

static void set_type_bits(pcre2_real_code *re, int cbit_type, unsigned int table_limit)

static PCRE2_SPTR set_table_bit(pcre2_real_code *re, PCRE2_SPTR p, BOOL caseless, BOOL utf, BOOL ucp)

struct recurse_check * prev

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