<<<    Table Of Contents     Substrings >>>
##
A Aa Ab Ac Ad Ae Af Ag Ah Ai Aj Ak Al Am An Ao Ap Aq Ar As At Au Av Aw Ax Ay Az
B Ba Bb Bc Bd Be Bf Bg Bh Bi Bj Bk Bl Bm Bn Bo Bp Bq Br Bs Bt Bu Bv Bw Bx By Bz
C Ca Cb Cc Cd Ce Cf Cg Ch Ci Cj Ck Cl Cm Cn Co Cp Cq Cr Cs Ct Cu Cv Cw Cx Cy Cz
D Da Db Dc Dd De Df Dg Dh Di Dj Dk Dl Dm Dn Do Dp Dq Dr Ds Dt Du Dv Dw Dx Dy Dz
E Ea Eb Ec Ed Ee Ef Eg Eh Ei Ej Ek El Em En Eo Ep Eq Er Es Et Eu Ev Ew Ex Ey Ez
F Fa Fb Fc Fd Fe Ff Fg Fh Fi Fj Fk Fl Fm Fn Fo Fp Fq Fr Fs Ft Fu Fv Fw Fx Fy Fz
G Ga Gb Gc Gd Ge Gf Gg Gh Gi Gj Gk Gl Gm Gn Go Gp Gq Gr Gs Gt Gu Gv Gw Gx Gy Gz
H Ha Hb Hc Hd He Hf Hg Hh Hi Hj Hk Hl Hm Hn Ho Hp Hq Hr Hs Ht Hu Hv Hw Hx Hy Hz
I Ia Ib Ic Id Ie If Ig Ih Ii Ij Ik Il Im In Io Ip Iq Ir Is It Iu Iv Iw Ix Iy Iz
J Ja Jb Jc Jd Je Jf Jg Jh Ji Jj Jk Jl Jm Jn Jo Jp Jq Jr Js Jt Ju Jv Jw Jx Jy Jz
K Ka Kb Kc Kd Ke Kf Kg Kh Ki Kj Kk Kl Km Kn Ko Kp Kq Kr Ks Kt Ku Kv Kw Kx Ky Kz
L La Lb Lc Ld Le Lf Lg Lh Li Lj Lk Ll Lm Ln Lo Lp Lq Lr Ls Lt Lu Lv Lw Lx Ly Lz
M Ma Mb Mc Md Me Mf Mg Mh Mi Mj Mk Ml Mm Mn Mo Mp Mq Mr Ms Mt Mu Mv Mw Mx My Mz
N Na Nb Nc Nd Ne Nf Ng Nh Ni Nj Nk Nl Nm Nn No Np Nq Nr Ns Nt Nu Nv Nw Nx Ny Nz
O Oa Ob Oc Od Oe Of Og Oh Oi Oj Ok Ol Om On Oo Op Oq Or Os Ot Ou Ov Ow Ox Oy Oz
P Pa Pb Pc Pd Pe Pf Pg Ph Pi Pj Pk Pl Pm Pn Po Pp Pq Pr Ps Pt Pu Pv Pw Px Py Pz
Q Qa Qb Qc Qd Qe Qf Qg Qh Qi Qj Qk Ql Qm Qn Qo Qp Qq Qr Qs Qt Qu Qv Qw Qx Qy Qz
R Ra Rb Rc Rd Re Rf Rg Rh Ri Rj Rk Rl Rm Rn Ro Rp Rq Rr Rs Rt Ru Rv Rw Rx Ry Rz
S Sa Sb Sc Sd Se Sf Sg Sh Si Sj Sk Sl Sm Sn So Sp Sq Sr Ss St Su Sv Sw Sx Sy Sz
T Ta Tb Tc Td Te Tf Tg Th Ti Tj Tk Tl Tm Tn To Tp Tq Tr Ts Tt Tu Tv Tw Tx Ty Tz
U Ua Ub Uc Ud Ue Uf Ug Uh Ui Uj Uk Ul Um Un Uo Up Uq Ur Us Ut Uu Uv Uw Ux Uy Uz
V Va Vb Vc Vd Ve Vf Vg Vh Vi Vj Vk Vl Vm Vn Vo Vp Vq Vr Vs Vt Vu Vv Vw Vx Vy Vz
W Wa Wb Wc Wd We Wf Wg Wh Wi Wj Wk Wl Wm Wn Wo Wp Wq Wr Ws Wt Wu Wv Ww Wx Wy Wz
X Xa Xb Xc Xd Xe Xf Xg Xh Xi Xj Xk Xl Xm Xn Xo Xp Xq Xr Xs Xt Xu Xv Xw Xx Xy Xz
Y Ya Yb Yc Yd Ye Yf Yg Yh Yi Yj Yk Yl Ym Yn Yo Yp Yq Yr Ys Yt Yu Yv Yw Yx Yy Yz
Z Za Zb Zc Zd Ze Zf Zg Zh Zi Zj Zk Zl Zm Zn Zo Zp Zq Zr Zs Zt Zu Zv Zw Zx Zy Zz


##

AB

absolute complement -R negative lookahead assertion
absolute offset Basic terminology
absolute, lowest absolute offset Nearest terminal symbol
Abstract alphabet Lexer design
abstract symbol Lexer design
Abstract syntax tree Abstract syntax tree
abstract syntax tree Case study: XML stream parser

AC

access, constant and mutable data access Substring classes const_edge and edge
access, Node character access Node character access
accumulate_words Parser design
action, semantic action EBNF grammars
action, semantic action Arithmetic parser organization
action_handler.cpp Member function pointers
actions, semantic actions Parser design
actions, Semantic actions Semantic actions

AD

adaptor, CTTL_MEMBER_RULE() function adaptor CTTL_MEMBER_RULE() function adaptor
adaptor, CTTL_RULE() function adaptor CTTL_RULE() function adaptor
adaptor, CTTL_STATIC_RULE() function adaptor CTTL_STATIC_RULE() function adaptor
adaptor, edge(R) expression adaptor edge(R) expression adaptor
adaptor, entity(R) grammar expression adaptor entity(R) grammar expression adaptor
adaptor, node adaptor Substring class template parameters
adaptor, Node grammar adaptor Node grammar adaptor
adaptor, node(R) expression adaptor node(R) expression adaptor
adaptor, rule() function adaptor rule() function adaptor
adaptors, C++ function adaptors C++ function adaptors
adaptors, function adaptors Production rule function formats
adaptors, Grammar expression adaptors Grammar expression adaptors
adaptors, Search algorithm unavailability in function adaptors !R terminal symbol search operator
adaptors, Search algorithm unavailability in function adaptors !!R non-terminal symbol search operator
adaptors, Traceable function call adaptors Traceable function call adaptors

AL

algorithm, balanced search algorithm Quote evaluation rules
algorithm, greedy evaluation algorithm White space policy classes
algorithm, greedy evaluation algorithm Programming language comment policy classes
algorithm, greedy evaluation algorithm Void region-aware space policy classes
algorithm, Search algorithm unavailability in function adaptors !R terminal symbol search operator
algorithm, Search algorithm unavailability in function adaptors !!R non-terminal symbol search operator
algorithms, grammar evaluation algorithms Lexical analysis interface
algorithms, recursive algorithms Text transformations
alphabet, Abstract alphabet Lexer design
alphabet, common alphabet Lexeme symbol(text)
alternative grammar paths Arithmetic parser error handling

AN

analysis, incremental lexical analysis Stream parsers
analysis, Lexical analysis interface Lexical analysis interface
analysis, Lexical analysis primer Lexical analysis primer
anchors, Epsilon match anchors Epsilon match anchors
AND, binary bitwise AND R1&R2 binary set intersection operator
ANSI C multi-character entity Lexeme entity(is...)
ANSI, ansi_double_quote(RM) ANSI double quote ansi_double_quote(RM) ANSI double quote
ANSI, ansi_single_quote(RM) ANSI single quote ansi_single_quote(RM) ANSI single quote
ANSI, wchar_ansi_double_quote(RM) wide char ANSI double quote wchar_ansi_double_quote(RM) wide char ANSI double quote
ANSI, wchar_ansi_single_quote(RM) wide char ANSI single quote wchar_ansi_single_quote(RM) wide char ANSI single quote
ansi_double_quote lookbehind example: CSV to XML conversion
ansi_double_quote(RM) ANSI double quote ansi_double_quote(RM) ANSI double quote
ansi_single_quote(RM) ANSI single quote ansi_single_quote(RM) ANSI single quote

AP

Applicability of generic quoted expressions Applicability of generic quoted expressions

AR

arbitrary line Node navigation
argument, lexeme argument Lexemes
Arithmetic expression lexer Arithmetic expression lexer
Arithmetic expression parser Arithmetic expression parser
arithmetic parser Arithmetic parser organization
Arithmetic parser error handling Arithmetic parser error handling
Arithmetic parser organization Arithmetic parser organization
arithmetics.cpp Arithmetic parser organization
array of string literals Source code generation

AS

assertion, -R negative lookahead assertion -R negative lookahead assertion
assertion, begin(R) positive lookahead assertion begin(R) positive lookahead assertion
assertion, lookahead assertion Stream parser grammar
assertion, lookbehind(R1 R2) positive lookbehind assertion lookbehind(R1 R2) positive lookbehind assertion
assertion, negative lookahead assertion +R one or more matches
assertion, positive lookahead assertion R1&R2 binary set intersection operator
assertion, regex negative lookahead assertion Regular expression pattern map
assertion, regex negative lookbehind assertion Regular expression pattern map
assertion, regex positive lookahead assertion Regular expression pattern map
assertion, regex positive lookbehind assertion Regular expression pattern map
assertion, zero-width lookahead assertion Lexemes
assertions, inline assertions Lambda library tracing
assignment, Node assignment Node assignment
assignment, Substring assignment Substring assignment
associativity, left-to-right associativity R1+R2 binary sequence operator
associativity, left-to-right associativity R1^R2 binary concatenation operator
associativity, left-to-right associativity R1-R2 binary set complement
associativity, left-to-right associativity R1&R2 binary set intersection operator
associativity, left-to-right associativity R1|R2 binary set union operator
associativity, operator associativity Grammar transformations
AST Abstract syntax tree
AST Case study: XML stream parser
asymmetric, quote(true RM RR) asymmetric quote quote(true RM RR) asymmetric quote

