Pattern class holds a regex pattern and its compiled FSM opcode table or code for the reflex::Matcher engine. More...

#include <pattern.h>

Collaboration diagram for reflex::Pattern:

[legend]

Classes
struct	Chars
	Set of chars and meta chars. More...

struct	Const
	Common constants. More...

struct	DFA
	DFA created by subset construction from regex patterns. More...

struct	ModConst
	Modifiers 'i', 'm', 'q', 's', 'u' (enable) 'I', 'M', 'Q', 'S', 'U' (disable) More...

struct	Option
	Global modifier modes, syntax flags, and compiler options. More...

struct	Position
	Finite state machine construction position information. More...

Public Types
typedef uint8_t	Pred
	predict match bits More...

typedef uint16_t	Hash
	hash value type, max value is Const::HASH More...

typedef uint32_t	Index
	index into opcodes array Pattern::opc_ and subpattern indexing More...

typedef uint32_t	Accept
	group capture index More...

typedef uint32_t	Opcode
	32 bit opcode word More...

typedef void(*	FSM) (class Matcher &)

Public Member Functions
	Pattern ()
	Construct an unset pattern. More...

	Pattern (const char regex, const char options=NULL)
	Construct a pattern object given a regex string. More...

	Pattern (const char *regex, const std::string &options)
	Construct a pattern object given a regex string. More...

	Pattern (const std::string &regex, const char *options=NULL)
	Construct a pattern object given a regex string. More...

	Pattern (const std::string &regex, const std::string &options)
	Construct a pattern object given a regex string. More...

	Pattern (const Opcode code, const uint8_t pred=NULL)
	Construct a pattern object given an opcode table. More...

	Pattern (FSM fsm, const uint8_t *pred=NULL)
	Construct a pattern object given a function pointer to FSM code. More...

	Pattern (const Pattern &pattern)
	Copy constructor. More...

virtual	~Pattern ()
	Destructor, deletes internal code array when owned and allocated. More...

void	clear ()
	Clear and delete pattern data. More...

Pattern &	assign (const char regex, const char options=NULL)
	Assign a (new) pattern. More...

Pattern &	assign (const char *regex, const std::string &options)
	Assign a (new) pattern. More...

Pattern &	assign (const std::string &regex, const char *options=NULL)
	Assign a (new) pattern. More...

Pattern &	assign (const std::string &regex, const std::string &options)
	Assign a (new) pattern. More...

Pattern &	assign (const Opcode code, const uint8_t pred=NULL)
	Assign a (new) pattern. More...

Pattern &	assign (FSM fsm, const uint8_t *pred=NULL)
	Assign a (new) pattern. More...

Pattern &	operator= (const Pattern &pattern)
	Assign a (new) pattern. More...

Pattern &	operator= (const char *regex)
	Assign a (new) pattern. More...

Pattern &	operator= (const std::string &regex)
	Assign a (new) pattern. More...

Pattern &	operator= (const Opcode *code)
	Assign a (new) pattern. More...

Pattern &	operator= (FSM fsm)
	Assign a (new) pattern. More...

Accept	size () const
	Get the number of subpatterns of this pattern object. More...

bool	empty () const
	Return true if this pattern is not assigned. More...

const std::string	operator[] (Accept choice) const
	Get subpattern regex of this pattern object or the whole regex with index 0. More...

bool	reachable (Accept choice) const
	Check if subpattern is reachable by a match. More...

size_t	nodes () const
	Get the number of finite state machine nodes (vertices). More...

size_t	edges () const
	Get the number of finite state machine edges (transitions on input characters). More...

size_t	words () const
	Get the code size in number of words. More...

float	parse_time () const
	Get elapsed regex parsing and analysis time. More...

float	nodes_time () const
	Get elapsed DFA vertices construction time. More...

float	edges_time () const
	Get elapsed DFA edges construction time. More...

