cttl Namespace Reference

---

Detailed Description

Namespace cttl defines publicly visible classes and functions of CTTL library.

Classes
struct	policy_default
	Provides default implementation for CTTL white space policy. More...
class	const_edge
	Implements concept of a logical immutable substring inside user input text. More...
class	edge
	Implements concept of logical mutable substring inside user input text. More...
struct	edge_replace
	Function object, which, if called as a function, replaces underlying text of an edge with the string specified when the function object was constructed. More...
struct	edge_first_insert_go
	Function object, which, if called as a function, inserts substring specified when the function object was constructed, at the offset pointed by the upper boundary of the edge, const_edge::first. More...
struct	edge_first_insert_stay
	Function object, which, if called as a function, inserts string specified when the function object was constructed, at the offset pointed by the upper boundary of the edge, const_edge::first. More...
struct	edge_second_insert_go
	Function object, which, if called as a function, inserts substring specified when the function object was constructed, at the offset pointed by the upper boundary of the edge, const_edge::second. More...
struct	edge_second_insert_stay
	Function object, which, if called as a function, inserts string specified when the function object was constructed, at the offset pointed by the upper boundary of the edge, const_edge::second. More...
class	input
	Template class cttl::input accommodates user input text and maintains offset identity vector. More...
class	node
	Keeps track of a logical position inside user input text. More...
struct	node_insert_go
	Function object, which, if called as a function, inserts substring specified when the function object was constructed, at the offset pointed by the node. More...
struct	node_insert_stay
	Function object, which, if called as a function, inserts substring specified when the function object was constructed, at the offset pointed by the node. More...
class	policy_mapped_space
	This a base class for region-based white space policy classes. More...
struct	policy_space
	Generic version of pre-defined policy. More...
struct	policy_space< flag_follow_space >
	This policy instructs cttl lexer to automatically skip white space characters ht, lf, vt, ff, cr, and space. More...
struct	policy_space< flag_follow_region >
	Makes user-defined regions "invisible" to CTTL lexer. More...
struct	policy_space< flag_follow_space|flag_follow_region >
	This policy instructs CTTL lexer to automatically skip white space characters ht, lf, vt, ff, cr, and space, combined with user-defined regions. More...
struct	policy_space< flag_greedy|flag_follow_space >
	greedy version of white space policy More...
struct	policy_space< flag_greedy >
	greedy version of white space policy More...
struct	policy_space< flag_greedy|flag_follow_region >
	greedy version of user-defined region policy More...
struct	policy_space< flag_greedy|flag_follow_space|flag_follow_region >
	greedy version of the combined policy More...
struct	policy_space< flag_cpp_comments >
	Typical C++ white space, including C and C++ style comments. More...
struct	policy_space< flag_greedy|flag_cpp_comments >
	Greedy version of C++ white space. More...
Functions
template<typename StringT>
const_edge< policy_default, StringT >	operator- (node< StringT > &one_, node< StringT > &another_)
	Constructs cttl::const_edge object from pair of cttl::node objects.
template<typename StringT>
const_edge< policy_default, StringT >	operator+ (node< StringT > &one_, node< StringT > &another_)
	Constructs cttl::const_edge object from pair of cttl::node objects.
template<typename PolicyT, typename StringT>
const_edge< PolicyT, StringT >	new_edge (const_edge< PolicyT, StringT > &other_)
	Constructs new cttl::const_edge object from another edge.
template<typename StringT>
const_edge< policy_default, StringT >	new_edge (input< StringT > &inp_)
	Constructs new edge object pointing to the entire parseable universe.
template<typename StringT>
const_edge< policy_default, StringT >	new_edge (input< StringT > &inp_, size_t lhs_offset_, size_t rhs_offset_)
	Constructs new edge object pointing to the part of the cttl::input specified by the user.
