High-level intermediate representation for a regular expression.

A high-level intermediate representation Syntax.Hir for a regular expression.

@[reducible, inline]

abbrev Regex.Syntax.ClassUnicodeRange : Type

Equations

• Regex.Syntax.ClassUnicodeRange = NonemptyInterval Char

@[implicit_reducible]

instance Regex.Syntax.instInhabitedClassUnicodeRange : Inhabited ClassUnicodeRange

Equations

• One or more equations did not get rendered due to their size.

structure Regex.Syntax.ClassUnicode : Type

• set : IntervalSet Char

@[implicit_reducible]

instance Regex.Syntax.instToStringNonemptyIntervalChar : ToString (NonemptyInterval Char)

Equations

• Regex.Syntax.instToStringNonemptyIntervalChar = { toString := fun (r : NonemptyInterval Char) => toString r.fst.val.intAsString ++ toString "-" ++ toString r.snd.val.intAsString }

@[implicit_reducible]

instance Regex.Syntax.instToStringIntervalSetChar : ToString (IntervalSet Char)

Equations

• Regex.Syntax.instToStringIntervalSetChar = { toString := fun (set : IntervalSet Char) => toString "ranges: " ++ toString set.intervals }

@[implicit_reducible]

instance Regex.Syntax.instToStringClassUnicode : ToString ClassUnicode

Equations

• Regex.Syntax.instToStringClassUnicode = { toString := fun (cls : Regex.Syntax.ClassUnicode) => toString cls.set }

@[implicit_reducible]

instance Regex.Syntax.instInhabitedClassUnicode : Inhabited ClassUnicode

see UInt32.isValidChar

Equations

• One or more equations did not get rendered due to their size.

def Regex.Syntax.ClassUnicode.empty : ClassUnicode

Equations

