real::detail Namespace Reference

DFA construction internals: subset construction over a flattened NFA. Not a stable API. More...

Namespaces
namespace	byte_ctx
	The context bits both lazy DFAs keep for the byte beside a position (before it forward, after it backward): a newline, an ASCII word byte, or – under word_quit only – a non-ASCII byte, which sets both bits at once since no ASCII byte does.
namespace	inner_literal_detail
	Helpers for real::detail::extract_inner_literal; not part of any interface.
namespace	prof
	Opt-in route/work counters, compiled out unless the profiling build flag is set.

Classes
class	ac_automaton
	Aho-Corasick automaton for a fixed_alternation program's branch set, built once per compiled program and reused across every match on it. More...
struct	alternation_density
	Whether an alternation's first bytes are dense in one subject, decided once from a sample of it. More...
struct	alternation_pairs
	Two probe bytes per branch of a literal alternation: the branch's first byte and one byte further in it, for the pair filter an alternation's block scan turns to once the first bytes prove common. More...
struct	anchored_walk_bill
	Tells when the anchored walks from candidates should give way to one forward pass and one reverse, from what the walks that found no match cost against the distance crossed. More...
struct	ast
	A parsed pattern: the node pool plus side tables. More...
struct	ast_node
	One AST node. Active fields depend on kind (noted per field). More...
struct	backtrack_frame
	The bounded backtracker's state for one search, on the caller's stack (see pike_vm::run_bounded_backtrack). More...
struct	basic_capture_pool
	Copy-on-write pool of capture blocks, the one capture-slot mechanism for both storages. More...
struct	basic_pike_state
	Reusable VM scratch state. More...
struct	basic_thread_list
	One priority-ordered list of NFA threads (leftmost-greedy semantics). More...
struct	binprop_alias_entry
	A loose-normalized (lowercase, no _/-/space) binary-property name and its value. More...
struct	borrowed_names
	The compile-time policy's name owner: there is nothing to own. More...
struct	byte_program
	A byte-level view of a Pike program for the DFA passes: every klass_cp is expanded into UTF-8 byte-range split/klass chains, so a forward DFA can represent it; the Pike program is untouched. eligible is false when an op no DFA can represent is present — the caller keeps the Pike VM. More...
struct	char_class
	A set of byte values (0–255) as a 256-bit bitmap. More...
struct	class_def
	A parsed character class: its ASCII bitmap plus its non-ASCII code-point ranges, bundled so the two cannot desynchronize. More...
struct	class_ref
	A typed reference into a possessive-loop body's operand space. More...
struct	code_range
	An inclusive code-point range [lo, hi], shared by ast.hpp's classes and the generated Unicode tables; here so those headers need not include the parser. More...
class	compiler
	Compiles an ast into a dynamic_program (NFA bytecode). More...
struct	cp_class
	A match-time code-point class for klass_cp: an ASCII bitmap below 0x80 plus a slice of sorted non-ASCII ranges in the program's flat cp_ranges, negation already applied. Unlike the byte-NFA klass, the ranges are kept and searched at match time (O(log ranges)). More...
struct	cp_hi_table
	Unicode-property sparse 2-stage membership for code points > U+07FF (page = cp>>8 → 256-bit block). A thread-local heap cache, so basic_pike_state (and the ASCII class loop) keeps its size. More...
struct	decoded_codepoint
	The result of a strict UTF-8 decode: the code point, its byte length, and validity. More...
struct	dfa_byte_classes
	Computes byte-equivalence classes: two bytes are equivalent iff they satisfy the same consuming predicates (every klass test and every byte literal). Reduces the alphabet so the DFA is built over classes, not over 256 bytes. More...
struct	dfa_fidelity_raw
	The per-pattern answer of real::dfa_faithful, before the public wrapping. More...
struct	dfa_instr
	A flattened NFA instruction (global PCs, global class index). More...
class	dfa_lease
	This thread's DFA set for one regex, for the lifetime of the lease: a scan through it takes no lock, so threads sharing a regex do not queue on its DFAs. More...
struct	dfa_nfa
	The union NFA over all the patterns, flattened into one address space. More...
struct	dfa_tables
	The baked DFA tables produced by dfa_build. More...
struct	digit_escape_result
	Result of decode_digit_escape. More...
struct	dynamic_program
	The view is copied on every find_iter and count_matches call: a fixed per-call cost under any throughput row's noise floor, so its size is guarded by counting bytes, not by timing. More...
struct	dynamic_storage
	Storage policy backing real::regex: heap, sized once at run time. More...
struct	eps_entry
	One frame on the epsilon-closure DFS stack: a pc plus the capture block its branch carries (a split shares it, a save copies it on write), so no slot-restore entry is needed. More...
struct	fold_entry
	A code point and the other members of its case-fold orbit (up to 3; orbits <= 4). More...
struct	gc_alias_entry
	A loose-normalized (lowercase, no _/-/space) General_Category name and its property. More...
struct	inner_literal
	The best required inner literal of a pattern (the memmem candidate). More...
struct	inner_literal_bill
	Tells when the inner-literal route's candidates should give way to the core search, from what reaching their starts and confirming them read against the distance crossed. More...
struct	instr
	One NFA instruction. Field meaning depends on op. More...
struct	lazy_byte_alphabet
	Byte-class alphabet over a Pike program: bytes satisfying exactly the same byte/klass predicates share a class, so the DFA transitions over classes instead of 256 raw bytes. More...
class	lazy_dfa
	A lazy priority-preserving forward DFA over a Pike program (the kFirstMatch forward pass). More...
struct	literal_alt_chain
	The literal alternation starting at a split: its exit and each branch's bytes. More...
struct	literal_alt_trie
	A literal alternation (every branch a run of byte ops converging on one exit) factored into a trie that keeps leftmost-first priority. More...
struct	literal_density
	What the adaptive literal search learned about one subject: whether the needle's rarest byte is common there. More...
struct	literal_memo
	The two literal densities of one subject, held in a std::optional built at the first literal search, so constructing a search state (every search does) writes no densities. More...
struct	lookaround_scratch
	Reusable, isolated scratch for one level of lookaround evaluation (dynamic only). More...
struct	lookaround_sub
	A bounded lookaround sub-program, referenced by assert_lookaround's arg16. More...
class	name_context_box
	A uniquely-owning, deep-copying box for owned_name_context that survives constant evaluation. More...
struct	named_group
	A named capture group. More...
struct	non_empty_access
	The searches that accept no empty match (std::regex_constants::match_not_null), for the std drop-in; not part of REAL's own interface. More...
class	onepass
	Builds and holds the one-pass classification (and table, when eligible) of a byte-program. More...
struct	onepass_edge
	One outgoing edge of a one-pass node, for a byte-class: the next node and the capture slots that take the current position as the byte is consumed. Two epsilon paths reaching the same class with a different edge is the one-pass conflict — the pattern is then rejected. More...
struct	onepass_node
	A one-pass node: one edge per byte-class, plus whether the run may end here and with what captures. Nodes are the points the automaton can be in between byte reads. More...
struct	onepass_step
	One edge of the flattened table onepass::extract walks: onepass_edge with the target given as the offset of its row, so a step is one load from one array. More...
struct	owned_name_context
	The name-resolution context a result owns when it must outlive the regex it came from. More...
class	parser
	Recursive-descent parser: a pattern string in, an ast out. More...
struct	pattern_hints
	Search-acceleration hints extracted from a compiled program by analyze_program (prefilter.hpp). They change how fast, never what matches. More...
struct	pc_set_cache
	A chained hash set of interned state ids keyed by their pc-set: maps a candidate pc-set to its state id, or not_found. All-std::vector, not std::unordered_map, so the DFAs stay literal types (a constexpr real::regex embeds one in its scratch state). More...
struct	pike_state
	VM scratch state for the dynamic storage mode, plus the lookaround sub-scratch. More...
class	pike_vm
	The Pike VM, generic over the scratch-state container policy. More...
struct	program_view
	A non-owning view of everything the engine needs to run one compiled pattern: the borrowed spans, the slot count, the mode flags, the search hints, and the per-regex cache. Both storages hand one of these to the VM, which is why the engine is storage-agnostic. Valid only as long as the program it views is alive. More...
struct	range_intern_table
	Intern table for UTF-8 edge byte ranges, keyed by the exact 16-bit (lo << 8) | hi. More...
struct	regex_immutables
	The per-regex immutable cache the router shares across every find_iter on a regex: the byte program (klass_cp expanded to the deterministic trie) and, when the pattern is one-pass, the extractor table. More...
class	reverse_dfa
	The start-finder companion to lazy_dfa. Given a match end, it finds the leftmost start (the design guide §7.6 contract). It runs the inverted program — the forward program's edges transposed, its consuming bytes kept — as a cached DFA over the text scanned right-to-left from the end, recording an accept each time it reaches the original start (reverse-kLongest: the furthest-back accept is the start). It needs no priority ordering — its states are plain unordered (sorted) PC sets and its rule is longest — so it is simpler than the forward pass. Dynamic only. More...
struct	script_alias_entry
	A loose-normalized (lowercase, no _/-/space) Script name and its value. More...
struct	script_range
	One code-point range and the Script it belongs to (the table partitions the code space). More...
struct	shape_close
	The shape_lead counterpart: optional trail \b/\B, optional \Z/$, then exactly save 1, match ending the program. More...
struct	shape_lead
	A fixed shape's lead: save 0, an optional \A/^, an optional \b/\B. More...
struct	shared_dfa_set
	One thread's lazy DFAs for one regex: the transition caches a scan fills as it walks. More...
struct	shared_dfa_slot
	Process-wide per-regex DFA state keyed by regex_immutables*: a pool of shared_dfa_set, one per thread using the regex, and the flags every thread shares. More...
class	small_vec
	Small-buffer-optimized vector for the dynamic hot paths: up to InlineCapacity elements inline, spilling to the heap beyond that. More...
struct	static_il_guard_fields
	IL: the per-haystack guard fields the inner-literal route needs, for a compile-time storage. More...
struct	static_no_il_guard_fields
	No IL fields: the route is not compiled for this pattern. More...
struct	static_pike_scratch
	Compile-time-storage VM scratch, all fixed-capacity (zero heap), keyed on DIMENSIONS ONLY. More...
struct	static_storage
	Storage policy backing real::static_regex: compile-time, stateless. More...
class	static_vec
	Fixed-capacity vector backed by an inline array (no heap): the subset of std::vector the Pike VM uses, for the static storage mode. More...
struct	utf8_byte_range
	One byte-range step [lo, hi] of a UTF-8 sequence produced by the code-point-range algorithm. More...
struct	utf8_byte_seq
	A canonical UTF-8 byte-range sequence (1–4 steps) covering part of a code-point range. More...
struct	utf8_second_byte_bounds
	[lo, hi] bounds for the FIRST continuation byte of a multi-byte UTF-8 sequence, given its lead byte — one entry of utf8_second_byte_bounds_table. More...
struct	utf8_trie
	A minimal deterministic UTF-8 trie for a code-point class. root == -1 means the class is empty. More...
struct	utf8_trie_node
	One node of a minimal deterministic UTF-8 trie for a code-point class. Its byte-range transitions are pairwise disjoint (at most one edge matches a byte), which makes the byte-program one-pass-friendly. A target >= 0 is a node id; -1 is accept (the run continues at the construct's successor). More...
struct	visit_marks
	The pcs one closure computation has entered, by generation: starting one bumps the generation instead of clearing per pc, so a cache miss costs its closure, not the program's size (a large alternation's byte program runs to hundreds of thousands of instructions). More...

Concepts
concept	state_has_alt_pairs
	Alternation pair plan.
concept	state_has_lookaround
	Lookaround scratch.
concept	state_has_il_abandoned
	Inner-literal give-way.
concept	state_has_rare_disc_abandoned
	Rare-discriminator give-way.
concept	state_has_fwd_dfa
	Search lazy DFAs.

Typedefs
using	dfa_set = std::vector< std::uint64_t >
	A set of NFA PCs as a bitset (one per DFA state during construction).
using	capture_pool = basic_capture_pool< std::vector< std::size_t >, std::vector< std::int32_t >, std::vector< std::uint32_t > >
	The dynamic-storage capture pool: heap vectors, grows on demand.
using	thread_list = basic_thread_list< std::vector< std::int32_t >, std::vector< std::size_t >, std::vector< std::uint64_t > >
	Thread list specialized on std::vector (the dynamic storage mode).
using	byte_splat = std::array< std::uint8_t, 16 >
	One byte in all 16 lanes, as plain bytes: not a vector type, so it sits in std::array with no attribute to drop, and in plans that targets without vectors also carry.

Enumerations
enum class	ac_verdict : std::uint8_t { not_consulted = 0 , cascade , automaton }
	What the AC density gate last decided; ac_density_last_verdict() below reports it. More...
enum class	opcode : std::uint8_t {   byte , klass , klass_cp , split ,   jump , save , assert_position , match ,   assert_lookaround , byte_loop_possessive , klass_loop_possessive , klass_cp_loop_possessive }
	NFA instruction opcodes executed by the Pike VM. More...
enum class	assert_kind : std::uint8_t {   text_start , text_end , text_end_or_final_newline , line_start ,   line_end , word_boundary , not_word_boundary , word_start ,   word_end , line_start_cr , line_end_cr }
	Kind of zero-width assertion carried in assert_position's arg8. Multiline and trailing-newline variants are resolved at compile time. More...
enum class	look_dir : std::uint8_t { ahead , behind }
	Direction of a lookaround sub-pattern. More...
enum class	class_kind : std::uint8_t { none , byte , klass , klass_cp }
	Which operand space a class_ref indexes: the literal byte (byte_loop_possessive), classes[] (klass_loop_possessive) or cp_classes[] (klass_cp_loop_possessive). none = unarmed.
enum class	run_mode : std::uint8_t { prefix , full , search }
	How a VM run is anchored. More...
enum class	counter : std::uint8_t {   prefilter_work_units , vm_window_runs , batch_fills , inner_literal_bill_trips ,   inner_literal_reverse_bytes , inner_literal_confirm_bytes , byte_program_builds , il_prefix_run_walks ,   batch_handouts , vm_reseeds , onepass_anchored_walks , bounded_backtrack_runs ,   dfa_quits , literal_pair_scans , alternation_avx2_blocks , literal_avx2_scans ,   fixed_shape_batches , literal_rest_scans , alternation_pair_blocks , alternation_nibble_blocks ,   ac_completion_walks , alternation_variant_scans , alternation_wide_scans , alternation_pair_candidates ,   ahead_table_rows , behind_walk_steps , behind_atom_steps , dfa_span_batches ,   dfa_leases_taken , class_folds , count_ }
	Test counters, one per mechanism, for the tests that pin when it runs. Billed through note() only under REAL_TEST_INSTRUMENT (free in production); process-wide relaxed atomics. More...
enum class	node_kind : std::uint8_t {   empty , byte , klass , any ,   concat , repeat , alternation , group ,   anchor , lookaround }
	Kind of an AST node; selects which fields of real::detail::ast_node are meaningful. More...
enum class	anchor_kind : std::uint8_t {   caret , dollar , text_start , text_end ,   word_boundary , not_word_boundary , word_start , word_end }
	The specific zero-width assertion of an anchor node (see node_kind::anchor). More...
enum class	digit_escape_kind : std::uint8_t { octal , group_ref , octal_overflow }
	What a \<digit> escape decoded to (see decode_digit_escape()). More...
enum class	binprop : std::uint8_t {   ASCII_Hex_Digit , Alphabetic , Bidi_Control , Case_Ignorable ,   Cased , Changes_When_Casefolded , Changes_When_Casemapped , Changes_When_Lowercased ,   Changes_When_Titlecased , Changes_When_Uppercased , Dash , Default_Ignorable_Code_Point ,   Deprecated , Diacritic , Emoji , Emoji_Component ,   Emoji_Modifier , Emoji_Modifier_Base , Emoji_Presentation , Extended_Pictographic ,   Extender , Grapheme_Base , Grapheme_Extend , Grapheme_Link ,   Hex_Digit , Hyphen , IDS_Binary_Operator , IDS_Trinary_Operator ,   IDS_Unary_Operator , ID_Compat_Math_Continue , ID_Compat_Math_Start , ID_Continue ,   ID_Start , Ideographic , Join_Control , Logical_Order_Exception ,   Lowercase , Math , Modifier_Combining_Mark , Noncharacter_Code_Point ,   Other_Alphabetic , Other_Default_Ignorable_Code_Point , Other_Grapheme_Extend , Other_ID_Continue ,   Other_ID_Start , Other_Lowercase , Other_Math , Other_Uppercase ,   Pattern_Syntax , Pattern_White_Space , Prepended_Concatenation_Mark , Quotation_Mark ,   Radical , Regional_Indicator , Sentence_Terminal , Soft_Dotted ,   Terminal_Punctuation , Unified_Ideograph , Uppercase , Variation_Selector ,   White_Space , XID_Continue , XID_Start , count }
	A Unicode binary property: the 63 standard yes/no properties this build knows.
enum class	gc_property : std::uint8_t {   Lu , Ll , Lt , Lm ,   Lo , Mn , Mc , Me ,   Nd , Nl , No , Pc ,   Pd , Ps , Pe , Pi ,   Pf , Po , Sm , Sc ,   Sk , So , Zs , Zl ,   Zp , Cc , Cf , Co ,   Cn , L , M , N ,   P , S , Z , C ,   count }
	A Unicode General_Category property: the 29 assignable categories then the 7 groups.
enum class	script : std::uint8_t {   Unknown , Adlam , Ahom , Anatolian_Hieroglyphs ,   Arabic , Armenian , Avestan , Balinese ,   Bamum , Bassa_Vah , Batak , Bengali ,   Bhaiksuki , Bopomofo , Brahmi , Braille ,   Buginese , Buhid , Canadian_Aboriginal , Carian ,   Caucasian_Albanian , Chakma , Cham , Cherokee ,   Chorasmian , Common , Coptic , Cuneiform ,   Cypriot , Cypro_Minoan , Cyrillic , Deseret ,   Devanagari , Dives_Akuru , Dogra , Duployan ,   Egyptian_Hieroglyphs , Elbasan , Elymaic , Ethiopic ,   Garay , Georgian , Glagolitic , Gothic ,   Grantha , Greek , Gujarati , Gunjala_Gondi ,   Gurmukhi , Gurung_Khema , Han , Hangul ,   Hanifi_Rohingya , Hanunoo , Hatran , Hebrew ,   Hiragana , Imperial_Aramaic , Inherited , Inscriptional_Pahlavi ,   Inscriptional_Parthian , Javanese , Kaithi , Kannada ,   Katakana , Kawi , Kayah_Li , Kharoshthi ,   Khitan_Small_Script , Khmer , Khojki , Khudawadi ,   Kirat_Rai , Lao , Latin , Lepcha ,   Limbu , Linear_A , Linear_B , Lisu ,   Lycian , Lydian , Mahajani , Makasar ,   Malayalam , Mandaic , Manichaean , Marchen ,   Masaram_Gondi , Medefaidrin , Meetei_Mayek , Mende_Kikakui ,   Meroitic_Cursive , Meroitic_Hieroglyphs , Miao , Modi ,   Mongolian , Mro , Multani , Myanmar ,   Nabataean , Nag_Mundari , Nandinagari , New_Tai_Lue ,   Newa , Nko , Nushu , Nyiakeng_Puachue_Hmong ,   Ogham , Ol_Chiki , Ol_Onal , Old_Hungarian ,   Old_Italic , Old_North_Arabian , Old_Permic , Old_Persian ,   Old_Sogdian , Old_South_Arabian , Old_Turkic , Old_Uyghur ,   Oriya , Osage , Osmanya , Pahawh_Hmong ,   Palmyrene , Pau_Cin_Hau , Phags_Pa , Phoenician ,   Psalter_Pahlavi , Rejang , Runic , Samaritan ,   Saurashtra , Sharada , Shavian , Siddham ,   SignWriting , Sinhala , Sogdian , Sora_Sompeng ,   Soyombo , Sundanese , Sunuwar , Syloti_Nagri ,   Syriac , Tagalog , Tagbanwa , Tai_Le ,   Tai_Tham , Tai_Viet , Takri , Tamil ,   Tangsa , Tangut , Telugu , Thaana ,   Thai , Tibetan , Tifinagh , Tirhuta ,   Todhri , Toto , Tulu_Tigalari , Ugaritic ,   Vai , Vithkuqi , Wancho , Warang_Citi ,   Yezidi , Yi , Zanabazar_Square , count }
	A Unicode Script value; Unknown (0) is every code point no script assigns.

Functions
bool &	lazy_dfa_route_disabled ()
	Test seam: force the matcher off the lazy-DFA route onto the pure Pike VM, so a differential can assert routed and unrouted searches agree in one binary. Not for production use (applies to every *_disabled seam below).
