about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/pcre2el-20161120.2103/pcre2el.el
diff options
context:
space:
mode:
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/pcre2el-20161120.2103/pcre2el.el')
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/pcre2el-20161120.2103/pcre2el.el3157
1 files changed, 0 insertions, 3157 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/pcre2el-20161120.2103/pcre2el.el b/configs/shared/emacs/.emacs.d/elpa/pcre2el-20161120.2103/pcre2el.el
deleted file mode 100644
index bea8effe825d..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/pcre2el-20161120.2103/pcre2el.el
+++ /dev/null
@@ -1,3157 +0,0 @@
-;;; pcre2el.el --- regexp syntax converter -*- lexical-binding: t -*-
-
-;; Copyright (C) 2012-2015 Jon Oddie <jonxfield@gmail.com>
-
-;; Author:			joddie <jonxfield at gmail.com>
-;; Hacked additionally by:	opensource at hardakers dot net
-;; Created:			14 Feb 2012
-;; Updated:			13 December 2015
-;; Version:                     1.8
-;; Package-Version: 20161120.2103
-;; Url:                         https://github.com/joddie/pcre2el
-;; Package-Requires:            ((emacs "24") (cl-lib "0.3"))
-
-;; This file is NOT part of GNU Emacs.
-
-;; This program is free software: you can redistribute it and/or
-;; modify it under the terms of the GNU General Public License as
-;; published by the Free Software Foundation, either version 3 of the
-;; License, or (at your option) any later version.
-;;
-;; This program is distributed in the hope that it will be useful, but
-;; WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;; General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see `http://www.gnu.org/licenses/'.
-
-;; This file incorporates work covered by the following copyright and
-;; permission notice:
-;;
-;; Copyright (c) 1993-2002 Richard Kelsey and Jonathan Rees
-;; Copyright (c) 1994-2002 by Olin Shivers and Brian D. Carlstrom.
-;; Copyright (c) 1999-2002 by Martin Gasbichler.
-;; Copyright (c) 2001-2002 by Michael Sperber.
-;; All rights reserved.
-;;
-;; Redistribution and use in source and binary forms, with or without
-;; modification, are permitted provided that the following conditions
-;; are met: 1. Redistributions of source code must retain the above
-;; copyright notice, this list of conditions and the following
-;; disclaimer. 2. Redistributions in binary form must reproduce the
-;; above copyright notice, this list of conditions and the following
-;; disclaimer in the documentation and/or other materials provided
-;; with the distribution. 3. The name of the authors may not be used
-;; to endorse or promote products derived from this software without
-;; specific prior written permission.
-;;
-;; THIS SOFTWARE IS PROVIDED BY THE AUTHORS "AS IS" AND ANY EXPRESS OR
-;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
-;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
-;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-;;; Commentary:
-
-;; 1 Overview
-;; ==========
-
-;;   `pcre2el' or `rxt' (RegeXp Translator or RegeXp Tools) is a utility
-;;   for working with regular expressions in Emacs, based on a
-;;   recursive-descent parser for regexp syntax. In addition to converting
-;;   (a subset of) PCRE syntax into its Emacs equivalent, it can do the
-;;   following:
-
-;;   - convert Emacs syntax to PCRE
-;;   - convert either syntax to `rx', an S-expression based regexp syntax
-;;   - untangle complex regexps by showing the parse tree in `rx' form and
-;;     highlighting the corresponding chunks of code
-;;   - show the complete list of strings (productions) matching a regexp,
-;;     provided the list is finite
-;;   - provide live font-locking of regexp syntax (so far only for Elisp
-;;     buffers -- other modes on the TODO list)
-
-
-;; 2 Usage
-;; =======
-
-;;   Enable `rxt-mode' or its global equivalent `rxt-global-mode' to get
-;;   the default key-bindings. There are three sets of commands: commands
-;;   that take a PCRE regexp, commands which take an Emacs regexp, and
-;;   commands that try to do the right thing based on the current
-;;   mode. Currently, this means Emacs syntax in `emacs-lisp-mode' and
-;;   `lisp-interaction-mode', and PCRE syntax everywhere else.
-
-;;   The default key bindings all begin with `C-c /' and have a mnemonic
-;;   structure: `C-c / <source> <target>', or just `C-c / <target>' for the
-;;   "do what I mean" commands. The complete list of key bindings is given
-;;   here and explained in more detail below:
-
-;;   - "Do-what-I-mean" commands:
-;;     `C-c / /': `rxt-explain'
-;;     `C-c / c': `rxt-convert-syntax'
-;;     `C-c / x': `rxt-convert-to-rx'
-;;     `C-c / '': `rxt-convert-to-strings'
-
-;;   - Commands that work on a PCRE regexp:
-;;     `C-c / p e': `rxt-pcre-to-elisp'
-;;     `C-c / %': `pcre-query-replace-regexp'
-;;     `C-c / p x': `rxt-pcre-to-rx'
-;;     `C-c / p '': `rxt-pcre-to-strings'
-;;     `C-c / p /': `rxt-explain-pcre'
-
-;;   - Commands that work on an Emacs regexp:
-;;     `C-c / e /': `rxt-explain-elisp'
-;;     `C-c / e p': `rxt-elisp-to-pcre'
-;;     `C-c / e x': `rxt-elisp-to-rx'
-;;     `C-c / e '': `rxt-elisp-to-strings'
-;;     `C-c / e t': `rxt-toggle-elisp-rx'
-;;     `C-c / t': `rxt-toggle-elisp-rx'
-
-
-;; 2.1 Interactive input and output
-;; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-;;   When used interactively, the conversion commands can read a regexp
-;;   either from the current buffer or from the minibuffer. The output is
-;;   displayed in the minibuffer and copied to the kill-ring.
-
-;;   - When called with a prefix argument (`C-u'), they read a regular
-;;     expression from the minibuffer literally, without further processing
-;;     -- meaning there's no need to double the backslashes if it's an
-;;     Emacs regexp.  This is the same way commands like
-;;     `query-replace-regexp' read input.
-
-;;   - When the region is active, they use they the region contents, again
-;;     literally (without any translation of string syntax).
-
-;;   - With neither a prefix arg nor an active region, the behavior depends
-;;     on whether the command expects an Emacs regexp or a PCRE one.
-
-;;     Commands that take an Emacs regexp behave like `C-x C-e': they
-;;     evaluate the sexp before point (which could be simply a string
-;;     literal) and use its value. This is designed for use in Elisp
-;;     buffers. As a special case, if point is *inside* a string, it's
-;;     first moved to the string end, so in practice they should work as
-;;     long as point is somewhere within the regexp literal.
-
-;;     Commands that take a PCRE regexp try to read a Perl-style delimited
-;;     regex literal *after* point in the current buffer, including its
-;;     flags. For example, putting point before the `m' in the following
-;;     example and doing `C-c / p e' (`rxt-pcre-to-elisp') displays
-;;     `\(?:bar\|foo\)', correctly stripping out the whitespace and
-;;     comment:
-
-;;     ,----
-;;     | $x =~ m/  foo   |  (?# comment) bar /x
-;;     `----
-
-;;     The PCRE reader currently only works with `/ ... /' delimiters. It
-;;     will ignore any preceding `m', `s', or `qr' operator, as well as the
-;;     replacement part of an `s' construction.
-
-;;     Readers for other PCRE-using languages are on the TODO list.
-
-;;   The translation functions display their result in the minibuffer and
-;;   copy it to the kill ring. When translating something into Elisp
-;;   syntax, you might need to use the result either literally (e.g. for
-;;   interactive input to a command like `query-replace-regexp'), or as a
-;;   string to paste into Lisp code.  To allow both uses,
-;;   `rxt-pcre-to-elisp' copies both versions successively to the
-;;   kill-ring. The literal regexp without string quoting is the top
-;;   element of the kill-ring, while the Lisp string is the
-;;   second-from-top. You can paste the literal regexp somewhere by doing
-;;   `C-y', or the Lisp string by `C-y M-y'.
-
-
-;; 2.2 Syntax conversion commands
-;; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-;;   `rxt-convert-syntax' (`C-c / c') converts between Emacs and PCRE
-;;   syntax, depending on the major mode in effect when called.
-;;   Alternatively, you can specify the conversion direction explicitly by
-;;   using either `rxt-pcre-to-elisp' (`C-c / p e') or `rxt-elisp-to-pcre'
-;;   (`C-c / e p').
-
-;;   Similarly, `rxt-convert-to-rx' (`C-c / x') converts either kind of
-;;   syntax to `rx' form, while `rxt-convert-pcre-to-rx' (`C-c / p x') and
-;;   `rxt-convert-elisp-to-rx' (`C-c / e x') convert to `rx' from a
-;;   specified source type.
-
-;;   In Elisp buffers, you can use `rxt-toggle-elisp-rx' (`C-c / t' or `C-c
-;;   / e t') to switch the regexp at point back and forth between string
-;;   and `rx' syntax. Point should either be within an `rx' or
-;;   `rx-to-string' form or a string literal for this to work.
-
-
-;; 2.3 PCRE mode (experimental)
-;; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-;;   If you want to use emulated PCRE regexp syntax in all Emacs commands,
-;;   try `pcre-mode', which uses Emacs's advice system to make all commands
-;;   that read regexps using the minibuffer use emulated PCRE syntax.  It
-;;   should also work with Isearch.
-
-;;   This feature is still fairly experimental.  It may fail to work or do
-;;   the wrong thing with certain commands.  Please report bugs.
-
-;;   `pcre-query-replace-regexp' was originally defined to do query-replace
-;;   using emulated PCRE regexps, and is now made somewhat obsolete by
-;;   `pcre-mode'.  It is bound to `C-c / %' by default, by analogy with
-;;   `M-%'.  Put the following in your `.emacs' if you want to use
-;;   PCRE-style query replacement everywhere:
-
-;;   ,----
-;;   | (global-set-key [(meta %)] 'pcre-query-replace-regexp)
-;;   `----
-
-;; 2.5 Explain regexps
-;; ~~~~~~~~~~~~~~~~~~~
-
-;;   When syntax-highlighting isn't enough to untangle some gnarly regexp
-;;   you find in the wild, try the 'explain' commands: `rxt-explain' (`C-c
-;;   / /'), `rxt-explain-pcre' (`C-c / p') and `rxt-explain-elisp' (`C-c /
-;;   e'). These display the original regexp along with its pretty-printed
-;;   `rx' equivalent in a new buffer.  Moving point around either in the
-;;   original regexp or the `rx' translation highlights corresponding
-;;   pieces of syntax, which can aid in seeing things like the scope of
-;;   quantifiers.
-
-;;   I call them "explain" commands because the `rx' form is close to a
-;;   plain syntax tree, and this plus the wordiness of the operators
-;;   usually helps to clarify what is going on.  People who dislike Lisp
-;;   syntax might disagree with this assessment.
-
-
-;; 2.6 Generate all matching strings (productions)
-;; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-;;   Occasionally you come across a regexp which is designed to match a
-;;   finite set of strings, e.g. a set of keywords, and it would be useful
-;;   to recover the original set. (In Emacs you can generate such regexps
-;;   using `regexp-opt'). The commands `rxt-convert-to-strings' (`C-c /
-;;   ′'), `rxt-pcre-to-strings' (`C-c / p ′') or `rxt-elisp-to-strings'
-;;   (`C-c / e ′') accomplish this by generating all the matching strings
-;;   ("productions") of a regexp.  (The productions are copied to the kill
-;;   ring as a Lisp list).
-
-;;   An example in Lisp code:
-
-;;   ,----
-;;   | (regexp-opt '("cat" "caterpillar" "catatonic"))
-;;   |    ;; => "\\(?:cat\\(?:atonic\\|erpillar\\)?\\)"
-;;   | (rxt-elisp-to-strings "\\(?:cat\\(?:atonic\\|erpillar\\)?\\)")
-;;   |     ;; => '("cat" "caterpillar" "catatonic")
-;;   `----
-
-;;   For obvious reasons, these commands only work with regexps that don't
-;;   include any unbounded quantifiers like `+' or `*'. They also can't
-;;   enumerate all the characters that match a named character class like
-;;   `[[:alnum:]]'. In either case they will give a (hopefully meaningful)
-;;   error message. Due to the nature of permutations, it's still possible
-;;   for a finite regexp to generate a huge number of productions, which
-;;   will eat memory and slow down your Emacs. Be ready with `C-g' if
-;;   necessary.
-
-
-;; 2.7 RE-Builder support
-;; ~~~~~~~~~~~~~~~~~~~~~~
-
-;;   The Emacs RE-Builder is a useful visual tool which allows using
-;;   several different built-in syntaxes via `reb-change-syntax' (`C-c
-;;   TAB'). It supports Elisp read and literal syntax and `rx', but it can
-;;   only convert from the symbolic forms to Elisp, not the other way. This
-;;   package hacks the RE-Builder to also work with emulated PCRE syntax,
-;;   and to convert transparently between Elisp, PCRE and rx syntaxes. PCRE
-;;   mode reads a delimited Perl-like literal of the form `/ ... /', and it
-;;   should correctly support using the `x' and `s' flags.
-
-
-;; 2.8 Use from Lisp
-;; ~~~~~~~~~~~~~~~~~
-
-;;   Example of using the conversion functions:
-;;   ,----
-;;   | (rxt-pcre-to-elisp "(abc|def)\\w+\\d+")
-;;   |    ;; => "\\(\\(?:abc\\|def\\)\\)[_[:alnum:]]+[[:digit:]]+"
-;;   `----
-
-;;   All the conversion functions take a single string argument, the regexp
-;;   to translate:
-
-;;   - `rxt-pcre-to-elisp'
-;;   - `rxt-pcre-to-rx'
-;;   - `rxt-pcre-to-strings'
-;;   - `rxt-elisp-to-pcre'
-;;   - `rxt-elisp-to-rx'
-;;   - `rxt-elisp-to-strings'
-
-
-;; 3 Bugs and Limitations
-;; ======================
-
-;; 3.1 Limitations on PCRE syntax
-;; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-;;   PCRE has a complicated syntax and semantics, only some of which can be
-;;   translated into Elisp. The following subset of PCRE should be
-;;   correctly parsed and converted:
-
-;;   - parenthesis grouping `( .. )', including shy matches `(?: ... )'
-;;   - backreferences (various syntaxes), but only up to 9 per expression
-;;   - alternation `|'
-;;   - greedy and non-greedy quantifiers `*', `*?', `+', `+?', `?' and `??'
-;;           (all of which are the same in Elisp as in PCRE)
-;;   - numerical quantifiers `{M,N}'
-;;   - beginning/end of string `\A', `\Z'
-;;   - string quoting `\Q .. \E'
-;;   - word boundaries `\b', `\B' (these are the same in Elisp)
-;;   - single character escapes `\a', `\c', `\e', `\f', `\n', `\r', `\t',
-;;     `\x', and `\octal digits' (but see below about non-ASCII characters)
-;;   - character classes `[...]' including Posix escapes
-;;   - character classes `\d', `\D', `\h', `\H', `\s', `\S', `\v', `\V'
-;;           both within character class brackets and outside
-;;   - word and non-word characters `\w' and `\W' (Emacs has the same
-;;           syntax, but its meaning is different)
-;;   - `s' (single line) and `x' (extended syntax) flags, in regexp
-;;     literals, or set within the expression via `(?xs-xs)' or `(?xs-xs:
-;;     .... )' syntax
-;;   - comments `(?# ... )'
-
-;;   Most of the more esoteric PCRE features can't really be supported by
-;;   simple translation to Elisp regexps. These include the different
-;;   lookaround assertions, conditionals, and the "backtracking control
-;;   verbs" `(* ...)' . OTOH, there are a few other syntaxes which are
-;;   currently unsupported and possibly could be:
-
-;;   - `\L', `\U', `\l', `\u' case modifiers
-;;   - `\g{...}' backreferences
-
-
-;; 3.2 Other limitations
-;; ~~~~~~~~~~~~~~~~~~~~~
-
-;;   - The order of alternatives and characters in char classes sometimes
-;;     gets shifted around, which is annoying.
-;;   - Although the string parser tries to interpret PCRE's octal and
-;;     hexadecimal escapes correctly, there are problems with matching
-;;     8-bit characters that I don't use enough to properly understand,
-;;     e.g.:
-;;     ,----
-;;     | (string-match-p (rxt-pcre-to-elisp "\\377") "\377") => nil
-;;     `----
-;;     A fix for this would be welcome.
-
-;;   - Most of PCRE's rules for how `^', `\A', `$' and `\Z' interact with
-;;     newlines are not implemented, since they seem less relevant to
-;;     Emacs's buffer-oriented rather than line-oriented model.  However,
-;;     the different meanings of the `.' metacharacter *are* implemented
-;;     (it matches newlines with the `/s' flag, but not otherwise).
-
-;;   - Not currently namespace clean (both `rxt-' and a couple of `pcre-'
-;;     functions).
-
-
-;; 3.3 TODO:
-;; ~~~~~~~~~
-
-;;   - Python-specific extensions to PCRE?
-;;   - Language-specific stuff to enable regexp font-locking and explaining
-;;     in different modes. Each language would need two functions, which
-;;     could be kept in an alist:
-
-;;     1. A function to read PCRE regexps, taking the string syntax into
-;;        account. E.g., Python has single-quoted, double-quoted and raw
-;;        strings, each with different quoting rules.  PHP has the kind of
-;;        belt-and-suspenders solution you would expect: regexps are in
-;;        strings, /and/ you have to include the `/ ...  /' delimiters!
-;;        Duh.
-
-;;     2. A function to copy faces back from the parsed string to the
-;;        original buffer text. This has to recognize any escape sequences
-;;        so they can be treated as a single character.
-
-
-;; 4 Internal details
-;; ==================
-
-;;   `rxt' defines an internal syntax tree representation of regular
-;;   expressions, parsers for Elisp and PCRE syntax, and 'unparsers'
-;;   to convert the internal representation to PCRE or `rx' syntax.
-;;   Converting from the internal representation to Emacs syntax is
-;;   done by converting to `rx' form and passing it to `rx-to-string'.
-;;   See `rxt-parse-re', `rxt-adt->pcre', and `rxt-adt->rx' for
-;;   details.
-
-;;   This code is partially based on Olin Shivers' reference SRE
-;;   implementation in scsh, although it is simplified in some respects and
-;;   extended in others. See `scsh/re.scm', `scsh/spencer.scm' and
-;;   `scsh/posixstr.scm' in the `scsh' source tree for details. In
-;;   particular, `pcre2el' steals the idea of an abstract data type for
-;;   regular expressions and the general structure of the string regexp
-;;   parser and unparser. The data types for character sets are extended in
-;;   order to support symbolic translation between character set
-;;   expressions without assuming a small (Latin1) character set. The
-;;   string parser is also extended to parse a bigger variety of
-;;   constructions, including POSIX character classes and various Emacs and
-;;   Perl regexp assertions. Otherwise, only the bare minimum of scsh's
-;;   abstract data type is implemented.
-
-
-;; 5 Soapbox
-;; =========
-
-;;   Emacs regexps have their annoyances, but it is worth getting used to
-;;   them. The Emacs assertions for word boundaries, symbol boundaries, and
-;;   syntax classes depending on the syntax of the mode in effect are
-;;   especially useful. (PCRE has `\b' for word-boundary, but AFAIK it
-;;   doesn't have separate assertions for beginning-of-word and
-;;   end-of-word). Other things that might be done with huge regexps in
-;;   other languages can be expressed more understandably in Elisp using
-;;   combinations of `save-excursion' with the various searches (regexp,
-;;   literal, skip-syntax-forward, sexp-movement functions, etc.).
-
-;;   There's not much point in using `rxt-pcre-to-elisp' to use PCRE
-;;   notation in a Lisp program you're going to maintain, since you still
-;;   have to double all the backslashes.  Better to just use the converted
-;;   result (or better yet, the `rx' form).
-
-
-;; 6 History and acknowledgments
-;; =============================
-
-;;   This was originally created out of an answer to a stackoverflow
-;;   question:
-;;   [http://stackoverflow.com/questions/9118183/elisp-mechanism-for-converting-pcre-regexps-to-emacs-regexps]
-
-;;   Thanks to:
-
-;;   - Wes Hardaker (hardaker) for the initial inspiration and subsequent
-;;     hacking
-;;   - priyadarshan for requesting RX support
-;;   - Daniel Colascione (dcolascione) for a patch to support Emacs's
-;;     explicitly-numbered match groups
-;;   - Aaron Meurer (asmeurer) for requesting Isearch support
-;;   - Philippe Vaucher (silex) for a patch to support `ibuffer-do-replace-regexp'
-;;     in PCRE mode
-
-;;; Code:
-
-(require 'cl-lib)
-(require 'rx)
-(require 're-builder)
-(require 'advice)
-(require 'ring)
-(require 'pcase)
-
-;;; Customization group
-(defgroup rxt nil
-  "Regex syntax converter and utilities."
-  :version 1.2
-  :group 'tools
-  :group 'lisp
-  :link '(emacs-commentary-link :tag "commentary" "pcre2el.el")
-  :link '(emacs-library-link :tag "lisp file" "pcre2el.el")
-  :link '(url-link :tag "web page" "https://github.com/joddie/pcre2el"))
-
-(defface rxt-highlight-face
-  '((((min-colors 16581375) (background light)) :background "#eee8d5")
-    (((min-colors 16581375) (background dark)) :background "#222222"))
-  "Face for highlighting corresponding regex syntax in `rxt-explain' buffers."
-  :group 'rxt)
-
-(defcustom rxt-verbose-rx-translation nil
-  "Non-nil if `rxt-pcre-to-rx' and `rxt-elisp-to-rx' should use verbose `rx' primitives.
-
-Verbose primitives are things like `line-start' instead of `bol',
-etc."
-  :group 'rxt
-  :type 'boolean)
-
-(defcustom rxt-explain-verbosely t
-  "Non-nil if `rxt-explain-elisp' and `rxt-explain-pcre' should use verbose `rx' primitives.
-
-This overrides the value of `rxt-verbose-rx-translation' for
-these commands only."
-  :group 'rxt
-  :type 'boolean)
-
-
-;;;; Macros and functions for writing interactive input and output
-
-;; Macros for handling return values.  If called interactively,
-;; display the value in the echo area and copy it to the kill ring,
-;; otherwise just return the value.  PCREs are copied as unquoted
-;; strings for yanking into Perl, JS, etc.  `rx' forms and other sexps
-;; are copied as `read'-able literals for yanking into Elisp buffers.
-;; Emacs regexps are copied twice: once as an unquoted value for
-;; interactive use, and once as a readable string literal for yanking
-;; into Elisp buffers.
-(defmacro rxt-return-pcre (expr)
-  (let ((value (make-symbol "value")))
-    `(let ((,value ,expr))
-       (when (called-interactively-p 'any)
-         (rxt--kill-pcre ,value))
-       ,value)))
-
-(defmacro rxt-return-sexp (expr)
-  (let ((value (make-symbol "value")))
-    `(let ((,value ,expr))
-       (when (called-interactively-p 'any)
-         (rxt--kill-sexp ,value))
-       ,value)))
-
-(defmacro rxt-return-emacs-regexp (expr)
-  (let ((value (make-symbol "value")))
-    `(let ((,value ,expr))
-       (when (called-interactively-p 'any)
-         (rxt--kill-emacs-regexp ,value))
-       ,value)))
-
-(defun rxt--kill-sexp (value)
-  (let ((lisp-literal (prin1-to-string value)))
-    (message "%s" lisp-literal)
-    (kill-new lisp-literal)))
-
-(defun rxt--kill-pcre (value)
-  (message "%s" value)
-  (kill-new value))
-
-(defun rxt--kill-emacs-regexp (value)
-  (let ((lisp-literal (prin1-to-string value)))
-    (message "%s" value)
-    (kill-new lisp-literal)
-    (kill-new value)))
-
-;; Read an Elisp regexp interactively.
-;;
-;; Three possibilities:
-;;
-;; 1) With a prefix arg, reads literally from the minibuffer, w/o
-;; using string syntax -- just like query-replace-regexp, etc.
-;;
-;; 2) If the region is active, use the text of the region literally
-;; (again w/o string syntax)
-;;
-;; 3) Otherwise, eval the sexp before point (which might be a string
-;; literal or an expression) and use its value. Falls back to method
-;; (1) if this fails to produce a string value.
-;;
-(cl-defun rxt-interactive/elisp (&optional (prompt "Emacs regexp: "))
-  (list
-   (cond (current-prefix-arg
-          (read-string prompt))
-
-         ((use-region-p)
-          (buffer-substring-no-properties (region-beginning) (region-end)))
-
-         (t
-          (condition-case nil
-              (save-excursion
-                (while (nth 3 (syntax-ppss)) (forward-char))
-                (let ((re (eval (preceding-sexp))))
-                  (if (stringp re) re
-                    (read-string prompt))))
-            (error
-             (read-string prompt)))))))
-
-;; Read a PCRE regexp interactively.
-;;
-;; Three possibilities: As above, except that without prefix arg or
-;; active region, tries to read a delimited regexp literal like /.../,
-;; m/.../, or qr/.../ following point in the current buffer. Falls
-;; back to reading from minibuffer if that fails.
-;;
-;; Returns the regexp, with flags as text properties.
-;;
-;; TODO: Different delimiters
-(cl-defun rxt-interactive/pcre (&optional (prompt "PCRE regexp: "))
-  (list
-   (cond (current-prefix-arg
-          (rxt--read-pcre prompt))
-
-         ((use-region-p)
-          (buffer-substring-no-properties (region-beginning) (region-end)))
-
-         (t
-          (condition-case nil
-              (rxt-read-delimited-pcre)
-            (error                     ; Fall back to reading from minibuffer
-             (rxt--read-pcre prompt)))))
-   nil))
-
-(define-minor-mode rxt--read-pcre-mode
-    "Minor-mode with key-bindings for toggling PCRE flags.
-
-You should not normally call this directly.  It will be enabled
-in minibuffers for `read-regexp' and in the `re-builder' buffer
-when `pcre-mode' is active.  These bindings will also be added to
-`isearch-mode-map' in `pcre-mode'."
-  :initial nil
-  :lighter nil
-  :keymap
-  `((,(kbd "C-c s") . ,#'rxt--toggle-s-mode)
-    (,(kbd "C-c x") . ,#'rxt--toggle-x-mode)
-    (,(kbd "C-c i") . ,#'rxt--toggle-i-mode)))
-
-(defun rxt--read-pcre (prompt)
-  "Read a PCRE regexp for translation, together with option flags.
-
-The `s', `x', and `i' flags can be toggled using the following
-commands: \\<rxt--read-pcre-mode-map>
-
-\\[rxt--toggle-s-mode] : toggle `s' (single-line) mode
-\\[rxt--toggle-x-mode] : toggle `x' (extended) mode
-\\[rxt--toggle-i-mode] : toggle `i' (case-insensitive) mode
-
-In single-line mode, `.' will also match newlines.
-In extended mode, whitespace is ignored.
-
-Case-insensitive mode emulates matching without case,
-independently of Emacs's builtin `case-fold-search' setting.
-Note that this does not apply to backreferences."
-  (minibuffer-with-setup-hook #'rxt--read-pcre-mode
-    (read-from-minibuffer prompt)))
-
-(defun rxt--toggle-s-mode ()
-  "Toggle emulated PCRE single-line (s) flag."
-  (interactive)
-  (rxt--toggle-flag ?s))
-
-(defun rxt--toggle-x-mode ()
-  "Toggle emulated PCRE extended (x) flag."
-  (interactive)
-  (rxt--toggle-flag ?x))
-
-(defun rxt--toggle-i-mode ()
-  "Toggle emulated PCRE case-insensitive (i) flag."
-  (interactive)
-  (rxt--toggle-flag ?i))
-
-(defun rxt--toggle-flag (char)
-  "Toggle CHAR, a PCRE flag."
-  (cond
-    ((derived-mode-p 'reb-mode)         ; RE-Builder
-     (rxt--toggle-flag-re-builder char))
-    ((minibufferp)
-     (rxt--toggle-flag-minibuffer char))
-    (isearch-mode
-     (rxt--toggle-flag-isearch char))
-    (t
-     (error "Not in minibuffer, RE-Builder or isearch mode."))))
-
-(defun rxt--toggle-flag-re-builder (char)
-  (save-excursion
-    (goto-char (point-max))
-    (search-backward "/")
-    (forward-char)
-    (when (looking-at (rx (* (any ?i ?s ?x))))
-      (let ((inhibit-modification-hooks t))
-        (replace-match (rxt--xor-flags (match-string 0) char) t t))))
-  (reb-do-update))
-
-(defun rxt--toggle-flag-minibuffer (char)
-  (setf (buffer-substring (minibuffer-prompt-end) (point-max))
-        (rxt--toggle-flag-string (minibuffer-contents) char))
-  (when
-      (and (= (point) (minibuffer-prompt-end))
-           (looking-at (rx "(?" (group (+ (any ?i ?s ?x))) ")")))
-    (forward-sexp)))
-
-(defun rxt--toggle-flag-isearch (char)
-  (when isearch-regexp
-    (setq isearch-string
-          (rxt--toggle-flag-string isearch-string char))
-    (setq isearch-message
-          (mapconcat #'isearch-text-char-description isearch-string ""))
-    (isearch-search-and-update)))
-
-(defun rxt--toggle-flag-string (string char)
-  (if (string-match (rx string-start "(?" (group (+ (any ?i ?s ?x))) ")")
-                    string)
-      (let ((flags (rxt--xor-flags (match-string 1 string) char)))
-        (if (string= flags "")
-            (replace-match "" t t string)
-          (replace-match flags t t string 1)))
-    (format "(?%c)%s" char string)))
-
-(defun rxt--xor-flags (flags char)
-  (concat
-   (sort
-    (cl-set-exclusive-or (string-to-list flags) (list char))
-    #'<)))
-
-
-;;;; Minor mode for using emulated PCRE syntax
-
-(defvar pcre-old-isearch-search-fun-function nil
-  "Original value of `isearch-search-fun-function' before entering `pcre-mode.'
-
-This function is wrapped by `pcre-isearch-search-fun-function'
-and restored on exit from `pcre-mode'.")
-(make-variable-buffer-local 'pcre-old-isearch-search-fun-function)
-
-(defvar pcre-old-isearch-key-bindings nil
-  "Alist of key-bindings to restore in `isearch-mode-map' on exiting `pcre-mode'.")
-
-;;;###autoload
-(define-minor-mode pcre-mode
-  "Use emulated PCRE syntax for regexps wherever possible.
-
-Advises the `interactive' specs of `read-regexp' and the
-following other functions so that they read PCRE syntax and
-translate to its Emacs equivalent:
-
-- `align-regexp'
-- `find-tag-regexp'
-- `sort-regexp-fields'
-- `isearch-message-prefix'
-- `ibuffer-do-replace-regexp'
-
-Also alters the behavior of `isearch-mode' when searching by regexp."
-  nil " PCRE"
-  nil
-  :global t
-
-  (if pcre-mode
-      ;; Enabling
-      (progn
-        ;; Enable advice
-        (ad-enable-regexp "pcre-mode")
-        ;; Set up isearch hooks
-        (add-hook 'isearch-mode-hook #'pcre-isearch-mode-hook)
-        (add-hook 'isearch-mode-end-hook #'pcre-isearch-mode-end-hook)
-        ;; Add the keybindings of `rxt--read-pcre-mode-map' to
-        ;; `isearch-mode-map' (so that they do not cause an exit from
-        ;; `isearch-mode'), and save any existing bindings for those
-        ;; keys to restore on exit from `pcre-mode'.
-        (setq pcre-old-isearch-key-bindings
-              (cl-loop for key being the key-seqs of rxt--read-pcre-mode-map
-                       for def = (lookup-key isearch-mode-map key)
-                       collect (cons (copy-sequence key)
-                                     (if (numberp def) nil def))))
-        (cl-loop for key being the key-seqs of rxt--read-pcre-mode-map
-                 using (key-bindings def)
-                 do (define-key isearch-mode-map key def)))
-
-    ;; Disable advice
-    (ad-disable-regexp "pcre-mode")
-    ;; Remove from isearch hooks
-    (remove-hook 'isearch-mode-hook #'pcre-isearch-mode-hook)
-    (remove-hook 'isearch-mode-end-hook #'pcre-isearch-mode-end-hook)
-    ;; Restore key-bindings
-    (cl-loop for (key . def) in pcre-old-isearch-key-bindings
-             do (define-key isearch-mode-map key def)))
-
-  ;; "Activating" advice re-computes the function definitions, which
-  ;; is necessary whether enabling or disabling
-  (ad-activate-regexp "pcre-mode"))
-
-;;; Cache of PCRE -> Elisp translations
-(defvar pcre-mode-cache-size 100
-  "Number of PCRE-to-Emacs translations to keep in the `pcre-mode' cache.")
-
-(defvar pcre-mode-cache (make-hash-table :test 'equal)
-  "Cache of PCRE-to-Emacs translations used in `pcre-mode'.
-
-Keys are PCRE regexps, values are their Emacs equivalents.")
-
-(defvar pcre-mode-reverse-cache (make-hash-table :test 'equal)
-  "Cache of original PCREs translated to Emacs syntax in `pcre-mode'.
-
-Keys are translated Emacs regexps, values are their original PCRE
-form.  This is used to display the original PCRE regexp in place
-of its translated form.")
-
-(defvar pcre-cache-ring (make-ring pcre-mode-cache-size)
-  "Ring of PCRE-to-Emacs translations used in `pcre-mode'.
-
-When the ring fills up, the oldest element is removed and the
-corresponding entries are deleted from the hash tables
-`pcre-mode-cache' and `pcre-mode-reverse-cache'.")
-
-(defun pcre-to-elisp/cached (pcre)
-  "Translate PCRE to Emacs syntax, caching both forms."
-  (or (gethash pcre pcre-mode-cache)
-      (let ((elisp (rxt-pcre-to-elisp pcre)))
-        (pcre-set-cache pcre elisp)
-        elisp)))
-
-(defun pcre-set-cache (pcre-regexp emacs-regexp)
-  "Add a PCRE-to-Emacs translation to the `pcre-mode' cache."
-  (when (and (not (zerop (length pcre-regexp)))
-             (not (zerop (length emacs-regexp)))
-             (not (gethash pcre-regexp pcre-mode-cache)))
-    (if (= (ring-length pcre-cache-ring) (ring-size pcre-cache-ring))
-        (let* ((old-item (ring-remove pcre-cache-ring))
-               (old-pcre (car old-item))
-               (old-emacs (cdr old-item)))
-          (remhash old-pcre pcre-mode-cache)
-          (remhash old-emacs pcre-mode-reverse-cache))
-      (puthash pcre-regexp emacs-regexp pcre-mode-cache)
-      (puthash emacs-regexp pcre-regexp pcre-mode-reverse-cache)
-      (ring-insert pcre-cache-ring (cons pcre-regexp emacs-regexp)))))
-
-;;; Isearch advice
-(defun pcre-isearch-mode-hook ()
-  (when (not (eq isearch-search-fun-function #'isearch-search-fun-default))
-    (message "Warning: pcre-mode overriding existing isearch function `%s'"
-             isearch-search-fun-function))
-  ;; Prevent an infinite loop, if a previous isearch in pcre-mode
-  ;; exited without restoring the original search function for some
-  ;; reason
-  (unless (eq isearch-search-fun-function #'pcre-isearch-search-fun-function)
-    (setq pcre-old-isearch-search-fun-function isearch-search-fun-function))
-  (set (make-local-variable 'isearch-search-fun-function)
-       #'pcre-isearch-search-fun-function))
-
-(defun pcre-isearch-mode-end-hook ()
-  (setq isearch-search-fun-function pcre-old-isearch-search-fun-function))
-
-(defun pcre-isearch-search-fun-function ()
-  "Enable isearching using emulated PCRE syntax.
-
-This is set as the value of `isearch-search-fun-function' when
-`pcre-mode' is enabled.  Returns a function which searches using
-emulated PCRE regexps when `isearch-regexp' is true."
-  (lambda (string bound noerror)
-    (let ((real-search-function
-           (funcall (or pcre-old-isearch-search-fun-function 'isearch-search-fun-default))))
-      (if (not isearch-regexp)
-          (funcall real-search-function string bound noerror)
-        ;; Raise an error if the regexp ends in an incomplete escape
-        ;; sequence (= odd number of backslashes).
-        ;; TODO: Perhaps this should really be handled in rxt-pcre-to-elisp?
-        (if (isearch-backslash string) (rxt-error "Trailing backslash"))
-        (funcall real-search-function
-                 (pcre-to-elisp/cached string) bound noerror)))))
-
-(defadvice isearch-message-prefix (after pcre-mode disable)
-  "Add \"PCRE\" to the Isearch message when searching by regexp in `pcre-mode'."
-  (when (and isearch-regexp
-             ;; Prevent an inaccurate message if our callback was
-             ;; removed somehow
-             (eq isearch-search-fun-function #'pcre-isearch-search-fun-function))
-    (let ((message ad-return-value))
-      ;; Some hackery to give replacement the same fontification as
-      ;; the original
-      (when
-          (let ((case-fold-search t)) (string-match "regexp" message))
-        (let* ((match (match-string 0 message))
-               (properties (text-properties-at 0 match))
-               (replacement (apply #'propertize "PCRE regexp" properties))
-               (new-message (replace-match replacement t t message)))
-          (setq ad-return-value new-message))))))
-
-(defadvice isearch-fallback
-  (before pcre-mode (want-backslash &optional allow-invalid to-barrier) disable)
-  "Hack to fall back correctly in `pcre-mode'. "
-  ;; A dirty hack to the internals of isearch.  Falling back to a
-  ;; previous match position is necessary when the (Emacs) regexp ends
-  ;; in "*", "?", "\{" or "\|": this is handled in
-  ;; `isearch-process-search-char' by calling `isearch-fallback' with
-  ;; `t' for the value of the first parameter, `want-backslash', in
-  ;; the last two cases.  With PCRE regexps, falling back should take
-  ;; place on "*", "?", "{" or "|", with no backslashes required.
-  ;; This advice handles the last two cases by unconditionally setting
-  ;; `want-backslash' to nil.
-  (ad-set-arg 0 nil))
-
-(defadvice isearch-edit-string
-    (around pcre-mode disable)
-  "Add PCRE mode-toggling keys to Isearch minibuffer in regexp mode."
-  (if isearch-regexp
-      (minibuffer-with-setup-hook
-          #'rxt--read-pcre-mode
-        ad-do-it)
-    ad-do-it))
-
-;;; evil-mode advice
-(defadvice evil-search-function
-    (around pcre-mode (forward regexp-p wrap) disable)
-  (if (and regexp-p (not isearch-mode))
-      (let ((real-search-function ad-do-it))
-        (setq ad-return-value
-              (pcre-decorate-search-function real-search-function)))
-    ad-do-it))
-
-(eval-after-load 'evil
-  '(when pcre-mode
-    (ad-enable-advice 'evil-search-function 'around 'pcre-mode)
-    (ad-activate 'evil-search-function)))
-
-(defun pcre-decorate-search-function (real-search-function)
-  (lambda (string &optional bound noerror count)
-    (funcall real-search-function
-             (pcre-to-elisp/cached string)
-             bound noerror count)))
-
-;;; Other hooks and defadvices
-
-;;;###autoload
-(defun pcre-query-replace-regexp ()
-  "Perform `query-replace-regexp' using PCRE syntax.
-
-Consider using `pcre-mode' instead of this function."
-  (interactive)
-  (let ((old-pcre-mode pcre-mode))
-    (unwind-protect
-        (progn
-          (pcre-mode +1)
-          (call-interactively #'query-replace-regexp))
-      (pcre-mode (if old-pcre-mode 1 0)))))
-
-
-(defadvice add-to-history
-  (before pcre-mode (history-var newelt &optional maxelt keep-all) disable)
-  "Add the original PCRE to query-replace history in `pcre-mode'."
-  (when (eq history-var query-replace-from-history-variable)
-    (let ((original (gethash newelt pcre-mode-reverse-cache)))
-      (when original
-        (ad-set-arg 1 original)))))
-
-(defadvice query-replace-descr
-  (before pcre-mode (from) disable)
-  "Use the original PCRE in Isearch prompts in `pcre-mode'."
-  (let ((original (gethash from pcre-mode-reverse-cache)))
-    (when original
-      (ad-set-arg 0 original))))
-
-;;; The `interactive' specs of the following functions are lifted
-;;; wholesale from the original built-ins, which see.
-(defadvice read-regexp
-  (around pcre-mode first (prompt &optional defaults history) disable)
-  "Read regexp using PCRE syntax and convert to Elisp equivalent."
-  (ad-set-arg 0 (concat "[PCRE] " prompt))
-  (minibuffer-with-setup-hook
-      #'rxt--read-pcre-mode
-    ad-do-it)
-  (setq ad-return-value
-        (pcre-to-elisp/cached ad-return-value)))
-
-(defadvice align-regexp
-  (before pcre-mode first (beg end regexp &optional group spacing repeat) disable)
-  "Read regexp using PCRE syntax and convert to Elisp equivalent."
-  (interactive
-   (append
-    (list (region-beginning) (region-end))
-    (if current-prefix-arg
-        (list (rxt-pcre-to-elisp
-               (read-string "Complex align using PCRE regexp: "
-                            "(\\s*)"))
-              (string-to-number
-               (read-string
-                "Parenthesis group to modify (justify if negative): " "1"))
-              (string-to-number
-               (read-string "Amount of spacing (or column if negative): "
-                            (number-to-string align-default-spacing)))
-              (y-or-n-p "Repeat throughout line? "))
-      (list (concat "\\(\\s-*\\)"
-                    (rxt-pcre-to-elisp
-                     (read-string "Align PCRE regexp: ")))
-            1 align-default-spacing nil)))))
-
-(defadvice ibuffer-do-replace-regexp
-  (before pcre-mode first (from-str to-str) disable)
-  "Read regexp using PCRE syntax and convert to Elisp equivalent."
-  (interactive
-   (let* ((from-str (read-from-minibuffer "[PCRE] Replace regexp: "))
-          (to-str (read-from-minibuffer (concat "[PCRE] Replace " from-str " with: "))))
-     (list (rxt-pcre-to-elisp from-str) to-str))))
-
-(defadvice find-tag-regexp
-  (before pcre-mode first (regexp &optional next-p other-window) disable)
-  "Read regexp using PCRE syntax and convert to Elisp equivalent.
-Perform `find-tag-regexp' using emulated PCRE regexp syntax."
-  (interactive
-   (let ((args (find-tag-interactive "[PCRE] Find tag regexp: " t)))
-     (list (rxt-pcre-to-elisp (nth 0 args))
-           (nth 1 args) (nth 2 args)))))
-
-(defadvice sort-regexp-fields
-  (before pcre-mode first (reverse record-regexp key-regexp beg end) disable)
-  "Read regexp using PCRE syntax and convert to Elisp equivalent."
-  (interactive "P\nsPCRE regexp specifying records to sort: \n\
-sPCRE regexp specifying key within record: \nr")
-  (ad-set-arg 1 (rxt-pcre-to-elisp (ad-get-arg 1)))
-  (ad-set-arg 2 (rxt-pcre-to-elisp (ad-get-arg 2))))
-
-
-
-;;; Commands that take Emacs-style regexps as input
-
-;;;###autoload
-(defun rxt-elisp-to-pcre (regexp)
-  "Translate REGEXP, a regexp in Emacs Lisp syntax, to Perl-compatible syntax.
-
-Interactively, reads the regexp in one of three ways. With a
-prefix arg, reads from minibuffer without string escaping, like
-`query-replace-regexp'. Without a prefix arg, uses the text of
-the region if it is active. Otherwise, uses the result of
-evaluating the sexp before point (which might be a string regexp
-literal or an expression that produces a string).
-
-Displays the translated PCRE regexp in the echo area and copies
-it to the kill ring.
-
-Emacs regexp features such as syntax classes which cannot be
-translated to PCRE will cause an error."
-  (interactive (rxt-interactive/elisp))
-  (rxt-return-pcre (rxt-adt->pcre (rxt-parse-elisp regexp))))
-
-;;;###autoload
-(defun rxt-elisp-to-rx (regexp)
-  "Translate REGEXP, a regexp in Emacs Lisp syntax, to `rx' syntax.
-
-See `rxt-elisp-to-pcre' for a description of the interactive
-behavior and `rx' for documentation of the S-expression based
-regexp syntax."
-  (interactive (rxt-interactive/elisp))
-  (rxt-return-sexp (rxt-adt->rx (rxt-parse-elisp regexp))))
-
-;;;###autoload
-(defun rxt-elisp-to-strings (regexp)
-  "Return a list of all strings matched by REGEXP, an Emacs Lisp regexp.
-
-See `rxt-elisp-to-pcre' for a description of the interactive behavior.
-
-This is useful primarily for getting back the original list of
-strings from a regexp generated by `regexp-opt', but it will work
-with any regexp without unbounded quantifiers (*, +, {2, } and so
-on).
-
-Throws an error if REGEXP contains any infinite quantifiers."
-  (interactive (rxt-interactive/elisp))
-  (rxt-return-sexp (rxt-adt->strings (rxt-parse-elisp regexp))))
-
-;;;###autoload
-(defun rxt-toggle-elisp-rx ()
-  "Toggle the regexp near point between Elisp string and rx syntax."
-  (interactive)
-  ;; First, position point before the regex form near point (either
-  ;; a string literal or a list beginning `rx' or `rx-to-string').
-  (let* ((context (syntax-ppss))
-         (string-start (nth 8 context)))
-    (cond (string-start (goto-char string-start))
-          ((looking-back "\"") (backward-sexp))
-          ((looking-at "\"") nil)
-          (t
-           ;; Search backwards, leaving point in place on error
-           (goto-char
-            (save-excursion
-              (skip-syntax-forward "-")
-              (while (not (looking-at
-                           (rx "(" (or "rx" "rx-to-string") symbol-end)))
-                (backward-up-list))
-              (point))))))
-
-  ;; Read and replace the regex following point
-  (let* ((regex (read (current-buffer)))
-         (print-escape-newlines t))
-    (save-excursion
-      (if (listp regex)
-          ;; Replace rx form with string value
-          (prin1 (eval regex) (current-buffer))
-        ;; Pretty-print rx form
-        (save-restriction
-          (let* ((start (point))
-                 (rx-syntax (rxt-elisp-to-rx regex))
-                 (rx-form
-                  (pcase rx-syntax
-                    (`(seq . ,rest) `(rx . ,rest))
-                    (form           `(rx ,form)))))
-            (rxt-print rx-form)
-            (narrow-to-region start (point)))
-          (pp-buffer)
-          ;; remove the extra newline that pp-buffer inserts
-          (goto-char (point-max))
-          (delete-region
-           (point)
-           (save-excursion (skip-chars-backward " \t\n") (point))))))
-    (kill-sexp -1)
-    (indent-pp-sexp)))
-
-
-
-;;; Commands that translate PCRE to other formats
-
-;;;###autoload
-(defun rxt-pcre-to-elisp (pcre &optional flags)
-  "Translate PCRE, a regexp in Perl-compatible syntax, to Emacs Lisp.
-
-Interactively, uses the contents of the region if it is active,
-otherwise reads from the minibuffer. Prints the Emacs translation
-in the echo area and copies it to the kill ring.
-
-PCRE regexp features that cannot be translated into Emacs syntax
-will cause an error. See the commentary section of pcre2el.el for
-more details."
-  (interactive (rxt-interactive/pcre))
-  (rxt-return-emacs-regexp
-   (rx-to-string
-    (rxt-pcre-to-rx (rxt--add-flags pcre flags))
-    t)))
-
-;;;###autoload
-(defalias 'pcre-to-elisp 'rxt-pcre-to-elisp)
-
-;;;###autoload
-(defun rxt-pcre-to-rx (pcre &optional flags)
-  "Translate PCRE, a regexp in Perl-compatible syntax, to `rx' syntax.
-
-See `rxt-pcre-to-elisp' for a description of the interactive behavior."
-  (interactive (rxt-interactive/pcre))
-  (rxt-return-sexp (rxt-adt->rx (rxt-parse-pcre (rxt--add-flags pcre flags)))))
-
-;;;###autoload
-(defun rxt-pcre-to-strings (pcre &optional flags)
-  "Return a list of all strings matched by PCRE, a Perl-compatible regexp.
-
-See `rxt-elisp-to-pcre' for a description of the interactive
-behavior and `rxt-elisp-to-strings' for why this might be useful.
-
-Throws an error if PCRE contains any infinite quantifiers."
-  (interactive (rxt-interactive/pcre))
-  (rxt-return-sexp (rxt-adt->strings (rxt-parse-pcre (rxt--add-flags pcre flags)))))
-
-(defun rxt--add-flags (pcre flags)
-  "Prepend FLAGS to PCRE."
-  (if (not (zerop (length flags)))
-      (concat "(?" flags ")" pcre)
-    pcre))
-
-
-;;; Regexp explaining functions to display pretty-printed rx syntax
-
-;; When the `rxt-explain' flag is non-nil, `rxt-adt->rx' records
-;; location information for each element of the generated `rx' form,
-;; allowing highlighting corresponding pieces of syntax at point.
-(defvar rxt-explain nil)
-
-(defvar rxt-highlight-overlays nil
-  "List of active location-highlighting overlays in rxt-help-mode buffer.")
-
-;;;###autoload
-(defun rxt-explain-elisp (regexp)
-  "Insert the pretty-printed `rx' syntax for REGEXP in a new buffer.
-
-REGEXP is a regular expression in Emacs Lisp syntax. See
-`rxt-elisp-to-pcre' for a description of how REGEXP is read
-interactively."
-  (interactive (rxt-interactive/elisp))
-  (let ((rxt-explain t)
-        (rxt-verbose-rx-translation rxt-explain-verbosely))
-    (rxt-pp-rx regexp (rxt-elisp-to-rx regexp))))
-
-;;;###autoload
-(defun rxt-explain-pcre (regexp &optional flags)
-  "Insert the pretty-printed `rx' syntax for REGEXP in a new buffer.
-
-REGEXP is a regular expression in PCRE syntax. See
-`rxt-pcre-to-elisp' for a description of how REGEXP is read
-interactively."
-  (interactive (rxt-interactive/pcre))
-  (let ((rxt-explain t)
-        (rxt-verbose-rx-translation rxt-explain-verbosely))
-    (rxt-pp-rx regexp (rxt-pcre-to-rx regexp flags))))
-
-;;;###autoload
-(defun rxt-quote-pcre (text)
-  "Return a PCRE regexp which matches TEXT literally.
-
-Any PCRE metacharacters in TEXT will be quoted with a backslash."
-  (rxt-adt->pcre (rxt-string text)))
-
-
-;;;; Commands that depend on the major mode in effect
-
-;; Macro: interactively call one of two functions depending on the
-;; major mode
-(defmacro rxt-mode-dispatch (elisp-function pcre-function)
-  `(if (memq major-mode '(emacs-lisp-mode lisp-interaction-mode))
-       (call-interactively #',elisp-function)
-     (call-interactively #',pcre-function)))
-
-;;;###autoload
-(defun rxt-explain ()
-  "Pop up a buffer with pretty-printed `rx' syntax for the regex at point.
-
-Chooses regex syntax to read based on current major mode, calling
-`rxt-explain-elisp' if buffer is in `emacs-lisp-mode' or
-`lisp-interaction-mode', or `rxt-explain-pcre' otherwise."
-  (interactive)
-  (rxt-mode-dispatch rxt-explain-elisp rxt-explain-pcre))
-
-;;;###autoload
-(defun rxt-convert-syntax ()
-  "Convert regex at point to other kind of syntax, depending on major mode.
-
-For buffers in `emacs-lisp-mode' or `lisp-interaction-mode',
-calls `rxt-elisp-to-pcre' to convert to PCRE syntax. Otherwise,
-calls `rxt-pcre-to-elisp' to convert to Emacs syntax.
-
-The converted syntax is displayed in the echo area and copied to
-the kill ring; see the two functions named above for details."
-  (interactive)
-  (rxt-mode-dispatch rxt-elisp-to-pcre rxt-pcre-to-elisp))
-
-;;;###autoload
-(defun rxt-convert-to-rx ()
-  "Convert regex at point to RX syntax. Chooses Emacs or PCRE syntax by major mode."
-  (interactive)
-  (rxt-mode-dispatch rxt-elisp-to-rx rxt-pcre-to-rx))
-
-;;;###autoload
-(defun rxt-convert-to-strings ()
-  "Convert regex at point to RX syntax. Chooses Emacs or PCRE syntax by major mode."
-  (interactive)
-  (rxt-mode-dispatch rxt-elisp-to-strings rxt-pcre-to-strings))
-
-
-
-;;; Minor mode and keybindings
-
-(defvar rxt-mode-map
-  (let ((map (make-sparse-keymap)))
-    ;; Generic
-    (define-key map (kbd "C-c / /") 'rxt-explain)
-    (define-key map (kbd "C-c / c") 'rxt-convert-syntax)
-    (define-key map (kbd "C-c / x") 'rxt-convert-to-rx)
-    (define-key map (kbd "C-c / '") 'rxt-convert-to-strings)
-
-    ;; From PCRE
-    (define-key map (kbd "C-c / p /") 'rxt-explain-pcre)
-    (define-key map (kbd "C-c / p e") 'rxt-pcre-to-elisp)
-    (define-key map (kbd "C-c / p x") 'rxt-pcre-to-rx)
-    (define-key map (kbd "C-c / p '") 'rxt-pcre-to-strings)
-
-    ;; From Elisp
-    (define-key map (kbd "C-c / e /") 'rxt-explain-elisp)
-    (define-key map (kbd "C-c / e p") 'rxt-elisp-to-pcre)
-    (define-key map (kbd "C-c / e x") 'rxt-elisp-to-rx)
-    (define-key map (kbd "C-c / e '") 'rxt-elisp-to-strings)
-    (define-key map (kbd "C-c / e t") 'rxt-toggle-elisp-rx)
-    (define-key map (kbd "C-c / t") 'rxt-toggle-elisp-rx)
-    
-    ;; Search
-    (define-key map (kbd "C-c / %") 'pcre-query-replace-regexp)
-
-    map)
-  "Keymap for `rxt-mode'.")
-
-;;;###autoload
-(define-minor-mode rxt-mode
-  "Regex translation utilities." nil nil)
-
-;;;###autoload
-(defun turn-on-rxt-mode ()
-  "Turn on `rxt-mode' in the current buffer."
-  (interactive)
-  (rxt-mode 1))
-
-;;;###autoload
-(define-globalized-minor-mode rxt-global-mode rxt-mode
-  turn-on-rxt-mode)
-
-
-;;;; Syntax explanations
-
-;; Major mode for displaying pretty-printed S-exp syntax
-(define-derived-mode rxt-help-mode emacs-lisp-mode "Regexp Explain"
-  (setq buffer-read-only t)
-  (add-hook 'post-command-hook 'rxt-highlight-text nil t)
-  (rxt-highlight-text))
-
-;; Hack: stop paredit-mode interfering with `rxt-print'
-(eval-when-compile (declare-function paredit-mode "paredit.el"))
-(add-hook 'rxt-help-mode-hook
-          (lambda ()
-            (if (and (boundp 'paredit-mode)
-                     paredit-mode)
-                (paredit-mode 0))))
-
-(define-key rxt-help-mode-map "q" 'quit-window)
-(define-key rxt-help-mode-map "z" 'kill-this-buffer)
-(define-key rxt-help-mode-map "n" 'next-line)
-(define-key rxt-help-mode-map "p" 'previous-line)
-(define-key rxt-help-mode-map "f" 'forward-list)
-(define-key rxt-help-mode-map "b" 'backward-list)
-(define-key rxt-help-mode-map "u" 'backward-up-list)
-(define-key rxt-help-mode-map "d" 'down-list)
-
-(defvar rxt--print-with-overlays nil)
-(defvar rxt--print-depth 0)
-
-(defconst rxt--print-char-alist
-  '((?\a . "\\a")
-    (?\b . "\\b")
-    (?\t . "\\t")
-    (?\n . "\\n")
-    (?\v . "\\v")
-    (?\f . "\\f")
-    (?\r . "\\r")
-    (?\e . "\\e")
-    (?\s . "\\s")
-    (?\\ . "\\\\")
-    (?\d . "\\d"))
-  "Alist of characters to print using an escape sequence in Elisp source.
-See (info \"(elisp) Basic Char Syntax\").")
-
-(defconst rxt--whitespace-display-regexp
-  (rx-to-string `(any ,@(mapcar #'car rxt--print-char-alist))))
-
-(defconst rxt--print-special-chars
-  '(?\( ?\) ?\\ ?\| ?\; ?\' ?\` ?\" ?\# ?\. ?\,)
-  "Characters which require a preceding backslash in Elisp source.
-See (info \"(elisp) Basic Char Syntax\").")
-
-(defun rxt-pp-rx (regexp rx)
-  "Display string regexp REGEXP with its `rx' form RX in an `rxt-help-mode' buffer."
-  (with-current-buffer (get-buffer-create "* Regexp Explain *")
-    (let ((print-escape-newlines t)
-          (inhibit-read-only t))
-      (erase-buffer)
-      (rxt-help-mode)
-      (insert (rxt--propertize-whitespace regexp))
-      (newline 2)
-      (save-excursion
-        (let ((sexp-begin (point))
-              (rxt--print-with-overlays t))
-          (rxt-print rx)
-          (narrow-to-region sexp-begin (point))
-          (pp-buffer)
-          (widen)))
-      (rxt-highlight-text))
-    (pop-to-buffer (current-buffer))))
-
-(cl-defun rxt-print (rx)
-  "Insert RX, an `rx' form, into the current buffer, optionally adding overlays.
-
-Similar to `print' or `prin1', but ensures that `rx' forms are
-printed readably, using character or integer syntax depending on
-context.
-
-If `rxt--print-with-overlays' is non-nil, also creates overlays linking
-elements of RX to their corresponding locations in the source
-string (see `rxt-explain-elisp', `rxt-explain-pcre' and
-`rxt--make-help-overlays')."
-  (let ((start (point)))
-    (cl-typecase rx
-      (cons
-       (pcase rx
-         (`(,(and (or `repeat `**) head)
-             ,(and (pred integerp) from)
-             ,(and (pred integerp) to)
-             . ,rest)
-           (insert (format "(%s %d %d" head from to))
-           (rxt--print-list-tail rest))
-         (`(,(and (or `repeat `= `>=) head)
-             ,(and (pred integerp) n)
-             . ,rest)
-           (insert (format "(%s %d" head n))
-           (rxt--print-list-tail rest))
-         (_
-          (rxt--print-list-tail rx t))))
-      (symbol
-       (cl-case rx
-         ;; `print' escapes the ? characters in the rx operators *?
-         ;; and +?, but this looks bad and is not strictly necessary:
-         ;; (eq (read "*?") (read "*\\?"))     => t
-         ;; (eq (read "+?") (read "+\\?"))     => t
-         ((*? +?) (insert (symbol-name rx)))
-         (t (prin1 rx (current-buffer)))))
-      (string
-       (insert (rxt--propertize-whitespace (prin1-to-string rx))))
-      (character
-       (cond
-         ((eq ?  rx)
-          (insert "?"))
-         ((memq rx rxt--print-special-chars)
-          (insert "?\\" rx))
-         ((assq rx rxt--print-char-alist)
-          (insert "?" (assoc-default rx rxt--print-char-alist)))
-         (t
-          (insert "?" (char-to-string rx)))))
-      (t
-       (prin1 rx (current-buffer))))
-    (when rxt--print-with-overlays
-      (rxt--make-help-overlays rx start (point)))))
-
-(defun rxt--print-list-tail (tail &optional open-paren)
-  (let ((rxt--print-depth (1+ rxt--print-depth)))
-    (let ((done nil))
-      (while (not done)
-        (cl-typecase tail
-          (null
-           (insert ")")
-           (setq done t))
-          (cons
-           (if open-paren
-               (progn
-                 (insert "(")
-                 (setq open-paren nil))
-             (insert " "))
-           (rxt-print (car tail))
-           (setq tail (cdr tail)))
-          (t
-           (insert " . ")
-           (rxt-print tail)
-           (insert ")")
-           (setq done t)))))))
-
-(defun rxt--make-help-overlays (rx start end)
-  (let ((location (rxt-location rx)))
-    (when (and location
-               (rxt-location-start location)
-               (rxt-location-end location))
-      (let* ((sexp-begin (copy-marker start t))
-             (sexp-end (copy-marker end))
-             (sexp-bounds (list sexp-begin sexp-end))
-
-             (source-begin (1+ (rxt-location-start location)))
-             (source-end   (1+ (rxt-location-end   location)))
-             (source-bounds (list source-begin source-end))
-
-             (bounds (list source-bounds sexp-bounds))
-
-             (sexp-ol (make-overlay sexp-begin sexp-end (current-buffer) t nil))
-             (source-ol (make-overlay source-begin source-end (current-buffer) t nil)))
-        (dolist (ol (list sexp-ol source-ol))
-          (overlay-put ol 'priority rxt--print-depth)
-          (overlay-put ol 'rxt-bounds bounds))))))
-
-(defun rxt--propertize-whitespace (string)
-  (let ((string (copy-sequence string))
-        (start 0))
-    (while (string-match rxt--whitespace-display-regexp string start)
-      (put-text-property (match-beginning 0) (match-end 0)
-                         'display
-                         (assoc-default (string-to-char (match-string 0 string))
-                                        rxt--print-char-alist)
-                         string)
-      (setq start (match-end 0)))
-    string))
-
-(defun rxt-highlight-text ()
-  "Highlight the regex syntax at point and its corresponding RX/string form."
-  (let ((all-bounds (get-char-property (point) 'rxt-bounds)))
-    (mapc #'delete-overlay rxt-highlight-overlays)
-    (setq rxt-highlight-overlays nil)
-    (dolist (bounds all-bounds)
-      (cl-destructuring-bind (begin end) bounds
-        (let ((overlay (make-overlay begin end)))
-          (push overlay rxt-highlight-overlays)
-          (overlay-put overlay 'face 'rxt-highlight-face))))))
-
-
-;;;; Error handling
-
-(if (fboundp 'define-error)
-    (define-error 'rxt-invalid-regexp "Invalid regexp" 'invalid-regexp)
-  (put 'rxt-invalid-regexp
-         'error-conditions
-         '(rxt-invalid-regexp invalid-regexp error))
-  (put 'rxt-invalid-regexp 'error-message "Invalid regexp"))
-
-(defun rxt-error (&rest format-args)
-  (signal 'rxt-invalid-regexp (list (apply #'format format-args))))
-
-
-;;;; Regexp syntax tree data type
-
-;; Base class from which other elements of the syntax-tree inherit
-(cl-defstruct rxt-syntax-tree)
-
-;; Struct representing the original source location
-(cl-defstruct rxt-location
-  source                                ; Either a string or a buffer
-  start end                             ; Offsets, 0- or 1-indexed as appropriate
-  )
-
-(defun rxt-location-text (location)
-  (if (not (rxt-location-p location))
-      nil
-    (let ((start  (rxt-location-start  location))
-          (end    (rxt-location-end    location))
-          (source (rxt-location-source location)))
-      (cond
-        ((buffer-live-p source)
-         (with-current-buffer source
-           (buffer-substring-no-properties start end)))
-        ((stringp source)
-         (substring source start end))
-        (t nil)))))
-
-;; Hash table mapping from syntax-tree elements to source locations.
-(defvar rxt-location-map (make-hash-table :weakness 'key))
-
-(defun rxt-location (object)
-  (gethash object rxt-location-map))
-
-(gv-define-setter rxt-location (value object)
-  `(puthash ,object ,value rxt-location-map))
-
-(defun rxt-source-text (object)
-  (rxt-location-text (rxt-location object)))
-
-(defun rxt-to-string (tree)
-  "Return a readable representation of TREE, a regex syntax-tree object."
-  (or (rxt-source-text tree)
-      (let ((print-level 1))
-        (prin1-to-string tree))))
-(defalias 'rxt-syntax-tree-readable 'rxt-to-string)
-
-;; FIXME
-(defvar rxt-pcre-case-fold nil)
-
-;; Literal string
-(cl-defstruct
-    (rxt-string
-      (:constructor rxt-string (chars &optional case-fold))
-      (:include rxt-syntax-tree))
-  chars
-  (case-fold rxt-pcre-case-fold))
-
-(defun rxt-empty-string ()
-  (rxt-string ""))
-
-(defun rxt-trivial-p (re)
-  (and (rxt-string-p re)
-       (equal (rxt-string-chars re) "")))
-
-;;; Other primitives
-(cl-defstruct (rxt-primitive
-               (:constructor rxt-primitive (pcre rx))
-               (:include rxt-syntax-tree))
-  pcre rx)
-
-(defun rxt-bos () (rxt-primitive "\\A" 'bos))
-(defun rxt-eos () (rxt-primitive "\\Z" 'eos))
-
-(defun rxt-bol () (rxt-primitive "^" 'bol))
-(defun rxt-eol () (rxt-primitive "$" 'eol))
-
-;; FIXME
-(defun rxt-anything () (rxt-primitive "." 'anything))
-(defun rxt-nonl () (rxt-primitive "." 'nonl))
-
-(defun rxt-word-boundary () (rxt-primitive "\\b" 'word-boundary))
-(defun rxt-not-word-boundary () (rxt-primitive "\\B" 'not-word-boundary))
-
-(defun rxt-wordchar () (rxt-primitive "\\w" 'wordchar))
-(defun rxt-not-wordchar () (rxt-primitive "\\W" 'not-wordchar))
-
-(defun rxt-symbol-start () (rxt-primitive nil 'symbol-start))
-(defun rxt-symbol-end () (rxt-primitive nil 'symbol-end))
-
-(defun rxt-bow () (rxt-primitive nil 'bow))
-(defun rxt-eow () (rxt-primitive nil 'eow))
-
-;;; Sequence
-(cl-defstruct
-    (rxt-seq
-     (:constructor make-rxt-seq (elts))
-     (:include rxt-syntax-tree))
-  elts)
-
-;; Slightly smart sequence constructor:
-;; - Flattens nested sequences
-;; - Drops trivial "" elements
-;; - Empty sequence => ""
-;; - Singleton sequence is reduced to its one element.
-(defun rxt-seq (&rest res)        ; Flatten nested seqs & drop ""'s.
-  (let ((res (rxt-seq-flatten res)))
-    (if (consp res)
-        (if (consp (cdr res))
-            (make-rxt-seq res) ; General case
-          (car res))           ; Singleton sequence
-      (rxt-empty-string))))      ; Empty seq -- ""
-
-(defun rxt-seq-flatten (res)
-  (if (consp res)
-      (let ((re (car res))
-            (tail (rxt-seq-flatten (cdr res))))
-        (cond ((rxt-seq-p re)           ; Flatten nested seqs
-               (append (rxt-seq-flatten (rxt-seq-elts re)) tail))
-              ((rxt-trivial-p re) tail) ; Drop trivial elts
-              ((and (rxt-string-p re)   ; Flatten strings
-                    (consp tail)
-                    (rxt-string-p (car tail)))
-               (cons
-                (rxt-string-concat re (car tail))
-                (cdr tail)))
-              (t (cons re tail))))
-    '()))
-
-(defun rxt-string-concat (str1 str2)
-  (if (not (eq (rxt-string-case-fold str1)
-               (rxt-string-case-fold str2)))
-      (make-rxt-seq (list str1 str2))
-    (let ((result
-           (rxt-string (concat (rxt-string-chars str1)
-                               (rxt-string-chars str2))
-                       (rxt-string-case-fold str1)))
-          (first (rxt-location str1))
-          (last  (rxt-location str2)))
-      (when (and first last)
-        (setf (rxt-location result)
-              (make-rxt-location :source (rxt-location-source first)
-                                 :start  (rxt-location-start first)
-                                 :end    (rxt-location-end last))))
-      result)))
-
-;;; Choice (alternation/union)
-(cl-defstruct
-    (rxt-choice
-     (:constructor make-rxt-choice (elts))
-     (:include rxt-syntax-tree))
-  elts)
-
-;;; The empty choice represents a regexp that never matches in any context
-(defvar rxt-empty (make-rxt-choice nil))
-(defun rxt-empty-p (re)
-  (or
-   (and (rxt-choice-p re)
-        (null (rxt-choice-elts re)))
-   (rxt-empty-char-set-p re)))
-
-(defun rxt-choice (&rest alternatives)
-  "Construct the alternation (union) of several regexps.
-
-ALTERNATIVES should be a list of `rxt-syntax-tree' objects.
-The return value is an `rxt-choice' object representing a regexp
-which matches any one of ALTERNATIVES, but simplified in the
-following ways:
-
-- If ALTERNATIVES contains only one element, it is returned unchanged.
-
-- All existing `rxt-choice' elements in ALTERNATIVES are replaced
-  by a flat list of their subexpressions: symbolically,
-  a|(b|(c|d)) is replaced by a|b|c|d
-
-- All character sets and single-character strings in ALTERNATIVES
-  are combined together into one or two character sets,
-  respecting case-folding behaviour."
-  (cl-destructuring-bind (other-elements char-set case-fold-char-set)
-      (rxt--simplify-alternatives alternatives)
-    (let ((simplified-alternatives
-           (append (if (not (rxt-empty-p char-set))
-                       (list char-set)
-                     '())
-                   (if (not (rxt-empty-p case-fold-char-set))
-                       (list case-fold-char-set)
-                     '())
-                   other-elements)))
-      (pcase simplified-alternatives
-        (`()
-          rxt-empty)
-        (`(,element)
-          element)
-        (_
-         (make-rxt-choice simplified-alternatives))))))
-
-(defun rxt--simplify-alternatives (alternatives)
-  "Simplify a set of regexp alternatives.
-
-ALTERNATIVES should be a list of `rxt-syntax-tree' objects to be combined
-into an `rxt-choice' structure.  The result is a three-element
-list (OTHER-ELEMENTS CHAR-SET CASE-FOLDED-CHAR-SET):
-
-- CHAR-SET is an `rxt-char-set-union' containing the union of all
-  case-sensitive character sets and single-character strings in
-  RES.
-
-- CASE-FOLDED-CHAR-SET is similar but combines all the
-  case-insensitive character sets and single-character strings.
-
-- OTHER-ELEMENTS is a list of all other elements, with all
-  `rxt-choice' structures replaced by a flat list of their
-  component subexpressions."
-  (if (null alternatives)
-      (list '()
-            (make-rxt-char-set-union :case-fold nil)
-            (make-rxt-char-set-union :case-fold t))
-    (let* ((re (car alternatives)))
-      (cl-destructuring-bind (tail char-set case-fold-char-set)
-          (rxt--simplify-alternatives (cdr alternatives))
-        (cond ((rxt-choice-p re)         ; Flatten nested choices
-               (list
-                (append (rxt-choice-elts re) tail)
-                char-set
-                case-fold-char-set))
-
-              ((rxt-empty-p re)          ; Drop empty re's.
-               (list tail char-set case-fold-char-set))
-
-              ((rxt-char-set-union-p re) ; Fold char sets together
-               (if (rxt-char-set-union-case-fold re)
-                   (list tail
-                         char-set
-                         (rxt-char-set-union case-fold-char-set re))
-                 (list tail
-                       (rxt-char-set-union char-set re)
-                       case-fold-char-set)))
-
-              ((and (rxt-string-p re)    ; Same for 1-char strings
-                    (= 1 (length (rxt-string-chars re))))
-               (if (rxt-string-case-fold re)
-                   (list tail
-                         char-set
-                         (rxt-char-set-union case-fold-char-set re))
-                 (list tail
-                       (rxt-char-set-union char-set re)
-                       case-fold-char-set)))
-
-              (t                         ; Otherwise.
-               (list (cons re tail) char-set case-fold-char-set)))))))
-
-;;; Repetition
-(cl-defstruct (rxt-repeat
-               (:include rxt-syntax-tree))
-  from to body greedy)
-
-(cl-defun rxt-repeat (from to body &optional (greedy t))
-  (if (equal to 0)
-      (rxt-empty-string)
-    (make-rxt-repeat :from from :to to
-                     :body body :greedy greedy)))
-
-;;; Submatch
-(cl-defstruct
-    (rxt-submatch
-     (:constructor rxt-submatch (body))
-     (:include rxt-syntax-tree))
-  body)
-
-;;; Numbered submatch (Emacs only)
-(cl-defstruct
-    (rxt-submatch-numbered
-     (:constructor rxt-submatch-numbered (n body))
-     (:include rxt-syntax-tree))
-  n
-  body)
-
-;;; Backreference
-(cl-defstruct
-    (rxt-backref
-     (:constructor rxt-backref (n))
-     (:include rxt-syntax-tree))
-  n)
-
-;;; Syntax classes (Emacs only)
-(cl-defstruct (rxt-syntax-class
-               (:include rxt-syntax-tree))
-  symbol)
-
-(defun rxt-syntax-class (symbol)
-  (if (assoc symbol rx-syntax)
-      (make-rxt-syntax-class :symbol symbol)
-    (rxt-error "Invalid syntax class symbol `%s'" symbol)))
-
-;;; Character categories (Emacs only)
-(cl-defstruct (rxt-char-category
-               (:include rxt-syntax-tree))
-  symbol)
-
-(defun rxt-char-category (symbol)
-  (if (assoc symbol rx-categories)
-      (make-rxt-char-category :symbol symbol)
-    (rxt-error "Invalid character category symbol `%s'" symbol)))
-
-
-;;; Char sets
-;; <rxt-char-set> ::= <rxt-char-set-union>
-;;                  | <rxt-char-set-negation>
-;;                  | <rxt-char-set-intersection>
-
-(cl-defstruct (rxt-char-set (:include rxt-syntax-tree)))
-
-;; An rxt-char-set-union represents the union of any number of
-;; characters, character ranges, and POSIX character classes: anything
-;; that can be represented in string notation as a class [ ... ]
-;; without the negation operator.
-(cl-defstruct (rxt-char-set-union
-                (:include rxt-char-set))
-  chars    ; list of single characters
-  ranges   ; list of ranges (from . to)
-  classes  ; list of character classes
-  (case-fold rxt-pcre-case-fold))
-
-;; Test for empty character set
-(defun rxt-empty-char-set-p (cset)
-  (and (rxt-char-set-union-p cset)
-       (null (rxt-char-set-union-chars cset))
-       (null (rxt-char-set-union-ranges cset))
-       (null (rxt-char-set-union-classes cset))))
-
-;; Simple union constructor
-(defun rxt-char-set-union (&rest items)
-  "Construct an regexp character set representing the union of ITEMS.
-
-Each element of ITEMS may be either: a character; a
-single-character string; a single-character `rxt-string' object;
-a cons, (FROM . TO) representing a range of characters; a symbol,
-representing a named character class; or an `rxt-char-set-union'
-object.  All `rxt-char-set-union' objects in ITEMS must have the
-same `case-fold' property."
-  (let ((chars '())
-        (ranges '())
-        (classes '())
-        (case-fold 'undetermined))
-    (dolist (item items)
-      (cl-etypecase item
-        (character
-         (push item chars))
-
-        (string
-         (cl-assert (= 1 (length item)))
-         (push (string-to-char item) chars))
-
-        (rxt-string
-         (cl-assert (= 1 (length (rxt-string-chars item))))
-         (push (string-to-char (rxt-string-chars item)) chars))
-
-        (cons                           ; range (from . to)
-         (cl-check-type (car item) character)
-         (cl-check-type (cdr item) character)
-         (push item ranges))
-
-        (symbol                         ; named character class
-         (push item classes))
-
-        (rxt-char-set-union
-         (if (eq case-fold 'undetermined)
-             (setq case-fold (rxt-char-set-union-case-fold item))
-           (unless (eq case-fold (rxt-char-set-union-case-fold item))
-             (error "Cannot construct union of char-sets with unlike case-fold setting: %S" item)))
-         (setq chars (nconc chars (rxt-char-set-union-chars item)))
-         (setq ranges (nconc ranges (rxt-char-set-union-ranges item)))
-         (setq classes (nconc classes (rxt-char-set-union-classes item))))))
-
-    (make-rxt-char-set-union :chars chars :ranges ranges :classes classes
-                             :case-fold (if (eq case-fold 'undetermined)
-                                            rxt-pcre-case-fold
-                                          case-fold))))
-
-(defun rxt--all-char-set-union-chars (char-set)
-  "Return a list of all characters in CHAR-SET."
-  (cl-assert (rxt-char-set-union-p char-set))
-  (append
-   (rxt-char-set-union-chars char-set)
-   (cl-loop for (start . end) in (rxt-char-set-union-ranges char-set)
-            nconc (cl-loop for char from start to end collect char))))
-
-(defun rxt--simplify-char-set (char-set &optional case-fold-p)
-  "Return a minimal char-set to match the same characters as CHAR-SET.
-
-With optional argument CASE-FOLD-P, return a char-set which
-emulates case-folding behaviour by including both uppercase and
-lowercase versions of all characters in CHAR-SET."
-  (cl-assert (rxt-char-set-union-p char-set))
-  (let* ((classes (rxt-char-set-union-classes char-set))
-         (all-chars
-          (if case-fold-p
-              (cl-loop for char in (rxt--all-char-set-union-chars char-set)
-                       nconc (list (upcase char) (downcase char)))
-            (rxt--all-char-set-union-chars char-set)))
-         (all-ranges
-          (rxt--extract-ranges (rxt--remove-redundant-chars all-chars classes))))
-    (let ((singletons nil)
-          (ranges nil))
-      (cl-loop for (start . end) in all-ranges
-               do
-               (cond ((= start end) (push start singletons))
-                     ((= (1+ start) end)
-                      (push start singletons)
-                      (push end singletons))
-                     (t (push (cons start end) ranges))))
-      (make-rxt-char-set-union :chars (nreverse singletons)
-                               :ranges (nreverse ranges)
-                               :classes classes
-                               :case-fold (if case-fold-p
-                                              nil
-                                            (rxt-char-set-union-case-fold char-set))))))
-
-(defun rxt--remove-redundant-chars (chars classes)
-  "Remove all characters which match a character class in CLASSES from CHARS."
-  (if (null classes)
-      chars
-    (string-to-list
-     (replace-regexp-in-string
-      (rx-to-string `(any ,@classes))
-      ""
-      (apply #'string chars)))))
-
-(defun rxt--extract-ranges (chars)
-  "Return a list of all contiguous ranges in CHARS.
-
-CHARS should be a list of characters (integers).  The return
-value is a list of conses (START . END) representing ranges, such
-that the union of all the ranges represents the same of
-characters as CHARS.
-
-Example:
-    (rxt--extract-ranges (list ?a ?b ?c ?q ?x ?y ?z))
-        => ((?a . ?c) (?q . ?q) (?x . ?z))"
-  (let ((array
-         (apply #'vector
-                (cl-remove-duplicates
-                 (sort (copy-sequence chars) #'<)))))
-    (cl-labels
-        ((recur (start end)
-           (if (< end start)
-               nil
-             (let ((min (aref array start))
-                   (max (aref array end)))
-               (if (= (- max min) (- end start))
-                   (list (cons min max))
-                 (let* ((split-point (/ (+ start end) 2))
-                        (left (recur start split-point))
-                        (right (recur (1+ split-point) end)))
-                   (merge left right))))))
-         (merge (left right)
-           (cond ((null left) right)
-                 ((null right) left)
-                 (t
-                  (let ((last-left (car (last left)))
-                        (first-right (car right)))
-                    (if (= (1+ (cdr last-left))
-                           (car first-right))
-                        (append (cl-subseq left 0 -1)
-                                (list
-                                 (cons (car last-left)
-                                       (cdr first-right)))
-                                (cl-subseq right 1))
-                      (append left right)))))))
-      (recur 0 (1- (length array))))))
-
-;;; Set complement of character set, syntax class, or character
-;;; category
-
-;; In general, all character sets that can be represented in string
-;; notation as [^ ... ] (but see `rxt-char-set-intersection', below), plus
-;; Emacs' \Sx and \Cx constructions.
-(cl-defstruct (rxt-char-set-negation
-               (:include rxt-char-set))
-  elt)
-
-(defun rxt-negate (char-set)
-  "Construct the logical complement (negation) of CHAR-SET.
-
-CHAR-SET may be any of the following types: `rxt-char-set-union',
-`rxt-syntax-class', `rxt-char-category', or `rxt-char-set-negation'."
-  (cl-etypecase char-set
-    ((or rxt-char-set-union rxt-syntax-class rxt-char-category)
-     (make-rxt-char-set-negation :elt char-set))
-
-    (rxt-char-set-negation
-     (rxt-char-set-negation-elt char-set))))
-
-;;; Intersections of char sets
-
-;; These are difficult to represent in general, but can be constructed
-;; in Perl using double negation; for example: [^\Wabc] means the set
-;; complement of [abc] with respect to the universe of "word
-;; characters": (& (~ (~ word)) (~ ("abc"))) == (& word (~ ("abc")))
-;; == (- word ("abc"))
-
-(cl-defstruct (rxt-char-set-intersection
-               (:include rxt-char-set))
-  elts)
-
-;; Intersection constructor
-(defun rxt-char-set-intersection (&rest charsets)
-  (let ((elts '())
-        (cmpl (make-rxt-char-set-union)))
-    (dolist (cset (rxt-int-flatten charsets))
-      (cond
-       ((rxt-char-set-negation-p cset)
-        ;; Fold negated charsets together: ~A & ~B = ~(A|B)
-        (setq cmpl (rxt-char-set-union cmpl (rxt-char-set-negation-elt cset))))
-
-       ((rxt-char-set-union-p cset)
-        (push cset elts))
-
-       (t
-        (rxt-error "Can't take intersection of non-character-set %S" cset))))
-
-    (if (null elts)
-        (rxt-negate cmpl)
-      (unless (rxt-empty-char-set-p cmpl)
-        (push (rxt-negate cmpl) elts))
-      (if (null (cdr elts))
-          (car elts)      ; singleton case
-        (make-rxt-char-set-intersection :elts elts)))))
-
-;; Constructor helper: flatten nested intersections
-(defun rxt-int-flatten (csets)
-  (if (consp csets)
-      (let ((cset (car csets))
-            (tail (rxt-int-flatten (cdr csets))))
-        (if (rxt-char-set-intersection-p cset)
-            (append (rxt-int-flatten (rxt-char-set-intersection-elts cset)) tail)
-          (cons cset tail)))
-    '()))
-
-
-
-;;;; Macros for building the parser
-
-(defmacro rxt-token-case (&rest cases)
-  "Consume a token at point and evaluate corresponding forms.
-
-CASES is a list of `cond'-like clauses, (REGEXP BODY ...) where
-the REGEXPs define possible tokens which may appear at point. The
-CASES are considered in order. For each case, if the text at
-point matches REGEXP, then point is moved to the end of the
-matched token, the corresponding BODY is evaluated and their
-value returned. The matched token is available within the BODY
-forms as (match-string 0).
-
-There can be a default case where REGEXP is `t', which evaluates
-the corresponding FORMS but does not move point.
-
-Returns `nil' if none of the CASES matches."
-  (declare (debug (&rest (sexp &rest form))))
-  `(cond
-     ,@(cl-loop for (token . action) in cases
-                collect
-                (if (eq token t)
-                    `(t ,@action)
-                  `((looking-at ,token)
-                    (goto-char (match-end 0))
-                    ,@action)))))
-
-(defmacro rxt-with-source-location (&rest body)
-  "Evaluate BODY and record source location information on its value. 
-
-BODY may evaluate to any kind of object, but its value should
-generally not be `eq' to any other object."
-  (declare (debug (&rest form)))
-  (let ((begin (make-symbol "begin"))
-        (value (make-symbol "value")))
-    `(let ((,begin (point))
-           (,value ,(macroexp-progn body)))
-       (setf (rxt-location ,value)
-             (make-rxt-location :source rxt-source-text-string
-                                :start  (1- ,begin)
-                                :end    (1- (point))))
-       ,value)))
-
-;; Read PCRE + flags
-(defun rxt-read-delimited-pcre ()
-  "Read a Perl-style delimited regexp and flags from the current buffer.
-
-Point should be before the regexp literal before calling
-this. Currently only regexps delimited by / ... / are supported.
-A preceding \"m\", \"qr\" or \"s\" will be ignored, as will the
-replacement string in an s/.../.../ construction.
-
-Returns two strings: the regexp and the flags."
-  (save-excursion
-    (skip-syntax-forward "-")
-
-    ;; Skip m, qr, s
-    (let ((is-subst (rxt-token-case
-                     ("s" t)
-                     ((rx (or "m" "qr")) nil))))
-
-      (when (not (looking-at "/"))
-        (error "Only Perl regexps delimited by slashes are supported"))
-      (let ((beg (match-end 0))
-            (delim (rx (not (any "\\"))
-                       (group "/"))))
-        (search-forward-regexp delim)
-        (let ((end (match-beginning 1)))
-          (when is-subst (search-forward-regexp delim))
-          (let ((pcre (buffer-substring-no-properties beg end)))
-            (rxt-token-case
-             ("[gimosx]*"
-              (rxt--add-flags pcre (match-string-no-properties 0))))))))))
-
-
-;;;; Elisp and PCRE string notation parser
-
-;;; Parser constants
-(defconst rxt-pcre-char-set-alist
-  `((?w .                               ; "word" characters
-        (?_ alnum))
-    (?d .                               ; digits
-        (digit))
-    (?h .                               ; horizontal whitespace
-        (#x0009 #x0020 #x00A0 #x1680 #x180E #x2000 #x2001 #x2002 #x2003
-                #x2004 #x2005 #x2006 #x2007 #x2008 #x2009 #x200A #x202F
-                #x205F #x3000))
-    (?s .                               ; whitespace
-        (9 10 12 13 32))
-    (?v .                               ; vertical whitespace
-        (#x000A #x000B #x000C #x000D #x0085 #x2028 #x2029))))
-
-(defconst rxt-pcre-named-classes-regexp
-  (rx "[:"
-      (submatch
-       (or "alnum" "alpha" "ascii" "blank" "cntrl" "digit" "graph" "lower"
-           "print" "punct" "space" "upper" "word" "xdigit"))
-      ":]"))
-
-(defconst rxt-elisp-named-classes-regexp
-  (rx "[:"
-      (submatch
-       (or "alnum" "alpha" "ascii" "blank" "cntrl" "digit" "graph" "lower"
-           "print" "punct" "space" "upper" "word" "xdigit"
-           "unibyte" "nonascii" "multibyte"))
-      ":]"))
-
-;;; The following dynamically bound variables control the operation of
-;;; the parser (see `rxt-parse-re'.)
-(defvar rxt-parse-pcre nil
-  "t if the rxt string parser is parsing PCRE syntax, nil for Elisp syntax.
-
-This should only be let-bound internally, never set otherwise.")
-
-(defvar rxt-pcre-extended-mode nil
-  "t if the rxt string parser is emulating PCRE's \"extended\" mode.
-
-In extended mode (indicated by /x in Perl/PCRE), whitespace
-outside of character classes and \\Q...\\E quoting is ignored,
-and a `#' character introduces a comment that extends to the end
-of line.")
-
-(defvar rxt-pcre-s-mode nil
-  "t if the rxt string parser is emulating PCRE's single-line \"/s\" mode.
-
-When /s is used, PCRE's \".\" matches newline characters, which
-otherwise it would not match.")
-
-(defvar rxt-pcre-case-fold nil
-  "non-nil to emulate PCRE's case-insensitive \"/i\" mode in translated regexps.")
-
-(defvar rxt-branch-end-regexp nil)
-(defvar rxt-choice-regexp nil)
-(defvar rxt-brace-begin-regexp nil)
-(defvar rxt-m-to-n-brace-regexp nil)
-(defvar rxt-m-to-?-brace-regexp nil)
-(defvar rxt-m-brace-regexp nil)
-(defvar rxt-named-classes-regexp nil)
-
-(defvar rxt-subgroup-count nil)
-(defvar rxt-source-text-string nil)
-
-(defun rxt-parse-pcre (re)
-  (rxt-parse-re re t))
-
-(defun rxt-parse-elisp (re)
-  (rxt-parse-re re nil))
-
-(defun rxt-parse-re (re pcre-p)
-  (let* ((rxt-parse-pcre pcre-p)
-         (rxt-pcre-extended-mode nil)
-         (rxt-pcre-s-mode        nil)
-         (rxt-pcre-case-fold     nil)
-
-         ;; Bind regexps to match syntax that differs between PCRE and
-         ;; Elisp only in the addition of a backslash "\"
-         (escape (if pcre-p "" "\\"))
-         (rxt-choice-regexp
-          (rx-to-string `(seq ,escape "|")))
-         (rxt-branch-end-regexp
-          (rx-to-string `(or buffer-end
-                             (seq ,escape (or "|" ")")))))
-         (rxt-brace-begin-regexp
-          (rx-to-string `(seq ,escape "{")))
-         (rxt-m-to-n-brace-regexp
-          (rx-to-string
-           `(seq
-             (submatch (* (any "0-9"))) "," (submatch (+ (any "0-9")))
-             ,escape "}")))
-         (rxt-m-to-?-brace-regexp
-          (rx-to-string
-           `(seq (submatch (+ (any "0-9"))) "," ,escape "}")))
-         (rxt-m-brace-regexp
-          (rx-to-string
-           `(seq (submatch (+ (any "0-9"))) ,escape "}")))
-
-         ;; Named character classes [: ... :] differ slightly
-         (rxt-named-classes-regexp
-          (if pcre-p
-              rxt-pcre-named-classes-regexp
-            rxt-elisp-named-classes-regexp))
-
-         (rxt-subgroup-count 0)
-         (case-fold-search nil))
-    (with-temp-buffer
-      (insert re)
-      (goto-char (point-min))
-      (let ((rxt-source-text-string re))
-        (rxt-parse-exp)))))
-
-;; Parse a complete regex: a number of branches separated by | or
-;; \|, as determined by `rxt-branch-end-regexp'.
-(defun rxt-parse-exp ()
-  ;; These variables are let-bound here because in PCRE mode they may
-  ;; be set internally by (?x) or (?s) constructions, whose scope
-  ;; lasts until the end of a sub-expression
-  (rxt-with-source-location
-   (let ((rxt-pcre-extended-mode rxt-pcre-extended-mode)
-         (rxt-pcre-s-mode rxt-pcre-s-mode)
-         (rxt-pcre-case-fold rxt-pcre-case-fold))
-     (if (eobp)
-         (rxt-seq)
-       (let ((branches '()))
-         (cl-block nil
-           (while t
-             (let ((branch (rxt-parse-branch)))
-               (push branch branches)
-               (rxt-token-case
-                (rxt-choice-regexp nil)
-                (t (cl-return (apply #'rxt-choice (reverse branches)))))))))))))
-
-;; Skip over whitespace and comments in PCRE extended mode
-(defun rxt-extended-skip ()
-  (when rxt-pcre-extended-mode
-    (skip-syntax-forward "-")
-    (while (looking-at "#")
-      (beginning-of-line 2)
-      (skip-syntax-forward "-"))))
-
-;; Parse a regexp "branch": a sequence of pieces
-(defun rxt-parse-branch ()
-  (rxt-extended-skip)
-  (rxt-with-source-location
-   (let ((pieces '())
-         (branch-start-p t))
-     (while (not (looking-at rxt-branch-end-regexp))
-       (push (rxt-parse-piece branch-start-p) pieces)
-       (setq branch-start-p nil))
-     (apply #'rxt-seq (reverse pieces)))))
-
-;; Parse a regexp "piece": an atom (`rxt-parse-atom') plus any
-;; following quantifiers
-(defun rxt-parse-piece (&optional branch-begin)
-  (rxt-extended-skip)
-  (rxt-with-source-location
-   (let ((atom (rxt-parse-atom branch-begin)))
-     (rxt-parse-quantifiers atom))))
-
-;; Parse any and all quantifiers after ATOM and return the quantified
-;; regexp, or ATOM unchanged if no quantifiers
-(defun rxt-parse-quantifiers (atom)
-  (catch 'done
-    (while (not (eobp))
-      (let ((atom1 (rxt-parse-quantifier atom)))
-        (if (eq atom1 atom)
-            (throw 'done t)
-          (setq atom atom1)))))
-  atom)
-
-;; Possibly parse a single quantifier after ATOM and return the
-;; quantified atom, or ATOM if no quantifier
-(defun rxt-parse-quantifier (atom)
-  (rxt-extended-skip)
-  (rxt-token-case
-   ((rx "*?") (rxt-repeat 0 nil atom nil))
-   ((rx "*")  (rxt-repeat 0 nil atom t))
-   ((rx "+?") (rxt-repeat 1 nil atom nil))
-   ((rx "+")  (rxt-repeat 1 nil atom t))
-   ((rx "??") (rxt-repeat 0 1 atom nil))
-   ((rx "?")  (rxt-repeat 0 1 atom t))
-   ;; Brace expression "{M,N}", "{M,}", "{M}"
-   (rxt-brace-begin-regexp
-    (cl-destructuring-bind (from to)
-        (rxt-parse-braces)
-      (rxt-repeat from to atom)))
-   ;; No quantifiers found
-   (t atom)))
-
-;; Parse a regexp atom, i.e. an element that binds to any following
-;; quantifiers. This includes characters, character classes,
-;; parenthesized groups, assertions, etc.
-(defun rxt-parse-atom (&optional branch-begin)
-  (if (eobp)
-      (rxt-error "Unexpected end of regular expression")
-    (if rxt-parse-pcre
-        (rxt-parse-atom/pcre)
-      (rxt-parse-atom/el branch-begin))))
-
-(defun rxt-parse-atom/common ()
-  (rxt-token-case
-   ((rx "[")   (rxt-parse-char-class))
-   ((rx "\\b") (rxt-word-boundary))
-   ((rx "\\B") (rxt-not-word-boundary))))
-
-(defun rxt-parse-atom/el (branch-begin)
-  (rxt-with-source-location
-   (or (rxt-parse-atom/common)
-       (rxt-token-case
-        ;; "." wildcard
-        ((rx ".") (rxt-nonl))
-        ;; "^" and "$" are metacharacters only at beginning or end of a
-        ;; branch in Elisp; elsewhere they are literals
-        ((rx "^")
-         (if branch-begin
-             (rxt-bol)
-           (rxt-string "^")))
-        ((rx "$")
-         (if (looking-at rxt-branch-end-regexp)
-             (rxt-eol)
-           (rxt-string "$")))
-        ;; Beginning & end of string, word, symbol
-        ((rx "\\`") (rxt-bos))
-        ((rx "\\'") (rxt-eos))
-        ((rx "\\<") (rxt-bow))
-        ((rx "\\>") (rxt-eow))
-        ((rx "\\_<") (rxt-symbol-start))
-        ((rx "\\_>") (rxt-symbol-end))
-        ;; Subgroup
-        ((rx "\\(") (rxt-parse-subgroup/el))
-        ;; Word/non-word characters (meaning depending on syntax table)
-        ((rx "\\w") (rxt-wordchar))
-        ((rx "\\W") (rxt-not-wordchar))
-        ;; Other syntax categories
-        ((rx "\\" (submatch (any ?S ?s)) (submatch nonl))
-         (let ((negated (string= (match-string 1) "S"))
-               (syntax
-                (car (rassoc (string-to-char (match-string 2))
-                              rx-syntax))))
-           (if syntax
-               (let ((re (rxt-syntax-class syntax)))
-                 (if negated (rxt-negate re) re))
-             (rxt-error "Invalid syntax class `\\%s'" (match-string 0)))))
-        ;; Character categories
-        ((rx "\\" (submatch (any ?C ?c)) (submatch nonl))
-         (let ((negated (string= (match-string 1) "C"))
-               (category
-                (car (rassoc (string-to-char (match-string 2))
-                             rx-categories))))
-           (if category
-               (let ((re (rxt-char-category category)))
-                 (if negated (rxt-negate re) re))
-             (rxt-error "Invalid character category `%s'" (match-string 0)))))
-        ;; Backreference
-        ((rx (seq "\\" (submatch (any "1-9"))))
-         (rxt-backref (string-to-number (match-string 1))))
-        ;; Other escaped characters
-        ((rx (seq "\\" (submatch nonl)))
-         (rxt-string (match-string 1)))
-        ;; Normal characters
-        ((rx (or "\n" nonl))
-         (rxt-string (match-string 0)))))))
-
-(defun rxt-parse-atom/pcre ()
-  (rxt-extended-skip)
-  (rxt-with-source-location
-   (or
-    ;; Is it an atom that's the same in Elisp?
-    (rxt-parse-atom/common)
-    ;; Is it common to PCRE regex and character class syntax?
-    (let ((char (rxt-parse-escapes/pcre)))
-      (and char
-           (rxt-string (char-to-string char))))
-    ;; Otherwise:
-    (rxt-token-case
-     ;; "." wildcard
-     ((rx ".")
-      (if rxt-pcre-s-mode
-          (rxt-anything)
-        (rxt-nonl)))
-     ;; Beginning & end of string/line
-     ((rx "^") (rxt-bol))
-     ((rx "$") (rxt-eol))
-     ((rx "\\A") (rxt-bos))
-     ((rx "\\Z") (rxt-eos))
-     ;; Subgroup
-     ((rx "(") (rxt-parse-subgroup/pcre))
-     ;; Metacharacter quoting
-     ((rx "\\Q")
-      ;; It would seem simple to take all the characters between \Q
-      ;; and \E and make an rxt-string, but \Q...\E isn't an atom:
-      ;; any quantifiers afterward should bind only to the last
-      ;; character, not the whole string.
-      (let ((begin (point)))
-        (search-forward "\\E" nil t)
-        (let* ((end (match-beginning 0))
-               (str (buffer-substring-no-properties begin (1- end)))
-               (char (char-to-string (char-before end))))
-          (rxt-seq (rxt-string str)
-                   (rxt-parse-quantifiers (rxt-string char))))))
-     ;; Pre-defined character sets
-     ((rx "\\" (submatch (any "d" "D" "h" "H" "s" "S" "v" "V" "w" "W")))
-      (rxt--pcre-char-set (string-to-char (match-string 1))))
-     ;; \ + digits: backreference or octal char?
-     ((rx "\\" (submatch (+ (any "0-9"))))
-      (let* ((digits (match-string 1))
-             (dec (string-to-number digits)))
-        ;; from "man pcrepattern": If the number is less than 10, or if
-        ;; there have been at least that many previous capturing left
-        ;; parentheses in the expression, the entire sequence is taken
-        ;; as a back reference.
-        (if (and (> dec 0)
-                 (or (< dec 10)
-                     (>= rxt-subgroup-count dec)))
-            (progn
-              (when rxt-pcre-case-fold
-                (display-warning
-                 'rxt "Backreferences with case-folding are handled poorly"))
-              (rxt-backref dec))
-          ;; from "man pcrepattern": if the decimal number is greater
-          ;; than 9 and there have not been that many capturing
-          ;; subpatterns, PCRE re-reads up to three octal digits
-          ;; following the backslash, and uses them to generate a data
-          ;; character. Any subsequent digits stand for themselves.
-          (goto-char (match-beginning 1))
-          (re-search-forward (rx (** 0 3 (any "0-7"))))
-          (rxt-string (char-to-string (string-to-number (match-string 0) 8))))))
-     ;; Other escaped characters
-     ((rx "\\" (submatch nonl)) (rxt-string (match-string 1)))
-     ;; Everything else
-     ((rx (or (any "\n") nonl)) (rxt-string (match-string 0)))))))
-
-(defun rxt-parse-escapes/pcre ()
-  "Consume a one-char PCRE escape at point and return its codepoint equivalent.
-
-Handles only those character escapes which have the same meaning
-in character classes as outside them."
-  (rxt-token-case
-   ((rx "\\a") #x07) ; bell
-   ((rx "\\e") #x1b) ; escape
-   ((rx "\\f") #x0c) ; formfeed
-   ((rx "\\n") #x0a) ; linefeed
-   ((rx "\\r") #x0d) ; carriage return
-   ((rx "\\t") #x09) ; tab
-   ;; Control character
-   ((rx "\\c" (submatch nonl))
-    ;; from `man pcrepattern':
-    ;; The precise effect of \cx is as follows: if x is a lower case
-    ;; letter, it is converted to upper case.  Then bit 6 of the
-    ;; character (hex 40) is inverted.
-    (logxor (string-to-char (upcase (match-string 1))) #x40))
-   ;; Hex escapes
-   ((rx "\\x" (submatch (** 1 2 (any "0-9" "A-Z" "a-z"))))
-    (string-to-number (match-string 1) 16))
-   ((rx "\\x{" (submatch (* (any "0-9" "A-Z" "a-z"))) "}")
-    (string-to-number (match-string 1) 16))))
-
-(defun rxt-parse-subgroup/pcre ()
-  (catch 'return
-    (let ((shy nil)
-          (extended-mode rxt-pcre-extended-mode)
-          (single-line-mode rxt-pcre-s-mode)
-          (case-fold rxt-pcre-case-fold))
-      (rxt-extended-skip)
-      ;; Check for special (? ..) and (* ...) syntax
-      (rxt-token-case
-       ((rx "?")                        ; (?
-        (rxt-token-case
-         ((rx ")")                      ; Empty group (?)
-          (throw 'return (rxt-empty-string)))
-         (":" (setq shy t))             ; Shy group (?:
-         ("#"                           ; Comment   (?#
-          (search-forward ")")
-          (throw 'return (rxt-empty-string)))
-         ((rx (or                       ; Flags     (?isx-isx
-               (seq (group (* (any "gimosx"))) "-" (group (+ (any "gimosx"))))
-               (seq (group (+ (any "gimosx"))))))
-          (let ((token (match-string 0))
-                (on (or (match-string 1) (match-string 3)))
-                (off (or (match-string 2) "")))
-            (if (cl-find ?x on)  (setq extended-mode t))
-            (if (cl-find ?s on)  (setq single-line-mode t))
-            (if (cl-find ?i on)  (setq case-fold t))
-            (if (cl-find ?x off) (setq extended-mode nil))
-            (if (cl-find ?s off) (setq single-line-mode nil))
-            (if (cl-find ?i off) (setq case-fold nil))
-            (when (string-match-p "[gmo]" token)
-              (display-warning
-               'rxt (format "Unhandled PCRE flags in (?%s" token))))
-          (rxt-token-case
-           (":" (setq shy t))        ; Shy group with flags (?isx-isx: ...
-           (")"                      ; Set flags (?isx-isx)
-            ;; Set flags for the remainder of the current subexpression
-            (setq rxt-pcre-extended-mode extended-mode
-                  rxt-pcre-s-mode single-line-mode
-                  rxt-pcre-case-fold case-fold)
-            (throw 'return (rxt-empty-string)))))
-         ;; Other constructions like (?=, (?!, etc. are not recognised
-         (t (rxt-error "Unrecognized PCRE extended construction `(?%c'"
-                       (char-after)))))
-
-       ;; No special (* ...) verbs are recognised
-       ((rx "*")
-        (let ((begin (point)))
-          (search-forward ")" nil 'go-to-end)
-          (rxt-error "Unrecognized PCRE extended construction `(*%s'"
-                     (buffer-substring begin (point))))))
-
-      ;; Parse the remainder of the subgroup
-      (unless shy (cl-incf rxt-subgroup-count))
-      (let* ((rxt-pcre-extended-mode extended-mode)
-             (rxt-pcre-s-mode single-line-mode)
-             (rxt-pcre-case-fold case-fold)
-             (rx (rxt-parse-exp)))
-        (rxt-extended-skip)
-        (rxt-token-case
-         (")" (if shy rx (rxt-submatch rx)))
-         (t (rxt-error "Subexpression missing close paren")))))))
-
-(defun rxt-parse-subgroup/el ()
-  (let ((kind
-         (rxt-token-case
-          ((rx "?:")
-           (cl-incf rxt-subgroup-count)
-           'shy)
-          ((rx "?" (group (+ (in "0-9"))) ":")
-           (let ((n (string-to-number (match-string 1))))
-             (when (< rxt-subgroup-count n)
-               (setf rxt-subgroup-count n))
-             n))
-          ((rx "?") ; Reserved
-           (rxt-error "Unknown match group sequence")))))
-    (let ((rx (rxt-parse-exp)))
-      (rxt-token-case
-       ((rx "\\)")
-        (cond ((eq kind 'shy) rx)
-              ((numberp kind)
-               (rxt-submatch-numbered kind rx))
-              (t (rxt-submatch rx))))
-       (t (rxt-error "Subexpression missing close paren"))))))
-
-(defun rxt-parse-braces ()
-  (rxt-token-case
-   (rxt-m-to-n-brace-regexp
-    (list (string-to-number (match-string 1))
-          (string-to-number (match-string 2))))
-   (rxt-m-to-?-brace-regexp
-    (list (string-to-number (match-string 1)) nil))
-   (rxt-m-brace-regexp
-    (let ((a (string-to-number (match-string 1))))
-      (list a a)))
-   (t
-    (let ((begin (point)))
-      (search-forward "}" nil 'go-to-end)
-      (rxt-error "Bad brace expression {%s"
-                 (buffer-substring-no-properties begin (point)))))))
-
-;; Parse a character set range [...]
-(defun rxt-parse-char-class ()
-  (when (eobp)
-    (rxt-error "Missing close right bracket in regexp"))
-  (rxt-with-source-location
-   (let* ((negated (rxt-token-case
-                    ((rx "^") t)
-                    (t nil)))
-          (begin (point))
-          (result
-           (if negated
-               (rxt-negate (rxt-char-set-union))
-             (rxt-char-set-union)))
-          (transformer
-           (if negated #'rxt-negate #'identity))
-          (builder
-           (if negated #'rxt-char-set-intersection #'rxt-choice)))
-     (catch 'done
-       (while t
-         (when (eobp)
-           (rxt-error "Missing close right bracket in regexp"))
-         (if (and (looking-at (rx "]"))
-                  (not (= (point) begin)))
-             (throw 'done result)
-           (let ((piece (funcall transformer (rxt-parse-char-class-piece))))
-             (setq result (funcall builder result piece))))))
-     (forward-char)                     ; Skip over closing "]"
-     result)))
-
-;; Parse a single character, a character range, or a posix class
-;; within a character set context.  Returns an `rxt-char-set'.
-(defun rxt-parse-char-class-piece ()
-  (let ((atom (rxt-parse-char-class-atom)))
-    (cl-typecase atom
-      (rxt-char-set                     ; return unchanged
-       atom)
-      (integer                          ; character: check for range
-       (let ((range-end (rxt-maybe-parse-range-end)))
-         (if range-end
-             (rxt-char-set-union (cons atom range-end))
-           (rxt-char-set-union atom))))
-      (t                                ; transform into character set
-       (rxt-char-set-union atom)))))
-
-;; Parse a single character or named class within a charset.
-;;
-;; Returns an integer (a character), a symbol (representing a named
-;; character class) or an `rxt-char-set' (for pre-defined character
-;; classes like \d, \W, etc.)
-(defun rxt-parse-char-class-atom ()
-  (or
-   ;; First, check for PCRE-specific backslash sequences
-   (and rxt-parse-pcre
-        (rxt-parse-char-class-atom/pcre))
-   ;; Char-class syntax
-   (rxt-token-case
-    ;; Named classes [:alnum:], ...
-    (rxt-named-classes-regexp
-     (intern (match-string 1)))
-    ;; Error on unknown posix-class-like syntax
-    ((rx "[:" (* (any "a-z")) ":]")
-     (rxt-error "Unknown posix character class `%s'" (match-string 0)))
-    ;; Error on [= ... ]= collation syntax
-    ((rx "[" (submatch (any "." "="))
-         (* (any "a-z")) (backref 1) "]")
-     (rxt-error "Unsupported collation syntax `%s'" (match-string 0)))
-    ;; Other characters stand for themselves
-    ((rx (or "\n" nonl))
-     (string-to-char (match-string 0))))))
-
-;; Parse backslash escapes inside PCRE character classes
-(defun rxt-parse-char-class-atom/pcre ()
-  (or (rxt-parse-escapes/pcre)
-      (rxt-token-case
-       ;; Backslash + digits => octal char
-       ((rx "\\" (submatch (** 1 3 (any "0-7"))))
-        (string-to-number (match-string 1) 8))
-       ;; Pre-defined character sets
-       ((rx "\\" (submatch (any "d" "D" "h" "H" "s" "S" "v" "V" "w" "W")))
-        (rxt--pcre-char-set (string-to-char (match-string 1))))
-       ;; "\b" inside character classes is a backspace
-       ((rx "\\b") ?\C-h)
-       ;; Ignore other escapes
-       ((rx "\\" (submatch nonl))
-        (string-to-char (match-string 1))))))
-
-;; Look for a range tail (the "-z" in "a-z") after parsing a single
-;; character within in a character set.  Returns either a character
-;; representing the range end, or nil.
-(defun rxt-maybe-parse-range-end ()
-  (let ((range-end nil) (end-position nil))
-    (when (looking-at (rx "-" (not (any "]"))))
-      (save-excursion
-        (forward-char)
-        (setq range-end (rxt-parse-char-class-atom)
-              end-position (point))))
-
-    (if (characterp range-end)
-        ;; This is a range: move point after it and return the ending character
-        (progn
-          (goto-char end-position)
-          range-end)
-      ;; Not a range.
-      nil)))
-
-;; Return the pre-defined PCRE char-set associated with CHAR: i.e. \d
-;; is digits, \D non-digits, \s space characters, etc.
-(defun rxt--pcre-char-set (char)
-  (let* ((base-char (downcase char))
-         (negated (/= char base-char))
-         (elements (assoc-default base-char rxt-pcre-char-set-alist))
-         (base-char-set (apply #'rxt-char-set-union elements)))
-    (if negated
-        (rxt-negate base-char-set)
-      base-char-set)))
-
-
-;;;; Unparser to `rx' syntax
-
-(defconst rxt-rx-verbose-equivalents
-  '((bol . line-start)
-    (eol . line-end)
-    (nonl . not-newline)
-    (bos . string-start)
-    (eos . string-end)
-    (bow . word-start)
-    (eow . word-end)
-    (seq . sequence))
-  "Alist of verbose equivalents for short `rx' primitives.")
-
-(defun rxt-rx-symbol (sym)
-  (if rxt-verbose-rx-translation
-      (or (assoc-default sym rxt-rx-verbose-equivalents)
-          sym)
-    sym))
-
-(defun rxt-adt->rx (re)
-  (let ((rx
-         (cl-typecase re
-          (rxt-primitive
-           (rxt-rx-symbol (rxt-primitive-rx re)))
-
-          (rxt-string
-           (if (or (not (rxt-string-case-fold re))
-                   (string= "" (rxt-string-chars re)))
-               (rxt-string-chars re)
-             `(seq
-               ,@(cl-loop for char across (rxt-string-chars re)
-                          collect `(any ,(upcase char) ,(downcase char))))))
-
-          (rxt-seq
-           `(seq ,@(mapcar #'rxt-adt->rx (rxt-seq-elts re))))
-
-          (rxt-choice
-           `(or ,@(mapcar #'rxt-adt->rx (rxt-choice-elts re))))
-
-          (rxt-submatch
-           (if (rxt-seq-p (rxt-submatch-body re))
-               `(submatch
-                 ,@(mapcar #'rxt-adt->rx (rxt-seq-elts (rxt-submatch-body re))))
-             `(submatch ,(rxt-adt->rx (rxt-submatch-body re)))))
-
-          (rxt-submatch-numbered
-           (if (rxt-seq-p (rxt-submatch-numbered-p re))
-               `(,(rxt-rx-symbol 'submatch-n)
-                  ,(rxt-submatch-numbered-n re)
-                  ,@(mapcar #'rxt-adt->rx
-                            (rxt-seq-elts
-                             (rxt-submatch-numbered-body re))))
-             `(,(rxt-rx-symbol 'submatch-n)
-                ,(rxt-submatch-numbered-n re)
-                ,(rxt-adt->rx (rxt-submatch-numbered-body re)))))
-
-          (rxt-backref
-           (let ((n (rxt-backref-n re)))
-             (if (<= n 9)
-                 `(backref ,(rxt-backref-n re))
-               (rxt-error "Too many backreferences (%s)" n))))
-
-          (rxt-syntax-class
-           `(syntax ,(rxt-syntax-class-symbol re)))
-
-          (rxt-char-category
-           `(category ,(rxt-char-category-symbol re)))
-
-          (rxt-repeat
-           (let ((from (rxt-repeat-from re))
-                 (to (rxt-repeat-to re))
-                 (greedy (rxt-repeat-greedy re))
-                 (body (rxt-adt->rx (rxt-repeat-body re))))
-             (if rxt-verbose-rx-translation
-                 (let ((rx
-                        (cond
-                          ((and (zerop from) (null to))
-                           `(zero-or-more ,body))
-                          ((and (equal from 1) (null to))
-                           `(one-or-more ,body))
-                          ((and (zerop from) (equal to 1))
-                           `(zero-or-one ,body))
-                          ((null to)
-                           `(>= ,from ,body))
-                          ((equal from to)
-                           `(repeat ,from ,body))
-                          (t
-                           `(** ,from ,to ,body)))))
-                   (if greedy
-                       (if rxt-explain
-                           rx           ; Readable but not strictly accurate. Fixme?
-                         `(maximal-match ,rx))
-                     `(minimal-match ,rx)))
-               (cond
-                 ((and (zerop from) (null to))
-                  `(,(if greedy '* '*?) ,body))
-                 ((and (equal from 1) (null to))
-                  `(,(if greedy '+ '+?) ,body))
-                 ((and (zerop from) (equal to 1))
-                  `(,(if greedy ? ??) ,body))
-                 ((null to)
-                  `(>= ,from ,body))
-                 ((equal from to)
-                  `(= ,from ,body))
-                 (t
-                  `(** ,from ,to ,body))))))
-
-          (rxt-char-set-union
-           (let* ((case-fold (rxt-char-set-union-case-fold re))
-                  (re (rxt--simplify-char-set re case-fold))
-                  (chars (rxt-char-set-union-chars re))
-                  (ranges (rxt-char-set-union-ranges re))
-                  (classes (rxt-char-set-union-classes re))
-                  (case-fold (rxt-char-set-union-case-fold re)))
-             (if (and (null chars) (null ranges) (= 1 (length classes)))
-                 (car classes)
-               `(any ,@chars ,@ranges ,@classes))))
-
-          (rxt-char-set-negation
-           `(not ,(rxt-adt->rx (rxt-char-set-negation-elt re))))
-
-          (t
-           (rxt-error "No RX translation of `%s'" (rxt-to-string re))))))
-
-    ;; Store source information on each fragment of the generated RX
-    ;; sexp for rxt-explain mode
-    (when rxt-explain
-      ;; Use gensyms to store unique source information for multiple
-      ;; occurrences of primitives like `bol'
-      (when (symbolp rx)
-        (setq rx (make-symbol (symbol-name rx))))
-      (setf (rxt-location rx) (rxt-location re)))
-    rx))
-
-
-;;;; 'Unparser' to PCRE notation
-
-;;; Based on scsh/posixstr.scm in scsh
-
-;; To ensure that the operator precedence in the generated regexp does
-;; what we want, we need to keep track of what kind of production is
-;; returned from each step. Therefore these functions return a string
-;; and a numeric "level" which lets the function using the generated
-;; regexp know whether it has to be parenthesized:
-;;
-;; 0: an already parenthesized expression
-;;
-;; 1: a "piece" binds to any succeeding quantifiers
-;;
-;; 2: a "branch", or concatenation of pieces, needs parenthesizing to
-;; bind to quantifiers
-;;
-;; 3: a "top", or alternation of branches, needs parenthesizing to
-;; bind to quantifiers or to concatenation
-;;
-;; This idea is stolen straight out of the scsh implementation.
-
-(defun rxt-adt->pcre (re)
-  (cl-destructuring-bind (s _) (rxt-adt->pcre/lev re) s))
-
-(defun rxt-adt->pcre/lev (re)
-  (cl-typecase re
-    (rxt-primitive
-     (let ((s (rxt-primitive-pcre re)))
-       (if s
-           (list s 1)
-         (rxt-error "No PCRE translation of `%s'" (rxt-to-string re)))))
-
-   (rxt-string (rxt-string->pcre re))
-   (rxt-seq (rxt-seq->pcre re))
-   (rxt-choice (rxt-choice->pcre re))
-   (rxt-submatch (rxt-submatch->pcre re))
-   (rxt-backref
-    (list (format "\\%d" (rxt-backref-n re)) 1))
-   (rxt-repeat (rxt-repeat->pcre re))
-
-   ((or rxt-char-set-union rxt-char-set-negation)
-    (rxt-char-set->pcre re))
-   
-   ;; FIXME
-   ;; ((rxt-char-set-intersection re) (rxt-char-set-intersection->pcre re))
-
-   (t
-    (rxt-error "No PCRE translation of `%s'" (rxt-to-string re)))))
-
-(defconst rxt-pcre-metachars (rx (any "\\^.$|()[]*+?{}")))
-(defconst rxt-pcre-charset-metachars (rx (any "]" "[" "\\" "^" "-")))
-
-(defun rxt-string->pcre (re)
-  (let ((chars (rxt-string-chars re)))
-    (list
-     (replace-regexp-in-string
-      rxt-pcre-metachars
-      "\\\\\\&" chars)
-     ;; A one-character string is a 'piece' (it binds to a following
-     ;; quantifier).  A longer string is a 'branch' (it has to be
-     ;; enclosed in parentheses to bind to a following quantifier).
-     (if (> (length chars) 1) 2 1))))
-
-(defun rxt-seq->pcre (re)
-  (let ((elts (rxt-seq-elts re)))
-    (if (null elts)
-        ""
-      (rxt-seq-elts->pcre elts))))
-
-(defun rxt-seq-elts->pcre (elts)
-  (cl-destructuring-bind
-      (s lev) (rxt-adt->pcre/lev (car elts))
-    (if (null (cdr elts))
-        (list s lev)
-      (cl-destructuring-bind
-          (s1 lev1) (rxt-seq-elts->pcre (cdr elts))
-        (list (concat (rxt-paren-if-necessary s lev)
-                      (rxt-paren-if-necessary s1 lev1))
-              2)))))
-
-(defun rxt-paren-if-necessary (s lev)
-  (if (< lev 3)
-      s
-    (concat "(?:" s ")")))
-
-(defun rxt-choice->pcre (re)
-  (let ((elts (rxt-choice-elts re)))
-    (if (null elts)
-        nil
-      (rxt-choice-elts->pcre elts))))
-
-(defun rxt-choice-elts->pcre (elts)
-  (cl-destructuring-bind
-      (s lev) (rxt-adt->pcre/lev (car elts))
-    (if (null (cdr elts))
-        (list s lev)
-      (cl-destructuring-bind
-          (s1 lev1) (rxt-choice-elts->pcre (cdr elts))
-        (list (concat s "|" s1) 3)))))
-
-(defun rxt-submatch->pcre (re)
-  (cl-destructuring-bind
-      (s lev) (rxt-adt->pcre/lev (rxt-submatch-body re))
-    (list (concat "(" s ")") 0)))
-
-(defun rxt-repeat->pcre (re)
-  (let ((from (rxt-repeat-from re))
-        (to (rxt-repeat-to re))
-        (body (rxt-repeat-body re))
-        (greedy (rxt-repeat-greedy re)))
-    (cl-destructuring-bind
-        (s lev) (rxt-adt->pcre/lev body)
-      (cond
-       ((and to (= from 1) (= to 1)) (list s lev))
-       ((and to (= from 0) (= to 0)) (list "" 2))
-       (t
-        (when (> lev 1)     ; parenthesize non-atoms
-          (setq s (concat "(?:" s ")")
-                lev 0))
-        (list (if to
-                  (cond ((and (= from 0) (= to 1))
-                         (concat s (if greedy "?" "??")))
-                        ((= from to)
-                         (concat s "{" (number-to-string to) "}"))
-                        (t
-                         (concat s "{" (number-to-string from)
-                                 "," (number-to-string to) "}")))
-                (cond ((= from 0)
-                       (concat s (if greedy "*" "*?")))
-                      ((= from 1)
-                       (concat s (if greedy "+" "+?")))
-                      (t (concat s "{" (number-to-string from) ",}"))))
-              1))))))
-
-(defun rxt-char-set->pcre (re)
-  (cond ((rxt-char-set-union-p re)
-         (list
-          (concat "[" (rxt-char-set->pcre/chars re) "]") 1))
-
-        ((rxt-char-set-negation-p re)
-         (let ((elt (rxt-char-set-negation-elt re)))
-           (if (rxt-char-set-union-p elt)
-               (list
-                (concat "[^" (rxt-char-set->pcre/chars elt) "]") 1)
-             (rxt-error "No PCRE translation of `%s'" (rxt-to-string elt)))))
-
-        (t
-         (rxt-error "Non-char-set in rxt-char-set->pcre: %s" re))))
-
-;; Fortunately, easier in PCRE than in POSIX!
-(defun rxt-char-set->pcre/chars (re)
-  (cl-flet
-      ((escape
-        (char)
-        (let ((s (char-to-string char)))
-          (cond ((string-match rxt-pcre-charset-metachars s)
-                 (concat "\\" s))
-
-                ((and (not (string= s " "))
-                      (string-match "[^[:graph:]]" s))
-                 (format "\\x{%x}" char))
-
-                (t s)))))
-
-    (let ((chars (rxt-char-set-union-chars re))
-          (ranges (rxt-char-set-union-ranges re))
-          (classes (rxt-char-set-union-classes re)))
-
-      (concat
-       (mapconcat #'escape chars "")
-       (mapconcat #'(lambda (rg)
-                      (format "%s-%s"
-                              (escape (car rg))
-                              (escape (cdr rg))))
-                  ranges "")
-       (mapconcat #'(lambda (class)
-                      (format "[:%s:]" class))
-                  classes "")))))
-
-
-;;;; Generate all productions of a finite regexp
-
-(defun rxt-adt->strings (re)
-  (cl-typecase re
-    (rxt-primitive
-     (list ""))
-    (rxt-string
-     (list (rxt-string-chars re)))
-    (rxt-seq
-     (rxt-seq-elts->strings (rxt-seq-elts re)))
-    (rxt-choice
-     (rxt-choice-elts->strings (rxt-choice-elts re)))
-    (rxt-submatch
-     (rxt-adt->strings (rxt-submatch-body re)))
-    (rxt-submatch-numbered
-     (rxt-adt->strings (rxt-submatch-numbered-body re)))
-    (rxt-repeat
-     (rxt-repeat->strings re))
-    (rxt-char-set-union
-     (rxt-char-set->strings re))
-    (t
-     (error "Can't generate productions of %s"
-            (rxt-syntax-tree-readable re)))))
-
-(defun rxt-concat-product (heads tails)
-  (cl-mapcan
-   (lambda (hs)
-     (mapcar
-      (lambda (ts) (concat hs ts))
-      tails))
-   heads))
-
-(defun rxt-seq-elts->strings (elts)
-  (if (null elts)
-      '("")
-    (let ((heads (rxt-adt->strings (car elts)))
-          (tails (rxt-seq-elts->strings (cdr elts))))
-      (rxt-concat-product heads tails))))
-
-(defun rxt-choice-elts->strings (elts)
-  (if (null elts)
-      '()
-    (append (rxt-adt->strings (car elts))
-            (rxt-choice-elts->strings (cdr elts)))))
-
-(defun rxt-repeat->strings (re)
-  (let ((from (rxt-repeat-from re))
-        (to (rxt-repeat-to re)))
-    (if (not to)
-        (error "Can't generate all productions of unbounded repeat \"%s\""
-               (rxt-syntax-tree-readable re))
-      (let ((strings (rxt-adt->strings (rxt-repeat-body re))))
-        (rxt-repeat-n-m->strings from to strings)))))
-
-(defun rxt-repeat-n-m->strings (from to strings)
-  (cond
-   ((zerop to) '(""))
-   ((= to from) (rxt-repeat-n->strings from strings))
-   (t           ; to > from
-    (let* ((strs-n (rxt-repeat-n->strings from strings))
-           (accum (cl-copy-list strs-n)))
-      (dotimes (i (- to from))
-        (setq strs-n (rxt-concat-product strs-n strings))
-        (setq accum (nconc accum strs-n)))
-      accum))))
-
-(defun rxt-repeat-n->strings (n strings)
-  ;; n > 1
-  (cond ((zerop n) '(""))
-        ((= n 1) strings)
-        (t
-         (rxt-concat-product
-          (rxt-repeat-n->strings (- n 1) strings)
-          strings))))
-
-(defun rxt-char-set->strings (re)
-  (if (rxt-char-set-union-classes re)
-      (error "Can't generate all productions of named character classes in \"%s\""
-             (rxt-syntax-tree-readable re))
-    (let ((chars (mapcar #'char-to-string (rxt-char-set-union-chars re))))
-      (dolist (range (rxt-char-set-union-ranges re))
-        (let ((end (cdr range)))
-          (cl-do ((i (car range) (+ i 1)))
-              ((> i end))
-            (push (char-to-string i) chars))))
-      chars)))
-
-
-;;;; RE-Builder hacks
-
-(defadvice reb-update-modestring
-  (after rxt () activate compile)
-  "This function is hacked for emulated PCRE syntax and regexp conversion."
-  (setq reb-mode-string
-        (concat
-         (format " (%s)" reb-re-syntax)
-         reb-mode-string))
-  (force-mode-line-update))
-
-(defadvice reb-change-syntax
-  (around rxt (&optional syntax) activate compile)
-  "This function is hacked for emulated PCRE syntax and regexp conversion."
-  (interactive
-   (list (intern
-          (completing-read (format "Select syntax (%s): " reb-re-syntax)
-                           '(read string pcre sregex rx)
-                           nil t "" nil (symbol-name reb-re-syntax)))))
-  (unless (memq syntax '(read string pcre lisp-re sregex rx))
-    (error "Invalid syntax: %s" syntax))
-  (let ((re-builder-buffer (get-buffer reb-buffer)))
-    (setq reb-re-syntax syntax)
-    (when re-builder-buffer
-      (with-current-buffer reb-target-buffer
-        (cl-case syntax
-          (rx
-           (let ((rx (rxt-elisp-to-rx reb-regexp)))
-             (setq reb-regexp-src
-                   (with-temp-buffer
-                     (insert "\n" "'")
-                     (rxt-print rx)
-                     (buffer-string)))))
-          (pcre
-           (setq reb-regexp-src (rxt-elisp-to-pcre reb-regexp)))))
-      (with-current-buffer re-builder-buffer
-        ;; Hack: prevent reb-auto-update from clobbering the
-        ;; reb-regexp-src we just set
-        (let ((inhibit-modification-hooks t))
-          (reb-initialize-buffer))
-        ;; Enable flag-toggling bindings for PCRE syntax
-        (rxt--re-builder-switch-pcre-mode)))))
-
-(defadvice reb-read-regexp
-  (around rxt () activate compile)
-  "This function is hacked for emulated PCRE syntax and regexp conversion."
-  (if (eq reb-re-syntax 'pcre)
-      (setq ad-return-value
-            (save-excursion
-              (goto-char (point-min))
-              (rxt-read-delimited-pcre)))
-    ad-do-it))
-
-(defadvice reb-insert-regexp
-  (around rxt () activate compile)
-  "This function is hacked for emulated PCRE syntax and regexp conversion."
-  (if (eq reb-re-syntax 'pcre)
-      (let ((src (reb-target-binding reb-regexp-src)))
-        (if src
-            (insert "\n/" (replace-regexp-in-string "/" "\\/" src t t) "/")
-          (insert "\n//")))
-    ad-do-it))
-
-(defadvice reb-cook-regexp
-  (around rxt (re) activate compile)
-  "This function is hacked for emulated PCRE syntax and regexp conversion."
-  (if (eq reb-re-syntax 'pcre)
-      (setq ad-return-value (rxt-pcre-to-elisp re))
-    ad-do-it))
-
-(defadvice reb-update-regexp
-  (around rxt () activate compile)
-  "This function is hacked for emulated PCRE syntax and regexp conversion."
-  (setq ad-return-value
-        (let* ((re-src (reb-read-regexp))
-               (re (reb-cook-regexp re-src)))
-          (with-current-buffer reb-target-buffer
-            (let ((oldre reb-regexp))
-              (prog1
-                  (not (string= oldre re))
-                (setq reb-regexp re)
-                ;; Update the source re if format requires translation
-                (when (or (reb-lisp-syntax-p) (eq reb-re-syntax 'pcre))
-                  (setq reb-regexp-src re-src))))))))
-
-(defun rxt--re-builder-switch-pcre-mode ()
-  (rxt--read-pcre-mode
-   (if (eq reb-re-syntax 'pcre) 1 0)))
-
-(add-hook 'reb-mode-hook #'rxt--re-builder-switch-pcre-mode)
-
-(provide 'rxt)
-(provide 'pcre2el)
-
-
-;;; pcre2el.el ends here