real::detail::static_storage< Pat, F > Struct Template Reference

Storage policy backing real::static_regex: compile-time, stateless. More...

#include <storage.hpp>

Collaboration diagram for real::detail::static_storage< Pat, F >:

Classes
struct	measured
	Everything build yields that is not a range, measured in one evaluation: each build() re-runs the compiler front end, against the constexpr step budget and compile time. More...

Public Types
using	name_owner = borrowed_names
	Name-resolution owner: empty, the tables having static storage duration.
using	slot_storage = static_vec< std::size_t, slot_count >
	Capture-slot storage, sized exactly to the program's slot count (no heap).
using	state_type = static_pike_scratch< scratch_code_tier(code_size), slot_count, wants_inner_literal >
	This pattern's VM scratch — nothing but static_pike_scratch at this pattern's dimensions, so two patterns of the same shape name the same type.

Public Member Functions
constexpr const program_view &	view () const
	Returns a non-owning view of the compile-time program, by reference.
constexpr std::string_view	pattern () const
	Returns the pattern text.
constexpr flags	compiled_flags () const
	Returns the flag set in force: constructor flags, plus a leading global-flags group's additions, minus its -removal – see real::basic_regex::compile_flags.

Static Public Attributes
static constexpr bool	is_compile_time {true}
	Selects the default constructor.
static constexpr bool	viable {requires { typename std::bool_constant<(build(), true)>; }}
	Whether build is a constant expression for this pattern.
static constexpr measured	survey
	The one measuring evaluation. Never emitted: nothing takes its address, and every member below reads it at compile time only.
static constexpr flags	effective_flags
	The flag set in force: F plus a leading group's additions, minus its removals, as dynamic_storage::compile reports it. Parsed once.
static constexpr pattern_hints	hints {survey.hints}
	Search hints.
static constexpr std::size_t	code_size {survey.code_size}
	Instruction count.
static constexpr std::size_t	class_count {survey.class_count}
	Distinct class count.
static constexpr std::size_t	name_count {survey.name_count}
	Named-group count.
static constexpr std::size_t	cp_class_count {survey.cp_class_count}
	Code-point class count (klass_cp).
static constexpr std::size_t	cp_range_count {survey.cp_range_count}
	Total code-point ranges.
static constexpr std::uint16_t	slot_count {survey.slot_count}
	2*(groups+1).
static constexpr std::array< instr, code_size >	code {take<instr, code_size>(build().code)}
	The program.
static constexpr std::array< char_class, class_count >	classes
	Interned classes.
static constexpr std::array< named_group, name_count >	names
	Named groups.
static constexpr std::array< cp_class, cp_class_count >	cp_classes
	Code-point classes.
static constexpr std::array< code_range, cp_range_count >	cp_ranges
	Flat range buffer.
static constexpr std::array< std::uint8_t,(class_count==0 ? 1 :class_count) *256 >	class_tables
	Flat byte-class membership tables, built at compile time: class_tables[i*256 + b]. Reads classes rather than calling build again, which would pass clang's constexpr step budget.
static constexpr std::array< std::uint8_t,(cp_class_count==0 ? 1 :cp_class_count) *256 >	cp_ascii_tables
	Flat ASCII tables for the code-point classes: cp_ascii_tables[i*256 + b].
static constexpr std::array< std::uint64_t,(cp_class_count==0 ? 1 :cp_class_count) *30 >	cp_page_tables
	Two-byte-range membership bitmaps (U+0080..U+07FF) for the code-point classes, 30 words each.
static constexpr bool	wants_inner_literal
	Whether the inner-literal route is worth compiling into this pattern's run().

Static Private Member Functions
static constexpr dynamic_program	build ()
	Returns the freshly built program (used for both measuring and filling).
template<typename T , std::size_t N, typename Vec >
static constexpr std::array< T, N >	take (const Vec &source)
	Copies the first N elements of v into a fixed array.

Static Private Attributes
static constexpr program_view	view_
	The view itself, materialised once at compile time. See view.

Detailed Description

template<fixed_string Pat, flags F = flags::none>
struct real::detail::static_storage< Pat, F >

Storage policy backing real::static_regex: compile-time, stateless.

Every array is a static constexpr member sized exactly by a measuring pass over the same compilation, so a static_regex object is stateless (sizeof 1) and matching allocates nothing.

Template Parameters

Pat	The pattern, as a real::fixed_string non-type parameter.
F	Compilation flags.

Member Typedef Documentation

state_type

template<fixed_string Pat, flags F = flags::none>

using real::detail::static_storage< Pat, F >::state_type = static_pike_scratch<scratch_code_tier (code_size), slot_count, wants_inner_literal>

This pattern's VM scratch — nothing but static_pike_scratch at this pattern's dimensions, so two patterns of the same shape name the same type.

Nothing here may depend on the pattern's value: the table addresses travel in real::detail::program_view (see 10.1 The inlining budget).

