• Top
  • Documentation
  • Books
  • Recursion-and-induction
  • Boolean-reasoning
  • Projects
    • Apt
    • Acre
      • Acre-internals
      • Parse-and-match-regex
      • Match-regex
      • Parse
      • Matchresult->matchedp
      • Match
    • Milawa
    • Smtlink
    • Abnf
    • Vwsim
    • Isar
    • Wp-gen
    • Dimacs-reader
    • Legacy-defrstobj
    • Prime-field-constraint-systems
    • Proof-checker-array
    • Soft
    • Rp-rewriter
    • Farray
    • Instant-runoff-voting
    • Imp-language
    • Sidekick
    • Leftist-trees
    • Taspi
    • Bitcoin
    • Des
    • Ethereum
    • Sha-2
    • Yul
    • Zcash
    • Proof-checker-itp13
    • Bigmem
    • Regex
    • ACL2-programming-language
    • Java
    • C
    • Jfkr
    • X86isa
    • Equational
    • Cryptography
    • Where-do-i-place-my-book
    • Json
    • Built-ins
    • Execloader
    • Solidity
    • Paco
    • Concurrent-programs
  • Debugging
  • Std
  • Proof-automation
  • Macro-libraries
  • ACL2
  • Interfacing-tools
  • Hardware-verification
  • Software-verification
  • Testing-utilities
  • Math

• Acre

Match-regex

Perform regular expression matching on a string.

Signature

(match-regex regex x &key (case-insens 'nil)) → match

Arguments

regex — Regular expression to match.
    Guard (regex-p regex).

x — String to match against.
    Guard (stringp x).

case-insens — Match case-insensitively.
    Guard (booleanp case-insens).

Returns

match — Result of matching, including whether it matched, which part matched, and capture group matches.
    Type (matchresult-p match).

Definitions and Theorems

Function: match-regex-fn

(defun
 match-regex-fn (regex x case-insens)
 (declare (xargs :guard (and (regex-p regex)
                             (stringp x)
                             (booleanp case-insens))))
 (let
  ((__function__ 'match-regex))
  (declare (ignorable __function__))
  (b*
   ((ans
      (match-regex-locs regex x 0
                        (make-matchmode :case-insens case-insens))))
   ans)))

Theorem: matchresult-p-of-match-regex

(defthm matchresult-p-of-match-regex
        (b* ((match (match-regex-fn regex x case-insens)))
            (matchresult-p match))
        :rule-classes :rewrite)

Theorem: matchresult-in-bounds-of-match-regex

(defthm matchresult-in-bounds-of-match-regex
        (b* ((?match (match-regex-fn regex x case-insens)))
            (matchresult-in-bounds match)))

Theorem: matchresult->str-of-match-regex

(defthm matchresult->str-of-match-regex
        (b* ((?match (match-regex-fn regex x case-insens)))
            (equal (matchresult->str match)
                   (lstrfix x))))

Theorem: match-regex-fn-of-regex-fix-regex

(defthm match-regex-fn-of-regex-fix-regex
        (equal (match-regex-fn (regex-fix regex)
                               x case-insens)
               (match-regex-fn regex x case-insens)))

Theorem: match-regex-fn-regex-equiv-congruence-on-regex

(defthm match-regex-fn-regex-equiv-congruence-on-regex
        (implies (regex-equiv regex regex-equiv)
                 (equal (match-regex-fn regex x case-insens)
                        (match-regex-fn regex-equiv x case-insens)))
        :rule-classes :congruence)

Theorem: match-regex-fn-of-str-fix-x

(defthm match-regex-fn-of-str-fix-x
        (equal (match-regex-fn regex (acl2::str-fix x)
                               case-insens)
               (match-regex-fn regex x case-insens)))

Theorem: match-regex-fn-streqv-congruence-on-x

(defthm match-regex-fn-streqv-congruence-on-x
        (implies (acl2::streqv x x-equiv)
                 (equal (match-regex-fn regex x case-insens)
                        (match-regex-fn regex x-equiv case-insens)))
        :rule-classes :congruence)

Theorem: match-regex-fn-of-bool-fix-case-insens

(defthm match-regex-fn-of-bool-fix-case-insens
        (equal (match-regex-fn regex x (acl2::bool-fix case-insens))
               (match-regex-fn regex x case-insens)))

Theorem: match-regex-fn-iff-congruence-on-case-insens

(defthm match-regex-fn-iff-congruence-on-case-insens
        (implies (iff case-insens case-insens-equiv)
                 (equal (match-regex-fn regex x case-insens)
                        (match-regex-fn regex x case-insens-equiv)))
        :rule-classes :congruence)