float	words_time () const
	Get elapsed code words assembly time. More...

Static Public Member Functions
static bool	predict_match (const Pred pmh[], const char *s, size_t n)
	Returns true when match is predicted, based on s[0..3..e-1] (e >= s + 4). More...

static size_t	predict_match (const Pred pma[], const char *s)
	Returns zero when match is predicted or nonzero shift value, based on s[0..3]. More...

Protected Member Functions
virtual void	error (regex_error_type code, size_t pos=0) const
	Throw an error. More...

Private Types
enum	Meta { META_MIN = 0x100, META_NWB = 0x101, META_NWE = 0x102, META_BWB = 0x103, META_EWB = 0x104, META_BWE = 0x105, META_EWE = 0x106, META_BOL = 0x107, META_EOL = 0x108, META_BOB = 0x109, META_EOB = 0x10A, META_UND = 0x10B, META_IND = 0x10C, META_DED = 0x10D, META_MAX }
	Meta characters. More...

typedef uint8_t	Mod

typedef uint16_t	Char

typedef uint8_t	Lazy

typedef uint16_t	Iter

typedef uint16_t	Lookahead

typedef std::set< Lookahead >	Lookaheads

typedef uint32_t	Location

typedef ORanges< Location >	Locations

typedef std::map< int, Locations >	Map

typedef Locations	Mods[10]

typedef std::vector< Lazy >	Lazyset

typedef std::vector< Position >	Positions

typedef std::map< Position, Positions >	Follow

typedef std::pair< Chars, Positions >	Move

typedef std::list< Move >	Moves

Private Member Functions
void	init (const char options, const uint8_t pred=NULL)
	Initialize the pattern at construction. More...

void	init_options (const char *options)

void	parse (Positions &startpos, Follow &followpos, Mods modifiers, Map &lookahead)

void	parse1 (bool begin, Location &loc, Positions &firstpos, Positions &lastpos, bool &nullable, Follow &followpos, Lazy &lazyidx, Lazyset &lazyset, Mods modifiers, Locations &lookahead, Iter &iter)

void	parse2 (bool begin, Location &loc, Positions &firstpos, Positions &lastpos, bool &nullable, Follow &followpos, Lazy &lazyidx, Lazyset &lazyset, Mods modifiers, Locations &lookahead, Iter &iter)

void	parse3 (bool begin, Location &loc, Positions &firstpos, Positions &lastpos, bool &nullable, Follow &followpos, Lazy &lazyidx, Lazyset &lazyset, Mods modifiers, Locations &lookahead, Iter &iter)

void	parse4 (bool begin, Location &loc, Positions &firstpos, Positions &lastpos, bool &nullable, Follow &followpos, Lazy &lazyidx, Lazyset &lazyset, Mods modifiers, Locations &lookahead, Iter &iter)

Char	parse_esc (Location &loc, Chars *chars=NULL) const

void	compile (DFA::State *start, Follow &followpos, const Mods modifiers, const Map &lookahead)

void	lazy (const Lazyset &lazyset, Positions &pos) const

void	lazy (const Lazyset &lazyset, const Positions &pos, Positions &pos1) const

void	greedy (Positions &pos) const

void	trim_anchors (Positions &follow, const Position p) const

void	trim_lazy (Positions *pos) const

void	compile_transition (DFA::State *state, Follow &followpos, const Mods modifiers, const Map &lookahead, Moves &moves) const

void	transition (Moves &moves, Chars &chars, const Positions &follow) const

void	compile_list (Location loc, Chars &chars, const Mods modifiers) const

void	posix (size_t index, Chars &chars) const

void	flip (Chars &chars) const

void	assemble (DFA::State *start)

void	compact_dfa (DFA::State *start)

void	encode_dfa (DFA::State *start)

void	gencode_dfa (const DFA::State *start) const

void	check_dfa_closure (const DFA::State *state, int nest, bool &peek, bool &prev) const