AU

automata, Finite state automata Finite state automata
Automation, Deterministic Finite Automation Finite state automata
Automation, Nondeterministic Finite Automation Finite state automata
automaton, non-deterministic finite automaton R1||R2 binary POSIX union operator
Automaton, traditional Non-deterministic Finite Automaton R1|R2 binary set union operator

BA

backreference, regex backreference Regular expression pattern map
backtracking Predictive grammar in stream parsers
Backtracking vs. predictive parsing Backtracking vs. predictive parsing
balanced pairs Quotes
balanced search algorithm Quote evaluation rules
balanced_output.cpp Quote search parser example
bang_find Lexical analysis primer
bang_find Lexical analysis interface
bang_find Search parsers
bang_find bang_find: non-terminal symbol search
bang_find: non-terminal symbol search bang_find: non-terminal symbol search

BE

begin Strict policy requirements
begin Semantic actions
begin Lexeme begin(std::set)
begin(), Lexeme begin() Lexeme begin()
begin(char), Lexeme begin(char) Lexeme begin(char)
begin(false), Lexeme begin(false) Lexeme begin(false)
begin(is...), Lexeme begin(is...) Lexeme begin(is...)
begin(R) positive lookahead assertion begin(R) positive lookahead assertion
begin(std::set), Lexeme begin(std::set) Lexeme begin(std::set)
begin(text), Lexeme begin(text) Lexeme begin(text)
begin(true), Lexeme begin(true) Lexeme begin(true)
beginning-of-file Node navigation

BH

bi-directional text Nearest terminal symbol

BI

binary bitwise AND R1&R2 binary set intersection operator
binary bitwise OR R1|R2 binary set union operator
Binary Kleene plus quantifier R+N one to N matches
Binary Kleene plus quantifier R+pair(N M) N to M matches
Binary Kleene plus quantifier R+pair(N npos) exactly N matches
Binary Kleene star quantifier R*N zero to N matches
binary logical OR R1||R2 binary POSIX union operator
binary minus R1-R2 binary set complement
binary multiplication R*N zero to N matches
binary plus R+N one to N matches
binary plus R+pair(N M) N to M matches
binary plus R+pair(N npos) exactly N matches
binary plus R1+R2 binary sequence operator
binary, R1-R2 binary set complement R1-R2 binary set complement
binary, R1&R2 binary set intersection operator R1&R2 binary set intersection operator
binary, R1^R2 binary concatenation operator R1^R2 binary concatenation operator
binary, R1||R2 binary POSIX union operator R1||R2 binary POSIX union operator
binary, R1|R2 binary set union operator R1|R2 binary set union operator
binary, R1+R2 binary sequence operator R1+R2 binary sequence operator
bitwise exclusive OR XOR R1^R2 binary concatenation operator
bitwise, binary bitwise AND R1&R2 binary set intersection operator
bitwise, binary bitwise OR R1|R2 binary set union operator

BN

BNF Types of input languages

BO

boundaries, lower and upper boundaries Substring classes const_edge and edge
boundary, regex word boundary Regular expression pattern map
boundary, synchronizing boundary Error processing

C

c_double_quote Region-aware substring
c_double_quote Quote search parser example
c_double_quote(RM) C double quote c_double_quote(RM) C double quote
c_single_quote Region-aware substring
c_single_quote(RM) C single quote c_single_quote(RM) C single quote
C2784 Member function pointers

CA

call, Traceable function call adaptors Traceable function call adaptors
calls, traced function calls Production rule function formats
capturing, regex named capturing group Regular expression pattern map
carriage return Node navigation
Case-insensitive string Case-insensitive string
case-insensitive substring CTTL string and character types
case sensitivity CTTL string and character types
Case study: XML stream parser Case study: XML stream parser
case, regex case insensitive match mode Regular expression pattern map

CH

char, wchar_ansi_double_quote(RM) wide char ANSI double quote wchar_ansi_double_quote(RM) wide char ANSI double quote
char, wchar_ansi_single_quote(RM) wide char ANSI single quote wchar_ansi_single_quote(RM) wide char ANSI single quote
char, wchar_c_double_quote(RM) wide char C double quote wchar_c_double_quote(RM) wide char C double quote
char, wchar_c_single_quote(RM) wide char C single quote wchar_c_single_quote(RM) wide char C single quote
character sequence Substrings
character, CTTL string and character types CTTL string and character types
character, Node character access Node character access
character, POSIX character class Lexemes
character, POSIX character class Lexeme entity(is...)
character, quote(char RM char) single character quote quote(char RM char) single character quote
character, regex character range Regular expression pattern map
character, regex control character class Regular expression pattern map
character, regex hexadecimal character hh Regular expression pattern map
character, regex octal character nnn Regular expression pattern map
character, regex POSIX character classes Regular expression pattern map
character, structured character sequence literal() and wchar_literal() metaphors
character, unparsed character Parseable substring and lexer state
character, wchar_quote(wchar_t RM wchar_t) single wide character quote wchar_quote(wchar_t RM wchar_t) single wide character quote
characters, permutation of characters Lexeme entity(is...)
characters, permutation of characters Lexeme entity(text)

CI

cin.get() Stream parser grammar
circularly-linked list Node constructors

CL

class, default space policy class Predefined space policy classes
class, POSIX character class Lexemes
class, POSIX character class Lexeme entity(is...)
class, regex control character class Regular expression pattern map
class, regex digit class Regular expression pattern map
class, regex white space class Regular expression pattern map
class, strict-mode policy class Strict policy requirements
class, Substring class template parameters Substring class template parameters

CO

Code generation example Code generation example
Code generator project Code generator project
code, Gumus dot code Gumus dot code
code, Gumus source code Gumus source code
code, pseudo code Arithmetic expression parser
code, Source code generation Source code generation
code, zip code Strict policy requirements
comma separated value format lookbehind example: CSV to XML conversion
command, Gumus command line parameters Gumus command line parameters
comment, Programming language comment policy classes Programming language comment policy classes
comments, programming language comments Space policy classes
common alphabet Lexeme symbol(text)
commutativity R1||R2 binary POSIX union operator
comparison, Node comparison operators Node comparison operators
comparison, Substring comparison operators Substring comparison operators
compiled, natively compiled Parser design
complement, absolute complement -R negative lookahead assertion
complement, R1-R2 binary set complement R1-R2 binary set complement
complement, set complement R1-R2 binary set complement
component, lexer component Parser design
component, parser component Parser design
concatenation Strict policy requirements
concatenation, R1^R2 binary concatenation operator R1^R2 binary concatenation operator
condition, regex condition Regular expression pattern map
const_edge Node functors
const_edge Finite state automata
const_edge match: pattern matching
const_edge Parser design
const_edge CTTL grammar example
const_edge, Substring classes const_edge and edge Substring classes const_edge and edge
const_edge::text_tolower Summary of mutating operations on substrings and nodes
const_edge::text_toupper Summary of mutating operations on substrings and nodes
constant and mutable data access Substring classes const_edge and edge
constant and mutable substrings Text transformations
constant substring Lexical analysis interface
constructors, Node constructors Node constructors
constructors, Substring constructors Substring constructors
context-free grammar Types of input languages
contextually predictive Stream parser grammar
control, regex control character class Regular expression pattern map
conversion, File offset to line number conversion File offset to line number conversion
conversion, lookbehind example: CSV to XML conversion lookbehind example: CSV to XML conversion
conversion, Number to words conversion Number to words conversion

CP

cpp_comment_lexer Region-aware substring
cpp_comment_parser Region-aware substring
cpp_comment_strip.cpp Region-aware substring

CS

CSV, lookbehind example: CSV to XML conversion lookbehind example: CSV to XML conversion

CT

cttl::node, Logical input position: cttl::node Logical input position: cttl::node
cttl::node, Text insert by cttl::node Text insert by cttl::node
CTTL_MEMBER_RULE Production rule function formats
CTTL_MEMBER_RULE Arithmetic parser organization
CTTL_MEMBER_RULE() function adaptor CTTL_MEMBER_RULE() function adaptor
CTTL_QWERTY_ literal() and wchar_literal() metaphors
CTTL_QWERTY_123_ literal() and wchar_literal() metaphors
CTTL_RULE Semantic actions
CTTL_RULE Arithmetic parser organization
CTTL_RULE Quote search parser example
CTTL_RULE Filename and path parser example
CTTL_RULE() function adaptor CTTL_RULE() function adaptor
CTTL_STATIC_RULE Search parsers
CTTL_STATIC_RULE Stream parser grammar
CTTL_STATIC_RULE Production rule function formats
CTTL_STATIC_RULE Quotes
CTTL_STATIC_RULE() function adaptor CTTL_STATIC_RULE() function adaptor
CTTL_STD_CHAR CTTL string and character types
CTTL_STD_STRING CTTL string and character types
CTTL_STD_WCHAR CTTL string and character types
CTTL_STD_WSTRING CTTL string and character types
CTTL_TRACE_EVERYTHING CTTL_TRACE_EVERYTHING
CTTL_TRACE_MESSAGE Production rule function formats
CTTL_TRACE_MESSAGE CTTL_TRACE_MESSAGE
CTTL_TRACE_RULES Production rule function formats
CTTL_TRACE_RULES CTTL_TRACE_RULES
CTTL_TRACE_SILENT CTTL_TRACE_SILENT
CTTL_TRACE_TRIVIAL CTTL_TRACE_TRIVIAL
CTTL_UNILOG_STREAM CTTL_UNILOG_STREAM
CTTL_WCHAR_QWERTY_ literal() and wchar_literal() metaphors
CTTL_WCHAR_QWERTY_123_ literal() and wchar_literal() metaphors

CU

current line Node navigation
custom space policy Policy match member function
custom space policy processing mode Substring class template parameters
custom_space_policy.cpp Substring class template parameters
Customized space policy Customized space policy