• Regex.Syntax.ClassUnicode.empty = { set := { intervals := #[], isNonOverlapping := ⋯ } }

def Regex.Syntax.ClassUnicode.canonicalize (cls : ClassUnicode) : ClassUnicode

Equations

• cls.canonicalize = { set := IntervalSet.canonicalize cls.set.intervals }

def Regex.Syntax.ClassUnicode.union (cls1 cls2 : ClassUnicode) : ClassUnicode

Equations

• cls1.union cls2 = { set := cls1.set.union cls2.set }

def Regex.Syntax.ClassUnicode.intersection (cls1 cls2 : ClassUnicode) : ClassUnicode

Equations

• cls1.intersection cls2 = { set := cls1.set.intersection cls2.set }

def Regex.Syntax.ClassUnicode.difference (cls1 cls2 : ClassUnicode) : ClassUnicode

Equations

• cls1.difference cls2 = { set := cls1.set.difference cls2.set }

def Regex.Syntax.ClassUnicode.symmetric_difference (cls1 cls2 : ClassUnicode) : ClassUnicode

Equations

• cls1.symmetric_difference cls2 = { set := cls1.set.symmetric_difference cls2.set }

def Regex.Syntax.ClassUnicode.negate (cls : ClassUnicode) : ClassUnicode

Equations

• cls.negate = { set := cls.set.negate }

def Regex.Syntax.ClassUnicode.case_fold (cls : ClassUnicode) : ClassUnicode

Equations

• One or more equations did not get rendered due to their size.

inductive Regex.Syntax.Class : Type

• Unicode : ClassUnicode → Class

  A set of characters represented by Unicode scalar values.

@[implicit_reducible]

instance Regex.Syntax.instToStringClass : ToString Class

Equations

• Regex.Syntax.instToStringClass = { toString := fun (cls : Regex.Syntax.Class) => match cls with | Regex.Syntax.Class.Unicode cls => toString cls }

inductive Regex.Syntax.Look : Type

The high-level intermediate representation for a look-around assertion.

• Start : Look

  Match the beginning of text.

• End : Look

  Match the end of text.

• EndWithOptionalLF : Look

  Match the end of text (before optional newline).

• StartLF : Look

  Match the beginning of a line or the beginning of text.

• EndLF : Look

  Match the end of a line or the end of text.

• StartCRLF : Look

  Match the beginning of a line or the beginning of text.

• EndCRLF : Look

  Match the end of a line or the end of text.

• WordUnicode : Look

  Match a Unicode-aware word boundary.

• WordUnicodeNegate : Look

  Match a Unicode-aware negation of a word boundary.

• WordStartUnicode : Look

  Match the start of a Unicode word boundary.

• WordEndUnicode : Look

  Match the end of a Unicode word boundary.

• WordStartHalfUnicode : Look

  Match the start half of a Unicode word boundary.

• WordEndHalfUnicode : Look

  Match the end half of a Unicode word boundary.

• PreviousMatch : Look

  Match the end of the previous match or start of string.

• ClearMatches : Look

  Clear all matches.

def Regex.Syntax.instBEqLook.beq : Look → Look → Bool

Equations

• Regex.Syntax.instBEqLook.beq x✝ y✝ = (x✝.ctorIdx == y✝.ctorIdx)

@[implicit_reducible]

instance Regex.Syntax.instBEqLook : BEq Look

Equations

• Regex.Syntax.instBEqLook = { beq := Regex.Syntax.instBEqLook.beq }

def Regex.Syntax.Look.toString : Look → String

Equations

• Regex.Syntax.Look.Start.toString = toString "Start"
• Regex.Syntax.Look.End.toString = toString "End"
• Regex.Syntax.Look.EndWithOptionalLF.toString = toString "EndWithOptionalLF"
• Regex.Syntax.Look.StartLF.toString = toString "StartLF"
• Regex.Syntax.Look.EndLF.toString = toString "EndLF"
• Regex.Syntax.Look.StartCRLF.toString = toString "StartCRLF"
• Regex.Syntax.Look.EndCRLF.toString = toString "EndCRLF"
• Regex.Syntax.Look.WordUnicode.toString = toString "WordUnicode"
• Regex.Syntax.Look.WordUnicodeNegate.toString = toString "WordUnicodeNegate"
• Regex.Syntax.Look.WordStartUnicode.toString = toString "WordStartUnicode"
• Regex.Syntax.Look.WordEndUnicode.toString = toString "WordEndUnicode"
• Regex.Syntax.Look.WordStartHalfUnicode.toString = toString "WordStartHalfUnicode"
• Regex.Syntax.Look.WordEndHalfUnicode.toString = toString "WordEndHalfUnicode"
• Regex.Syntax.Look.PreviousMatch.toString = toString "PreviousMatch"
• Regex.Syntax.Look.ClearMatches.toString = toString "ClearMatches"

@[implicit_reducible]

instance Regex.Syntax.instToStringLook : ToString Look

Equations

• Regex.Syntax.instToStringLook = { toString := Regex.Syntax.Look.toString }

structure Regex.Syntax.Properties : Type

A type that collects various properties of an HIR value.

• minimum_len : Option UInt32
• maximum_len : Option UInt32

@[implicit_reducible]

instance Regex.Syntax.instInhabitedProperties : Inhabited Properties

Equations

• Regex.Syntax.instInhabitedProperties = { default := { minimum_len := none, maximum_len := none } }

structure Regex.Syntax.Flags : Type

A translator's representation of a regular expression's flags at any given moment in time.

• case_insensitive : Option Bool
• multi_line : Option Bool
• dot_matches_new_line : Option Bool
• swap_greed : Option Bool
• crlf : Option Bool
• extended : Option Grammar.ExtendedKind

@[implicit_reducible]

instance Regex.Syntax.instInhabitedFlags : Inhabited Flags

Equations

• Regex.Syntax.instInhabitedFlags = { default := { case_insensitive := none, multi_line := none, dot_matches_new_line := none, swap_greed := none, crlf := none, extended := none } }

@[implicit_reducible]

instance Regex.Syntax.instToStringFlags : ToString Flags

Equations

• One or more equations did not get rendered due to their size.

inductive Regex.Syntax.Lookaround : Type

The high-level intermediate representation for a look-around assertion.

• PositiveLookahead : Hir → Lookaround
• NegativeLookahead : Hir → Lookaround
• PositiveLookbehind : Nat → Hir → Lookaround
• NegativeLookbehind : Nat → Hir → Lookaround

inductive Regex.Syntax.Repetition : Type

A concatenation of regular expressions.

• mk (min : Nat) (max : Option Nat) (greedy possessive : Bool) (sub : Hir) : Repetition

inductive Regex.Syntax.Capture : Type

The high-level intermediate representation for a capturing group.

• mk (index : Nat) (name : Option String) (sub : Hir) : Capture

inductive Regex.Syntax.Alternation : Type

• mk (fst snd : Hir) (tail : Array Hir) : Alternation

inductive Regex.Syntax.HirKind : Type

The underlying kind of an arbitrary [Hir] expression.

• Empty : HirKind

  The empty regular expression, which matches everything, including the empty string.

• Literal : Char → HirKind

  A literal string that matches exactly these bytes.

• BackRef : Bool → Nat → HirKind

  A backrefence to a capturung group.

• Class : Syntax.Class → HirKind

  A single character class that matches any of the characters in the class.

• Look : Syntax.Look → HirKind

  A look-around assertion. A look-around match always has zero length.

• Lookaround : Syntax.Lookaround → HirKind

  A complex look-around assertion.

• Repetition : Syntax.Repetition → HirKind

  A repetition operation applied to a sub-expression.

• Capture : Syntax.Capture → HirKind

  A capturing group, which contains a sub-expression.

• Concat : Array Hir → HirKind

  A concatenation of expressions.

• Alternation : Syntax.Alternation → HirKind

  An alternation of expressions.

inductive Regex.Syntax.Hir : Type

A high-level intermediate representation (HIR) for a regular expression.

• mk (kind : HirKind) (props : Properties) : Hir

@[implicit_reducible]

instance Regex.Syntax.instInhabitedHir : Inhabited Hir

Equations

• Regex.Syntax.instInhabitedHir = { default := Regex.Syntax.Hir.mk Regex.Syntax.HirKind.Empty default }

def Regex.Syntax.Hir.kind (hir : Hir) : HirKind

Equations

• (Regex.Syntax.Hir.mk kind props).kind = kind

theorem Regex.Syntax.Hir.sizeOfKindOfHir (hir : Hir) : sizeOf hir.kind < sizeOf hir

def Regex.Syntax.Hir.properties (hir : Hir) : Properties

Equations

• (Regex.Syntax.Hir.mk kind props).properties = props

def Regex.Syntax.Hir.toProperties (kind : HirKind) : Properties

Equations

• Regex.Syntax.Hir.toProperties (Regex.Syntax.HirKind.Class (Regex.Syntax.Class.Unicode cls)) = { minimum_len := if cls.set.intervals.size > 0 then some 1 else none, maximum_len := none }
• Regex.Syntax.Hir.toProperties kind = default

@[irreducible]

def Regex.Syntax.Hir.toString (hir : Hir) (col : Nat) : String

Equations

• One or more equations did not get rendered due to their size.

@[irreducible]

def Regex.Syntax.Hir.fold {α : Type u_1} [Inhabited α] [ToString α] (hir : Hir) (f : α → Hir → α) (init : α) : α

Equations

• One or more equations did not get rendered due to their size.
• (Regex.Syntax.Hir.mk Regex.Syntax.HirKind.Empty props).fold f init = f (f init (Regex.Syntax.Hir.mk Regex.Syntax.HirKind.Empty props)) (Regex.Syntax.Hir.mk Regex.Syntax.HirKind.Empty props)

def Regex.Syntax.Hir.containsLookaround (hir : Hir) : Bool

check if an hir contains .Lookaround

Equations

• One or more equations did not get rendered due to their size.

@[implicit_reducible]

instance Regex.Syntax.instToStringHir : ToString Hir

Equations

• Regex.Syntax.instToStringHir = { toString := fun (hir : Regex.Syntax.Hir) => hir.toString 0 }

inductive Regex.Syntax.Dot : Type

A type describing the different flavors of ..

• AnyChar : Dot

  Matches the UTF-8 encoding of any Unicode scalar value. This is equivalent to (?su:.) and also \p{any}.

• AnyCharExceptLF : Dot

  Matches the UTF-8 encoding of any Unicode scalar value except for \n. This is equivalent to (?u-s:.) and also [\p{any}--\n].

• AnyCharExceptCRLF : Dot

  Matches the UTF-8 encoding of any Unicode scalar value except for \r and \n. This is equivalent to (?uR-s:.) and also [\p{any}--\r\n].

def Regex.Syntax.dot (dot : Dot) : Hir

Equations

• One or more equations did not get rendered due to their size.

inductive Regex.Syntax.HirFrame : Type

An HirFrame is a single stack frame, represented explicitly, which is created for each item in the Ast that we traverse.

• Expr : Hir → HirFrame
• Literal : Char → HirFrame
• BackRef : Bool → Nat → HirFrame
• ClassUnicode : Syntax.ClassUnicode → HirFrame
• Repetition : HirFrame
• Group (old_flags : Flags) : HirFrame
• Concat : HirFrame
• Alternation : HirFrame

def Regex.Syntax.HirFrame.toString : HirFrame → String

Equations

• (Regex.Syntax.HirFrame.Expr hir).toString = toString "Expr '" ++ toString hir ++ toString "'"
• (Regex.Syntax.HirFrame.Literal c).toString = toString "Literal " ++ toString c
• (Regex.Syntax.HirFrame.BackRef f n).toString = toString "BackRef " ++ toString (if f = true then "case_insensitive" else "") ++ toString " " ++ toString n
• (Regex.Syntax.HirFrame.ClassUnicode cls).toString = toString "ClassUnicode cls set size " ++ toString cls.set.intervals.size
• Regex.Syntax.HirFrame.Repetition.toString = "Repetition"
• (Regex.Syntax.HirFrame.Group flags).toString = toString "Group " ++ toString flags
• Regex.Syntax.HirFrame.Concat.toString = "Concat"
• Regex.Syntax.HirFrame.Alternation.toString = "Alternation"

def Regex.Syntax.HirFrame.unwrap_expr (frame : HirFrame) : Except String Hir

Equations

• (Regex.Syntax.HirFrame.Expr expr).unwrap_expr = Except.ok expr
• (Regex.Syntax.HirFrame.Literal c).unwrap_expr = Except.ok (Regex.Syntax.Hir.mk (Regex.Syntax.HirKind.Literal c) default)
• (Regex.Syntax.HirFrame.BackRef f n).unwrap_expr = Except.ok (Regex.Syntax.Hir.mk (Regex.Syntax.HirKind.BackRef f n) default)
• frame.unwrap_expr = Except.error "unwrap_expr, Literal or Expr expected"

def Regex.Syntax.HirFrame.unwrap_class_unicode (frame : HirFrame) : Except String Syntax.ClassUnicode

Assert that the current stack frame is a Unicode class expression and return it.

Equations

• (Regex.Syntax.HirFrame.ClassUnicode cls).unwrap_class_unicode = Except.ok cls
• frame.unwrap_class_unicode = Except.error "unwrap_repetition, Repetition expected"

def Regex.Syntax.HirFrame.unwrap_repetition (frame : HirFrame) : Except String Unit

Assert that the current stack frame is a repetition.

Equations

• Regex.Syntax.HirFrame.Repetition.unwrap_repetition = Except.ok ()
• frame.unwrap_repetition = Except.error "unwrap_repetition, Repetition expected"

def Regex.Syntax.HirFrame.unwrap_group (frame : HirFrame) : Except String Flags

Assert that the current stack frame is a group.

Equations

• (Regex.Syntax.HirFrame.Group flags).unwrap_group = Except.ok flags
• frame.unwrap_group = Except.error "unwrap_repetition, Repetition expected"

@[implicit_reducible]

instance Regex.Syntax.instToStringHirFrame : ToString HirFrame

Equations

• Regex.Syntax.instToStringHirFrame = { toString := Regex.Syntax.HirFrame.toString }