void	gencode_dfa_closure (FILE fd, const DFA::State start, int nest, bool peek) const

void	graph_dfa (const DFA::State *start) const

void	export_code () const

void	predict_match_dfa (DFA::State *start)

void	gen_predict_match (DFA::State *state)

void	gen_predict_match_transitions (DFA::State state, std::map< DFA::State , ORanges< Hash > > &states)

void	gen_predict_match_transitions (size_t level, DFA::State state, ORanges< Hash > &labels, std::map< DFA::State , ORanges< Hash > > &states)

void	write_predictor (FILE *fd) const

void	write_namespace_open (FILE *fd) const

void	write_namespace_close (FILE *fd) const

size_t	find_at (Location loc, char c) const

Char	at (Location k) const

bool	eq_at (Location loc, const char *s) const

Char	escape_at (Location loc) const

Char	escapes_at (Location loc, const char *escapes) const

Static Private Member Functions
static void	pos_insert (Positions &s1, const Positions &s2)

static void	pos_add (Positions &s, const Position &e)

static void	lazy_insert (Lazyset &s1, const Lazyset &s2)

static void	lazy_add (Lazyset &s, const Lazy &e)

static bool	is_modified (Mod mod, const Mods modifiers, Location loc)

static void	update_modified (Mod mod, Mods modifiers, Location from, Location to)

static uint16_t	hash_pos (const Positions *pos)

static bool	valid_goto_index (Index index)

static bool	valid_take_index (Index index)

static bool	valid_lookahead_index (Index index)

static bool	is_meta (Char c)

static Opcode	opcode_long (Index index)

static Opcode	opcode_take (Index index)

static Opcode	opcode_redo ()

static Opcode	opcode_tail (Index index)

static Opcode	opcode_head (Index index)

static Opcode	opcode_goto (Char lo, Char hi, Index index)

static Opcode	opcode_halt ()

static bool	is_opcode_long (Opcode opcode)

static bool	is_opcode_take (Opcode opcode)

static bool	is_opcode_redo (Opcode opcode)

static bool	is_opcode_tail (Opcode opcode)

static bool	is_opcode_head (Opcode opcode)

static bool	is_opcode_halt (Opcode opcode)

static bool	is_opcode_goto (Opcode opcode)

static bool	is_opcode_meta (Opcode opcode)

static bool	is_opcode_goto (Opcode opcode, unsigned char c)

static Char	meta_of (Opcode opcode)

static Char	lo_of (Opcode opcode)

static Char	hi_of (Opcode opcode)

static Index	index_of (Opcode opcode)

static Index	long_index_of (Opcode opcode)

static Lookahead	lookahead_of (Opcode opcode)

static Char	lowercase (Char c)

static Char	uppercase (Char c)

static Char	reversecase (Char c)

static Hash	hash (Hash h, uint8_t b)

static Hash	hash (Hash h)

Private Attributes
Option	opt_
	pattern compiler options More...

DFA	tfa_
	tree DFA constructed from strings More...

DFA	dfa_
	DFA constructed from regex with subset construction using firstpos/lastpos/followpos. More...

std::string	rex_
	regular expression string More...

std::vector< Location >	end_
	entries point to the subpattern's ending '\|' or '\0' More...

std::vector< bool >	acc_
	true if subpattern n is accepting (state is reachable) More...

size_t	vno_
	number of finite state machine vertices \|V\| More...

size_t	eno_
	number of finite state machine edges \|E\| More...

const Opcode *	opc_
	points to the opcode table More...

Index	nop_
	number of opcodes generated More...

FSM	fsm_
	function pointer to FSM code More...

size_t	len_
	prefix length of pre_[], less or equal to 255 More...

size_t	min_
	patterns after the prefix are at least this long but no more than 8 More...

char	pre_ [256]
	pattern prefix, shorter or equal to 255 bytes More...

