cttl Namespace Reference

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


Classes

class  const_edge
 Implements constant parseable substring. More...
class  edge
 Implements mutable parseable substring. More...
struct  edge_first_insert_go
 Substring inserter. More...
struct  edge_first_insert_stay
 Substring inserter. More...
struct  edge_replace
 Substring replacer. More...
struct  edge_second_insert_go
 Substring inserter. More...
struct  edge_second_insert_stay
 Substring inserter. More...
class  node
 Implements placeholder of the logical position inside parseable substring. More...
struct  node_insert_go
 Substring inserter. More...
struct  node_insert_stay
 Substring inserter. More...
struct  policy_default
 Provides default implementation of CTTL space policy. More...
class  policy_mapped_space
 Base class for region-based white space policy classes. More...
struct  policy_space
 Generic version of pre-defined policy. More...
struct  policy_space< flag_cpp_comments >
 Space policy specialization to skip white space characters combined with C and C++ style comments. More...
struct  policy_space< flag_follow_region >
 Space policy specialization to skip user-defined void regions. More...
struct  policy_space< flag_follow_space >
 Space policy specialization to skip white space characters ht, lf, vt, ff, cr, and space. More...
struct  policy_space< flag_follow_space|flag_follow_region >
 Space policy specialization to skip user-defined void regions combined with white space characters ht, lf, vt, ff, cr, and space. More...
struct  policy_space< flag_greedy >
 Greedy version of the white space policy. More...
struct  policy_space< flag_greedy|flag_cpp_comments >
 Space policy specialization to skip white space characters combined with C and C++ style comments. More...
struct  policy_space< flag_greedy|flag_follow_region >
 Space policy specialization to skip user-defined void regions. More...
struct  policy_space< flag_greedy|flag_follow_space >
 Space policy specialization to skip white space characters ht, lf, vt, ff, cr, and space. More...
struct  policy_space< flag_greedy|flag_follow_space|flag_follow_region >
 Space policy specialization to skip user-defined void regions combined with white space characters ht, lf, vt, ff, cr, and space. More...

Functions

ansi_double_quote_T ansi_double_quote ()
 CTTL quote helper function function generating implementation for ANSI double 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 helper function function generating implementation for ANSI double quotes.
ansi_single_quote_T ansi_single_quote ()
 CTTL quote helper function function generating implementation for ANSI single 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 helper function function generating implementation for ANSI single quotes.
xtl_wrap< xtl_text_ref_begin
< CTTL_STD_WSTRING > > 
begin (CTTL_STD_WSTRING const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_ref_begin
< CTTL_STD_STRING > > 
begin (CTTL_STD_STRING const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_begin
< CTTL_STD_WSTRING > > 
begin (CTTL_STD_WSTRING const &any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_begin
< CTTL_STD_STRING > > 
begin (CTTL_STD_STRING const &any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_begin
< CTTL_STD_WSTRING > > 
begin (CTTL_STD_WCHAR const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_begin
< CTTL_STD_STRING > > 
begin (CTTL_STD_CHAR const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_iswhat_beginbegin (iswhat_T iswhat_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_keyword
< CTTL_STD_WSTRING > > 
begin (std::set< CTTL_STD_WSTRING > const &keywords_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_keyword
< CTTL_STD_STRING > > 
begin (std::set< CTTL_STD_STRING > const &keywords_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char_begin
< CTTL_STD_CHAR > > 
begin (int char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char_begin
< CTTL_STD_WCHAR > > 
begin (CTTL_STD_WCHAR char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char_begin
< CTTL_STD_CHAR > > 
begin (CTTL_STD_CHAR char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_bool< true > > begin (bool bool_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_position_bofbegin ()
 CTTL lexeme function helper implementation.
template<typename ExprT >
xtl_wrap< xtl_lookahead
< xtl_wrap< ExprT > >> 
begin (xtl_wrap< ExprT > const &expr_)
 Helper function to create implemention object for positive lookahead assertion adaptor.
c_double_quote_T c_double_quote ()
 CTTL quote helper function function generating implementation for C double 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 helper function function generating implementation for C double quotes.
c_single_quote_T c_single_quote ()
 CTTL quote helper function function generating implementation for C single 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 helper function function generating implementation for C single quotes.
xtl_wrap< xtl_position_eofend ()
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_ref_end
< CTTL_STD_WSTRING > > 
end (CTTL_STD_WSTRING const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_ref_end
< CTTL_STD_STRING > > 
end (CTTL_STD_STRING const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_end
< CTTL_STD_WSTRING > > 
end (CTTL_STD_WSTRING const &any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_end
< CTTL_STD_STRING > > 
end (CTTL_STD_STRING const &any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_end
< CTTL_STD_WSTRING > > 
end (CTTL_STD_WCHAR const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_end
< CTTL_STD_STRING > > 
end (CTTL_STD_CHAR const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_iswhat_endend (iswhat_T iswhat_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char_end
< CTTL_STD_CHAR > > 
end (int char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char_end
< CTTL_STD_WCHAR > > 
end (CTTL_STD_WCHAR char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char_end
< CTTL_STD_CHAR > > 
end (CTTL_STD_CHAR char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_ref_entity
< CTTL_STD_WSTRING > > 
entity (CTTL_STD_WSTRING const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_ref_entity
< CTTL_STD_STRING > > 
entity (CTTL_STD_STRING const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_entity
< CTTL_STD_WSTRING > > 
entity (CTTL_STD_WSTRING const &any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_entity
< CTTL_STD_STRING > > 
entity (CTTL_STD_STRING const &any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_entity
< CTTL_STD_WSTRING > > 
entity (CTTL_STD_WCHAR const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_entity
< CTTL_STD_STRING > > 
entity (CTTL_STD_CHAR const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char
< CTTL_STD_CHAR > > 
entity (int char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char
< CTTL_STD_WCHAR > > 
entity (CTTL_STD_WCHAR char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char
< CTTL_STD_CHAR > > 
entity (CTTL_STD_CHAR char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_iswhat_entityentity (iswhat_T iswhat_)
 CTTL lexeme function helper implementation.
universe_T entity ()
 Helper function to create implemention object for entity lexeme.
template<typename ExprT >
xtl_wrap< xtl_entity< xtl_wrap
< ExprT > >> 
entity (xtl_wrap< ExprT > const &expr_)
 Helper function to create implemention object for entity adaptor filtering successful result of grammar evaluation based on non-empty match.
xtl_wrap< xtl_text_ref_first
< CTTL_STD_WSTRING > > 
first (CTTL_STD_WSTRING const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_ref_first
< CTTL_STD_STRING > > 
first (CTTL_STD_STRING const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_first
< CTTL_STD_WSTRING > > 
first (CTTL_STD_WSTRING const &any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_first
< CTTL_STD_STRING > > 
first (CTTL_STD_STRING const &any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_first
< CTTL_STD_WSTRING > > 
first (CTTL_STD_WCHAR const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_first
< CTTL_STD_STRING > > 
first (CTTL_STD_CHAR const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_iswhat_firstfirst (iswhat_T iswhat_)
 CTTL lexeme function helper implementation.
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_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_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 ()
 Implements behavior of literal metaphor inside CTTL grammar expression.
template<typename BehindT , typename AheadT >
xtl_wrap< xtl_quote_bool
< xtl_wrap< BehindT >
, xtl_wrap< AheadT > > > 
lookbehind (xtl_wrap< BehindT > const &behind_, xtl_wrap< AheadT > const &ahead_)
 CTTL positive lookbehind assertion helper function.
template<typename ExprT >
xtl_wrap< xtl_opunarbang
< xtl_wrap< ExprT > > > 
operator! (xtl_wrap< ExprT > const &expr_)
 Overloads unary search operator.
template<typename StringT >
bool operator!= (node< StringT > const &one_, node< StringT > const &another_)
 Compares two nodes.
template<typename PolicyT , typename StringT >
bool operator!= (const_edge< PolicyT, StringT > const &substr_, typename StringT::value_type const *cstr_)
 Compares substring to a C string.
template<typename PolicyT , typename StringT >
bool operator!= (typename StringT::value_type const *cstr_, const_edge< PolicyT, StringT > const &substr_)
 Compares C string to a substring.
template<typename PolicyT , typename StringT >
bool operator!= (StringT const &str_, const_edge< PolicyT, StringT > const &substr_)
 Compares string to a substring.
template<typename PolicyT , typename StringT >
bool operator!= (const_edge< PolicyT, StringT > const &substr_, StringT const &str_)
 Compares substring to a string.
template<typename PolicyT , typename StringT >
bool operator!= (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
 Compares two substrings.
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 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_opunarstar
< xtl_wrap< ExprT > > > 
operator* (xtl_wrap< ExprT > const &expr_)
 Overloads unary Kleene star 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 >
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 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 ExprT >
xtl_wrap< xtl_opunarplus
< xtl_wrap< ExprT > > > 
operator+ (xtl_wrap< ExprT > const &expr_)
 Overloads unary Kleene plus operator.
template<typename StringT >
node< StringT > & operator++ (node< StringT > &node_)
 Prefix increment operator increments node offset.
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 ExprT >
xtl_wrap< xtl_opunarminus
< xtl_wrap< ExprT > > > 
operator- (xtl_wrap< ExprT > const &expr_)
 Overloads unary negative lookahead assertion operator.
template<typename StringT >
node< StringT > & operator-- (node< StringT > &node_)
 Prefix decrement operator decrements node offset.
template<typename StringT >
bool operator< (node< StringT > const &one_, node< StringT > const &another_)
 Compares offsets of two nodes.
template<typename PolicyT , typename StringT >
bool operator< (const_edge< PolicyT, StringT > const &substr_, typename StringT::value_type const *cstr_)
 Compares substring to a C string.
template<typename PolicyT , typename StringT >
bool operator< (typename StringT::value_type const *cstr_, const_edge< PolicyT, StringT > const &substr_)
 Compares C string to a substring.
template<typename PolicyT , typename StringT >
bool operator< (StringT const &str_, const_edge< PolicyT, StringT > const &substr_)
 Compares string to a substring.
template<typename PolicyT , typename StringT >
bool operator< (const_edge< PolicyT, StringT > const &substr_, StringT const &str_)
 Compares substring to a string.
template<typename PolicyT , typename StringT >
bool operator< (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
 Compares two substrings.
template<typename PolicyT , typename StringT >
std::ostream & operator<< (std::ostream &os_, const_edge< PolicyT, StringT > const &edge_)
 Stream insertion operator performs substring output operation on std::ostream.
template<typename StringT >
bool operator<= (node< StringT > const &one_, node< StringT > const &another_)
 Compares offsets of two nodes.
template<typename PolicyT , typename StringT >
bool operator<= (const_edge< PolicyT, StringT > const &substr_, typename StringT::value_type const *cstr_)
 Compares substring to a C string.
template<typename PolicyT , typename StringT >
bool operator<= (typename StringT::value_type const *cstr_, const_edge< PolicyT, StringT > const &substr_)
 Compares C string to a substring.
template<typename PolicyT , typename StringT >
bool operator<= (StringT const &str_, const_edge< PolicyT, StringT > const &substr_)
 Compares string to a substring.
template<typename PolicyT , typename StringT >
bool operator<= (const_edge< PolicyT, StringT > const &substr_, StringT const &str_)
 Compares substring to a string.
template<typename PolicyT , typename StringT >
bool operator<= (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
 Compares two substrings.
template<typename StringT >
bool operator== (node< StringT > const &one_, node< StringT > const &another_)
 Compares two nodes.
template<typename PolicyT , typename StringT >
bool operator== (const_edge< PolicyT, StringT > const &substr_, typename StringT::value_type const *cstr_)
 Compares substring to a C string.
template<typename PolicyT , typename StringT >
bool operator== (typename StringT::value_type const *cstr_, const_edge< PolicyT, StringT > const &substr_)
 Compares C string to a substring.
template<typename PolicyT , typename StringT >
bool operator== (StringT const &str_, const_edge< PolicyT, StringT > const &substr_)
 Compares string to a substring.
template<typename PolicyT , typename StringT >
bool operator== (const_edge< PolicyT, StringT > const &substr_, StringT const &str_)
 Compares substring to a string.
template<typename PolicyT , typename StringT >
bool operator== (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
 Compares two substrings.
template<typename StringT >
bool operator> (node< StringT > const &one_, node< StringT > const &another_)
 Compares offsets of two nodes.
template<typename PolicyT , typename StringT >
bool operator> (const_edge< PolicyT, StringT > const &substr_, typename StringT::value_type const *cstr_)
 Compares substring to a C string.
template<typename PolicyT , typename StringT >
bool operator> (typename StringT::value_type const *cstr_, const_edge< PolicyT, StringT > const &substr_)
 Compares C string to a substring.
template<typename PolicyT , typename StringT >
bool operator> (StringT const &str_, const_edge< PolicyT, StringT > const &substr_)
 Compares string to a substring.
template<typename PolicyT , typename StringT >
bool operator> (const_edge< PolicyT, StringT > const &substr_, StringT const &str_)
 Compares substring to a string.
template<typename PolicyT , typename StringT >
bool operator> (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
 Compares two substrings.
template<typename StringT >
bool operator>= (node< StringT > const &one_, node< StringT > const &another_)
 Compares offsets of two nodes.
template<typename PolicyT , typename StringT >
bool operator>= (const_edge< PolicyT, StringT > const &substr_, typename StringT::value_type const *cstr_)
 Compares substring to a C string.
template<typename PolicyT , typename StringT >
bool operator>= (typename StringT::value_type const *cstr_, const_edge< PolicyT, StringT > const &substr_)
 Compares C string to a substring.
template<typename PolicyT , typename StringT >
bool operator>= (StringT const &str_, const_edge< PolicyT, StringT > const &substr_)
 Compares string to a substring.
template<typename PolicyT , typename StringT >
bool operator>= (const_edge< PolicyT, StringT > const &substr_, StringT const &str_)
 Compares substring to a string.
template<typename PolicyT , typename StringT >
bool operator>= (const_edge< PolicyT, StringT > const &one_, const_edge< PolicyT, StringT > const &another_)
 Compares two substrings.
template<typename PolicyT , typename StringT >
std::istream & operator>> (std::istream &is_, edge< PolicyT, StringT > &edge_)
 Input stream extraction operator performs an input operation on std::istream.
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_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 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 helper function function generating implementation for single-character 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 helper function function generating implementation for asymmetric quotes.
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 helper function for implementation of generic quote.
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.
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 StringT , typename CharT >
void string_array2string (StringT &str_, CharT const *const *array_, CharT delimiter_)
 Loads text from array of string literals into a string provided by the user.
template<typename StringT , typename CharT >
void string_array2string (StringT &str_, CharT const *const *array_)
 Loads text from array of string literals into a string provided by the user.
template<typename StringT , typename CharT >
void string_array2string (StringT &str_, CharT const *const *array_, CharT const *delimiter_)
 Loads text from array of string literals into a string provided by the user.
template<typename StringT >
void string_tolower (StringT &str_)
 Converts string to lowercase.
template<typename StringT >
void string_toupper (StringT &str_)
 Converts string to UPPERCASE.
xtl_wrap< xtl_text_ref_symbol
< CTTL_STD_WSTRING > > 
symbol (CTTL_STD_WSTRING const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_ref_symbol
< CTTL_STD_STRING > > 
symbol (CTTL_STD_STRING const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_symbol
< CTTL_STD_WSTRING > > 
symbol (CTTL_STD_WSTRING const &any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_symbol
< CTTL_STD_STRING > > 
symbol (CTTL_STD_STRING const &any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_symbol
< CTTL_STD_WSTRING > > 
symbol (CTTL_STD_WCHAR const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_text_symbol
< CTTL_STD_STRING > > 
symbol (CTTL_STD_CHAR const *any_text_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char
< CTTL_STD_CHAR > > 
symbol (int char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char
< CTTL_STD_WCHAR > > 
symbol (CTTL_STD_WCHAR char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char
< CTTL_STD_CHAR > > 
symbol (CTTL_STD_CHAR char_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_bool< false > > symbol (bool bool_)
 CTTL lexeme function helper implementation.
xtl_wrap< xtl_char_symbolsymbol ()
 CTTL lexeme function helper implementation.
wchar_ansi_double_quote_T wchar_ansi_double_quote ()
 CTTL quote helper function function generating implementation for wide character ANSI double 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 helper function function generating implementation for wide character ANSI double quotes.
wchar_ansi_single_quote_T wchar_ansi_single_quote ()
 CTTL quote helper function function generating implementation for wide character ANSI single 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 helper function function generating implementation for wide character ANSI single quotes.
wchar_c_double_quote_T wchar_c_double_quote ()
 CTTL quote helper function function generating implementation for wide character C double 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 helper function function generating implementation for wide character C double quotes.
wchar_c_single_quote_T wchar_c_single_quote ()
 CTTL quote helper function function generating implementation for wide character C single 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 helper function function generating implementation for wide character C single quotes.
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.
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_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 ()
 Implements behavior of wide character literal metaphor inside CTTL grammar expression.
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 helper function function generating implementation for single wide character quotes.

Variables

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
 Shorthand for both white space and user-defined void regions.
const int flag_follow_region = 2
 Suggests that the specialization understands user-defined void regions.
const int flag_follow_space = 1
 Suggests that the specialization understands conventional white space.
const int flag_greedy = 4
 Suggests that the specialization implements greedy evaluation algorithm.


Detailed Description

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


Function Documentation

ansi_double_quote_T cttl::ansi_double_quote (  ) 

CTTL quote helper function 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 an empty string.

Definition at line 394 of file xtl_quote_sym.h.

00395     {
00396         return ansi_double_quote_T( xtl_quote_ansi_double_quote< relaxed_bool_T, CTTL_STD_CHAR >( true ) );
00397     }

template<typename MiddleT >
xtl_wrap< xtl_quote_ansi_double_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > > cttl::ansi_double_quote ( xtl_wrap< MiddleT > const &  middle_  ) 

CTTL quote helper function function generating implementation for ANSI double quotes.

Template Parameters:
MiddleT specifies 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 374 of file xtl_quote_sym.h.

00375     {
00376         return xtl_wrap< xtl_quote_ansi_double_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > >( xtl_quote_ansi_double_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR >( middle_ ) );
00377     }

ansi_single_quote_T cttl::ansi_single_quote (  ) 

CTTL quote helper function 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 an empty string.

Definition at line 347 of file xtl_quote_sym.h.

00348     {
00349         return ansi_single_quote_T( xtl_quote_ansi_single_quote< relaxed_bool_T, CTTL_STD_CHAR >( true ) );
00350     }

template<typename MiddleT >
xtl_wrap< xtl_quote_ansi_single_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > > cttl::ansi_single_quote ( xtl_wrap< MiddleT > const &  middle_  ) 

CTTL quote helper function function generating implementation for ANSI single quotes.

Template Parameters:
MiddleT specifies 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 327 of file xtl_quote_sym.h.

00328     {
00329         return xtl_wrap< xtl_quote_ansi_single_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > >( xtl_quote_ansi_single_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR >( middle_ ) );
00330     }

xtl_wrap< xtl_text_ref_begin< CTTL_STD_WSTRING > > cttl::begin ( CTTL_STD_WSTRING const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    begin(std::wstring const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 736 of file xtl_sym.h.

00737     {
00738         return xtl_wrap< xtl_text_ref_begin< CTTL_STD_WSTRING > >( any_text_ );
00739     }

xtl_wrap< xtl_text_ref_begin< CTTL_STD_STRING > > cttl::begin ( CTTL_STD_STRING const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    begin(std::string const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 714 of file xtl_sym.h.

00715     {
00716         return xtl_wrap< xtl_text_ref_begin< CTTL_STD_STRING > >( any_text_ );
00717     }

xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > > cttl::begin ( CTTL_STD_WSTRING const &  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    begin(std::wstring const&)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 692 of file xtl_sym.h.

00693     {
00694         return xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >( any_text_ );
00695     }

xtl_wrap< xtl_text_begin< CTTL_STD_STRING > > cttl::begin ( CTTL_STD_STRING const &  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    begin(std::string const&)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 670 of file xtl_sym.h.

00671     {
00672         return xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >( any_text_ );
00673     }

xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > > cttl::begin ( CTTL_STD_WCHAR const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 648 of file xtl_sym.h.

00649     {
00650         return xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >( any_text_ );
00651     }

xtl_wrap< xtl_text_begin< CTTL_STD_STRING > > cttl::begin ( CTTL_STD_CHAR const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 626 of file xtl_sym.h.

00627     {
00628         return xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >( any_text_ );
00629     }

xtl_wrap< xtl_iswwhat_begin > cttl::begin ( iswhat_T  iswhat_  ) 

CTTL lexeme function helper implementation.

Usage:

    begin(is...)

Parameters:
iswhat_ address of C character classification routine.
Returns:
Instance of C++ lexeme implementation class.
Usage:
    begin(isw...)

iswwhat_
address of C wide character classification routine.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 446 of file xtl_sym.h.

00447     {
00448         return xtl_wrap< xtl_iswhat_begin >( iswhat_ );
00449     }

xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > > cttl::begin ( std::set< CTTL_STD_WSTRING > const &  keywords_  ) 

CTTL lexeme function helper implementation.

Usage:

    begin(std::set<std::wstring>&)

Parameters:
keywords_ reference to the std::set<std::wstring>& object.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 423 of file xtl_sym.h.

00424     {
00425         return xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >( keywords_ );
00426     }

xtl_wrap< xtl_keyword< CTTL_STD_STRING > > cttl::begin ( std::set< CTTL_STD_STRING > const &  keywords_  ) 

CTTL lexeme function helper implementation.

Usage:

    begin(std::set<std::string>&)

Parameters:
keywords_ reference to the std::set<std::string>& object.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 402 of file xtl_sym.h.

00403     {
00404         return xtl_wrap< xtl_keyword< CTTL_STD_STRING > >( keywords_ );
00405     }

xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > > cttl::begin ( int  char_  ) 

CTTL lexeme function helper implementation.

Usage:

    begin(int)

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 316 of file xtl_sym.h.

00317     {
00318         // allows begin( 0x0a ) notation for individual characters
00319         return xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > >( CTTL_STD_CHAR( char_ ) );
00320     }

xtl_wrap< xtl_char_begin< CTTL_STD_WCHAR > > cttl::begin ( CTTL_STD_WCHAR  char_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 295 of file xtl_sym.h.

00296     {
00297         return xtl_wrap< xtl_char_begin< CTTL_STD_WCHAR > >( char_ );
00298     }

xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > > cttl::begin ( CTTL_STD_CHAR  char_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 274 of file xtl_sym.h.

00275     {
00276         return xtl_wrap< xtl_char_begin< CTTL_STD_CHAR > >( char_ );
00277     }

xtl_wrap< xtl_bool< true > > cttl::begin ( bool  bool_  ) 

CTTL lexeme function helper implementation.

Usage:

    begin(true)
and
    begin(false)

Parameters:
bool_ boolean flag specifying type of the lexeme.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 188 of file xtl_sym.h.

00189     {
00190         // succeeds on empty substring
00191         return xtl_wrap< xtl_bool< true > >( bool_ );
00192     }

xtl_wrap< xtl_position_bof > cttl::begin (  ) 

CTTL lexeme function helper implementation.

Usage:

    begin( )
expression.

Returns:
Instance of C++ lexeme implementation class.

Definition at line 137 of file xtl_sym.h.

00138     {
00139         return xtl_wrap< xtl_position_bof >();
00140     }

template<typename ExprT >
xtl_wrap< xtl_lookahead< xtl_wrap< ExprT > >> cttl::begin ( xtl_wrap< ExprT > const &  expr_  ) 

Helper function to create implemention object for positive lookahead assertion adaptor.

Template Parameters:
ExprT specifies 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 positive lookahead assertion adaptor.

Definition at line 371 of file xtl_metaphor.h.

00372 {
00373     typedef
00374         xtl_lookahead<
00375             xtl_wrap< ExprT >
00376         > xtl_lookahead_T;
00377 
00378     return xtl_wrap< xtl_lookahead_T >( xtl_lookahead_T( expr_ ) );
00379 }

c_double_quote_T cttl::c_double_quote (  ) 

CTTL quote helper function 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 an empty string.

Definition at line 490 of file xtl_quote_sym.h.

00491     {
00492         return c_double_quote_T( xtl_quote_c_double_quote< relaxed_bool_T, CTTL_STD_CHAR >( true ) );
00493     }

template<typename MiddleT >
xtl_wrap< xtl_quote_c_double_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > > cttl::c_double_quote ( xtl_wrap< MiddleT > const &  middle_  ) 

CTTL quote helper function function generating implementation for C double quotes.

Template Parameters:
MiddleT specifies 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 470 of file xtl_quote_sym.h.

00471     {
00472         return xtl_wrap< xtl_quote_c_double_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > >( xtl_quote_c_double_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR >( middle_ ) );
00473     }

c_single_quote_T cttl::c_single_quote (  ) 

CTTL quote helper function 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 an empty string.

Definition at line 443 of file xtl_quote_sym.h.

00444     {
00445         return c_single_quote_T( xtl_quote_c_single_quote< relaxed_bool_T, CTTL_STD_CHAR >( true ) );
00446     }

template<typename MiddleT >
xtl_wrap< xtl_quote_c_single_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > > cttl::c_single_quote ( xtl_wrap< MiddleT > const &  middle_  ) 

CTTL quote helper function function generating implementation for C single quotes.

Template Parameters:
MiddleT specifies 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 423 of file xtl_quote_sym.h.

00424     {
00425         return xtl_wrap< xtl_quote_c_single_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR > >( xtl_quote_c_single_quote< xtl_wrap< MiddleT >, CTTL_STD_CHAR >( middle_ ) );
00426     }

xtl_wrap< xtl_position_eof > cttl::end (  ) 

CTTL lexeme function helper implementation.

Usage:

    end( )

Returns:
Instance of C++ lexeme implementation class.

Definition at line 1359 of file xtl_sym.h.

01360     {
01361         return xtl_wrap< xtl_position_eof >();
01362     }

xtl_wrap< xtl_text_ref_end< CTTL_STD_WSTRING > > cttl::end ( CTTL_STD_WSTRING const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    end(std::wstring const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 870 of file xtl_sym.h.

00871     {
00872         return xtl_wrap< xtl_text_ref_end< CTTL_STD_WSTRING > >( any_text_ );
00873     }

xtl_wrap< xtl_text_ref_end< CTTL_STD_STRING > > cttl::end ( CTTL_STD_STRING const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    end(std::string const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 848 of file xtl_sym.h.

00849     {
00850         return xtl_wrap< xtl_text_ref_end< CTTL_STD_STRING > >( any_text_ );
00851     }

xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > cttl::end ( CTTL_STD_WSTRING const &  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    end(std::wstring const&)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 826 of file xtl_sym.h.

00827     {
00828         return xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > >( any_text_ );
00829     }

xtl_wrap< xtl_text_end< CTTL_STD_STRING > > cttl::end ( CTTL_STD_STRING const &  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    end(std::string const&)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 804 of file xtl_sym.h.

00805     {
00806         return xtl_wrap< xtl_text_end< CTTL_STD_STRING > >( any_text_ );
00807     }

xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > cttl::end ( CTTL_STD_WCHAR const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 782 of file xtl_sym.h.

00783     {
00784         return xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > >( any_text_ );
00785     }

xtl_wrap< xtl_text_end< CTTL_STD_STRING > > cttl::end ( CTTL_STD_CHAR const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    end(CTTL_STD_CHAR const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 760 of file xtl_sym.h.

00761     {
00762         return xtl_wrap< xtl_text_end< CTTL_STD_STRING > >( any_text_ );
00763     }

xtl_wrap< xtl_iswwhat_end > cttl::end ( iswhat_T  iswhat_  ) 

CTTL lexeme function helper implementation.

Usage:

    end(is...)

Parameters:
iswhat_ address of C character classification routine.
Returns:
Instance of C++ lexeme implementation class.
Usage:
    end(isw...)

iswwhat_
address of C wide character classification routine.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 468 of file xtl_sym.h.

00469     {
00470         return xtl_wrap< xtl_iswhat_end >( iswhat_ );
00471     }

xtl_wrap< xtl_char_end< CTTL_STD_CHAR > > cttl::end ( int  char_  ) 

CTTL lexeme function helper implementation.

Usage:

    end(int)

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 380 of file xtl_sym.h.

00381     {
00382         // allows end( 0x0a ) notation for individual characters
00383         return xtl_wrap< xtl_char_end< CTTL_STD_CHAR > >( CTTL_STD_CHAR( char_ ) );
00384     }

xtl_wrap< xtl_char_end< CTTL_STD_WCHAR > > cttl::end ( CTTL_STD_WCHAR  char_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 359 of file xtl_sym.h.

00360     {
00361         return xtl_wrap< xtl_char_end< CTTL_STD_WCHAR > >( char_ );
00362     }

xtl_wrap< xtl_char_end< CTTL_STD_CHAR > > cttl::end ( CTTL_STD_CHAR  char_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 338 of file xtl_sym.h.

00339     {
00340         return xtl_wrap< xtl_char_end< CTTL_STD_CHAR > >( char_ );
00341     }

xtl_wrap< xtl_text_ref_entity< CTTL_STD_WSTRING > > cttl::entity ( CTTL_STD_WSTRING const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    entity(std::wstring const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1204 of file xtl_sym.h.

01205     {
01206         return xtl_wrap< xtl_text_ref_entity< CTTL_STD_WSTRING > >( any_text_ );
01207     }

xtl_wrap< xtl_text_ref_entity< CTTL_STD_STRING > > cttl::entity ( CTTL_STD_STRING const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    entity(std::string const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1182 of file xtl_sym.h.

01183     {
01184         return xtl_wrap< xtl_text_ref_entity< CTTL_STD_STRING > >( any_text_ );
01185     }

xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > > cttl::entity ( CTTL_STD_WSTRING const &  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    entity(std::wstring const&)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1160 of file xtl_sym.h.

01161     {
01162         return xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > >( any_text_ );
01163     }

xtl_wrap< xtl_text_entity< CTTL_STD_STRING > > cttl::entity ( CTTL_STD_STRING const &  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    entity(std::string const&)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1138 of file xtl_sym.h.

01139     {
01140         return xtl_wrap< xtl_text_entity< CTTL_STD_STRING > >( any_text_ );
01141     }

xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > > cttl::entity ( CTTL_STD_WCHAR const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1116 of file xtl_sym.h.

01117     {
01118         return xtl_wrap< xtl_text_entity< CTTL_STD_WSTRING > >( any_text_ );
01119     }

xtl_wrap< xtl_text_entity< CTTL_STD_STRING > > cttl::entity ( CTTL_STD_CHAR const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1094 of file xtl_sym.h.

01095     {
01096         return xtl_wrap< xtl_text_entity< CTTL_STD_STRING > >( any_text_ );
01097     }

xtl_wrap< xtl_char< CTTL_STD_CHAR > > cttl::entity ( int  char_  ) 

CTTL lexeme function helper implementation.

Usage:

    entity(int)

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1071 of file xtl_sym.h.

01072     {
01073         // allows entity( 0x0a ) notation for individual characters
01074         return xtl_wrap< xtl_char< CTTL_STD_CHAR > >( CTTL_STD_CHAR( char_ ) );
01075     }

xtl_wrap< xtl_char< CTTL_STD_WCHAR > > cttl::entity ( CTTL_STD_WCHAR  char_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1049 of file xtl_sym.h.

01050     {
01051         return xtl_wrap< xtl_char< CTTL_STD_WCHAR > >( char_ );
01052     }

xtl_wrap< xtl_char< CTTL_STD_CHAR > > cttl::entity ( CTTL_STD_CHAR  char_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1027 of file xtl_sym.h.

01028     {
01029         return xtl_wrap< xtl_char< CTTL_STD_CHAR > >( char_ );
01030     }

xtl_wrap< xtl_iswwhat_entity > cttl::entity ( iswhat_T  iswhat_  ) 

CTTL lexeme function helper implementation.

Usage:

    entity(is...)

Parameters:
iswhat_ address of C character classification routine.
Returns:
Instance of C++ lexeme implementation class.
Usage:
    entity(isw...)

iswwhat_
address of C wide character classification routine.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 512 of file xtl_sym.h.

00513     {
00514         return xtl_wrap< xtl_iswhat_entity >( iswhat_ );
00515     }

universe_T cttl::entity (  ) 

Helper function to create implemention object for entity lexeme.

Returns:
Instance of C++ implementation class that matches current substring.

Definition at line 338 of file xtl_metaphor.h.

00339 {
00340     return universe_T(
00341         relaxed_bool_T( true ) + !end()
00342         );
00343 }

template<typename ExprT >
xtl_wrap< xtl_entity< xtl_wrap< ExprT > >> cttl::entity ( xtl_wrap< ExprT > const &  expr_  ) 

Helper function to create implemention object for entity adaptor filtering successful result of grammar evaluation based on non-empty match.

Template Parameters:
ExprT specifies 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 318 of file xtl_metaphor.h.

00319 {
00320     typedef
00321         xtl_entity<
00322             xtl_wrap< ExprT >
00323         > xtl_entity_T;
00324 
00325     return xtl_wrap< xtl_entity_T >( xtl_entity_T( expr_ ) );
00326 }

xtl_wrap< xtl_text_ref_first< CTTL_STD_WSTRING > > cttl::first ( CTTL_STD_WSTRING const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    first(std::wstring const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1003 of file xtl_sym.h.

01004     {
01005         return xtl_wrap< xtl_text_ref_first< CTTL_STD_WSTRING > >( any_text_ );
01006     }

xtl_wrap< xtl_text_ref_first< CTTL_STD_STRING > > cttl::first ( CTTL_STD_STRING const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    first(std::string const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 981 of file xtl_sym.h.

00982     {
00983         return xtl_wrap< xtl_text_ref_first< CTTL_STD_STRING > >( any_text_ );
00984     }

xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > > cttl::first ( CTTL_STD_WSTRING const &  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    first(std::wstring const&)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 959 of file xtl_sym.h.

00960     {
00961         return xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > >( any_text_ );
00962     }

xtl_wrap< xtl_text_first< CTTL_STD_STRING > > cttl::first ( CTTL_STD_STRING const &  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    first(std::string const&)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 937 of file xtl_sym.h.

00938     {
00939         return xtl_wrap< xtl_text_first< CTTL_STD_STRING > >( any_text_ );
00940     }

xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > > cttl::first ( CTTL_STD_WCHAR const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 915 of file xtl_sym.h.

00916     {
00917         return xtl_wrap< xtl_text_first< CTTL_STD_WSTRING > >( any_text_ );
00918     }

xtl_wrap< xtl_text_first< CTTL_STD_STRING > > cttl::first ( CTTL_STD_CHAR const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 893 of file xtl_sym.h.

00894     {
00895         return xtl_wrap< xtl_text_first< CTTL_STD_STRING > >( any_text_ );
00896     }

xtl_wrap< xtl_iswwhat_first > cttl::first ( iswhat_T  iswhat_  ) 

CTTL lexeme function helper implementation.

Usage:

    first(is...)

Parameters:
iswhat_ address of C character classification routine.
Returns:
Instance of C++ lexeme implementation class.
Usage:
    first(isw...)

iswwhat_
address of C wide character classification routine.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 490 of file xtl_sym.h.

00491     {
00492         return xtl_wrap< xtl_iswhat_first >( iswhat_ );
00493     }

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_ref_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_ref_end< CTTL_STD_STRING > > > > cttl::literal ( CTTL_STD_STRING const *  text_begin_,
CTTL_STD_STRING const *  text_end_ 
)

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 179 of file xtl_metaphor.h.

00180 {
00181     return xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_ref_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_ref_end< CTTL_STD_STRING > > > >(
00182         begin( text_begin_ ) ^ end( text_end_ )
00183         );
00184 }

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > > cttl::literal ( CTTL_STD_STRING const &  text_begin_,
CTTL_STD_STRING const &  text_end_ 
)

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 148 of file xtl_metaphor.h.

00149 {
00150     return xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > >(
00151         begin( text_begin_ ) ^ end( text_end_ )
00152         );
00153 }

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > > cttl::literal ( CTTL_STD_CHAR const *  text_begin_,
CTTL_STD_CHAR const *  text_end_ 
)

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 120 of file xtl_metaphor.h.

00121 {
00122     // compile time function
00123     // literal() is example of a function returning complex expression of type "expr ^ expr"
00124     return xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > >(
00125         begin( text_begin_ ) ^ end( text_end_ )
00126         );
00127 }

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > > cttl::literal (  ) 

Implements behavior of literal metaphor inside CTTL grammar expression.

Returns:
Instance of C++ implementation class for grammar expression

Definition at line 89 of file xtl_metaphor.h.

00090 {
00091     const CTTL_STD_CHAR CTTL_QWERTY_CONST[] = CTTL_QWERTY_;
00092     const CTTL_STD_CHAR CTTL_QWERTY_123_CONST[] = CTTL_QWERTY_123_;
00093     return xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_STRING > >, xtl_wrap< xtl_text_end< CTTL_STD_STRING > > > >(
00094         //begin( CTTL_STD_STRING( CTTL_QWERTY_ ) ) ^ end( CTTL_STD_STRING( CTTL_QWERTY_123_ ) )
00095         begin( CTTL_STD_STRING( CTTL_QWERTY_CONST ) )
00096         ^
00097         end( CTTL_STD_STRING( CTTL_QWERTY_123_CONST ) )
00098         );
00099 }

template<typename BehindT , typename AheadT >
xtl_wrap< xtl_quote_bool< xtl_wrap< BehindT >, xtl_wrap< AheadT > > > cttl::lookbehind ( xtl_wrap< BehindT > const &  behind_,
xtl_wrap< AheadT > const &  ahead_ 
)

CTTL positive lookbehind assertion helper function.

Template Parameters:
BehindT specifies type of grammar expression, describing the first expression in lookbehind relation.
AheadT specifies type of grammar expression, describing the second expression in lookbehind relation.
Parameters:
behind_ constant reference to CTTL grammar expression to the first expression.
ahead_ constant reference to CTTL grammar expression to the second expression.
Returns:
Instance of C++ implementation class for CTTL grammar expression describing positive lookbehind relation.

Definition at line 194 of file xtl_quote_sym.h.

00195     {
00196         typedef
00197             xtl_quote_bool<
00198             xtl_wrap< BehindT >,
00199             xtl_wrap< AheadT >
00200             >
00201             xtl_quote_T;
00202 
00203         return xtl_wrap< xtl_quote_T >( xtl_quote_T( behind_, ahead_ ) );
00204     }

template<typename ExprT >
xtl_wrap< xtl_opunarbang< xtl_wrap< ExprT > > > cttl::operator! ( xtl_wrap< ExprT > const &  expr_  ) 

Overloads unary search operator.

Template Parameters:
ExprT specifies 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 74 of file xtl_op.h.

00075     {
00076         typedef
00077             xtl_opunarbang<
00078             xtl_wrap< ExprT >
00079             >
00080             opfind_T;
00081 
00082         return xtl_wrap< opfind_T >( opfind_T( expr_ ) );
00083     }

template<typename StringT >
bool cttl::operator!= ( node< StringT > const &  one_,
node< StringT > const &  another_ 
)

Compares two nodes.

Nodes are equal if their offsets are the same.

Definition at line 706 of file node.h.

00707     {
00708         return one_.offset() != another_.offset();
00709     }

template<typename PolicyT , typename StringT >
bool cttl::operator!= ( const_edge< PolicyT, StringT > const &  substr_,
typename StringT::value_type const *  cstr_ 
)

Compares substring to a C string.

Parameters:
substr_ substring.
cstr_ C string.

Definition at line 1192 of file const_edge.h.

01193     {
01194         return substr_.parent().compare(
01195             substr_.first.offset(),
01196             substr_.length(),
01197             cstr_
01198             ) != 0;
01199     }

template<typename PolicyT , typename StringT >
bool cttl::operator!= ( typename StringT::value_type const *  cstr_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares C string to a substring.

Parameters:
cstr_ C string.
substr_ substring.

Definition at line 1073 of file const_edge.h.

01074     {
01075         return substr_.parent().compare(
01076             substr_.first.offset(),
01077             substr_.length(),
01078             cstr_
01079             ) != 0;
01080     }

template<typename PolicyT , typename StringT >
bool cttl::operator!= ( StringT const &  str_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares string to a substring.

Parameters:
str_ string.
substr_ substring.

Definition at line 952 of file const_edge.h.

00953     {
00954         return str_.compare(
00955             0,
00956             str_.length(),
00957             substr_.parent(),
00958             substr_.first.offset(),
00959             substr_.length()
00960             ) != 0;
00961     }

template<typename PolicyT , typename StringT >
bool cttl::operator!= ( const_edge< PolicyT, StringT > const &  substr_,
StringT const &  str_ 
)

Compares substring to a string.

Parameters:
substr_ substring.
str_ string.

Definition at line 823 of file const_edge.h.

00824     {
00825         return substr_.parent().compare(
00826             substr_.first.offset(),
00827             substr_.length(),
00828             str_
00829             ) != 0;
00830     }

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

Compares two substrings.

Parameters:
one_ left substring.
another_ right substring.

Definition at line 702 of file const_edge.h.

00703     {
00704         return one_.parent().compare(
00705             one_.first.offset(),
00706             one_.length(),
00707             another_.parent(),
00708             another_.first.offset(),
00709             another_.length()
00710             ) != 0;
00711     }

template<typename Left_exprT , typename Right_exprT >
xtl_wrap< xtl_opbinand< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > > > cttl::operator& ( xtl_wrap< Left_exprT > const &  lhs_expr_,
xtl_wrap< Right_exprT > const &  rhs_expr_ 
)

Overloads binary set intersection operator.

Template Parameters:
Left_exprT specifies type of left-hand-side grammar expression object, determined by the C++ compiler at compile time.
Right_exprT specifies 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 559 of file xtl_op.h.

00560     {
00561         typedef
00562             xtl_opbinand<
00563             xtl_wrap< Left_exprT >,
00564             xtl_wrap< Right_exprT >
00565             >
00566             opbinand_T;
00567 
00568         return xtl_wrap< opbinand_T >( opbinand_T( lhs_expr_, rhs_expr_ ) );
00569     }

template<typename Left_exprT >
xtl_wrap< xtl_opunarstar< xtl_wrap< Left_exprT > > > cttl::operator* ( xtl_wrap< Left_exprT > const &  lhs_expr_,
int  upper_limit_ 
)

Overloads binary Kleene star operator.

Template Parameters:
Left_exprT specifies 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 146 of file xtl_op.h.

00147     {
00148         typedef
00149             xtl_opunarstar<
00150             xtl_wrap< Left_exprT >
00151             >
00152             opstar_T;
00153 
00154         return xtl_wrap< opstar_T >( opstar_T( lhs_expr_, upper_limit_ ) );
00155     }

template<typename ExprT >
xtl_wrap< xtl_opunarstar< xtl_wrap< ExprT > > > cttl::operator* ( xtl_wrap< ExprT > const &  expr_  ) 

Overloads unary Kleene star operator.

Template Parameters:
ExprT specifies 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 109 of file xtl_op.h.

00110     {
00111         typedef
00112             xtl_opunarstar<
00113             xtl_wrap< ExprT >
00114             >
00115             opstar_T;
00116 
00117         return xtl_wrap< opstar_T >( opstar_T( expr_ ) );
00118     }

template<typename Left_exprT , typename Right_exprT >
xtl_wrap< xtl_opbinplus< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > > > cttl::operator+ ( xtl_wrap< Left_exprT > const &  lhs_expr_,
xtl_wrap< Right_exprT > const &  rhs_expr_ 
)

Overloads binary sequence operator.

Template Parameters:
Left_exprT specifies type of left-hand-side grammar expression object, determined by the C++ compiler at compile time.
Right_exprT specifies 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 339 of file xtl_op.h.

00340     {
00341         typedef
00342             xtl_opbinplus<
00343             xtl_wrap< Left_exprT >,
00344             xtl_wrap< Right_exprT >
00345             >
00346             opplus_T;
00347 
00348         return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, rhs_expr_ ) );
00349     }

template<typename Left_exprT >
xtl_wrap< xtl_opunarplus< xtl_wrap< Left_exprT > > > cttl::operator+ ( xtl_wrap< Left_exprT > const &  lhs_expr_,
std::pair< int, int >  limits_ 
)

Overloads binary greedy Kleene plus operator.

Template Parameters:
Left_exprT specifies 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 258 of file xtl_op.h.

00259     {
00260         typedef
00261             xtl_opunarplus<
00262             xtl_wrap< Left_exprT >
00263             >
00264             opplus_T;
00265 
00266         return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, limits_.second, limits_.first ) );
00267     }

template<typename Left_exprT >
xtl_wrap< xtl_opunarplus< xtl_wrap< Left_exprT > > > cttl::operator+ ( xtl_wrap< Left_exprT > const &  lhs_expr_,
int  upper_limit_ 
)

Overloads binary Kleene plus operator.

Template Parameters:
Left_exprT specifies 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 217 of file xtl_op.h.

00218     {
00219         typedef
00220             xtl_opunarplus<
00221             xtl_wrap< Left_exprT >
00222             >
00223             opplus_T;
00224 
00225         return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, upper_limit_ ) );
00226     }

template<typename ExprT >
xtl_wrap< xtl_opunarplus< xtl_wrap< ExprT > > > cttl::operator+ ( xtl_wrap< ExprT > const &  expr_  ) 

Overloads unary Kleene plus operator.

Template Parameters:
ExprT specifies 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 180 of file xtl_op.h.

00181     {
00182         typedef
00183             xtl_opunarplus<
00184             xtl_wrap< ExprT >
00185             >
00186             opplus_T;
00187 
00188         return xtl_wrap< opplus_T >( opplus_T( expr_ ) );
00189     }

template<typename StringT >
node< StringT >& cttl::operator++ ( node< StringT > &  node_  ) 

Prefix increment operator increments node offset.

Definition at line 741 of file node.h.

00742     {
00743         node_.offset( node_.offset() + 1 );
00744         return node_;
00745     }

template<typename Left_exprT , typename Right_exprT >
xtl_wrap< xtl_opbinminus< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > > > cttl::operator- ( xtl_wrap< Left_exprT > const &  lhs_expr_,
xtl_wrap< Right_exprT > const &  rhs_expr_ 
)

Overloads binary set complement operator.

Template Parameters:
Left_exprT specifies type of left-hand-side grammar expression object, determined by the C++ compiler at compile time.
Right_exprT specifies 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 515 of file xtl_op.h.

00516     {
00517         typedef
00518             xtl_opbinminus<
00519             xtl_wrap< Left_exprT >,
00520             xtl_wrap< Right_exprT >
00521             >
00522             opbinminus_T;
00523 
00524         return xtl_wrap< opbinminus_T >( opbinminus_T( lhs_expr_, rhs_expr_ ) );
00525     }

template<typename ExprT >
xtl_wrap< xtl_opunarminus< xtl_wrap< ExprT > > > cttl::operator- ( xtl_wrap< ExprT > const &  expr_  ) 

Overloads unary negative lookahead assertion operator.

Template Parameters:
ExprT specifies 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 292 of file xtl_op.h.

00293     {
00294         typedef
00295             xtl_opunarminus<
00296             xtl_wrap< ExprT >
00297             >
00298             opminus_T;
00299 
00300         return xtl_wrap< opminus_T >( opminus_T( expr_ ) );
00301     }

template<typename StringT >
node< StringT >& cttl::operator-- ( node< StringT > &  node_  ) 

Prefix decrement operator decrements node offset.

Definition at line 749 of file node.h.

00750     {
00751         node_.offset( node_.offset() - 1 );
00752         return node_;
00753     }

template<typename StringT >
bool cttl::operator< ( node< StringT > const &  one_,
node< StringT > const &  another_ 
)

Compares offsets of two nodes.

Definition at line 720 of file node.h.

00721     {
00722         return one_.offset() < another_.offset();
00723     }

template<typename PolicyT , typename StringT >
bool cttl::operator< ( const_edge< PolicyT, StringT > const &  substr_,
typename StringT::value_type const *  cstr_ 
)

Compares substring to a C string.

Parameters:
substr_ substring.
cstr_ C string.

Definition at line 1097 of file const_edge.h.

01098     {
01099         return substr_.parent().compare(
01100             substr_.first.offset(),
01101             substr_.length(),
01102             cstr_
01103             ) < 0;
01104     }

template<typename PolicyT , typename StringT >
bool cttl::operator< ( typename StringT::value_type const *  cstr_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares C string to a substring.

Parameters:
cstr_ C string.
substr_ substring.

Definition at line 978 of file const_edge.h.

00979     {
00980         return -substr_.parent().compare(
00981             substr_.first.offset(),
00982             substr_.length(),
00983             cstr_
00984             ) < 0;
00985     }

template<typename PolicyT , typename StringT >
bool cttl::operator< ( StringT const &  str_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares string to a substring.

Parameters:
str_ string.
substr_ substring.

Definition at line 847 of file const_edge.h.

00848     {
00849         return str_.compare(
00850             0,
00851             str_.length(),
00852             substr_.parent(),
00853             substr_.first.offset(),
00854             substr_.length()
00855             ) < 0;
00856     }

template<typename PolicyT , typename StringT >
bool cttl::operator< ( const_edge< PolicyT, StringT > const &  substr_,
StringT const &  str_ 
)

Compares substring to a string.

Parameters:
substr_ substring.
str_ string.

Definition at line 728 of file const_edge.h.

00729     {
00730         return substr_.parent().compare(
00731             substr_.first.offset(),
00732             substr_.length(),
00733             str_
00734             ) < 0;
00735     }

template<typename PolicyT , typename StringT >
bool cttl::operator< ( const_edge< PolicyT, StringT > const &  one_,
const_edge< PolicyT, StringT > const &  another_ 
)

Compares two substrings.

Parameters:
one_ left substring.
another_ right substring.

Definition at line 597 of file const_edge.h.

00598     {
00599         return one_.parent().compare(
00600             one_.first.offset(),
00601             one_.length(),
00602             another_.parent(),
00603             another_.first.offset(),
00604             another_.length()
00605             ) < 0;
00606     }

template<typename PolicyT , typename StringT >
std::ostream& cttl::operator<< ( std::ostream &  os_,
const_edge< PolicyT, StringT > const &  edge_ 
)

Stream insertion operator performs substring output operation on std::ostream.

Definition at line 581 of file const_edge.h.

00582     {
00583         os_ << edge_.text();
00584         return os_;
00585     }

template<typename StringT >
bool cttl::operator<= ( node< StringT > const &  one_,
node< StringT > const &  another_ 
)

Compares offsets of two nodes.

Definition at line 734 of file node.h.

00735     {
00736         return one_.offset() <= another_.offset();
00737     }

template<typename PolicyT , typename StringT >
bool cttl::operator<= ( const_edge< PolicyT, StringT > const &  substr_,
typename StringT::value_type const *  cstr_ 
)

Compares substring to a C string.

Parameters:
substr_ substring.
cstr_ C string.

Definition at line 1154 of file const_edge.h.

01155     {
01156         return substr_.parent().compare(
01157             substr_.first.offset(),
01158             substr_.length(),
01159             cstr_
01160             ) <= 0;
01161     }

template<typename PolicyT , typename StringT >
bool cttl::operator<= ( typename StringT::value_type const *  cstr_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares C string to a substring.

Parameters:
cstr_ C string.
substr_ substring.

Definition at line 1035 of file const_edge.h.

01036     {
01037         return -substr_.parent().compare(
01038             substr_.first.offset(),
01039             substr_.length(),
01040             cstr_
01041             ) <= 0;
01042     }

template<typename PolicyT , typename StringT >
bool cttl::operator<= ( StringT const &  str_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares string to a substring.

Parameters:
str_ string.
substr_ substring.

Definition at line 910 of file const_edge.h.

00911     {
00912         return str_.compare(
00913             0,
00914             str_.length(),
00915             substr_.parent(),
00916             substr_.first.offset(),
00917             substr_.length()
00918             ) <= 0;
00919     }

template<typename PolicyT , typename StringT >
bool cttl::operator<= ( const_edge< PolicyT, StringT > const &  substr_,
StringT const &  str_ 
)

Compares substring to a string.

Parameters:
substr_ substring.
str_ string.

Definition at line 785 of file const_edge.h.

00786     {
00787         return substr_.parent().compare(
00788             substr_.first.offset(),
00789             substr_.length(),
00790             str_
00791             ) <= 0;
00792     }

template<typename PolicyT , typename StringT >
bool cttl::operator<= ( const_edge< PolicyT, StringT > const &  one_,
const_edge< PolicyT, StringT > const &  another_ 
)

Compares two substrings.

Parameters:
one_ left substring.
another_ right substring.

Definition at line 660 of file const_edge.h.

00661     {
00662         return one_.parent().compare(
00663             one_.first.offset(),
00664             one_.length(),
00665             another_.parent(),
00666             another_.first.offset(),
00667             another_.length()
00668             ) <= 0;
00669     }

template<typename StringT >
bool cttl::operator== ( node< StringT > const &  one_,
node< StringT > const &  another_ 
)

Compares two nodes.

Nodes are equal if their offsets are the same.

Definition at line 699 of file node.h.

00700     {
00701         return one_.offset() == another_.offset();
00702     }

template<typename PolicyT , typename StringT >
bool cttl::operator== ( const_edge< PolicyT, StringT > const &  substr_,
typename StringT::value_type const *  cstr_ 
)

Compares substring to a C string.

Parameters:
substr_ substring.
cstr_ C string.

Definition at line 1173 of file const_edge.h.

01174     {
01175         return substr_.parent().compare(
01176             substr_.first.offset(),
01177             substr_.length(),
01178             cstr_
01179             ) == 0;
01180     }

template<typename PolicyT , typename StringT >
bool cttl::operator== ( typename StringT::value_type const *  cstr_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares C string to a substring.

Parameters:
cstr_ C string.
substr_ substring.

Definition at line 1054 of file const_edge.h.

01055     {
01056         return substr_.parent().compare(
01057             substr_.first.offset(),
01058             substr_.length(),
01059             cstr_
01060             ) == 0;
01061     }

template<typename PolicyT , typename StringT >
bool cttl::operator== ( StringT const &  str_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares string to a substring.

Parameters:
str_ string.
substr_ substring.

Definition at line 931 of file const_edge.h.

00932     {
00933         return str_.compare(
00934             0,
00935             str_.length(),
00936             substr_.parent(),
00937             substr_.first.offset(),
00938             substr_.length()
00939             ) == 0;
00940     }

template<typename PolicyT , typename StringT >
bool cttl::operator== ( const_edge< PolicyT, StringT > const &  substr_,
StringT const &  str_ 
)

Compares substring to a string.

Parameters:
substr_ substring.
str_ string.

Definition at line 804 of file const_edge.h.

00805     {
00806         return substr_.parent().compare(
00807             substr_.first.offset(),
00808             substr_.length(),
00809             str_
00810             ) == 0;
00811     }

template<typename PolicyT , typename StringT >
bool cttl::operator== ( const_edge< PolicyT, StringT > const &  one_,
const_edge< PolicyT, StringT > const &  another_ 
)

Compares two substrings.

Parameters:
one_ left substring.
another_ right substring.

Definition at line 681 of file const_edge.h.

00682     {
00683         return one_.parent().compare(
00684             one_.first.offset(),
00685             one_.length(),
00686             another_.parent(),
00687             another_.first.offset(),
00688             another_.length()
00689             ) == 0;
00690     }

template<typename StringT >
bool cttl::operator> ( node< StringT > const &  one_,
node< StringT > const &  another_ 
)

Compares offsets of two nodes.

Definition at line 713 of file node.h.

00714     {
00715         return one_.offset() > another_.offset();
00716     }

template<typename PolicyT , typename StringT >
bool cttl::operator> ( const_edge< PolicyT, StringT > const &  substr_,
typename StringT::value_type const *  cstr_ 
)

Compares substring to a C string.

Parameters:
substr_ substring.
cstr_ C string.

Definition at line 1116 of file const_edge.h.

01117     {
01118         return substr_.parent().compare(
01119             substr_.first.offset(),
01120             substr_.length(),
01121             cstr_
01122             ) > 0;
01123     }

template<typename PolicyT , typename StringT >
bool cttl::operator> ( typename StringT::value_type const *  cstr_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares C string to a substring.

Parameters:
cstr_ C string.
substr_ substring.

Definition at line 997 of file const_edge.h.

00998     {
00999         return -substr_.parent().compare(
01000             substr_.first.offset(),
01001             substr_.length(),
01002             cstr_
01003             ) > 0;
01004     }

template<typename PolicyT , typename StringT >
bool cttl::operator> ( StringT const &  str_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares string to a substring.

Parameters:
str_ string.
substr_ substring.

Definition at line 868 of file const_edge.h.

00869     {
00870         return str_.compare(
00871             0,
00872             str_.length(),
00873             substr_.parent(),
00874             substr_.first.offset(),
00875             substr_.length()
00876             ) > 0;
00877     }

template<typename PolicyT , typename StringT >
bool cttl::operator> ( const_edge< PolicyT, StringT > const &  substr_,
StringT const &  str_ 
)

Compares substring to a string.

Parameters:
substr_ substring.
str_ string.

Definition at line 747 of file const_edge.h.

00748     {
00749         return substr_.parent().compare(
00750             substr_.first.offset(),
00751             substr_.length(),
00752             str_
00753             ) > 0;
00754     }

template<typename PolicyT , typename StringT >
bool cttl::operator> ( const_edge< PolicyT, StringT > const &  one_,
const_edge< PolicyT, StringT > const &  another_ 
)

Compares two substrings.

Parameters:
one_ left substring.
another_ right substring.

Definition at line 618 of file const_edge.h.

00619     {
00620         return one_.parent().compare(
00621             one_.first.offset(),
00622             one_.length(),
00623             another_.parent(),
00624             another_.first.offset(),
00625             another_.length()
00626             ) > 0;
00627     }

template<typename StringT >
bool cttl::operator>= ( node< StringT > const &  one_,
node< StringT > const &  another_ 
)

Compares offsets of two nodes.

Definition at line 727 of file node.h.

00728     {
00729         return one_.offset() >= another_.offset();
00730     }

template<typename PolicyT , typename StringT >
bool cttl::operator>= ( const_edge< PolicyT, StringT > const &  substr_,
typename StringT::value_type const *  cstr_ 
)

Compares substring to a C string.

Parameters:
substr_ substring.
cstr_ C string.

Definition at line 1135 of file const_edge.h.

01136     {
01137         return substr_.parent().compare(
01138             substr_.first.offset(),
01139             substr_.length(),
01140             cstr_
01141             ) >= 0;
01142     }

template<typename PolicyT , typename StringT >
bool cttl::operator>= ( typename StringT::value_type const *  cstr_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares C string to a substring.

Parameters:
cstr_ C string.
substr_ substring.

Definition at line 1016 of file const_edge.h.

01017     {
01018         return -substr_.parent().compare(
01019             substr_.first.offset(),
01020             substr_.length(),
01021             cstr_
01022             ) >= 0;
01023     }

template<typename PolicyT , typename StringT >
bool cttl::operator>= ( StringT const &  str_,
const_edge< PolicyT, StringT > const &  substr_ 
)

Compares string to a substring.

Parameters:
str_ string.
substr_ substring.

Definition at line 889 of file const_edge.h.

00890     {
00891         return str_.compare(
00892             0,
00893             str_.length(),
00894             substr_.parent(),
00895             substr_.first.offset(),
00896             substr_.length()
00897             ) >= 0;
00898     }

template<typename PolicyT , typename StringT >
bool cttl::operator>= ( const_edge< PolicyT, StringT > const &  substr_,
StringT const &  str_ 
)

Compares substring to a string.

Parameters:
substr_ substring.
str_ string.

Definition at line 766 of file const_edge.h.

00767     {
00768         return substr_.parent().compare(
00769             substr_.first.offset(),
00770             substr_.length(),
00771             str_
00772             ) >= 0;
00773     }

template<typename PolicyT , typename StringT >
bool cttl::operator>= ( const_edge< PolicyT, StringT > const &  one_,
const_edge< PolicyT, StringT > const &  another_ 
)

Compares two substrings.

Parameters:
one_ left substring.
another_ right substring.

Definition at line 639 of file const_edge.h.

00640     {
00641         return one_.parent().compare(
00642             one_.first.offset(),
00643             one_.length(),
00644             another_.parent(),
00645             another_.first.offset(),
00646             another_.length()
00647             ) >= 0;
00648     }

template<typename PolicyT , typename StringT >
std::istream& cttl::operator>> ( std::istream &  is_,
edge< PolicyT, StringT > &  edge_ 
)

Input stream extraction operator performs an input operation on std::istream.

Definition at line 634 of file edge.h.

00635     {
00636         StringT temp;
00637         is_ >> temp;
00638         edge_.text( temp );
00639         return is_;
00640     }

template<typename Left_exprT , typename Right_exprT >
xtl_wrap< xtl_opbinconcat< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > > > cttl::operator^ ( xtl_wrap< Left_exprT > const &  lhs_expr_,
xtl_wrap< Right_exprT > const &  rhs_expr_ 
)

Overloads binary concatenation operator.

Template Parameters:
Left_exprT specifies type of left-hand-side grammar expression object, determined by the C++ compiler at compile time.
Right_exprT specifies 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 471 of file xtl_op.h.

00472     {
00473         typedef
00474             xtl_opbinconcat<
00475             xtl_wrap< Left_exprT >,
00476             xtl_wrap< Right_exprT >
00477             >
00478             opconcat_T;
00479 
00480         return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, rhs_expr_ ) );
00481     }

template<typename Left_exprT , typename Right_exprT >
xtl_wrap< xtl_opbinpipe< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > > > cttl::operator| ( xtl_wrap< Left_exprT > const &  lhs_expr_,
xtl_wrap< Right_exprT > const &  rhs_expr_ 
)

Overloads binary set union operator.

Template Parameters:
Left_exprT specifies type of left-hand-side grammar expression object, determined by the C++ compiler at compile time.
Right_exprT specifies 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 383 of file xtl_op.h.

00384     {
00385         typedef
00386             xtl_opbinpipe<
00387             xtl_wrap< Left_exprT >,
00388             xtl_wrap< Right_exprT >
00389             >
00390             oppipe_T;
00391 
00392         return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, rhs_expr_ ) );
00393     }

template<typename Left_exprT , typename Right_exprT >
xtl_wrap< xtl_opbin2pipe< xtl_wrap< Left_exprT >, xtl_wrap< Right_exprT > > > cttl::operator|| ( xtl_wrap< Left_exprT > const &  lhs_expr_,
xtl_wrap< Right_exprT > const &  rhs_expr_ 
)

Overloads binary POSIX union operator.

Template Parameters:
Left_exprT specifies type of left-hand-side grammar expression object, determined by the C++ compiler at compile time.
Right_exprT specifies 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 427 of file xtl_op.h.

00428     {
00429         typedef
00430             xtl_opbin2pipe<
00431             xtl_wrap< Left_exprT >,
00432             xtl_wrap< Right_exprT >
00433             >
00434             oppipe_T;
00435 
00436         return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, rhs_expr_ ) );
00437     }

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 > > > > cttl::quote ( CTTL_STD_CHAR  left_,
xtl_wrap< MiddleT > const &  middle_,
CTTL_STD_CHAR  right_ 
)

CTTL quote helper function function generating implementation for single-character quotes.

Template Parameters:
MiddleT specifies 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 241 of file xtl_quote_sym.h.

00242     {
00243         typedef
00244             xtl_quote_generic<
00245             xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
00246             xtl_wrap< MiddleT >,
00247             xtl_wrap< xtl_char< CTTL_STD_CHAR > >
00248             >
00249             xtl_quote_T;
00250 
00251         return xtl_wrap< xtl_quote_T >( xtl_quote_T( xtl_char< CTTL_STD_CHAR >( left_ ), middle_, xtl_char< CTTL_STD_CHAR >( right_ ) ) );
00252     }

template<typename MiddleT , typename RightT >
xtl_wrap< xtl_quote_bool< xtl_wrap< MiddleT >, xtl_wrap< RightT > > > cttl::quote ( bool  ,
xtl_wrap< MiddleT > const &  middle_,
xtl_wrap< RightT > const &  right_ 
)

CTTL quote helper function function generating implementation for asymmetric quotes.

Template Parameters:
MiddleT specifies type of grammar expression, describing interior clause of the quote.
RightT specifies 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 144 of file xtl_quote_sym.h.

00145     {
00146         typedef
00147             xtl_quote_bool<
00148             xtl_wrap< MiddleT >,
00149             xtl_wrap< RightT >
00150             >
00151             xtl_quote_T;
00152 
00153         return xtl_wrap< xtl_quote_T >( xtl_quote_T( middle_, right_ ) );
00154     }

template<typename LeftT , typename MiddleT , typename RightT >
xtl_wrap< xtl_quote_generic< xtl_wrap< LeftT >, xtl_wrap< MiddleT >, xtl_wrap< RightT > > > cttl::quote ( xtl_wrap< LeftT > const &  left_,
xtl_wrap< MiddleT > const &  middle_,
xtl_wrap< RightT > const &  right_ 
)

CTTL quote helper function for implementation of generic quote.

Template Parameters:
LeftT specifies type of grammar expression, describing opening clause of the quote.
MiddleT specifies type of grammar expression, describing interior clause of the quote.
RightT specifies 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.

00094     {
00095         typedef
00096             xtl_quote_generic<
00097             xtl_wrap< LeftT >,
00098             xtl_wrap< MiddleT >,
00099             xtl_wrap< RightT >
00100             >
00101             xtl_quote_T;
00102 
00103         return xtl_wrap< xtl_quote_T >( xtl_quote_T( left_, middle_, right_ ) );
00104     }

template<typename ObjectT , typename PredicateT >
xtl_wrap< xtl_member_predicate< ObjectT, PredicateT > > cttl::rule ( ObjectT &  object_ref_,
PredicateT  pred_ 
)

CTTL function adaptor, generating implementation for member function adaptor.

Template Parameters:
ObjectT specifies type of C++ class that defines non-static member function Member_predicateT.
Member_predicateT specifies 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 101 of file xtl_sym.h.

00102     {
00103         return xtl_wrap< xtl_member_predicate< ObjectT, PredicateT > >( xtl_member_predicate< ObjectT, PredicateT >( object_ref_, pred_ ) );
00104     }

template<typename Static_predicateT >
xtl_wrap< xtl_predicate< Static_predicateT > > cttl::rule ( const Static_predicateT  pred_  ) 

CTTL function adaptor, generating implementation for static grammar rule adaptor.

Template Parameters:
Static_predicateT specifies type which is copy-constructible, and, if SubstrT is a typename that represents cttl::const_edge or cttl::edge, Static_predicateT can be invoked as
    size_t operator()( SubstrT& );
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 the static grammar rule adaptor.

Definition at line 69 of file xtl_sym.h.

00070     {
00071         return xtl_wrap< xtl_predicate< Static_predicateT > >( pred_ );
00072     }

template<typename StringT , typename CharT >
void cttl::string_array2string ( StringT &  str_,
CharT const *const *  array_,
CharT  delimiter_ 
)

Loads text from array of string literals into a string provided by the user.

Template Parameters:
StringT specifies type of the string.
CharT specifies 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 const* arr[] = { "abc", "def", NULL };

Definition at line 155 of file coreutils.h.

00156     {
00157         const CharT delimiter[] = { delimiter_, 0x00 };
00158         string_array2string( str_, array_, delimiter );
00159     }

template<typename StringT , typename CharT >
void cttl::string_array2string ( StringT &  str_,
CharT const *const *  array_ 
)

Loads text from array of string literals into a string provided by the user.

Template Parameters:
StringT specifies type of the string.
CharT specifies character type.
Parameters:
str_ reference to the target string.
array_ source array of string literals.
Precondition:
Array should have trailing NULL string, for example,
char const* arr[] = { "abc", "def", NULL };

Definition at line 125 of file coreutils.h.

00126     {
00127         static const CharT delimiter[] = { CharT( '\t' ), 0x00 };
00128         string_array2string( str_, array_, delimiter );
00129     }

template<typename StringT , typename CharT >
void cttl::string_array2string ( StringT &  str_,
CharT const *const *  array_,
CharT const *  delimiter_ 
)

Loads text from array of string literals into a string provided by the user.

Template Parameters:
StringT specifies type of the string.
CharT specifies 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 const* arr[] = { "abc", "def", NULL };

Definition at line 88 of file coreutils.h.

00089     {
00090         assert( array_ );
00091         if ( !*array_ ) {
00092             str_.clear();
00093             return;
00094         }
00095         str_ = *array_++;
00096 
00097         while ( *array_ ) {
00098             if ( delimiter_ )
00099                 str_ += delimiter_;
00100             str_ += *array_++;
00101         }
00102     }

template<typename StringT >
void cttl::string_tolower ( StringT &  str_  ) 

Converts string to lowercase.

Definition at line 58 of file coreutils.h.

00059     {
00060         std::transform( str_.begin(), str_.end(), str_.begin(), tolower );
00061 
00062     }

template<typename StringT >
void cttl::string_toupper ( StringT &  str_  ) 

Converts string to UPPERCASE.

Definition at line 50 of file coreutils.h.

00051     {
00052         std::transform( str_.begin(), str_.end(), str_.begin(), toupper );
00053     }

xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > > cttl::symbol ( CTTL_STD_WSTRING const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    symbol(std::wstring const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1337 of file xtl_sym.h.

01338     {
01339         return xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >( any_text_ );
01340     }

xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > > cttl::symbol ( CTTL_STD_STRING const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    symbol(std::string const*)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1315 of file xtl_sym.h.

01316     {
01317         return xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >( any_text_ );
01318     }

xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > > cttl::symbol ( CTTL_STD_WSTRING const &  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    symbol(std::wstring const&)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1293 of file xtl_sym.h.

01294     {
01295         return xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >( any_text_ );
01296     }

xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > > cttl::symbol ( CTTL_STD_STRING const &  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

    symbol(std::string const&)

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1271 of file xtl_sym.h.

01272     {
01273         return xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >( any_text_ );
01274     }

xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > > cttl::symbol ( CTTL_STD_WCHAR const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1250 of file xtl_sym.h.

01251     {
01252         return xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >( any_text_ );
01253     }

xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > > cttl::symbol ( CTTL_STD_CHAR const *  any_text_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
any_text_ text to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 1228 of file xtl_sym.h.

01229     {
01230         return xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >( any_text_ );
01231     }

xtl_wrap< xtl_char< CTTL_STD_CHAR > > cttl::symbol ( int  char_  ) 

CTTL lexeme function helper implementation.

Usage:

    symbol(int)

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 252 of file xtl_sym.h.

00253     {
00254         // allows symbol( 0x0a ) notation for individual characters
00255         return xtl_wrap< xtl_char< CTTL_STD_CHAR > >( CTTL_STD_CHAR( char_ ) );
00256     }

xtl_wrap< xtl_char< CTTL_STD_WCHAR > > cttl::symbol ( CTTL_STD_WCHAR  char_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 231 of file xtl_sym.h.

00232     {
00233         return xtl_wrap< xtl_char< CTTL_STD_WCHAR > >( char_ );
00234     }

xtl_wrap< xtl_char< CTTL_STD_CHAR > > cttl::symbol ( CTTL_STD_CHAR  char_  ) 

CTTL lexeme function helper implementation.

Usage:

Parameters:
char_ character to match.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 210 of file xtl_sym.h.

00211     {
00212         return xtl_wrap< xtl_char< CTTL_STD_CHAR > >( char_ );
00213     }

xtl_wrap< xtl_bool< false > > cttl::symbol ( bool  bool_  ) 

CTTL lexeme function helper implementation.

Usage:

    symbol(true)
and
    symbol(false)

Parameters:
bool_ boolean flag specifying type of the lexeme.
Returns:
Instance of C++ lexeme implementation class.

Definition at line 162 of file xtl_sym.h.

00163     {
00164         // fails on empty substring
00165         return xtl_wrap< xtl_bool< false > >( bool_ );
00166     }

xtl_wrap< xtl_char_symbol > cttl::symbol (  ) 

CTTL lexeme function helper implementation.

Usage:

    symbol( )

Returns:
Instance of C++ lexeme implementation class.

Definition at line 119 of file xtl_sym.h.

00120     {
00121         return xtl_wrap< xtl_char_symbol >();
00122     }

wchar_ansi_double_quote_T cttl::wchar_ansi_double_quote (  ) 

CTTL quote helper function function generating implementation for wide character ANSI double quotes.

Returns:
Instance of C++ implementation class for CTTL grammar expression describing wide character ANSI double quote.
Remarks:
This version of overloaded function assumes that any content inside the quotes is acceptable, including an empty string.

Definition at line 588 of file xtl_quote_sym.h.

00589     {
00590         return wchar_ansi_double_quote_T( xtl_quote_ansi_double_quote< relaxed_bool_T, CTTL_STD_WCHAR >( true ) );
00591     }

template<typename MiddleT >
xtl_wrap< xtl_quote_ansi_double_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > > cttl::wchar_ansi_double_quote ( xtl_wrap< MiddleT > const &  middle_  ) 

CTTL quote helper function function generating implementation for wide character ANSI double quotes.

Template Parameters:
MiddleT specifies 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 character ANSI double quote.

Definition at line 567 of file xtl_quote_sym.h.

00568     {
00569         return xtl_wrap< xtl_quote_ansi_double_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > >( xtl_quote_ansi_double_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR >( middle_ ) );
00570     }

wchar_ansi_single_quote_T cttl::wchar_ansi_single_quote (  ) 

CTTL quote helper function function generating implementation for wide character ANSI single quotes.

Returns:
Instance of C++ implementation class for CTTL grammar expression describing wide character ANSI single quote.
Remarks:
This version of overloaded function assumes that any content inside the quotes is acceptable, including an empty string.

Definition at line 540 of file xtl_quote_sym.h.

00541     {
00542         return wchar_ansi_single_quote_T( xtl_quote_ansi_single_quote< relaxed_bool_T, CTTL_STD_WCHAR >( true ) );
00543     }

template<typename MiddleT >
xtl_wrap< xtl_quote_ansi_single_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > > cttl::wchar_ansi_single_quote ( xtl_wrap< MiddleT > const &  middle_  ) 

CTTL quote helper function function generating implementation for wide character ANSI single quotes.

Template Parameters:
MiddleT specifies 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 character ANSI single quote.

Definition at line 520 of file xtl_quote_sym.h.

00521     {
00522         return xtl_wrap< xtl_quote_ansi_single_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > >( xtl_quote_ansi_single_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR >( middle_ ) );
00523     }

wchar_c_double_quote_T cttl::wchar_c_double_quote (  ) 

CTTL quote helper function function generating implementation for wide character C double quotes.

Returns:
Instance of C++ implementation class for CTTL grammar expression describing wide character C double quote.
Remarks:
This version of overloaded function assumes that any content inside the quotes is acceptable, including an empty string.

Definition at line 687 of file xtl_quote_sym.h.

00688     {
00689         return wchar_c_double_quote_T( xtl_quote_c_double_quote< relaxed_bool_T, CTTL_STD_WCHAR >( true ) );
00690     }

template<typename MiddleT >
xtl_wrap< xtl_quote_c_double_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > > cttl::wchar_c_double_quote ( xtl_wrap< MiddleT > const &  middle_  ) 

CTTL quote helper function function generating implementation for wide character C double quotes.

Template Parameters:
MiddleT specifies 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 character C double quote.

Definition at line 666 of file xtl_quote_sym.h.

00667     {
00668         return xtl_wrap< xtl_quote_c_double_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > >( xtl_quote_c_double_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR >( middle_ ) );
00669     }

wchar_c_single_quote_T cttl::wchar_c_single_quote (  ) 

CTTL quote helper function function generating implementation for wide character C single quotes.

Returns:
Instance of C++ implementation class for CTTL grammar expression describing wide character C single quote.
Remarks:
This version of overloaded function assumes that any content inside the quotes is acceptable, including an empty string.

Definition at line 639 of file xtl_quote_sym.h.

00640     {
00641         return wchar_c_single_quote_T( xtl_quote_c_single_quote< relaxed_bool_T, CTTL_STD_WCHAR >( true ) );
00642     }

template<typename MiddleT >
xtl_wrap< xtl_quote_c_single_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > > cttl::wchar_c_single_quote ( xtl_wrap< MiddleT > const &  middle_  ) 

CTTL quote helper function function generating implementation for wide character C single quotes.

Template Parameters:
MiddleT specifies 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 character C single quote.

Definition at line 618 of file xtl_quote_sym.h.

00619     {
00620         return xtl_wrap< xtl_quote_c_single_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR > >( xtl_quote_c_single_quote< xtl_wrap< MiddleT >, CTTL_STD_WCHAR >( middle_ ) );
00621     }

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_ref_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_ref_end< CTTL_STD_WSTRING > > > > cttl::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.

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 285 of file xtl_metaphor.h.

00286 {
00287     return xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_ref_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_ref_end< CTTL_STD_WSTRING > > > >(
00288         begin( text_begin_ ) ^ end( text_end_ )
00289         );
00290 }

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > > cttl::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.

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 253 of file xtl_metaphor.h.

00254 {
00255     return xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > >(
00256         begin( text_begin_ ) ^ end( text_end_ )
00257         );
00258 }

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > > cttl::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.

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 226 of file xtl_metaphor.h.

00227 {
00228     return xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > >(
00229         begin( text_begin_ ) ^ end( text_end_ )
00230         );
00231 }

xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > > cttl::wchar_literal (  ) 

Implements behavior of wide character literal metaphor inside CTTL grammar expression.

Returns:
Instance of C++ implementation class for grammar expression

Definition at line 199 of file xtl_metaphor.h.

00200 {
00201     return xtl_wrap< xtl_opbinconcat< xtl_wrap< xtl_text_begin< CTTL_STD_WSTRING > >, xtl_wrap< xtl_text_end< CTTL_STD_WSTRING > > > >(
00202         begin( CTTL_STD_WSTRING( CTTL_WCHAR_QWERTY_ ) ) ^ end( CTTL_STD_WSTRING( CTTL_WCHAR_QWERTY_123_ ) )
00203         );
00204 }

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 > > > > cttl::wchar_quote ( CTTL_STD_WCHAR  left_,
xtl_wrap< MiddleT > const &  middle_,
CTTL_STD_WCHAR  right_ 
)

CTTL quote helper function function generating implementation for single wide character quotes.

Template Parameters:
MiddleT specifies 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 289 of file xtl_quote_sym.h.

00290     {
00291         typedef
00292             xtl_quote_generic<
00293             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
00294             xtl_wrap< MiddleT >,
00295             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
00296             >
00297             xtl_quote_T;
00298 
00299         return xtl_wrap< xtl_quote_T >( xtl_quote_T( xtl_char< CTTL_STD_WCHAR >( left_ ), middle_, xtl_char< CTTL_STD_WCHAR >( right_ ) ) );
00300     }


Variable Documentation

const int cttl::flag_cpp_comments = 8

Suggests that the specialization understands C/C++ comments.

Definition at line 59 of file policy.h.

Shorthand for both white space and user-defined void regions.

Definition at line 62 of file policy.h.

const int cttl::flag_follow_region = 2

Suggests that the specialization understands user-defined void regions.

Definition at line 53 of file policy.h.

const int cttl::flag_follow_space = 1

Suggests that the specialization understands conventional white space.

Definition at line 50 of file policy.h.

const int cttl::flag_greedy = 4

Suggests that the specialization implements greedy evaluation algorithm.

Definition at line 56 of file policy.h.


Generated on Sun Aug 23 13:43:44 2009 for Common Text Transformation Library by  doxygen 1.5.9