CY

cyclic left recursion Grammar transformations

DA

data, constant and mutable data access Substring classes const_edge and edge
data, Space policy and stream data extraction Space policy and stream data extraction

DE

Debugging tips Debugging tips
debugging, Grammar debugging and tracing Grammar debugging and tracing
default space policy class Predefined space policy classes
definitions, terminal symbol definitions Parser design
delimiter, line delimiter Node navigation
delimiters, token delimiters Customized space policy
dereference, unary dereference *R zero or more matches
design, Lexer design Lexer design
design, Parser design Parser design
determinism, lack of determinism Left factoring
Deterministic Finite Automation Finite state automata
deterministic parser Left factoring

DF

DFA Finite state automata
DFA, undefined DFA state Grammar evaluation result

DI

digit, regex digit class Regular expression pattern map
disjunction Left factoring
disjunction of evaluation paths Grammar evaluation result
disjunction, set disjunction R1|R2 binary set union operator

DO

dot, Gumus dot code Gumus dot code
dot, regex dot match Regular expression pattern map
double, ansi_double_quote(RM) ANSI double quote ansi_double_quote(RM) ANSI double quote
double, c_double_quote(RM) C double quote c_double_quote(RM) C double quote
double, wchar_ansi_double_quote(RM) wide char ANSI double quote wchar_ansi_double_quote(RM) wide char ANSI double quote
double, wchar_c_double_quote(RM) wide char C double quote wchar_c_double_quote(RM) wide char C double quote
Doxygen pages Doxygen pages

EB

EBNF grammars EBNF grammars

ED

edge Parser design
edge Mutable substring example
edge(R) expression adaptor edge(R) expression adaptor
edge, Substring classes const_edge and edge Substring classes const_edge and edge
edge::erase Summary of mutating operations on substrings and nodes
edge::insert_go Summary of mutating operations on substrings and nodes
edge::insert_stay Summary of mutating operations on substrings and nodes
edge::text Substring assignment
edge::text Summary of mutating operations on substrings and nodes
edge::text_swap Summary of mutating operations on substrings and nodes
edge_functors.cpp Parser design
edge_functors.h Parser design
edge_replace Parser design
edge_sort.cpp Substring comparison operators

EM

empty string Lexeme symbol(text)
empty substring validator Lexeme end()
empty symbol Lexeme symbol(true)
empty symbol Lexeme begin(true)

EN

end(), Lexeme end() Lexeme end()
end(char), Lexeme end(char) Lexeme end(char)
end(is...), Lexeme end(is...) Lexeme end(is...)
end(text), Lexeme end(text) Lexeme end(text)
end, regex end of line Regular expression pattern map
end, regex end of string Regular expression pattern map
ending-of-file Node navigation
entity match: pattern matching
entity Policy match member function
entity Lexeme begin(std::set)
entity(), Lexeme entity() Lexeme entity()
entity(char), Lexeme symbol(char) and entity(char) Lexeme symbol(char) and entity(char)
entity(is...), Lexeme entity(is...) Lexeme entity(is...)
entity(R) grammar expression adaptor entity(R) grammar expression adaptor
entity(text), Lexeme entity(text) Lexeme entity(text)
entity, ANSI C multi-character entity Lexeme entity(is...)
entity, multi-character entity Lexeme entity(text)
entity, multi-character entity lookup Lexeme begin(text)

EO

EOF Policy match member function

EP

epsilon match Grammar transformations
epsilon match Lexeme begin()
epsilon match Lexeme end()
epsilon match Lexeme symbol(true)
epsilon match Lexeme begin(true)
epsilon match Lexeme begin(std::set)
epsilon match Lexeme begin(char)
epsilon match Lexeme end(char)
epsilon match Lexeme begin(is...)
epsilon match Lexeme end(is...)
epsilon match Lexeme symbol(text)
epsilon match Lexeme begin(text)
epsilon match Lexeme end(text)
epsilon match begin(R) positive lookahead assertion
epsilon match -R negative lookahead assertion
Epsilon match anchors Epsilon match anchors
epsilon symbol Predictive grammar in stream parsers
epsilon symbol Lexeme symbol(true)
epsilon symbol Lexeme begin(true)

EQ

equal Node comparison operators

ER

Error processing Error processing
error, Arithmetic parser error handling Arithmetic parser error handling

EV

evaluation Lexical analysis primer
evaluation, disjunction of evaluation paths Grammar evaluation result
evaluation, grammar evaluation algorithms Lexical analysis interface
evaluation, grammar evaluation function Lexical analysis primer
evaluation, grammar evaluation function Production rule functions
evaluation, Grammar evaluation result Grammar evaluation result
evaluation, grammar expression evaluation Lexical analysis primer
evaluation, greedy evaluation algorithm White space policy classes
evaluation, greedy evaluation algorithm Programming language comment policy classes
evaluation, greedy evaluation algorithm Void region-aware space policy classes
evaluation, Greedy evaluation of space Greedy evaluation of space
evaluation, Quote evaluation rules Quote evaluation rules
evaluation, result of evaluation Lexical analysis primer
evaluation, Strict-mode evaluation Strict-mode evaluation
evaluation, Strict-mode grammar evaluation Strict-mode grammar evaluation
evaluation, strict evaluation mode Predictive grammar in stream parsers
evaluation, strict evaluation mode Lexeme symbol(true)

EX

exact text Lexeme symbol(text)
exactly, R+pair(N npos) exactly N matches R+pair(N npos) exactly N matches
exactly, regex exactly N matches Regular expression pattern map
example, Code generation example Code generation example
example, CTTL grammar example CTTL grammar example
example, Filename and path parser example Filename and path parser example
example, Grammar production rule example Grammar production rule example
example, Mutable substring example Mutable substring example
example, Quote search parser example Quote search parser example
example, Start rule example Start rule example
example, Stateless lexer example Stateless lexer example
example, Strict-mode grammar example Strict-mode grammar example
example:, lookbehind example: CSV to XML conversion lookbehind example: CSV to XML conversion
exclusive, bitwise exclusive OR XOR R1^R2 binary concatenation operator
Explicit instantiation of a strict-mode substring Explicit instantiation of a strict-mode substring
expression, Arithmetic expression lexer Arithmetic expression lexer
expression, Arithmetic expression parser Arithmetic expression parser
expression, edge(R) expression adaptor edge(R) expression adaptor
expression, entity(R) grammar expression adaptor entity(R) grammar expression adaptor
expression, grammar expression Parser design
expression, Grammar expression adaptors Grammar expression adaptors
expression, grammar expression evaluation Lexical analysis primer
expression, grammar expression trace mode CTTL_TRACE_EVERYTHING
expression, node(R) expression adaptor node(R) expression adaptor
expression, Regular expression pattern map Regular expression pattern map
expressions, Applicability of generic quoted expressions Applicability of generic quoted expressions
expressions, grammar expressions Lexical analysis primer
expressions, grammar expressions Grammar production rule example
expressions, Grammar expressions Production rule functions
extended, indefinitely extended Left recursion
extraction, Space policy and stream data extraction Space policy and stream data extraction

FA

factor Arithmetic parser organization
factoring, Left factoring Left factoring
failed, trace line of the failed lexeme CTTL_TRACE_EVERYTHING

FI

File offset to line number conversion File offset to line number conversion
file2string Search parsers
file2string Region-aware substring
file2string Quote search parser example
file2string File offset to line number conversion
fileio Search parsers
fileio Region-aware substring
fileio.h Filename and path parser example
Filename and path parser example Filename and path parser example
filename_parser.cpp Filename and path parser example
find Lexical analysis primer
find Grammar evaluation result
find Lexical analysis interface
find find: terminal symbol search
find: terminal symbol search find: terminal symbol search
find_class() node::find_class() and node::rfind_class()
Finite state automata Finite state automata
Finite State Machine Types of input languages
Finite, Deterministic Finite Automation Finite state automata
finite, non-deterministic finite automaton R1||R2 binary POSIX union operator
Finite, Nondeterministic Finite Automation Finite state automata
Finite, traditional Non-deterministic Finite Automaton R1|R2 binary set union operator
first Substring classes const_edge and edge
first Grammar evaluation result
first match: pattern matching
first Strict policy requirements
first( isdigit ) Mutable substring example
first(is...), Lexeme first(is...) Lexeme first(is...)
first(text), Lexeme first(text) Lexeme first(text)

FL

flag_follow_either Void region-aware space policy classes
flag_follow_either Region-aware substring
flag_follow_region Void region policy interface
flag_follow_space White space policy classes
flag_follow_space Void region-aware space policy classes
flag_follow_space Stream parser grammar
flag_greedy White space policy classes
flag_greedy Programming language comment policy classes
flag_greedy Void region-aware space policy classes

FO

format, comma separated value format lookbehind example: CSV to XML conversion
format, Trace output format Trace output format
formats, Production rule function formats Production rule function formats
formatting, text formatting Utility functions classes and programs

FR

fractional numbers Finite state automata
fractional numbers CTTL grammar example
fragments of text Substrings

FS

FSM Types of input languages

FU

function adaptors Production rule function formats
function object Production rule function formats
Function objects Function objects
function, C++ function adaptors C++ function adaptors
function, CTTL_MEMBER_RULE() function adaptor CTTL_MEMBER_RULE() function adaptor
function, CTTL_RULE() function adaptor CTTL_RULE() function adaptor
function, CTTL_STATIC_RULE() function adaptor CTTL_STATIC_RULE() function adaptor
function, global function Production rule function formats
function, grammar evaluation function Lexical analysis primer
function, grammar evaluation function Production rule functions
function, grammar production function Parser design
function, member function Production rule function formats
function, Member function pointers Member function pointers
function, member function template Member function pointers
function, Policy match member function Policy match member function
function, production rule function Recursive grammar productions
function, Production rule function formats Production rule function formats
function, rule() function adaptor rule() function adaptor
function, Search algorithm unavailability in function adaptors !R terminal symbol search operator
function, Search algorithm unavailability in function adaptors !!R non-terminal symbol search operator
function, static member function Production rule function formats
function, Traceable function call adaptors Traceable function call adaptors
function, traced function calls Production rule function formats
functions, Production rule functions Production rule functions
functions, production rule functions Semantic actions
functions, Utility functions classes and programs Utility functions classes and programs
functor Production rule function formats
functor.cpp Function objects
functors, Node functors Node functors