Pred	bit_ [256]
	bitap array More...

Pred	pmh_ [Const::HASH]
	predict-match hash array More...

Pred	pma_ [Const::HASH]
	predict-match array More...

float	pms_
	ms elapsed time to parse regex More...

float	vms_
	ms elapsed time to compile DFA vertices More...

float	ems_
	ms elapsed time to compile DFA edges More...

float	wms_
	ms elapsed time to assemble code words More...

bool	one_
	true if matching one string in pre_[] without meta/anchors More...

Friends
class	Matcher
	permit access by the reflex::Matcher engine More...

class	FuzzyMatcher
	permit access by the reflex::FuzzyMatcher engine More...

Detailed Description

Pattern class holds a regex pattern and its compiled FSM opcode table or code for the reflex::Matcher engine.

Member Typedef Documentation

typedef uint32_t reflex::Pattern::Accept

group capture index

typedef uint16_t reflex::Pattern::Char

private

typedef std::map<Position,Positions> reflex::Pattern::Follow

private

typedef void(* reflex::Pattern::FSM) (class Matcher &)

function pointer to FSM code

typedef uint16_t reflex::Pattern::Hash

hash value type, max value is Const::HASH

typedef uint32_t reflex::Pattern::Index

index into opcodes array Pattern::opc_ and subpattern indexing

typedef uint16_t reflex::Pattern::Iter

private

typedef uint8_t reflex::Pattern::Lazy

private

typedef std::vector<Lazy> reflex::Pattern::Lazyset

private

typedef uint32_t reflex::Pattern::Location

private

typedef ORanges<Location> reflex::Pattern::Locations

private

typedef uint16_t reflex::Pattern::Lookahead

private

typedef std::set<Lookahead> reflex::Pattern::Lookaheads

private

typedef std::map<int,Locations> reflex::Pattern::Map

private

typedef uint8_t reflex::Pattern::Mod

private

typedef Locations reflex::Pattern::Mods[10]

private

typedef std::pair<Chars,Positions> reflex::Pattern::Move

private

typedef std::list<Move> reflex::Pattern::Moves

private

typedef uint32_t reflex::Pattern::Opcode

32 bit opcode word

typedef std::vector<Position> reflex::Pattern::Positions

private

typedef uint8_t reflex::Pattern::Pred

predict match bits

Member Enumeration Documentation

enum reflex::Pattern::Meta

private

Meta characters.

Enumerator
META_MIN
META_NWB	non-word boundary at begin `\Bx`
META_NWE	non-word boundary at end `x\B`
META_BWB	begin of word at begin `\<x` where =(<\|>)x
META_EWB	end of word at begin `\>x`
META_BWE	begin of word at end `x\<` where x=x(<\|>)
META_EWE	end of word at end `x\>`
META_BOL	begin of line `^`
META_EOL	end of line `$`
META_BOB	begin of buffer `\A`
META_EOB	end of buffer `\Z`
META_UND	undent boundary `\k`
META_IND	indent boundary `\i` (must be one but the largest META code)
META_DED	dedent boundary `\j` (must be the largest META code)
META_MAX	max meta characters

Constructor & Destructor Documentation

reflex::Pattern::Pattern ( )

inline

Construct an unset pattern.

reflex::Pattern::Pattern	(	const char *	regex,
		const char *	options = `NULL`
	)

inlineexplicit

Construct a pattern object given a regex string.

reflex::Pattern::Pattern	(	const char *	regex,
		const std::string &	options
	)

inline

Construct a pattern object given a regex string.

reflex::Pattern::Pattern	(	const std::string &	regex,
		const char *	options = `NULL`
	)

inlineexplicit

Construct a pattern object given a regex string.

reflex::Pattern::Pattern	(	const std::string &	regex,
		const std::string &	options
	)

inline

Construct a pattern object given a regex string.

reflex::Pattern::Pattern	(	const Opcode *	code,
		const uint8_t *	pred = `NULL`
	)