template<typename PolicyT, typename StringT>
bool	operator< (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
	Compares two edges by comparing the underlying text.
template<typename PolicyT, typename StringT>
bool	operator> (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
	Compares two edges by comparing the underlying text.
template<typename PolicyT, typename StringT>
bool	operator>= (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
	Compares two edges by comparing the underlying text.
template<typename PolicyT, typename StringT>
bool	operator<= (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
	Compares two edges by comparing the underlying text.
template<typename PolicyT, typename StringT>
bool	operator== (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
	Compares two edges by comparing the underlying text.
template<typename PolicyT, typename StringT>
bool	operator!= (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
	Compares two edges by comparing the underlying text.
template<typename StringT>
void	string_toupper (StringT &str_)
	Converts string to UPPERCASE.
template<typename StringT>
void	string_tolower (StringT &str_)
	Converts string to lowercase.
template<typename StringT, typename CharT>
void	string_array2string (StringT &str_, CharT *array_[])
	Loads text from array of string literals into STL string provided by the user.
template<typename StringT, typename CharT>
void	string_array2string (StringT &str_, CharT *array_[], CharT delimiter_)
	Loads text from array of string literals into STL string provided by the user.
template<typename StringT, typename CharT>
void	string_array2string (StringT &str_, CharT *array_[], CharT const *delimiter_)
	Loads text from array of string literals into STL string provided by the user.
template<typename StringT>
node< StringT >	new_node (input< StringT > &inp_, size_t offset_)
	Constructs new cttl::node object from cttl::input object.
template<typename StringT>
node< StringT >	new_node (input< StringT > &inp_)
	Constructs new cttl::node object from cttl::input object.
template<typename StringT>
node< StringT >	new_node (node< StringT > &other_)
	Constructs new cttl::node object from another node.
template<typename StringT>
bool	operator== (node< StringT > const &one_, node< StringT > const &another_)
	Compares two nodes.
template<typename StringT>
bool	operator!= (node< StringT > const &one_, node< StringT > const &another_)
	Compares two nodes.
template<typename StringT>
bool	operator> (node< StringT > const &one_, node< StringT > const &another_)
	Compares offsets of two nodes.
template<typename StringT>
bool	operator< (node< StringT > const &one_, node< StringT > const &another_)
	Compares offsets of two nodes.
template<typename StringT>
bool	operator>= (node< StringT > const &one_, node< StringT > const &another_)
	Compares offsets of two nodes.
template<typename StringT>
bool	operator<= (node< StringT > const &one_, node< StringT > const &another_)
	Compares offsets of two nodes.
template<typename StringT>
node< StringT > &	operator++ (node< StringT > &node_)
	Prefix increment operator increments node offset.
template<typename StringT>
node< StringT > &	operator-- (node< StringT > &node_)
	Prefix decrement operator decrements node offset.
xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > >	literal ()
	Implements behavior of literal metaphor inside CTTL grammar expression.
xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > >	literal (CTTL_STD_CHAR const *text_begin_, CTTL_STD_CHAR const *text_end_)
	Implements behavior of literal metaphor inside CTTL grammar expression.
xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > >	literal (CTTL_STD_STRING const &text_begin_, CTTL_STD_STRING const &text_end_)
	Implements behavior of literal metaphor inside CTTL grammar expression.
xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_ref_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_ref_end< CTTL_STD_STRING > > > >	literal (CTTL_STD_STRING const *text_begin_, CTTL_STD_STRING const *text_end_)
	Implements behavior of literal metaphor inside CTTL grammar expression.
xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > >	wchar_literal ()
	Implements behavior of wide character literal metaphor inside CTTL grammar expression.
xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > >	wchar_literal (CTTL_STD_WCHAR const *text_begin_, CTTL_STD_WCHAR const *text_end_)
	Implements behavior of wide character literal metaphor inside CTTL grammar expression.
xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > >	wchar_literal (CTTL_STD_WSTRING const &text_begin_, CTTL_STD_WSTRING const &text_end_)
	Implements behavior of wide character literal metaphor inside CTTL grammar expression.
xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_ref_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_ref_end< CTTL_STD_WSTRING > > > >	wchar_literal (CTTL_STD_WSTRING const *text_begin_, CTTL_STD_WSTRING const *text_end_)
	Implements behavior of wide character literal metaphor inside CTTL grammar expression.
template<typename ExprT>
xtl_wrap< xtl_entity< xtl_wrap< ExprT > >>	entity (xtl_wrap< ExprT > const &expr_)
	Helper function to create implemention object for entity expression adaptor which filters successful result of grammar evaluation based on non-empty match.
universe_T	entity ()
	Helper function to create implemention object for entity lexeme.
template<typename ExprT>
xtl_wrap< xtl_opunarbang< xtl_wrap< ExprT > >>	operator! (xtl_wrap< ExprT > const &expr_)
	Overloads unary search operator.
template<typename ExprT>
xtl_wrap< xtl_opunarstar< xtl_wrap< ExprT > >>	operator * (xtl_wrap< ExprT > const &expr_)
	Overloads unary Kleene star operator.
template<typename Left_exprT>
xtl_wrap< xtl_opunarstar< xtl_wrap< Left_exprT > >>	operator * (xtl_wrap< Left_exprT > const &lhs_expr_, int upper_limit_)
	Overloads binary Kleene star operator.
template<typename ExprT>
xtl_wrap< xtl_opunarplus< xtl_wrap< ExprT > >>	operator+ (xtl_wrap< ExprT > const &expr_)
	Overloads unary Kleeene plus operator.
template<typename Left_exprT>
xtl_wrap< xtl_opunarplus< xtl_wrap< Left_exprT > >>	operator+ (xtl_wrap< Left_exprT > const &lhs_expr_, int upper_limit_)
	Overloads binary Kleene plus operator.
template<typename Left_exprT>
xtl_wrap< xtl_opunarplus< xtl_wrap< Left_exprT > >>	operator+ (xtl_wrap< Left_exprT > const &lhs_expr_, std::pair< int, int > limits_)
	Overloads binary greedy Kleene plus operator.
template<typename ExprT>
xtl_wrap< xtl_opunarminus< xtl_wrap< ExprT > >>	operator- (xtl_wrap< ExprT > const &expr_)
	Overloads unary logical not operator.
template<typename Left_exprT, typename Right_exprT>
xtl_wrap< xtl_opbinplus< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >>	operator+ (xtl_wrap< Left_exprT > const &lhs_expr_, xtl_wrap< Right_exprT > const &rhs_expr_)
	Overloads binary sequence operator.
template<typename Left_exprT, typename Right_exprT>
xtl_wrap< xtl_opbinpipe< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >>	operator| (xtl_wrap< Left_exprT > const &lhs_expr_, xtl_wrap< Right_exprT > const &rhs_expr_)
	Overloads binary set union operator.
template<typename Left_exprT, typename Right_exprT>
xtl_wrap< xtl_opbin2pipe< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >>	operator|| (xtl_wrap< Left_exprT > const &lhs_expr_, xtl_wrap< Right_exprT > const &rhs_expr_)
	Overloads binary POSIX union operator.
template<typename Left_exprT, typename Right_exprT>
xtl_wrap< xtl_opbinconcat< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >>	operator^ (xtl_wrap< Left_exprT > const &lhs_expr_, xtl_wrap< Right_exprT > const &rhs_expr_)
	Overloads binary concatenation operator.
template<typename Left_exprT, typename Right_exprT>
xtl_wrap< xtl_opbinminus< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >>	operator- (xtl_wrap< Left_exprT > const &lhs_expr_, xtl_wrap< Right_exprT > const &rhs_expr_)
	Overloads binary set complement operator.
template<typename Left_exprT, typename Right_exprT>
xtl_wrap< xtl_opbinand< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >>	operator & (xtl_wrap< Left_exprT > const &lhs_expr_, xtl_wrap< Right_exprT > const &rhs_expr_)
	Overloads binary set intersection operator.
template<typename LeftT, typename MiddleT, typename RightT>
xtl_wrap< xtl_quote_generic< xtl_wrap< LeftT >, xtl_wrap< MiddleT >, xtl_wrap< RightT > >>	quote (xtl_wrap< LeftT > const &left_, xtl_wrap< MiddleT > const &middle_, xtl_wrap< RightT > const &right_)
	CTTL quote function generating implementation for generic quotes.
template<typename MiddleT, typename RightT>
xtl_wrap< xtl_quote_bool< xtl_wrap< MiddleT >, xtl_wrap< RightT > >>	quote (bool, xtl_wrap< MiddleT > const &middle_, xtl_wrap< RightT > const &right_)
	CTTL quote function generating implementation for asymmetric quotes.
template<typename MiddleT>
xtl_wrap< xtl_quote_generic< xtl_wrap< xtl_char< CTTL_STD_CHAR > >, xtl_wrap< MiddleT >, xtl_wrap< xtl_char< CTTL_STD_CHAR > > >>	quote (CTTL_STD_CHAR left_, xtl_wrap< MiddleT > const &middle_, CTTL_STD_CHAR right_)
	CTTL quote function generating implementation for single-character quotes.
template<typename MiddleT>
xtl_wrap< xtl_quote_generic< xtl_wrap< xtl_char< CTTL_STD_WCHAR > >, xtl_wrap< MiddleT >, xtl_wrap< xtl_char< CTTL_STD_WCHAR > > >>	wchar_quote (CTTL_STD_WCHAR left_, xtl_wrap< MiddleT > const &middle_, CTTL_STD_WCHAR right_)
	CTTL quote function generating implementation for single wide character quotes.
template<typename MiddleT>
xtl_wrap< xtl_quote_ansi_single_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR >>	ansi_single_quote (xtl_wrap< MiddleT > const &middle_)
	CTTL quote function generating implementation for ANSI single quotes.
ansi_single_quote_T	ansi_single_quote ()
	CTTL quote function generating implementation for ANSI single quotes.
template<typename MiddleT>
xtl_wrap< xtl_quote_ansi_double_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > >	ansi_double_quote (xtl_wrap< MiddleT > const &middle_)
	CTTL quote function generating implementation for ANSI double quotes.
ansi_double_quote_T	ansi_double_quote ()
	CTTL quote function generating implementation for ANSI double quotes.
template<typename MiddleT>
xtl_wrap< xtl_quote_c_single_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR >>	c_single_quote (xtl_wrap< MiddleT > const &middle_)
	CTTL quote function generating implementation for C single quotes.
c_single_quote_T	c_single_quote ()
	CTTL quote function generating implementation for C single quotes.
template<typename MiddleT>
xtl_wrap< xtl_quote_c_double_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > >	c_double_quote (xtl_wrap< MiddleT > const &middle_)
	CTTL quote function generating implementation for C double quotes.
c_double_quote_T	c_double_quote ()
	CTTL quote function generating implementation for C double quotes.
template<typename MiddleT>
xtl_wrap< xtl_quote_ansi_single_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR >>	wchar_ansi_single_quote (xtl_wrap< MiddleT > const &middle_)
	CTTL quote function generating implementation for wide CTTL_STD_CHAR ANSI single quotes.
wchar_ansi_single_quote_T	wchar_ansi_single_quote ()
	CTTL quote function generating implementation for wide CTTL_STD_CHAR ANSI single quotes.
template<typename MiddleT>
xtl_wrap< xtl_quote_ansi_double_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > >	wchar_ansi_double_quote (xtl_wrap< MiddleT > const &middle_)
	CTTL quote function generating implementation for wide CTTL_STD_CHAR ANSI double quotes.
wchar_ansi_double_quote_T	wchar_ansi_double_quote ()
	CTTL quote function generating implementation for wide CTTL_STD_CHAR ANSI double quotes.
template<typename MiddleT>
xtl_wrap< xtl_quote_c_single_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR >>	wchar_c_single_quote (xtl_wrap< MiddleT > const &middle_)
	CTTL quote function generating implementation for wide CTTL_STD_CHAR C single quotes.
wchar_c_single_quote_T	wchar_c_single_quote ()
	CTTL quote function generating implementation for wide CTTL_STD_CHAR C single quotes.
template<typename MiddleT>
xtl_wrap< xtl_quote_c_double_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > >	wchar_c_double_quote (xtl_wrap< MiddleT > const &middle_)
	CTTL quote function generating implementation for wide CTTL_STD_CHAR C double quotes.
wchar_c_double_quote_T	wchar_c_double_quote ()
	CTTL quote function generating implementation for wide CTTL_STD_CHAR C double quotes.
template<typename Static_predicateT>
xtl_wrap< xtl_predicate< Static_predicateT > >	rule (const Static_predicateT pred_)
	CTTL function adaptor, generating implementation for static grammar rule adaptor.
template<typename ObjectT, typename PredicateT>
xtl_wrap< xtl_member_predicate< ObjectT, PredicateT > >	rule (ObjectT &object_ref_, PredicateT pred_)
	CTTL function adaptor, generating implementation for member function adaptor.
xtl_wrap< xtl_char_symbol >	symbol ()
	CTTL lexeme function generating implementation for symbol( ) expression.
xtl_wrap< xtl_position_bof >	begin ()
	CTTL lexeme function generating implementation for begin( ) expression.
xtl_wrap< xtl_bool< false > >	symbol (bool bool_)
	CTTL lexeme function generating implementation for symbol(true) and symbol(false) expressions.
xtl_wrap< xtl_bool< true > >	begin (bool bool_)
	CTTL lexeme function generating implementation for begin(true) and begin(false) expressions.
xtl_wrap< xtl_char< CTTL_STD_CHAR > >	symbol (CTTL_STD_CHAR char_)
	CTTL lexeme function generating implementation for symbol(CTTL_STD_CHAR) expression.
xtl_wrap< xtl_char< CTTL_STD_WCHAR > >	symbol (CTTL_STD_WCHAR char_)
	CTTL lexeme function generating implementation for symbol(CTTL_STD_WCHAR) expression.
xtl_wrap< xtl_char< CTTL_STD_CHAR > >	symbol (int char_)
	CTTL lexeme function generating implementation for symbol(int) expression.
xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > >	begin (CTTL_STD_CHAR char_)
	CTTL lexeme function generating implementation for begin(CTTL_STD_CHAR) expression.
xtl_wrap< xtl_char_begin< CTTL_STD_WCHAR > >	begin (CTTL_STD_WCHAR char_)
	CTTL lexeme function generating implementation for begin(CTTL_STD_WCHAR) expression.
xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > >	begin (int char_)
	CTTL lexeme function generating implementation for begin(int) expression.
xtl_wrap< xtl_char_end< CTTL_STD_CHAR > >	end (CTTL_STD_CHAR char_)
	CTTL lexeme function generating implementation for end(CTTL_STD_CHAR) expression.
xtl_wrap< xtl_char_end< CTTL_STD_WCHAR > >	end (CTTL_STD_WCHAR char_)
	CTTL lexeme function generating implementation for end(CTTL_STD_WCHAR) expression.
xtl_wrap< xtl_char_end< CTTL_STD_CHAR > >	end (int char_)
	CTTL lexeme function generating implementation for end(int) expression.
xtl_wrap< xtl_keyword< CTTL_STD_STRING > >	begin (std::set< CTTL_STD_STRING > const &keywords_)
	CTTL lexeme function generating implementation for begin(std::set<std::string>&) expression.
xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >	begin (std::set< CTTL_STD_WSTRING > const &keywords_)
	CTTL lexeme function generating implementation for begin(std::set<std::wstring>&) expression.
xtl_wrap< xtl_iswhat_begin >	begin (iswhat_T iswhat_)
	CTTL lexeme function generating implementation for begin(is...) expression.
xtl_wrap< xtl_iswhat_end >	end (iswhat_T iswhat_)
	CTTL lexeme function generating implementation for end(is...) expression.
xtl_wrap< xtl_iswhat_first >	first (iswhat_T iswhat_)
	CTTL lexeme function generating implementation for first(is...) expression.
xtl_wrap< xtl_iswhat_entity >	entity (iswhat_T iswhat_)
	CTTL lexeme function generating implementation for entity(is...) expression.
xtl_wrap< xtl_iswwhat_begin >	begin (iswwhat_T iswwhat_)
	CTTL lexeme function generating implementation for begin(isw...) expression.
xtl_wrap< xtl_iswwhat_end >	end (iswwhat_T iswwhat_)
	CTTL lexeme function generating implementation for end(isw...) expression.
xtl_wrap< xtl_iswwhat_first >	first (iswwhat_T iswwhat_)
	CTTL lexeme function generating implementation for first(isw...) expression.
xtl_wrap< xtl_iswwhat_entity >	entity (iswwhat_T iswwhat_)
	CTTL lexeme function generating implementation for entity(isw...) expression.
xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >	begin (CTTL_STD_CHAR const *any_text_)
	CTTL lexeme function generating implementation for begin(CTTL_STD_CHAR*) expression.
xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >	begin (CTTL_STD_WCHAR const *any_text_)
	CTTL lexeme function generating implementation for begin(CTTL_STD_WCHAR*) expression.
xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >	begin (CTTL_STD_STRING const &any_text_)
	CTTL lexeme function generating implementation for begin(string&) expression.
xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >	begin (CTTL_STD_WSTRING const &any_text_)
	CTTL lexeme function generating implementation for begin(wstring&) expression.
xtl_wrap< xtl_text_ref_begin< CTTL_STD_STRING > >	begin (CTTL_STD_STRING const *any_text_)
	CTTL lexeme function generating implementation for begin(string*) expression.
xtl_wrap< xtl_text_ref_begin< CTTL_STD_WSTRING > >	begin (CTTL_STD_WSTRING const *any_text_)
	CTTL lexeme function generating implementation for begin(wstring*) expression.
xtl_wrap< xtl_text_end< CTTL_STD_STRING > >	end (CTTL_STD_CHAR const *any_text_)
	CTTL lexeme function generating implementation for end(CTTL_STD_CHAR*) expression.
xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > >	end (CTTL_STD_WCHAR const *any_text_)
	CTTL lexeme function generating implementation for end(CTTL_STD_WCHAR*) expression.
xtl_wrap< xtl_text_end< CTTL_STD_STRING > >	end (CTTL_STD_STRING const &any_text_)
	CTTL lexeme function generating implementation for end(string&) expression.
xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > >	end (CTTL_STD_WSTRING const &any_text_)
	CTTL lexeme function generating implementation for end(wstring&) expression.
xtl_wrap< xtl_text_ref_end< CTTL_STD_STRING > >	end (CTTL_STD_STRING const *any_text_)
	CTTL lexeme function generating implementation for end(string*) expression.
xtl_wrap< xtl_text_ref_end< CTTL_STD_WSTRING > >	end (CTTL_STD_WSTRING const *any_text_)
	CTTL lexeme function generating implementation for end(wstring*) expression.
xtl_wrap< xtl_text_first< CTTL_STD_STRING > >	first (CTTL_STD_CHAR const *any_text_)
	CTTL lexeme function generating implementation for first(CTTL_STD_CHAR*) expression.
xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > >	first (CTTL_STD_WCHAR const *any_text_)
	CTTL lexeme function generating implementation for first(CTTL_STD_WCHAR*) expression.
xtl_wrap< xtl_text_first< CTTL_STD_STRING > >	first (CTTL_STD_STRING const &any_text_)
	CTTL lexeme function generating implementation for first(string&) expression.
xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > >	first (CTTL_STD_WSTRING const &any_text_)
	CTTL lexeme function generating implementation for first(wstring&) expression.
xtl_wrap< xtl_text_ref_first< CTTL_STD_STRING > >	first (CTTL_STD_STRING const *any_text_)
	CTTL lexeme function generating implementation for first(string*) expression.
xtl_wrap< xtl_text_ref_first< CTTL_STD_WSTRING > >	first (CTTL_STD_WSTRING const *any_text_)
	CTTL lexeme function generating implementation for first(wstring*) expression.
xtl_wrap< xtl_char< CTTL_STD_CHAR > >	entity (CTTL_STD_CHAR char_)
	CTTL lexeme function generating implementation for entity(CTTL_STD_CHAR) expression.
xtl_wrap< xtl_char< CTTL_STD_WCHAR > >	entity (CTTL_STD_WCHAR char_)
	CTTL lexeme function generating implementation for entity(CTTL_STD_WCHAR) expression.
xtl_wrap< xtl_char< CTTL_STD_CHAR > >	entity (int char_)
	CTTL lexeme function generating implementation for entity(int) expression.
xtl_wrap< xtl_text_entity< CTTL_STD_STRING > >	entity (CTTL_STD_CHAR const *any_text_)
	CTTL lexeme function generating implementation for entity(CTTL_STD_CHAR*) expression.
xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > >	entity (CTTL_STD_WCHAR const *any_text_)
	CTTL lexeme function generating implementation for entity(CTTL_STD_WCHAR*) expression.
xtl_wrap< xtl_text_entity< CTTL_STD_STRING > >	entity (CTTL_STD_STRING const &any_text_)
	CTTL lexeme function generating implementation for entity(string&) expression.
xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > >	entity (CTTL_STD_WSTRING const &any_text_)
	CTTL lexeme function generating implementation for entity(wstring&) expression.
xtl_wrap< xtl_text_ref_entity< CTTL_STD_STRING > >	entity (CTTL_STD_STRING const *any_text_)
	CTTL lexeme function generating implementation for entity(string*) expression.
xtl_wrap< xtl_text_ref_entity< CTTL_STD_WSTRING > >	entity (CTTL_STD_WSTRING const *any_text_)
	CTTL lexeme function generating implementation for entity(wstring*) expression.
xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >	symbol (CTTL_STD_CHAR const *any_text_)
	CTTL lexeme function generating implementation for symbol(CTTL_STD_CHAR*) expression.
xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >	symbol (CTTL_STD_WCHAR const *any_text_)
	CTTL lexeme function generating implementation for symbol(CTTL_STD_WCHAR*) expression.
xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >	symbol (CTTL_STD_STRING const &any_text_)
	CTTL lexeme function generating implementation for symbol(string&) expression.
xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >	symbol (CTTL_STD_WSTRING const &any_text_)
	CTTL lexeme function generating implementation for symbol(wstring&) expression.
xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >	symbol (CTTL_STD_STRING const *any_text_)
	CTTL lexeme function generating implementation for symbol(string*) expression.
xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >	symbol (CTTL_STD_WSTRING const *any_text_)
	CTTL lexeme function generating implementation for symbol(wstring*) expression.
xtl_wrap< xtl_position_eof >	end ()
	CTTL lexeme function generating implementation for end( ) expression.
Variables
const int	flag_follow_space = 1
	Suggests that the specialization understands conventional white space.
const int	flag_follow_region = 2
	Suggests that the specialization understands user-defined regions.
const int	flag_greedy = 4
	Suggests that the specialization implements greedy evaluation algorithm.
const int	flag_cpp_comments = 8
	Suggests that the specialization understands C/C++ comments.
const int	flag_follow_either = flag_follow_space | flag_follow_region
	Convinience flag.

---

Function Documentation

ansi_double_quote_T ansi_double_quote (   )  [inline]

CTTL quote function generating implementation for ANSI double quotes. Returns: Instance of C++ implementation class for CTTL grammar expression describing ANSI double quote. Remarks: This version of overloaded function assumes that any content inside the quotes is acceptable, including the empty string. Definition at line 348 of file xtl_quote_sym.h. References cttl_impl::ansi_double_quote_T.

xtl_wrap< xtl_quote_ansi_double_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > > ansi_double_quote (  xtl_wrap< MiddleT > const &  middle_  )  [inline]

CTTL quote function generating implementation for ANSI double quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. Parameters: middle_  constant reference to CTTL grammar expression describing interior clause of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing ANSI double quote. Definition at line 328 of file xtl_quote_sym.h. References CTTL_STD_CHAR.

ansi_single_quote_T ansi_single_quote (   )  [inline]

CTTL quote function generating implementation for ANSI single quotes. Returns: Instance of C++ implementation class for CTTL grammar expression describing ANSI single quote. Remarks: This version of overloaded function assumes that any content inside the quotes is acceptable, including the empty string. Definition at line 301 of file xtl_quote_sym.h. References cttl_impl::ansi_single_quote_T.

xtl_wrap< xtl_quote_ansi_single_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR >> ansi_single_quote (  xtl_wrap< MiddleT > const &  middle_  )  [inline]

CTTL quote function generating implementation for ANSI single quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. Parameters: middle_  constant reference to CTTL grammar expression describing interior clause of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing ANSI single quote. Definition at line 281 of file xtl_quote_sym.h. References CTTL_STD_CHAR.

xtl_wrap< xtl_text_ref_begin< CTTL_STD_WSTRING > > begin (  CTTL_STD_WSTRING const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for begin(wstring*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 636 of file xtl_sym.h.

xtl_wrap< xtl_text_ref_begin< CTTL_STD_STRING > > begin (  CTTL_STD_STRING const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for begin(string*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 617 of file xtl_sym.h.

xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > > begin (  CTTL_STD_WSTRING const &  any_text_  )  [inline]

CTTL lexeme function generating implementation for begin(wstring&) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 598 of file xtl_sym.h.

xtl_wrap< xtl_text_begin< CTTL_STD_STRING > > begin (  CTTL_STD_STRING const &  any_text_  )  [inline]

CTTL lexeme function generating implementation for begin(string&) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 579 of file xtl_sym.h.

xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > > begin (  CTTL_STD_WCHAR const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for begin(CTTL_STD_WCHAR*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 560 of file xtl_sym.h.

xtl_wrap< xtl_text_begin< CTTL_STD_STRING > > begin (  CTTL_STD_CHAR const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for begin(CTTL_STD_CHAR*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 541 of file xtl_sym.h.

xtl_wrap< xtl_iswwhat_begin > begin (  iswwhat_T  iswwhat_  )  [inline]

CTTL lexeme function generating implementation for begin(isw...) expression. Parameters: iswwhat_  address of C wide character classification routine. Returns: Instance of C++ lexeme implementation class. Definition at line 463 of file xtl_sym.h.

xtl_wrap< xtl_iswhat_begin > begin (  iswhat_T  iswhat_  )  [inline]

CTTL lexeme function generating implementation for begin(is...) expression. Parameters: iswhat_  address of C character classification routine. Returns: Instance of C++ lexeme implementation class. Definition at line 385 of file xtl_sym.h.

xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > > begin (  std::set< CTTL_STD_WSTRING > const &  keywords_  )  [inline]

CTTL lexeme function generating implementation for begin(std::set<std::wstring>&) expression. Parameters: keywords_  reference to the std::set<std::wstring>& object. Returns: Instance of C++ lexeme implementation class. Definition at line 365 of file xtl_sym.h.

xtl_wrap< xtl_keyword< CTTL_STD_STRING > > begin (  std::set< CTTL_STD_STRING > const &  keywords_  )  [inline]

CTTL lexeme function generating implementation for begin(std::set<std::string>&) expression. Parameters: keywords_  reference to the std::set<std::string>& object. Returns: Instance of C++ lexeme implementation class. Definition at line 347 of file xtl_sym.h.

xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > > begin (  int  char_  )  [inline]

CTTL lexeme function generating implementation for begin(int) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 273 of file xtl_sym.h. References CTTL_STD_CHAR.

xtl_wrap< xtl_char_begin< CTTL_STD_WCHAR > > begin (  CTTL_STD_WCHAR  char_  )  [inline]

CTTL lexeme function generating implementation for begin(CTTL_STD_WCHAR) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 255 of file xtl_sym.h.

xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > > begin (  CTTL_STD_CHAR  char_  )  [inline]

CTTL lexeme function generating implementation for begin(CTTL_STD_CHAR) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 237 of file xtl_sym.h.

xtl_wrap< xtl_bool< true > > begin (  bool  bool_  )  [inline]

CTTL lexeme function generating implementation for begin(true) and begin(false) expressions. Parameters: bool_  boolean flag specifying type of the lexeme. Returns: Instance of C++ lexeme implementation class. Definition at line 165 of file xtl_sym.h.

xtl_wrap< xtl_position_bof > begin (   )  [inline]

CTTL lexeme function generating implementation for begin( ) expression. Returns: Instance of C++ lexeme implementation class. Definition at line 128 of file xtl_sym.h. Referenced by literal(), and wchar_literal().

c_double_quote_T c_double_quote (   )  [inline]

CTTL quote function generating implementation for C double quotes. Returns: Instance of C++ implementation class for CTTL grammar expression describing C double quote. Remarks: This version of overloaded function assumes that any content inside the quotes is acceptable, including the empty string. Definition at line 446 of file xtl_quote_sym.h. References cttl_impl::c_double_quote_T.

xtl_wrap< xtl_quote_c_double_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > > c_double_quote (  xtl_wrap< MiddleT > const &  middle_  )  [inline]

CTTL quote function generating implementation for C double quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. Parameters: middle_  constant reference to CTTL grammar expression describing interior clause of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing C double quote. Definition at line 426 of file xtl_quote_sym.h. References CTTL_STD_CHAR.

c_single_quote_T c_single_quote (   )  [inline]

CTTL quote function generating implementation for C single quotes. Returns: Instance of C++ implementation class for CTTL grammar expression describing C single quotes quote. Remarks: This version of overloaded function assumes that any content inside the quotes is acceptable, including the empty string. Definition at line 398 of file xtl_quote_sym.h. References cttl_impl::c_single_quote_T.

xtl_wrap< xtl_quote_c_single_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR >> c_single_quote (  xtl_wrap< MiddleT > const &  middle_  )  [inline]

CTTL quote function generating implementation for C single quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. Parameters: middle_  constant reference to CTTL grammar expression describing interior clause of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing C single quotes quote. Definition at line 378 of file xtl_quote_sym.h. References CTTL_STD_CHAR.

xtl_wrap< xtl_position_eof > end (   )  [inline]

CTTL lexeme function generating implementation for end( ) expression. Returns: Instance of C++ lexeme implementation class. Definition at line 1175 of file xtl_sym.h. Referenced by entity(), literal(), and wchar_literal().

xtl_wrap< xtl_text_ref_end< CTTL_STD_WSTRING > > end (  CTTL_STD_WSTRING const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for end(wstring*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 752 of file xtl_sym.h.

xtl_wrap< xtl_text_ref_end< CTTL_STD_STRING > > end (  CTTL_STD_STRING const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for end(string*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 733 of file xtl_sym.h.

xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > end (  CTTL_STD_WSTRING const &  any_text_  )  [inline]

CTTL lexeme function generating implementation for end(wstring&) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 714 of file xtl_sym.h.

xtl_wrap< xtl_text_end< CTTL_STD_STRING > > end (  CTTL_STD_STRING const &  any_text_  )  [inline]

CTTL lexeme function generating implementation for end(string&) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 695 of file xtl_sym.h.

xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > end (  CTTL_STD_WCHAR const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for end(CTTL_STD_WCHAR*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 676 of file xtl_sym.h.

xtl_wrap< xtl_text_end< CTTL_STD_STRING > > end (  CTTL_STD_CHAR const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for end(CTTL_STD_CHAR*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 657 of file xtl_sym.h.

xtl_wrap< xtl_iswwhat_end > end (  iswwhat_T  iswwhat_  )  [inline]

CTTL lexeme function generating implementation for end(isw...) expression. Parameters: iswwhat_  address of C wide character classification routine. Returns: Instance of C++ lexeme implementation class. Definition at line 482 of file xtl_sym.h.

xtl_wrap< xtl_iswhat_end > end (  iswhat_T  iswhat_  )  [inline]

CTTL lexeme function generating implementation for end(is...) expression. Parameters: iswhat_  address of C character classification routine. Returns: Instance of C++ lexeme implementation class. Definition at line 404 of file xtl_sym.h.

xtl_wrap< xtl_char_end< CTTL_STD_CHAR > > end (  int  char_  )  [inline]

CTTL lexeme function generating implementation for end(int) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 328 of file xtl_sym.h. References CTTL_STD_CHAR.

xtl_wrap< xtl_char_end< CTTL_STD_WCHAR > > end (  CTTL_STD_WCHAR  char_  )  [inline]

CTTL lexeme function generating implementation for end(CTTL_STD_WCHAR) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 310 of file xtl_sym.h.

xtl_wrap< xtl_char_end< CTTL_STD_CHAR > > end (  CTTL_STD_CHAR  char_  )  [inline]

CTTL lexeme function generating implementation for end(CTTL_STD_CHAR) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 292 of file xtl_sym.h.

xtl_wrap< xtl_text_ref_entity< CTTL_STD_WSTRING > > entity (  CTTL_STD_WSTRING const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for entity(wstring*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 1041 of file xtl_sym.h.

xtl_wrap< xtl_text_ref_entity< CTTL_STD_STRING > > entity (  CTTL_STD_STRING const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for entity(string*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 1022 of file xtl_sym.h.

xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > > entity (  CTTL_STD_WSTRING const &  any_text_  )  [inline]

CTTL lexeme function generating implementation for entity(wstring&) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 1003 of file xtl_sym.h.

xtl_wrap< xtl_text_entity< CTTL_STD_STRING > > entity (  CTTL_STD_STRING const &  any_text_  )  [inline]

CTTL lexeme function generating implementation for entity(string&) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 984 of file xtl_sym.h.

xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > > entity (  CTTL_STD_WCHAR const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for entity(CTTL_STD_WCHAR*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 965 of file xtl_sym.h.

xtl_wrap< xtl_text_entity< CTTL_STD_STRING > > entity (  CTTL_STD_CHAR const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for entity(CTTL_STD_CHAR*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 946 of file xtl_sym.h.

xtl_wrap< xtl_char< CTTL_STD_CHAR > > entity (  int  char_  )  [inline]

CTTL lexeme function generating implementation for entity(int) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 926 of file xtl_sym.h. References CTTL_STD_CHAR.

xtl_wrap< xtl_char< CTTL_STD_WCHAR > > entity (  CTTL_STD_WCHAR  char_  )  [inline]

CTTL lexeme function generating implementation for entity(CTTL_STD_WCHAR) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 907 of file xtl_sym.h.

xtl_wrap< xtl_char< CTTL_STD_CHAR > > entity (  CTTL_STD_CHAR  char_  )  [inline]

CTTL lexeme function generating implementation for entity(CTTL_STD_CHAR) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 888 of file xtl_sym.h.

xtl_wrap< xtl_iswwhat_entity > entity (  iswwhat_T  iswwhat_  )  [inline]

CTTL lexeme function generating implementation for entity(isw...) expression. Parameters: iswwhat_  address of C wide character classification routine. Returns: Instance of C++ lexeme implementation class. Definition at line 520 of file xtl_sym.h.

xtl_wrap< xtl_iswhat_entity > entity (  iswhat_T  iswhat_  )  [inline]

CTTL lexeme function generating implementation for entity(is...) expression. Parameters: iswhat_  address of C character classification routine. Returns: Instance of C++ lexeme implementation class. Definition at line 442 of file xtl_sym.h.

universe_T entity (   )  [inline]

Helper function to create implemention object for entity lexeme. Returns: Instance of C++ implementation class that matches current universe. Definition at line 334 of file xtl_metaphor.h. References end(), cttl_impl::relaxed_bool_T, and cttl_impl::universe_T.

xtl_wrap< xtl_entity< xtl_wrap< ExprT > >> entity (  xtl_wrap< ExprT > const &  expr_  )

Helper function to create implemention object for entity expression adaptor which filters successful result of grammar evaluation based on non-empty match. ExprT Template parameter specifying type of grammar expression, which is determined by the C++ compiler at compile time. Parameters: expr_  constant reference to C++ object representing CTTL grammar expression. Returns: Instance of C++ implementation class for entity adaptor. Definition at line 313 of file xtl_metaphor.h.

xtl_wrap< xtl_text_ref_first< CTTL_STD_WSTRING > > first (  CTTL_STD_WSTRING const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for first(wstring*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 867 of file xtl_sym.h.

xtl_wrap< xtl_text_ref_first< CTTL_STD_STRING > > first (  CTTL_STD_STRING const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for first(string*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 848 of file xtl_sym.h.

xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > > first (  CTTL_STD_WSTRING const &  any_text_  )  [inline]

CTTL lexeme function generating implementation for first(wstring&) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 829 of file xtl_sym.h.

xtl_wrap< xtl_text_first< CTTL_STD_STRING > > first (  CTTL_STD_STRING const &  any_text_  )  [inline]

CTTL lexeme function generating implementation for first(string&) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 810 of file xtl_sym.h.

xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > > first (  CTTL_STD_WCHAR const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for first(CTTL_STD_WCHAR*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 791 of file xtl_sym.h.

xtl_wrap< xtl_text_first< CTTL_STD_STRING > > first (  CTTL_STD_CHAR const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for first(CTTL_STD_CHAR*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 772 of file xtl_sym.h.

xtl_wrap< xtl_iswwhat_first > first (  iswwhat_T  iswwhat_  )  [inline]

CTTL lexeme function generating implementation for first(isw...) expression. Parameters: iswwhat_  address of C wide character classification routine. Returns: Instance of C++ lexeme implementation class. Definition at line 501 of file xtl_sym.h.

xtl_wrap< xtl_iswhat_first > first (  iswhat_T  iswhat_  )  [inline]

CTTL lexeme function generating implementation for first(is...) expression. Parameters: iswhat_  address of C character classification routine. Returns: Instance of C++ lexeme implementation class. Definition at line 423 of file xtl_sym.h. Referenced by const_edge::const_edge(), const_edge::length(), const_edge::operator=(), const_edge::parent(), const_edge::pop(), const_edge::push(), const_edge::region_difference(), const_edge::region_erase(), const_edge::region_insert(), const_edge::text(), const_edge::text_tolower(), and const_edge::text_toupper().

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_ref_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_ref_end< CTTL_STD_STRING > > > > literal (  CTTL_STD_STRING const *  text_begin_, CTTL_STD_STRING const *  text_end_ )  [inline]

Implements behavior of literal metaphor inside CTTL grammar expression. Parameters: text_begin_  address of character entity string specifying upper boundary of the literal. text_end_  address of character entity string specifying lower boundary of the literal. Returns: Instance of C++ implementation class for grammar expression begin( text_begin_ ) ^ end( text_end_ ) Precondition: This function generates reference-based implementation. Therefore, strings pointed by text_begin_ and text_end_ should stay in scope while literal is in use. Definition at line 174 of file xtl_metaphor.h. References begin(), and end().

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > > literal (  CTTL_STD_STRING const &  text_begin_, CTTL_STD_STRING const &  text_end_ )  [inline]

Implements behavior of literal metaphor inside CTTL grammar expression. Parameters: text_begin_  character entity specifying upper boundary of the literal. text_end_  character entity specifying lower boundary of the literal. Returns: Instance of C++ implementation class for grammar expression begin( text_begin_ ) ^ end( text_end_ ) Definition at line 143 of file xtl_metaphor.h. References begin(), and end().

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > > literal (  CTTL_STD_CHAR const *  text_begin_, CTTL_STD_CHAR const *  text_end_ )  [inline]

Implements behavior of literal metaphor inside CTTL grammar expression. Parameters: text_begin_  character entity specifying upper boundary of the literal. text_end_  character entity specifying lower boundary of the literal. Returns: Instance of C++ implementation class for grammar expression begin( text_begin_ ) ^ end( text_end_ ) Definition at line 115 of file xtl_metaphor.h. References begin(), and end().

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > > literal (   )  [inline]

Implements behavior of literal metaphor inside CTTL grammar expression. Returns: Instance of C++ implementation class for grammar expression begin( CTTL_QWERTY_ ) ^ end( CTTL_QWERTY_123_ ) Definition at line 84 of file xtl_metaphor.h. References begin(), CTTL_STD_CHAR, CTTL_STD_STRING, and end().

const_edge< policy_default, StringT > new_edge (  input< StringT > &  inp_, size_t  lhs_offset_, size_t  rhs_offset_ )  [inline]

Constructs new edge object pointing to the part of the cttl::input specified by the user. StringT Template parameter specifying type of the encapsulated string. Parameters: inp_  Mutable reference to cttl::input object lhs_offset_  Specifies absolute offset of the upper boundary of the edge to be constructed. rhs_offset_  Specifies absolute offset of the lower boundary of the edge to be constructed. See also: Edge creation. Definition at line 685 of file const_edge.h. References input::container().

const_edge< policy_default, StringT > new_edge (  input< StringT > &  inp_  )  [inline]

Constructs new edge object pointing to the entire parseable universe. StringT Template parameter specifying type of the encapsulated string. Parameters: inp_  Mutable reference to cttl::input object See also: Edge creation. Definition at line 658 of file const_edge.h. References input::container(), and input::length().

const_edge< PolicyT, StringT > new_edge (  const_edge< PolicyT, StringT > &  other_  )  [inline]

Constructs new cttl::const_edge object from another edge. PolicyT Template parameter specifying white space policy. StringT Template parameter specifying type of the encapsulated string. See also: Edge creation. Definition at line 637 of file const_edge.h. References const_edge::first, const_edge::parent(), and const_edge::second.

node< StringT > new_node (  node< StringT > &  other_  )  [inline]

Constructs new cttl::node object from another node. StringT Template parameter specifying type of the encapsulated string. See also: Node creation. Definition at line 668 of file node.h. References node::offset(), and node::parent().

node< StringT > new_node (  input< StringT > &  inp_  )  [inline]

Constructs new cttl::node object from cttl::input object. StringT Template parameter specifying type of the encapsulated string. Postcondition: New node is positioned at the end of the user input text. See also: Node creation. Definition at line 652 of file node.h. References input::length().

node< StringT > new_node (  input< StringT > &  inp_, size_t  offset_ )  [inline]

Constructs new cttl::node object from cttl::input object. StringT Template parameter specifying type of the encapsulated string. Parameters: inp_  Mutable reference to cttl::input object offset_  Specifies absolute offset of the node to be constructed. See also: Node creation. Definition at line 633 of file node.h.

xtl_wrap< xtl_opbinand< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >> operator & (  xtl_wrap< Left_exprT > const &  lhs_expr_, xtl_wrap< Right_exprT > const &  rhs_expr_ )  [inline]

Overloads binary set intersection operator. Left_exprT Template parameter specifying type of left-hand-side grammar expression object, determined by the C++ compiler at compile time. Right_exprT Template parameter specifying type of right-hand-side grammar expression object, determined by the C++ compiler at compile time. Parameters: lhs_expr_  immutable reference to left-hand-side grammar expression object. rhs_expr_  immutable reference to right-hand-side grammar expression object. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 556 of file xtl_op.h.

xtl_wrap< xtl_opunarstar< xtl_wrap< Left_exprT > >> operator * (  xtl_wrap< Left_exprT > const &  lhs_expr_, int  upper_limit_ )  [inline]

Overloads binary Kleene star operator. Left_exprT Template parameter specifying type of grammar expression object, determined by the C++ compiler at compile time. Parameters: lhs_expr_  immutable reference to CTTL grammar expression object. upper_limit_  upper limit of requested number of matches. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 143 of file xtl_op.h.

xtl_wrap< xtl_opunarstar< xtl_wrap< ExprT > >> operator * (  xtl_wrap< ExprT > const &  expr_  )  [inline]

Overloads unary Kleene star operator. ExprT Template parameter specifying type of grammar expression object, determined by the C++ compiler at compile time. Parameters: expr_  immutable reference to CTTL grammar expression object. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 106 of file xtl_op.h.

xtl_wrap< xtl_opunarbang< xtl_wrap< ExprT > >> operator! (  xtl_wrap< ExprT > const &  expr_  )  [inline]

Overloads unary search operator. ExprT Template parameter specifying type of grammar expression object, determined by the C++ compiler at compile time. Parameters: expr_  immutable reference to CTTL grammar expression object. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 71 of file xtl_op.h.

bool operator!= (  node< StringT > const &  one_, node< StringT > const &  another_ )

Compares two nodes. Nodes are equal if their offsets are the same. Definition at line 687 of file node.h. References node::offset().

bool operator!= (  const_edge< PolicyT, StringT > const &  one_, const_edge< PolicyT, StringT > const &  another_ )

Compares two edges by comparing the underlying text. Parameters: one_  instance of left hand side edge. another_  instance of right hand side edge. See also: String-like behavior of the const_edge. Definition at line 792 of file const_edge.h. References const_edge::text().

xtl_wrap< xtl_opbinplus< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >> operator+ (  xtl_wrap< Left_exprT > const &  lhs_expr_, xtl_wrap< Right_exprT > const &  rhs_expr_ )  [inline]

Overloads binary sequence operator. Left_exprT Template parameter specifying type of left-hand-side grammar expression object, determined by the C++ compiler at compile time. Right_exprT Template parameter specifying type of right-hand-side grammar expression object, determined by the C++ compiler at compile time. Parameters: lhs_expr_  immutable reference to left-hand-side grammar expression object. rhs_expr_  immutable reference to right-hand-side grammar expression object. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 336 of file xtl_op.h.

xtl_wrap< xtl_opunarplus< xtl_wrap< Left_exprT > >> operator+ (  xtl_wrap< Left_exprT > const &  lhs_expr_, std::pair< int, int >  limits_ )  [inline]

Overloads binary greedy Kleene plus operator. Left_exprT Template parameter specifying type of grammar expression object, determined by the C++ compiler at compile time. Parameters: lhs_expr_  immutable reference to CTTL grammar expression object. limits_  STL pair specifying lower and upper limits for the requested matches, for example, std::make_pair( lower_limit, upper_limit ) Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 255 of file xtl_op.h.

xtl_wrap< xtl_opunarplus< xtl_wrap< Left_exprT > >> operator+ (  xtl_wrap< Left_exprT > const &  lhs_expr_, int  upper_limit_ )  [inline]

Overloads binary Kleene plus operator. Left_exprT Template parameter specifying type of grammar expression object, determined by the C++ compiler at compile time. Parameters: lhs_expr_  immutable reference to CTTL grammar expression object. upper_limit_  upper limit of requested number of matches. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 214 of file xtl_op.h.

xtl_wrap< xtl_opunarplus< xtl_wrap< ExprT > >> operator+ (  xtl_wrap< ExprT > const &  expr_  )  [inline]

Overloads unary Kleeene plus operator. ExprT Template parameter specifying type of grammar expression object, determined by the C++ compiler at compile time. Parameters: expr_  immutable reference to CTTL grammar expression object. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 177 of file xtl_op.h.

xtl_wrap< xtl_opbinminus< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >> operator- (  xtl_wrap< Left_exprT > const &  lhs_expr_, xtl_wrap< Right_exprT > const &  rhs_expr_ )  [inline]

Overloads binary set complement operator. Left_exprT Template parameter specifying type of left-hand-side grammar expression object, determined by the C++ compiler at compile time. Right_exprT Template parameter specifying type of right-hand-side grammar expression object, determined by the C++ compiler at compile time. Parameters: lhs_expr_  immutable reference to left-hand-side grammar expression object. rhs_expr_  immutable reference to right-hand-side grammar expression object. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 512 of file xtl_op.h.

xtl_wrap< xtl_opunarminus< xtl_wrap< ExprT > >> operator- (  xtl_wrap< ExprT > const &  expr_  )  [inline]

Overloads unary logical not operator. ExprT Template parameter specifying type of grammar expression object, determined by the C++ compiler at compile time. Parameters: expr_  immutable reference to CTTL grammar expression object. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 289 of file xtl_op.h.

bool operator< (  const_edge< PolicyT, StringT > const &  one_, const_edge< PolicyT, StringT > const &  another_ )

Compares two edges by comparing the underlying text. Parameters: one_  instance of left hand side edge. another_  instance of right hand side edge. See also: String-like behavior of the const_edge. Definition at line 707 of file const_edge.h. References input::text().

bool operator<= (  const_edge< PolicyT, StringT > const &  one_, const_edge< PolicyT, StringT > const &  another_ )

Compares two edges by comparing the underlying text. Parameters: one_  instance of left hand side edge. another_  instance of right hand side edge. See also: String-like behavior of the const_edge. Definition at line 758 of file const_edge.h. References const_edge::text().

bool operator== (  node< StringT > const &  one_, node< StringT > const &  another_ )

Compares two nodes. Nodes are equal if their offsets are the same. Definition at line 680 of file node.h. References node::offset().

bool operator== (  const_edge< PolicyT, StringT > const &  one_, const_edge< PolicyT, StringT > const &  another_ )

Compares two edges by comparing the underlying text. Parameters: one_  instance of left hand side edge. another_  instance of right hand side edge. See also: String-like behavior of the const_edge. Definition at line 775 of file const_edge.h. References const_edge::text().

bool operator> (  const_edge< PolicyT, StringT > const &  one_, const_edge< PolicyT, StringT > const &  another_ )

Compares two edges by comparing the underlying text. Parameters: one_  instance of left hand side edge. another_  instance of right hand side edge. See also: String-like behavior of the const_edge. Definition at line 724 of file const_edge.h. References const_edge::text().

bool operator>= (  const_edge< PolicyT, StringT > const &  one_, const_edge< PolicyT, StringT > const &  another_ )

Compares two edges by comparing the underlying text. Parameters: one_  instance of left hand side edge. another_  instance of right hand side edge. See also: String-like behavior of the const_edge. Definition at line 741 of file const_edge.h. References const_edge::text().

xtl_wrap< xtl_opbinconcat< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >> operator^ (  xtl_wrap< Left_exprT > const &  lhs_expr_, xtl_wrap< Right_exprT > const &  rhs_expr_ )  [inline]

Overloads binary concatenation operator. Left_exprT Template parameter specifying type of left-hand-side grammar expression object, determined by the C++ compiler at compile time. Right_exprT Template parameter specifying type of right-hand-side grammar expression object, determined by the C++ compiler at compile time. Parameters: lhs_expr_  immutable reference to left-hand-side grammar expression object. rhs_expr_  immutable reference to right-hand-side grammar expression object. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 468 of file xtl_op.h.

xtl_wrap< xtl_opbinpipe< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >> operator| (  xtl_wrap< Left_exprT > const &  lhs_expr_, xtl_wrap< Right_exprT > const &  rhs_expr_ )  [inline]

Overloads binary set union operator. Left_exprT Template parameter specifying type of left-hand-side grammar expression object, determined by the C++ compiler at compile time. Right_exprT Template parameter specifying type of right-hand-side grammar expression object, determined by the C++ compiler at compile time. Parameters: lhs_expr_  immutable reference to left-hand-side grammar expression object. rhs_expr_  immutable reference to right-hand-side grammar expression object. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 380 of file xtl_op.h.

xtl_wrap< xtl_opbin2pipe< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > >> operator|| (  xtl_wrap< Left_exprT > const &  lhs_expr_, xtl_wrap< Right_exprT > const &  rhs_expr_ )  [inline]

Overloads binary POSIX union operator. Left_exprT Template parameter specifying type of left-hand-side grammar expression object, determined by the C++ compiler at compile time. Right_exprT Template parameter specifying type of right-hand-side grammar expression object, determined by the C++ compiler at compile time. Parameters: lhs_expr_  immutable reference to left-hand-side grammar expression object. rhs_expr_  immutable reference to right-hand-side grammar expression object. Returns: Instance of C++ implementation class for the overloaded operator. Definition at line 424 of file xtl_op.h.

xtl_wrap< xtl_quote_generic< xtl_wrap< xtl_char< CTTL_STD_CHAR > >, xtl_wrap< MiddleT >, xtl_wrap< xtl_char< CTTL_STD_CHAR > > >> quote (  CTTL_STD_CHAR  left_, xtl_wrap< MiddleT > const &  middle_, CTTL_STD_CHAR  right_ )  [inline]

CTTL quote function generating implementation for single-character quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. Parameters: left_  character representing opening of the quote. middle_  constant reference to CTTL grammar expression describing interior clause of the quote. right_  character representing closing of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing single-character quote. Definition at line 193 of file xtl_quote_sym.h.

xtl_wrap< xtl_quote_bool< xtl_wrap< MiddleT >, xtl_wrap< RightT > >> quote (  bool  , xtl_wrap< MiddleT > const &  middle_, xtl_wrap< RightT > const &  right_ )  [inline]

CTTL quote function generating implementation for asymmetric quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. RightT Template parameter specifying type of grammar expression, describing closing unit of the quote. Parameters: middle_  constant reference to CTTL grammar expression describing interior clause of the quote. right_  constant reference to CTTL grammar expression describing closing unit of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing asymmetric quote. Definition at line 145 of file xtl_quote_sym.h.

xtl_wrap< xtl_quote_generic< xtl_wrap< LeftT >, xtl_wrap< MiddleT >, xtl_wrap< RightT > >> quote (  xtl_wrap< LeftT > const &  left_, xtl_wrap< MiddleT > const &  middle_, xtl_wrap< RightT > const &  right_ )  [inline]

CTTL quote function generating implementation for generic quotes. LeftT Template parameter specifying type of grammar expression, describing opening clause of the quote. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. RightT Template parameter specifying type of grammar expression, describing closing unit of the quote. Parameters: left_  constant reference to CTTL grammar expression describing opening clause of the quote. middle_  constant reference to CTTL grammar expression describing interior clause of the quote. right_  constant reference to CTTL grammar expression describing closing unit of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing generic quote. Definition at line 93 of file xtl_quote_sym.h.

xtl_wrap< xtl_member_predicate< ObjectT, PredicateT > > rule (  ObjectT &  object_ref_, PredicateT  pred_ )  [inline]

CTTL function adaptor, generating implementation for member function adaptor. ObjectT Template parameter specifying type of C++ class that defines non-static member function Member_predicateT. Member_predicateT Template parameter specifying type of a non-static member function, accepting specialization of cttl::const_edge or cttl::edge as a parameter, and returning size_t evaluation result. Parameters: object_ref_  Object reference. pred_  Address of the rule implementation member function, which can be declared either const or mutable. Returns: Instance of C++ implementation class for CTTL member function adaptor. Definition at line 100 of file xtl_sym.h. Referenced by policy_space< flag_cpp_comments >::match().

xtl_wrap< xtl_predicate< Static_predicateT > > rule (  const Static_predicateT  pred_  )  [inline]

CTTL function adaptor, generating implementation for static grammar rule adaptor. Static_predicateT Template parameter specifying type which is copy-constructible, and, if UniverseT is a typename that represents cttl::const_edge or cttl::edge, Static_predicateT can be invoked as size_t operator()( UniverseT& ); Parameters: pred_  Address of the rule implementation function, which can be either global, or static member function. Returns: Instance of C++ implementation class for CTTL static grammar rule adaptor. Definition at line 67 of file xtl_sym.h.

void string_array2string (  StringT &  str_, CharT *  array_[], CharT const *  delimiter_ )  [inline]

Loads text from array of string literals into STL string provided by the user. StringT Template parameter specifying type of the string. CharT Template parameter specifying character type. Parameters: str_  reference to the target string. array_  source array of string literals. delimiter_  a multi-character delimiter to be inserted between source text fragments. Precondition: Array should have trailing NULL string, for example, char* arr[] = { "abc", "def", NULL }; Definition at line 138 of file coreutils.h. Referenced by input::input(), and string_array2string().

void string_array2string (  StringT &  str_, CharT *  array_[], CharT  delimiter_ )  [inline]

Loads text from array of string literals into STL string provided by the user. StringT Template parameter specifying type of the string. CharT Template parameter specifying character type. Parameters: str_  reference to the target string. array_  source array of string literals. delimiter_  a single-character delimiter to be inserted between source text fragments. Precondition: Array should have trailing NULL string, for example, char* arr[] = { "abc", "def", NULL }; Definition at line 108 of file coreutils.h. References string_array2string().

void string_array2string (  StringT &  str_, CharT *  array_[] )  [inline]

Loads text from array of string literals into STL string provided by the user. StringT Template parameter specifying type of the string. Parameters: str_  reference to the target string. array_  source array of string literals. Precondition: Array should have trailing NULL string, for example, char* arr[] = { "abc", "def", NULL }; Definition at line 78 of file coreutils.h. References string_array2string().

xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > > symbol (  CTTL_STD_WSTRING const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for symbol(wstring*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 1156 of file xtl_sym.h.

xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > > symbol (  CTTL_STD_STRING const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for symbol(string*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 1137 of file xtl_sym.h.

xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > > symbol (  CTTL_STD_WSTRING const &  any_text_  )  [inline]

CTTL lexeme function generating implementation for symbol(wstring&) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 1118 of file xtl_sym.h.

xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > > symbol (  CTTL_STD_STRING const &  any_text_  )  [inline]

CTTL lexeme function generating implementation for symbol(string&) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 1099 of file xtl_sym.h.

xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > > symbol (  CTTL_STD_WCHAR const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for symbol(CTTL_STD_WCHAR*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 1081 of file xtl_sym.h.

xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > > symbol (  CTTL_STD_CHAR const *  any_text_  )  [inline]

CTTL lexeme function generating implementation for symbol(CTTL_STD_CHAR*) expression. Parameters: any_text_  text to match. Returns: Instance of C++ lexeme implementation class. Definition at line 1062 of file xtl_sym.h.

xtl_wrap< xtl_char< CTTL_STD_CHAR > > symbol (  int  char_  )  [inline]

CTTL lexeme function generating implementation for symbol(int) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 218 of file xtl_sym.h. References CTTL_STD_CHAR.

xtl_wrap< xtl_char< CTTL_STD_WCHAR > > symbol (  CTTL_STD_WCHAR  char_  )  [inline]

CTTL lexeme function generating implementation for symbol(CTTL_STD_WCHAR) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 200 of file xtl_sym.h.

xtl_wrap< xtl_char< CTTL_STD_CHAR > > symbol (  CTTL_STD_CHAR  char_  )  [inline]

CTTL lexeme function generating implementation for symbol(CTTL_STD_CHAR) expression. Parameters: char_  character to match. Returns: Instance of C++ lexeme implementation class. Definition at line 183 of file xtl_sym.h.

xtl_wrap< xtl_bool< false > > symbol (  bool  bool_  )  [inline]

CTTL lexeme function generating implementation for symbol(true) and symbol(false) expressions. Parameters: bool_  boolean flag specifying type of the lexeme. Returns: Instance of C++ lexeme implementation class. Definition at line 146 of file xtl_sym.h.

xtl_wrap< xtl_char_symbol > symbol (   )  [inline]

CTTL lexeme function generating implementation for symbol( ) expression. Returns: Instance of C++ lexeme implementation class. Definition at line 114 of file xtl_sym.h. Referenced by policy_space< flag_greedy|flag_follow_space >::match(), and policy_space< flag_follow_space >::match().

wchar_ansi_double_quote_T wchar_ansi_double_quote (   )  [inline]

CTTL quote function generating implementation for wide CTTL_STD_CHAR ANSI double quotes. Returns: Instance of C++ implementation class for CTTL grammar expression describing wide CTTL_STD_CHAR ANSI double quote. Remarks: This version of overloaded function assumes that any content inside the quotes is acceptable, including the empty string. Definition at line 546 of file xtl_quote_sym.h. References cttl_impl::wchar_ansi_double_quote_T.

xtl_wrap< xtl_quote_ansi_double_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > > wchar_ansi_double_quote (  xtl_wrap< MiddleT > const &  middle_  )  [inline]

CTTL quote function generating implementation for wide CTTL_STD_CHAR ANSI double quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. Parameters: middle_  constant reference to CTTL grammar expression describing interior clause of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing wide CTTL_STD_CHAR ANSI double quote. Definition at line 525 of file xtl_quote_sym.h. References CTTL_STD_WCHAR.

wchar_ansi_single_quote_T wchar_ansi_single_quote (   )  [inline]

CTTL quote function generating implementation for wide CTTL_STD_CHAR ANSI single quotes. Returns: Instance of C++ implementation class for CTTL grammar expression describing wide CTTL_STD_CHAR ANSI single quote. Remarks: This version of overloaded function assumes that any content inside the quotes is acceptable, including the empty string. Definition at line 497 of file xtl_quote_sym.h. References cttl_impl::wchar_ansi_single_quote_T.

xtl_wrap< xtl_quote_ansi_single_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR >> wchar_ansi_single_quote (  xtl_wrap< MiddleT > const &  middle_  )  [inline]

CTTL quote function generating implementation for wide CTTL_STD_CHAR ANSI single quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. Parameters: middle_  constant reference to CTTL grammar expression describing interior clause of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing wide CTTL_STD_CHAR ANSI single quote. Definition at line 477 of file xtl_quote_sym.h. References CTTL_STD_WCHAR.

wchar_c_double_quote_T wchar_c_double_quote (   )  [inline]

CTTL quote function generating implementation for wide CTTL_STD_CHAR C double quotes. Returns: Instance of C++ implementation class for CTTL grammar expression describing wide CTTL_STD_CHAR C double quote. Remarks: This version of overloaded function assumes that any content inside the quotes is acceptable, including the empty string. Definition at line 647 of file xtl_quote_sym.h. References cttl_impl::wchar_c_double_quote_T.

xtl_wrap< xtl_quote_c_double_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > > wchar_c_double_quote (  xtl_wrap< MiddleT > const &  middle_  )  [inline]

CTTL quote function generating implementation for wide CTTL_STD_CHAR C double quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. Parameters: middle_  constant reference to CTTL grammar expression describing interior clause of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing wide CTTL_STD_CHAR C double quote. Definition at line 626 of file xtl_quote_sym.h. References CTTL_STD_WCHAR.

wchar_c_single_quote_T wchar_c_single_quote (   )  [inline]

CTTL quote function generating implementation for wide CTTL_STD_CHAR C single quotes. Returns: Instance of C++ implementation class for CTTL grammar expression describing wide CTTL_STD_CHAR C single quote. Remarks: This version of overloaded function assumes that any content inside the quotes is acceptable, including the empty string. Definition at line 598 of file xtl_quote_sym.h. References cttl_impl::wchar_c_single_quote_T.

xtl_wrap< xtl_quote_c_single_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR >> wchar_c_single_quote (  xtl_wrap< MiddleT > const &  middle_  )  [inline]

CTTL quote function generating implementation for wide CTTL_STD_CHAR C single quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. Parameters: middle_  constant reference to CTTL grammar expression describing interior clause of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing wide CTTL_STD_CHAR C single quote. Definition at line 577 of file xtl_quote_sym.h. References CTTL_STD_WCHAR.

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_ref_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_ref_end< CTTL_STD_WSTRING > > > > wchar_literal (  CTTL_STD_WSTRING const *  text_begin_, CTTL_STD_WSTRING const *  text_end_ )  [inline]

Implements behavior of wide character literal metaphor inside CTTL grammar expression. Parameters: text_begin_  address of character entity string specifying upper boundary of the literal. text_end_  address of character entity string specifying lower boundary of the literal. Returns: Instance of C++ implementation class for grammar expression begin( text_begin_ ) ^ end( text_end_ ) Precondition: This function generates reference-based implementation. Therefore, strings pointed by text_begin_ and text_end_ should stay in scope while literal is in use. Definition at line 280 of file xtl_metaphor.h. References begin(), and end().

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > > wchar_literal (  CTTL_STD_WSTRING const &  text_begin_, CTTL_STD_WSTRING const &  text_end_ )  [inline]

Implements behavior of wide character literal metaphor inside CTTL grammar expression. Parameters: text_begin_  character entity specifying upper boundary of the literal. text_end_  character entity specifying lower boundary of the literal. Returns: Instance of C++ implementation class for grammar expression begin( text_begin_ ) ^ end( text_end_ ) Definition at line 248 of file xtl_metaphor.h. References begin(), and end().

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > > wchar_literal (  CTTL_STD_WCHAR const *  text_begin_, CTTL_STD_WCHAR const *  text_end_ )  [inline]

Implements behavior of wide character literal metaphor inside CTTL grammar expression. Parameters: text_begin_  character entity specifying upper boundary of the literal. text_end_  character entity specifying lower boundary of the literal. Returns: Instance of C++ implementation class for grammar expression begin( text_begin_ ) ^ end( text_end_ ) Definition at line 221 of file xtl_metaphor.h. References begin(), and end().

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > > wchar_literal (   )  [inline]

Implements behavior of wide character literal metaphor inside CTTL grammar expression. Returns: Instance of C++ implementation class for grammar expression begin( CTTL_WCHAR_QWERTY_ ) ^ end( CTTL_WCHAR_QWERTY_123_ ) Definition at line 194 of file xtl_metaphor.h. References begin(), CTTL_STD_WSTRING, CTTL_WCHAR_QWERTY_, CTTL_WCHAR_QWERTY_123_, and end().

xtl_wrap< xtl_quote_generic< xtl_wrap< xtl_char< CTTL_STD_WCHAR > >, xtl_wrap< MiddleT >, xtl_wrap< xtl_char< CTTL_STD_WCHAR > > >> wchar_quote (  CTTL_STD_WCHAR  left_, xtl_wrap< MiddleT > const &  middle_, CTTL_STD_WCHAR  right_ )  [inline]

CTTL quote function generating implementation for single wide character quotes. MiddleT Template parameter specifying type of grammar expression, describing interior clause of the quote. Parameters: left_  character representing opening of the quote. middle_  constant reference to CTTL grammar expression describing interior clause of the quote. right_  character representing closing of the quote. Returns: Instance of C++ implementation class for CTTL grammar expression describing single wide character quote. Definition at line 242 of file xtl_quote_sym.h.

---