GE

generation, Code generation example Code generation example
generation, Source code generation Source code generation
generator, Code generator project Code generator project
generic, Applicability of generic quoted expressions Applicability of generic quoted expressions
generic, quote(RL RM RR) generic quote quote(RL RM RR) generic quote

GL

global function Production rule function formats

GO

go_line Substring comparison operators
go_line_end Node navigation
go_line_end Substring comparison operators
go_line_home Node navigation

GR

grammar Arithmetic parser organization
Grammar debugging and tracing Grammar debugging and tracing
grammar evaluation algorithms Lexical analysis interface
grammar evaluation function Lexical analysis primer
grammar evaluation function Production rule functions
Grammar evaluation result Grammar evaluation result
grammar expression Parser design
Grammar expression adaptors Grammar expression adaptors
grammar expression evaluation Lexical analysis primer
grammar expression trace mode CTTL_TRACE_EVERYTHING
grammar expressions Lexical analysis primer
grammar expressions Grammar production rule example
Grammar expressions Production rule functions
grammar production function Parser design
grammar production rule Lexical analysis primer
grammar production rule Parser design
grammar production rule Production rule functions
Grammar production rule example Grammar production rule example
Grammar reference Grammar reference
grammar rule Parser design
grammar rules Production rule functions
grammar token edge(R) expression adaptor
grammar transformation Left factoring
grammar transformation Left recursion
Grammar transformations Grammar transformations
grammar, alternative grammar paths Arithmetic parser error handling
grammar, context-free grammar Types of input languages
grammar, CTTL grammar example CTTL grammar example
grammar, CTTL grammar tutorial CTTL grammar tutorial
grammar, entity(R) grammar expression adaptor entity(R) grammar expression adaptor
grammar, named grammar rules Grammar production rule example
grammar, Node grammar adaptor Node grammar adaptor
grammar, predictive grammar Predictive grammar in stream parsers
grammar, Predictive grammar in stream parsers Predictive grammar in stream parsers
grammar, Recursive grammar productions Recursive grammar productions
grammar, reduced grammar sets Applicability of generic quoted expressions
grammar, space grammar Customized space policy
grammar, Stream parser grammar Stream parser grammar
grammar, Strict-mode grammar evaluation Strict-mode grammar evaluation
grammar, Strict-mode grammar example Strict-mode grammar example
grammar.cpp Stateless lexer example
grammars, EBNF grammars EBNF grammars
greedy evaluation algorithm White space policy classes
greedy evaluation algorithm Programming language comment policy classes
greedy evaluation algorithm Void region-aware space policy classes
Greedy evaluation of space Greedy evaluation of space
group, regex named capturing group Regular expression pattern map
group, regex passive group Regular expression pattern map

GU

Gumus command line parameters Gumus command line parameters
Gumus dot code Gumus dot code
Gumus preprocessor Gumus preprocessor
Gumus script Gumus script
Gumus source code Gumus source code
gumus, Keeping track of gumus source Keeping track of gumus source
gumus.cpp Gumus source code

HA

half open range Substring classes const_edge and edge
half open range Void region policy interface
handling, Arithmetic parser error handling Arithmetic parser error handling

HE

hexadecimal, regex hexadecimal character hh Regular expression pattern map

HI

higher precedence Arithmetic expression lexer

HT

HTML Quotes

IC

icsubstring.cpp CTTL string and character types

ID

identity, Node identity test Node identity test

IG

ignore, regex ignore whitespace between tokens mode Regular expression pattern map

IM

immutable substring Text transformations

IN

incomplete input Stream parsers
Incomplete inputs Incomplete inputs
incomplete messages Stream parsers
incremental lexical analysis Stream parsers
incremental parsing Stream parsers
indefinitely extended Left recursion
infinite recursion Left recursion
infix notation Types of input languages
inline assertions Lambda library tracing
Inline text transformations Inline text transformations
inline traces Lambda library tracing
inode_reader Abstract syntax tree
inode_writer Abstract syntax tree
inoperable space of input Void regions
input Basic terminology
input Utility functions classes and programs
input symbol Basic terminology
input, incomplete input Stream parsers
input, inoperable space of input Void regions
input, Logical input position: cttl::node Logical input position: cttl::node
input, Types of input languages Types of input languages
input/output, Substring stream input/output operators Substring stream input/output operators
inputs, Incomplete inputs Incomplete inputs
inputs, static inputs Text transformations
insensitive, regex case insensitive match mode Regular expression pattern map
insert, Text insert by cttl::node Text insert by cttl::node
insert_go Source code generation
insert_stay Number to words conversion
inserter, node inserter Node functors
instantiation, Explicit instantiation of a strict-mode substring Explicit instantiation of a strict-mode substring
instantiation, template instantiation Lexical analysis primer
interface, Lexical analysis interface Lexical analysis interface
interface, Void region policy interface Void region policy interface
interior of the quote Quote evaluation rules
interior, quote interior Quotes
intersection, R1&R2 binary set intersection operator R1&R2 binary set intersection operator
intersection, set intersection R1&R2 binary set intersection operator
invalid substring Substring classes const_edge and edge
Invalid substring Invalid substring
invalid substring Lexeme entity()

IS

isalpha Node functors
isalpha match: pattern matching
isalpha Strict policy requirements
isalpha Policy match member function
isalpha Stream parser grammar
isalpha Parser design
isdigit match: pattern matching
isdigit Stream parser grammar
isdigit, first( isdigit ) Mutable substring example
isxdigit Stream parser grammar

IT

iteration, plain vanilla iteration Left recursion
iterators, mutable iterators Logical input position: cttl::node
itos Source code generation

KE

Keeping track of gumus source Keeping track of gumus source
keywords Semantic actions

KL

Kleene plus operator Strict policy requirements
Kleene, Binary Kleene plus quantifier R+N one to N matches
Kleene, Binary Kleene plus quantifier R+pair(N M) N to M matches
Kleene, Binary Kleene plus quantifier R+pair(N npos) exactly N matches
Kleene, Binary Kleene star quantifier R*N zero to N matches
Kleene, Unary Kleene plus quantifier +R one or more matches
Kleene, Unary Kleene star quantifier *R zero or more matches

KN

known-size tokens Stream parsers

LA

lack of determinism Left factoring
lambda Quote search parser example
Lambda library tracing Lambda library tracing
language, Programming language comment policy classes Programming language comment policy classes
language, programming language comments Space policy classes
language, regular language Types of input languages
languages, Types of input languages Types of input languages

LE

left-to-right associativity R1+R2 binary sequence operator
left-to-right associativity R1^R2 binary concatenation operator
left-to-right associativity R1-R2 binary set complement
left-to-right associativity R1&R2 binary set intersection operator
left-to-right associativity R1|R2 binary set union operator
left-to-right oriented Nearest terminal symbol
Left factoring Left factoring
Left recursion Left recursion
left, cyclic left recursion Grammar transformations
length, non-zero length entity(R) grammar expression adaptor
lexeme argument Lexemes
Lexeme begin() Lexeme begin()
Lexeme begin(char) Lexeme begin(char)
Lexeme begin(false) Lexeme begin(false)
Lexeme begin(is...) Lexeme begin(is...)
Lexeme begin(std::set) Lexeme begin(std::set)
Lexeme begin(text) Lexeme begin(text)
Lexeme begin(true) Lexeme begin(true)
Lexeme end() Lexeme end()
Lexeme end(char) Lexeme end(char)
Lexeme end(is...) Lexeme end(is...)
Lexeme end(text) Lexeme end(text)
Lexeme entity() Lexeme entity()
Lexeme entity(is...) Lexeme entity(is...)
Lexeme entity(text) Lexeme entity(text)
Lexeme first(is...) Lexeme first(is...)
Lexeme first(text) Lexeme first(text)
Lexeme symbol() Lexeme symbol()
Lexeme symbol(char) and entity(char) Lexeme symbol(char) and entity(char)
Lexeme symbol(false) Lexeme symbol(false)
Lexeme symbol(text) Lexeme symbol(text)
Lexeme symbol(true) Lexeme symbol(true)
lexeme, trace line of the failed lexeme CTTL_TRACE_EVERYTHING
Lexemes Lexemes
lexer Node functors
lexer Semantic actions
lexer component Parser design
Lexer design Lexer design
lexer state Parseable substring and lexer state
lexer, Arithmetic expression lexer Arithmetic expression lexer
lexer, Parseable substring and lexer state Parseable substring and lexer state
lexer, Stateless lexer example Stateless lexer example
Lexical analysis interface Lexical analysis interface
Lexical analysis primer Lexical analysis primer
lexical, incremental lexical analysis Stream parsers

LI

library, Lambda library tracing Lambda library tracing
line-end Node navigation
line-home Node navigation
line Node navigation
line delimiter Node navigation
line parser lookbehind(R1 R2) positive lookbehind assertion
line parser lookbehind example: CSV to XML conversion
line, arbitrary line Node navigation
line, current line Node navigation
line, File offset to line number conversion File offset to line number conversion
line, Gumus command line parameters Gumus command line parameters
line, regex end of line Regular expression pattern map
line, regex start of line Regular expression pattern map
line, trace line of the failed lexeme CTTL_TRACE_EVERYTHING
line_navigate.cpp Node navigation
line_parser.cpp lookbehind(R1 R2) positive lookbehind assertion
linefeed Node navigation
linefeed Node navigation
list of nodes Node constructors
list size Node identity test
list, circularly-linked list Node constructors
literal Quotes
literal() and wchar_literal() metaphors literal() and wchar_literal() metaphors
literal, numeric literal Arithmetic expression lexer
literals, array of string literals Source code generation

LO