inlineexplicit

Construct a pattern object given an opcode table.

reflex::Pattern::Pattern	(	FSM	fsm,
		const uint8_t *	pred = `NULL`
	)

inlineexplicit

Construct a pattern object given a function pointer to FSM code.

reflex::Pattern::Pattern ( const Pattern & pattern )

inline

Copy constructor.

Parameters

pattern pattern to copy

virtual reflex::Pattern::~Pattern ( )

inlinevirtual

Destructor, deletes internal code array when owned and allocated.

Member Function Documentation

void reflex::Pattern::assemble ( DFA::State * start )

private

Pattern& reflex::Pattern::assign	(	const char *	regex,
		const char *	options = `NULL`
	)

inline

Assign a (new) pattern.

Pattern& reflex::Pattern::assign	(	const char *	regex,
		const std::string &	options
	)

inline

Assign a (new) pattern.

Pattern& reflex::Pattern::assign	(	const std::string &	regex,
		const char *	options = `NULL`
	)

inline

Assign a (new) pattern.

Pattern& reflex::Pattern::assign	(	const std::string &	regex,
		const std::string &	options
	)

inline

Assign a (new) pattern.

Pattern& reflex::Pattern::assign	(	const Opcode *	code,
		const uint8_t *	pred = `NULL`
	)

inline

Assign a (new) pattern.

Pattern& reflex::Pattern::assign	(	FSM	fsm,
		const uint8_t *	pred = `NULL`
	)

inline

Assign a (new) pattern.

Char reflex::Pattern::at ( Location k ) const

inlineprivate

void reflex::Pattern::check_dfa_closure	(	const DFA::State *	state,
		int	nest,
		bool &	peek,
		bool &	prev
	)		const

private

void reflex::Pattern::clear ( )

inline

Clear and delete pattern data.

void reflex::Pattern::compact_dfa ( DFA::State * start )

private

void reflex::Pattern::compile	(	DFA::State *	start,
		Follow &	followpos,
		const Mods	modifiers,
		const Map &	lookahead
	)

private

void reflex::Pattern::compile_list	(	Location	loc,
		Chars &	chars,
		const Mods	modifiers
	)		const

private

void reflex::Pattern::compile_transition	(	DFA::State *	state,
		Follow &	followpos,
		const Mods	modifiers,
		const Map &	lookahead,
		Moves &	moves
	)		const

private

size_t reflex::Pattern::edges ( ) const

inline

Get the number of finite state machine edges (transitions on input characters).

Returns: number of edges or 0 when no finite state machine was constructed by this pattern

float reflex::Pattern::edges_time ( ) const

inline

Get elapsed DFA edges construction time.

bool reflex::Pattern::empty ( ) const

inline

Return true if this pattern is not assigned.

Returns: true if this pattern is not assigned

void reflex::Pattern::encode_dfa ( DFA::State * start )

private

bool reflex::Pattern::eq_at	(	Location	loc,
		const char *	s
	)		const

inlineprivate

virtual void reflex::Pattern::error	(	regex_error_type	code,
		size_t	pos = `0`
	)		const

protectedvirtual

Throw an error.

Parameters

code	error code
pos	optional location of the error in regex string Pattern::rex_

Char reflex::Pattern::escape_at ( Location loc ) const

inlineprivate

Char reflex::Pattern::escapes_at	(	Location	loc,
		const char *	escapes
	)		const

inlineprivate

void reflex::Pattern::export_code ( ) const

private

size_t reflex::Pattern::find_at	(	Location	loc,
		char	c
	)		const

inlineprivate

void reflex::Pattern::flip ( Chars & chars ) const

private

void reflex::Pattern::gen_predict_match ( DFA::State * state )

private

void reflex::Pattern::gen_predict_match_transitions	(	DFA::State *	state,
		std::map< DFA::State *, ORanges< Hash > > &	states
	)