Member Function Documentation

build()

template<fixed_string Pat, flags F = flags::none>

static constexpr dynamic_program real::detail::static_storage< Pat, F >::build ( )

inlinestaticconstexprprivate

Returns the freshly built program (used for both measuring and filling).

Runs only at compile time (a static_regex instantiation), so it is invisible to the runtime coverage report; it is exercised by the constexpr static_asserts in tests/test_static.cpp and tests/test_constexpr.cpp.

Returns

The compiled program.

compiled_flags()

template<fixed_string Pat, flags F = flags::none>

constexpr flags real::detail::static_storage< Pat, F >::compiled_flags ( ) const

inlineconstexpr

Returns the flag set in force: constructor flags, plus a leading global-flags group's additions, minus its -removal – see real::basic_regex::compile_flags.

Returns

The effective flag set.

pattern()

template<fixed_string Pat, flags F = flags::none>

constexpr std::string_view real::detail::static_storage< Pat, F >::pattern ( ) const

inlineconstexpr

Returns the pattern text.

Returns

A view of the compile-time pattern string.

take()

template<fixed_string Pat, flags F = flags::none>

template<typename T , std::size_t N, typename Vec >

static constexpr std::array< T, N > real::detail::static_storage< Pat, F >::take ( const Vec &  source )

inlinestaticconstexprprivate

Copies the first N elements of v into a fixed array.

Template Parameters

T	Element type.
N	Exact size (measured from build).
Vec	Source container type.

Parameters

[in]

source

The source vector.

Returns

The exactly-sized array.

view()

template<fixed_string Pat, flags F = flags::none>

constexpr const program_view & real::detail::static_storage< Pat, F >::view ( ) const

inlineconstexpr

Returns a non-owning view of the compile-time program, by reference.

Every field is a compile-time constant, so a reference costs nothing where a by-value return would copy the view per search(), a large share of a short search.

Returns

A reference to the single compile-time view; it outlives every caller.

Member Data Documentation

class_tables

template<fixed_string Pat, flags F = flags::none>

constexpr std::array< std::uint8_t, (class_count == 0 ? 1 : class_count) * 256 > real::detail::static_storage< Pat, F >::class_tables

staticconstexpr

Initial value:

{[] {
                                                                                                               std::array < std::uint8_t, (class_count == 0 ? 1 : class_count) * 256 > t {};
                                                                                                               for (std::size_t i = 0; i < class_count; ++i) {
                                                                                                                 for (std::size_t b = 0; b < 256; ++b) {
                                                                                                                   t[(i * 256) + b] = classes[i].test(static_cast<std::uint8_t>(b)) ? std::uint8_t {1} : std::uint8_t {0};
                                                                                                                 }
                                                                                                               }
                                                                                                               return t;
                                                                                                             }()}

Flat byte-class membership tables, built at compile time: class_tables[i*256 + b]. Reads classes rather than calling build again, which would pass clang's constexpr step budget.

classes

template<fixed_string Pat, flags F = flags::none>

constexpr std::array<char_class, class_count> real::detail::static_storage< Pat, F >::classes

staticconstexpr

Initial value:

=
        take<char_class, class_count>(build().classes)

Interned classes.

cp_ascii_tables

template<fixed_string Pat, flags F = flags::none>

constexpr std::array< std::uint8_t, (cp_class_count == 0 ? 1 : cp_class_count) * 256 > real::detail::static_storage< Pat, F >::cp_ascii_tables

staticconstexpr

Initial value:

{[] {
                         std::array < std::uint8_t, (cp_class_count == 0 ? 1 : cp_class_count) * 256 > t {};
                         for (std::size_t i = 0; i < cp_class_count; ++i) {
                           for (std::size_t b = 0; b < 256; ++b) {
                             t[(i * 256) + b] = cp_classes[i].ascii.test(static_cast<std::uint8_t>(b)) ? std::uint8_t {1}
                                                                                       : std::uint8_t {0};
                           }
                         }
                         return t;
                       }()}

Flat ASCII tables for the code-point classes: cp_ascii_tables[i*256 + b].

cp_classes

template<fixed_string Pat, flags F = flags::none>

constexpr std::array<cp_class, cp_class_count> real::detail::static_storage< Pat, F >::cp_classes

staticconstexpr

Initial value:

=
        take<cp_class, cp_class_count>(build().cp_classes)

Code-point classes.

cp_page_tables

template<fixed_string Pat, flags F = flags::none>

constexpr std::array< std::uint64_t, (cp_class_count == 0 ? 1 : cp_class_count) * 30 > real::detail::static_storage< Pat, F >::cp_page_tables

staticconstexpr

Initial value:

{[] {
                        std::array < std::uint64_t, (cp_class_count == 0 ? 1 : cp_class_count) * 30 > t {};
                        for (std::size_t i = 0; i < cp_class_count; ++i) {
                          for (std::uint32_t k = 0; k < cp_classes[i].range_count; ++k) {
                            const code_range& r {cp_ranges[cp_classes[i].range_begin + k]};
                            if (r.lo > 0x7FFU) {
                              break; 
                            }
                            const std::uint32_t lo {r.lo < 0x80U ? 0x80U : r.lo};
                            const std::uint32_t hi {r.hi > 0x7FFU ? 0x7FFU : r.hi};
                            for (std::uint32_t c = lo; c <= hi; ++c) {
                              const std::uint32_t bit {c - 0x80U};
                              t[(i * 30) + (bit >> 6U)] |= std::uint64_t {1} << (bit & 63U);
                            }
                          }
                        }
                        return t;
                      }()}

Two-byte-range membership bitmaps (U+0080..U+07FF) for the code-point classes, 30 words each.

cp_ranges

template<fixed_string Pat, flags F = flags::none>

constexpr std::array<code_range, cp_range_count> real::detail::static_storage< Pat, F >::cp_ranges

staticconstexpr

Initial value:

=
        take<code_range, cp_range_count>(build().cp_ranges)

Flat range buffer.

effective_flags

template<fixed_string Pat, flags F = flags::none>

constexpr flags real::detail::static_storage< Pat, F >::effective_flags

staticconstexpr

Initial value:

{[] {
                                                                   const auto parsed {detail::parse(Pat.view(), F)};
                                                                   return flags_without(F | parsed.inline_flags,
                                                                                        parsed.inline_removed);
                                                                 }()}

The flag set in force: F plus a leading group's additions, minus its removals, as dynamic_storage::compile reports it. Parsed once.

names

template<fixed_string Pat, flags F = flags::none>

constexpr std::array<named_group, name_count> real::detail::static_storage< Pat, F >::names

staticconstexpr

Initial value:

=
        take<named_group, name_count>(build().names)

Named groups.

survey

template<fixed_string Pat, flags F = flags::none>

constexpr measured real::detail::static_storage< Pat, F >::survey

staticconstexpr

Initial value:

{[] {
                                          const dynamic_program p {build()};
                                          return measured {.hints          = p.hints,
                                                           .code_size      = p.code.size(),
                                                           .class_count    = p.classes.size(),
                                                           .name_count     = p.names.size(),
                                                           .cp_class_count = p.cp_classes.size(),
                                                           .cp_range_count = p.cp_ranges.size(),
                                                           .slot_count     = p.slot_count};
                                        }()}

The one measuring evaluation. Never emitted: nothing takes its address, and every member below reads it at compile time only.

viable

template<fixed_string Pat, flags F = flags::none>

constexpr bool real::detail::static_storage< Pat, F >::viable {requires { typename std::bool_constant<(build(), true)>; }}

staticconstexpr

Whether build is a constant expression for this pattern.

A requires expression is a SFINAE context: forming the bool_constant template argument needs a constant expression, and build throwing makes it one substitution failure rather than a hard error. That is what lets viable be asked instead of crashed into.

view_

template<fixed_string Pat, flags F = flags::none>

constexpr program_view real::detail::static_storage< Pat, F >::view_

staticconstexprprivate

Initial value:

{.code = code,
                                           .classes           = classes,
                                           .names             = names,
                                           .lookarounds       = {}, 
                                           .cp_classes        = cp_classes,
                                           .cp_ranges         = cp_ranges,
                                                                    
                                                                    
                                           .prefix_code       = {},
                                           .prefix_classes    = {},
                                           .prefix_cp_classes = {},
                                           .prefix_cp_ranges  = {},
                                           .slot_count        = slot_count,
                                           .byte_mode         = has_flag(effective_flags, flags::bytes),
                                           .unicode_word      = !has_flag(effective_flags, flags::bytes) && !has_flag(effective_flags, flags::ascii),
                                           .hints             = hints,
                                           .immut             = nullptr,
                                           
                                           
                                           .class_tables      = class_tables.data(),
                                           .cp_ascii_tables   = cp_ascii_tables.data(),
                                           .cp_page_tables    = cp_page_tables.data()}

The view itself, materialised once at compile time. See view.

wants_inner_literal

template<fixed_string Pat, flags F = flags::none>

constexpr bool real::detail::static_storage< Pat, F >::wants_inner_literal

staticconstexpr

Initial value:

{hints.inner_literal_len > 0 && hints.inner_literal_prefix >= 1
                                                 && !hints.fixed_shape}

Whether the inner-literal route is worth compiling into this pattern's run().

A required literal at offset >= 1 is necessary, not sufficient: a fixed_shape pattern already has an arithmetic-width scan and gains nothing, while others gain orders of magnitude on a subject with no match. Decided here, not at run time: compiling the block into run() costs patterns that never enter it.

---

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

• include/real/storage.hpp