Logical input position: cttl::node Logical input position: cttl::node
logical NOT !R terminal symbol search operator
logical NOT !!R non-terminal symbol search operator
logical position Basic terminology
logical, binary logical OR R1||R2 binary POSIX union operator
longer matches R1|R2 binary set union operator
longest nearest match R1||R2 binary POSIX union operator
lookahead Backtracking vs. predictive parsing
lookahead assertion Stream parser grammar
lookahead, -R negative lookahead assertion -R negative lookahead assertion
lookahead, begin(R) positive lookahead assertion begin(R) positive lookahead assertion
lookahead, negative lookahead assertion +R one or more matches
lookahead, positive lookahead assertion R1&R2 binary set intersection operator
lookahead, regex negative lookahead assertion Regular expression pattern map
lookahead, regex positive lookahead assertion Regular expression pattern map
lookahead, unlimited positive and negative lookahead Backtracking vs. predictive parsing
lookahead, unlimited positive lookahead begin(R) positive lookahead assertion
lookahead, zero-width lookahead assertion Lexemes
lookbehind Gumus source code
lookbehind Source code generation
lookbehind Filename and path parser example
lookbehind example: CSV to XML conversion lookbehind example: CSV to XML conversion
lookbehind(R1 R2) positive lookbehind assertion lookbehind(R1 R2) positive lookbehind assertion
lookbehind, lookbehind(R1 R2) positive lookbehind assertion lookbehind(R1 R2) positive lookbehind assertion
lookbehind, regex negative lookbehind assertion Regular expression pattern map
lookbehind, regex positive lookbehind assertion Regular expression pattern map
lookup, multi-character entity lookup Lexeme begin(text)
lower and upper boundaries Substring classes const_edge and edge
lower_bound Void region policy interface
lowercase Summary of mutating operations on substrings and nodes
lowest absolute offset Nearest terminal symbol

LT

LTR Nearest terminal symbol

MA

Machine, Finite State Machine Types of input languages
manual, Reference manual Reference manual
map, Regular expression pattern map Regular expression pattern map
match: pattern matching match: pattern matching
matching, match: pattern matching match: pattern matching

ME

member function Production rule function formats
Member function pointers Member function pointers
member function template Member function pointers
member, Policy match member function Policy match member function
member, static member function Production rule function formats
messages, incomplete messages Stream parsers
metadata Space policy classes
metaphors, literal() and wchar_literal() metaphors literal() and wchar_literal() metaphors

MI

minus, binary minus R1-R2 binary set complement
minus, unary minus -R negative lookahead assertion
mixer, policy mixer Space policy and stream data extraction

MO

mode, custom space policy processing mode Substring class template parameters
mode, grammar expression trace mode CTTL_TRACE_EVERYTHING
mode, regex case insensitive match mode Regular expression pattern map
mode, regex ignore whitespace between tokens mode Regular expression pattern map
mode, rule-level trace mode CTTL_TRACE_RULES
mode, strict evaluation mode Predictive grammar in stream parsers
mode, strict evaluation mode Lexeme symbol(true)
mode, trivial trace mode CTTL_TRACE_TRIVIAL

MU

multi-character entity Lexeme entity(text)
multi-character entity lookup Lexeme begin(text)
multi-character, ANSI C multi-character entity Lexeme entity(is...)
multiplication, binary multiplication R*N zero to N matches
mutable iterators Logical input position: cttl::node
mutable substring Substrings
mutable substring Lexical analysis interface
mutable substring Text transformations
Mutable substring example Mutable substring example
mutable value type Substring comparison operators
mutable, constant and mutable data access Substring classes const_edge and edge
mutable, constant and mutable substrings Text transformations
mutable_substring.cpp Mutable substring example
mutating, Summary of mutating operations on substrings and nodes Summary of mutating operations on substrings and nodes

NA

named grammar rules Grammar production rule example
named, regex named capturing group Regular expression pattern map
natively compiled Parser design
navigable Void region policy interface
navigation, Node navigation Node navigation

NE

Nearest terminal symbol Nearest terminal symbol
nearest terminal symbol match: pattern matching
nearest terminal symbol match: pattern matching
nearest terminal symbol find: terminal symbol search
nearest terminal symbol bang_find: non-terminal symbol search
nearest, longest nearest match R1||R2 binary POSIX union operator
negative lookahead assertion +R one or more matches
negative, -R negative lookahead assertion -R negative lookahead assertion
negative, regex negative lookahead assertion Regular expression pattern map
negative, regex negative lookbehind assertion Regular expression pattern map
negative, unlimited positive and negative lookahead Backtracking vs. predictive parsing
nested pairs Quote evaluation rules
newline Node navigation

NF

NFA Finite state automata
NFA R1|R2 binary set union operator
NFA R1||R2 binary POSIX union operator

NO

node Node navigation
node adaptor Substring class template parameters
Node assignment Node assignment
Node character access Node character access
Node comparison operators Node comparison operators
Node constructors Node constructors
Node functors Node functors
Node grammar adaptor Node grammar adaptor
Node identity test Node identity test
node inserter Node functors
Node navigation Node navigation
Node swap Node swap
node(R) expression adaptor node(R) expression adaptor
node::find_class() node::find_class() and node::rfind_class()
node::find_class() and node::rfind_class() node::find_class() and node::rfind_class()
node::insert_go Text insert by cttl::node
node::insert_go Summary of mutating operations on substrings and nodes
node::insert_stay Text insert by cttl::node
node::insert_stay Summary of mutating operations on substrings and nodes
node::offset Node constructors
node::rfind_class() node::find_class() and node::rfind_class()
node::rfind_class(), node::find_class() and node::rfind_class() node::find_class() and node::rfind_class()
node_find_class_cpp.cpp node::find_class() and node::rfind_class()
node_functors.cpp Node functors
node_insert_go Node functors
node_insert_stay Node functors
nodes, list of nodes Node constructors
nodes, Summary of mutating operations on substrings and nodes Summary of mutating operations on substrings and nodes
non-deterministic finite automaton R1||R2 binary POSIX union operator
Non-deterministic, traditional Non-deterministic Finite Automaton R1|R2 binary set union operator
non-empty match validator entity(R) grammar expression adaptor
non-terminal Parser design
non-terminal Overloaded operators
non-terminal symbols Lexical analysis primer
non-terminal symbols Grammar production rule example
non-terminal, !!R non-terminal symbol search operator !!R non-terminal symbol search operator
non-terminal, bang_find: non-terminal symbol search bang_find: non-terminal symbol search
non-zero length entity(R) grammar expression adaptor
Nondeterministic Finite Automation Finite state automata
NOT, logical NOT !R terminal symbol search operator
NOT, logical NOT !!R non-terminal symbol search operator
notation, infix notation Types of input languages

NP

npos Grammar evaluation result
npos Arithmetic parser error handling

NU

Number to words conversion Number to words conversion
number, File offset to line number conversion File offset to line number conversion
number2words.cpp Number to words conversion
numbers, fractional numbers Finite state automata
numbers, fractional numbers CTTL grammar example
numeric literal Arithmetic expression lexer

OB

object, function object Production rule function formats
objects, Function objects Function objects

OC

octal, regex octal character nnn Regular expression pattern map

OF

offset Node navigation
offset, absolute offset Basic terminology
offset, File offset to line number conversion File offset to line number conversion
offset, lowest absolute offset Nearest terminal symbol
offset2line.cpp File offset to line number conversion

OP

open, half open range Substring classes const_edge and edge
open, half open range Void region policy interface
operations, Summary of mutating operations on substrings and nodes Summary of mutating operations on substrings and nodes
operator associativity Grammar transformations
operator precedence Grammar transformations
operator, !!R non-terminal symbol search operator !!R non-terminal symbol search operator
operator, !R terminal symbol search operator !R terminal symbol search operator
operator, Kleene plus operator Strict policy requirements
operator, R1&R2 binary set intersection operator R1&R2 binary set intersection operator
operator, R1^R2 binary concatenation operator R1^R2 binary concatenation operator
operator, R1||R2 binary POSIX union operator R1||R2 binary POSIX union operator
operator, R1|R2 binary set union operator R1|R2 binary set union operator
operator, R1+R2 binary sequence operator R1+R2 binary sequence operator
operators, Node comparison operators Node comparison operators
operators, Overloaded operators Overloaded operators
operators, Substring comparison operators Substring comparison operators
operators, Substring stream input/output operators Substring stream input/output operators

OR

ordering, strict weak ordering Substring comparison operators
organization, Arithmetic parser organization Arithmetic parser organization
oriented, left-to-right oriented Nearest terminal symbol

OU

output Utility functions classes and programs
output, Trace output format Trace output format
output, Trace output symbols Trace output symbols

OV

Overloaded operators Overloaded operators

PA

pages, Doxygen pages Doxygen pages
pairs, balanced pairs Quotes
pairs, nested pairs Quote evaluation rules
parameters, Gumus command line parameters Gumus command line parameters
parameters, Substring class template parameters Substring class template parameters
parent Logical input position: cttl::node
parent Substring classes const_edge and edge
parent Substring constructors
parseable substring Lexical analysis primer
parseable substring Production rule functions
parseable substring Semantic actions
Parseable substring and lexer state Parseable substring and lexer state
parseable, space-aware parseable substring Substring class template parameters
parseable, strict parseable substring Strict-mode evaluation
parseable, Strict parseable substring Strict parseable substring
parsed token Lexemes
parser Node functors
parser Semantic actions
parser component Parser design
Parser design Parser design
parser state Strict policy requirements
parser, Arithmetic expression parser Arithmetic expression parser
parser, arithmetic parser Arithmetic parser organization
parser, Arithmetic parser error handling Arithmetic parser error handling
parser, Arithmetic parser organization Arithmetic parser organization
parser, Case study: XML stream parser Case study: XML stream parser
parser, deterministic parser Left factoring
parser, Filename and path parser example Filename and path parser example
parser, line parser lookbehind(R1 R2) positive lookbehind assertion
parser, line parser lookbehind example: CSV to XML conversion
parser, Quote search parser example Quote search parser example
parser, read-only parser Text transformations
parser, search parser Applicability of generic quoted expressions
parser, Stream parser grammar Stream parser grammar
parsers, Predictive grammar in stream parsers Predictive grammar in stream parsers
parsers, Search parsers Search parsers
parsers, Stream parsers Stream parsers
parsing, Backtracking vs. predictive parsing Backtracking vs. predictive parsing
parsing, incremental parsing Stream parsers
parsing, top-down parsing Recursive grammar productions
passive, regex passive group Regular expression pattern map
path, Filename and path parser example Filename and path parser example
paths, alternative grammar paths Arithmetic parser error handling
paths, disjunction of evaluation paths Grammar evaluation result
pattern, match: pattern matching match: pattern matching
pattern, Regular expression pattern map Regular expression pattern map
patterns, regex patterns Regular expression pattern map