private

void reflex::Pattern::gen_predict_match_transitions	(	size_t	level,
		DFA::State *	state,
		ORanges< Hash > &	labels,
		std::map< DFA::State *, ORanges< Hash > > &	states
	)

private

void reflex::Pattern::gencode_dfa ( const DFA::State * start ) const

private

void reflex::Pattern::gencode_dfa_closure	(	FILE *	fd,
		const DFA::State *	start,
		int	nest,
		bool	peek
	)		const

private

void reflex::Pattern::graph_dfa ( const DFA::State * start ) const

private

void reflex::Pattern::greedy ( Positions & pos ) const

private

static Hash reflex::Pattern::hash	(	Hash	h,
		uint8_t	b
	)

inlinestaticprivate

static Hash reflex::Pattern::hash ( Hash h )

inlinestaticprivate

static uint16_t reflex::Pattern::hash_pos ( const Positions * pos )

inlinestaticprivate

static Char reflex::Pattern::hi_of ( Opcode opcode )

inlinestaticprivate

static Index reflex::Pattern::index_of ( Opcode opcode )

inlinestaticprivate

void reflex::Pattern::init	(	const char *	options,
		const uint8_t *	pred = `NULL`
	)

private

Initialize the pattern at construction.

void reflex::Pattern::init_options ( const char * options )

private

static bool reflex::Pattern::is_meta ( Char c )

inlinestaticprivate

static bool reflex::Pattern::is_modified	(	Mod	mod,
		const Mods	modifiers,
		Location	loc
	)

inlinestaticprivate

static bool reflex::Pattern::is_opcode_goto ( Opcode opcode )

inlinestaticprivate

static bool reflex::Pattern::is_opcode_goto	(	Opcode	opcode,
		unsigned char	c
	)

inlinestaticprivate

static bool reflex::Pattern::is_opcode_halt ( Opcode opcode )

inlinestaticprivate

static bool reflex::Pattern::is_opcode_head ( Opcode opcode )

inlinestaticprivate

static bool reflex::Pattern::is_opcode_long ( Opcode opcode )

inlinestaticprivate

static bool reflex::Pattern::is_opcode_meta ( Opcode opcode )

inlinestaticprivate

static bool reflex::Pattern::is_opcode_redo ( Opcode opcode )

inlinestaticprivate

static bool reflex::Pattern::is_opcode_tail ( Opcode opcode )

inlinestaticprivate

static bool reflex::Pattern::is_opcode_take ( Opcode opcode )

inlinestaticprivate

void reflex::Pattern::lazy	(	const Lazyset &	lazyset,
		Positions &	pos
	)		const

private

void reflex::Pattern::lazy	(	const Lazyset &	lazyset,
		const Positions &	pos,
		Positions &	pos1
	)		const

private

static void reflex::Pattern::lazy_add	(	Lazyset &	s,
		const Lazy &	e
	)

inlinestaticprivate

static void reflex::Pattern::lazy_insert	(	Lazyset &	s1,
		const Lazyset &	s2
	)

inlinestaticprivate

static Char reflex::Pattern::lo_of ( Opcode opcode )

inlinestaticprivate

static Index reflex::Pattern::long_index_of ( Opcode opcode )

inlinestaticprivate

static Lookahead reflex::Pattern::lookahead_of ( Opcode opcode )

inlinestaticprivate

static Char reflex::Pattern::lowercase ( Char c )

inlinestaticprivate

static Char reflex::Pattern::meta_of ( Opcode opcode )

inlinestaticprivate

size_t reflex::Pattern::nodes ( ) const

inline

Get the number of finite state machine nodes (vertices).

Returns: number of nodes or 0 when no finite state machine was constructed by this pattern

float reflex::Pattern::nodes_time ( ) const

inline

Get elapsed DFA vertices construction time.