std::size_t &	lazy_dfa_byte_budget ()
	Test seam: the byte budget the search DFAs are built with (read at each DFA's construction).
bool &	bounded_backtrack_route_disabled ()
	Test seam: force the general loop off the bounded backtracker onto the Pike VM, so a differential can assert both agree on every small subject.
bool &	inner_literal_route_disabled ()
	Test seam: force the matcher off the inner-literal search route onto the core search. The route cannot miss a leftmost match because its reverse bound never advances mid-search.
bool &	rare_disc_route_disabled ()
	Test seam: force off the rare-discriminant prefilter (https?:// memchr-: route) onto prefix/first-byte search.
bool &	inner_literal_guard_disabled ()
	Test seam: force the inner-literal small-haystack guard off, so the route fires on any size and tiny correctness inputs exercise it. The guard uses regex_immutables::il_min_haystack on the first candidate scan and il_warm_floor thereafter.
bool &	trailing_la_route_disabled ()
	Test seam: force the matcher off the trailing-lookaround class+ route onto the pure Pike VM.
bool &	fixed_shape_pair_route_disabled ()
	Test seam: force the matcher off the heterogeneous fixed-shape pair-filter route onto the ordinary run_fixed_shape walk. The route only filters; match_fixed_body_wb decides each candidate.
bool &	fixed_shape_route_disabled ()
	Test seam: force the matcher off the fixed-shape walk (run_fixed_shape) onto the general Pike loop. inner_literal_route_disabled does not reach a fixed_shape pattern (the inner-literal gate excludes it); a differential on one needs this seam.
bool &	class_fastpath_disabled ()
	Test/profile seam: skip the dedicated class-scan fast paths (byte class-loop, cp-class-loop, codepoint_class, negated-class ./[^,]+), so such a pattern falls through to lazy-DFA / general.
bool &	possessive_fastpath_disabled ()
	Test/profile seam: force the matcher off the possessive-loop fast paths (bare/suffixed/delimited X*+/X++) onto the general VM.
bool &	aho_corasick_route_disabled ()
	Test seam: force the matcher off the Aho-Corasick multi-literal route onto the pattern_hints::fixed_alternation run_alternation path.
bool &	alternation_pairs_disabled ()
	Test seam: keep an alternation's block scans on its first bytes whatever the subject's density, so a differential can compare the pair filter with the first-byte scan.
bool &	alternation_nibbles_disabled ()
	Test seam: mask a dense alternation's blocks by its byte pairs rather than by the nibble fingerprint, so a differential can compare both filters.
bool &	ac_density_gate_disabled ()
	Test seam: take the Aho-Corasick density gate out, so the route is chosen on branch count alone.
std::atomic< bool > &	il_density_last_abandoned ()
	Test observability: whether the inner-literal density gate last abandoned the route.
std::atomic< ac_verdict > &	ac_density_last_verdict ()
	Test observability: the AC density gate's most recent verdict.
constexpr utf8_trie	build_utf8_trie (const cp_class &cc, std::span< const code_range > cp_ranges)
	Builds the minimal deterministic trie recognising a code-point class's UTF-8 byte sequences.
constexpr std::size_t	utf8_trie_emit_size (const utf8_trie &trie)
	The instruction count emit_utf8_trie writes: an empty class is one dead klass; otherwise each node is a split-guarded chain of k byte ranges (3k - 1 instructions).
REAL_BUILD_COLD constexpr void	emit_utf8_trie (byte_program &bp, const utf8_trie &trie, std::int32_t after, range_intern_table &seen)
	Emits trie into bp as a deterministic split/klass/jump fragment, interning each edge's byte range through seen.
bool &	alternation_trie_disabled ()
	Test seam: build the byte program's literal alternations flat, so a differential can compare the trie against them.
constexpr bool	detect_literal_alt (std::span< const instr > code, std::size_t pc, literal_alt_chain &out)
	Whether [pc, exit) is a chain of splits whose branches are runs of byte ops jumping forward to one exit, the last branch falling through to it.
REAL_BUILD_COLD constexpr byte_program	build_byte_program (const program_view &prog, bool keep_assertions=false, std::size_t max_size=max_byte_program_size)
	Builds the byte-level DFA program for prog (see byte_program). A klass_cp at P (the op plus three utf8_cont slots) is replaced by its class's deterministic UTF-8 trie (build_utf8_trie), converging on the mapped P+4; every other op is copied with remapped targets. The first pass sizes each construct into the old→new pc map and enforces max_size; the second emits.
constexpr bool	is_cr_line_assert (const instr &in)
	Whether in is an ECMAScript line assertion, whose line ends at \r as well as \n.
REAL_BUILD_COLD constexpr lazy_byte_alphabet	compute_lazy_alphabet (std::span< const instr > code, std::span< const char_class > classes)
	Partition 0..255 by the program's consuming predicates (every klass test, every byte literal). Bytes with an identical signature collapse to one class.
constexpr bool	undecidable_word (assert_kind kind, bool prev_word, bool prev_nonascii, bool next_word, bool next_nonascii)
	Whether a word assertion needs a code point's word-ness that one byte does not give: a side it reads is a non-ASCII byte, and the ASCII side does not settle it alone.
constexpr bool	dfa_representable (std::span< const instr > code, bool ascii_word)
	Whether a lazy DFA, forward or reversed, can represent every op of code.
void	erase_shared_dfas (const regex_immutables *immut)
	Retire this regex's slot (called from ~regex_immutables). Scans still holding the slot's shared_ptr keep it alive; clearing shared_dfa_slot::owner stops their cached copy matching, so a new regex at this address is never served the retired slot.
std::mutex &	immut_build_mu (const regex_immutables *immut)
	Striped rebuild lock for pike_vm::ensure_immutables (not on regex_immutables — layout isolation). Distinct from shared_dfa_map_mu / shared_dfa_slot::pool_mu so reset_shared_dfas cannot self-deadlock. Different immutables rarely share a stripe.
std::mutex &	shared_dfa_map_mu ()
	The mutex guarding insert/erase on the process-wide shared_dfa_slot map.
std::unordered_map< const regex_immutables *, std::shared_ptr< shared_dfa_slot > > &	shared_dfa_map ()
	Process-wide map, deliberately never destroyed: other statics' ~regex_immutables still call erase_shared_dfas at exit. Entries are erased per destructor, so nothing accumulates.
shared_dfa_slot &	shared_dfa_for (regex_immutables *immut)
	Resolve the process-wide DFA slot for this regex (map insert under shared_dfa_map_mu).
void	reset_shared_dfas (regex_immutables *immut, bool keep_warm=false)
	Drop any DFAs cached for immut (caller holds nothing; takes map + slot locks). Invoked from pike_vm's ensure_immutables rebuild so a reused immutables address — or the same address under a new program — cannot keep a previous pattern's DFAs.
std::size_t	shared_dfa_map_size_for_test ()
	Test/audit: number of live shared-DFA map entries (process-wide). Not for production.
constexpr std::size_t	encode_utf8_bytes (std::uint32_t cp, std::uint8_t(&out)[4])
	Encodes cp to its UTF-8 bytes in out, returning the length (1–4).
constexpr void	utf8_push_range (std::uint32_t start, std::uint32_t end, std::vector< utf8_byte_seq > &out)
	Appends to out the byte-range sequences recognising exactly the UTF-8 encodings of [start, end] (RE2 / rust regex-syntax Utf8Sequences).
constexpr std::vector< utf8_byte_seq >	utf8_range_sequences (std::uint32_t lo, std::uint32_t hi)
	Canonical UTF-8 byte-range sequences for the code-point range [lo, hi], excluding the surrogate block [U+D800, U+DFFF] (so a negated class never matches a surrogate encoding).
constexpr void	fold_ascii_case (char_class &klass)
	Closes klass under ASCII case folding.
constexpr bool	is_ascii_word_byte (std::uint8_t byte)
	Reports whether byte is an ASCII "word" byte ([0-9A-Za-z_]).
constexpr char_class	digit_set ()
	The ASCII digit set behind \d (Python re.ASCII semantics).
constexpr char_class	word_set ()
	The ASCII word set behind \w.
constexpr char_class	space_set ()
	The ASCII whitespace set behind \s under flags::ascii / flags::bytes.
constexpr char_class	utf8_cont_set ()
	The UTF-8 continuation-byte set 10xxxxxx.
constexpr char_class	utf8_lead2_set ()
	The lead-byte set of a 2-byte UTF-8 sequence.
constexpr char_class	utf8_lead3_set ()
	The lead-byte set of a 3-byte UTF-8 sequence.
constexpr char_class	utf8_lead4_set ()
	The lead-byte set of a 4-byte UTF-8 sequence.
constexpr std::array< utf8_second_byte_bounds, 256 >	make_utf8_second_byte_bounds_table ()
	Builds utf8_second_byte_bounds_table.
constexpr std::uint64_t	fingerprint_cp_class_content (const char_class &ascii, const code_range *ranges, std::uint32_t range_count)
	FNV-1a 64-bit content fingerprint of an ASCII bitmap and a range span, computed once at intern_cp_class (constexpr, for static_regex); match time reads cp_class::fingerprint.
dfa_nfa	dfa_flatten (std::span< const program_view > programs)
	Flattens programs into one union NFA, auditing DFA-ability.
void	dfa_set_bit (dfa_set &s, std::size_t i)
	Set bit i in s. Indices past the set's size are ignored (it is sized to fit).
bool	dfa_test_bit (const dfa_set &s, std::size_t i)
	Whether bit i is set in s.
dfa_set	dfa_closure (const dfa_nfa &nfa, const std::vector< std::uint32_t > &seeds, bool at_start)
	The epsilon-closure of seeds (a PC list), as a canonical PC bitset. at_start follows a text_start assertion (true only at offset 0).
dfa_set	dfa_move (const dfa_nfa &nfa, const dfa_set &set, std::uint8_t rep)
	The move on the byte rep: ε-closure of the successors of every PC in set that consumes rep.
std::int64_t	dfa_accept_of (const dfa_nfa &nfa, const dfa_set &set)
	The accepting rule of a state set: the SMALLEST rule index among its match PCs (the order tie-break), or -1 if none accept.
std::size_t	dfa_mask_words (std::size_t rule_count) noexcept
	Word count for a which-matched bitset over rule_count rules.
std::vector< std::uint64_t >	dfa_accept_mask_of (const dfa_nfa &nfa, const dfa_set &set)
	Bitset of ALL accepting rule indices in set (which-matched; word-packed). Empty vector when no rule accepts (or rule_count == 0).
std::int64_t	dfa_mask_min_rule (const std::vector< std::uint64_t > &mask)
	Smallest rule index set in mask, or -1 if empty (munch tag derivation).
dfa_byte_classes	dfa_compute_classes (const dfa_nfa &nfa)
	Partition 0..255 by the union NFA's consuming predicates.
void	dfa_seeds_all (const dfa_nfa &nfa, const dfa_set &set, const dfa_byte_classes &bc, const std::vector< std::vector< std::uint8_t > > &klass_members, std::vector< std::vector< std::uint32_t > > &seeds)
	Every class's seed list from one state in one pass over the state's PCs: the PCs after each consuming instruction that class passes, without rescanning the set once per class.
dfa_tables	dfa_build (std::span< const program_view > programs, std::size_t state_cap=max_dfa_states, bool unanchored=false)
	Subset construction over byte-classes, then Moore minimization.
bool	dfa_priority_closure (const dfa_nfa &nfa, std::uint32_t seed, bool at_start, std::vector< std::uint8_t > &seen, std::vector< std::uint32_t > &out)
	The priority-ordered epsilon closure of seed, as the Pike walk builds it: consuming pcs are appended to out in priority order, and reaching a match stops the walk, because a thread list is cut below its first accepting thread.
dfa_fidelity_raw	dfa_decide_fidelity (const program_view &prog, std::size_t budget)
	Decides whether prog's priority match equals its longest match on every input.
void	dfa_memo_misuse (const char *what)
	Throws the std::invalid_argument a misused dfa_munch_memo raises, out of line so the throw does not weigh on the per-token match that checks for it.
std::size_t &	ac_memory_budget ()
	Bytes an automaton may hold (the layout rule is in the file header); ac_memory_budget_default unless a test shrinks it to reach the sparse form and the decline.
bool &	ac_dense_disabled ()
	Test seam: search the sparse trie even where the dense table fits.
std::size_t &	ac_sparse_row_cap ()
	Test seam: at most this many dense rows in the sparse form below what the budget allows. The root keeps its row whatever the cap: a miss there has no fail link to fall along.
REAL_BUILD_COLD std::optional< ac_automaton >	build_ac_automaton (std::span< const instr > code, std::span< const char_class > classes, std::size_t body_pc)
	Builds an ac_automaton from a fixed_alternation-shaped program's branch set, over the program's own byte classes (every class it tests is a union of them, so no position is split).
constexpr bool	word_before (std::string_view text, std::size_t pos, bool ascii_word)
	Word-ness of the code point ending at pos — the left side of a boundary. False at the text start or on a malformed sequence; ASCII / bytes / re.A (ascii_word) stay byte-level.
constexpr bool	word_after (std::string_view text, std::size_t pos, bool ascii_word)
	Word-ness of the code point starting at pos — the right side of a boundary. False at the text end or on a malformed sequence; ASCII / bytes / re.A stay byte-level.
constexpr bool	assertion_holds (assert_kind kind, std::string_view text, std::size_t pos, bool ascii_word)
	Evaluates a zero-width assertion at pos in text.
std::atomic< std::uint64_t > &	tally (counter c) noexcept
	The value of a test counter, to read or to reset.
constexpr void	note (counter c, std::uint64_t n=1) noexcept
	Bills n to a test counter. A no-op unless the test binary defines REAL_TEST_INSTRUMENT.
bool &	alternation_avx2_disabled ()
	Test seam: keep the alternation fingerprint on 16-byte blocks where the CPU has AVX2, so a differential can compare both widths in one binary. Not for production use.
bool &	literal_avx2_disabled ()
	Test seam: keep the literal filter on 16-byte blocks where the CPU has AVX2, so a differential can compare both widths in one binary. Not for production use.
constexpr bool	is_word_boundary_kind (assert_kind kind) noexcept
	True if kind is \b or \B (the only position asserts a fast path wraps).
constexpr std::uint8_t	wb_hint_of (assert_kind kind) noexcept
	Encodes kind as a wb_lead/wb_trail hint value (1 = \b, 2 = \B); 0 if not a word boundary.
constexpr bool	peel_optional_wb (std::span< const instr > code, std::size_t &p, std::uint8_t &hint) noexcept
	Peels an optional \b/\B assertion at p, lead or trail alike.
constexpr shape_lead	parse_shape_lead (std::span< const instr > code) noexcept
	Peels a fixed shape's save 0 and its optional lead \b/\B.
constexpr shape_close	parse_shape_close (std::span< const instr > code, std::size_t from) noexcept
	Peels a fixed shape's optional trail \b/\B, then its save 1 and match.
constexpr bool	is_full_ascii_word_class (const char_class &cls) noexcept
	True if cls is exactly the ASCII word set [0-9A-Za-z_] (\w under bytes/re.A).
constexpr bool	is_ascii_word_subset_class (const char_class &cls) noexcept
	True if every member of cls is an ASCII word byte (subset of \w under bytes/re.A).
constexpr bool	is_full_unicode_word_cp_class (const cp_class &cc, std::span< const code_range > all_ranges) noexcept
	True if cc is exactly the canonical Unicode \w class (not a user superset).
constexpr bool	wb_redundant_for_full_word (std::uint8_t lead, std::uint8_t trail) noexcept
	The DROP rule: \b next to a full-\w maximal run is redundant (\B never is).
constexpr bool	resolve_class_wb_hints (bool full_word, bool word_sub, bool maximal_run, std::uint8_t lead, std::uint8_t trail, std::uint8_t &out_lead, std::uint8_t &out_trail) noexcept
	DROP / WRAP policy for class / cp-class loops under optional \b/\B wraps.
constexpr bool	word_ranges_cover_interval_from (char32_t lo, char32_t hi, std::size_t &cursor) noexcept
	True if every code point in [lo, hi] is a Unicode word char (word_ranges), resuming the scan at cursor and leaving it past the last range consulted.
constexpr bool	word_ranges_cover_interval (char32_t lo, char32_t hi) noexcept
	True if every code point in [lo, hi] is a Unicode word char (covered by word_ranges). Standalone form of word_ranges_cover_interval_from.
constexpr bool	is_unicode_word_subset_cp_class (const cp_class &cc, std::span< const code_range > all_ranges) noexcept
	True if cc is a non-empty subset of Unicode \w (safe for maximal-run + \b wrap).
constexpr bool	cp_class_may_contain_ascii_byte (const cp_class &cc, std::uint8_t b) noexcept
	Whether byte b could be a member of cc; a delimiter that could hide in a possessive code-point loop makes the delimited fast path decline (pattern_hints::possessive_prefix).
constexpr bool	is_fixed_alternation (std::span< const instr > code, std::uint8_t *out_wb_lead=nullptr, std::uint8_t *out_wb_trail=nullptr, std::uint8_t *out_body_pc=nullptr, std::int32_t *out_branch_count=nullptr)
	Alternation of straight-line byte/klass branches, optionally wrapped in \b/\B.
constexpr void	extract_anchoring (std::span< const instr > code, pattern_hints &hints)
	Records start anchoring: the first non-save instruction tells whether every match must begin at position 0 (\A/^ non-multiline) or at a line start.
constexpr void	extract_prefix (std::span< const instr > code, pattern_hints &hints)
	Collects the required literal prefix and the exact-literal fast-path length.
constexpr void	compute_first_bytes (std::span< const instr > code, std::span< const char_class > classes, std::span< const cp_class > cp_classes, pattern_hints &hints)
	Computes the possible first-byte set by a DFS over the epsilon closure of pc 0.
constexpr int	class_range_count (const char_class &klass, std::uint8_t &lo0, std::uint8_t &hi0, std::uint8_t &lo1, std::uint8_t &hi1)
	Reports klass as up to two contiguous byte ranges.
REAL_BUILD_COLD constexpr void	detect_fast_shapes (std::span< const instr > code, std::span< const char_class > classes, std::span< const cp_class > cp_classes, std::span< const code_range > cp_ranges, std::int32_t cp_mark_ascii, std::int32_t cp_mark_offset, std::int32_t cp_mark_end, std::span< const lookaround_sub > lookarounds, pattern_hints &hints)
	Detects the whole-pattern fast-path shapes and sets their hint flags: class+, fixed-shape straight runs, a single codepoint class (./negated, optional +), an alternation of straight-line branches, and trailing-lookaround class+.
constexpr std::uint16_t	byte_frequency (std::uint8_t b)
	Approximate static frequency of a byte in mixed English and source text, per 10000, used only to rank candidate prefilter bytes: a rare required byte (-, @) is a far more selective memchr target than a common first-byte class.
constexpr std::uint8_t	literal_rarest_offset (std::string_view literal)
	Offset of the rarest byte of literal by byte_frequency (the first of equals).
constexpr void	extract_rare_byte (std::span< const instr > code, pattern_hints &hints)
	Records a required literal byte at a FIXED offset far rarer than the first-byte set (pattern_hints::rare_byte / rare_offset), so the search can memchr that one byte.
constexpr void	extract_rare_discriminant (std::span< const instr > code, pattern_hints &hints)
	Arms the rare-discriminant prefilter for shapes like https?://…: fixed prefix (http) + optional mono-byte (s?) + fixed mid with a rare disc (://).
constexpr bool	capture_free_walk_structural (std::span< const instr > code) noexcept
	The structural half of pattern_hints::capture_free_walk, that save 0 is the program's first instruction.
constexpr pattern_hints	analyze_program (std::span< const instr > code, std::span< const char_class > classes, std::span< const cp_class > cp_classes, std::span< const code_range > cp_ranges, std::int32_t cp_mark_ascii, std::int32_t cp_mark_offset, std::int32_t cp_mark_end, std::span< const lookaround_sub > lookarounds={})
	Walks a compiled program once to derive its search hints.
constexpr bool	fixed_shape_walk_pays (std::span< const instr > code, const pattern_hints &hints) noexcept
	Whether a search over this fixed shape (pattern_hints::fixed_shape) should walk each candidate start rather than run the lazy DFA.
constexpr std::size_t	find_byte (std::string_view text, std::size_t pos, char byte)
	Index of byte in text[pos..), or real::npos.
constexpr std::size_t	find_rare_disc_candidate (std::string_view text, std::size_t pos, const pattern_hints &hints, bool *density_abandon=nullptr)
	Next candidate start for the rare-discriminant prefilter, or real::npos.
constexpr void	store_literal_density (literal_density &density, std::uint32_t cands, std::size_t origin, std::size_t next) noexcept
	Writes the adaptive search's local density back (find_literal_adaptive_rest keeps it in locals while it scans).
std::size_t	find_literal_adaptive_rest (std::string_view text, std::size_t pos, std::string_view literal, std::size_t rare, literal_density &density)
	The body of find_literal_adaptive past its first stop: the pair filter for a dense subject, else the rarest-byte scan that counts its stops and judges their density.
std::size_t	find_literal_adaptive (std::string_view text, std::size_t pos, std::string_view literal, std::size_t rare, literal_density &density)
	Index of the first occurrence of literal in text[pos..), or real::npos, by its rarest byte while that byte is rare in the subject and by the two-byte block filter once it is not.
bool	alternation_nibbles_supported ()
	Whether the nibble fingerprint can run here: AArch64 always, x86 when the build enables SSSE3 or, with gcc or clang, when the running CPU has it. A plan built elsewhere never claims one: the fingerprint's reach is shorter than the pairs', and a scan that bounded its blocks by it while masking by the pairs would read past the subject.
constexpr std::size_t	find_literal (std::string_view text, std::size_t pos, std::string_view literal)
	Index of the first occurrence of literal in text[pos..), or real::npos.
constexpr std::size_t	find_prefix (std::string_view text, std::size_t pos, std::string_view prefix)
	First position >= pos where prefix occurs in text, or npos; the dispatch of find_literal.
std::size_t	find_members (std::string_view text, std::size_t pos, const std::array< std::uint8_t, 8 > &mem, std::uint8_t n)
	Least index at or after pos whose byte is one of n members, in ONE pass.
std::size_t	find_folded_literal (std::string_view text, std::size_t pos, std::string_view lit, std::uint16_t folded, std::size_t rare)
	The first occurrence at or after pos of a literal some of whose letters match in either case.
constexpr std::size_t	find_line_end_cr (std::string_view text, std::size_t pos)
	Where an ECMAScript line ends: the index of the first \n or \r in text[pos..), or real::npos.
constexpr std::size_t	find_bytes_cascade (std::string_view text, std::size_t pos, const char *set, std::uint8_t n)
	Index of the first byte in text[pos..) that belongs to a small first-byte set.
constexpr std::size_t	first_high_byte (std::string_view text, std::size_t pos, std::size_t end)
	Index of the first byte >= 0x80 in text[pos, end), or end if the range is pure ASCII.
constexpr std::vector< code_range >	coalesce_ranges (std::vector< code_range > ranges)
	Sorts ranges and merges overlapping or adjacent ones: the same code points in the fewest ranges.
constexpr std::vector< code_range >	complement_code_ranges (std::vector< code_range > ranges)
	Complements a set of code-point ranges within [0x80, 0x10FFFF] (negated classes, in-class \W/\D/\S). Input may be unsorted or overlapping; the gaps come sorted.
constexpr std::uint32_t	single_codepoint_atom (const ast &tree, std::int32_t index)
	The code point a node spells, when it is exactly one non-ASCII literal character.
constexpr digit_escape_result	decode_digit_escape (std::string_view text, std::size_t first)
	Decodes a \<digit> escape per CPython's rule; shared by the pattern and the replacement-template parsers so the two never drift.
constexpr ast	parse (std::string_view pattern, flags initial_flags=flags::none)
	Parses pattern into an ast (convenience over parser).
constexpr bool	is_any_non_ascii (const std::vector< code_range > &ranges)
	Whether ranges is exactly the whole non-ASCII space [U+0080, U+10FFFF] — the "any non-ASCII code point" shape emitted by compiler::emit_any_codepoint_class.
constexpr bool	cp_ranges_are_normalised (const std::vector< code_range > &ranges)
	Whether ranges is what every consumer of a cp_class requires: each range non-empty, the sequence strictly ascending and disjoint.
constexpr class_def	unicode_casefold (const class_def &in)
	Expands a character class to its Unicode simple case-fold closure (text-mode icase).
constexpr bool	node_nullable (const ast &tree, std::int32_t idx)
	True if the AST subtree rooted at idx can match the empty string. empty, anchor and lookaround are zero-width, so exactly nullable; byte/klass/any never are.
constexpr bool	subtree_has_nullable_capturing_group (const ast &tree, std::int32_t idx)
	True if the AST subtree rooted at idx contains, at any depth, a capturing group (group >= 0) whose body is nullable (node_nullable).
constexpr bool	ast_has_nullable_captured_repeat (const ast &tree, std::int32_t idx)
	True if a capturing group with a nullable body sits anywhere under a quantifier (? included): the source of pattern_hints::nullable_captured_repeat. A safe over-approximation: it flags the shape ((\b|x)+ counts), not a proven divergent capture.
constexpr dynamic_program	compile (const ast &tree, flags compile_flags)
	Compiles tree to an NFA program (convenience over compiler).
constexpr inner_literal	extract_inner_literal (const ast &tree)
	Extract the best required inner literal from a pattern's AST (a pure function on the node pool).
ast	build_prefix_ast (const ast &tree, std::int32_t count, std::int32_t skip=0)
	Build the prefix sub-AST: count top-level concat children starting after skip lead children.
std::size_t	prefix_reverse_start (const ast &tree, std::int32_t count, flags compile_flags, std::string_view text, std::size_t h, std::size_t min_start)
	The match start for a literal candidate at h: reverse-match the prefix (the first count top-level children) ending at h, bounded below by min_start. Runtime only (the reverse walk is not constexpr).
constexpr std::string_view	c_string_subject (const char *text) noexcept
	A C string as a subject. A null pointer is a caller's bug: a debug build stops on it, and a release build reads it as the empty subject, as the C API does, where constructing a std::string_view from it is undefined.
template<typename State , bool Bound, typename Slots >
constexpr bool	run_attempt (pike_vm< State, Bound > &vm, const program_view &prog, std::string_view subject, std::size_t pos, run_mode mode, Slots &slots, match_semantics sem=match_semantics::first)
	One attempt over a region, as every single search makes it: the trailing-lookaround walk where the pattern has one, else pike_vm::run with its memchr-cascade variant chosen once, here.
constexpr std::size_t	scratch_code_tier (std::size_t code_size)
	Rounds a program length up to the scratch capacity tier it shares with its neighbours.
constexpr bool	is_binprop_cp (binprop prop, char32_t cp)
	Whether cp has the binary property prop (== the UCD).
constexpr binprop	resolve_binprop (std::string_view loose)
	Resolve a loose-normalized binary-property name to its value, or count if unknown.
constexpr std::size_t	find_fold_lower_bound (std::uint32_t cp)
	Index of the first entry whose code point is at or after cp, or unicode_fold_table_size if none is. The seek half of find_fold_index, exposed on its own so a caller holding a RANGE enters the table once and walks forward instead of scanning it whole – see real::detail::unicode_casefold.
constexpr std::size_t	find_fold_index (std::uint32_t cp)
	Binary-searches unicode_fold_table for cp; returns its index, or unicode_fold_table_size if cp is not cased. An index (not a pointer into the table) keeps this usable in a constant expression on every compiler — g++ rejects a &table[i] != nullptr comparison inside a static_regex. Shared by the parser (is a literal cased?) and the compiler (its fold partners).
constexpr bool	is_gc_cp (gc_property prop, char32_t cp)
	Whether cp is in the General_Category property prop (== the UCD).
constexpr gc_property	resolve_gc (std::string_view loose)
	Resolve a loose-normalized General_Category name to its property, or count if unknown.
constexpr bool	cp_in_ranges (std::span< const code_range > ranges, char32_t cp)
	Binary-searches a sorted, non-overlapping range table for cp. Returns a bool (not a pointer into the table) so it stays constant-evaluable on every compiler.
constexpr bool	is_word_cp (char32_t cp)
	Whether cp is a Unicode word code point (== re \w).
constexpr bool	is_digit_cp (char32_t cp)
	Whether cp is a Unicode digit code point (== re \d).
constexpr bool	is_space_cp (char32_t cp)
	Whether cp is a Unicode whitespace code point (== re \s).
constexpr script	script_of (char32_t cp)
	The Script of cp (binary search; Unknown when no range covers it).
constexpr bool	is_script_cp (script sc, char32_t cp)
	Whether cp belongs to Script sc (== the UCD).
constexpr script	resolve_script (std::string_view loose)
	Resolve a loose-normalized Script name to its value, or count if unknown.
constexpr bool	is_scx_cp (script sc, char32_t cp)
	Whether cp is in the Script_Extensions of sc (== the UCD). NOT exclusive: a code point can satisfy this for several script values at once.
constexpr decoded_codepoint	decode_codepoint_strict (std::string_view text, std::size_t pos)
	Strictly decodes and validates the UTF-8 sequence at text[pos].
constexpr std::size_t	codepoint_advance (std::string_view text, std::size_t pos)
	Number of bytes from pos to the next code-point boundary, for advancing past an empty match during iteration.
constexpr std::size_t	codepoint_retreat (std::string_view text, std::size_t end, std::size_t floor)
	Width of the last code point before end, the mirror of codepoint_advance.

Variables
constexpr int	max_loop_hops {8}
	Cap on how far a jump chain is followed to a loop head (empty-iteration exit routing), shared by every closure walk; a loop join reaches its split in one hop, so eight is headroom, not a knob.
constexpr std::size_t	lazy_dfa_default_byte_budget {std::size_t {64} << 20U}
constexpr std::size_t	alternation_trie_min_branches {64}
constexpr std::size_t	max_byte_program_size {20000}
constexpr std::size_t	il_warm_floor {4UL * 1024}
	Warm-regime IL minimum haystack, in bytes: below it the candidate scan can cost more than the route saves, even with the reverse DFA already built. A cold first scan uses the higher regex_immutables::il_min_haystack.
constexpr std::size_t	il_short_scan_budget {64UL * 1024}
	Subject bytes a regex lets the inner-literal route decline under its floor before it builds what the route needs: the cold floor's least amortization. Short subjects that add up to it have paid for the build as one long subject would, and the build lifts both floors for good. Without it a regex only ever searched on short subjects stays on the bounded backtracker, many times dearer per search than the built route.
constexpr std::uint32_t	onepass_prefix_warm_calls {8192}
	Anchored matches a regex runs before it builds its one-pass table for them. Rent before buying: the build (byte program, table, minimization) costs about as much as 5 000 to 13 000 of these calls made without it, so a regex matched a few times never pays it, and one matched in a loop pays at most about twice what the best choice made in hindsight would have.
constexpr std::array< utf8_second_byte_bounds, 256 >	utf8_second_byte_bounds_table
	First-continuation-byte bounds indexed by lead byte (only 0xC2–0xF4 are consulted).
constexpr std::size_t	default_max_program_size {262144}
	max_program_size's default.
constexpr std::int32_t	default_max_repeat_count {1000}
	max_repeat_count's default.
constexpr std::int32_t	default_max_group_count {32766}
	max_group_count's default.
constexpr std::int32_t	default_max_nesting_depth {200}
	max_nesting_depth's default.
constexpr std::int32_t	default_max_lookaround_length {255}
	max_lookaround_length's default.
constexpr std::size_t	default_max_dfa_states {65536}
	max_dfa_states's default.
constexpr std::size_t	max_program_size {default_max_program_size}
	Maximum number of NFA instructions in a compiled program — 256 Ki by default (REAL_MAX_PROGRAM_SIZE).
constexpr std::string_view	program_too_large {"program too large"}
	The cause a program past max_program_size is rejected with (real::regex_error::cause).
constexpr std::int32_t	max_repeat_count {default_max_repeat_count}
	Per-quantifier bounded-repeat cap, enforced at parse time (REAL_MAX_REPEAT_COUNT).
constexpr std::int32_t	max_group_count {default_max_group_count}
	Maximum capture groups; bounds slot_count = 2 * (groups + 1) (REAL_MAX_GROUP_COUNT).
constexpr std::int32_t	max_nesting_depth {default_max_nesting_depth}
	Maximum parser recursion depth; prevents stack overflow on deep nesting (REAL_MAX_NESTING_DEPTH).
constexpr std::int32_t	max_lookaround_length {default_max_lookaround_length}
	Maximum bytes a bounded lookaround sub-pattern may consume (its L_max); bounding it keeps per-position evaluation linear (REAL_MAX_LOOKAROUND_LENGTH).
constexpr std::size_t	max_dfa_states {default_max_dfa_states}
	Maximum DFA states (opt-in real::dfa; REAL_MAX_DFA_STATES).
constexpr std::uint64_t	fnv1a_offset_basis {14695981039346656037ULL}
	FNV-1a 64-bit offset basis. Reference it, never re-type it: a wrong basis still hashes, just not as FNV-1a, and nothing downstream notices.
constexpr std::uint64_t	fnv1a_prime {1099511628211ULL}
	FNV-1a 64-bit prime, paired with fnv1a_offset_basis.
constexpr std::size_t	bounded_backtrack_max_slots {34}
	Capture slots the bounded backtracker carries in a fixed array (16 groups and group 0).
constexpr std::size_t	bounded_backtrack_bits {8192}
	The bounded backtracker's budget: one bit per (instruction, position), (n + 1) x m bits for an n-byte subject and an m-instruction program.
constexpr std::size_t	max_dfa_byte_program {512}
	Cap on a pattern's expanded byte program before subset construction runs on it.
constexpr std::uint32_t	dfa_no_rule {std::numeric_limits<std::uint32_t>::max()}
	dfa_tables::accept's "this state does not accept" marker.
constexpr std::size_t	ac_memory_budget_default {std::size_t {32} << 20U}
constexpr std::size_t	ac_max_branch_expansion = 64
	Maximum class sequences one branch may expand into (one per combination of the classes its positions span); past this the WHOLE pattern takes the ordinary pattern_hints::fixed_alternation route. A case-folded letter is one class unless another branch tells its cases apart.
constexpr std::size_t	fixed_shape_walk_max_width {8}
	Widest unfiltered shape kept on the walk.
constexpr std::uint32_t	rare_disc_fail_abandon {32}
	Consecutive disc hits that fail back-verify before the density gate trips. Dense : filler (e.g. a:b:c:d…) makes memchr+verify lose to a selective http prefix.
constexpr std::uint32_t	literal_dense_min_cands {8}
	Stops the rarest-byte scan makes before its density is judged: fewer say nothing.
constexpr std::size_t	literal_dense_gap {64}
	Mean bytes between stops below which the rarest byte counts as common: under it, a stop costs more than the pair filter spends crossing that many bytes.
constexpr std::size_t	alternation_nibbles_min_branches {3}
	Fewest branches for which the fingerprint replaces the pairs. Two pairs are two compares a block, a fingerprint six table lookups: on x86 (SSSE3) two branches lose by the fingerprint and three break even; AArch64's lookups are cheap enough that two branches already gain.
constexpr std::size_t	alternation_sample_min {4096}
	Shorter rests are scanned by the first bytes, unsampled (at least the sample and its reach).
constexpr std::size_t	alternation_sample_bytes {512}
	Bytes sampled for the first bytes' density.
constexpr std::size_t	alternation_wide_min_branches {2}
	Fewest branches the wide route considers: branches that open on classes outgrow the small set with a few.
constexpr std::size_t	alternation_wide_max_branches {16}
	Most branches the fingerprint's plan holds.
constexpr std::size_t	alternation_wide_false_budget {256}
	Past this many false candidates times branches in a sample, the automaton scans cheaper than the fingerprint and its verifier.
constexpr std::size_t	alternation_dense_gap {32}
	Mean bytes between first-byte hits in the sample below which the pair filter takes over (both ISAs: where the first-byte scan and the pair filter crossed on 500 KB of log lines).
constexpr std::size_t	alternation_dense_gap_nibbles {128}
	The same threshold for a plan masking by the nibble fingerprint, whose cost per block is fixed: it crossed the first-byte loop at 256-512 bytes between false stops (arm64, x86-64 AVX2, 3 to 10 branches); at 128 its worst ratio was 0.77 of the loop's time.
constexpr bool	have_members_scan {false}
	Whether a consumer should ARM a filter on find_members (one ISA only, measured).
constexpr std::uint32_t	not_a_single_codepoint {0xFFFFFFFFU}
	Returned by single_codepoint_atom when the node is not one code point's bytes.
constexpr std::uint32_t	optional_literal_min_score {1800}
	The least inner_literal::score an inner run needs to be kept when an optional precedes or follows it.
constexpr std::size_t	inner_literal_max {16}
	The most bytes an inner literal keeps; past this a longer needle costs storage without shrinking the candidate set much.
constexpr const char *	unicode_binprop_unidata_version {"16.0.0"}
	The Unicode data version these tables were generated from.
constexpr code_range	binprop_ASCII_Hex_Digit_ranges []
	\p{ASCII_Hex_Digit} — 3 ranges, 22 code points.
constexpr code_range	binprop_Alphabetic_ranges []
	\p{Alphabetic} — 757 ranges, 142759 code points.
constexpr code_range	binprop_Bidi_Control_ranges []
	\p{Bidi_Control} — 4 ranges, 12 code points.
constexpr code_range	binprop_Case_Ignorable_ranges []
	\p{Case_Ignorable} — 452 ranges, 2749 code points.
constexpr code_range	binprop_Cased_ranges []
	\p{Cased} — 159 ranges, 4578 code points.
constexpr code_range	binprop_Changes_When_Casefolded_ranges []
	\p{Changes_When_Casefolded} — 626 ranges, 1533 code points.
constexpr code_range	binprop_Changes_When_Casemapped_ranges []
	\p{Changes_When_Casemapped} — 131 ranges, 2981 code points.
constexpr code_range	binprop_Changes_When_Lowercased_ranges []
	\p{Changes_When_Lowercased} — 614 ranges, 1460 code points.
constexpr code_range	binprop_Changes_When_Titlecased_ranges []
	\p{Changes_When_Titlecased} — 629 ranges, 1479 code points.
constexpr code_range	binprop_Changes_When_Uppercased_ranges []
	\p{Changes_When_Uppercased} — 630 ranges, 1552 code points.
constexpr code_range	binprop_Dash_ranges []
	\p{Dash} — 24 ranges, 31 code points.
constexpr code_range	binprop_Default_Ignorable_Code_Point_ranges []
	\p{Default_Ignorable_Code_Point} — 17 ranges, 4174 code points.
constexpr code_range	binprop_Deprecated_ranges []
	\p{Deprecated} — 8 ranges, 15 code points.
constexpr code_range	binprop_Diacritic_ranges []
	\p{Diacritic} — 214 ranges, 1178 code points.
constexpr code_range	binprop_Emoji_ranges []
	\p{Emoji} — 150 ranges, 1431 code points.
constexpr code_range	binprop_Emoji_Component_ranges []
	\p{Emoji_Component} — 10 ranges, 146 code points.
constexpr code_range	binprop_Emoji_Modifier_ranges []
	\p{Emoji_Modifier} — 1 ranges, 5 code points.
constexpr code_range	binprop_Emoji_Modifier_Base_ranges []
	\p{Emoji_Modifier_Base} — 40 ranges, 134 code points.
constexpr code_range	binprop_Emoji_Presentation_ranges []
	\p{Emoji_Presentation} — 80 ranges, 1212 code points.
constexpr code_range	binprop_Extended_Pictographic_ranges []
	\p{Extended_Pictographic} — 78 ranges, 3537 code points.
constexpr code_range	binprop_Extender_ranges []
	\p{Extender} — 41 ranges, 59 code points.
constexpr code_range	binprop_Grapheme_Base_ranges []
	\p{Grapheme_Base} — 894 ranges, 152730 code points.
constexpr code_range	binprop_Grapheme_Extend_ranges []
	\p{Grapheme_Extend} — 375 ranges, 2193 code points.
constexpr code_range	binprop_Grapheme_Link_ranges []
	\p{Grapheme_Link} — 58 ranges, 69 code points.
constexpr code_range	binprop_Hex_Digit_ranges []
	\p{Hex_Digit} — 6 ranges, 44 code points.
constexpr code_range	binprop_Hyphen_ranges []
	\p{Hyphen} — 10 ranges, 11 code points.
constexpr code_range	binprop_IDS_Binary_Operator_ranges []
	\p{IDS_Binary_Operator} — 3 ranges, 13 code points.
constexpr code_range	binprop_IDS_Trinary_Operator_ranges []
	\p{IDS_Trinary_Operator} — 1 ranges, 2 code points.
constexpr code_range	binprop_IDS_Unary_Operator_ranges []
	\p{IDS_Unary_Operator} — 1 ranges, 2 code points.
constexpr code_range	binprop_ID_Compat_Math_Continue_ranges []
	\p{ID_Compat_Math_Continue} — 18 ranges, 43 code points.
constexpr code_range	binprop_ID_Compat_Math_Start_ranges []
	\p{ID_Compat_Math_Start} — 13 ranges, 13 code points.
constexpr code_range	binprop_ID_Continue_ranges []
	\p{ID_Continue} — 793 ranges, 144541 code points.
constexpr code_range	binprop_ID_Start_ranges []
	\p{ID_Start} — 677 ranges, 141269 code points.
constexpr code_range	binprop_Ideographic_ranges []
	\p{Ideographic} — 21 ranges, 106477 code points.
constexpr code_range	binprop_Join_Control_ranges []
	\p{Join_Control} — 1 ranges, 2 code points.
constexpr code_range	binprop_Logical_Order_Exception_ranges []
	\p{Logical_Order_Exception} — 7 ranges, 19 code points.
constexpr code_range	binprop_Lowercase_ranges []
	\p{Lowercase} — 675 ranges, 2569 code points.
constexpr code_range	binprop_Math_ranges []
	\p{Math} — 139 ranges, 2312 code points.
constexpr code_range	binprop_Modifier_Combining_Mark_ranges []
	\p{Modifier_Combining_Mark} — 9 ranges, 14 code points.
constexpr code_range	binprop_Noncharacter_Code_Point_ranges []
	\p{Noncharacter_Code_Point} — 18 ranges, 66 code points.
constexpr code_range	binprop_Other_Alphabetic_ranges []
	\p{Other_Alphabetic} — 250 ranges, 1495 code points.
constexpr code_range	binprop_Other_Default_Ignorable_Code_Point_ranges []
	\p{Other_Default_Ignorable_Code_Point} — 11 ranges, 3776 code points.
constexpr code_range	binprop_Other_Grapheme_Extend_ranges []
	\p{Other_Grapheme_Extend} — 49 ranges, 160 code points.
constexpr code_range	binprop_Other_ID_Continue_ranges []
	\p{Other_ID_Continue} — 7 ranges, 16 code points.
constexpr code_range	binprop_Other_ID_Start_ranges []
	\p{Other_ID_Start} — 4 ranges, 6 code points.
constexpr code_range	binprop_Other_Lowercase_ranges []
	\p{Other_Lowercase} — 28 ranges, 311 code points.
constexpr code_range	binprop_Other_Math_ranges []
	\p{Other_Math} — 134 ranges, 1362 code points.
constexpr code_range	binprop_Other_Uppercase_ranges []
	\p{Other_Uppercase} — 5 ranges, 120 code points.
constexpr code_range	binprop_Pattern_Syntax_ranges []
	\p{Pattern_Syntax} — 28 ranges, 2760 code points.
constexpr code_range	binprop_Pattern_White_Space_ranges []
	\p{Pattern_White_Space} — 5 ranges, 11 code points.
constexpr code_range	binprop_Prepended_Concatenation_Mark_ranges []
	\p{Prepended_Concatenation_Mark} — 7 ranges, 13 code points.
constexpr code_range	binprop_Quotation_Mark_ranges []
	\p{Quotation_Mark} — 13 ranges, 30 code points.
constexpr code_range	binprop_Radical_ranges []
	\p{Radical} — 3 ranges, 329 code points.
constexpr code_range	binprop_Regional_Indicator_ranges []
	\p{Regional_Indicator} — 1 ranges, 26 code points.
constexpr code_range	binprop_Sentence_Terminal_ranges []
	\p{Sentence_Terminal} — 88 ranges, 170 code points.
constexpr code_range	binprop_Soft_Dotted_ranges []
	\p{Soft_Dotted} — 34 ranges, 50 code points.
constexpr code_range	binprop_Terminal_Punctuation_ranges []
	\p{Terminal_Punctuation} — 116 ranges, 291 code points.
constexpr code_range	binprop_Unified_Ideograph_ranges []
	\p{Unified_Ideograph} — 17 ranges, 97680 code points.
constexpr code_range	binprop_Uppercase_ranges []
	\p{Uppercase} — 656 ranges, 1978 code points.
constexpr code_range	binprop_Variation_Selector_ranges []
	\p{Variation_Selector} — 4 ranges, 260 code points.
constexpr code_range	binprop_White_Space_ranges []
	\p{White_Space} — 10 ranges, 25 code points.
constexpr code_range	binprop_XID_Continue_ranges []
	\p{XID_Continue} — 800 ranges, 144522 code points.
constexpr code_range	binprop_XID_Start_ranges []
	\p{XID_Start} — 684 ranges, 141246 code points.
constexpr std::span< const code_range >	binprop_ranges []
	Range table indexed by binprop (parallel to the enum order).
constexpr binprop_alias_entry	binprop_aliases []
	Binary-property names, loose-keyed; for the \p{...} parser (no namespace prefix, same as PCRE2: \p{Alphabetic}, not \p{bp=Alphabetic}).
constexpr const char *	unicode_fold_unidata_version {"16.0.0"}
	The Unicode data version these orbits were generated from.
constexpr fold_entry	unicode_fold_table []
	Fold orbits, sorted by fold_entry::cp for binary search.
constexpr std::size_t	unicode_fold_table_size {2940}
	Number of entries in unicode_fold_table.
constexpr const char *	unicode_property_unidata_version {"16.0.0"}
	The Unicode data version these tables were generated from.
constexpr code_range	gc_Lu_ranges []
	\p{Lu} — 651 ranges, 1858 code points.
constexpr code_range	gc_Ll_ranges []
	\p{Ll} — 662 ranges, 2258 code points.
constexpr code_range	gc_Lt_ranges []
	\p{Lt} — 10 ranges, 31 code points.
constexpr code_range	gc_Lm_ranges []
	\p{Lm} — 75 ranges, 404 code points.
constexpr code_range	gc_Lo_ranges []
	\p{Lo} — 528 ranges, 136477 code points.
constexpr code_range	gc_Mn_ranges []
	\p{Mn} — 357 ranges, 2020 code points.
constexpr code_range	gc_Mc_ranges []
	\p{Mc} — 190 ranges, 468 code points.
constexpr code_range	gc_Me_ranges []
	\p{Me} — 5 ranges, 13 code points.
constexpr code_range	gc_Nd_ranges []
	\p{Nd} — 71 ranges, 760 code points.
constexpr code_range	gc_Nl_ranges []
	\p{Nl} — 12 ranges, 236 code points.
constexpr code_range	gc_No_ranges []
	\p{No} — 72 ranges, 915 code points.
constexpr code_range	gc_Pc_ranges []
	\p{Pc} — 6 ranges, 10 code points.
constexpr code_range	gc_Pd_ranges []
	\p{Pd} — 20 ranges, 27 code points.
constexpr code_range	gc_Ps_ranges []
	\p{Ps} — 79 ranges, 79 code points.
constexpr code_range	gc_Pe_ranges []
	\p{Pe} — 76 ranges, 77 code points.
constexpr code_range	gc_Pi_ranges []
	\p{Pi} — 11 ranges, 12 code points.
constexpr code_range	gc_Pf_ranges []
	\p{Pf} — 10 ranges, 10 code points.
constexpr code_range	gc_Po_ranges []
	\p{Po} — 193 ranges, 640 code points.
constexpr code_range	gc_Sm_ranges []
	\p{Sm} — 65 ranges, 950 code points.
constexpr code_range	gc_Sc_ranges []
	\p{Sc} — 21 ranges, 63 code points.
constexpr code_range	gc_Sk_ranges []
	\p{Sk} — 31 ranges, 125 code points.
constexpr code_range	gc_So_ranges []
	\p{So} — 187 ranges, 7376 code points.
constexpr code_range	gc_Zs_ranges []
	\p{Zs} — 7 ranges, 17 code points.
constexpr code_range	gc_Zl_ranges []
	\p{Zl} — 1 ranges, 1 code points.
constexpr code_range	gc_Zp_ranges []
	\p{Zp} — 1 ranges, 1 code points.
constexpr code_range	gc_Cc_ranges []
	\p{Cc} — 2 ranges, 65 code points.
constexpr code_range	gc_Cf_ranges []
	\p{Cf} — 21 ranges, 170 code points.
constexpr code_range	gc_Co_ranges []
	\p{Co} — 3 ranges, 137468 code points.
constexpr code_range	gc_Cn_ranges []
	\p{Cn} — 731 ranges, 819533 code points.
constexpr code_range	gc_L_ranges []
	\p{L} — 677 ranges, 141028 code points.
constexpr code_range	gc_M_ranges []
	\p{M} — 321 ranges, 2501 code points.
constexpr code_range	gc_N_ranges []
	\p{N} — 144 ranges, 1911 code points.
constexpr code_range	gc_P_ranges []
	\p{P} — 198 ranges, 855 code points.
constexpr code_range	gc_S_ranges []
	\p{S} — 236 ranges, 8514 code points.
constexpr code_range	gc_Z_ranges []
	\p{Z} — 8 ranges, 19 code points.
constexpr code_range	gc_C_ranges []
	\p{C} — 737 ranges, 957236 code points.
constexpr std::span< const code_range >	gc_property_ranges []
	Range table indexed by gc_property (parallel to the enum order).
constexpr gc_alias_entry	gc_aliases []
	Short codes (Lu) and long names (Uppercase_Letter), loose-keyed; for the \p{...} parser.
constexpr const char *	unicode_props_unidata_version {"16.0.0"}
	The Unicode data version these tables were generated from.
constexpr code_range	word_ranges []
	Code-point ranges matched by \w (771 ranges, 142940 code points).
constexpr std::size_t	word_ranges_size {771}
	Number of ranges in word_ranges.
constexpr code_range	digit_ranges []
	Code-point ranges matched by \d (71 ranges, 760 code points).
constexpr std::size_t	digit_ranges_size {71}
	Number of ranges in digit_ranges.
constexpr code_range	space_ranges []
	Code-point ranges matched by \s (10 ranges, 29 code points).
constexpr std::size_t	space_ranges_size {10}
	Number of ranges in space_ranges.
constexpr const char *	unicode_script_unidata_version {"16.0.0"}
	The Unicode data version these tables were generated from.
constexpr script_range	script_ranges []
	Script partition — 979 ranges, sorted and disjoint.
constexpr script_alias_entry	script_aliases []
	Script names, loose-keyed; for the \p{sc=...} / \p{scx=...} parsers. Both the long name (Latin) and the short UAX24/ISO 15924 code (Latn) resolve to the same value – \p{scx=...} states its overrides in short codes only, and since this table is shared, \p{sc=...} gains the short form too.
constexpr const char *	unicode_scx_unidata_version {"16.0.0"}
	The Unicode data version these tables were generated from.
constexpr code_range	scx_Adlam_ranges []
	\p{scx=Adlam} — 7 ranges, 92 code points.
constexpr code_range	scx_Ahom_ranges []
	\p{scx=Ahom} — 3 ranges, 65 code points.
constexpr code_range	scx_Anatolian_Hieroglyphs_ranges []
	\p{scx=Anatolian_Hieroglyphs} — 1 ranges, 583 code points.
constexpr code_range	scx_Arabic_ranges []
	\p{scx=Arabic} — 55 ranges, 1421 code points.
constexpr code_range	scx_Armenian_ranges []
	\p{scx=Armenian} — 5 ranges, 97 code points.
constexpr code_range	scx_Avestan_ranges []
	\p{scx=Avestan} — 4 ranges, 64 code points.
constexpr code_range	scx_Balinese_ranges []
	\p{scx=Balinese} — 2 ranges, 127 code points.
constexpr code_range	scx_Bamum_ranges []
	\p{scx=Bamum} — 2 ranges, 657 code points.
constexpr code_range	scx_Bassa_Vah_ranges []
	\p{scx=Bassa_Vah} — 2 ranges, 36 code points.
constexpr code_range	scx_Batak_ranges []
	\p{scx=Batak} — 2 ranges, 56 code points.
constexpr code_range	scx_Bengali_ranges []
	\p{scx=Bengali} — 27 ranges, 114 code points.
constexpr code_range	scx_Bhaiksuki_ranges []
	\p{scx=Bhaiksuki} — 4 ranges, 97 code points.
constexpr code_range	scx_Bopomofo_ranges []
	\p{scx=Bopomofo} — 15 ranges, 122 code points.
constexpr code_range	scx_Brahmi_ranges []
	\p{scx=Brahmi} — 3 ranges, 115 code points.
constexpr code_range	scx_Braille_ranges []
	\p{scx=Braille} — 1 ranges, 256 code points.
constexpr code_range	scx_Buginese_ranges []
	\p{scx=Buginese} — 3 ranges, 31 code points.
constexpr code_range	scx_Buhid_ranges []
	\p{scx=Buhid} — 2 ranges, 22 code points.
constexpr code_range	scx_Canadian_Aboriginal_ranges []
	\p{scx=Canadian_Aboriginal} — 3 ranges, 726 code points.
constexpr code_range	scx_Carian_ranges []
	\p{scx=Carian} — 5 ranges, 53 code points.
constexpr code_range	scx_Caucasian_Albanian_ranges []
	\p{scx=Caucasian_Albanian} — 5 ranges, 56 code points.
constexpr code_range	scx_Chakma_ranges []
	\p{scx=Chakma} — 4 ranges, 91 code points.
constexpr code_range	scx_Cham_ranges []
	\p{scx=Cham} — 4 ranges, 83 code points.
constexpr code_range	scx_Cherokee_ranges []
	\p{scx=Cherokee} — 8 ranges, 182 code points.
constexpr code_range	scx_Chorasmian_ranges []
	\p{scx=Chorasmian} — 1 ranges, 28 code points.
constexpr code_range	scx_Common_ranges []
	\p{scx=Common} — 159 ranges, 8585 code points.
constexpr code_range	scx_Coptic_ranges []
	\p{scx=Coptic} — 10 ranges, 173 code points.
constexpr code_range	scx_Cuneiform_ranges []
	\p{scx=Cuneiform} — 4 ranges, 1234 code points.
constexpr code_range	scx_Cypriot_ranges []
	\p{scx=Cypriot} — 9 ranges, 112 code points.
constexpr code_range	scx_Cypro_Minoan_ranges []
	\p{scx=Cypro_Minoan} — 2 ranges, 101 code points.
constexpr code_range	scx_Cyrillic_ranges []
	\p{scx=Cyrillic} — 18 ranges, 521 code points.
constexpr code_range	scx_Deseret_ranges []
	\p{scx=Deseret} — 1 ranges, 80 code points.
constexpr code_range	scx_Devanagari_ranges []
	\p{scx=Devanagari} — 9 ranges, 221 code points.
constexpr code_range	scx_Dives_Akuru_ranges []
	\p{scx=Dives_Akuru} — 8 ranges, 72 code points.
constexpr code_range	scx_Dogra_ranges []
	\p{scx=Dogra} — 3 ranges, 82 code points.
constexpr code_range	scx_Duployan_ranges []
	\p{scx=Duployan} — 10 ranges, 154 code points.
constexpr code_range	scx_Egyptian_Hieroglyphs_ranges []
	\p{scx=Egyptian_Hieroglyphs} — 2 ranges, 5105 code points.
constexpr code_range	scx_Elbasan_ranges []
	\p{scx=Elbasan} — 3 ranges, 42 code points.
constexpr code_range	scx_Elymaic_ranges []
	\p{scx=Elymaic} — 1 ranges, 23 code points.
constexpr code_range	scx_Ethiopic_ranges []
	\p{scx=Ethiopic} — 37 ranges, 524 code points.
constexpr code_range	scx_Garay_ranges []
	\p{scx=Garay} — 6 ranges, 72 code points.
constexpr code_range	scx_Georgian_ranges []
	\p{scx=Georgian} — 13 ranges, 178 code points.
constexpr code_range	scx_Glagolitic_ranges []
	\p{scx=Glagolitic} — 16 ranges, 144 code points.
constexpr code_range	scx_Gothic_ranges []
	\p{scx=Gothic} — 5 ranges, 32 code points.
constexpr code_range	scx_Grantha_ranges []
	\p{scx=Grantha} — 25 ranges, 116 code points.
constexpr code_range	scx_Greek_ranges []
	\p{scx=Greek} — 44 ranges, 531 code points.
constexpr code_range	scx_Gujarati_ranges []
	\p{scx=Gujarati} — 17 ranges, 105 code points.
constexpr code_range	scx_Gunjala_Gondi_ranges []
	\p{scx=Gunjala_Gondi} — 8 ranges, 66 code points.
constexpr code_range	scx_Gurmukhi_ranges []
	\p{scx=Gurmukhi} — 19 ranges, 94 code points.
constexpr code_range	scx_Gurung_Khema_ranges []
	\p{scx=Gurung_Khema} — 2 ranges, 59 code points.
constexpr code_range	scx_Han_ranges []
	\p{scx=Han} — 42 ranges, 99338 code points.
constexpr code_range	scx_Hangul_ranges []
	\p{scx=Hangul} — 21 ranges, 11775 code points.
constexpr code_range	scx_Hanifi_Rohingya_ranges []
	\p{scx=Hanifi_Rohingya} — 7 ranges, 55 code points.
constexpr code_range	scx_Hanunoo_ranges []
	\p{scx=Hanunoo} — 1 ranges, 23 code points.
constexpr code_range	scx_Hatran_ranges []
	\p{scx=Hatran} — 3 ranges, 26 code points.
constexpr code_range	scx_Hebrew_ranges []
	\p{scx=Hebrew} — 10 ranges, 136 code points.
constexpr code_range	scx_Hiragana_ranges []
	\p{scx=Hiragana} — 17 ranges, 433 code points.
constexpr code_range	scx_Imperial_Aramaic_ranges []
	\p{scx=Imperial_Aramaic} — 2 ranges, 31 code points.
constexpr code_range	scx_Inherited_ranges []
	\p{scx=Inherited} — 28 ranges, 558 code points.
constexpr code_range	scx_Inscriptional_Pahlavi_ranges []
	\p{scx=Inscriptional_Pahlavi} — 2 ranges, 27 code points.
constexpr code_range	scx_Inscriptional_Parthian_ranges []
	\p{scx=Inscriptional_Parthian} — 2 ranges, 30 code points.
constexpr code_range	scx_Javanese_ranges []
	\p{scx=Javanese} — 3 ranges, 91 code points.
constexpr code_range	scx_Kaithi_ranges []
	\p{scx=Kaithi} — 5 ranges, 89 code points.
constexpr code_range	scx_Kannada_ranges []
	\p{scx=Kannada} — 21 ranges, 107 code points.
constexpr code_range	scx_Katakana_ranges []
	\p{scx=Katakana} — 22 ranges, 375 code points.
constexpr code_range	scx_Kawi_ranges []
	\p{scx=Kawi} — 3 ranges, 87 code points.
constexpr code_range	scx_Kayah_Li_ranges []
	\p{scx=Kayah_Li} — 1 ranges, 48 code points.
constexpr code_range	scx_Kharoshthi_ranges []
	\p{scx=Kharoshthi} — 8 ranges, 68 code points.
constexpr code_range	scx_Khitan_Small_Script_ranges []
	\p{scx=Khitan_Small_Script} — 3 ranges, 472 code points.
constexpr code_range	scx_Khmer_ranges []
	\p{scx=Khmer} — 4 ranges, 146 code points.
constexpr code_range	scx_Khojki_ranges []
	\p{scx=Khojki} — 4 ranges, 85 code points.
constexpr code_range	scx_Khudawadi_ranges []
	\p{scx=Khudawadi} — 4 ranges, 81 code points.
constexpr code_range	scx_Kirat_Rai_ranges []
	\p{scx=Kirat_Rai} — 1 ranges, 58 code points.
constexpr code_range	scx_Lao_ranges []
	\p{scx=Lao} — 11 ranges, 83 code points.
constexpr code_range	scx_Latin_ranges []
	\p{scx=Latin} — 65 ranges, 1555 code points.
constexpr code_range	scx_Lepcha_ranges []
	\p{scx=Lepcha} — 3 ranges, 74 code points.
constexpr code_range	scx_Limbu_ranges []
	\p{scx=Limbu} — 6 ranges, 69 code points.
constexpr code_range	scx_Linear_A_ranges []
	\p{scx=Linear_A} — 4 ranges, 386 code points.
constexpr code_range	scx_Linear_B_ranges []
	\p{scx=Linear_B} — 10 ranges, 268 code points.
constexpr code_range	scx_Lisu_ranges []
	\p{scx=Lisu} — 5 ranges, 53 code points.
constexpr code_range	scx_Lycian_ranges []
	\p{scx=Lycian} — 2 ranges, 30 code points.
constexpr code_range	scx_Lydian_ranges []
	\p{scx=Lydian} — 4 ranges, 29 code points.
constexpr code_range	scx_Mahajani_ranges []
	\p{scx=Mahajani} — 4 ranges, 62 code points.
constexpr code_range	scx_Makasar_ranges []
	\p{scx=Makasar} — 1 ranges, 25 code points.
constexpr code_range	scx_Malayalam_ranges []
	\p{scx=Malayalam} — 12 ranges, 127 code points.
constexpr code_range	scx_Mandaic_ranges []
	\p{scx=Mandaic} — 3 ranges, 30 code points.
constexpr code_range	scx_Manichaean_ranges []
	\p{scx=Manichaean} — 3 ranges, 52 code points.
constexpr code_range	scx_Marchen_ranges []
	\p{scx=Marchen} — 3 ranges, 68 code points.
constexpr code_range	scx_Masaram_Gondi_ranges []
	\p{scx=Masaram_Gondi} — 8 ranges, 77 code points.
constexpr code_range	scx_Medefaidrin_ranges []
	\p{scx=Medefaidrin} — 1 ranges, 91 code points.
constexpr code_range	scx_Meetei_Mayek_ranges []
	\p{scx=Meetei_Mayek} — 3 ranges, 79 code points.
constexpr code_range	scx_Mende_Kikakui_ranges []
	\p{scx=Mende_Kikakui} — 2 ranges, 213 code points.
constexpr code_range	scx_Meroitic_Cursive_ranges []
	\p{scx=Meroitic_Cursive} — 3 ranges, 90 code points.
constexpr code_range	scx_Meroitic_Hieroglyphs_ranges []
	\p{scx=Meroitic_Hieroglyphs} — 2 ranges, 33 code points.
constexpr code_range	scx_Miao_ranges []
	\p{scx=Miao} — 3 ranges, 149 code points.
constexpr code_range	scx_Modi_ranges []
	\p{scx=Modi} — 3 ranges, 89 code points.
constexpr code_range	scx_Mongolian_ranges []
	\p{scx=Mongolian} — 7 ranges, 178 code points.
constexpr code_range	scx_Mro_ranges []
	\p{scx=Mro} — 3 ranges, 43 code points.
constexpr code_range	scx_Multani_ranges []
	\p{scx=Multani} — 6 ranges, 48 code points.
constexpr code_range	scx_Myanmar_ranges []
	\p{scx=Myanmar} — 5 ranges, 244 code points.
constexpr code_range	scx_Nabataean_ranges []
	\p{scx=Nabataean} — 2 ranges, 40 code points.
constexpr code_range	scx_Nag_Mundari_ranges []
	\p{scx=Nag_Mundari} — 1 ranges, 42 code points.
constexpr code_range	scx_Nandinagari_ranges []
	\p{scx=Nandinagari} — 9 ranges, 86 code points.
constexpr code_range	scx_New_Tai_Lue_ranges []
	\p{scx=New_Tai_Lue} — 4 ranges, 83 code points.
constexpr code_range	scx_Newa_ranges []
	\p{scx=Newa} — 2 ranges, 97 code points.
constexpr code_range	scx_Nko_ranges []
	\p{scx=Nko} — 6 ranges, 67 code points.
constexpr code_range	scx_Nushu_ranges []
	\p{scx=Nushu} — 2 ranges, 397 code points.
constexpr code_range	scx_Nyiakeng_Puachue_Hmong_ranges []
	\p{scx=Nyiakeng_Puachue_Hmong} — 4 ranges, 71 code points.
constexpr code_range	scx_Ogham_ranges []
	\p{scx=Ogham} — 1 ranges, 29 code points.
constexpr code_range	scx_Ol_Chiki_ranges []
	\p{scx=Ol_Chiki} — 1 ranges, 48 code points.
constexpr code_range	scx_Ol_Onal_ranges []
	\p{scx=Ol_Onal} — 3 ranges, 46 code points.
constexpr code_range	scx_Old_Hungarian_ranges []
	\p{scx=Old_Hungarian} — 7 ranges, 112 code points.
constexpr code_range	scx_Old_Italic_ranges []
	\p{scx=Old_Italic} — 2 ranges, 39 code points.
constexpr code_range	scx_Old_North_Arabian_ranges []
	\p{scx=Old_North_Arabian} — 1 ranges, 32 code points.
constexpr code_range	scx_Old_Permic_ranges []
	\p{scx=Old_Permic} — 6 ranges, 50 code points.
constexpr code_range	scx_Old_Persian_ranges []
	\p{scx=Old_Persian} — 2 ranges, 50 code points.
constexpr code_range	scx_Old_Sogdian_ranges []
	\p{scx=Old_Sogdian} — 1 ranges, 40 code points.
constexpr code_range	scx_Old_South_Arabian_ranges []
	\p{scx=Old_South_Arabian} — 1 ranges, 32 code points.
constexpr code_range	scx_Old_Turkic_ranges []
	\p{scx=Old_Turkic} — 3 ranges, 75 code points.
constexpr code_range	scx_Old_Uyghur_ranges []
	\p{scx=Old_Uyghur} — 3 ranges, 28 code points.
constexpr code_range	scx_Oriya_ranges []
	\p{scx=Oriya} — 18 ranges, 97 code points.
constexpr code_range	scx_Osage_ranges []
	\p{scx=Osage} — 6 ranges, 76 code points.
constexpr code_range	scx_Osmanya_ranges []
	\p{scx=Osmanya} — 2 ranges, 40 code points.
constexpr code_range	scx_Pahawh_Hmong_ranges []
	\p{scx=Pahawh_Hmong} — 5 ranges, 127 code points.
constexpr code_range	scx_Palmyrene_ranges []
	\p{scx=Palmyrene} — 1 ranges, 32 code points.
constexpr code_range	scx_Pau_Cin_Hau_ranges []
	\p{scx=Pau_Cin_Hau} — 1 ranges, 57 code points.
constexpr code_range	scx_Phags_Pa_ranges []
	\p{scx=Phags_Pa} — 5 ranges, 61 code points.
constexpr code_range	scx_Phoenician_ranges []
	\p{scx=Phoenician} — 2 ranges, 29 code points.
constexpr code_range	scx_Psalter_Pahlavi_ranges []
	\p{scx=Psalter_Pahlavi} — 4 ranges, 30 code points.
constexpr code_range	scx_Rejang_ranges []
	\p{scx=Rejang} — 2 ranges, 37 code points.
constexpr code_range	scx_Runic_ranges []
	\p{scx=Runic} — 1 ranges, 89 code points.
constexpr code_range	scx_Samaritan_ranges []
	\p{scx=Samaritan} — 3 ranges, 62 code points.
constexpr code_range	scx_Saurashtra_ranges []
	\p{scx=Saurashtra} — 2 ranges, 82 code points.
constexpr code_range	scx_Sharada_ranges []
	\p{scx=Sharada} — 8 ranges, 109 code points.
constexpr code_range	scx_Shavian_ranges []
	\p{scx=Shavian} — 2 ranges, 49 code points.
constexpr code_range	scx_Siddham_ranges []
	\p{scx=Siddham} — 2 ranges, 92 code points.
constexpr code_range	scx_SignWriting_ranges []
	\p{scx=SignWriting} — 3 ranges, 672 code points.
constexpr code_range	scx_Sinhala_ranges []
	\p{scx=Sinhala} — 15 ranges, 114 code points.
constexpr code_range	scx_Sogdian_ranges []
	\p{scx=Sogdian} — 2 ranges, 43 code points.
constexpr code_range	scx_Sora_Sompeng_ranges []
	\p{scx=Sora_Sompeng} — 2 ranges, 35 code points.
constexpr code_range	scx_Soyombo_ranges []
	\p{scx=Soyombo} — 1 ranges, 83 code points.
constexpr code_range	scx_Sundanese_ranges []
	\p{scx=Sundanese} — 2 ranges, 72 code points.
constexpr code_range	scx_Sunuwar_ranges []
	\p{scx=Sunuwar} — 8 ranges, 51 code points.
constexpr code_range	scx_Syloti_Nagri_ranges []
	\p{scx=Syloti_Nagri} — 3 ranges, 57 code points.
constexpr code_range	scx_Syriac_ranges []
	\p{scx=Syriac} — 19 ranges, 119 code points.
constexpr code_range	scx_Tagalog_ranges []
	\p{scx=Tagalog} — 3 ranges, 25 code points.
constexpr code_range	scx_Tagbanwa_ranges []
	\p{scx=Tagbanwa} — 4 ranges, 20 code points.
constexpr code_range	scx_Tai_Le_ranges []
	\p{scx=Tai_Le} — 6 ranges, 50 code points.
constexpr code_range	scx_Tai_Tham_ranges []
	\p{scx=Tai_Tham} — 5 ranges, 127 code points.
constexpr code_range	scx_Tai_Viet_ranges []
	\p{scx=Tai_Viet} — 2 ranges, 72 code points.
constexpr code_range	scx_Takri_ranges []
	\p{scx=Takri} — 4 ranges, 80 code points.
constexpr code_range	scx_Tamil_ranges []
	\p{scx=Tamil} — 25 ranges, 133 code points.
constexpr code_range	scx_Tangsa_ranges []
	\p{scx=Tangsa} — 2 ranges, 89 code points.
constexpr code_range	scx_Tangut_ranges []
	\p{scx=Tangut} — 6 ranges, 6931 code points.
constexpr code_range	scx_Telugu_ranges []
	\p{scx=Telugu} — 17 ranges, 106 code points.
constexpr code_range	scx_Thaana_ranges []
	\p{scx=Thaana} — 7 ranges, 66 code points.
constexpr code_range	scx_Thai_ranges []
	\p{scx=Thai} — 6 ranges, 90 code points.
constexpr code_range	scx_Tibetan_ranges []
	\p{scx=Tibetan} — 8 ranges, 211 code points.
constexpr code_range	scx_Tifinagh_ranges []
	\p{scx=Tifinagh} — 7 ranges, 63 code points.
constexpr code_range	scx_Tirhuta_ranges []
	\p{scx=Tirhuta} — 6 ranges, 97 code points.
constexpr code_range	scx_Todhri_ranges []
	\p{scx=Todhri} — 7 ranges, 58 code points.
constexpr code_range	scx_Toto_ranges []
	\p{scx=Toto} — 2 ranges, 32 code points.
constexpr code_range	scx_Tulu_Tigalari_ranges []
	\p{scx=Tulu_Tigalari} — 16 ranges, 99 code points.
constexpr code_range	scx_Ugaritic_ranges []
	\p{scx=Ugaritic} — 2 ranges, 31 code points.
constexpr code_range	scx_Vai_ranges []
	\p{scx=Vai} — 1 ranges, 300 code points.
constexpr code_range	scx_Vithkuqi_ranges []
	\p{scx=Vithkuqi} — 8 ranges, 70 code points.
constexpr code_range	scx_Wancho_ranges []
	\p{scx=Wancho} — 2 ranges, 59 code points.
constexpr code_range	scx_Warang_Citi_ranges []
	\p{scx=Warang_Citi} — 2 ranges, 84 code points.
constexpr code_range	scx_Yezidi_ranges []
	\p{scx=Yezidi} — 7 ranges, 60 code points.
constexpr code_range	scx_Yi_ranges []
	\p{scx=Yi} — 7 ranges, 1246 code points.
constexpr code_range	scx_Zanabazar_Square_ranges []
	\p{scx=Zanabazar_Square} — 1 ranges, 72 code points.
constexpr std::span< const code_range >	scx_ranges []
	Range table indexed by script (parallel to the enum order, Unknown empty – no code point's scx is ever explicitly Unknown, see the generator).

Detailed Description

DFA construction internals: subset construction over a flattened NFA. Not a stable API.

Storage-policy internals shared by real::regex and real::static_regex.

REAL's internal implementation. Not a stable API: anything here may change between releases.

Enumeration Type Documentation

ac_verdict

enum class real::detail::ac_verdict : std::uint8_t

strong

What the AC density gate last decided; ac_density_last_verdict() below reports it.

Enumerator
not_consulted	The gate has not run since the last reset.
cascade	Candidates too sparse: keep the memchr cascade.
automaton	Candidates dense enough: take the Aho-Corasick walk.

anchor_kind

enum class real::detail::anchor_kind : std::uint8_t

strong

The specific zero-width assertion of an anchor node (see node_kind::anchor).

Enumerator
caret	^ (text or line start, depending on multiline).
dollar	$ (end, before a trailing \n, or line end with m).
text_start	\A.
text_end	\Z.
word_boundary	\b.
not_word_boundary	\B.
word_start	\< (start of word; REAL extension, not in Python re).
word_end	\> (end of word; REAL extension, not in Python re).

assert_kind

enum class real::detail::assert_kind : std::uint8_t

strongprivate

Kind of zero-width assertion carried in assert_position's arg8. Multiline and trailing-newline variants are resolved at compile time.

Enumerator
text_start	\A, and ^ without multiline.
text_end	\Z.
text_end_or_final_newline	$ without multiline (Python semantics).
line_start	^ with multiline.
line_end	$ with multiline.
word_boundary	\b (Unicode word-ness in text mode; ASCII in bytes / re.A).
not_word_boundary	\B.
word_start	\< (non-word/start on the left, word on the right).
word_end	\> (word on the left, non-word/end on the right).
line_start_cr	^ with multiline under ecma: the text start, or after \n or \r.
line_end_cr	$ with multiline under ecma: the text end, or before \n or \r.

counter

enum class real::detail::counter : std::uint8_t

strong

Test counters, one per mechanism, for the tests that pin when it runs. Billed through note() only under REAL_TEST_INSTRUMENT (free in production); process-wide relaxed atomics.

Enumerator
prefilter_work_units	Bytes the prefilters scanned: the O(n) against O(n²) gates.
vm_window_runs	Pike VM runs over a window the DFAs found.
batch_fills	Calls a batched walk made to its filler.
inner_literal_bill_trips	Times the inner-literal route gave way on its bill.
inner_literal_reverse_bytes	Bytes the inner-literal route's reverse automaton read.
inner_literal_confirm_bytes	Bytes the inner-literal route's rejected forward confirms read.
byte_program_builds	Byte programs built (each expands every Unicode class's UTF-8 trie).
il_prefix_run_walks	Two-run group fills that walked the prefix run on past the literal.
batch_handouts	Buffered spans a batched walk handed out one at a time, slots written.
vm_reseeds	Positions past its start where a search-mode VM run seeded a thread.
onepass_anchored_walks	Anchored matches whose end and groups the one-pass table found.
bounded_backtrack_runs	Windows the bounded backtracker filled rather than the VM.
dfa_quits	Searches or confirms the lazy DFAs handed to the VM because a scan quit.
literal_pair_scans	Literal searches the two-byte block filter answered.
alternation_avx2_blocks	Alternation blocks the fingerprint masked 32 starts at a time (AVX2).
literal_avx2_scans	Literal filter searches that ran on 32-byte AVX2 blocks.
fixed_shape_batches	Batches the fixed-shape filler produced.
literal_rest_scans	Literal searches whose first stop failed and that went on out of line.
alternation_pair_blocks	Alternation blocks the pair filter masked.
alternation_nibble_blocks	Alternation blocks the nibble fingerprint masked, among the pair blocks.
ac_completion_walks	Branch walks the Aho-Corasick gate's completion sample spent.
alternation_variant_scans	Searches that took a program's variant fingerprint.
alternation_wide_scans	Subjects an alternation wider than the small set scanned by the fingerprint.
alternation_pair_candidates	Candidates the alternation pair filter left to verify.
ahead_table_rows	Rows the unbounded-lookahead tables were filled with.
behind_walk_steps	Bytes the lookbehind walks stepped.
behind_atom_steps	Continuation bytes a one-atom lookbehind receded over.
dfa_span_batches	Batches the lazy-DFA span filler produced.
dfa_leases_taken	DFA set leases taken.
class_folds	Case folds the compiler computed for a class (a fold-cache hit costs none).
count_	The number of counters.

digit_escape_kind

enum class real::detail::digit_escape_kind : std::uint8_t

strong

What a \<digit> escape decoded to (see decode_digit_escape()).

Enumerator
octal	An octal byte escape; value is the byte (0-255).
group_ref	A decimal group number; value is the group (a back-reference in a pattern).
octal_overflow	A 3-octal-digit escape greater than 0o377 (an error in CPython).

look_dir

enum class real::detail::look_dir : std::uint8_t

strongprivate

Direction of a lookaround sub-pattern.

Enumerator
ahead	(?= / (?! — the sub matches starting at the position.
behind	(?<= / (?<! — the sub matches ending exactly at the position.

node_kind

enum class real::detail::node_kind : std::uint8_t

strong

Kind of an AST node; selects which fields of real::detail::ast_node are meaningful.

Enumerator
empty	Matches the empty string.
byte	One exact byte.
klass	One codepoint constrained by classes[klass] (a class_def; negated or not).
any	One codepoint, except newline (the . metacharacter).
concat	Children matched in sequence.
repeat	Child repeated [min, max] times (max -1 = unbounded).
alternation	Children are branches, leftmost preferred.
group	Child wrapped in a group; group >= 0 when capturing.
anchor	Zero-width assertion; kind in real::detail::ast_node::anchor.
lookaround	Bounded lookaround: child = sub-pattern, negated = (?!/(?<!), direction = ahead/behind.

opcode

enum class real::detail::opcode : std::uint8_t

strongprivate

NFA instruction opcodes executed by the Pike VM.

Enumerator
byte	Consume one byte equal to arg8; fall through to pc+1.
klass	Consume one byte in classes[arg16]; fall through to pc+1.
klass_cp	Consume one code point tested against cp_classes[arg16] (decode + range bsearch); enters a 3-instr continuation chain via a computed skip. See pike.hpp.
split	Epsilon-branch to x (preferred) and y.
jump	Epsilon-jump to x.
save	Store current position in slot arg16; fall through (epsilon).
assert_position	Epsilon; proceeds only if assertion arg8 holds here.
match	Accept.
assert_lookaround	Epsilon; proceeds only if the lookaround sub-program arg16 holds here.
byte_loop_possessive	Consume one byte == arg8. See the note above.
klass_loop_possessive	Consume one byte in classes[arg16]. See the note above.
klass_cp_loop_possessive	Consume one code point in cp_classes[arg16], followed by the same 3-slot continuation chain as klass_cp. See the note above.

run_mode

enum class real::detail::run_mode : std::uint8_t

strong

How a VM run is anchored.

Enumerator
prefix	Anchored at the start position (Python re.match).
full	Anchored at both ends (Python re.fullmatch).
search	First match anywhere (Python re.search).

Function Documentation

ac_dense_disabled()

bool & real::detail::ac_dense_disabled ( )

inline

Test seam: search the sparse trie even where the dense table fits.

Returns

A reference to the process-wide flag.

ac_density_gate_disabled()

bool & real::detail::ac_density_gate_disabled ( )

inline

Test seam: take the Aho-Corasick density gate out, so the route is chosen on branch count alone.

aho_corasick_route_disabled() = false only declines to forbid the automaton; the gate still decides. A harness forcing the automaton needs this seam too.

Returns

Reference to the process-wide seam flag; set it to true to route on branch count alone.

ac_density_last_verdict()

std::atomic< ac_verdict > & real::detail::ac_density_last_verdict ( )

inline

Test observability: the AC density gate's most recent verdict.

Both routes give identical spans, so a test asserts this decision, never a speed-up: the margin shrinks under ASan/UBSan (sanitizer cost is per operation, diluting a byte-skipping route). Timing belongs in benchmarks/ac_regime.cpp. Atomic and relaxed as il_density_last_abandoned.

Returns

Reference to the process-wide verdict; assign ac_verdict::not_consulted to arm it.

ac_memory_budget()

std::size_t & real::detail::ac_memory_budget ( )

inline

Bytes an automaton may hold (the layout rule is in the file header); ac_memory_budget_default unless a test shrinks it to reach the sparse form and the decline.

Returns

A reference to the process-wide budget.

ac_sparse_row_cap()

std::size_t & real::detail::ac_sparse_row_cap ( )

inline

Test seam: at most this many dense rows in the sparse form below what the budget allows. The root keeps its row whatever the cap: a miss there has no fail link to fall along.

Returns

A reference to the process-wide cap; unbounded by default (the budget decides).

aho_corasick_route_disabled()

bool & real::detail::aho_corasick_route_disabled ( )

inline

Test seam: force the matcher off the Aho-Corasick multi-literal route onto the pattern_hints::fixed_alternation run_alternation path.

Returns

Reference to the process-wide seam flag; set it to true to take the route out.

alternation_avx2_disabled()

bool & real::detail::alternation_avx2_disabled ( )

inline

Test seam: keep the alternation fingerprint on 16-byte blocks where the CPU has AVX2, so a differential can compare both widths in one binary. Not for production use.

Returns

Reference to the process-wide seam flag.

alternation_nibbles_disabled()

bool & real::detail::alternation_nibbles_disabled ( )

inline

Test seam: mask a dense alternation's blocks by its byte pairs rather than by the nibble fingerprint, so a differential can compare both filters.

Returns

Reference to the process-wide seam flag; set it to true to take the fingerprint out.

alternation_nibbles_supported()

bool real::detail::alternation_nibbles_supported ( )

inline

Whether the nibble fingerprint can run here: AArch64 always, x86 when the build enables SSSE3 or, with gcc or clang, when the running CPU has it. A plan built elsewhere never claims one: the fingerprint's reach is shorter than the pairs', and a scan that bounded its blocks by it while masking by the pairs would read past the subject.

Returns

True when a plan may carry the fingerprint.

alternation_pairs_disabled()

bool & real::detail::alternation_pairs_disabled ( )

inline

Test seam: keep an alternation's block scans on its first bytes whatever the subject's density, so a differential can compare the pair filter with the first-byte scan.

Returns

Reference to the process-wide seam flag; set it to true to take the pair filter out.

alternation_trie_disabled()

bool & real::detail::alternation_trie_disabled ( )

inline

Test seam: build the byte program's literal alternations flat, so a differential can compare the trie against them.

Returns

A reference to the process-wide flag.

analyze_program()

constexpr pattern_hints real::detail::analyze_program ( std::span< const instr >  code, std::span< const char_class >  classes, std::span< const cp_class >  cp_classes, std::span< const code_range >  cp_ranges, std::int32_t  cp_mark_ascii, std::int32_t  cp_mark_offset, std::int32_t  cp_mark_end, std::span< const lookaround_sub >  lookarounds = {}  )

constexpr

Walks a compiled program once to derive its search hints.

Parameters

[in]	code	The instruction stream.
[in]	classes	The interned character classes referenced by code.
[in]	cp_classes	The match-time code-point classes referenced by klass_cp.
[in]	cp_ranges	Flat range buffer the cp_classes slices index into.
[in]	cp_mark_ascii	ASCII sub-class index of an emitted codepoint-class block (-1 = none).
[in]	cp_mark_offset	Program offset where that block starts (-1 = none).
[in]	cp_mark_end	Program offset right after that block (-1 = none); its length varies.
[in]	lookarounds	Bounded lookaround subs (trailing-LA class+ detection).

Returns

The pattern_hints.

assertion_holds()

constexpr bool real::detail::assertion_holds ( assert_kind  kind, std::string_view  text, std::size_t  pos, bool  ascii_word  )

constexpr

Evaluates a zero-width assertion at pos in text.

Parameters

[in]	kind	The assertion to evaluate.
[in]	text	The full subject (assertions read pos - 1 and pos, so never a substring).
[in]	pos	The position at which to evaluate it.
[in]	ascii_word	Word-ness mode for \b \B \< \>: byte-level ASCII when true, Unicode when false.

Returns

true if the assertion holds there.

ast_has_nullable_captured_repeat()

constexpr bool real::detail::ast_has_nullable_captured_repeat ( const ast &  tree, std::int32_t  idx  )

constexpr

True if a capturing group with a nullable body sits anywhere under a quantifier (? included): the source of pattern_hints::nullable_captured_repeat. A safe over-approximation: it flags the shape ((\b|x)+ counts), not a proven divergent capture.

Parameters

[in]	tree	The AST.
[in]	idx	Root to walk from.

Returns

Whether some quantifier in the tree has a nullable capturing group under it.

bounded_backtrack_route_disabled()

bool & real::detail::bounded_backtrack_route_disabled ( )

inline

Test seam: force the general loop off the bounded backtracker onto the Pike VM, so a differential can assert both agree on every small subject.

Returns

Reference to the process-wide seam flag; set it to true to take the route out.

build_ac_automaton()

REAL_BUILD_COLD std::optional< ac_automaton > real::detail::build_ac_automaton ( std::span< const instr >  code, std::span< const char_class >  classes, std::size_t  body_pc  )

inline

Builds an ac_automaton from a fixed_alternation-shaped program's branch set, over the program's own byte classes (every class it tests is a union of them, so no position is split).

Trusts the shape is_fixed_alternation validated: every branch is a run of byte/klass ops ended by a jump or, for the last, falling through.

Parameters

[in]	code	The program's instruction stream.
[in]	classes	Its class table.
[in]	body_pc	The first branch/split pc (pattern_hints::body_pc).

Returns

The automaton, or std::nullopt when a branch expands past ac_max_branch_expansion or the trie past ac_memory_budget – the caller then takes the ordinary alternation route.

build_byte_program()

REAL_BUILD_COLD constexpr byte_program real::detail::build_byte_program ( const program_view &  prog, bool  keep_assertions = false, std::size_t  max_size = max_byte_program_size  )

constexpr

Builds the byte-level DFA program for prog (see byte_program). A klass_cp at P (the op plus three utf8_cont slots) is replaced by its class's deterministic UTF-8 trie (build_utf8_trie), converging on the mapped P+4; every other op is copied with remapped targets. The first pass sizes each construct into the old→new pc map and enforces max_size; the second emits.

Parameters

[in]	prog	The Pike program to expand.
[in]	keep_assertions	Tier-B: keep assert_position ops as edge conditions instead of declining them (Tier-A's default).
[in]	max_size	Expanded-program-size cap. Defaults to max_byte_program_size; a smaller value lets a test reach the decline cheaply.

Returns

The expanded program, with byte_program::eligible false when it declined.

build_prefix_ast()

ast real::detail::build_prefix_ast ( const ast &  tree, std::int32_t  count, std::int32_t  skip = 0  )

inline

Build the prefix sub-AST: count top-level concat children starting after skip lead children.

Copies the tree, re-roots the concat chain at the skip-th child, and truncates after count body children — later siblings (literal + suffix + trail wb) become unreferenced.

Parameters

[in]	tree	The pattern whose prefix is wanted.
[in]	count	How many body children the prefix keeps; must be >= 1.
[in]	skip	Peeled-lead count (inner_literal::prefix_skip); 0 means nothing was peeled, so the prefix is simply the first count children.

Returns

A copy of tree re-rooted and truncated to that prefix.

build_utf8_trie()

constexpr utf8_trie real::detail::build_utf8_trie ( const cp_class &  cc, std::span< const code_range >  cp_ranges  )

constexpr

Builds the minimal deterministic trie recognising a code-point class's UTF-8 byte sequences.

One branch per UTF-8 range would let ranges sharing a lead byte cross it on two threads (never one-pass). Overlapping ranges are split into disjoint per-node transitions and identical suffix sub-tries hash-consed (Daciuk): Unicode \w \d \s become one-pass, and \w shrinks from thousands of instructions to a few hundred shared nodes.

Parameters

[in]	cc	The code-point class to recognise.
[in]	cp_ranges	The program's range pool, which cc slices.

Returns

The trie; its utf8_trie::root is -1 when the class is empty.

A sequence's remaining byte ranges, as a view: the pool outlives the recursion, so a suffix is subspan(1), never a copy.

byte_frequency()

constexpr std::uint16_t real::detail::byte_frequency ( std::uint8_t  b )

constexpr

Approximate static frequency of a byte in mixed English and source text, per 10000, used only to rank candidate prefilter bytes: a rare required byte (-, @) is a far more selective memchr target than a common first-byte class.

Parameters

[in]

b

The byte to rank.

Returns

Its approximate frequency, in occurrences per 10000.

c_string_subject()

constexpr std::string_view real::detail::c_string_subject ( const char *  text )

constexprprivatenoexcept

A C string as a subject. A null pointer is a caller's bug: a debug build stops on it, and a release build reads it as the empty subject, as the C API does, where constructing a std::string_view from it is undefined.

Parameters

[in]

text

A NUL-terminated string; null only by mistake.

Returns

The view.

capture_free_walk_structural()

constexpr bool real::detail::capture_free_walk_structural ( std::span< const instr >  code )

constexprnoexcept

The structural half of pattern_hints::capture_free_walk, that save 0 is the program's first instruction.

The walk keeps group 0's start in one scalar shared by a whole epsilon closure, correct only while save 0 cannot be skipped: behind a split, a bypassing branch would inherit its sibling's start (a wrong answer). The other half (no save past slot 1) is the caller's: one that reads no captures (real::basic_regex::count_matches) may set the flag on this condition alone.

Parameters

[in]

code

The instruction stream.

Returns

True when the capture-free walk's single-scalar start is sound for code.

class_fastpath_disabled()

bool & real::detail::class_fastpath_disabled ( )

inline

Test/profile seam: skip the dedicated class-scan fast paths (byte class-loop, cp-class-loop, codepoint_class, negated-class ./[^,]+), so such a pattern falls through to lazy-DFA / general.

Returns

Reference to the process-wide seam flag; set it to true to take the route out.

class_range_count()

constexpr int real::detail::class_range_count ( const char_class &  klass, std::uint8_t &  lo0, std::uint8_t &  hi0, std::uint8_t &  lo1, std::uint8_t &  hi1  )

constexpr

Reports klass as up to two contiguous byte ranges.

[lo0, hi0] is the first run in byte order, [lo1, hi1] the second; with no second run they are left untouched, so the caller presets lo1 > hi1. Decides the SIMD range-compare eligibility.

Parameters

[in]	klass	The class to scan.
[out]	lo0	Lower bound of the first run.
[out]	hi0	Upper bound of the first run.
[out]	lo1	Lower bound of the second run (untouched when none).
[out]	hi1	Upper bound of the second run (untouched when none).

Returns

The number of runs found (scanning stops at 3); outside [1, 2] is ineligible.

coalesce_ranges()

constexpr std::vector< code_range > real::detail::coalesce_ranges ( std::vector< code_range >  ranges )

constexpr

Sorts ranges and merges overlapping or adjacent ones: the same code points in the fewest ranges.

Parameters

[in]

ranges

The ranges to normalise; may be unsorted and overlapping.

Returns

The minimal sorted equivalent.

codepoint_advance()

constexpr std::size_t real::detail::codepoint_advance ( std::string_view  text, std::size_t  pos  )

constexpr

Number of bytes from pos to the next code-point boundary, for advancing past an empty match during iteration.

A boundary is any non-continuation byte: the same notion pike_vm::seed_viable uses for match starts, so empty-match stepping and match starts stay in lock-step. On malformed text the continuation run is stepped over as one unit.

Parameters

[in]	text	The subject text.
[in]	pos	Index of the lead byte; must be < text.size().

Returns

The advance in bytes (>= 1).

codepoint_retreat()

constexpr std::size_t real::detail::codepoint_retreat ( std::string_view  text, std::size_t  end, std::size_t  floor  )

constexpr

Width of the last code point before end, the mirror of codepoint_advance.

Exact for a run built by codepoint_advance-consistent steps. Capped at 4 and never walks past floor, so a malformed run cannot read outside the caller's range.

Parameters

[in]	text	The subject text.
[in]	end	Index one past the last consumed byte; must be <= text.size() and > floor.
[in]	floor	Never walk back past this index (the run's own known start).

Returns

The retreat in bytes (>= 1, <= min(4, end - floor)).

compile()

constexpr dynamic_program real::detail::compile ( const ast &  tree, flags  compile_flags  )

constexpr

Compiles tree to an NFA program (convenience over compiler).

Parameters

[in]	tree	The parsed AST.
[in]	compile_flags	The effective compilation flags.

Returns

The compiled dynamic_program.

Exceptions

real::regex_error

if the program exceeds max_program_size.

complement_code_ranges()

constexpr std::vector< code_range > real::detail::complement_code_ranges ( std::vector< code_range >  ranges )

constexpr

Complements a set of code-point ranges within [0x80, 0x10FFFF] (negated classes, in-class \W/\D/\S). Input may be unsorted or overlapping; the gaps come sorted.

Parameters

[in]

ranges

The ranges to complement.

Returns

The gaps between them within [0x80, 0x10FFFF], sorted.

compute_first_bytes()

constexpr void real::detail::compute_first_bytes ( std::span< const instr >  code, std::span< const char_class >  classes, std::span< const cp_class >  cp_classes, pattern_hints &  hints  )

constexpr

Computes the possible first-byte set by a DFS over the epsilon closure of pc 0.

Assertions and lookarounds are crossed (they constrain positions, not bytes), so the set is a sound superset. If match is reachable without consuming, an empty match is possible and no byte-based skipping is sound.

Parameters

[in]	code	The program's instruction stream.
[in]	classes	Its byte classes.
[in]	cp_classes	Its code-point classes.
[in,out]	hints	Hints to record the first-byte set in.

compute_lazy_alphabet()

REAL_BUILD_COLD constexpr lazy_byte_alphabet real::detail::compute_lazy_alphabet ( std::span< const instr >  code, std::span< const char_class >  classes  )

inlineconstexpr

Partition 0..255 by the program's consuming predicates (every klass test, every byte literal). Bytes with an identical signature collapse to one class.

Parameters

[in]	code	The program's instruction stream.
[in]	classes	The byte classes it indexes.

Returns

The alphabet: a byte-to-class map plus the class count.

cp_class_may_contain_ascii_byte()

constexpr bool real::detail::cp_class_may_contain_ascii_byte ( const cp_class &  cc, std::uint8_t  b  )

constexprnoexcept

Whether byte b could be a member of cc; a delimiter that could hide in a possessive code-point loop makes the delimited fast path decline (pattern_hints::possessive_prefix).

Parameters

[in]	cc	The loop body's code-point class.
[in]	b	The candidate delimiter byte.

Returns

True when b could be a member, and for any b >= 0x80.

cp_in_ranges()

constexpr bool real::detail::cp_in_ranges ( std::span< const code_range >  ranges, char32_t  cp  )

constexpr

Binary-searches a sorted, non-overlapping range table for cp. Returns a bool (not a pointer into the table) so it stays constant-evaluable on every compiler.

Parameters

[in]	ranges	Sorted, non-overlapping ranges to search.
[in]	cp	The code point to look for.

Returns

Whether cp falls inside one of them.

cp_ranges_are_normalised()

constexpr bool real::detail::cp_ranges_are_normalised ( const std::vector< code_range > &  ranges )

constexpr

Whether ranges is what every consumer of a cp_class requires: each range non-empty, the sequence strictly ascending and disjoint.

Both match-time paths rely on the order (fill_cp_page_row stops at the first range past the page, cp_class_matches binary-searches above it): an unsorted list loses members silently. Not minimality: a touching pair costs a comparison, never an answer.

Parameters

[in]

ranges

The class's non-ASCII ranges, in the order they would be interned.

Returns

Whether they are ordered as the matchers require.

decode_codepoint_strict()

constexpr decoded_codepoint real::detail::decode_codepoint_strict ( std::string_view  text, std::size_t  pos  )

constexpr

Strictly decodes and validates the UTF-8 sequence at text[pos].

Unlike the lenient codepoint_advance, rejects a lone continuation, a truncated sequence, an overlong (C0 80), a surrogate, and anything above U+10FFFF (so also leads 0xC0/0xC1 and 0xF5–0xFF). In a pattern, a rejection is a malformed pattern, not a silent literal.

Note

Keep the mask tests: an equivalent lead-byte table wins in an isolated probe but loses in make bench-engines, ASCII rows included, because this header sits at a codegen cliff (docs/design.dox §10.1). Measure any change here in make bench-engines, never a probe.

Not noinline: the two supported compilers want opposite inlining, and noinline costs one heavily on the code-point loops without helping the other.

Parameters

[in]	text	A byte sequence.
[in]	pos	Index of the lead byte; must be < text.size().

Returns

The decoded code point with valid == true, or valid == false on any malformation.

decode_digit_escape()

constexpr digit_escape_result real::detail::decode_digit_escape ( std::string_view  text, std::size_t  first  )

constexpr

Decodes a \<digit> escape per CPython's rule; shared by the pattern and the replacement-template parsers so the two never drift.

A \0 prefix, or a 1-7 digit followed by two more octal digits, is an octal escape (\0: value & 0xff; the 3-digit form errors above 0o377). Otherwise the digits (at most two) are a decimal group number.

Parameters

[in]	text	The pattern or template text.
[in]	first	Offset of the first digit.

Returns

The decoded kind, value and consumed length.

detect_fast_shapes()

REAL_BUILD_COLD constexpr void real::detail::detect_fast_shapes ( std::span< const instr >  code, std::span< const char_class >  classes, std::span< const cp_class >  cp_classes, std::span< const code_range >  cp_ranges, std::int32_t  cp_mark_ascii, std::int32_t  cp_mark_offset, std::int32_t  cp_mark_end, std::span< const lookaround_sub >  lookarounds, pattern_hints &  hints  )

constexpr

Detects the whole-pattern fast-path shapes and sets their hint flags: class+, fixed-shape straight runs, a single codepoint class (./negated, optional +), an alternation of straight-line branches, and trailing-lookaround class+.

Parameters

[in]	code	The instruction stream.
[in]	classes	Interned character classes referenced by code.
[in]	cp_classes	Match-time code-point classes (for \w/\d/\s word-class tests).
[in]	cp_ranges	Flat range buffer the cp_classes slices index into.
[in]	cp_mark_ascii	ASCII sub-class index of an emitted codepoint-class block (-1 = none).
[in]	cp_mark_offset	Program offset where that block starts (-1 = none).
[in]	cp_mark_end	Program offset right after that block (-1 = none); its length varies.
[in]	lookarounds	Bounded lookaround subs (for trailing-LA eligibility); may be empty.
[in,out]	hints	Hint bag to fill (class-loop, fixed-shape, trailing-LA, …).

detect_literal_alt()

constexpr bool real::detail::detect_literal_alt ( std::span< const instr >  code, std::size_t  pc, literal_alt_chain &  out  )

constexpr

Whether [pc, exit) is a chain of splits whose branches are runs of byte ops jumping forward to one exit, the last branch falling through to it.

Parameters

[in]	code	The program.
[in]	pc	The candidate first split.
[out]	out	The chain, when it is one.

Returns

True when it is.

dfa_accept_mask_of()

std::vector< std::uint64_t > real::detail::dfa_accept_mask_of ( const dfa_nfa &  nfa, const dfa_set &  set  )

inline

Bitset of ALL accepting rule indices in set (which-matched; word-packed). Empty vector when no rule accepts (or rule_count == 0).

Parameters

[in]	nfa	The union NFA.
[in]	set	The state's PC set.

Returns

The word-packed mask, or an empty vector when nothing accepts.

dfa_accept_of()

std::int64_t real::detail::dfa_accept_of ( const dfa_nfa &  nfa, const dfa_set &  set  )

inline

The accepting rule of a state set: the SMALLEST rule index among its match PCs (the order tie-break), or -1 if none accept.

Parameters

[in]	nfa	The union NFA.
[in]	set	The state's PC set.

Returns

The winning rule index, or -1 when the state does not accept.

dfa_build()

dfa_tables real::detail::dfa_build ( std::span< const program_view >  programs, std::size_t  state_cap = max_dfa_states, bool  unanchored = false  )

inline

Subset construction over byte-classes, then Moore minimization.

The initial partition keys on the full accept mask, not only the min-rule munch tag: two states with the same earliest rule but different accept sets must not merge. unanchored unions the pattern starts into every post-move set, so one scan finds matches at any offset.

Parameters

[in]	programs	The flattened NFA programs.
[in]	state_cap	Maximum DFA states before dfa_error.
[in]	unanchored	Mid-stream restart for which-matched; munch uses false.

Returns

The baked tables.

Exceptions

real::dfa_error

when construction exceeds state_cap, or when dfa_flatten refuses a pattern.

dfa_closure()

dfa_set real::detail::dfa_closure ( const dfa_nfa &  nfa, const std::vector< std::uint32_t > &  seeds, bool  at_start  )

inline

The epsilon-closure of seeds (a PC list), as a canonical PC bitset. at_start follows a text_start assertion (true only at offset 0).

Parameters

[in]	nfa	The union NFA.
[in]	seeds	PCs to close over.
[in]	at_start	Whether a head text_start assertion may be crossed.

Returns

The closure as a canonical bitset.

dfa_compute_classes()

dfa_byte_classes real::detail::dfa_compute_classes ( const dfa_nfa &  nfa )

inline

Partition 0..255 by the union NFA's consuming predicates.

Parameters

[in]

nfa

The union NFA.

Returns

The byte-to-class map, its representatives and their count.

dfa_decide_fidelity()

dfa_fidelity_raw real::detail::dfa_decide_fidelity ( const program_view &  prog, std::size_t  budget  )

inline

Decides whether prog's priority match equals its longest match on every input.

The search walks the PRODUCT of two simulations over one byte program: the priority one (the ordered threads above the current best, as dfa_priority_closure builds them, and whether a best exists) and the set one (every live pc, as the DFA sees it). A reachable product state whose set accepts at a byte where the priority list does not is a divergence, its path a witness input. Conversely every divergence reaches one (the priority best only moves forward, so at the longest match's end the set accepts and the list did not), so the search is exact, bounded only by budget.

Parameters

[in]	prog	The pattern's program.
[in]	budget	Product states explored before the answer is "undecided".

Returns

The outcome, with a witness when divergent.

Exceptions

real::dfa_error

for a pattern that is not DFA-able.

< Priority threads above the current best, in order.

< A priority match has been recorded.

< Every live pc, as a set.

dfa_flatten()

dfa_nfa real::detail::dfa_flatten ( std::span< const program_view >  programs )

inline

Flattens programs into one union NFA, auditing DFA-ability.

Parameters

[in]

programs

The compiled patterns, one per rule, in rule order.

Returns

The union NFA in one address space.

Exceptions

real::dfa_error

if any program holds an assertion other than a head text_start, a lookaround, a possessive/atomic construct, or a code-point class too wide to expand.

dfa_mask_min_rule()

std::int64_t real::detail::dfa_mask_min_rule ( const std::vector< std::uint64_t > &  mask )

inline

Smallest rule index set in mask, or -1 if empty (munch tag derivation).

Parameters

[in]

mask

A word-packed which-matched bitset.

Returns

The lowest rule index present, or -1 for an empty mask.

dfa_mask_words()

std::size_t real::detail::dfa_mask_words ( std::size_t  rule_count )

inlinenoexcept

Word count for a which-matched bitset over rule_count rules.

Parameters

[in]

rule_count

Rules the bitset must hold.

Returns

64-bit words needed.

dfa_memo_misuse()

void real::detail::dfa_memo_misuse ( const char *  what )

inline

Throws the std::invalid_argument a misused dfa_munch_memo raises, out of line so the throw does not weigh on the per-token match that checks for it.

Parameters

[in]

what

The message.

dfa_move()

dfa_set real::detail::dfa_move ( const dfa_nfa &  nfa, const dfa_set &  set, std::uint8_t  rep  )

inline

The move on the byte rep: ε-closure of the successors of every PC in set that consumes rep.

Parameters

[in]	nfa	The union NFA.
[in]	set	The source state's PC set.
[in]	rep	The representative byte of the class being stepped over.

Returns

The successor state's PC set.

dfa_priority_closure()

bool real::detail::dfa_priority_closure ( const dfa_nfa &  nfa, std::uint32_t  seed, bool  at_start, std::vector< std::uint8_t > &  seen, std::vector< std::uint32_t > &  out  )

inline

The priority-ordered epsilon closure of seed, as the Pike walk builds it: consuming pcs are appended to out in priority order, and reaching a match stops the walk, because a thread list is cut below its first accepting thread.

It must stay the SAME walk as pike_vm::add_thread: DFS order (primary before secondary), a pc dropped once seen in this generation, and the empty-iteration routing (a jump back to a loop head already seen exits through the head's secondary, at this thread's priority; without it (?:c??)* on "c" reads as faithful while the engine answers the empty match). dfa_fidelity_agrees_with_the_engine in tests/automata/test_dfa_fidelity.cpp holds the two walks together.

Parameters

[in]	nfa	The union NFA (one rule).
[in]	seed	The pc to close over.
[in]	at_start	Whether a head text_start assertion may be crossed.
[in,out]	seen	Per-generation visited marks, shared by every seed of one step.
[in,out]	out	Receives the consuming pcs, in priority order.

Returns

True when the walk reached a match.

dfa_representable()

constexpr bool real::detail::dfa_representable ( std::span< const instr >  code, bool  ascii_word  )

constexpr

Whether a lazy DFA, forward or reversed, can represent every op of code.

Variable-width classes and lookarounds have no DFA representation. Tier 1's possessive-loop family has no consuming-edge representation either (each DFA's consumes() recognizes byte/klass only): treating it as a dead end would be an outright wrong DFA. A position assertion is represented – an edge the closure crosses where it holds – unless it is a word boundary whose word-ness is a code point's, which no single byte decides, or one scoped to the other word-ness.

Parameters

[in]	code	The program's instruction stream.
[in]	ascii_word	Whether a word boundary's word-ness is ASCII (then a byte decides it).

Returns

True when every op is representable.

dfa_seeds_all()

void real::detail::dfa_seeds_all ( const dfa_nfa &  nfa, const dfa_set &  set, const dfa_byte_classes &  bc, const std::vector< std::vector< std::uint8_t > > &  klass_members, std::vector< std::vector< std::uint32_t > > &  seeds  )

inline

Every class's seed list from one state in one pass over the state's PCs: the PCs after each consuming instruction that class passes, without rescanning the set once per class.

Parameters

[in]	nfa	The union NFA.
[in]	set	The source state's PC set.
[in]	bc	The byte classes (a byte PC consumes exactly its own byte's class).
[in]	klass_members	For each NFA class, the byte-class indices it contains.
[out]	seeds	One list per class, cleared first; the lists keep their capacity, so a construction allocates them once rather than once per state.

dfa_set_bit()

void real::detail::dfa_set_bit ( dfa_set &  s, std::size_t  i  )

inline

Set bit i in s. Indices past the set's size are ignored (it is sized to fit).

Parameters

[in,out]	s	The PC bitset.
[in]	i	The PC to mark present.

dfa_test_bit()

bool real::detail::dfa_test_bit ( const dfa_set &  s, std::size_t  i  )

inline

Whether bit i is set in s.

Parameters

[in]	s	The PC bitset.
[in]	i	The PC to test.

Returns

True when present; false for any index beyond the set.

digit_set()

constexpr char_class real::detail::digit_set ( )

constexpr

The ASCII digit set behind \d (Python re.ASCII semantics).

Returns

The set [0-9].

emit_utf8_trie()

REAL_BUILD_COLD constexpr void real::detail::emit_utf8_trie ( byte_program &  bp, const utf8_trie &  trie, std::int32_t  after, range_intern_table &  seen  )

constexpr

Emits trie into bp as a deterministic split/klass/jump fragment, interning each edge's byte range through seen.

The root is emitted first, so the entry is the base pc. Equal edges share one class (0x80..0xBF sits on nearly every node): sound because a class index is only read as a byte set, never to tell klass ops apart.

Parameters

[in,out]	bp	Byte program the fragment is appended to.
[in]	trie	The trie to emit.
[in]	after	Program counter the accept edges jump to (the construct's successor).
[in,out]	seen	Byte-range intern table, shared across every occurrence in one program.

encode_utf8_bytes()

constexpr std::size_t real::detail::encode_utf8_bytes ( std::uint32_t  cp, std::uint8_t(&)  out[4]  )

constexpr

Encodes cp to its UTF-8 bytes in out, returning the length (1–4).

Parameters

[in]	cp	The code point to encode; must be a scalar value (not checked).
[out]	out	Receives the bytes; only the first n are written, n being the return value.

Returns

The encoded length, 1 to 4.

erase_shared_dfas()

void real::detail::erase_shared_dfas ( const regex_immutables *  immut )

inline

Retire this regex's slot (called from ~regex_immutables). Scans still holding the slot's shared_ptr keep it alive; clearing shared_dfa_slot::owner stops their cached copy matching, so a new regex at this address is never served the retired slot.

The release store of the owner pairs with shared_dfa_for's acquire check: the allocator orders this erase before a construction reusing the address, and a thread reaches the new regex only by synchronizing with that constructor, so it sees the null. The map entry drops under the lock, the last reference outside it; the pooled sets and this thread's cached one are freed here (dfa_lease::drop_thread_set).

Parameters

[in]

immut

The regex being destroyed, whose slot is retired.

extract_anchoring()

constexpr void real::detail::extract_anchoring ( std::span< const instr >  code, pattern_hints &  hints  )

constexpr

Records start anchoring: the first non-save instruction tells whether every match must begin at position 0 (\A/^ non-multiline) or at a line start.

Parameters

[in]	code	The program's instruction stream.
[in,out]	hints	Hints to record the anchoring in.

extract_inner_literal()

constexpr inner_literal real::detail::extract_inner_literal ( const ast &  tree )

constexpr

Extract the best required inner literal from a pattern's AST (a pure function on the node pool).

Routed on by pike_vm::run in search mode, via its run_inner_literal.

Leading and trailing top-level \b/\B are peeled — recorded in inner_literal::wb_lead, inner_literal::wb_trail and inner_literal::prefix_skip — so \b\w+@\w+\b keeps the @ route; a mid-body wb anchor still declines. confirm_at on the full program re-checks the boundaries.

Parameters

[in]

tree

The parsed pattern.

Returns

The best required literal, or a default-constructed inner_literal (len == 0) when the pattern declines.

extract_prefix()

constexpr void real::detail::extract_prefix ( std::span< const instr >  code, pattern_hints &  hints  )

constexpr

Collects the required literal prefix and the exact-literal fast-path length.

The prefix is the leading byte instructions; saves and assertions consume nothing and are crossed (hints only filter candidates, the engine verifies). The exact-literal hint fires when those bytes are the whole match: past the first byte only saves and one trailing \b/\B may precede match (recorded as wb hints); any other trailing or inner assertion stays on the VM.

Parameters

[in]	code	The program's instruction stream.
[in,out]	hints	Hints to record the prefix and the exact-literal length in.

extract_rare_byte()

constexpr void real::detail::extract_rare_byte ( std::span< const instr >  code, pattern_hints &  hints  )

constexpr

Records a required literal byte at a FIXED offset far rarer than the first-byte set (pattern_hints::rare_byte / rare_offset), so the search can memchr that one byte.

Walks the leading fixed-width run and stops at the first variable-width or branching op (klass_cp, split, jump, match). The byte must clear an absolute rarity threshold and be several times rarer than the first-byte set. Sound: the hint only filters candidate starts.

Parameters

[in]	code	The program's instruction stream.
[in,out]	hints	Hints to record the rare byte and its offset in.

extract_rare_discriminant()

constexpr void real::detail::extract_rare_discriminant ( std::span< const instr >  code, pattern_hints &  hints  )

constexpr

Arms the rare-discriminant prefilter for shapes like https?://…: fixed prefix (http) + optional mono-byte (s?) + fixed mid with a rare disc (://).

Unlike extract_rare_byte, the disc need not sit at a fixed offset: the search memchr's it and back-verifies the optional shape. Sound: it only filters candidates.

Parameters

[in]	code	The program's instruction stream.
[in,out]	hints	Hints to record the discriminant and its surrounding shape in.

find_byte()

constexpr std::size_t real::detail::find_byte ( std::string_view  text, std::size_t  pos, char  byte  )

constexpr

Index of byte in text[pos..), or real::npos.

memchr at run time (NEON: simd_byte_scan), a plain loop in constant evaluation.

Parameters

[in]	text	The subject text.
[in]	pos	Index to start scanning from.
[in]	byte	The byte to find.

Returns

The index of the first occurrence at or after pos, else npos.

find_bytes_cascade()

constexpr std::size_t real::detail::find_bytes_cascade ( std::string_view  text, std::size_t  pos, const char *  set, std::uint8_t  n  )

constexpr

Index of the first byte in text[pos..) that belongs to a small first-byte set.

A cascade of std::memchr, one per member, keeping the least hit and narrowing the window to [pos, best) for the later members. Constant evaluation runs the plain member-wise scan.

With two or more members the window gallops (doubling from a seed) rather than spanning the rest: a caller running this per rejected candidate (next_candidate's icase small-set route) would otherwise rescan the rest for a rare or absent member ((?i)cafe's C in lowercase text), O(n^2). Galloping bounds a call to ~2x the distance to the hit. One member cannot go quadratic (a memchr costs its progress), and windowing it charges x86 stop sets ([^\x01]+), so it takes one unbounded memchr.

Parameters

[in]	text	The subject text.
[in]	pos	Index to start scanning from.
[in]	set	Pointer to the enumerated set members (first n valid).
[in]	n	Number of valid members (1..6 — run_cascade_stop's stop_set allows up to 6).

Returns

The least index at or after pos whose byte is in the set, else npos.

find_fold_index()

constexpr std::size_t real::detail::find_fold_index ( std::uint32_t  cp )

constexpr

Binary-searches unicode_fold_table for cp; returns its index, or unicode_fold_table_size if cp is not cased. An index (not a pointer into the table) keeps this usable in a constant expression on every compiler — g++ rejects a &table[i] != nullptr comparison inside a static_regex. Shared by the parser (is a literal cased?) and the compiler (its fold partners).

Parameters

[in]

cp

The code point to look up.

Returns

Its index in unicode_fold_table, or unicode_fold_table_size when uncased.

find_fold_lower_bound()

constexpr std::size_t real::detail::find_fold_lower_bound ( std::uint32_t  cp )

constexpr

Index of the first entry whose code point is at or after cp, or unicode_fold_table_size if none is. The seek half of find_fold_index, exposed on its own so a caller holding a RANGE enters the table once and walks forward instead of scanning it whole – see real::detail::unicode_casefold.

Parameters

[in]

cp

The code point to seek.

Returns

The index of the first entry at or after cp; unicode_fold_table_size when none is.

find_folded_literal()

std::size_t real::detail::find_folded_literal ( std::string_view  text, std::size_t  pos, std::string_view  lit, std::uint16_t  folded, std::size_t  rare  )

inline

The first occurrence at or after pos of a literal some of whose letters match in either case.

Scans for the byte at offset rare – both cases of it when it is such a letter, in one pass (find_members) – and checks the whole literal around each hit.

Parameters

[in]	text	The subject.
[in]	pos	Index to start from.
[in]	lit	The literal, its case-free letters in lower case.
[in]	folded	Bit i: byte i of lit is a letter that matches in either case.
[in]	rare	The offset of the byte to scan for (the literal's rarest).

Returns

The index of the occurrence, else real::npos.

find_line_end_cr()

constexpr std::size_t real::detail::find_line_end_cr ( std::string_view  text, std::size_t  pos  )

constexpr

Where an ECMAScript line ends: the index of the first \n or \r in text[pos..), or real::npos.

Parameters

[in]	text	The subject.
[in]	pos	Index to start scanning from.

Returns

The least index at or after pos holding either byte, else npos.

find_literal()

constexpr std::size_t real::detail::find_literal ( std::string_view  text, std::size_t  pos, std::string_view  literal  )

constexpr

Index of the first occurrence of literal in text[pos..), or real::npos.

One byte is find_byte; a longer literal takes find_literal_adaptive with a density that lasts this call (the engine's routes keep one per subject). No memmem (absent on MSVC).

Parameters

[in]	text	The subject text.
[in]	pos	Index to start searching from.
[in]	literal	The literal to locate.

Returns

The index of the first occurrence at or after pos, else npos.

find_literal_adaptive()

std::size_t real::detail::find_literal_adaptive ( std::string_view  text, std::size_t  pos, std::string_view  literal, std::size_t  rare, literal_density &  density  )

inline

Index of the first occurrence of literal in text[pos..), or real::npos, by its rarest byte while that byte is rare in the subject and by the two-byte block filter once it is not.

Once literal_dense_min_cands stops sit under literal_dense_gap bytes apart on average, density turns dense and the pair filter resumes at the last stop's start plus one, so an overlapping occurrence is still found. The route depends on the subject's bytes only. Linear: a position is a candidate at most once. Billed once per call to the test work counter.

Parameters

[in]	text	The subject text.
[in]	pos	Index to start searching from.
[in]	literal	The needle (>= 2 bytes).
[in]	rare	Offset of its rarest byte (literal_rarest_offset), below literal.size().
[in,out]	density	What this subject has shown so far.

Returns

The index of the first occurrence at or after pos, else real::npos.

find_literal_adaptive_rest()

std::size_t real::detail::find_literal_adaptive_rest ( std::string_view  text, std::size_t  pos, std::string_view  literal, std::size_t  rare, literal_density &  density  )

inline

The body of find_literal_adaptive past its first stop: the pair filter for a dense subject, else the rarest-byte scan that counts its stops and judges their density.

Out of line: next_candidate runs per candidate on routes that never reach a literal; inlined there it charges them.

Parameters

[in]	text	The subject text.
[in]	pos	Index to start from (a stop the caller saw fail, or where a dense search starts).
[in]	literal	The needle (>= 2 bytes).
[in]	rare	Offset of its rarest byte by the hints.
[in,out]	density	What this subject has shown so far.

Returns

The index of the first occurrence at or after pos, else real::npos.

find_members()

std::size_t real::detail::find_members ( std::string_view  text, std::size_t  pos, const std::array< std::uint8_t, 8 > &  mem, std::uint8_t  n  )

inline

Least index at or after pos whose byte is one of n members, in ONE pass.

Unlike find_bytes_cascade (one memchr per member: a six-byte union over 8 KB cost what the six searches it replaced did), this tests all n members against sixteen bytes at a time.

Parameters

[in]	text	The subject.
[in]	pos	Index to start scanning from.
[in]	mem	The member bytes, already in the mask load's layout (first n valid).
[in]	n	How many members, 1..8.

Returns

The least index at or after pos whose byte is a member, else npos.

find_prefix()

constexpr std::size_t real::detail::find_prefix ( std::string_view  text, std::size_t  pos, std::string_view  prefix  )

constexpr

First position >= pos where prefix occurs in text, or npos; the dispatch of find_literal.

Parameters

[in]	text	The subject text.
[in]	pos	Index to start searching from.
[in]	prefix	The literal to locate (empty matches at pos).

Returns

The index of the first occurrence at or after pos, else npos.

find_rare_disc_candidate()

constexpr std::size_t real::detail::find_rare_disc_candidate ( std::string_view  text, std::size_t  pos, const pattern_hints &  hints, bool *  density_abandon = nullptr  )

constexpr

Next candidate start for the rare-discriminant prefilter, or real::npos.

Scans for the disc with find_byte, then back-verifies [prefix][opt?][disc][after]. After rare_disc_fail_abandon failed hits it sets density_abandon and returns npos; the caller then takes the prefix path for the rest of the subject.

Parameters

[in]	text	Subject.
[in]	pos	Lower bound on the returned start.
[in]	hints	The armed hints, read for the discriminant and its shape.
[out]	density_abandon	When non-null, set if the disc proved too dense to be worth scanning.

Returns

The verified candidate start, or real::npos when there is none.

fingerprint_cp_class_content()

constexpr std::uint64_t real::detail::fingerprint_cp_class_content ( const char_class &  ascii, const code_range *  ranges, std::uint32_t  range_count  )

constexprprivate

FNV-1a 64-bit content fingerprint of an ASCII bitmap and a range span, computed once at intern_cp_class (constexpr, for static_regex); match time reads cp_class::fingerprint.

Parameters

[in]	ascii	The class's ASCII bitmap.
[in]	ranges	Pointer to its first non-ASCII range.
[in]	range_count	Ranges belonging to it.

Returns

The content hash, equal for two classes holding the same code points.

first_high_byte()

constexpr std::size_t real::detail::first_high_byte ( std::string_view  text, std::size_t  pos, std::size_t  end  )

constexpr

Index of the first byte >= 0x80 in text[pos, end), or end if the range is pure ASCII.

SWAR: eight bytes per memcpy'd word (alignment- and aliasing-safe); the hit word is rechecked byte by byte, which keeps it endianness-free.

Parameters

[in]	text	The subject text.
[in]	pos	Start of the range.
[in]	end	Exclusive end of the range (<= text.size()).

Returns

The least index in [pos, end) whose byte is >= 0x80, else end.

fixed_shape_pair_route_disabled()

bool & real::detail::fixed_shape_pair_route_disabled ( )

inline

Test seam: force the matcher off the heterogeneous fixed-shape pair-filter route onto the ordinary run_fixed_shape walk. The route only filters; match_fixed_body_wb decides each candidate.

Returns

Reference to the process-wide seam flag; set it to true to take the route out.

fixed_shape_route_disabled()

bool & real::detail::fixed_shape_route_disabled ( )

inline

Test seam: force the matcher off the fixed-shape walk (run_fixed_shape) onto the general Pike loop. inner_literal_route_disabled does not reach a fixed_shape pattern (the inner-literal gate excludes it); a differential on one needs this seam.

Returns

Reference to the process-wide seam flag; set it to true to take the route out.

fixed_shape_walk_pays()

constexpr bool real::detail::fixed_shape_walk_pays ( std::span< const instr >  code, const pattern_hints &  hints  )

constexprnoexcept

Whether a search over this fixed shape (pattern_hints::fixed_shape) should walk each candidate start rather than run the lazy DFA.

The walk verifies a candidate up to the shape's width, so a subject whose starts match far into the shape costs it width x length: [a-z]{300}[0-9] over letters, 270 ms/MiB against the DFA's 2 (arm64). A filter that skips starts bounds that: the fused scan (pattern_hints::fixed_shape_simd_len), the pair filter, a rare byte at a fixed offset, a single first byte, or a start anchor (one candidate). Without one, the walk holds its own up to fixed_shape_walk_max_width; past it the DFA's one pass wins on prose and identifiers by 2x to 28x, and loses only where nearly every start matches, by a bounded ~0.6 ms/MiB.

Parameters

[in]	code	The program, a fixed shape.
[in]	hints	Its hints.

Returns

True when the walk is the better route.

fold_ascii_case()

constexpr void real::detail::fold_ascii_case ( char_class &  klass )

constexpr

Closes klass under ASCII case folding.

Apply before negation: [^a] with icase then rejects both 'a' and 'A', as Python does.

Parameters

[in,out]

klass

The class to fold in place.

il_density_last_abandoned()

std::atomic< bool > & real::detail::il_density_last_abandoned ( )

inline

Test observability: whether the inner-literal density gate last abandoned the route.

Both routes give identical spans, so no span test can see the gate or real::detail::pike_vm::il_density_milli_threshold; this flag is what a test asserts. Atomic because concurrent searches all write it; the relaxed store costs a plain store.

Returns

Reference to the process-wide flag; clear it before a search to arm it.

immut_build_mu()

std::mutex & real::detail::immut_build_mu ( const regex_immutables *  immut )

inline

Striped rebuild lock for pike_vm::ensure_immutables (not on regex_immutables — layout isolation). Distinct from shared_dfa_map_mu / shared_dfa_slot::pool_mu so reset_shared_dfas cannot self-deadlock. Different immutables rarely share a stripe.

Parameters

[in]

immut

The cache whose stripe is wanted; hashed by address, never dereferenced.

Returns

The stripe guarding that cache's build.

inner_literal_guard_disabled()

bool & real::detail::inner_literal_guard_disabled ( )

inline

Test seam: force the inner-literal small-haystack guard off, so the route fires on any size and tiny correctness inputs exercise it. The guard uses regex_immutables::il_min_haystack on the first candidate scan and il_warm_floor thereafter.

Returns

Reference to the process-wide seam flag; set it to true to take the guard out.

inner_literal_route_disabled()

bool & real::detail::inner_literal_route_disabled ( )

inline

Test seam: force the matcher off the inner-literal search route onto the core search. The route cannot miss a leftmost match because its reverse bound never advances mid-search.

Returns

Reference to the process-wide seam flag; set it to true to take the route out.

is_any_non_ascii()

constexpr bool real::detail::is_any_non_ascii ( const std::vector< code_range > &  ranges )

constexpr

Whether ranges is exactly the whole non-ASCII space [U+0080, U+10FFFF] — the "any non-ASCII code point" shape emitted by compiler::emit_any_codepoint_class.

Parameters

[in]

ranges

The class's non-ASCII ranges.

Returns

Whether they are exactly the one range covering all of non-ASCII.

is_ascii_word_byte()

constexpr bool real::detail::is_ascii_word_byte ( std::uint8_t  byte )

constexpr

Reports whether byte is an ASCII "word" byte ([0-9A-Za-z_]).

Parameters

[in]

byte

The byte to classify.

Returns

true for ASCII word bytes, used by \b / \w.

is_ascii_word_subset_class()

constexpr bool real::detail::is_ascii_word_subset_class ( const char_class &  cls )

constexprnoexcept

True if every member of cls is an ASCII word byte (subset of \w under bytes/re.A).

Parameters

[in]

cls

The byte class under test.

Returns

Whether it is non-empty and every member is an ASCII word byte.

is_binprop_cp()

constexpr bool real::detail::is_binprop_cp ( binprop  prop, char32_t  cp  )

constexpr

Whether cp has the binary property prop (== the UCD).

Parameters

[in]	prop	The property to test for.
[in]	cp	The code point to test.

Returns

Whether cp has prop.

is_cr_line_assert()

constexpr bool real::detail::is_cr_line_assert ( const instr &  in )

constexpr

Whether in is an ECMAScript line assertion, whose line ends at \r as well as \n.

Parameters

[in]

in

An instruction.

Returns

True for line_start_cr / line_end_cr.

is_digit_cp()

constexpr bool real::detail::is_digit_cp ( char32_t  cp )

constexpr

Whether cp is a Unicode digit code point (== re \d).

Parameters

[in]

cp

The code point to test.

Returns

Whether it is a member of digit_ranges.

is_fixed_alternation()

constexpr bool real::detail::is_fixed_alternation ( std::span< const instr >  code, std::uint8_t *  out_wb_lead = nullptr, std::uint8_t *  out_wb_trail = nullptr, std::uint8_t *  out_body_pc = nullptr, std::int32_t *  out_branch_count = nullptr  )

constexpr

Alternation of straight-line byte/klass branches, optionally wrapped in \b/\B.

Layout: save 0, optional lead word-boundary assert, split chain of branches, optional trail word-boundary assert, save 1, match. Branch jumps target the first instruction after the last branch (trail assert or save 1). Captures other than group 0, nested branches, empty branches, and non-wb assertions all disqualify.

Parameters

[in]	code	The instruction stream.
[out]	out_wb_lead	Optional; receives lead wb hint (0/1/2).
[out]	out_wb_trail	Optional; receives trail wb hint (0/1/2).
[out]	out_body_pc	Optional; receives first branch/split pc after lead wrap.
[out]	out_branch_count	Optional; receives the branch count, so a caller picks a strategy (e.g. Aho-Corasick) without re-walking the split chain.

Returns

true if the program has that shape with at least two branches.

is_full_ascii_word_class()

constexpr bool real::detail::is_full_ascii_word_class ( const char_class &  cls )

constexprnoexcept

True if cls is exactly the ASCII word set [0-9A-Za-z_] (\w under bytes/re.A).

Parameters

[in]

cls

The byte class under test.

Returns

Whether it is exactly \w, neither a subset nor a superset.

is_full_unicode_word_cp_class()

constexpr bool real::detail::is_full_unicode_word_cp_class ( const cp_class &  cc, std::span< const code_range >  all_ranges  )

constexprnoexcept

True if cc is exactly the canonical Unicode \w class (not a user superset).

Range identity, not a range_count threshold: [\w😀] would pass one, yet \b[\w😀]+\b is not [\w😀]+.

Parameters

[in]	cc	The code-point class under test.
[in]	all_ranges	Program flat range buffer (cc indexes a slice of it).

Returns

Whether cc is exactly Unicode \w.

is_gc_cp()

constexpr bool real::detail::is_gc_cp ( gc_property  prop, char32_t  cp  )

constexpr

Whether cp is in the General_Category property prop (== the UCD).

Parameters

[in]	prop	The General_Category to test for.
[in]	cp	The code point to test.

Returns

Whether cp is in prop.

is_script_cp()

constexpr bool real::detail::is_script_cp ( script  sc, char32_t  cp  )

constexpr

Whether cp belongs to Script sc (== the UCD).

Parameters

[in]	sc	The Script to test for.
[in]	cp	The code point to test.

Returns

Whether script_of answers sc. Exclusive: a code point has exactly one Script.

is_scx_cp()

constexpr bool real::detail::is_scx_cp ( script  sc, char32_t  cp  )

constexpr

Whether cp is in the Script_Extensions of sc (== the UCD). NOT exclusive: a code point can satisfy this for several script values at once.

Parameters

[in]	sc	The Script to test for.
[in]	cp	The code point to test.

Returns

Whether sc is in cp's Script_Extensions set.

is_space_cp()

constexpr bool real::detail::is_space_cp ( char32_t  cp )

constexpr

Whether cp is a Unicode whitespace code point (== re \s).

Parameters

[in]

cp

The code point to test.

Returns

Whether it is a member of space_ranges.

is_unicode_word_subset_cp_class()

constexpr bool real::detail::is_unicode_word_subset_cp_class ( const cp_class &  cc, std::span< const code_range >  all_ranges  )

constexprnoexcept

True if cc is a non-empty subset of Unicode \w (safe for maximal-run + \b wrap).

A superset like [\w😀] must not take the WRAP rule: a maximal run starting on a non-word member skips a later word-bounded sub-run.

Parameters

[in]	cc	The code-point class under test.
[in]	all_ranges	Program flat range buffer (cc indexes a slice of it).

Returns

Whether cc is non-empty and wholly inside Unicode \w.

is_word_boundary_kind()

constexpr bool real::detail::is_word_boundary_kind ( assert_kind  kind )

constexprnoexcept

True if kind is \b or \B (the only position asserts a fast path wraps).

Parameters

[in]

kind

Assertion kind from assert_position.

Returns

Whether it is a word-boundary assertion.

is_word_cp()

constexpr bool real::detail::is_word_cp ( char32_t  cp )

constexpr

Whether cp is a Unicode word code point (== re \w).

Parameters

[in]

cp

The code point to test.

Returns

Whether it is a member of word_ranges.

lazy_dfa_byte_budget()

std::size_t & real::detail::lazy_dfa_byte_budget ( )

inline

Test seam: the byte budget the search DFAs are built with (read at each DFA's construction).

Returns

A reference to the process-wide budget; lazy_dfa_default_byte_budget unless a test moved it.

lazy_dfa_route_disabled()

bool & real::detail::lazy_dfa_route_disabled ( )

inline

Test seam: force the matcher off the lazy-DFA route onto the pure Pike VM, so a differential can assert routed and unrouted searches agree in one binary. Not for production use (applies to every *_disabled seam below).

Returns

Reference to the process-wide seam flag; set it to true to take the route out.

literal_avx2_disabled()

bool & real::detail::literal_avx2_disabled ( )

inline

Test seam: keep the literal filter on 16-byte blocks where the CPU has AVX2, so a differential can compare both widths in one binary. Not for production use.

Returns

Reference to the process-wide seam flag.

literal_rarest_offset()

constexpr std::uint8_t real::detail::literal_rarest_offset ( std::string_view  literal )

constexpr

Offset of the rarest byte of literal by byte_frequency (the first of equals).

Parameters

[in]

literal

The needle (non-empty).

Returns

The offset.

make_utf8_second_byte_bounds_table()

constexpr std::array< utf8_second_byte_bounds, 256 > real::detail::make_utf8_second_byte_bounds_table ( )

constexpr

Builds utf8_second_byte_bounds_table.

Returns

The table, indexed by lead byte.

node_nullable()

constexpr bool real::detail::node_nullable ( const ast &  tree, std::int32_t  idx  )

constexpr

True if the AST subtree rooted at idx can match the empty string. empty, anchor and lookaround are zero-width, so exactly nullable; byte/klass/any never are.

Parameters

[in]	tree	The AST.
[in]	idx	Root of the subtree; a negative index reads as nullable (an absent body).

Returns

Whether the subtree can match the empty string.

note()

constexpr void real::detail::note ( counter  c, std::uint64_t  n = 1  )

constexprnoexcept

Bills n to a test counter. A no-op unless the test binary defines REAL_TEST_INSTRUMENT.

Parameters

[in]	c	The counter.
[in]	n	What to add.

parse()

constexpr ast real::detail::parse ( std::string_view  pattern, flags  initial_flags = flags::none  )

constexpr

Parses pattern into an ast (convenience over parser).

Parameters

[in]	pattern	The pattern text.
[in]	initial_flags	Constructor flags; only verbose affects parsing.

Returns

The parsed AST.

Exceptions

real::regex_error

on unsupported or malformed syntax.

parse_shape_close()

constexpr shape_close real::detail::parse_shape_close ( std::span< const instr >  code, std::size_t  from  )

constexprnoexcept

Peels a fixed shape's optional trail \b/\B, then its save 1 and match.

Parameters

[in]	code	The program's instruction stream.
[in]	from	Program counter just past the body.

Returns

Which trail wrap was found; ok false when the tail is not exactly save 1, match.

parse_shape_lead()

constexpr shape_lead real::detail::parse_shape_lead ( std::span< const instr >  code )

constexprnoexcept

Peels a fixed shape's save 0 and its optional lead \b/\B.

Parameters

[in]

code

The program's instruction stream.

Returns

Where the body begins and which lead wrap was found; ok false when the shape disqualifies.

peel_optional_wb()

constexpr bool real::detail::peel_optional_wb ( std::span< const instr >  code, std::size_t &  p, std::uint8_t &  hint  )

constexprnoexcept

Peels an optional \b/\B assertion at p, lead or trail alike.

Parameters

[in]	code	Instruction stream.
[in,out]	p	Program counter, advanced past a peeled assert.
[out]	hint	0 when nothing was peeled, else 1/2 (see wb_hint_of).

Returns

false only when another assertion sits at p (the shape is disqualified).

possessive_fastpath_disabled()

bool & real::detail::possessive_fastpath_disabled ( )

inline

Test/profile seam: force the matcher off the possessive-loop fast paths (bare/suffixed/delimited X*+/X++) onto the general VM.

Returns

Reference to the process-wide seam flag; set it to true to take the route out.

prefix_reverse_start()

std::size_t real::detail::prefix_reverse_start ( const ast &  tree, std::int32_t  count, flags  compile_flags, std::string_view  text, std::size_t  h, std::size_t  min_start  )

inline

The match start for a literal candidate at h: reverse-match the prefix (the first count top-level children) ending at h, bounded below by min_start. Runtime only (the reverse walk is not constexpr).

Capturing groups compile to save ops, which build_byte_program drops, so the reverse is capture-free without a separate compile. No peeled lead is skipped: pass only a pattern whose inner_literal::prefix_skip is 0.

Parameters

[in]	tree	The pattern's AST, which the prefix is rebuilt from.
[in]	count	Top-level children forming the prefix; 0 means the literal is at the head.
[in]	compile_flags	Flags to compile the prefix with, matching the whole pattern's.
[in]	text	Subject.
[in]	h	Offset of the literal candidate (the prefix must end here).
[in]	min_start	Lower bound the reverse walk will not cross.

Returns

The match start, or real::npos when the prefix cannot reach one.

rare_disc_route_disabled()

bool & real::detail::rare_disc_route_disabled ( )

inline

Test seam: force off the rare-discriminant prefilter (https?:// memchr-: route) onto prefix/first-byte search.

Returns

Reference to the process-wide seam flag; set it to true to take the route out.

reset_shared_dfas()

void real::detail::reset_shared_dfas ( regex_immutables *  immut, bool  keep_warm = false  )

inline

Drop any DFAs cached for immut (caller holds nothing; takes map + slot locks). Invoked from pike_vm's ensure_immutables rebuild so a reused immutables address — or the same address under a new program — cannot keep a previous pattern's DFAs.

Parameters

[in]	immut	The regex whose cached DFAs are dropped.
[in]	keep_warm	Keep shared_dfa_slot::il_warmed on a first build, after which a scan that declined before it still counts as the reuse the warm floor exists for.

resolve_binprop()

constexpr binprop real::detail::resolve_binprop ( std::string_view  loose )

constexpr

Resolve a loose-normalized binary-property name to its value, or count if unknown.

Parameters

[in]

loose

A name already put through the parser's loose normalization.

Returns

The property, or binprop::count when no alias matches.

resolve_class_wb_hints()

constexpr bool real::detail::resolve_class_wb_hints ( bool  full_word, bool  word_sub, bool  maximal_run, std::uint8_t  lead, std::uint8_t  trail, std::uint8_t &  out_lead, std::uint8_t &  out_trail  )

constexprnoexcept

DROP / WRAP policy for class / cp-class loops under optional \b/\B wraps.

• Full word + \b on a maximal (+) run: drop the boundaries (wb_redundant_for_full_word).
• Proper word subset + \b, or full word + \b on a single atom: keep the wrap (the WRAP rule).
• \B on a maximal run: unarm. The runner skips whole class runs on a failed lead check, but \B starts mid-run (\B\w+ on "hello" is "ello").
• \B on a single atom (\B\w): keep the wrap; a failed check advances one atom.
• Non-word-subset class under any wb: unarm (a superset maximal run is unsound).
• Bare (no wb): arm with zero wb hints.

Parameters

[in]	full_word	Exact \w class (ASCII or Unicode table identity).
[in]	word_sub	Non-empty subset of \w.
[in]	maximal_run	Whether the class loop is a greedy + (starts sit at word transitions) rather than a single code point (which may start mid-run).
[in]	lead	Peeled lead hint.
[in]	trail	Peeled trail hint.
[out]	out_lead	Hints to store (0 when dropped).
[out]	out_trail	Hints to store (0 when dropped).

Returns

true if the fast path should arm.

resolve_gc()

constexpr gc_property real::detail::resolve_gc ( std::string_view  loose )

constexpr

Resolve a loose-normalized General_Category name to its property, or count if unknown.

Parameters

[in]

loose

A name already put through the parser's loose normalization.

Returns

The property, or gc_property::count when no alias matches.

resolve_script()

constexpr script real::detail::resolve_script ( std::string_view  loose )

constexpr

Resolve a loose-normalized Script name to its value, or count if unknown.

Parameters

[in]

loose

A name already put through the parser's loose normalization.

Returns

The Script, or script::count when no alias matches.

run_attempt()

template<typename State , bool Bound, typename Slots >

constexpr bool real::detail::run_attempt ( pike_vm< State, Bound > &  vm, const program_view &  prog, std::string_view  subject, std::size_t  pos, run_mode  mode, Slots &  slots, match_semantics  sem = match_semantics::first  )

constexprprivate

One attempt over a region, as every single search makes it: the trailing-lookaround walk where the pattern has one, else pike_vm::run with its memchr-cascade variant chosen once, here.

Shared by basic_regex and the bindings that keep their own scratch, so all take the same routes.

Template Parameters

State	The caller's scratch state.
Bound	Whether the engine may skip its program-identity check.
Slots	The capture-slot container the engine fills.

Parameters

[in]	vm	The engine.
[in]	prog	The program it runs.
[in]	subject	The subject, already truncated to the region's end.
[in]	pos	Where the attempt starts.
[in]	mode	Anchoring.
[out]	slots	Capture slots, filled on a match.
[in]	sem	Match semantics.

Returns

True on a match.

scratch_code_tier()

constexpr std::size_t real::detail::scratch_code_tier ( std::size_t  code_size )

constexpr

Rounds a program length up to the scratch capacity tier it shares with its neighbours.

static_pike_scratch is shared by exact template arguments: keyed on the exact code_size, two patterns one instruction apart would instantiate every Pike VM route twice. Powers of two (floor 8) collapse neighbours with at most 2x over-allocation. Rounding up only: each capacity is a bound.

Parameters

[in]

code_size

The program's exact instruction count.

Returns

The tier capacity, a power of two and at least 8.

script_of()

constexpr script real::detail::script_of ( char32_t  cp )

constexpr

The Script of cp (binary search; Unknown when no range covers it).

Parameters

[in]

cp

The code point to look up.

Returns

Its Script, or script::Unknown when no range covers it.

shared_dfa_for()

shared_dfa_slot & real::detail::shared_dfa_for ( regex_immutables *  immut )

inline

Resolve the process-wide DFA slot for this regex (map insert under shared_dfa_map_mu).

A thread-local last-hit cache fronts the map, else a dense inner-literal scan takes the map mutex once per candidate. It is not on regex_immutables, whose cache lines the class-loop path uses (widening it is measurable). It holds a shared_ptr so an erase cannot free a slot under a scan, and validates the hit against shared_dfa_slot::owner.

Parameters

[in]

immut

The regex whose slot is wanted.

Returns

Its slot, created on first use; never null.

shared_dfa_map()

std::unordered_map< const regex_immutables *, std::shared_ptr< shared_dfa_slot > > & real::detail::shared_dfa_map ( )

inline

Process-wide map, deliberately never destroyed: other statics' ~regex_immutables still call erase_shared_dfas at exit. Entries are erased per destructor, so nothing accumulates.

The one std::unordered_map in these headers. The rule (see lazy_dfa.hpp's hash_trans) keeps std::hash and std::unordered_map, whose out-of-line libc++ symbols drift across toolchains, off scan paths; this map is consulted on a lease or a thread-cache miss, never per match nor in constant evaluation. check-layers accepts REAL_ALLOW_STD_HASH on these lines as the exception.

Returns

The map, keyed by regex_immutables address.

shared_dfa_map_mu()

std::mutex & real::detail::shared_dfa_map_mu ( )

inline

The mutex guarding insert/erase on the process-wide shared_dfa_slot map.

Distinct from shared_dfa_slot::pool_mu, which guards a slot's free sets; a scan holds neither, so erase_shared_dfas cannot deadlock against one.

Returns

The process-wide map mutex.

shared_dfa_map_size_for_test()

std::size_t real::detail::shared_dfa_map_size_for_test ( )

inline

Test/audit: number of live shared-DFA map entries (process-wide). Not for production.

Returns

The live entry count.

single_codepoint_atom()

constexpr std::uint32_t real::detail::single_codepoint_atom ( const ast &  tree, std::int32_t  index  )

constexpr

The code point a node spells, when it is exactly one non-ASCII literal character.

A non-ASCII literal in text mode parses to a concat of its UTF-8 bytes (é is concat(byte C3, byte A9)); the parser (possessive eligibility) and the compiler (unbounded repeat as a code-point class) both ask here. The strict decode must consume every byte, so a concat of more than one code point ((?:éé), (?:ab)) is refused: as one atom it would change what a quantifier repeats.

Parameters

[in]	tree	The AST holding index.
[in]	index	The node to inspect.

Returns

The code point, or not_a_single_codepoint.

space_set()

constexpr char_class real::detail::space_set ( )

constexpr

The ASCII whitespace set behind \s under flags::ascii / flags::bytes.

Returns

The set [ \t\n\r\f\v].

Note

Not str.isspace(): Python's ASCII \s rejects FS/GS/RS/US (U+001C–U+001F), which text mode accepts through the generated space_ranges table.

store_literal_density()

constexpr void real::detail::store_literal_density ( literal_density &  density, std::uint32_t  cands, std::size_t  origin, std::size_t  next  )

constexprnoexcept

Writes the adaptive search's local density back (find_literal_adaptive_rest keeps it in locals while it scans).

Parameters

[out]	density	The subject's density.
[in]	cands	Distinct stops counted.
[in]	origin	Offset of the first.
[in]	next	First offset not yet counted (0: none counted).

subtree_has_nullable_capturing_group()

constexpr bool real::detail::subtree_has_nullable_capturing_group ( const ast &  tree, std::int32_t  idx  )

constexpr

True if the AST subtree rooted at idx contains, at any depth, a capturing group (group >= 0) whose body is nullable (node_nullable).

Parameters

[in]	tree	The AST.
[in]	idx	Root of the subtree.

Returns

Whether a capturing group with a nullable body sits anywhere underneath.

tally()

std::atomic< std::uint64_t > & real::detail::tally ( counter  c )

inlinenoexcept

The value of a test counter, to read or to reset.

Parameters

[in]

c

The counter.

Returns

A reference to its process-wide relaxed atomic.

trailing_la_route_disabled()

bool & real::detail::trailing_la_route_disabled ( )

inline

Test seam: force the matcher off the trailing-lookaround class+ route onto the pure Pike VM.

Returns

Reference to the process-wide seam flag; set it to true to take the route out.

undecidable_word()

constexpr bool real::detail::undecidable_word ( assert_kind  kind, bool  prev_word, bool  prev_nonascii, bool  next_word, bool  next_nonascii  )

constexpr

Whether a word assertion needs a code point's word-ness that one byte does not give: a side it reads is a non-ASCII byte, and the ASCII side does not settle it alone.

Between two ASCII bytes a Unicode word boundary is an ASCII one (assert_eval.hpp). \< is false after an ASCII word byte or before an ASCII non-word byte whatever the other side, and \> mirrors it.

Parameters

[in]	kind	The assertion.
[in]	prev_word	The byte before is an ASCII word byte.
[in]	prev_nonascii	The byte before is not ASCII.
[in]	next_word	The byte after is an ASCII word byte.
[in]	next_nonascii	The byte after is not ASCII.

Returns

True when only the VM can decide it.

unicode_casefold()

constexpr class_def real::detail::unicode_casefold ( const class_def &  in )

constexpr

Expands a character class to its Unicode simple case-fold closure (text-mode icase).

The fold acts on the members written as characters, ranges or properties, across the ASCII boundary both ways, before negation: each ASCII member contributes its partners (k↦Kelvin becomes a range), and each fold entry inside a class range contributes its partners ([U+0080-U+10FFFF] pulls k/K into the bitmap). A shorthand member stays as it is, as in re: folding \W would pull in iota through U+0345, a non-word mark. The ASCII-letter literal fold takes this same route.

Parameters

[in]

in

The class as written.

Returns

Its case-fold closure: the folded ASCII bitmap plus the coalesced non-ASCII ranges.

utf8_cont_set()

constexpr char_class real::detail::utf8_cont_set ( )

constexpr

The UTF-8 continuation-byte set 10xxxxxx.

Returns

The set [0x80, 0xBF].

utf8_lead2_set()

constexpr char_class real::detail::utf8_lead2_set ( )

constexpr

The lead-byte set of a 2-byte UTF-8 sequence.

Returns

The set [0xC2, 0xDF].

utf8_lead3_set()

constexpr char_class real::detail::utf8_lead3_set ( )

constexpr

The lead-byte set of a 3-byte UTF-8 sequence.

Returns

The set [0xE0, 0xEF].

utf8_lead4_set()

constexpr char_class real::detail::utf8_lead4_set ( )

constexpr

The lead-byte set of a 4-byte UTF-8 sequence.

Returns

The set [0xF0, 0xF4].

utf8_push_range()

constexpr void real::detail::utf8_push_range ( std::uint32_t  start, std::uint32_t  end, std::vector< utf8_byte_seq > &  out  )

constexpr

Appends to out the byte-range sequences recognising exactly the UTF-8 encodings of [start, end] (RE2 / rust regex-syntax Utf8Sequences).

Splits at UTF-8 length boundaries, then at continuation-byte boundaries, until each piece is one tuple of byte ranges. The output has no overlong form; surrogates are not excluded here (see utf8_range_sequences).

Parameters

[in]	start	First code point of the range.
[in]	end	Last code point of the range, inclusive; an inverted range appends nothing.
[in,out]	out	Receives the sequences, appended.

utf8_range_sequences()

constexpr std::vector< utf8_byte_seq > real::detail::utf8_range_sequences ( std::uint32_t  lo, std::uint32_t  hi  )

constexpr

Canonical UTF-8 byte-range sequences for the code-point range [lo, hi], excluding the surrogate block [U+D800, U+DFFF] (so a negated class never matches a surrogate encoding).

Parameters

[in]	lo	First code point of the range.
[in]	hi	Last code point of the range, inclusive.

Returns

The canonical sequences covering it, surrogates excluded — empty for an inverted range, or for one lying wholly inside the surrogate block.

utf8_trie_emit_size()

constexpr std::size_t real::detail::utf8_trie_emit_size ( const utf8_trie &  trie )

constexpr

The instruction count emit_utf8_trie writes: an empty class is one dead klass; otherwise each node is a split-guarded chain of k byte ranges (3k - 1 instructions).

Parameters

[in]

trie

The trie to measure.

Returns

Instructions the emission will occupy.

wb_hint_of()

constexpr std::uint8_t real::detail::wb_hint_of ( assert_kind  kind )

constexprnoexcept

Encodes kind as a wb_lead/wb_trail hint value (1 = \b, 2 = \B); 0 if not a word boundary.

Parameters

[in]

kind

Assertion kind from assert_position.

Returns

1 for \b, 2 for \B, 0 for anything else.

wb_redundant_for_full_word()

constexpr bool real::detail::wb_redundant_for_full_word ( std::uint8_t  lead, std::uint8_t  trail  )

constexprnoexcept

The DROP rule: \b next to a full-\w maximal run is redundant (\B never is).

Sound only for a maximal (+) run, which starts and ends at \b anyway; a single atom may start mid-run. Call only for a maximal-run shape.

Parameters

[in]	lead	The lead wrap hint (0/1/2, see wb_hint_of).
[in]	trail	The trail wrap hint, same encoding.

Returns

True when at least one side is \b and neither is \B, so both may be dropped.

word_after()

constexpr bool real::detail::word_after ( std::string_view  text, std::size_t  pos, bool  ascii_word  )

constexpr

Word-ness of the code point starting at pos — the right side of a boundary. False at the text end or on a malformed sequence; ASCII / bytes / re.A stay byte-level.

Parameters

[in]	text	Subject.
[in]	pos	Boundary position.
[in]	ascii_word	Restrict word-ness to ASCII.

Returns

Whether the following code point is a word character.

word_before()

constexpr bool real::detail::word_before ( std::string_view  text, std::size_t  pos, bool  ascii_word  )

constexpr

Word-ness of the code point ending at pos — the left side of a boundary. False at the text start or on a malformed sequence; ASCII / bytes / re.A (ascii_word) stay byte-level.

Parameters

[in]	text	Subject.
[in]	pos	Boundary position.
[in]	ascii_word	Restrict word-ness to ASCII.

Returns

Whether the preceding code point is a word character.

word_ranges_cover_interval()

constexpr bool real::detail::word_ranges_cover_interval ( char32_t  lo, char32_t  hi  )

constexprnoexcept

True if every code point in [lo, hi] is a Unicode word char (covered by word_ranges). Standalone form of word_ranges_cover_interval_from.

Parameters

[in]	lo	First code point of the interval.
[in]	hi	Last code point of the interval, inclusive.

Returns

Whether every code point in it is a Unicode word character.

word_ranges_cover_interval_from()

constexpr bool real::detail::word_ranges_cover_interval_from ( char32_t  lo, char32_t  hi, std::size_t &  cursor  )

constexprnoexcept

True if every code point in [lo, hi] is a Unicode word char (word_ranges), resuming the scan at cursor and leaving it past the last range consulted.

cursor is a hint, not a precondition: an out-of-order interval rewinds it. Restarting at 0 per interval would be quadratic in the range count.

Parameters

[in]	lo	First code point of the interval.
[in]	hi	Last code point of the interval (inclusive).
[in,out]	cursor	Index to resume from, advanced in place.

Returns

true if every code point in the interval is a Unicode word character.

word_set()

constexpr char_class real::detail::word_set ( )

constexpr

The ASCII word set behind \w.

Returns

The set [0-9A-Za-z_].

Variable Documentation

ac_memory_budget_default

constexpr std::size_t real::detail::ac_memory_budget_default {std::size_t {32} << 20U}

inlineconstexpr

Bytes an automaton may hold by default: every program within max_program_size whose alphabet is under 32 classes fits the dense table.

alternation_trie_min_branches

constexpr std::size_t real::detail::alternation_trie_min_branches {64}

inlineconstexpr

Branches from which a literal alternation is factored into a trie in the byte program; below it the flat alternation's states stay small.

binprop_ASCII_Hex_Digit_ranges

constexpr code_range real::detail::binprop_ASCII_Hex_Digit_ranges[]

inlineconstexpr

Initial value:

{
    {0x0030, 0x0039},
    {0x0041, 0x0046},
    {0x0061, 0x0066},
  }

\p{ASCII_Hex_Digit} — 3 ranges, 22 code points.

binprop_Bidi_Control_ranges

constexpr code_range real::detail::binprop_Bidi_Control_ranges[]

inlineconstexpr

Initial value:

{
    {0x061C, 0x061C},
    {0x200E, 0x200F},
    {0x202A, 0x202E},
    {0x2066, 0x2069},
  }

\p{Bidi_Control} — 4 ranges, 12 code points.

binprop_Dash_ranges

constexpr code_range real::detail::binprop_Dash_ranges[]

inlineconstexpr

Initial value:

{
    {0x002D, 0x002D},
    {0x058A, 0x058A},
    {0x05BE, 0x05BE},
    {0x1400, 0x1400},
    {0x1806, 0x1806},
    {0x2010, 0x2015},
    {0x2053, 0x2053},
    {0x207B, 0x207B},
    {0x208B, 0x208B},
    {0x2212, 0x2212},
    {0x2E17, 0x2E17},
    {0x2E1A, 0x2E1A},
    {0x2E3A, 0x2E3B},
    {0x2E40, 0x2E40},
    {0x2E5D, 0x2E5D},
    {0x301C, 0x301C},
    {0x3030, 0x3030},
    {0x30A0, 0x30A0},
    {0xFE31, 0xFE32},
    {0xFE58, 0xFE58},
    {0xFE63, 0xFE63},
    {0xFF0D, 0xFF0D},
    {0x10D6E, 0x10D6E},
    {0x10EAD, 0x10EAD},
  }

\p{Dash} — 24 ranges, 31 code points.

binprop_Default_Ignorable_Code_Point_ranges

constexpr code_range real::detail::binprop_Default_Ignorable_Code_Point_ranges[]

inlineconstexpr

Initial value:

{
    {0x00AD, 0x00AD},
    {0x034F, 0x034F},
    {0x061C, 0x061C},
    {0x115F, 0x1160},
    {0x17B4, 0x17B5},
    {0x180B, 0x180F},
    {0x200B, 0x200F},
    {0x202A, 0x202E},
    {0x2060, 0x206F},
    {0x3164, 0x3164},
    {0xFE00, 0xFE0F},
    {0xFEFF, 0xFEFF},
    {0xFFA0, 0xFFA0},
    {0xFFF0, 0xFFF8},
    {0x1BCA0, 0x1BCA3},
    {0x1D173, 0x1D17A},
    {0xE0000, 0xE0FFF},
  }

\p{Default_Ignorable_Code_Point} — 17 ranges, 4174 code points.

binprop_Deprecated_ranges

constexpr code_range real::detail::binprop_Deprecated_ranges[]

inlineconstexpr

Initial value:

{
    {0x0149, 0x0149},
    {0x0673, 0x0673},
    {0x0F77, 0x0F77},
    {0x0F79, 0x0F79},
    {0x17A3, 0x17A4},
    {0x206A, 0x206F},
    {0x2329, 0x232A},
    {0xE0001, 0xE0001},
  }

\p{Deprecated} — 8 ranges, 15 code points.

binprop_Emoji_Component_ranges

constexpr code_range real::detail::binprop_Emoji_Component_ranges[]

inlineconstexpr

Initial value:

{
    {0x0023, 0x0023},
    {0x002A, 0x002A},
    {0x0030, 0x0039},
    {0x200D, 0x200D},
    {0x20E3, 0x20E3},
    {0xFE0F, 0xFE0F},
    {0x1F1E6, 0x1F1FF},
    {0x1F3FB, 0x1F3FF},
    {0x1F9B0, 0x1F9B3},
    {0xE0020, 0xE007F},
  }

\p{Emoji_Component} — 10 ranges, 146 code points.

binprop_Emoji_Modifier_ranges

constexpr code_range real::detail::binprop_Emoji_Modifier_ranges[]

inlineconstexpr

Initial value:

{
    {0x1F3FB, 0x1F3FF},
  }

\p{Emoji_Modifier} — 1 ranges, 5 code points.

binprop_Hex_Digit_ranges

constexpr code_range real::detail::binprop_Hex_Digit_ranges[]

inlineconstexpr

Initial value:

{
    {0x0030, 0x0039},
    {0x0041, 0x0046},
    {0x0061, 0x0066},
    {0xFF10, 0xFF19},
    {0xFF21, 0xFF26},
    {0xFF41, 0xFF46},
  }

\p{Hex_Digit} — 6 ranges, 44 code points.

binprop_Hyphen_ranges

constexpr code_range real::detail::binprop_Hyphen_ranges[]

inlineconstexpr

Initial value:

{
    {0x002D, 0x002D},
    {0x00AD, 0x00AD},
    {0x058A, 0x058A},
    {0x1806, 0x1806},
    {0x2010, 0x2011},
    {0x2E17, 0x2E17},
    {0x30FB, 0x30FB},
    {0xFE63, 0xFE63},
    {0xFF0D, 0xFF0D},
    {0xFF65, 0xFF65},
  }

\p{Hyphen} — 10 ranges, 11 code points.

binprop_ID_Compat_Math_Continue_ranges

constexpr code_range real::detail::binprop_ID_Compat_Math_Continue_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B2, 0x00B3},
    {0x00B9, 0x00B9},
    {0x2070, 0x2070},
    {0x2074, 0x207E},
    {0x2080, 0x208E},
    {0x2202, 0x2202},
    {0x2207, 0x2207},
    {0x221E, 0x221E},
    {0x1D6C1, 0x1D6C1},
    {0x1D6DB, 0x1D6DB},
    {0x1D6FB, 0x1D6FB},
    {0x1D715, 0x1D715},
    {0x1D735, 0x1D735},
    {0x1D74F, 0x1D74F},
    {0x1D76F, 0x1D76F},
    {0x1D789, 0x1D789},
    {0x1D7A9, 0x1D7A9},
    {0x1D7C3, 0x1D7C3},
  }

\p{ID_Compat_Math_Continue} — 18 ranges, 43 code points.

binprop_ID_Compat_Math_Start_ranges

constexpr code_range real::detail::binprop_ID_Compat_Math_Start_ranges[]

inlineconstexpr

Initial value:

{
    {0x2202, 0x2202},
    {0x2207, 0x2207},
    {0x221E, 0x221E},
    {0x1D6C1, 0x1D6C1},
    {0x1D6DB, 0x1D6DB},
    {0x1D6FB, 0x1D6FB},
    {0x1D715, 0x1D715},
    {0x1D735, 0x1D735},
    {0x1D74F, 0x1D74F},
    {0x1D76F, 0x1D76F},
    {0x1D789, 0x1D789},
    {0x1D7A9, 0x1D7A9},
    {0x1D7C3, 0x1D7C3},
  }

\p{ID_Compat_Math_Start} — 13 ranges, 13 code points.

binprop_Ideographic_ranges

constexpr code_range real::detail::binprop_Ideographic_ranges[]

inlineconstexpr

Initial value:

{
    {0x3006, 0x3007},
    {0x3021, 0x3029},
    {0x3038, 0x303A},
    {0x3400, 0x4DBF},
    {0x4E00, 0x9FFF},
    {0xF900, 0xFA6D},
    {0xFA70, 0xFAD9},
    {0x16FE4, 0x16FE4},
    {0x17000, 0x187F7},
    {0x18800, 0x18CD5},
    {0x18CFF, 0x18D08},
    {0x1B170, 0x1B2FB},
    {0x20000, 0x2A6DF},
    {0x2A700, 0x2B739},
    {0x2B740, 0x2B81D},
    {0x2B820, 0x2CEA1},
    {0x2CEB0, 0x2EBE0},
    {0x2EBF0, 0x2EE5D},
    {0x2F800, 0x2FA1D},
    {0x30000, 0x3134A},
    {0x31350, 0x323AF},
  }

\p{Ideographic} — 21 ranges, 106477 code points.

binprop_IDS_Binary_Operator_ranges

constexpr code_range real::detail::binprop_IDS_Binary_Operator_ranges[]

inlineconstexpr

Initial value:

{
    {0x2FF0, 0x2FF1},
    {0x2FF4, 0x2FFD},
    {0x31EF, 0x31EF},
  }

\p{IDS_Binary_Operator} — 3 ranges, 13 code points.

binprop_IDS_Trinary_Operator_ranges

constexpr code_range real::detail::binprop_IDS_Trinary_Operator_ranges[]

inlineconstexpr

Initial value:

{
    {0x2FF2, 0x2FF3},
  }

\p{IDS_Trinary_Operator} — 1 ranges, 2 code points.

binprop_IDS_Unary_Operator_ranges

constexpr code_range real::detail::binprop_IDS_Unary_Operator_ranges[]

inlineconstexpr

Initial value:

{
    {0x2FFE, 0x2FFF},
  }

\p{IDS_Unary_Operator} — 1 ranges, 2 code points.

binprop_Join_Control_ranges

constexpr code_range real::detail::binprop_Join_Control_ranges[]

inlineconstexpr

Initial value:

{
    {0x200C, 0x200D},
  }

\p{Join_Control} — 1 ranges, 2 code points.

binprop_Logical_Order_Exception_ranges

constexpr code_range real::detail::binprop_Logical_Order_Exception_ranges[]

inlineconstexpr

Initial value:

{
    {0x0E40, 0x0E44},
    {0x0EC0, 0x0EC4},
    {0x19B5, 0x19B7},
    {0x19BA, 0x19BA},
    {0xAAB5, 0xAAB6},
    {0xAAB9, 0xAAB9},
    {0xAABB, 0xAABC},
  }

\p{Logical_Order_Exception} — 7 ranges, 19 code points.

binprop_Modifier_Combining_Mark_ranges

constexpr code_range real::detail::binprop_Modifier_Combining_Mark_ranges[]

inlineconstexpr

Initial value:

{
    {0x0654, 0x0655},
    {0x0658, 0x0658},
    {0x06DC, 0x06DC},
    {0x06E3, 0x06E3},
    {0x06E7, 0x06E8},
    {0x08CA, 0x08CB},
    {0x08CD, 0x08CF},
    {0x08D3, 0x08D3},
    {0x08F3, 0x08F3},
  }

\p{Modifier_Combining_Mark} — 9 ranges, 14 code points.

binprop_Noncharacter_Code_Point_ranges

constexpr code_range real::detail::binprop_Noncharacter_Code_Point_ranges[]

inlineconstexpr

Initial value:

{
    {0xFDD0, 0xFDEF},
    {0xFFFE, 0xFFFF},
    {0x1FFFE, 0x1FFFF},
    {0x2FFFE, 0x2FFFF},
    {0x3FFFE, 0x3FFFF},
    {0x4FFFE, 0x4FFFF},
    {0x5FFFE, 0x5FFFF},
    {0x6FFFE, 0x6FFFF},
    {0x7FFFE, 0x7FFFF},
    {0x8FFFE, 0x8FFFF},
    {0x9FFFE, 0x9FFFF},
    {0xAFFFE, 0xAFFFF},
    {0xBFFFE, 0xBFFFF},
    {0xCFFFE, 0xCFFFF},
    {0xDFFFE, 0xDFFFF},
    {0xEFFFE, 0xEFFFF},
    {0xFFFFE, 0xFFFFF},
    {0x10FFFE, 0x10FFFF},
  }

\p{Noncharacter_Code_Point} — 18 ranges, 66 code points.

binprop_Other_Default_Ignorable_Code_Point_ranges

constexpr code_range real::detail::binprop_Other_Default_Ignorable_Code_Point_ranges[]

inlineconstexpr

Initial value:

{
    {0x034F, 0x034F},
    {0x115F, 0x1160},
    {0x17B4, 0x17B5},
    {0x2065, 0x2065},
    {0x3164, 0x3164},
    {0xFFA0, 0xFFA0},
    {0xFFF0, 0xFFF8},
    {0xE0000, 0xE0000},
    {0xE0002, 0xE001F},
    {0xE0080, 0xE00FF},
    {0xE01F0, 0xE0FFF},
  }

\p{Other_Default_Ignorable_Code_Point} — 11 ranges, 3776 code points.

binprop_Other_ID_Continue_ranges

constexpr code_range real::detail::binprop_Other_ID_Continue_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x0387, 0x0387},
    {0x1369, 0x1371},
    {0x19DA, 0x19DA},
    {0x200C, 0x200D},
    {0x30FB, 0x30FB},
    {0xFF65, 0xFF65},
  }

\p{Other_ID_Continue} — 7 ranges, 16 code points.

binprop_Other_ID_Start_ranges

constexpr code_range real::detail::binprop_Other_ID_Start_ranges[]

inlineconstexpr

Initial value:

{
    {0x1885, 0x1886},
    {0x2118, 0x2118},
    {0x212E, 0x212E},
    {0x309B, 0x309C},
  }

\p{Other_ID_Start} — 4 ranges, 6 code points.

binprop_Other_Lowercase_ranges

constexpr code_range real::detail::binprop_Other_Lowercase_ranges[]

inlineconstexpr

Initial value:

{
    {0x00AA, 0x00AA},
    {0x00BA, 0x00BA},
    {0x02B0, 0x02B8},
    {0x02C0, 0x02C1},
    {0x02E0, 0x02E4},
    {0x0345, 0x0345},
    {0x037A, 0x037A},
    {0x10FC, 0x10FC},
    {0x1D2C, 0x1D6A},
    {0x1D78, 0x1D78},
    {0x1D9B, 0x1DBF},
    {0x2071, 0x2071},
    {0x207F, 0x207F},
    {0x2090, 0x209C},
    {0x2170, 0x217F},
    {0x24D0, 0x24E9},
    {0x2C7C, 0x2C7D},
    {0xA69C, 0xA69D},
    {0xA770, 0xA770},
    {0xA7F2, 0xA7F4},
    {0xA7F8, 0xA7F9},
    {0xAB5C, 0xAB5F},
    {0xAB69, 0xAB69},
    {0x10780, 0x10780},
    {0x10783, 0x10785},
    {0x10787, 0x107B0},
    {0x107B2, 0x107BA},
    {0x1E030, 0x1E06D},
  }

\p{Other_Lowercase} — 28 ranges, 311 code points.

binprop_Other_Uppercase_ranges

constexpr code_range real::detail::binprop_Other_Uppercase_ranges[]

inlineconstexpr

Initial value:

{
    {0x2160, 0x216F},
    {0x24B6, 0x24CF},
    {0x1F130, 0x1F149},
    {0x1F150, 0x1F169},
    {0x1F170, 0x1F189},
  }

\p{Other_Uppercase} — 5 ranges, 120 code points.

binprop_Pattern_Syntax_ranges

constexpr code_range real::detail::binprop_Pattern_Syntax_ranges[]

inlineconstexpr

Initial value:

{
    {0x0021, 0x002F},
    {0x003A, 0x0040},
    {0x005B, 0x005E},
    {0x0060, 0x0060},
    {0x007B, 0x007E},
    {0x00A1, 0x00A7},
    {0x00A9, 0x00A9},
    {0x00AB, 0x00AC},
    {0x00AE, 0x00AE},
    {0x00B0, 0x00B1},
    {0x00B6, 0x00B6},
    {0x00BB, 0x00BB},
    {0x00BF, 0x00BF},
    {0x00D7, 0x00D7},
    {0x00F7, 0x00F7},
    {0x2010, 0x2027},
    {0x2030, 0x203E},
    {0x2041, 0x2053},
    {0x2055, 0x205E},
    {0x2190, 0x245F},
    {0x2500, 0x2775},
    {0x2794, 0x2BFF},
    {0x2E00, 0x2E7F},
    {0x3001, 0x3003},
    {0x3008, 0x3020},
    {0x3030, 0x3030},
    {0xFD3E, 0xFD3F},
    {0xFE45, 0xFE46},
  }

\p{Pattern_Syntax} — 28 ranges, 2760 code points.

binprop_Pattern_White_Space_ranges

constexpr code_range real::detail::binprop_Pattern_White_Space_ranges[]

inlineconstexpr

Initial value:

{
    {0x0009, 0x000D},
    {0x0020, 0x0020},
    {0x0085, 0x0085},
    {0x200E, 0x200F},
    {0x2028, 0x2029},
  }

\p{Pattern_White_Space} — 5 ranges, 11 code points.

binprop_Prepended_Concatenation_Mark_ranges

constexpr code_range real::detail::binprop_Prepended_Concatenation_Mark_ranges[]

inlineconstexpr

Initial value:

{
    {0x0600, 0x0605},
    {0x06DD, 0x06DD},
    {0x070F, 0x070F},
    {0x0890, 0x0891},
    {0x08E2, 0x08E2},
    {0x110BD, 0x110BD},
    {0x110CD, 0x110CD},
  }

\p{Prepended_Concatenation_Mark} — 7 ranges, 13 code points.

binprop_Quotation_Mark_ranges

constexpr code_range real::detail::binprop_Quotation_Mark_ranges[]

inlineconstexpr

Initial value:

{
    {0x0022, 0x0022},
    {0x0027, 0x0027},
    {0x00AB, 0x00AB},
    {0x00BB, 0x00BB},
    {0x2018, 0x201F},
    {0x2039, 0x203A},
    {0x2E42, 0x2E42},
    {0x300C, 0x300F},
    {0x301D, 0x301F},
    {0xFE41, 0xFE44},
    {0xFF02, 0xFF02},
    {0xFF07, 0xFF07},
    {0xFF62, 0xFF63},
  }

\p{Quotation_Mark} — 13 ranges, 30 code points.

binprop_Radical_ranges

constexpr code_range real::detail::binprop_Radical_ranges[]

inlineconstexpr

Initial value:

{
    {0x2E80, 0x2E99},
    {0x2E9B, 0x2EF3},
    {0x2F00, 0x2FD5},
  }

\p{Radical} — 3 ranges, 329 code points.

binprop_Regional_Indicator_ranges

constexpr code_range real::detail::binprop_Regional_Indicator_ranges[]

inlineconstexpr

Initial value:

{
    {0x1F1E6, 0x1F1FF},
  }

\p{Regional_Indicator} — 1 ranges, 26 code points.

binprop_Unified_Ideograph_ranges

constexpr code_range real::detail::binprop_Unified_Ideograph_ranges[]

inlineconstexpr

Initial value:

{
    {0x3400, 0x4DBF},
    {0x4E00, 0x9FFF},
    {0xFA0E, 0xFA0F},
    {0xFA11, 0xFA11},
    {0xFA13, 0xFA14},
    {0xFA1F, 0xFA1F},
    {0xFA21, 0xFA21},
    {0xFA23, 0xFA24},
    {0xFA27, 0xFA29},
    {0x20000, 0x2A6DF},
    {0x2A700, 0x2B739},
    {0x2B740, 0x2B81D},
    {0x2B820, 0x2CEA1},
    {0x2CEB0, 0x2EBE0},
    {0x2EBF0, 0x2EE5D},
    {0x30000, 0x3134A},
    {0x31350, 0x323AF},
  }

\p{Unified_Ideograph} — 17 ranges, 97680 code points.

binprop_Variation_Selector_ranges

constexpr code_range real::detail::binprop_Variation_Selector_ranges[]

inlineconstexpr

Initial value:

{
    {0x180B, 0x180D},
    {0x180F, 0x180F},
    {0xFE00, 0xFE0F},
    {0xE0100, 0xE01EF},
  }

\p{Variation_Selector} — 4 ranges, 260 code points.

binprop_White_Space_ranges

constexpr code_range real::detail::binprop_White_Space_ranges[]

inlineconstexpr

Initial value:

{
    {0x0009, 0x000D},
    {0x0020, 0x0020},
    {0x0085, 0x0085},
    {0x00A0, 0x00A0},
    {0x1680, 0x1680},
    {0x2000, 0x200A},
    {0x2028, 0x2029},
    {0x202F, 0x202F},
    {0x205F, 0x205F},
    {0x3000, 0x3000},
  }

\p{White_Space} — 10 ranges, 25 code points.

bounded_backtrack_bits

constexpr std::size_t real::detail::bounded_backtrack_bits {8192}

inlineconstexprprivate

The bounded backtracker's budget: one bit per (instruction, position), (n + 1) x m bits for an n-byte subject and an m-instruction program.

The bitmap is on the stack: a kibibyte, beside two for the pending branches held before spilling to the heap.

gc_Cc_ranges

constexpr code_range real::detail::gc_Cc_ranges[]

inlineconstexpr

Initial value:

{
    {0x0000, 0x001F},
    {0x007F, 0x009F},
  }

\p{Cc} — 2 ranges, 65 code points.

gc_Cf_ranges

constexpr code_range real::detail::gc_Cf_ranges[]

inlineconstexpr

Initial value:

{
    {0x00AD, 0x00AD},
    {0x0600, 0x0605},
    {0x061C, 0x061C},
    {0x06DD, 0x06DD},
    {0x070F, 0x070F},
    {0x0890, 0x0891},
    {0x08E2, 0x08E2},
    {0x180E, 0x180E},
    {0x200B, 0x200F},
    {0x202A, 0x202E},
    {0x2060, 0x2064},
    {0x2066, 0x206F},
    {0xFEFF, 0xFEFF},
    {0xFFF9, 0xFFFB},
    {0x110BD, 0x110BD},
    {0x110CD, 0x110CD},
    {0x13430, 0x1343F},
    {0x1BCA0, 0x1BCA3},
    {0x1D173, 0x1D17A},
    {0xE0001, 0xE0001},
    {0xE0020, 0xE007F},
  }

\p{Cf} — 21 ranges, 170 code points.

gc_Co_ranges

constexpr code_range real::detail::gc_Co_ranges[]

inlineconstexpr

Initial value:

{
    {0xE000, 0xF8FF},
    {0xF0000, 0xFFFFD},
    {0x100000, 0x10FFFD},
  }

\p{Co} — 3 ranges, 137468 code points.

gc_Lt_ranges

constexpr code_range real::detail::gc_Lt_ranges[]

inlineconstexpr

Initial value:

{
    {0x01C5, 0x01C5},
    {0x01C8, 0x01C8},
    {0x01CB, 0x01CB},
    {0x01F2, 0x01F2},
    {0x1F88, 0x1F8F},
    {0x1F98, 0x1F9F},
    {0x1FA8, 0x1FAF},
    {0x1FBC, 0x1FBC},
    {0x1FCC, 0x1FCC},
    {0x1FFC, 0x1FFC},
  }

\p{Lt} — 10 ranges, 31 code points.

gc_Me_ranges

constexpr code_range real::detail::gc_Me_ranges[]

inlineconstexpr

Initial value:

{
    {0x0488, 0x0489},
    {0x1ABE, 0x1ABE},
    {0x20DD, 0x20E0},
    {0x20E2, 0x20E4},
    {0xA670, 0xA672},
  }

\p{Me} — 5 ranges, 13 code points.

gc_Nl_ranges

constexpr code_range real::detail::gc_Nl_ranges[]

inlineconstexpr

Initial value:

{
    {0x16EE, 0x16F0},
    {0x2160, 0x2182},
    {0x2185, 0x2188},
    {0x3007, 0x3007},
    {0x3021, 0x3029},
    {0x3038, 0x303A},
    {0xA6E6, 0xA6EF},
    {0x10140, 0x10174},
    {0x10341, 0x10341},
    {0x1034A, 0x1034A},
    {0x103D1, 0x103D5},
    {0x12400, 0x1246E},
  }

\p{Nl} — 12 ranges, 236 code points.

gc_Pc_ranges

constexpr code_range real::detail::gc_Pc_ranges[]

inlineconstexpr

Initial value:

{
    {0x005F, 0x005F},
    {0x203F, 0x2040},
    {0x2054, 0x2054},
    {0xFE33, 0xFE34},
    {0xFE4D, 0xFE4F},
    {0xFF3F, 0xFF3F},
  }

\p{Pc} — 6 ranges, 10 code points.

gc_Pd_ranges

constexpr code_range real::detail::gc_Pd_ranges[]

inlineconstexpr

Initial value:

{
    {0x002D, 0x002D},
    {0x058A, 0x058A},
    {0x05BE, 0x05BE},
    {0x1400, 0x1400},
    {0x1806, 0x1806},
    {0x2010, 0x2015},
    {0x2E17, 0x2E17},
    {0x2E1A, 0x2E1A},
    {0x2E3A, 0x2E3B},
    {0x2E40, 0x2E40},
    {0x2E5D, 0x2E5D},
    {0x301C, 0x301C},
    {0x3030, 0x3030},
    {0x30A0, 0x30A0},
    {0xFE31, 0xFE32},
    {0xFE58, 0xFE58},
    {0xFE63, 0xFE63},
    {0xFF0D, 0xFF0D},
    {0x10D6E, 0x10D6E},
    {0x10EAD, 0x10EAD},
  }

\p{Pd} — 20 ranges, 27 code points.

gc_Pf_ranges

constexpr code_range real::detail::gc_Pf_ranges[]

inlineconstexpr

Initial value:

{
    {0x00BB, 0x00BB},
    {0x2019, 0x2019},
    {0x201D, 0x201D},
    {0x203A, 0x203A},
    {0x2E03, 0x2E03},
    {0x2E05, 0x2E05},
    {0x2E0A, 0x2E0A},
    {0x2E0D, 0x2E0D},
    {0x2E1D, 0x2E1D},
    {0x2E21, 0x2E21},
  }

\p{Pf} — 10 ranges, 10 code points.

gc_Pi_ranges

constexpr code_range real::detail::gc_Pi_ranges[]

inlineconstexpr

Initial value:

{
    {0x00AB, 0x00AB},
    {0x2018, 0x2018},
    {0x201B, 0x201C},
    {0x201F, 0x201F},
    {0x2039, 0x2039},
    {0x2E02, 0x2E02},
    {0x2E04, 0x2E04},
    {0x2E09, 0x2E09},
    {0x2E0C, 0x2E0C},
    {0x2E1C, 0x2E1C},
    {0x2E20, 0x2E20},
  }

\p{Pi} — 11 ranges, 12 code points.

gc_Sc_ranges

constexpr code_range real::detail::gc_Sc_ranges[]

inlineconstexpr

Initial value:

{
    {0x0024, 0x0024},
    {0x00A2, 0x00A5},
    {0x058F, 0x058F},
    {0x060B, 0x060B},
    {0x07FE, 0x07FF},
    {0x09F2, 0x09F3},
    {0x09FB, 0x09FB},
    {0x0AF1, 0x0AF1},
    {0x0BF9, 0x0BF9},
    {0x0E3F, 0x0E3F},
    {0x17DB, 0x17DB},
    {0x20A0, 0x20C0},
    {0xA838, 0xA838},
    {0xFDFC, 0xFDFC},
    {0xFE69, 0xFE69},
    {0xFF04, 0xFF04},
    {0xFFE0, 0xFFE1},
    {0xFFE5, 0xFFE6},
    {0x11FDD, 0x11FE0},
    {0x1E2FF, 0x1E2FF},
    {0x1ECB0, 0x1ECB0},
  }

\p{Sc} — 21 ranges, 63 code points.

gc_Z_ranges

constexpr code_range real::detail::gc_Z_ranges[]

inlineconstexpr

Initial value:

{
    {0x0020, 0x0020},
    {0x00A0, 0x00A0},
    {0x1680, 0x1680},
    {0x2000, 0x200A},
    {0x2028, 0x2029},
    {0x202F, 0x202F},
    {0x205F, 0x205F},
    {0x3000, 0x3000},
  }

\p{Z} — 8 ranges, 19 code points.

gc_Zl_ranges

constexpr code_range real::detail::gc_Zl_ranges[]

inlineconstexpr

Initial value:

{
    {0x2028, 0x2028},
  }

\p{Zl} — 1 ranges, 1 code points.

gc_Zp_ranges

constexpr code_range real::detail::gc_Zp_ranges[]

inlineconstexpr

Initial value:

{
    {0x2029, 0x2029},
  }

\p{Zp} — 1 ranges, 1 code points.

gc_Zs_ranges

constexpr code_range real::detail::gc_Zs_ranges[]

inlineconstexpr

Initial value:

{
    {0x0020, 0x0020},
    {0x00A0, 0x00A0},
    {0x1680, 0x1680},
    {0x2000, 0x200A},
    {0x202F, 0x202F},
    {0x205F, 0x205F},
    {0x3000, 0x3000},
  }

\p{Zs} — 7 ranges, 17 code points.

have_members_scan

constexpr bool real::detail::have_members_scan {false}

inlineconstexpr

Whether a consumer should ARM a filter on find_members (one ISA only, measured).

One pass over N members' union competes with N platform memchr calls: it wins where memchr is no wider than this 128-bit loop and loses by a comparable factor where it is twice as wide, a structural gap no tuning closes (a wider mask_t leg would). find_members stays compiled everywhere; this gates only the mechanisms built on it.

lazy_dfa_default_byte_budget

constexpr std::size_t real::detail::lazy_dfa_default_byte_budget {std::size_t {64} << 20U}

inlineconstexpr

Default bytes one lazy DFA's state cache may hold per direction; past it the cache flushes, and a scan that keeps flushing quits to the VM. Above the 30 MB a 2 000-word alternation builds without thrashing.

literal_dense_gap

constexpr std::size_t real::detail::literal_dense_gap {64}

inlineconstexpr

Mean bytes between stops below which the rarest byte counts as common: under it, a stop costs more than the pair filter spends crossing that many bytes.

Per ISA, since the one-byte scan's width differs. Measured break-even over 1 MB with no match: x86-64 memchr near 70 bytes, the arm64 128-bit loop near 190.

max_byte_program_size

constexpr std::size_t real::detail::max_byte_program_size {20000}

inlineconstexpr

Cap on the expanded byte-program's instruction count, checked as it grows. Each klass_cp occurrence emits its own copy of its class's trie, so \w{k} costs O(k x trie size) before the downstream caps (onepass::max_nodes, onepass::max_minimize_work) can act. Sized for the sanitized fuzzing build's per-input timeout; past it Tier-A/Tier-B decline and the general Pike VM runs unexpanded.

max_dfa_byte_program

constexpr std::size_t real::detail::max_dfa_byte_program {512}

inlineconstexpr

Cap on a pattern's expanded byte program before subset construction runs on it.

max_dfa_states bounds the RESULT; this bounds the WORK. Subset construction is superlinear: a text-mode \w+ expands into thousands of byte instructions and turns a sub-millisecond build into a fraction of a second, a timeout under sanitized fuzzing. The cap sits above every shape that builds in about a millisecond; past it the pattern declines with a message naming the cause.

max_dfa_states

constexpr std::size_t real::detail::max_dfa_states {default_max_dfa_states}

inlineconstexpr

Maximum DFA states (opt-in real::dfa; REAL_MAX_DFA_STATES).

Caps exponential subset construction: a pathological pattern throws real::dfa_error instead of exhausting memory.

max_program_size

constexpr std::size_t real::detail::max_program_size {default_max_program_size}

inlineconstexpr

Maximum number of NFA instructions in a compiled program — 256 Ki by default (REAL_MAX_PROGRAM_SIZE).

Bounds bounded-repeat unrolling (nested {1000} would expand to hundreds of millions of instructions) to a few MiB. Match-time structures have their own bounds: per lazy DFA, direction and thread, 65 536 states or lazy_dfa_default_byte_budget; per regex, ac_memory_budget.

optional_literal_min_score

constexpr std::uint32_t real::detail::optional_literal_min_score {1800}

inlineconstexpr

The least inner_literal::score an inner run needs to be kept when an optional precedes or follows it.

Past an optional the confirm is the full engine once per candidate, so the literal's density decides whether the route pays. A single byte clears the bound at a frequency of 200 or less (, . : = @); a space (1500) or an e (1000) does not.

scx_Adlam_ranges

constexpr code_range real::detail::scx_Adlam_ranges[]

inlineconstexpr

Initial value:

{
    {0x061F, 0x061F},
    {0x0640, 0x0640},
    {0x204F, 0x204F},
    {0x2E41, 0x2E41},
    {0x1E900, 0x1E94B},
    {0x1E950, 0x1E959},
    {0x1E95E, 0x1E95F},
  }

\p{scx=Adlam} — 7 ranges, 92 code points.

scx_Ahom_ranges

constexpr code_range real::detail::scx_Ahom_ranges[]

inlineconstexpr

Initial value:

{
    {0x11700, 0x1171A},
    {0x1171D, 0x1172B},
    {0x11730, 0x11746},
  }

\p{scx=Ahom} — 3 ranges, 65 code points.

scx_Anatolian_Hieroglyphs_ranges

constexpr code_range real::detail::scx_Anatolian_Hieroglyphs_ranges[]

inlineconstexpr

Initial value:

{
    {0x14400, 0x14646},
  }

\p{scx=Anatolian_Hieroglyphs} — 1 ranges, 583 code points.

scx_Armenian_ranges

constexpr code_range real::detail::scx_Armenian_ranges[]

inlineconstexpr

Initial value:

{
    {0x0308, 0x0308},
    {0x0531, 0x0556},
    {0x0559, 0x058A},
    {0x058D, 0x058F},
    {0xFB13, 0xFB17},
  }

\p{scx=Armenian} — 5 ranges, 97 code points.

scx_Avestan_ranges

constexpr code_range real::detail::scx_Avestan_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x2E30, 0x2E31},
    {0x10B00, 0x10B35},
    {0x10B39, 0x10B3F},
  }

\p{scx=Avestan} — 4 ranges, 64 code points.

scx_Balinese_ranges

constexpr code_range real::detail::scx_Balinese_ranges[]

inlineconstexpr

Initial value:

{
    {0x1B00, 0x1B4C},
    {0x1B4E, 0x1B7F},
  }

\p{scx=Balinese} — 2 ranges, 127 code points.

scx_Bamum_ranges

constexpr code_range real::detail::scx_Bamum_ranges[]

inlineconstexpr

Initial value:

{
    {0xA6A0, 0xA6F7},
    {0x16800, 0x16A38},
  }

\p{scx=Bamum} — 2 ranges, 657 code points.

scx_Bassa_Vah_ranges

constexpr code_range real::detail::scx_Bassa_Vah_ranges[]

inlineconstexpr

Initial value:

{
    {0x16AD0, 0x16AED},
    {0x16AF0, 0x16AF5},
  }

\p{scx=Bassa_Vah} — 2 ranges, 36 code points.

scx_Batak_ranges

constexpr code_range real::detail::scx_Batak_ranges[]

inlineconstexpr

Initial value:

{
    {0x1BC0, 0x1BF3},
    {0x1BFC, 0x1BFF},
  }

\p{scx=Batak} — 2 ranges, 56 code points.

scx_Bengali_ranges

constexpr code_range real::detail::scx_Bengali_ranges[]

inlineconstexpr

Initial value:

{
    {0x02BC, 0x02BC},
    {0x0951, 0x0952},
    {0x0964, 0x0965},
    {0x0980, 0x0983},
    {0x0985, 0x098C},
    {0x098F, 0x0990},
    {0x0993, 0x09A8},
    {0x09AA, 0x09B0},
    {0x09B2, 0x09B2},
    {0x09B6, 0x09B9},
    {0x09BC, 0x09C4},
    {0x09C7, 0x09C8},
    {0x09CB, 0x09CE},
    {0x09D7, 0x09D7},
    {0x09DC, 0x09DD},
    {0x09DF, 0x09E3},
    {0x09E6, 0x09FE},
    {0x1CD0, 0x1CD0},
    {0x1CD2, 0x1CD2},
    {0x1CD5, 0x1CD6},
    {0x1CD8, 0x1CD8},
    {0x1CE1, 0x1CE1},
    {0x1CEA, 0x1CEA},
    {0x1CED, 0x1CED},
    {0x1CF2, 0x1CF2},
    {0x1CF5, 0x1CF7},
    {0xA8F1, 0xA8F1},
  }

\p{scx=Bengali} — 27 ranges, 114 code points.

scx_Bhaiksuki_ranges

constexpr code_range real::detail::scx_Bhaiksuki_ranges[]

inlineconstexpr

Initial value:

{
    {0x11C00, 0x11C08},
    {0x11C0A, 0x11C36},
    {0x11C38, 0x11C45},
    {0x11C50, 0x11C6C},
  }

\p{scx=Bhaiksuki} — 4 ranges, 97 code points.

scx_Bopomofo_ranges

constexpr code_range real::detail::scx_Bopomofo_ranges[]

inlineconstexpr

Initial value:

{
    {0x02C7, 0x02C7},
    {0x02C9, 0x02CB},
    {0x02D9, 0x02D9},
    {0x02EA, 0x02EB},
    {0x3001, 0x3003},
    {0x3008, 0x3011},
    {0x3013, 0x301F},
    {0x302A, 0x302D},
    {0x3030, 0x3030},
    {0x3037, 0x3037},
    {0x30FB, 0x30FB},
    {0x3105, 0x312F},
    {0x31A0, 0x31BF},
    {0xFE45, 0xFE46},
    {0xFF61, 0xFF65},
  }

\p{scx=Bopomofo} — 15 ranges, 122 code points.

scx_Brahmi_ranges

constexpr code_range real::detail::scx_Brahmi_ranges[]

inlineconstexpr

Initial value:

{
    {0x11000, 0x1104D},
    {0x11052, 0x11075},
    {0x1107F, 0x1107F},
  }

\p{scx=Brahmi} — 3 ranges, 115 code points.

scx_Braille_ranges

constexpr code_range real::detail::scx_Braille_ranges[]

inlineconstexpr

Initial value:

{
    {0x2800, 0x28FF},
  }

\p{scx=Braille} — 1 ranges, 256 code points.

scx_Buginese_ranges

constexpr code_range real::detail::scx_Buginese_ranges[]

inlineconstexpr

Initial value:

{
    {0x1A00, 0x1A1B},
    {0x1A1E, 0x1A1F},
    {0xA9CF, 0xA9CF},
  }

\p{scx=Buginese} — 3 ranges, 31 code points.

scx_Buhid_ranges

constexpr code_range real::detail::scx_Buhid_ranges[]

inlineconstexpr

Initial value:

{
    {0x1735, 0x1736},
    {0x1740, 0x1753},
  }

\p{scx=Buhid} — 2 ranges, 22 code points.

scx_Canadian_Aboriginal_ranges

constexpr code_range real::detail::scx_Canadian_Aboriginal_ranges[]

inlineconstexpr

Initial value:

{
    {0x1400, 0x167F},
    {0x18B0, 0x18F5},
    {0x11AB0, 0x11ABF},
  }

\p{scx=Canadian_Aboriginal} — 3 ranges, 726 code points.

scx_Carian_ranges

constexpr code_range real::detail::scx_Carian_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x205A, 0x205A},
    {0x205D, 0x205D},
    {0x2E31, 0x2E31},
    {0x102A0, 0x102D0},
  }

\p{scx=Carian} — 5 ranges, 53 code points.

scx_Caucasian_Albanian_ranges

constexpr code_range real::detail::scx_Caucasian_Albanian_ranges[]

inlineconstexpr

Initial value:

{
    {0x0304, 0x0304},
    {0x0331, 0x0331},
    {0x035E, 0x035E},
    {0x10530, 0x10563},
    {0x1056F, 0x1056F},
  }

\p{scx=Caucasian_Albanian} — 5 ranges, 56 code points.

scx_Chakma_ranges

constexpr code_range real::detail::scx_Chakma_ranges[]

inlineconstexpr

Initial value:

{
    {0x09E6, 0x09EF},
    {0x1040, 0x1049},
    {0x11100, 0x11134},
    {0x11136, 0x11147},
  }

\p{scx=Chakma} — 4 ranges, 91 code points.

scx_Cham_ranges

constexpr code_range real::detail::scx_Cham_ranges[]

inlineconstexpr

Initial value:

{
    {0xAA00, 0xAA36},
    {0xAA40, 0xAA4D},
    {0xAA50, 0xAA59},
    {0xAA5C, 0xAA5F},
  }

\p{scx=Cham} — 4 ranges, 83 code points.

scx_Cherokee_ranges

constexpr code_range real::detail::scx_Cherokee_ranges[]

inlineconstexpr

Initial value:

{
    {0x0300, 0x0302},
    {0x0304, 0x0304},
    {0x030B, 0x030C},
    {0x0323, 0x0324},
    {0x0330, 0x0331},
    {0x13A0, 0x13F5},
    {0x13F8, 0x13FD},
    {0xAB70, 0xABBF},
  }

\p{scx=Cherokee} — 8 ranges, 182 code points.

scx_Chorasmian_ranges

constexpr code_range real::detail::scx_Chorasmian_ranges[]

inlineconstexpr

Initial value:

{
    {0x10FB0, 0x10FCB},
  }

\p{scx=Chorasmian} — 1 ranges, 28 code points.

scx_Coptic_ranges

constexpr code_range real::detail::scx_Coptic_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x0300, 0x0300},
    {0x0304, 0x0305},
    {0x0307, 0x0307},
    {0x0374, 0x0375},
    {0x03E2, 0x03EF},
    {0x2C80, 0x2CF3},
    {0x2CF9, 0x2CFF},
    {0x2E17, 0x2E17},
    {0x102E0, 0x102FB},
  }

\p{scx=Coptic} — 10 ranges, 173 code points.

scx_Cuneiform_ranges

constexpr code_range real::detail::scx_Cuneiform_ranges[]

inlineconstexpr

Initial value:

{
    {0x12000, 0x12399},
    {0x12400, 0x1246E},
    {0x12470, 0x12474},
    {0x12480, 0x12543},
  }

\p{scx=Cuneiform} — 4 ranges, 1234 code points.

scx_Cypriot_ranges

constexpr code_range real::detail::scx_Cypriot_ranges[]

inlineconstexpr

Initial value:

{
    {0x10100, 0x10102},
    {0x10107, 0x10133},
    {0x10137, 0x1013F},
    {0x10800, 0x10805},
    {0x10808, 0x10808},
    {0x1080A, 0x10835},
    {0x10837, 0x10838},
    {0x1083C, 0x1083C},
    {0x1083F, 0x1083F},
  }

\p{scx=Cypriot} — 9 ranges, 112 code points.

scx_Cypro_Minoan_ranges

constexpr code_range real::detail::scx_Cypro_Minoan_ranges[]

inlineconstexpr

Initial value:

{
    {0x10100, 0x10101},
    {0x12F90, 0x12FF2},
  }

\p{scx=Cypro_Minoan} — 2 ranges, 101 code points.

scx_Cyrillic_ranges

constexpr code_range real::detail::scx_Cyrillic_ranges[]

inlineconstexpr

Initial value:

{
    {0x02BC, 0x02BC},
    {0x0300, 0x0302},
    {0x0304, 0x0304},
    {0x0306, 0x0306},
    {0x0308, 0x0308},
    {0x030B, 0x030B},
    {0x0311, 0x0311},
    {0x0400, 0x052F},
    {0x1C80, 0x1C8A},
    {0x1D2B, 0x1D2B},
    {0x1D78, 0x1D78},
    {0x1DF8, 0x1DF8},
    {0x2DE0, 0x2DFF},
    {0x2E43, 0x2E43},
    {0xA640, 0xA69F},
    {0xFE2E, 0xFE2F},
    {0x1E030, 0x1E06D},
    {0x1E08F, 0x1E08F},
  }

\p{scx=Cyrillic} — 18 ranges, 521 code points.

scx_Deseret_ranges

constexpr code_range real::detail::scx_Deseret_ranges[]

inlineconstexpr

Initial value:

{
    {0x10400, 0x1044F},
  }

\p{scx=Deseret} — 1 ranges, 80 code points.

scx_Devanagari_ranges

constexpr code_range real::detail::scx_Devanagari_ranges[]

inlineconstexpr

Initial value:

{
    {0x02BC, 0x02BC},
    {0x0900, 0x0952},
    {0x0955, 0x097F},
    {0x1CD0, 0x1CF6},
    {0x1CF8, 0x1CF9},
    {0x20F0, 0x20F0},
    {0xA830, 0xA839},
    {0xA8E0, 0xA8FF},
    {0x11B00, 0x11B09},
  }

\p{scx=Devanagari} — 9 ranges, 221 code points.

scx_Dives_Akuru_ranges

constexpr code_range real::detail::scx_Dives_Akuru_ranges[]

inlineconstexpr

Initial value:

{
    {0x11900, 0x11906},
    {0x11909, 0x11909},
    {0x1190C, 0x11913},
    {0x11915, 0x11916},
    {0x11918, 0x11935},
    {0x11937, 0x11938},
    {0x1193B, 0x11946},
    {0x11950, 0x11959},
  }

\p{scx=Dives_Akuru} — 8 ranges, 72 code points.

scx_Dogra_ranges

constexpr code_range real::detail::scx_Dogra_ranges[]

inlineconstexpr

Initial value:

{
    {0x0964, 0x096F},
    {0xA830, 0xA839},
    {0x11800, 0x1183B},
  }

\p{scx=Dogra} — 3 ranges, 82 code points.

scx_Duployan_ranges

constexpr code_range real::detail::scx_Duployan_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x0307, 0x0308},
    {0x030A, 0x030A},
    {0x0323, 0x0324},
    {0x2E3C, 0x2E3C},
    {0x1BC00, 0x1BC6A},
    {0x1BC70, 0x1BC7C},
    {0x1BC80, 0x1BC88},
    {0x1BC90, 0x1BC99},
    {0x1BC9C, 0x1BCA3},
  }

\p{scx=Duployan} — 10 ranges, 154 code points.

scx_Egyptian_Hieroglyphs_ranges

constexpr code_range real::detail::scx_Egyptian_Hieroglyphs_ranges[]

inlineconstexpr

Initial value:

{
    {0x13000, 0x13455},
    {0x13460, 0x143FA},
  }

\p{scx=Egyptian_Hieroglyphs} — 2 ranges, 5105 code points.

scx_Elbasan_ranges

constexpr code_range real::detail::scx_Elbasan_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x0305, 0x0305},
    {0x10500, 0x10527},
  }

\p{scx=Elbasan} — 3 ranges, 42 code points.

scx_Elymaic_ranges

constexpr code_range real::detail::scx_Elymaic_ranges[]

inlineconstexpr

Initial value:

{
    {0x10FE0, 0x10FF6},
  }

\p{scx=Elymaic} — 1 ranges, 23 code points.

scx_Garay_ranges

constexpr code_range real::detail::scx_Garay_ranges[]

inlineconstexpr

Initial value:

{
    {0x060C, 0x060C},
    {0x061B, 0x061B},
    {0x061F, 0x061F},
    {0x10D40, 0x10D65},
    {0x10D69, 0x10D85},
    {0x10D8E, 0x10D8F},
  }

\p{scx=Garay} — 6 ranges, 72 code points.

scx_Georgian_ranges

constexpr code_range real::detail::scx_Georgian_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x0589, 0x0589},
    {0x10A0, 0x10C5},
    {0x10C7, 0x10C7},
    {0x10CD, 0x10CD},
    {0x10D0, 0x10FF},
    {0x1C90, 0x1CBA},
    {0x1CBD, 0x1CBF},
    {0x205A, 0x205A},
    {0x2D00, 0x2D25},
    {0x2D27, 0x2D27},
    {0x2D2D, 0x2D2D},
    {0x2E31, 0x2E31},
  }

\p{scx=Georgian} — 13 ranges, 178 code points.

scx_Glagolitic_ranges

constexpr code_range real::detail::scx_Glagolitic_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x0303, 0x0303},
    {0x0305, 0x0305},
    {0x0484, 0x0484},
    {0x0487, 0x0487},
    {0x0589, 0x0589},
    {0x10FB, 0x10FB},
    {0x205A, 0x205A},
    {0x2C00, 0x2C5F},
    {0x2E43, 0x2E43},
    {0xA66F, 0xA66F},
    {0x1E000, 0x1E006},
    {0x1E008, 0x1E018},
    {0x1E01B, 0x1E021},
    {0x1E023, 0x1E024},
    {0x1E026, 0x1E02A},
  }

\p{scx=Glagolitic} — 16 ranges, 144 code points.

scx_Gothic_ranges

constexpr code_range real::detail::scx_Gothic_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x0304, 0x0305},
    {0x0308, 0x0308},
    {0x0331, 0x0331},
    {0x10330, 0x1034A},
  }