PE

permutation of characters Lexeme entity(is...)
permutation of characters Lexeme entity(text)

PI

pipe_input Region-aware substring
pipe_input.h Filename and path parser example
pipe_input_2_vector Filename and path parser example

PL

plain vanilla iteration Left recursion
plus, Binary Kleene plus quantifier R+N one to N matches
plus, Binary Kleene plus quantifier R+pair(N M) N to M matches
plus, Binary Kleene plus quantifier R+pair(N npos) exactly N matches
plus, binary plus R+N one to N matches
plus, binary plus R+pair(N M) N to M matches
plus, binary plus R+pair(N npos) exactly N matches
plus, binary plus R1+R2 binary sequence operator
plus, Kleene plus operator Strict policy requirements
plus, Unary Kleene plus quantifier +R one or more matches
plus, unary plus +R one or more matches

PO

pointer to string Lexeme symbol(text)
pointers, Member function pointers Member function pointers
Policy match member function Policy match member function
policy mixer Space policy and stream data extraction
policy, custom space policy Policy match member function
policy, custom space policy processing mode Substring class template parameters
policy, Customized space policy Customized space policy
policy, default space policy class Predefined space policy classes
policy, Predefined space policy classes Predefined space policy classes
policy, Programming language comment policy classes Programming language comment policy classes
policy, Space policy and stream data extraction Space policy and stream data extraction
policy, Space policy classes Space policy classes
policy, stateful policy Policy match member function
policy, stateful space policy Substring class template parameters
policy, stateless policy Policy match member function
policy, strict-mode policy class Strict policy requirements
policy, Strict policy requirements Strict policy requirements
policy, ungreedy policy Stream parser grammar
policy, Void region-aware space policy classes Void region-aware space policy classes
policy, Void region policy interface Void region policy interface
policy, White space policy classes White space policy classes
policy_dash.cpp Policy match member function
policy_default Substring class template parameters
policy_default Policy match member function
policy_default Stream parser grammar
policy_relaxed_stream Stream parser grammar
policy_space Node functors
policy_space match: pattern matching
policy_space White space policy classes
policy_space Void region policy interface
policy_space Region-aware substring
policy_space Parser design
policy_space Arithmetic parser organization
policy_stream.cpp Stream parser grammar
policy_strict_stream Stream parser grammar
position, logical position Basic terminology
position:, Logical input position: cttl::node Logical input position: cttl::node
positive lookahead assertion R1&R2 binary set intersection operator
positive, begin(R) positive lookahead assertion begin(R) positive lookahead assertion
positive, lookbehind(R1 R2) positive lookbehind assertion lookbehind(R1 R2) positive lookbehind assertion
positive, regex positive lookahead assertion Regular expression pattern map
positive, regex positive lookbehind assertion Regular expression pattern map
positive, unlimited positive and negative lookahead Backtracking vs. predictive parsing
positive, unlimited positive lookahead begin(R) positive lookahead assertion
POSIX character class Lexemes
POSIX character class Lexeme entity(is...)
POSIX, R1||R2 binary POSIX union operator R1||R2 binary POSIX union operator
POSIX, regex POSIX character classes Regular expression pattern map
postal_code.cpp match: pattern matching
postal_code_strict.cpp Strict policy requirements

PR

precedence, higher precedence Arithmetic expression lexer
precedence, operator precedence Grammar transformations
Predefined space policy classes Predefined space policy classes
predictive grammar Predictive grammar in stream parsers
Predictive grammar in stream parsers Predictive grammar in stream parsers
predictive, Backtracking vs. predictive parsing Backtracking vs. predictive parsing
predictive, contextually predictive Stream parser grammar
preprocessor, Gumus preprocessor Gumus preprocessor
primary Arithmetic parser organization
primer, Lexical analysis primer Lexical analysis primer
processing, custom space policy processing mode Substring class template parameters
processing, Error processing Error processing
production rule function Recursive grammar productions
Production rule function formats Production rule function formats
Production rule functions Production rule functions
production rule functions Semantic actions
production, grammar production function Parser design
production, grammar production rule Lexical analysis primer
production, grammar production rule Parser design
production, grammar production rule Production rule functions
production, Grammar production rule example Grammar production rule example
productions, Recursive grammar productions Recursive grammar productions
Programming language comment policy classes Programming language comment policy classes
programming language comments Space policy classes
programs, Utility functions classes and programs Utility functions classes and programs
project, Code generator project Code generator project

PS

pseudo code Arithmetic expression parser

QU

quantifier, Binary Kleene plus quantifier R+N one to N matches
quantifier, Binary Kleene plus quantifier R+pair(N M) N to M matches
quantifier, Binary Kleene plus quantifier R+pair(N npos) exactly N matches
quantifier, Binary Kleene star quantifier R*N zero to N matches
quantifier, regex range quantifier ungreedy Regular expression pattern map
quantifier, Unary Kleene plus quantifier +R one or more matches
quantifier, Unary Kleene star quantifier *R zero or more matches
quote Quote search parser example
Quote evaluation rules Quote evaluation rules
quote interior Quotes
Quote search parser example Quote search parser example
quote(char RM char) single character quote quote(char RM char) single character quote
quote(RL RM RR) generic quote quote(RL RM RR) generic quote
quote(true RM RR) asymmetric quote quote(true RM RR) asymmetric quote
quote, ansi_double_quote(RM) ANSI double quote ansi_double_quote(RM) ANSI double quote
quote, ansi_single_quote(RM) ANSI single quote ansi_single_quote(RM) ANSI single quote
quote, c_double_quote(RM) C double quote c_double_quote(RM) C double quote
quote, c_single_quote(RM) C single quote c_single_quote(RM) C single quote
quote, interior of the quote Quote evaluation rules
quote, quote(char RM char) single character quote quote(char RM char) single character quote
quote, quote(RL RM RR) generic quote quote(RL RM RR) generic quote
quote, quote(true RM RR) asymmetric quote quote(true RM RR) asymmetric quote
quote, wchar_ansi_double_quote(RM) wide char ANSI double quote wchar_ansi_double_quote(RM) wide char ANSI double quote
quote, wchar_ansi_single_quote(RM) wide char ANSI single quote wchar_ansi_single_quote(RM) wide char ANSI single quote
quote, wchar_c_double_quote(RM) wide char C double quote wchar_c_double_quote(RM) wide char C double quote
quote, wchar_c_single_quote(RM) wide char C single quote wchar_c_single_quote(RM) wide char C single quote
quote, wchar_quote(wchar_t RM wchar_t) single wide character quote wchar_quote(wchar_t RM wchar_t) single wide character quote
quoted, Applicability of generic quoted expressions Applicability of generic quoted expressions
Quotes Quotes
quotes_html.cpp Quotes

RA

range, half open range Substring classes const_edge and edge
range, half open range Void region policy interface
range, regex character range Regular expression pattern map
range, regex range quantifier ungreedy Regular expression pattern map
range, valid range Substring classes const_edge and edge

RE

read-only parser Text transformations
recursion Quotes
recursion, cyclic left recursion Grammar transformations
recursion, infinite recursion Left recursion
recursion, Left recursion Left recursion
recursion, right recursion Left recursion
recursive Arithmetic expression lexer
recursive algorithms Text transformations
Recursive grammar productions Recursive grammar productions
reduced grammar sets Applicability of generic quoted expressions
Reference manual Reference manual
reference, Grammar reference Grammar reference
regex backreference Regular expression pattern map
regex case insensitive match mode Regular expression pattern map
regex character range Regular expression pattern map
regex condition Regular expression pattern map
regex control character class Regular expression pattern map
regex digit class Regular expression pattern map
regex dot match Regular expression pattern map
regex end of line Regular expression pattern map
regex end of string Regular expression pattern map
regex exactly N matches Regular expression pattern map
regex hexadecimal character hh Regular expression pattern map
regex ignore whitespace between tokens mode Regular expression pattern map
regex N to M matches Regular expression pattern map
regex named capturing group Regular expression pattern map
regex negative lookahead assertion Regular expression pattern map
regex negative lookbehind assertion Regular expression pattern map
regex octal character nnn Regular expression pattern map
regex one or more Regular expression pattern map
regex one or more ungreedy Regular expression pattern map
regex passive group Regular expression pattern map
regex patterns Regular expression pattern map
regex positive lookahead assertion Regular expression pattern map
regex positive lookbehind assertion Regular expression pattern map
regex POSIX character classes Regular expression pattern map
regex range quantifier ungreedy Regular expression pattern map
regex start of line Regular expression pattern map
regex start of string Regular expression pattern map
regex white space class Regular expression pattern map
regex word Regular expression pattern map
regex word boundary Regular expression pattern map
regex zero or more Regular expression pattern map
regex zero or more ungreedy Regular expression pattern map
regex zero or one Regular expression pattern map
regex zero or one ungreedy Regular expression pattern map
Region-aware substring Region-aware substring
region-aware, Void region-aware space policy classes Void region-aware space policy classes
region, Void region policy interface Void region policy interface
region_difference Void region policy interface
region_difference Region-aware substring
region_insert Void region policy interface
region_insert Region-aware substring
regions, Void regions Void regions
regions, void regions Region-aware substring
Regular expression pattern map Regular expression pattern map
regular language Types of input languages
repeatability, Search repeatability Search repeatability
repeatability, Search repeatability !!R non-terminal symbol search operator
repeatable search bang_find: non-terminal symbol search
repeatable search !!R non-terminal symbol search operator
replace Search parsers
replace Text transformations
Replace Summary of mutating operations on substrings and nodes
replacement, text replacement Substring comparison operators
requirements, Strict policy requirements Strict policy requirements
resources, Additional resources Additional resources
result of evaluation Lexical analysis primer
result, Grammar evaluation result Grammar evaluation result
return, carriage return Node navigation

