Struct regex_syntax::hir::translate::TranslatorI

struct TranslatorI<'t, 'p> {
    trans: &'t Translator,
    pattern: &'p str,
}

The internal implementation of a translator.

This type is responsible for carrying around the original pattern string, which is not tied to the internal state of a translator.

A TranslatorI exists for the time it takes to translate a single Ast.

Fields

trans: &'t Translator

pattern: &'p str

Implementations

impl<'t, 'p> TranslatorI<'t, 'p>

fn new(trans: &'t Translator, pattern: &'p str) -> TranslatorI<'t, 'p>

Build a new internal translator.

fn trans(&self) -> &Translator

Return a reference to the underlying translator.

fn push(&self, frame: HirFrame)

Push the given frame on to the call stack.

fn push_char(&self, ch: char)

Push the given literal char on to the call stack.

If the top-most element of the stack is a literal, then the char is appended to the end of that literal. Otherwise, a new literal containing just the given char is pushed to the top of the stack.

fn push_byte(&self, byte: u8)

Push the given literal byte on to the call stack.

If the top-most element of the stack is a literal, then the byte is appended to the end of that literal. Otherwise, a new literal containing just the given byte is pushed to the top of the stack.

fn pop(&self) -> Option<HirFrame>

Pop the top of the call stack. If the call stack is empty, return None.

fn pop_concat_expr(&self) -> Option<Hir>

Pop an HIR expression from the top of the stack for a concatenation.

This returns None if the stack is empty or when a concat frame is seen. Otherwise, it panics if it could not find an HIR expression.

fn pop_alt_expr(&self) -> Option<Hir>

Pop an HIR expression from the top of the stack for an alternation.

This returns None if the stack is empty or when an alternation frame is seen. Otherwise, it panics if it could not find an HIR expression.

fn error(&self, span: Span, kind: ErrorKind) -> Error

Create a new error with the given span and error type.

fn flags(&self) -> Flags

Return a copy of the active flags.

fn set_flags(&self, ast_flags: &Flags) -> Flags

Set the flags of this translator from the flags set in the given AST. Then, return the old flags.

fn ast_literal_to_scalar( &self, lit: &Literal, ) -> Result<Either<char, u8>, Error>

Convert an Ast literal to its scalar representation.

When Unicode mode is enabled, then this always succeeds and returns a char (Unicode scalar value).

When Unicode mode is disabled, then a char will still be returned whenever possible. A byte is returned only when invalid UTF-8 is allowed and when the byte is not ASCII. Otherwise, a non-ASCII byte will result in an error when invalid UTF-8 is not allowed.

fn case_fold_char(&self, span: Span, c: char) -> Result<Option<Hir>, Error>

fn hir_dot(&self, span: Span) -> Result<Hir, Error>

fn hir_assertion(&self, asst: &Assertion) -> Result<Hir, Error>

fn hir_capture(&self, group: &Group, expr: Hir) -> Hir

fn hir_repetition(&self, rep: &Repetition, expr: Hir) -> Hir

fn hir_unicode_class( &self, ast_class: &ClassUnicode, ) -> Result<ClassUnicode, Error>

fn hir_ascii_unicode_class( &self, ast: &ClassAscii, ) -> Result<ClassUnicode, Error>

fn hir_ascii_byte_class(&self, ast: &ClassAscii) -> Result<ClassBytes, Error>

fn hir_perl_unicode_class( &self, ast_class: &ClassPerl, ) -> Result<ClassUnicode, Error>

fn hir_perl_byte_class( &self, ast_class: &ClassPerl, ) -> Result<ClassBytes, Error>

fn convert_unicode_class_error( &self, span: &Span, result: Result<ClassUnicode, Error>, ) -> Result<ClassUnicode, Error>

Converts the given Unicode specific error to an HIR translation error.

The span given should approximate the position at which an error would occur.

fn unicode_fold_and_negate( &self, span: &Span, negated: bool, class: &mut ClassUnicode, ) -> Result<(), Error>

fn bytes_fold_and_negate( &self, span: &Span, negated: bool, class: &mut ClassBytes, ) -> Result<(), Error>

fn class_literal_byte(&self, ast: &Literal) -> Result<u8, Error>

Return a scalar byte value suitable for use as a literal in a byte character class.

Trait Implementations

impl<'t, 'p> Clone for TranslatorI<'t, 'p>

fn clone(&self) -> TranslatorI<'t, 'p>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'t, 'p> Debug for TranslatorI<'t, 'p>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'t, 'p> Visitor for TranslatorI<'t, 'p>

type Output = Hir

The result of visiting an AST.

type Err = Error

An error that visiting an AST might return.

fn finish(self) -> Result<Hir, Error>

All implementors of Visitor must provide a finish method, which yields the result of visiting the AST or an error.

fn visit_pre(&mut self, ast: &Ast) -> Result<(), Error>

This method is called on an Ast before descending into child Ast nodes.

fn visit_post(&mut self, ast: &Ast) -> Result<(), Error>

This method is called on an Ast after descending all of its child Ast nodes.

fn visit_alternation_in(&mut self) -> Result<(), Error>

This method is called between child nodes of an Alternation.

fn visit_class_set_item_pre(&mut self, ast: &ClassSetItem) -> Result<(), Error>

This method is called on every ClassSetItem before descending into child nodes.

fn visit_class_set_item_post(&mut self, ast: &ClassSetItem) -> Result<(), Error>

This method is called on every ClassSetItem after descending into child nodes.

fn visit_class_set_binary_op_pre( &mut self, _op: &ClassSetBinaryOp, ) -> Result<(), Error>

This method is called on every ClassSetBinaryOp before descending into child nodes.

fn visit_class_set_binary_op_in( &mut self, _op: &ClassSetBinaryOp, ) -> Result<(), Error>

This method is called between the left hand and right hand child nodes of a ClassSetBinaryOp.

fn visit_class_set_binary_op_post( &mut self, op: &ClassSetBinaryOp, ) -> Result<(), Error>

This method is called on every ClassSetBinaryOp after descending into child nodes.

fn start(&mut self)

This method is called before beginning traversal of the AST.

fn visit_concat_in(&mut self) -> Result<(), Self::Err>

This method is called between child nodes of a concatenation.