static Opcode reflex::Pattern::opcode_goto	(	Char	lo,
		Char	hi,
		Index	index
	)

inlinestaticprivate

static Opcode reflex::Pattern::opcode_halt ( )

inlinestaticprivate

static Opcode reflex::Pattern::opcode_head ( Index index )

inlinestaticprivate

static Opcode reflex::Pattern::opcode_long ( Index index )

inlinestaticprivate

static Opcode reflex::Pattern::opcode_redo ( )

inlinestaticprivate

static Opcode reflex::Pattern::opcode_tail ( Index index )

inlinestaticprivate

static Opcode reflex::Pattern::opcode_take ( Index index )

inlinestaticprivate

Pattern& reflex::Pattern::operator= ( const Pattern & pattern )

inline

Assign a (new) pattern.

Pattern& reflex::Pattern::operator= ( const char * regex )

inline

Assign a (new) pattern.

Pattern& reflex::Pattern::operator= ( const std::string & regex )

inline

Assign a (new) pattern.

Pattern& reflex::Pattern::operator= ( const Opcode * code )

inline

Assign a (new) pattern.

Pattern& reflex::Pattern::operator= ( FSM fsm )

inline

Assign a (new) pattern.

const std::string reflex::Pattern::operator[] ( Accept choice ) const

Get subpattern regex of this pattern object or the whole regex with index 0.

Returns: subpattern string or "" when not set

void reflex::Pattern::parse	(	Positions &	startpos,
		Follow &	followpos,
		Mods	modifiers,
		Map &	lookahead
	)

private

void reflex::Pattern::parse1	(	bool	begin,
		Location &	loc,
		Positions &	firstpos,
		Positions &	lastpos,
		bool &	nullable,
		Follow &	followpos,
		Lazy &	lazyidx,
		Lazyset &	lazyset,
		Mods	modifiers,
		Locations &	lookahead,
		Iter &	iter
	)

private

void reflex::Pattern::parse2	(	bool	begin,
		Location &	loc,
		Positions &	firstpos,
		Positions &	lastpos,
		bool &	nullable,
		Follow &	followpos,
		Lazy &	lazyidx,
		Lazyset &	lazyset,
		Mods	modifiers,
		Locations &	lookahead,
		Iter &	iter
	)

private

void reflex::Pattern::parse3	(	bool	begin,
		Location &	loc,
		Positions &	firstpos,
		Positions &	lastpos,
		bool &	nullable,
		Follow &	followpos,
		Lazy &	lazyidx,
		Lazyset &	lazyset,
		Mods	modifiers,
		Locations &	lookahead,
		Iter &	iter
	)

private

void reflex::Pattern::parse4	(	bool	begin,
		Location &	loc,
		Positions &	firstpos,
		Positions &	lastpos,
		bool &	nullable,
		Follow &	followpos,
		Lazy &	lazyidx,
		Lazyset &	lazyset,
		Mods	modifiers,
		Locations &	lookahead,
		Iter &	iter
	)

private

Char reflex::Pattern::parse_esc	(	Location &	loc,
		Chars *	chars = `NULL`
	)		const

private

float reflex::Pattern::parse_time ( ) const

inline

Get elapsed regex parsing and analysis time.

static void reflex::Pattern::pos_add	(	Positions &	s,
		const Position &	e
	)

inlinestaticprivate

static void reflex::Pattern::pos_insert	(	Positions &	s1,
		const Positions &	s2
	)

inlinestaticprivate

void reflex::Pattern::posix	(	size_t	index,
		Chars &	chars
	)		const

private

static bool reflex::Pattern::predict_match	(	const Pred	pmh[],
		const char *	s,
		size_t	n
	)

inlinestatic

Returns true when match is predicted, based on s[0..3..e-1] (e >= s + 4).

static size_t reflex::Pattern::predict_match	(	const Pred	pma[],
		const char *	s
	)

inlinestatic