RF

rfind_class() node::find_class() and node::rfind_class()

RI

right recursion Left recursion

RU

rule-level trace mode CTTL_TRACE_RULES
rule Node functors
rule Finite state automata
rule Region-aware substring
rule CTTL grammar example
rule Production rule function formats
rule() Stateless lexer example
rule() function adaptor rule() function adaptor
rule, grammar production rule Lexical analysis primer
rule, grammar production rule Parser design
rule, grammar production rule Production rule functions
rule, Grammar production rule example Grammar production rule example
rule, grammar rule Parser design
rule, production rule function Recursive grammar productions
rule, Production rule function formats Production rule function formats
rule, Production rule functions Production rule functions
rule, production rule functions Semantic actions
rule, start rule EBNF grammars
rule, Start rule example Start rule example
rule_adaptor.cpp Finite state automata
rule_adaptor.cpp CTTL grammar example
rule_formats.cpp Production rule function formats
rule_traced.cpp Production rule function formats
rules, grammar rules Production rule functions
rules, named grammar rules Grammar production rule example
rules, Quote evaluation rules Quote evaluation rules
rules, space sensitivity rules Predictive grammar in stream parsers

SC

scanning Lexical analysis primer
script, Gumus script Gumus script

SE

Search algorithm unavailability in function adaptors !R terminal symbol search operator
Search algorithm unavailability in function adaptors !!R non-terminal symbol search operator
search parser Applicability of generic quoted expressions
Search parsers Search parsers
Search repeatability Search repeatability
Search repeatability !!R non-terminal symbol search operator
Search transitivity Search transitivity
Search transitivity !R terminal symbol search operator
search, !!R non-terminal symbol search operator !!R non-terminal symbol search operator
search, !R terminal symbol search operator !R terminal symbol search operator
search, balanced search algorithm Quote evaluation rules
search, bang_find: non-terminal symbol search bang_find: non-terminal symbol search
search, find: terminal symbol search find: terminal symbol search
search, Quote search parser example Quote search parser example
search, repeatable search bang_find: non-terminal symbol search
search, repeatable search !!R non-terminal symbol search operator
search_replace.cpp Search parsers
search_replace_map.cpp Text transformations
second Substring classes const_edge and edge
semantic action EBNF grammars
semantic action Arithmetic parser organization
semantic actions Parser design
Semantic actions Semantic actions
sensitivity, case sensitivity CTTL string and character types
sensitivity, space sensitivity Customized space policy
sensitivity, space sensitivity rules Predictive grammar in stream parsers
separated, comma separated value format lookbehind example: CSV to XML conversion
sequence, character sequence Substrings
sequence, R1+R2 binary sequence operator R1+R2 binary sequence operator
sequence, strict sequence R1^R2 binary concatenation operator
sequence, structured character sequence literal() and wchar_literal() metaphors
set complement R1-R2 binary set complement
set disjunction R1|R2 binary set union operator
set intersection R1&R2 binary set intersection operator
set of strings Lexeme begin(std::set)
set, R1-R2 binary set complement R1-R2 binary set complement
set, R1&R2 binary set intersection operator R1&R2 binary set intersection operator
set, R1|R2 binary set union operator R1|R2 binary set union operator
sets, reduced grammar sets Applicability of generic quoted expressions

SI

single, ansi_single_quote(RM) ANSI single quote ansi_single_quote(RM) ANSI single quote
single, c_single_quote(RM) C single quote c_single_quote(RM) C single quote
single, quote(char RM char) single character quote quote(char RM char) single character quote
single, wchar_ansi_single_quote(RM) wide char ANSI single quote wchar_ansi_single_quote(RM) wide char ANSI single quote
single, wchar_c_single_quote(RM) wide char C single quote wchar_c_single_quote(RM) wide char C single quote
single, wchar_quote(wchar_t RM wchar_t) single wide character quote wchar_quote(wchar_t RM wchar_t) single wide character quote
size, list size Node identity test

SK

skipahead Lexeme end(char)
skipahead Lexeme end(is...)
skipahead Lexeme end(text)

SO

Source code generation Source code generation
source, Gumus source code Gumus source code
source, Keeping track of gumus source Keeping track of gumus source

SP

space-aware parseable substring Substring class template parameters
space grammar Customized space policy
Space policy and stream data extraction Space policy and stream data extraction
Space policy classes Space policy classes
space sensitivity Customized space policy
space sensitivity rules Predictive grammar in stream parsers
space, custom space policy Policy match member function
space, custom space policy processing mode Substring class template parameters
space, Customized space policy Customized space policy
space, default space policy class Predefined space policy classes
space, Greedy evaluation of space Greedy evaluation of space
space, inoperable space of input Void regions
space, Predefined space policy classes Predefined space policy classes
space, regex white space class Regular expression pattern map
space, stateful space policy Substring class template parameters
space, Void region-aware space policy classes Void region-aware space policy classes
space, white space Substring class template parameters
space, white space Space policy classes
space, White space policy classes White space policy classes

ST

star, Binary Kleene star quantifier R*N zero to N matches
star, Unary Kleene star quantifier *R zero or more matches
start rule EBNF grammars
Start rule example Start rule example
start, regex start of line Regular expression pattern map
start, regex start of string Regular expression pattern map
state, Finite state automata Finite state automata
State, Finite State Machine Types of input languages
state, lexer state Parseable substring and lexer state
state, Parseable substring and lexer state Parseable substring and lexer state
state, parser state Strict policy requirements
state, undefined DFA state Grammar evaluation result
state, undefined state Finite state automata
stateful policy Policy match member function
stateful space policy Substring class template parameters
Stateless lexer example Stateless lexer example
stateless policy Policy match member function
static inputs Text transformations
static member function Production rule function formats
std::cin Stream parser grammar
std::for_each Node functors
std::for_each Parser design
std::make_pair match: pattern matching
std::make_pair Strict policy requirements
std::map Text transformations
std::ostream_iterator Substring comparison operators
std::set Semantic actions
std::set Lexeme begin(std::set)
std::sort Substring comparison operators
std::swap Substring swap
std::unary_function Function objects
std::vector Substring comparison operators
std::vector Parser design
STL, type of STL string Substring constructors
stop symbol Lexeme symbol(false)
stop symbol Lexeme begin(false)
Stream parser grammar Stream parser grammar
Stream parsers Stream parsers
stream, Case study: XML stream parser Case study: XML stream parser
stream, Predictive grammar in stream parsers Predictive grammar in stream parsers
stream, Space policy and stream data extraction Space policy and stream data extraction
stream, Substring stream input/output operators Substring stream input/output operators
stream_edge.cpp Substring stream input/output operators
Strict-mode evaluation Strict-mode evaluation
Strict-mode grammar evaluation Strict-mode grammar evaluation
Strict-mode grammar example Strict-mode grammar example
strict-mode policy class Strict policy requirements
strict-mode substring Strict policy requirements
strict-mode, Explicit instantiation of a strict-mode substring Explicit instantiation of a strict-mode substring
strict evaluation mode Predictive grammar in stream parsers
strict evaluation mode Lexeme symbol(true)
strict parseable substring Strict-mode evaluation
Strict parseable substring Strict parseable substring
Strict policy requirements Strict policy requirements
strict sequence R1^R2 binary concatenation operator
strict substring Strict-mode grammar example
strict substring type Strict-mode grammar evaluation
strict weak ordering Substring comparison operators
strict_edge_T Grammar production rule example
strict_edge_T Search parsers
strict_edge_T Strict policy requirements
strict_edge_T Strict-mode grammar evaluation
strict_edge_T Strict-mode grammar example
strict_policy_T Strict policy requirements
strict_policy_T Stream parser grammar
strict_policy_T Strict-mode grammar evaluation
string Basic terminology
string, array of string literals Source code generation
string, Case-insensitive string Case-insensitive string
string, CTTL string and character types CTTL string and character types
string, empty string Lexeme symbol(text)
string, pointer to string Lexeme symbol(text)
string, regex end of string Regular expression pattern map
string, regex start of string Regular expression pattern map
string, type of STL string Substring constructors
string_array2string Node functors
string_array2string Stateless lexer example
string_array2string Parser design
string_array2string Parser design
string_array2string Semantic actions
string_array2string Arithmetic parser organization
string_set_lexeme.cpp Lexeme begin(std::set)
strings, set of strings Lexeme begin(std::set)
structured character sequence literal() and wchar_literal() metaphors

SU

Substring assignment Substring assignment
Substring class template parameters Substring class template parameters
Substring classes const_edge and edge Substring classes const_edge and edge
Substring comparison operators Substring comparison operators
Substring constructors Substring constructors
Substring stream input/output operators Substring stream input/output operators
Substring swap Substring swap
substring, case-insensitive substring CTTL string and character types
substring, constant substring Lexical analysis interface
substring, empty substring validator Lexeme end()
substring, Explicit instantiation of a strict-mode substring Explicit instantiation of a strict-mode substring
substring, immutable substring Text transformations
substring, invalid substring Substring classes const_edge and edge
substring, Invalid substring Invalid substring
substring, invalid substring Lexeme entity()
substring, mutable substring Substrings
substring, mutable substring Lexical analysis interface
substring, mutable substring Text transformations
substring, Mutable substring example Mutable substring example
substring, parseable substring Lexical analysis primer
substring, parseable substring Production rule functions
substring, parseable substring Semantic actions
substring, Parseable substring and lexer state Parseable substring and lexer state
substring, Region-aware substring Region-aware substring
substring, space-aware parseable substring Substring class template parameters
substring, strict-mode substring Strict policy requirements
substring, strict parseable substring Strict-mode evaluation
substring, Strict parseable substring Strict parseable substring
substring, strict substring Strict-mode grammar example
substring, strict substring type Strict-mode grammar evaluation
Substrings Substrings
substrings, constant and mutable substrings Text transformations
substrings, Summary of mutating operations on substrings and nodes Summary of mutating operations on substrings and nodes
SubstrT Lexical analysis interface
SubstrT Strict-mode grammar example

SW

Swap Summary of mutating operations on substrings and nodes
swap, Node swap Node swap
swap, Substring swap Substring swap
switch Strict-mode evaluation

SY

symbol match: pattern matching
symbol Search parsers
symbol(), Lexeme symbol() Lexeme symbol()
symbol(char), Lexeme symbol(char) and entity(char) Lexeme symbol(char) and entity(char)
symbol(false), Lexeme symbol(false) Lexeme symbol(false)
symbol(text), Lexeme symbol(text) Lexeme symbol(text)
symbol(true), Lexeme symbol(true) Lexeme symbol(true)
symbol, !!R non-terminal symbol search operator !!R non-terminal symbol search operator
symbol, !R terminal symbol search operator !R terminal symbol search operator
symbol, abstract symbol Lexer design
symbol, bang_find: non-terminal symbol search bang_find: non-terminal symbol search
symbol, empty symbol Lexeme symbol(true)
symbol, empty symbol Lexeme begin(true)
symbol, epsilon symbol Predictive grammar in stream parsers
symbol, epsilon symbol Lexeme symbol(true)
symbol, epsilon symbol Lexeme begin(true)
symbol, find: terminal symbol search find: terminal symbol search
symbol, input symbol Basic terminology
symbol, Nearest terminal symbol Nearest terminal symbol
symbol, nearest terminal symbol match: pattern matching
symbol, nearest terminal symbol match: pattern matching
symbol, nearest terminal symbol find: terminal symbol search
symbol, nearest terminal symbol bang_find: non-terminal symbol search
symbol, stop symbol Lexeme symbol(false)
symbol, stop symbol Lexeme begin(false)
symbol, terminal symbol definitions Parser design
symbols, non-terminal symbols Lexical analysis primer
symbols, non-terminal symbols Grammar production rule example
symbols, terminal symbols Lexical analysis primer
symbols, Trace output symbols Trace output symbols
synchronizing boundary Error processing
syntax trees Utility functions classes and programs
syntax, Abstract syntax tree Abstract syntax tree
syntax, abstract syntax tree Case study: XML stream parser

TE

template instantiation Lexical analysis primer
template, member function template Member function pointers
template, Substring class template parameters Substring class template parameters
term Arithmetic parser organization
terminal Parser design
terminal Overloaded operators
terminal symbol definitions Parser design
terminal symbols Lexical analysis primer
terminal unit Lexemes
terminal, !R terminal symbol search operator !R terminal symbol search operator
terminal, find: terminal symbol search find: terminal symbol search
terminal, Nearest terminal symbol Nearest terminal symbol
terminal, nearest terminal symbol match: pattern matching
terminal, nearest terminal symbol match: pattern matching
terminal, nearest terminal symbol find: terminal symbol search
terminal, nearest terminal symbol bang_find: non-terminal symbol search
terminology, Basic terminology Basic terminology
test, Node identity test Node identity test
text Basic terminology
text formatting Utility functions classes and programs
Text insert by cttl::node Text insert by cttl::node
text replacement Substring comparison operators
text transformation Substrings
text transformation Quote search parser example
Text transformations Text transformations
text, bi-directional text Nearest terminal symbol
text, exact text Lexeme symbol(text)
text, fragments of text Substrings
text, Inline text transformations Inline text transformations
text2array.cpp Source code generation

TI

time Utility functions classes and programs
tips, Debugging tips Debugging tips

TO

Token EBNF grammars
token delimiters Customized space policy
token, grammar token edge(R) expression adaptor
token, parsed token Lexemes
tokens Lexical analysis primer
tokens, known-size tokens Stream parsers
tokens, regex ignore whitespace between tokens mode Regular expression pattern map
top-down parsing Recursive grammar productions

TR

trace line of the failed lexeme CTTL_TRACE_EVERYTHING
Trace output format Trace output format
Trace output symbols Trace output symbols
trace, grammar expression trace mode CTTL_TRACE_EVERYTHING
trace, rule-level trace mode CTTL_TRACE_RULES
trace, trivial trace mode CTTL_TRACE_TRIVIAL
Traceable function call adaptors Traceable function call adaptors
traced function calls Production rule function formats
traces, inline traces Lambda library tracing
tracing, Grammar debugging and tracing Grammar debugging and tracing
tracing, Lambda library tracing Lambda library tracing
track, Keeping track of gumus source Keeping track of gumus source
traditional Non-deterministic Finite Automaton R1|R2 binary set union operator
transformation, grammar transformation Left factoring
transformation, grammar transformation Left recursion
transformation, text transformation Substrings
transformation, text transformation Quote search parser example
transformations, Grammar transformations Grammar transformations
transformations, Inline text transformations Inline text transformations
transformations, Text transformations Text transformations
transitivity, Search transitivity Search transitivity
transitivity, Search transitivity !R terminal symbol search operator
tree, Abstract syntax tree Abstract syntax tree
tree, abstract syntax tree Case study: XML stream parser
trees, syntax trees Utility functions classes and programs
trivial trace mode CTTL_TRACE_TRIVIAL

TU

tutorial, CTTL grammar tutorial CTTL grammar tutorial

TY

type of STL string Substring constructors
type, mutable value type Substring comparison operators
type, strict substring type Strict-mode grammar evaluation
Types of input languages Types of input languages
types, CTTL string and character types CTTL string and character types

UN

unary dereference *R zero or more matches
Unary Kleene plus quantifier +R one or more matches
Unary Kleene star quantifier *R zero or more matches
unary minus -R negative lookahead assertion
unary plus +R one or more matches
undefined DFA state Grammar evaluation result
undefined state Finite state automata
ungreedy Greedy evaluation of space
ungreedy White space policy classes
ungreedy Programming language comment policy classes
ungreedy Void region-aware space policy classes
ungreedy match Policy match member function
ungreedy policy Stream parser grammar
ungreedy, regex one or more ungreedy Regular expression pattern map
ungreedy, regex range quantifier ungreedy Regular expression pattern map
ungreedy, regex zero or more ungreedy Regular expression pattern map
ungreedy, regex zero or one ungreedy Regular expression pattern map
union, R1||R2 binary POSIX union operator R1||R2 binary POSIX union operator
union, R1|R2 binary set union operator R1|R2 binary set union operator
unit, terminal unit Lexemes
unlimited positive and negative lookahead Backtracking vs. predictive parsing
unlimited positive lookahead begin(R) positive lookahead assertion
unparsed character Parseable substring and lexer state

UP

upper, lower and upper boundaries Substring classes const_edge and edge
uppercase Summary of mutating operations on substrings and nodes

UT

Utility functions classes and programs Utility functions classes and programs

VA

valid range Substring classes const_edge and edge
validator, empty substring validator Lexeme end()
validator, non-empty match validator entity(R) grammar expression adaptor
value, comma separated value format lookbehind example: CSV to XML conversion
value, mutable value type Substring comparison operators

VO

Void region-aware space policy classes Void region-aware space policy classes
Void region policy interface Void region policy interface
Void regions Void regions
void regions Region-aware substring
void_regions.cpp Void region policy interface

WC

wchar_ansi_double_quote(RM) wide char ANSI double quote wchar_ansi_double_quote(RM) wide char ANSI double quote
wchar_ansi_single_quote(RM) wide char ANSI single quote wchar_ansi_single_quote(RM) wide char ANSI single quote
wchar_c_double_quote(RM) wide char C double quote wchar_c_double_quote(RM) wide char C double quote
wchar_c_single_quote(RM) wide char C single quote wchar_c_single_quote(RM) wide char C single quote
wchar_literal(), literal() and wchar_literal() metaphors literal() and wchar_literal() metaphors
wchar_quote(wchar_t RM wchar_t) single wide character quote wchar_quote(wchar_t RM wchar_t) single wide character quote
wchar_t), wchar_quote(wchar_t RM wchar_t) single wide character quote wchar_quote(wchar_t RM wchar_t) single wide character quote

WE

weak, strict weak ordering Substring comparison operators

WH

white space Substring class template parameters
white space Space policy classes
White space policy classes White space policy classes
white, regex white space class Regular expression pattern map
whitespace, regex ignore whitespace between tokens mode Regular expression pattern map

WI

wide, wchar_ansi_double_quote(RM) wide char ANSI double quote wchar_ansi_double_quote(RM) wide char ANSI double quote
wide, wchar_ansi_single_quote(RM) wide char ANSI single quote wchar_ansi_single_quote(RM) wide char ANSI single quote
wide, wchar_c_double_quote(RM) wide char C double quote wchar_c_double_quote(RM) wide char C double quote
wide, wchar_c_single_quote(RM) wide char C single quote wchar_c_single_quote(RM) wide char C single quote
wide, wchar_quote(wchar_t RM wchar_t) single wide character quote wchar_quote(wchar_t RM wchar_t) single wide character quote

WO

word Lexemes
word, regex word Regular expression pattern map
word, regex word boundary Regular expression pattern map
word_count.cpp Semantic actions
word_parser Node functors
words, Number to words conversion Number to words conversion

XM

XML, Case study: XML stream parser Case study: XML stream parser
XML, lookbehind example: CSV to XML conversion lookbehind example: CSV to XML conversion

XO

XOR, bitwise exclusive OR XOR R1^R2 binary concatenation operator

XY

xyz.cpp Grammar evaluation result

ZE

zero-length match Lexemes
zero-width lookahead assertion Lexemes
zero, *R zero or more matches *R zero or more matches
zero, R*N zero to N matches R*N zero to N matches
zero, regex zero or more Regular expression pattern map
zero, regex zero or more ungreedy Regular expression pattern map
zero, regex zero or one Regular expression pattern map
zero, regex zero or one ungreedy Regular expression pattern map

ZI

zip code Strict policy requirements
<<<    Table Of Contents     Substrings >>>