\p{scx=Gothic} — 5 ranges, 32 code points.

scx_Grantha_ranges

constexpr code_range real::detail::scx_Grantha_ranges[]

inlineconstexpr

Initial value:

{
    {0x0951, 0x0952},
    {0x0964, 0x0965},
    {0x0BE6, 0x0BF3},
    {0x1CD0, 0x1CD0},
    {0x1CD2, 0x1CD3},
    {0x1CF2, 0x1CF4},
    {0x1CF8, 0x1CF9},
    {0x20F0, 0x20F0},
    {0x11300, 0x11303},
    {0x11305, 0x1130C},
    {0x1130F, 0x11310},
    {0x11313, 0x11328},
    {0x1132A, 0x11330},
    {0x11332, 0x11333},
    {0x11335, 0x11339},
    {0x1133B, 0x11344},
    {0x11347, 0x11348},
    {0x1134B, 0x1134D},
    {0x11350, 0x11350},
    {0x11357, 0x11357},
    {0x1135D, 0x11363},
    {0x11366, 0x1136C},
    {0x11370, 0x11374},
    {0x11FD0, 0x11FD1},
    {0x11FD3, 0x11FD3},
  }

\p{scx=Grantha} — 25 ranges, 116 code points.

scx_Gujarati_ranges

constexpr code_range real::detail::scx_Gujarati_ranges[]

inlineconstexpr

Initial value:

{
    {0x0951, 0x0952},
    {0x0964, 0x0965},
    {0x0A81, 0x0A83},
    {0x0A85, 0x0A8D},
    {0x0A8F, 0x0A91},
    {0x0A93, 0x0AA8},
    {0x0AAA, 0x0AB0},
    {0x0AB2, 0x0AB3},
    {0x0AB5, 0x0AB9},
    {0x0ABC, 0x0AC5},
    {0x0AC7, 0x0AC9},
    {0x0ACB, 0x0ACD},
    {0x0AD0, 0x0AD0},
    {0x0AE0, 0x0AE3},
    {0x0AE6, 0x0AF1},
    {0x0AF9, 0x0AFF},
    {0xA830, 0xA839},
  }

\p{scx=Gujarati} — 17 ranges, 105 code points.

scx_Gunjala_Gondi_ranges

constexpr code_range real::detail::scx_Gunjala_Gondi_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x0964, 0x0965},
    {0x11D60, 0x11D65},
    {0x11D67, 0x11D68},
    {0x11D6A, 0x11D8E},
    {0x11D90, 0x11D91},
    {0x11D93, 0x11D98},
    {0x11DA0, 0x11DA9},
  }

\p{scx=Gunjala_Gondi} — 8 ranges, 66 code points.