Returns zero when match is predicted or nonzero shift value, based on s[0..3].

void reflex::Pattern::predict_match_dfa ( DFA::State * start )

private

bool reflex::Pattern::reachable ( Accept choice ) const

inline

Check if subpattern is reachable by a match.

Returns: true if subpattern is reachable

static Char reflex::Pattern::reversecase ( Char c )

inlinestaticprivate

Accept reflex::Pattern::size ( ) const

inline

Get the number of subpatterns of this pattern object.

Returns: number of subpatterns

void reflex::Pattern::transition	(	Moves &	moves,
		Chars &	chars,
		const Positions &	follow
	)		const

private

void reflex::Pattern::trim_anchors	(	Positions &	follow,
		const Position	p
	)		const

private

void reflex::Pattern::trim_lazy ( Positions * pos ) const

private

static void reflex::Pattern::update_modified	(	Mod	mod,
		Mods	modifiers,
		Location	from,
		Location	to
	)

inlinestaticprivate

static Char reflex::Pattern::uppercase ( Char c )

inlinestaticprivate

static bool reflex::Pattern::valid_goto_index ( Index index )

inlinestaticprivate

static bool reflex::Pattern::valid_lookahead_index ( Index index )

inlinestaticprivate

static bool reflex::Pattern::valid_take_index ( Index index )

inlinestaticprivate

size_t reflex::Pattern::words ( ) const

inline

Get the code size in number of words.

Returns: number of words or 0 when no code was generated by this pattern

float reflex::Pattern::words_time ( ) const

inline

Get elapsed code words assembly time.

void reflex::Pattern::write_namespace_close ( FILE * fd ) const

private

void reflex::Pattern::write_namespace_open ( FILE * fd ) const

private

void reflex::Pattern::write_predictor ( FILE * fd ) const

private

Friends And Related Function Documentation

friend class FuzzyMatcher

friend

permit access by the reflex::FuzzyMatcher engine

friend class Matcher

friend

permit access by the reflex::Matcher engine

Member Data Documentation

std::vector<bool> reflex::Pattern::acc_

private

true if subpattern n is accepting (state is reachable)

Pred reflex::Pattern::bit_[256]

private

bitap array

DFA reflex::Pattern::dfa_

private

DFA constructed from regex with subset construction using firstpos/lastpos/followpos.

float reflex::Pattern::ems_

private

ms elapsed time to compile DFA edges

std::vector<Location> reflex::Pattern::end_

private

entries point to the subpattern's ending '|' or '\0'

size_t reflex::Pattern::eno_

private

number of finite state machine edges |E|

FSM reflex::Pattern::fsm_

private

function pointer to FSM code

size_t reflex::Pattern::len_

private

prefix length of pre_[], less or equal to 255

size_t reflex::Pattern::min_

private

patterns after the prefix are at least this long but no more than 8

Index reflex::Pattern::nop_

private

number of opcodes generated

bool reflex::Pattern::one_

private

true if matching one string in pre_[] without meta/anchors

const Opcode* reflex::Pattern::opc_

private

points to the opcode table

Option reflex::Pattern::opt_

private

pattern compiler options

Pred reflex::Pattern::pma_[Const::HASH]

private

predict-match array

Pred reflex::Pattern::pmh_[Const::HASH]

private

predict-match hash array

float reflex::Pattern::pms_

private

ms elapsed time to parse regex

char reflex::Pattern::pre_[256]

private

pattern prefix, shorter or equal to 255 bytes

std::string reflex::Pattern::rex_

private

regular expression string

DFA reflex::Pattern::tfa_

private

tree DFA constructed from strings

float reflex::Pattern::vms_

private

ms elapsed time to compile DFA vertices

size_t reflex::Pattern::vno_

private

number of finite state machine vertices |V|

float reflex::Pattern::wms_

private

ms elapsed time to assemble code words

The documentation for this class was generated from the following file:

pattern.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation