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

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

NCBI C++ ToolKit: include/misc/jsonwrapp/rapidjson11/internal/regex.h Source File

RAPIDJSON_DIAG_OFF(padded)

RAPIDJSON_DIAG_OFF(

-

)

RAPIDJSON_DIAG_OFF(implicit-fallthrough)

RAPIDJSON_DIAG_OFF(effc++)

RAPIDJSON_DIAG_OFF(4512)

<

SourceStream,

Encoding>

() {

codepoint_; }

c = codepoint_;

<

Encoding,

Allocator>

<

Encoding,

Allocator = CrtAllocator>

Encoding::Ch

;

states_(allocator, 256), ranges_(allocator, 256), root_(

), stateCount_(), rangeCount_(),

anchorBegin_(), anchorEnd_()

kAnyCharacterClass = 0xFFFFFFFF;

kRangeCharacterClass = 0xFFFFFFFE;

kRangeNegationFlag = 0x80000000;

states_.template Bottom<State>()[index];

states_.template Bottom<State>()[index];

ranges_.template Bottom<Range>()[index];

ranges_.template Bottom<Range>()[index];

<

InputStream>

*atomCountStack.template Push<unsigned>() = 0;

(ds.

() != 0) {

(codepoint = ds.

()) {

anchorBegin_ =

;

(!operatorStack.

() && *operatorStack.template Top<Operator>() < kAlternation)

(!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))

*operatorStack.template Push<Operator>() = kAlternation;

*atomCountStack.template Top<unsigned>() = 0;

*operatorStack.template Push<Operator>() = kLeftParenthesis;

*atomCountStack.template Push<unsigned>() = 0;

(!operatorStack.

() && *operatorStack.template Top<Operator>() != kLeftParenthesis)

(!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))

(operatorStack.

())

operatorStack.template Pop<Operator>(1);

atomCountStack.template Pop<unsigned>(1);

ImplicitConcatenation(atomCountStack, operatorStack);

(!Eval(operandStack, kZeroOrOne))

(!Eval(operandStack, kZeroOrMore))

(!Eval(operandStack, kOneOrMore))

(!ParseUnsigned(ds, &

))

(ds.

() ==

) {

(ds.

() ==

)

m = kInfinityQuantifier;

(!ParseUnsigned(ds, &m) || m <

)

(!EvalQuantifier(operandStack,

, m) || ds.

() !=

)

PushOperand(operandStack, kAnyCharacterClass);

ImplicitConcatenation(atomCountStack, operatorStack);

(!ParseRange(ds, &range))

GetState(s).rangeStart = range;

*operandStack.template Push<Frag>() =

(s, s, s);

ImplicitConcatenation(atomCountStack, operatorStack);

(!CharacterEscape(ds, &codepoint))

PushOperand(operandStack, codepoint);

ImplicitConcatenation(atomCountStack, operatorStack);

(!operatorStack.

())

(!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))

* e = operandStack.template Pop<Frag>(1);

printf(

, root_);

& s = GetState(

);

printf(

,

, s.

, s.

, (

)s.

);

* s = states_.template Push<State>();

stateCount_++;

*operandStack.template Push<Frag>() =

(s, s, s);

(*atomCountStack.template Top<unsigned>())

*operatorStack.template Push<Operator>() = kConcatenation;

(*atomCountStack.template Top<unsigned>())++;

l1 = GetState(l1).out;

GetState(l1).out = l2;

= GetState(

).out;

GetState(

).out = s;

e2 = *operandStack.template Pop<Frag>(1);

e1 = *operandStack.template Pop<Frag>(1);

(operandStack.

() >=

(

) * 2) {

e2 = *operandStack.template Pop<Frag>(1);

e1 = *operandStack.template Pop<Frag>(1);

e = *operandStack.template Pop<Frag>(1);

*operandStack.template Push<Frag>() =

(s, Append(e.

, s), e.

);

e = *operandStack.template Pop<Frag>(1);

*operandStack.template Push<Frag>() =

(s, s, e.

);

e = *operandStack.template Pop<Frag>(1);

(m == kInfinityQuantifier)

Eval(operandStack, kZeroOrMore);

Eval(operandStack, kZeroOrOne);

(

= 0;

< m - 1;

++)

CloneTopOperand(operandStack);

(

= 0;

< m - 1;

++)

Eval(operandStack, kConcatenation);

(

= 0;

<

- 1;

++)

CloneTopOperand(operandStack);

(m == kInfinityQuantifier)

Eval(operandStack, kOneOrMore);

CloneTopOperand(operandStack);

Eval(operandStack, kZeroOrOne);

(

=

;

< m - 1;

++)

CloneTopOperand(operandStack);

(

=

;

< m;

++)

Eval(operandStack, kConcatenation);

(

= 0;

<

- 1;

++)

Eval(operandStack, kConcatenation);

src = *operandStack.template Top<Frag>();

* s = states_.template Push<State>(

);

stateCount_ +=

;

<

InputStream>

(ds.

() <

|| ds.

() >

)

(ds.

() >=

&& ds.

() <=

) {

(

>= 429496729 && ds.

() >

)

=

* 10 + (ds.

() -

);

<

InputStream>

isBegin =

;

negate =

;

((codepoint = ds.

()) != 0) {

(codepoint ==

) {

GetRange(current).next =

;

GetRange(start).start |= kRangeNegationFlag;

(ds.

() ==

) {

(!CharacterEscape(ds, &codepoint))

(codepoint ==

) {

GetRange(current).next =

;

GetRange(current).end = codepoint;

*

= ranges_.template Push<Range>();

->start =

->end = codepoint;

rangeCount_++;

<

InputStream>

(codepoint = ds.

()) {

*escapedCodepoint = codepoint;

;

: *escapedCodepoint = 0x000C;

;

: *escapedCodepoint = 0x000A;

;

: *escapedCodepoint = 0x000D;

;

: *escapedCodepoint = 0x0009;

;

: *escapedCodepoint = 0x000B;

;

kInfinityQuantifier = ~0u;

<

RegexType,

Allocator = CrtAllocator>

RegexType::EncodingType

;

Encoding::Ch

;

regex_(regex), allocator_(allocator), ownAllocator_(0),

state0_(allocator, 0), state1_(allocator, 0), stateSet_()

stateSet_ =

*

(allocator_->Malloc(GetStateSetSize()));

state0_.template Reserve<SizeType>(regex_.stateCount_);

state1_.template Reserve<SizeType>(regex_.stateCount_);

<

InputStream>

SearchWithAnchoring(is,

,

);

<

InputStream>

SearchWithAnchoring(is, regex_.anchorBegin_, regex_.anchorEnd_);

RegexType::State

;

RegexType::Range

;

<

InputStream>

stateSetSize = GetStateSetSize();

std::memset(stateSet_, 0, stateSetSize);

matched = AddState(*current, regex_.root_);

(!current->

() && (codepoint = ds.

()) != 0) {

std::memset(stateSet_, 0, stateSetSize);

(

* s = current->template Bottom<SizeType>(); s != current->template End<SizeType>(); ++s) {

& sr = regex_.GetState(*s);

(sr.codepoint == codepoint ||

sr.codepoint == RegexType::kAnyCharacterClass ||

(sr.codepoint == RegexType::kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint)))

matched = AddState(*

, sr.out) || matched;

(!anchorEnd && matched)

AddState(*

, regex_.root_);

(regex_.stateCount_ + 31) / 32 * 4;

& s = regex_.GetState(index);

matched = AddState(

, s.out);

AddState(

, s.out1) || matched;

(!(stateSet_[index >> 5] & (1u << (index & 31)))) {

stateSet_[index >> 5] |= (1u << (index & 31));

*

.template PushUnsafe<SizeType>() = index;

= (regex_.GetRange(rangeIndex).start & RegexType::kRangeNegationFlag) == 0;

&

= regex_.GetRange(rangeIndex);

(codepoint >= (

.start & ~RegexType::kRangeNegationFlag) && codepoint <=

.end)

rangeIndex =

.next;

Concept for allocating, resizing and freeing memory block.

Concept for encoding of Unicode characters.

DecodedStream(SourceStream &ss)

Stack< Allocator > state1_

bool SearchWithAnchoring(InputStream &is, bool anchorBegin, bool anchorEnd)

size_t GetStateSetSize() const

bool Search(InputStream &is)

RegexType::EncodingType Encoding

Allocator * ownAllocator_

bool AddState(Stack< Allocator > &l, SizeType index)

bool Match(InputStream &is)

GenericRegexSearch(const RegexType &regex, Allocator *allocator=0)

Stack< Allocator > state0_

bool MatchRange(SizeType rangeIndex, unsigned codepoint) const

Regular expression engine with subset of ECMAscript grammar.

bool ParseRange(DecodedStream< InputStream, Encoding > &ds, SizeType *range)

static SizeType Min(SizeType a, SizeType b)

void PushOperand(Stack< Allocator > &operandStack, unsigned codepoint)

void CloneTopOperand(Stack< Allocator > &operandStack)

void ImplicitConcatenation(Stack< Allocator > &atomCountStack, Stack< Allocator > &operatorStack)

bool CharacterEscape(DecodedStream< InputStream, Encoding > &ds, unsigned *escapedCodepoint)

bool Eval(Stack< Allocator > &operandStack, Operator op)

Range & GetRange(SizeType index)

SizeType NewState(SizeType out, SizeType out1, unsigned codepoint)

SizeType NewRange(unsigned codepoint)

const Range & GetRange(SizeType index) const

void Parse(DecodedStream< InputStream, Encoding > &ds)

State & GetState(SizeType index)

Stack< Allocator > states_

void Patch(SizeType l, SizeType s)

bool EvalQuantifier(Stack< Allocator > &operandStack, unsigned n, unsigned m)

const State & GetState(SizeType index) const

bool ParseUnsigned(DecodedStream< InputStream, Encoding > &ds, unsigned *u)

Stack< Allocator > ranges_

SizeType Append(SizeType l1, SizeType l2)

GenericRegex(const Ch *source, Allocator *allocator=0)

A type-unsafe stack for storing different types of data.

std::ofstream out("events_result.xml")

main entry point for tests

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

#define RAPIDJSON_ASSERT(x)

Assertion.

#define RAPIDJSON_NAMESPACE_BEGIN

provide custom rapidjson namespace (opening expression)

#define RAPIDJSON_NAMESPACE_END

provide custom rapidjson namespace (closing expression)

fallback to Cassandra storage</td > n</tr > n</table > n</td > n< td > yes

static const SizeType kRegexInvalidState

Represents an invalid index in GenericRegex::State::out, out1.

static const SizeType kRegexInvalidRange

void Swap(T &a, T &b) RAPIDJSON_NOEXCEPT

Custom swap() to avoid dependency on C++ <algorithm> header.

GenericRegex< UTF8<> > Regex

GenericRegexSearch< Regex > RegexSearch

const CharType(& source)[N]

unsigned SizeType

Size type (for string lengths, array sizes, etc.)

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

#define RAPIDJSON_DELETE(x)

! customization point for global delete

#define RAPIDJSON_NEW(TypeName)

! customization point for global new

static SLJIT_INLINE sljit_ins l(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

Frag(SizeType s, SizeType o, SizeType m)

SizeType out

link-list of all output states

SizeType out

Equals to kInvalid for matching state.

SizeType out1

Equals to non-kInvalid for split.

void Decode(const vector< char > &, CRawScoreVector< Key, Score > &)

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