scx_Gurmukhi_ranges

constexpr code_range real::detail::scx_Gurmukhi_ranges[]

inlineconstexpr

Initial value:

{
    {0x0951, 0x0952},
    {0x0964, 0x0965},
    {0x0A01, 0x0A03},
    {0x0A05, 0x0A0A},
    {0x0A0F, 0x0A10},
    {0x0A13, 0x0A28},
    {0x0A2A, 0x0A30},
    {0x0A32, 0x0A33},
    {0x0A35, 0x0A36},
    {0x0A38, 0x0A39},
    {0x0A3C, 0x0A3C},
    {0x0A3E, 0x0A42},
    {0x0A47, 0x0A48},
    {0x0A4B, 0x0A4D},
    {0x0A51, 0x0A51},
    {0x0A59, 0x0A5C},
    {0x0A5E, 0x0A5E},
    {0x0A66, 0x0A76},
    {0xA830, 0xA839},
  }

\p{scx=Gurmukhi} — 19 ranges, 94 code points.

scx_Gurung_Khema_ranges

constexpr code_range real::detail::scx_Gurung_Khema_ranges[]

inlineconstexpr

Initial value:

{
    {0x0965, 0x0965},
    {0x16100, 0x16139},
  }

\p{scx=Gurung_Khema} — 2 ranges, 59 code points.

scx_Hangul_ranges

constexpr code_range real::detail::scx_Hangul_ranges[]

inlineconstexpr

Initial value:

{
    {0x1100, 0x11FF},
    {0x3001, 0x3003},
    {0x3008, 0x3011},
    {0x3013, 0x301F},
    {0x302E, 0x3030},
    {0x3037, 0x3037},
    {0x30FB, 0x30FB},
    {0x3131, 0x318E},
    {0x3200, 0x321E},
    {0x3260, 0x327E},
    {0xA960, 0xA97C},
    {0xAC00, 0xD7A3},
    {0xD7B0, 0xD7C6},
    {0xD7CB, 0xD7FB},
    {0xFE45, 0xFE46},
    {0xFF61, 0xFF65},
    {0xFFA0, 0xFFBE},
    {0xFFC2, 0xFFC7},
    {0xFFCA, 0xFFCF},
    {0xFFD2, 0xFFD7},
    {0xFFDA, 0xFFDC},
  }

\p{scx=Hangul} — 21 ranges, 11775 code points.

scx_Hanifi_Rohingya_ranges

constexpr code_range real::detail::scx_Hanifi_Rohingya_ranges[]

inlineconstexpr

Initial value:

{
    {0x060C, 0x060C},
    {0x061B, 0x061B},
    {0x061F, 0x061F},
    {0x0640, 0x0640},
    {0x06D4, 0x06D4},
    {0x10D00, 0x10D27},
    {0x10D30, 0x10D39},
  }

\p{scx=Hanifi_Rohingya} — 7 ranges, 55 code points.

scx_Hanunoo_ranges

constexpr code_range real::detail::scx_Hanunoo_ranges[]

inlineconstexpr

Initial value:

{
    {0x1720, 0x1736},
  }

\p{scx=Hanunoo} — 1 ranges, 23 code points.

scx_Hatran_ranges

constexpr code_range real::detail::scx_Hatran_ranges[]

inlineconstexpr

Initial value:

{
    {0x108E0, 0x108F2},
    {0x108F4, 0x108F5},
    {0x108FB, 0x108FF},
  }

\p{scx=Hatran} — 3 ranges, 26 code points.

scx_Hebrew_ranges

constexpr code_range real::detail::scx_Hebrew_ranges[]

inlineconstexpr

Initial value:

{
    {0x0307, 0x0308},
    {0x0591, 0x05C7},
    {0x05D0, 0x05EA},
    {0x05EF, 0x05F4},
    {0xFB1D, 0xFB36},
    {0xFB38, 0xFB3C},
    {0xFB3E, 0xFB3E},
    {0xFB40, 0xFB41},
    {0xFB43, 0xFB44},
    {0xFB46, 0xFB4F},
  }

\p{scx=Hebrew} — 10 ranges, 136 code points.

scx_Hiragana_ranges

constexpr code_range real::detail::scx_Hiragana_ranges[]

inlineconstexpr

Initial value:

{
    {0x3001, 0x3003},
    {0x3008, 0x3011},
    {0x3013, 0x301F},
    {0x3030, 0x3035},
    {0x3037, 0x3037},
    {0x303C, 0x303D},
    {0x3041, 0x3096},
    {0x3099, 0x30A0},
    {0x30FB, 0x30FC},
    {0xFE45, 0xFE46},
    {0xFF61, 0xFF65},
    {0xFF70, 0xFF70},
    {0xFF9E, 0xFF9F},
    {0x1B001, 0x1B11F},
    {0x1B132, 0x1B132},
    {0x1B150, 0x1B152},
    {0x1F200, 0x1F200},
  }

\p{scx=Hiragana} — 17 ranges, 433 code points.

scx_Imperial_Aramaic_ranges

constexpr code_range real::detail::scx_Imperial_Aramaic_ranges[]

inlineconstexpr

Initial value:

{
    {0x10840, 0x10855},
    {0x10857, 0x1085F},
  }

\p{scx=Imperial_Aramaic} — 2 ranges, 31 code points.

scx_Inherited_ranges

constexpr code_range real::detail::scx_Inherited_ranges[]

inlineconstexpr

Initial value:

{
    {0x030F, 0x030F},
    {0x0312, 0x0312},
    {0x0314, 0x031F},
    {0x0321, 0x0322},
    {0x0326, 0x032C},
    {0x032F, 0x032F},
    {0x0332, 0x0341},
    {0x0343, 0x0344},
    {0x0346, 0x0357},
    {0x0359, 0x035D},
    {0x035F, 0x0362},
    {0x0953, 0x0954},
    {0x1AB0, 0x1ACE},
    {0x1DC2, 0x1DF7},
    {0x1DF9, 0x1DF9},
    {0x1DFB, 0x1DFF},
    {0x200C, 0x200D},
    {0x20D0, 0x20EF},
    {0xFE00, 0xFE0F},
    {0xFE20, 0xFE2D},
    {0x101FD, 0x101FD},
    {0x1CF00, 0x1CF2D},
    {0x1CF30, 0x1CF46},
    {0x1D167, 0x1D169},
    {0x1D17B, 0x1D182},
    {0x1D185, 0x1D18B},
    {0x1D1AA, 0x1D1AD},
    {0xE0100, 0xE01EF},
  }

\p{scx=Inherited} — 28 ranges, 558 code points.

scx_Inscriptional_Pahlavi_ranges

constexpr code_range real::detail::scx_Inscriptional_Pahlavi_ranges[]

inlineconstexpr

Initial value:

{
    {0x10B60, 0x10B72},
    {0x10B78, 0x10B7F},
  }

\p{scx=Inscriptional_Pahlavi} — 2 ranges, 27 code points.

scx_Inscriptional_Parthian_ranges

constexpr code_range real::detail::scx_Inscriptional_Parthian_ranges[]

inlineconstexpr

Initial value:

{
    {0x10B40, 0x10B55},
    {0x10B58, 0x10B5F},
  }

\p{scx=Inscriptional_Parthian} — 2 ranges, 30 code points.

scx_Javanese_ranges

constexpr code_range real::detail::scx_Javanese_ranges[]

inlineconstexpr

Initial value:

{
    {0xA980, 0xA9CD},
    {0xA9CF, 0xA9D9},
    {0xA9DE, 0xA9DF},
  }

\p{scx=Javanese} — 3 ranges, 91 code points.

scx_Kaithi_ranges

constexpr code_range real::detail::scx_Kaithi_ranges[]

inlineconstexpr

Initial value:

{
    {0x0966, 0x096F},
    {0x2E31, 0x2E31},
    {0xA830, 0xA839},
    {0x11080, 0x110C2},
    {0x110CD, 0x110CD},
  }

\p{scx=Kaithi} — 5 ranges, 89 code points.

scx_Kannada_ranges

constexpr code_range real::detail::scx_Kannada_ranges[]

inlineconstexpr

Initial value:

{
    {0x0951, 0x0952},
    {0x0964, 0x0965},
    {0x0C80, 0x0C8C},
    {0x0C8E, 0x0C90},
    {0x0C92, 0x0CA8},
    {0x0CAA, 0x0CB3},
    {0x0CB5, 0x0CB9},
    {0x0CBC, 0x0CC4},
    {0x0CC6, 0x0CC8},
    {0x0CCA, 0x0CCD},
    {0x0CD5, 0x0CD6},
    {0x0CDD, 0x0CDE},
    {0x0CE0, 0x0CE3},
    {0x0CE6, 0x0CEF},
    {0x0CF1, 0x0CF3},
    {0x1CD0, 0x1CD0},
    {0x1CD2, 0x1CD3},
    {0x1CDA, 0x1CDA},
    {0x1CF2, 0x1CF2},
    {0x1CF4, 0x1CF4},
    {0xA830, 0xA835},
  }

\p{scx=Kannada} — 21 ranges, 107 code points.

scx_Katakana_ranges

constexpr code_range real::detail::scx_Katakana_ranges[]

inlineconstexpr

Initial value:

{
    {0x0305, 0x0305},
    {0x0323, 0x0323},
    {0x3001, 0x3003},
    {0x3008, 0x3011},
    {0x3013, 0x301F},
    {0x3030, 0x3035},
    {0x3037, 0x3037},
    {0x303C, 0x303D},
    {0x3099, 0x309C},
    {0x30A0, 0x30FF},
    {0x31F0, 0x31FF},
    {0x32D0, 0x32FE},
    {0x3300, 0x3357},
    {0xFE45, 0xFE46},
    {0xFF61, 0xFF9F},
    {0x1AFF0, 0x1AFF3},
    {0x1AFF5, 0x1AFFB},
    {0x1AFFD, 0x1AFFE},
    {0x1B000, 0x1B000},
    {0x1B120, 0x1B122},
    {0x1B155, 0x1B155},
    {0x1B164, 0x1B167},
  }

\p{scx=Katakana} — 22 ranges, 375 code points.

scx_Kawi_ranges

constexpr code_range real::detail::scx_Kawi_ranges[]

inlineconstexpr

Initial value:

{
    {0x11F00, 0x11F10},
    {0x11F12, 0x11F3A},
    {0x11F3E, 0x11F5A},
  }

\p{scx=Kawi} — 3 ranges, 87 code points.

scx_Kayah_Li_ranges

constexpr code_range real::detail::scx_Kayah_Li_ranges[]

inlineconstexpr

Initial value:

{
    {0xA900, 0xA92F},
  }

\p{scx=Kayah_Li} — 1 ranges, 48 code points.

scx_Kharoshthi_ranges

constexpr code_range real::detail::scx_Kharoshthi_ranges[]

inlineconstexpr

Initial value:

{
    {0x10A00, 0x10A03},
    {0x10A05, 0x10A06},
    {0x10A0C, 0x10A13},
    {0x10A15, 0x10A17},
    {0x10A19, 0x10A35},
    {0x10A38, 0x10A3A},
    {0x10A3F, 0x10A48},
    {0x10A50, 0x10A58},
  }

\p{scx=Kharoshthi} — 8 ranges, 68 code points.

scx_Khitan_Small_Script_ranges

constexpr code_range real::detail::scx_Khitan_Small_Script_ranges[]

inlineconstexpr

Initial value:

{
    {0x16FE4, 0x16FE4},
    {0x18B00, 0x18CD5},
    {0x18CFF, 0x18CFF},
  }

\p{scx=Khitan_Small_Script} — 3 ranges, 472 code points.

scx_Khmer_ranges

constexpr code_range real::detail::scx_Khmer_ranges[]

inlineconstexpr

Initial value:

{
    {0x1780, 0x17DD},
    {0x17E0, 0x17E9},
    {0x17F0, 0x17F9},
    {0x19E0, 0x19FF},
  }

\p{scx=Khmer} — 4 ranges, 146 code points.

scx_Khojki_ranges

constexpr code_range real::detail::scx_Khojki_ranges[]

inlineconstexpr

Initial value:

{
    {0x0AE6, 0x0AEF},
    {0xA830, 0xA839},
    {0x11200, 0x11211},
    {0x11213, 0x11241},
  }

\p{scx=Khojki} — 4 ranges, 85 code points.

scx_Khudawadi_ranges

constexpr code_range real::detail::scx_Khudawadi_ranges[]

inlineconstexpr

Initial value:

{
    {0x0964, 0x0965},
    {0xA830, 0xA839},
    {0x112B0, 0x112EA},
    {0x112F0, 0x112F9},
  }

\p{scx=Khudawadi} — 4 ranges, 81 code points.

scx_Kirat_Rai_ranges

constexpr code_range real::detail::scx_Kirat_Rai_ranges[]

inlineconstexpr

Initial value:

{
    {0x16D40, 0x16D79},
  }

\p{scx=Kirat_Rai} — 1 ranges, 58 code points.

scx_Lao_ranges

constexpr code_range real::detail::scx_Lao_ranges[]

inlineconstexpr

Initial value:

{
    {0x0E81, 0x0E82},
    {0x0E84, 0x0E84},
    {0x0E86, 0x0E8A},
    {0x0E8C, 0x0EA3},
    {0x0EA5, 0x0EA5},
    {0x0EA7, 0x0EBD},
    {0x0EC0, 0x0EC4},
    {0x0EC6, 0x0EC6},
    {0x0EC8, 0x0ECE},
    {0x0ED0, 0x0ED9},
    {0x0EDC, 0x0EDF},
  }

\p{scx=Lao} — 11 ranges, 83 code points.

scx_Lepcha_ranges

constexpr code_range real::detail::scx_Lepcha_ranges[]

inlineconstexpr

Initial value:

{
    {0x1C00, 0x1C37},
    {0x1C3B, 0x1C49},
    {0x1C4D, 0x1C4F},
  }

\p{scx=Lepcha} — 3 ranges, 74 code points.

scx_Limbu_ranges

constexpr code_range real::detail::scx_Limbu_ranges[]

inlineconstexpr

Initial value:

{
    {0x0965, 0x0965},
    {0x1900, 0x191E},
    {0x1920, 0x192B},
    {0x1930, 0x193B},
    {0x1940, 0x1940},
    {0x1944, 0x194F},
  }

\p{scx=Limbu} — 6 ranges, 69 code points.

scx_Linear_A_ranges

constexpr code_range real::detail::scx_Linear_A_ranges[]

inlineconstexpr

Initial value:

{
    {0x10107, 0x10133},
    {0x10600, 0x10736},
    {0x10740, 0x10755},
    {0x10760, 0x10767},
  }

\p{scx=Linear_A} — 4 ranges, 386 code points.

scx_Linear_B_ranges

constexpr code_range real::detail::scx_Linear_B_ranges[]

inlineconstexpr

Initial value:

{
    {0x10000, 0x1000B},
    {0x1000D, 0x10026},
    {0x10028, 0x1003A},
    {0x1003C, 0x1003D},
    {0x1003F, 0x1004D},
    {0x10050, 0x1005D},
    {0x10080, 0x100FA},
    {0x10100, 0x10102},
    {0x10107, 0x10133},
    {0x10137, 0x1013F},
  }

\p{scx=Linear_B} — 10 ranges, 268 code points.

scx_Lisu_ranges

constexpr code_range real::detail::scx_Lisu_ranges[]

inlineconstexpr

Initial value:

{
    {0x02BC, 0x02BC},
    {0x02CD, 0x02CD},
    {0x300A, 0x300B},
    {0xA4D0, 0xA4FF},
    {0x11FB0, 0x11FB0},
  }

\p{scx=Lisu} — 5 ranges, 53 code points.

scx_Lycian_ranges

constexpr code_range real::detail::scx_Lycian_ranges[]

inlineconstexpr

Initial value:

{
    {0x205A, 0x205A},
    {0x10280, 0x1029C},
  }

\p{scx=Lycian} — 2 ranges, 30 code points.

scx_Lydian_ranges

constexpr code_range real::detail::scx_Lydian_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x2E31, 0x2E31},
    {0x10920, 0x10939},
    {0x1093F, 0x1093F},
  }

\p{scx=Lydian} — 4 ranges, 29 code points.

scx_Mahajani_ranges

constexpr code_range real::detail::scx_Mahajani_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x0964, 0x096F},
    {0xA830, 0xA839},
    {0x11150, 0x11176},
  }

\p{scx=Mahajani} — 4 ranges, 62 code points.

scx_Makasar_ranges

constexpr code_range real::detail::scx_Makasar_ranges[]

inlineconstexpr

Initial value:

{
    {0x11EE0, 0x11EF8},
  }

\p{scx=Makasar} — 1 ranges, 25 code points.

scx_Malayalam_ranges

constexpr code_range real::detail::scx_Malayalam_ranges[]

inlineconstexpr

Initial value:

{
    {0x0951, 0x0952},
    {0x0964, 0x0965},
    {0x0D00, 0x0D0C},
    {0x0D0E, 0x0D10},
    {0x0D12, 0x0D44},
    {0x0D46, 0x0D48},
    {0x0D4A, 0x0D4F},
    {0x0D54, 0x0D63},
    {0x0D66, 0x0D7F},
    {0x1CDA, 0x1CDA},
    {0x1CF2, 0x1CF2},
    {0xA830, 0xA832},
  }

\p{scx=Malayalam} — 12 ranges, 127 code points.

scx_Mandaic_ranges

constexpr code_range real::detail::scx_Mandaic_ranges[]

inlineconstexpr

Initial value:

{
    {0x0640, 0x0640},
    {0x0840, 0x085B},
    {0x085E, 0x085E},
  }

\p{scx=Mandaic} — 3 ranges, 30 code points.

scx_Manichaean_ranges

constexpr code_range real::detail::scx_Manichaean_ranges[]

inlineconstexpr

Initial value:

{
    {0x0640, 0x0640},
    {0x10AC0, 0x10AE6},
    {0x10AEB, 0x10AF6},
  }

\p{scx=Manichaean} — 3 ranges, 52 code points.

scx_Marchen_ranges

constexpr code_range real::detail::scx_Marchen_ranges[]

inlineconstexpr

Initial value:

{
    {0x11C70, 0x11C8F},
    {0x11C92, 0x11CA7},
    {0x11CA9, 0x11CB6},
  }

\p{scx=Marchen} — 3 ranges, 68 code points.

scx_Masaram_Gondi_ranges

constexpr code_range real::detail::scx_Masaram_Gondi_ranges[]

inlineconstexpr

Initial value:

{
    {0x0964, 0x0965},
    {0x11D00, 0x11D06},
    {0x11D08, 0x11D09},
    {0x11D0B, 0x11D36},
    {0x11D3A, 0x11D3A},
    {0x11D3C, 0x11D3D},
    {0x11D3F, 0x11D47},
    {0x11D50, 0x11D59},
  }

\p{scx=Masaram_Gondi} — 8 ranges, 77 code points.

scx_Medefaidrin_ranges

constexpr code_range real::detail::scx_Medefaidrin_ranges[]

inlineconstexpr

Initial value:

{
    {0x16E40, 0x16E9A},
  }

\p{scx=Medefaidrin} — 1 ranges, 91 code points.

scx_Meetei_Mayek_ranges

constexpr code_range real::detail::scx_Meetei_Mayek_ranges[]

inlineconstexpr

Initial value:

{
    {0xAAE0, 0xAAF6},
    {0xABC0, 0xABED},
    {0xABF0, 0xABF9},
  }

\p{scx=Meetei_Mayek} — 3 ranges, 79 code points.

scx_Mende_Kikakui_ranges

constexpr code_range real::detail::scx_Mende_Kikakui_ranges[]

inlineconstexpr

Initial value:

{
    {0x1E800, 0x1E8C4},
    {0x1E8C7, 0x1E8D6},
  }

\p{scx=Mende_Kikakui} — 2 ranges, 213 code points.

scx_Meroitic_Cursive_ranges

constexpr code_range real::detail::scx_Meroitic_Cursive_ranges[]

inlineconstexpr

Initial value:

{
    {0x109A0, 0x109B7},
    {0x109BC, 0x109CF},
    {0x109D2, 0x109FF},
  }

\p{scx=Meroitic_Cursive} — 3 ranges, 90 code points.

scx_Meroitic_Hieroglyphs_ranges

constexpr code_range real::detail::scx_Meroitic_Hieroglyphs_ranges[]

inlineconstexpr

Initial value:

{
    {0x205D, 0x205D},
    {0x10980, 0x1099F},
  }

\p{scx=Meroitic_Hieroglyphs} — 2 ranges, 33 code points.

scx_Miao_ranges

constexpr code_range real::detail::scx_Miao_ranges[]

inlineconstexpr

Initial value:

{
    {0x16F00, 0x16F4A},
    {0x16F4F, 0x16F87},
    {0x16F8F, 0x16F9F},
  }

\p{scx=Miao} — 3 ranges, 149 code points.

scx_Modi_ranges

constexpr code_range real::detail::scx_Modi_ranges[]

inlineconstexpr

Initial value:

{
    {0xA830, 0xA839},
    {0x11600, 0x11644},
    {0x11650, 0x11659},
  }

\p{scx=Modi} — 3 ranges, 89 code points.

scx_Mongolian_ranges

constexpr code_range real::detail::scx_Mongolian_ranges[]

inlineconstexpr

Initial value:

{
    {0x1800, 0x1819},
    {0x1820, 0x1878},
    {0x1880, 0x18AA},
    {0x202F, 0x202F},
    {0x3001, 0x3002},
    {0x3008, 0x300B},
    {0x11660, 0x1166C},
  }

\p{scx=Mongolian} — 7 ranges, 178 code points.

scx_Mro_ranges

constexpr code_range real::detail::scx_Mro_ranges[]

inlineconstexpr

Initial value:

{
    {0x16A40, 0x16A5E},
    {0x16A60, 0x16A69},
    {0x16A6E, 0x16A6F},
  }

\p{scx=Mro} — 3 ranges, 43 code points.

scx_Multani_ranges

constexpr code_range real::detail::scx_Multani_ranges[]

inlineconstexpr

Initial value:

{
    {0x0A66, 0x0A6F},
    {0x11280, 0x11286},
    {0x11288, 0x11288},
    {0x1128A, 0x1128D},
    {0x1128F, 0x1129D},
    {0x1129F, 0x112A9},
  }

\p{scx=Multani} — 6 ranges, 48 code points.

scx_Myanmar_ranges

constexpr code_range real::detail::scx_Myanmar_ranges[]

inlineconstexpr

Initial value:

{
    {0x1000, 0x109F},
    {0xA92E, 0xA92E},
    {0xA9E0, 0xA9FE},
    {0xAA60, 0xAA7F},
    {0x116D0, 0x116E3},
  }

\p{scx=Myanmar} — 5 ranges, 244 code points.

scx_Nabataean_ranges

constexpr code_range real::detail::scx_Nabataean_ranges[]

inlineconstexpr

Initial value:

{
    {0x10880, 0x1089E},
    {0x108A7, 0x108AF},
  }

\p{scx=Nabataean} — 2 ranges, 40 code points.

scx_Nag_Mundari_ranges

constexpr code_range real::detail::scx_Nag_Mundari_ranges[]

inlineconstexpr

Initial value:

{
    {0x1E4D0, 0x1E4F9},
  }

\p{scx=Nag_Mundari} — 1 ranges, 42 code points.

scx_Nandinagari_ranges

constexpr code_range real::detail::scx_Nandinagari_ranges[]

inlineconstexpr

Initial value:

{
    {0x0964, 0x0965},
    {0x0CE6, 0x0CEF},
    {0x1CE9, 0x1CE9},
    {0x1CF2, 0x1CF2},
    {0x1CFA, 0x1CFA},
    {0xA830, 0xA835},
    {0x119A0, 0x119A7},
    {0x119AA, 0x119D7},
    {0x119DA, 0x119E4},
  }

\p{scx=Nandinagari} — 9 ranges, 86 code points.

scx_New_Tai_Lue_ranges

constexpr code_range real::detail::scx_New_Tai_Lue_ranges[]

inlineconstexpr

Initial value:

{
    {0x1980, 0x19AB},
    {0x19B0, 0x19C9},
    {0x19D0, 0x19DA},
    {0x19DE, 0x19DF},
  }

\p{scx=New_Tai_Lue} — 4 ranges, 83 code points.

scx_Newa_ranges

constexpr code_range real::detail::scx_Newa_ranges[]

inlineconstexpr

Initial value:

{
    {0x11400, 0x1145B},
    {0x1145D, 0x11461},
  }

\p{scx=Newa} — 2 ranges, 97 code points.

scx_Nko_ranges

constexpr code_range real::detail::scx_Nko_ranges[]

inlineconstexpr

Initial value:

{
    {0x060C, 0x060C},
    {0x061B, 0x061B},
    {0x061F, 0x061F},
    {0x07C0, 0x07FA},
    {0x07FD, 0x07FF},
    {0xFD3E, 0xFD3F},
  }

\p{scx=Nko} — 6 ranges, 67 code points.

scx_Nushu_ranges

constexpr code_range real::detail::scx_Nushu_ranges[]

inlineconstexpr

Initial value:

{
    {0x16FE1, 0x16FE1},
    {0x1B170, 0x1B2FB},
  }

\p{scx=Nushu} — 2 ranges, 397 code points.

scx_Nyiakeng_Puachue_Hmong_ranges

constexpr code_range real::detail::scx_Nyiakeng_Puachue_Hmong_ranges[]

inlineconstexpr

Initial value:

{
    {0x1E100, 0x1E12C},
    {0x1E130, 0x1E13D},
    {0x1E140, 0x1E149},
    {0x1E14E, 0x1E14F},
  }

\p{scx=Nyiakeng_Puachue_Hmong} — 4 ranges, 71 code points.

scx_Ogham_ranges

constexpr code_range real::detail::scx_Ogham_ranges[]

inlineconstexpr

Initial value:

{
    {0x1680, 0x169C},
  }

\p{scx=Ogham} — 1 ranges, 29 code points.

scx_Ol_Chiki_ranges

constexpr code_range real::detail::scx_Ol_Chiki_ranges[]

inlineconstexpr

Initial value:

{
    {0x1C50, 0x1C7F},
  }

\p{scx=Ol_Chiki} — 1 ranges, 48 code points.

scx_Ol_Onal_ranges

constexpr code_range real::detail::scx_Ol_Onal_ranges[]

inlineconstexpr

Initial value:

{
    {0x0964, 0x0965},
    {0x1E5D0, 0x1E5FA},
    {0x1E5FF, 0x1E5FF},
  }

\p{scx=Ol_Onal} — 3 ranges, 46 code points.

scx_Old_Hungarian_ranges

constexpr code_range real::detail::scx_Old_Hungarian_ranges[]

inlineconstexpr

Initial value:

{
    {0x205A, 0x205A},
    {0x205D, 0x205D},
    {0x2E31, 0x2E31},
    {0x2E41, 0x2E41},
    {0x10C80, 0x10CB2},
    {0x10CC0, 0x10CF2},
    {0x10CFA, 0x10CFF},
  }

\p{scx=Old_Hungarian} — 7 ranges, 112 code points.

scx_Old_Italic_ranges

constexpr code_range real::detail::scx_Old_Italic_ranges[]

inlineconstexpr

Initial value:

{
    {0x10300, 0x10323},
    {0x1032D, 0x1032F},
  }

\p{scx=Old_Italic} — 2 ranges, 39 code points.

scx_Old_North_Arabian_ranges

constexpr code_range real::detail::scx_Old_North_Arabian_ranges[]

inlineconstexpr

Initial value:

{
    {0x10A80, 0x10A9F},
  }

\p{scx=Old_North_Arabian} — 1 ranges, 32 code points.

scx_Old_Permic_ranges

constexpr code_range real::detail::scx_Old_Permic_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x0300, 0x0300},
    {0x0306, 0x0308},
    {0x0313, 0x0313},
    {0x0483, 0x0483},
    {0x10350, 0x1037A},
  }

\p{scx=Old_Permic} — 6 ranges, 50 code points.

scx_Old_Persian_ranges

constexpr code_range real::detail::scx_Old_Persian_ranges[]

inlineconstexpr

Initial value:

{
    {0x103A0, 0x103C3},
    {0x103C8, 0x103D5},
  }

\p{scx=Old_Persian} — 2 ranges, 50 code points.

scx_Old_Sogdian_ranges

constexpr code_range real::detail::scx_Old_Sogdian_ranges[]

inlineconstexpr

Initial value:

{
    {0x10F00, 0x10F27},
  }

\p{scx=Old_Sogdian} — 1 ranges, 40 code points.

scx_Old_South_Arabian_ranges

constexpr code_range real::detail::scx_Old_South_Arabian_ranges[]

inlineconstexpr

Initial value:

{
    {0x10A60, 0x10A7F},
  }

\p{scx=Old_South_Arabian} — 1 ranges, 32 code points.

scx_Old_Turkic_ranges

constexpr code_range real::detail::scx_Old_Turkic_ranges[]

inlineconstexpr

Initial value:

{
    {0x205A, 0x205A},
    {0x2E30, 0x2E30},
    {0x10C00, 0x10C48},
  }

\p{scx=Old_Turkic} — 3 ranges, 75 code points.

scx_Old_Uyghur_ranges

constexpr code_range real::detail::scx_Old_Uyghur_ranges[]

inlineconstexpr

Initial value:

{
    {0x0640, 0x0640},
    {0x10AF2, 0x10AF2},
    {0x10F70, 0x10F89},
  }

\p{scx=Old_Uyghur} — 3 ranges, 28 code points.

scx_Oriya_ranges

constexpr code_range real::detail::scx_Oriya_ranges[]

inlineconstexpr

Initial value:

{
    {0x0951, 0x0952},
    {0x0964, 0x0965},
    {0x0B01, 0x0B03},
    {0x0B05, 0x0B0C},
    {0x0B0F, 0x0B10},
    {0x0B13, 0x0B28},
    {0x0B2A, 0x0B30},
    {0x0B32, 0x0B33},
    {0x0B35, 0x0B39},
    {0x0B3C, 0x0B44},
    {0x0B47, 0x0B48},
    {0x0B4B, 0x0B4D},
    {0x0B55, 0x0B57},
    {0x0B5C, 0x0B5D},
    {0x0B5F, 0x0B63},
    {0x0B66, 0x0B77},
    {0x1CDA, 0x1CDA},
    {0x1CF2, 0x1CF2},
  }

\p{scx=Oriya} — 18 ranges, 97 code points.

scx_Osage_ranges

constexpr code_range real::detail::scx_Osage_ranges[]

inlineconstexpr

Initial value:

{
    {0x0301, 0x0301},
    {0x0304, 0x0304},
    {0x030B, 0x030B},
    {0x0358, 0x0358},
    {0x104B0, 0x104D3},
    {0x104D8, 0x104FB},
  }

\p{scx=Osage} — 6 ranges, 76 code points.

scx_Osmanya_ranges

constexpr code_range real::detail::scx_Osmanya_ranges[]

inlineconstexpr

Initial value:

{
    {0x10480, 0x1049D},
    {0x104A0, 0x104A9},
  }

\p{scx=Osmanya} — 2 ranges, 40 code points.

scx_Pahawh_Hmong_ranges

constexpr code_range real::detail::scx_Pahawh_Hmong_ranges[]

inlineconstexpr

Initial value:

{
    {0x16B00, 0x16B45},
    {0x16B50, 0x16B59},
    {0x16B5B, 0x16B61},
    {0x16B63, 0x16B77},
    {0x16B7D, 0x16B8F},
  }

\p{scx=Pahawh_Hmong} — 5 ranges, 127 code points.

scx_Palmyrene_ranges

constexpr code_range real::detail::scx_Palmyrene_ranges[]

inlineconstexpr

Initial value:

{
    {0x10860, 0x1087F},
  }

\p{scx=Palmyrene} — 1 ranges, 32 code points.

scx_Pau_Cin_Hau_ranges

constexpr code_range real::detail::scx_Pau_Cin_Hau_ranges[]

inlineconstexpr

Initial value:

{
    {0x11AC0, 0x11AF8},
  }

\p{scx=Pau_Cin_Hau} — 1 ranges, 57 code points.

scx_Phags_Pa_ranges

constexpr code_range real::detail::scx_Phags_Pa_ranges[]

inlineconstexpr

Initial value:

{
    {0x1802, 0x1803},
    {0x1805, 0x1805},
    {0x202F, 0x202F},
    {0x3002, 0x3002},
    {0xA840, 0xA877},
  }

\p{scx=Phags_Pa} — 5 ranges, 61 code points.

scx_Phoenician_ranges

constexpr code_range real::detail::scx_Phoenician_ranges[]

inlineconstexpr

Initial value:

{
    {0x10900, 0x1091B},
    {0x1091F, 0x1091F},
  }

\p{scx=Phoenician} — 2 ranges, 29 code points.

scx_Psalter_Pahlavi_ranges

constexpr code_range real::detail::scx_Psalter_Pahlavi_ranges[]

inlineconstexpr

Initial value:

{
    {0x0640, 0x0640},
    {0x10B80, 0x10B91},
    {0x10B99, 0x10B9C},
    {0x10BA9, 0x10BAF},
  }

\p{scx=Psalter_Pahlavi} — 4 ranges, 30 code points.

scx_Rejang_ranges

constexpr code_range real::detail::scx_Rejang_ranges[]

inlineconstexpr

Initial value:

{
    {0xA930, 0xA953},
    {0xA95F, 0xA95F},
  }

\p{scx=Rejang} — 2 ranges, 37 code points.

scx_Runic_ranges

constexpr code_range real::detail::scx_Runic_ranges[]

inlineconstexpr

Initial value:

{
    {0x16A0, 0x16F8},
  }

\p{scx=Runic} — 1 ranges, 89 code points.

scx_Samaritan_ranges

constexpr code_range real::detail::scx_Samaritan_ranges[]

inlineconstexpr

Initial value:

{
    {0x0800, 0x082D},
    {0x0830, 0x083E},
    {0x2E31, 0x2E31},
  }

\p{scx=Samaritan} — 3 ranges, 62 code points.

scx_Saurashtra_ranges

constexpr code_range real::detail::scx_Saurashtra_ranges[]

inlineconstexpr

Initial value:

{
    {0xA880, 0xA8C5},
    {0xA8CE, 0xA8D9},
  }

\p{scx=Saurashtra} — 2 ranges, 82 code points.

scx_Sharada_ranges

constexpr code_range real::detail::scx_Sharada_ranges[]

inlineconstexpr

Initial value:

{
    {0x0951, 0x0951},
    {0x1CD7, 0x1CD7},
    {0x1CD9, 0x1CD9},
    {0x1CDC, 0x1CDD},
    {0x1CE0, 0x1CE0},
    {0xA830, 0xA835},
    {0xA838, 0xA838},
    {0x11180, 0x111DF},
  }

\p{scx=Sharada} — 8 ranges, 109 code points.

scx_Shavian_ranges

constexpr code_range real::detail::scx_Shavian_ranges[]

inlineconstexpr

Initial value:

{
    {0x00B7, 0x00B7},
    {0x10450, 0x1047F},
  }

\p{scx=Shavian} — 2 ranges, 49 code points.

scx_Siddham_ranges

constexpr code_range real::detail::scx_Siddham_ranges[]

inlineconstexpr

Initial value:

{
    {0x11580, 0x115B5},
    {0x115B8, 0x115DD},
  }

\p{scx=Siddham} — 2 ranges, 92 code points.

scx_SignWriting_ranges

constexpr code_range real::detail::scx_SignWriting_ranges[]

inlineconstexpr

Initial value:

{
    {0x1D800, 0x1DA8B},
    {0x1DA9B, 0x1DA9F},
    {0x1DAA1, 0x1DAAF},
  }

\p{scx=SignWriting} — 3 ranges, 672 code points.

scx_Sinhala_ranges

constexpr code_range real::detail::scx_Sinhala_ranges[]

inlineconstexpr

Initial value:

{
    {0x0964, 0x0965},
    {0x0D81, 0x0D83},
    {0x0D85, 0x0D96},
    {0x0D9A, 0x0DB1},
    {0x0DB3, 0x0DBB},
    {0x0DBD, 0x0DBD},
    {0x0DC0, 0x0DC6},
    {0x0DCA, 0x0DCA},
    {0x0DCF, 0x0DD4},
    {0x0DD6, 0x0DD6},
    {0x0DD8, 0x0DDF},
    {0x0DE6, 0x0DEF},
    {0x0DF2, 0x0DF4},
    {0x1CF2, 0x1CF2},
    {0x111E1, 0x111F4},
  }

\p{scx=Sinhala} — 15 ranges, 114 code points.

scx_Sogdian_ranges

constexpr code_range real::detail::scx_Sogdian_ranges[]

inlineconstexpr

Initial value:

{
    {0x0640, 0x0640},
    {0x10F30, 0x10F59},
  }

\p{scx=Sogdian} — 2 ranges, 43 code points.

scx_Sora_Sompeng_ranges

constexpr code_range real::detail::scx_Sora_Sompeng_ranges[]

inlineconstexpr

Initial value:

{
    {0x110D0, 0x110E8},
    {0x110F0, 0x110F9},
  }

\p{scx=Sora_Sompeng} — 2 ranges, 35 code points.

scx_Soyombo_ranges

constexpr code_range real::detail::scx_Soyombo_ranges[]

inlineconstexpr

Initial value:

{
    {0x11A50, 0x11AA2},
  }

\p{scx=Soyombo} — 1 ranges, 83 code points.

scx_Sundanese_ranges

constexpr code_range real::detail::scx_Sundanese_ranges[]

inlineconstexpr

Initial value:

{
    {0x1B80, 0x1BBF},
    {0x1CC0, 0x1CC7},
  }

\p{scx=Sundanese} — 2 ranges, 72 code points.

scx_Sunuwar_ranges

constexpr code_range real::detail::scx_Sunuwar_ranges[]

inlineconstexpr

Initial value:

{
    {0x0300, 0x0301},
    {0x0303, 0x0303},
    {0x030D, 0x030D},
    {0x0310, 0x0310},
    {0x032D, 0x032D},
    {0x0331, 0x0331},
    {0x11BC0, 0x11BE1},
    {0x11BF0, 0x11BF9},
  }

\p{scx=Sunuwar} — 8 ranges, 51 code points.

scx_Syloti_Nagri_ranges

constexpr code_range real::detail::scx_Syloti_Nagri_ranges[]

inlineconstexpr

Initial value:

{
    {0x0964, 0x0965},
    {0x09E6, 0x09EF},
    {0xA800, 0xA82C},
  }

\p{scx=Syloti_Nagri} — 3 ranges, 57 code points.

scx_Syriac_ranges

constexpr code_range real::detail::scx_Syriac_ranges[]

inlineconstexpr

Initial value:

{
    {0x0303, 0x0304},
    {0x0307, 0x0308},
    {0x030A, 0x030A},
    {0x0320, 0x0320},
    {0x0323, 0x0325},
    {0x032D, 0x032E},
    {0x0330, 0x0330},
    {0x060C, 0x060C},
    {0x061B, 0x061C},
    {0x061F, 0x061F},
    {0x0640, 0x0640},
    {0x064B, 0x0655},
    {0x0670, 0x0670},
    {0x0700, 0x070D},
    {0x070F, 0x074A},
    {0x074D, 0x074F},
    {0x0860, 0x086A},
    {0x1DF8, 0x1DF8},
    {0x1DFA, 0x1DFA},
  }

\p{scx=Syriac} — 19 ranges, 119 code points.

scx_Tagalog_ranges

constexpr code_range real::detail::scx_Tagalog_ranges[]

inlineconstexpr

Initial value:

{
    {0x1700, 0x1715},
    {0x171F, 0x171F},
    {0x1735, 0x1736},
  }

\p{scx=Tagalog} — 3 ranges, 25 code points.

scx_Tagbanwa_ranges

constexpr code_range real::detail::scx_Tagbanwa_ranges[]

inlineconstexpr

Initial value:

{
    {0x1735, 0x1736},
    {0x1760, 0x176C},
    {0x176E, 0x1770},
    {0x1772, 0x1773},
  }

\p{scx=Tagbanwa} — 4 ranges, 20 code points.

scx_Tai_Le_ranges

constexpr code_range real::detail::scx_Tai_Le_ranges[]

inlineconstexpr

Initial value:

{
    {0x0300, 0x0301},
    {0x0307, 0x0308},
    {0x030C, 0x030C},
    {0x1040, 0x1049},
    {0x1950, 0x196D},
    {0x1970, 0x1974},
  }

\p{scx=Tai_Le} — 6 ranges, 50 code points.

scx_Tai_Tham_ranges

constexpr code_range real::detail::scx_Tai_Tham_ranges[]

inlineconstexpr

Initial value:

{
    {0x1A20, 0x1A5E},
    {0x1A60, 0x1A7C},
    {0x1A7F, 0x1A89},
    {0x1A90, 0x1A99},
    {0x1AA0, 0x1AAD},
  }

\p{scx=Tai_Tham} — 5 ranges, 127 code points.

scx_Tai_Viet_ranges

constexpr code_range real::detail::scx_Tai_Viet_ranges[]

inlineconstexpr

Initial value:

{
    {0xAA80, 0xAAC2},
    {0xAADB, 0xAADF},
  }

\p{scx=Tai_Viet} — 2 ranges, 72 code points.

scx_Takri_ranges

constexpr code_range real::detail::scx_Takri_ranges[]

inlineconstexpr

Initial value:

{
    {0x0964, 0x0965},
    {0xA830, 0xA839},
    {0x11680, 0x116B9},
    {0x116C0, 0x116C9},
  }

\p{scx=Takri} — 4 ranges, 80 code points.

scx_Tamil_ranges

constexpr code_range real::detail::scx_Tamil_ranges[]

inlineconstexpr

Initial value:

{
    {0x0951, 0x0952},
    {0x0964, 0x0965},
    {0x0B82, 0x0B83},
    {0x0B85, 0x0B8A},
    {0x0B8E, 0x0B90},
    {0x0B92, 0x0B95},
    {0x0B99, 0x0B9A},
    {0x0B9C, 0x0B9C},
    {0x0B9E, 0x0B9F},
    {0x0BA3, 0x0BA4},
    {0x0BA8, 0x0BAA},
    {0x0BAE, 0x0BB9},
    {0x0BBE, 0x0BC2},
    {0x0BC6, 0x0BC8},
    {0x0BCA, 0x0BCD},
    {0x0BD0, 0x0BD0},
    {0x0BD7, 0x0BD7},
    {0x0BE6, 0x0BFA},
    {0x1CDA, 0x1CDA},
    {0xA8F3, 0xA8F3},
    {0x11301, 0x11301},
    {0x11303, 0x11303},
    {0x1133B, 0x1133C},
    {0x11FC0, 0x11FF1},
    {0x11FFF, 0x11FFF},
  }

\p{scx=Tamil} — 25 ranges, 133 code points.

scx_Tangsa_ranges

constexpr code_range real::detail::scx_Tangsa_ranges[]

inlineconstexpr

Initial value:

{
    {0x16A70, 0x16ABE},
    {0x16AC0, 0x16AC9},
  }

\p{scx=Tangsa} — 2 ranges, 89 code points.

scx_Tangut_ranges

constexpr code_range real::detail::scx_Tangut_ranges[]

inlineconstexpr

Initial value:

{
    {0x2FF0, 0x2FFF},
    {0x31EF, 0x31EF},
    {0x16FE0, 0x16FE0},
    {0x17000, 0x187F7},
    {0x18800, 0x18AFF},
    {0x18D00, 0x18D08},
  }

\p{scx=Tangut} — 6 ranges, 6931 code points.

scx_Telugu_ranges

constexpr code_range real::detail::scx_Telugu_ranges[]

inlineconstexpr

Initial value:

{
    {0x0951, 0x0952},
    {0x0964, 0x0965},
    {0x0C00, 0x0C0C},
    {0x0C0E, 0x0C10},
    {0x0C12, 0x0C28},
    {0x0C2A, 0x0C39},
    {0x0C3C, 0x0C44},
    {0x0C46, 0x0C48},
    {0x0C4A, 0x0C4D},
    {0x0C55, 0x0C56},
    {0x0C58, 0x0C5A},
    {0x0C5D, 0x0C5D},
    {0x0C60, 0x0C63},
    {0x0C66, 0x0C6F},
    {0x0C77, 0x0C7F},
    {0x1CDA, 0x1CDA},
    {0x1CF2, 0x1CF2},
  }

\p{scx=Telugu} — 17 ranges, 106 code points.

scx_Thaana_ranges

constexpr code_range real::detail::scx_Thaana_ranges[]

inlineconstexpr

Initial value:

{
    {0x060C, 0x060C},
    {0x061B, 0x061C},
    {0x061F, 0x061F},
    {0x0660, 0x0669},
    {0x0780, 0x07B1},
    {0xFDF2, 0xFDF2},
    {0xFDFD, 0xFDFD},
  }

\p{scx=Thaana} — 7 ranges, 66 code points.

scx_Thai_ranges

constexpr code_range real::detail::scx_Thai_ranges[]

inlineconstexpr

Initial value:

{
    {0x02BC, 0x02BC},
    {0x02D7, 0x02D7},
    {0x0303, 0x0303},
    {0x0331, 0x0331},
    {0x0E01, 0x0E3A},
    {0x0E40, 0x0E5B},
  }

\p{scx=Thai} — 6 ranges, 90 code points.

scx_Tibetan_ranges

constexpr code_range real::detail::scx_Tibetan_ranges[]

inlineconstexpr

Initial value:

{
    {0x0F00, 0x0F47},
    {0x0F49, 0x0F6C},
    {0x0F71, 0x0F97},
    {0x0F99, 0x0FBC},
    {0x0FBE, 0x0FCC},
    {0x0FCE, 0x0FD4},
    {0x0FD9, 0x0FDA},
    {0x3008, 0x300B},
  }

\p{scx=Tibetan} — 8 ranges, 211 code points.

scx_Tifinagh_ranges

constexpr code_range real::detail::scx_Tifinagh_ranges[]

inlineconstexpr

Initial value:

{
    {0x0302, 0x0302},
    {0x0304, 0x0304},
    {0x0307, 0x0307},
    {0x0309, 0x0309},
    {0x2D30, 0x2D67},
    {0x2D6F, 0x2D70},
    {0x2D7F, 0x2D7F},
  }

\p{scx=Tifinagh} — 7 ranges, 63 code points.

scx_Tirhuta_ranges

constexpr code_range real::detail::scx_Tirhuta_ranges[]

inlineconstexpr

Initial value:

{
    {0x0951, 0x0952},
    {0x0964, 0x0965},
    {0x1CF2, 0x1CF2},
    {0xA830, 0xA839},
    {0x11480, 0x114C7},
    {0x114D0, 0x114D9},
  }

\p{scx=Tirhuta} — 6 ranges, 97 code points.

scx_Todhri_ranges

constexpr code_range real::detail::scx_Todhri_ranges[]

inlineconstexpr

Initial value:

{
    {0x0301, 0x0301},
    {0x0304, 0x0304},
    {0x0307, 0x0307},
    {0x0311, 0x0311},
    {0x0313, 0x0313},
    {0x035E, 0x035E},
    {0x105C0, 0x105F3},
  }

\p{scx=Todhri} — 7 ranges, 58 code points.

scx_Toto_ranges

constexpr code_range real::detail::scx_Toto_ranges[]

inlineconstexpr

Initial value:

{
    {0x02BC, 0x02BC},
    {0x1E290, 0x1E2AE},
  }

\p{scx=Toto} — 2 ranges, 32 code points.

scx_Tulu_Tigalari_ranges

constexpr code_range real::detail::scx_Tulu_Tigalari_ranges[]

inlineconstexpr

Initial value:

{
    {0x0CE6, 0x0CEF},
    {0x1CF2, 0x1CF2},
    {0x1CF4, 0x1CF4},
    {0xA830, 0xA835},
    {0xA8F1, 0xA8F1},
    {0x11380, 0x11389},
    {0x1138B, 0x1138B},
    {0x1138E, 0x1138E},
    {0x11390, 0x113B5},
    {0x113B7, 0x113C0},
    {0x113C2, 0x113C2},
    {0x113C5, 0x113C5},
    {0x113C7, 0x113CA},
    {0x113CC, 0x113D5},
    {0x113D7, 0x113D8},
    {0x113E1, 0x113E2},
  }

\p{scx=Tulu_Tigalari} — 16 ranges, 99 code points.

scx_Ugaritic_ranges

constexpr code_range real::detail::scx_Ugaritic_ranges[]

inlineconstexpr

Initial value:

{
    {0x10380, 0x1039D},
    {0x1039F, 0x1039F},
  }

\p{scx=Ugaritic} — 2 ranges, 31 code points.

scx_Vai_ranges

constexpr code_range real::detail::scx_Vai_ranges[]

inlineconstexpr

Initial value:

{
    {0xA500, 0xA62B},
  }

\p{scx=Vai} — 1 ranges, 300 code points.

scx_Vithkuqi_ranges

constexpr code_range real::detail::scx_Vithkuqi_ranges[]

inlineconstexpr

Initial value:

{
    {0x10570, 0x1057A},
    {0x1057C, 0x1058A},
    {0x1058C, 0x10592},
    {0x10594, 0x10595},
    {0x10597, 0x105A1},
    {0x105A3, 0x105B1},
    {0x105B3, 0x105B9},
    {0x105BB, 0x105BC},
  }

\p{scx=Vithkuqi} — 8 ranges, 70 code points.

scx_Wancho_ranges

constexpr code_range real::detail::scx_Wancho_ranges[]

inlineconstexpr

Initial value:

{
    {0x1E2C0, 0x1E2F9},
    {0x1E2FF, 0x1E2FF},
  }

\p{scx=Wancho} — 2 ranges, 59 code points.

scx_Warang_Citi_ranges

constexpr code_range real::detail::scx_Warang_Citi_ranges[]

inlineconstexpr

Initial value:

{
    {0x118A0, 0x118F2},
    {0x118FF, 0x118FF},
  }

\p{scx=Warang_Citi} — 2 ranges, 84 code points.

scx_Yezidi_ranges

constexpr code_range real::detail::scx_Yezidi_ranges[]

inlineconstexpr

Initial value:

{
    {0x060C, 0x060C},
    {0x061B, 0x061B},
    {0x061F, 0x061F},
    {0x0660, 0x0669},
    {0x10E80, 0x10EA9},
    {0x10EAB, 0x10EAD},
    {0x10EB0, 0x10EB1},
  }

\p{scx=Yezidi} — 7 ranges, 60 code points.

scx_Yi_ranges

constexpr code_range real::detail::scx_Yi_ranges[]

inlineconstexpr

Initial value:

{
    {0x3001, 0x3002},
    {0x3008, 0x3011},
    {0x3014, 0x301B},
    {0x30FB, 0x30FB},
    {0xA000, 0xA48C},
    {0xA490, 0xA4C6},
    {0xFF61, 0xFF65},
  }

\p{scx=Yi} — 7 ranges, 1246 code points.

scx_Zanabazar_Square_ranges

constexpr code_range real::detail::scx_Zanabazar_Square_ranges[]

inlineconstexpr

Initial value:

{
    {0x11A00, 0x11A47},
  }

\p{scx=Zanabazar_Square} — 1 ranges, 72 code points.

space_ranges

constexpr code_range real::detail::space_ranges[]

inlineconstexpr

Initial value:

{
    {0x0009, 0x000D},
    {0x001C, 0x0020},
    {0x0085, 0x0085},
    {0x00A0, 0x00A0},
    {0x1680, 0x1680},
    {0x2000, 0x200A},
    {0x2028, 0x2029},
    {0x202F, 0x202F},
    {0x205F, 0x205F},
    {0x3000, 0x3000},
  }

Code-point ranges matched by \s (10 ranges, 29 code points).

utf8_second_byte_bounds_table

constexpr std::array<utf8_second_byte_bounds, 256> real::detail::utf8_second_byte_bounds_table

inlineconstexpr

Initial value:

{
    make_utf8_second_byte_bounds_table()}

First-continuation-byte bounds indexed by lead byte (only 0xC2–0xF4 are consulted).

Default [0x80, 0xBF]; four leads narrow it (Unicode Table 3-7): 0xE0 drops the overlong [0x80, 0x9F], 0xED the surrogates [0xA0, 0xBF], 0xF0 the overlong [0x80, 0x8F], 0xF4 past-U+10FFFF [0x90, 0xBF]. 2-byte overlongs are already excluded by utf8_lead2_set.

Rejects those encodings without decoding, for a per-byte scan (pike.hpp's . fast path) where real::detail::decode_codepoint_strict is too costly.