Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/emacs-lisp/rx.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" #$))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


#@80 Alist mapping rx symbols to character classes.
Most of the names are from SRE.
(defconst rx--char-classes '((digit . digit) (numeric . digit) (num . digit) (control . cntrl) (cntrl . cntrl) (hex-digit . xdigit) (hex . xdigit) (xdigit . xdigit) (blank . blank) (graphic . graph) (graph . graph) (printing . print) (print . print) (alphanumeric . alnum) (alnum . alnum) (letter . alpha) (alphabetic . alpha) (alpha . alpha) (ascii . ascii) (nonascii . nonascii) (lower . lower) (lower-case . lower) (punctuation . punct) (punct . punct) (space . space) (whitespace . space) (white . space) (upper . upper) (upper-case . upper) (word . word) (wordchar . word) (unibyte . unibyte) (multibyte . multibyte)) (#$ . 408))
#@684 Alist of old-style rx extensions, for compatibility.
For new code, use `rx-define', `rx-let' or `rx-let-eval'.

Each element is (SYMBOL . DEF).

If DEF is a symbol, then SYMBOL is an alias of DEF.

If DEF is a string, then SYMBOL is a plain rx symbol defined as the
   regexp string DEF.

If DEF is a list on the form (FUN MIN-ARGS MAX-ARGS PRED), then
   SYMBOL is an rx form with at least MIN-ARGS and at most
   MAX-ARGS arguments.  If MAX-ARGS is nil, then there is no upper limit.
   FUN is a function taking the entire rx form as single argument
   and returning the translated regexp string.
   If PRED is non-nil, it is a predicate that all actual arguments must
   satisfy.
(defvar rx-constituents nil (#$ . 1129))
#@266 Alist of dynamic local rx definitions.
Each entry is:
 (NAME DEF)      -- NAME is an rx symbol defined as the rx form DEF.
 (NAME ARGS DEF) -- NAME is an rx form with arglist ARGS, defined
                    as the rx form DEF (which can contain members of ARGS).
(defvar rx--local-definitions nil (#$ . 1860))
#@77 Current definition of NAME: (DEF) or (ARGS DEF), or nil if none.

(fn NAME)
(defalias 'rx--lookup-def #[257 "\211\236A\206\n\211\301N\207" [rx--local-definitions rx-definition] 3 (#$ . 2178)])
(put 'rx--lookup-def 'byte-optimizer 'byte-compile-inline-expand)
#@77 FORM expanded (once) if a user-defined construct; otherwise nil.

(fn FORM)
(defalias 'rx--expand-def #[257 "\2119\203%\211\211\236A\206\211\301N\262
\211\205$\211A\203\"\302\303\"\202$\211@\207\211:\205[\211@9\205[\211@\211\211\236A\206=\211\301N\262
\211\205Y\211A\203U\304A@A@$\202Y\302\305\"\266\202\207" [rx--local-definitions rx-definition error "Not an `rx' symbol definition: %s" rx--expand-template "Not an `rx' form definition: %s"] 8 (#$ . 2445)])
#@66 Translate an rx symbol.  Return (REGEXP . PRECEDENCE).

(fn SYM)
(defalias 'rx--translate-symbol #[257 "\211\302\267\202O\303C\304B\207\305C\304B\207\306 \207\307C\310B\207\311C\312B\207\313C\304B\207\314C\304B\207\315C\304B\207\316C\304B\207\317C\304B\207\320C\304B\207\321C\304B\207\322C\304B\207\323C\304B\207\324C\304B\207\211\236A\211\205`\325\326!\327QC\304B\262
\206\254\330
!\211\205o\331
!\262
\206\254\211	\236\211\203\232\211A;\204\232\211A9\203\216\211A	\236\202\225\211@
	>A\236\262
\202w\211\205\243\211AC\332B\262
\206\254\333\334\"\207" [rx--char-classes rx-constituents #s(hash-table size 28 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (any 6 not-newline 6 nonl 6 anything 11 anychar 11 unmatchable 16 line-start 19 bol 19 line-end 24 eol 24 buffer-start 29 bot 29 string-start 29 bos 29 buffer-end 34 eot 34 string-end 34 eos 34 point 39 word-start 44 bow 44 word-end 49 eow 49 word-boundary 54 not-word-boundary 59 symbol-start 64 symbol-end 69 not-wordchar 74)) "." t "[^z-a]" rx--empty "^" lseq "$" rseq "\\`" "\\'" "\\=" "\\<" "\\>" "\\b" "\\B" "\\_<" "\\_>" "\\W" "[[:" symbol-name ":]]" rx--expand-def rx--translate nil error "Unknown rx symbol `%s'"] 5 (#$ . 2930)])
#@71 Bracket REXP by LEFT-STR and RIGHT-STR.

(fn LEFT-STR REXP RIGHT-STR)
(defalias 'rx--enclose #[771 "\300CC#\207" [append] 7 (#$ . 4163)])
#@13 

(fn REXP)
(defalias 'rx--bracket #[257 "\300\301\302#\207" [rx--enclose "\\(?:" "\\)"] 5 (#$ . 4310)])
#@152 Return the sequence (concatenation) of two translated items,
each on the form (REGEXP . PRECEDENCE), returning (REGEXP . PRECEDENCE).

(fn LEFT RIGHT)
(defalias 'rx--sequence #[514 "
@\204\207\211@\204

\207
A\300>\203\301@!\302B\202

A\303>\203.\301@!\302B\202/
\304@@\"A\305=\203H
A\306=?\205T\305\202T
A\306=\203S\306\202T\307B\207" [(nil rseq) rx--bracket t (nil lseq) append lseq rseq seq] 7 (#$ . 4423)])
#@89 Translate a sequence of zero or more rx items.
Return (REGEXP . PRECEDENCE).

(fn BODY)
(defalias 'rx--translate-seq #[257 "\211\203!\300\301\"\211@
A\211\203\211@\302\"\262
A\266\202\202\f\210\207\303\304B\207" [mapcar rx--translate rx--sequence nil seq] 8 (#$ . 4859)])
#@37 Regexp that never matches anything.
(defalias 'rx--empty #[0 "C\301B\207" [regexp-unmatchable seq] 2 (#$ . 5145)])
#@65 Whether PRED is true for every element of LIST.

(fn PRED LIST)
(defalias 'rx--every #[514 "\211\203

@!\203\211A\262
\202\211?\207" [] 4 (#$ . 5267)])
#@105 (F (F (F X L0) L1) L2) ...
Left-fold the list L, starting with X, by the binary function F.

(fn F X L)
(defalias 'rx--foldl #[771 "\211\203@\"\262\211A\262
\202
\207" [] 6 (#$ . 5432)])
#@164 Normalize the `or' argument FORM.
Characters become strings, user-definitions and `eval' forms are expanded,
and `or' forms are normalized recursively.

(fn FORM)
(defalias 'rx--normalise-or-arg #[257 "\300
!\203\n\301
!\207\211:\203\211@\302>\203\211@\303\304A\"B\207\211:\2032\211@\305=\2032\304\306A!!\207\307
!\211\203?\304
!\202@
\207" [characterp char-to-string (or |) mapcar rx--normalise-or-arg eval rx--expand-eval rx--expand-def] 5 (#$ . 5634)])
#@122 If BODY only consists of strings or such `or' forms, return all the strings.
Otherwise throw `rx--nonstring'.

(fn BODY)
(defalias 'rx--all-string-or-args #[257 "\300\301\"\207" [mapcan #[257 "\211;\203\211C\207\211:\203\211@\300>\203\301
A!\207\302\303\304\"\207" [(or |) rx--all-string-or-args throw rx--nonstring nil] 4 "\n\n(fn FORM)"]] 4 (#$ . 6108)])
#@92 Translate an or-pattern of zero or more rx items.
Return (REGEXP . PRECEDENCE).

(fn BODY)
(defalias 'rx--translate-or #[257 "\211\204\300 \207\211A\204\301
@!\207\302\303\"\3042\305
!0\211\203+\306
\307\"C\310B\202G\311\312\"\2039\313\307\"\202G\314\301@!@\315\316A\"\"\307B\207" [rx--empty rx--translate mapcar rx--normalise-or-arg rx--nonstring rx--all-string-or-args regexp-opt nil t rx--every rx--charset-p rx--translate-union append mapcan #[257 "\300\301!@B\207" ["\\|" rx--translate] 4 "\n\n(fn ITEM)"]] 8 (#$ . 6478)])
#@106 Whether FORM looks like a charset, only consisting of character intervals
and set operations.

(fn FORM)
(defalias 'rx--charset-p #[257 "\211:\203#\211@\300>\203\301\302A\"\206K\211@\303>\203#\301\304A\"\206K\305
!\206K\211;\2035\211G\306U\206K\2119\204?\211:\205K\307
!\211\205I\304
!\262
\207" [(any in char) rx--every #[257 "\2119?\207" [] 2 "\n\n(fn X)"] (not or | intersection) rx--charset-p characterp 1 rx--expand-def] 4 (#$ . 7029)])
#@138 Decode STR as intervals: A-Z becomes (?A . ?Z), and the single
character X becomes (?X . ?X).  Return the intervals in a list.

(fn STR)
(defalias 'rx--string-to-intervals #[257 "\300
!\203\n\301\202\302
G\303\304
W\203\212
\305ZW\203wTH\306U\203wH!\305\\H!
\307X\203P\211\310Y\203P
\307BB\262\310
BB\262\202m

X\203`

BB\262\202m\311\312\313	\211\314\\#\"\210\314\\\262\266\202H!\211
BB\266\202
T\262\202\207" [multibyte-string-p identity unibyte-char-to-multibyte 0 nil 2 45 127 4194176 error "Invalid rx `any' range: %s" substring 3] 14 (#$ . 7492)])
#@167 Merge adjacent and overlapping intervals by mutation, preserving the order.
INTERVALS is a list of (START . END) with START ≤ END, sorted by START.

(fn INTERVALS)
(defalias 'rx--condense-intervals #[257 "\211\300
A\211\262\203.
@A
@@SY\203(
@@A@A]\241\210

A\241\210\202\211\262\202\207" [nil] 6 (#$ . 8096)])
#@243 Parse arguments of an (any ...) construct.
Return (INTERVALS . CLASSES), where INTERVALS is a sorted list of
disjoint intervals (each a cons of chars), and CLASSES
a list of named character classes in the order they occur in BODY.

(fn BODY)
(defalias 'rx--parse-any #[257 "\301\211\211\211\203z\211@\211;\203\211B\262\202s\211:\203>\302
@!\203>\302
A!\203>\211@
AX\203>\211@
ABB\262\202s\302
!\203N\211
BB\262\202s\2119\203n\211\236A\211\205i\211>\206i\211B\262\303\262
\204s\304\305\"\210
A\266\202\202\210\306\307\310\311\312\"\"\313\"!\314!B\207" [rx--char-classes nil characterp t error "Invalid rx `any' argument: %s" rx--condense-intervals sort append mapcan rx--string-to-intervals car-less-than-car reverse] 11 (#$ . 8427)])
#@236 Generate a character alternative.  Return (REGEXP . PRECEDENCE).
If NEGATED is non-nil, negate the result; INTERVALS is a sorted
list of disjoint intervals and CLASSES a list of named character
classes.

(fn NEGATED INTERVALS CLASSES)
(defalias 'rx--generate-alt #[771 "\300\"\301
\236\211\203\211\302\"B\262\210\303\301\"\211\203,\211@\301=\204,\211\304\241\210\305B\262\210\303\306\"\211@\307=\203A\211\307\241\210
\310\244\262\210\306
\236\211\203b\211A\306=\203Y\302
\"\262\202]\211\311\240\210
\312\244\262\210\211@:\203\202\211@@\313=\203\202\211A\203\202\211A@
@AABB\262
\211\204\225\203\220\314\315!\202\333\316 \202\333\211A\204\273\211@:\203\273\211@@
@A=\203\273\204\273\317\320@@!!C\321B\202\333\211\322\232\203\313\203\313\314\323!\202\333\324\205\321\325\326\327\330#\331RC\321B\207" [append 93 delq rassq 92 (93 . 93) 45 44 ((45 . 45)) 46 ((45 . 45)) 94 rx--translate-symbol anything rx--empty regexp-quote char-to-string t ((10 . 10)) nonl "[" "^" mapconcat #[257 "\2119\203\n\300\301\"\207\211@
A=\203\302
@!\207\211@T
A=\203'\303
@A\"\207\303
@\304A#\207" [format "[:%s:]" char-to-string string 45] 5 "\n\n(fn ITEM)"] nil "]"] 10 (#$ . 9203)])
#@115 Translate an (any ...) construct.  Return (REGEXP . PRECEDENCE).
If NEGATED, negate the sense.

(fn NEGATED BODY)
(defalias 'rx--translate-any #[514 "\300
!\301@A#\207" [rx--parse-any rx--generate-alt] 7 (#$ . 10423)])
#@190 Generate a character alternative from an interval set.
Return (REGEXP . PRECEDENCE).
INTERVALS is a sorted list of disjoint intervals.
If NEGATED, negate the sense.

(fn NEGATED INTERVALS)
(defalias 'rx--intervals-to-alt #[514 "\300\301\"\203
\302\303#\207\302?\304!\303#\207" [rx--every #[257 "\300
@\301A#?\207" [<= 4194047] 5 "\n\n(fn IV)"] rx--generate-alt nil rx--complement-intervals] 6 (#$ . 10652)])
#@140 Translate a (not ...) construct.  Return (REGEXP . PRECEDENCE).
If NEGATED, negate the sense (thus making it positive).

(fn NEGATED BODY)
(defalias 'rx--translate-not #[514 "\211\203	\211A\203
\301\302!\210\211@\211:\203X\211@\211\303\267\202R\304?A\"\202S\305?A\"\202S\306?A\"\202S\307?A\"\202S\310?A\"\202S\311?A\"\202S\312\262
\206\304\211\236A\211\205g\313?\312C#\262
\206\304\211\314=\203\200\315\203{\314\202|\316!\202\304\317
!\203\222\313?\211BC\312#\202\304\211;\203\257\211G\320U\203\257\321
!\313?\211BC\312#\262
\202\304\322
!\211\205\273\307C\"\262
\206\304\301\323\"\207" [rx--char-classes error "rx `not' form takes exactly one argument" #s(hash-table size 9 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (char 28 in 28 any 28 syntax 37 category 46 not 55 | 64 or 64 intersection 73)) rx--translate-any rx--translate-syntax rx--translate-category rx--translate-not rx--translate-union rx--translate-intersection nil rx--generate-alt word-boundary rx--translate-symbol not-word-boundary characterp 1 string-to-char rx--expand-def "Illegal argument to rx `not': %S"] 8 (#$ . 11074)])
#@60 Complement of the interval list INTERVALS.

(fn INTERVALS)
(defalias 'rx--complement-intervals #[257 "\300\301\211\203%\211@
@W\203
@SBB\262\211AT\262
A\266\202\202\210\211\302 W\2035\211\302 BB\262
\237\207" [nil 0 max-char] 7 (#$ . 12243)])
#@71 Intersection of the interval lists IVS-A and IVS-B.

(fn IVS-A IVS-B)
(defalias 'rx--intersect-intervals #[514 "\300\203n
\203n@@
A
@W\203A\262\202i
@
AV\203+A\262\202i
@
@]AA^BB\262A\262A\262
A
AW\203W
AT
ABB\262\202i
A
AV\203i\211ATABB\262\266\202
\211\237\207" [nil] 8 (#$ . 12506)])
#@64 Union of the interval lists IVS-A and IVS-B.

(fn IVS-A IVS-B)
(defalias 'rx--union-intervals #[514 "\300\301\300!\300!\"!\207" [rx--complement-intervals rx--intersect-intervals] 7 (#$ . 12831)])
#@288 Return a sorted list of non-adjacent disjoint intervals from CHARSET.
CHARSET is any expression allowed in a character set expression:
characters, single-char strings, `any' forms (no classes permitted),
or `not', `or' or `intersection' forms whose arguments are charsets.

(fn CHARSET)
(defalias 'rx--charset-intervals #[257 "\300\301\302:\203\365@\211\303\267\202\317A\211\304
!\211A\203\"\305\306A@\"\210\211@\262
\262
\262
\202\360A\211:\203\213\211@
A\211\204G
\307\310!!\262
\202\206\311!\203V\211BC\202\206;\203qG\312U\203q\313!\211
BC\262
\202\206\314!\211\203\310
!\202\204\305\315\n\"\262
\266\202\202\260\311!\203\231!\202\260;\203\254G\312U\203\254!\202\260!\262
\202\360A\211\316
!\262
\262
\202\360A\211\317
!\262
\262
\202\360\311!\203\333
!\202\360;\203\355G\312U\203\355!\202\360!\262
\202
\311!\203

\211!\202
;\203
G\312U\203

!\202
!\207" [#[257 "\300
!\211\203
\301
!\202\302\303\"\207" [rx--expand-def rx--charset-intervals error #1="Bad character set: %S"] 5 "\n\n(fn CHARSET)"] #[257 "\300
!\211
BC\207" [string-to-char] 4 "\n\n(fn CHARSET)"] #[257 "\211
BC\207" [] 3 "\n\n(fn CHARSET)"] #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (char 16 in 16 any 16 not 45 | 181 or 181 intersection 194)) rx--parse-any error "Character class not permitted in set operations: %S" rx--complement-intervals rx--charset-intervals characterp 1 string-to-char rx--expand-def #1# rx--charset-union rx--charset-intersection] 12 (#$ . 13036)])
#@58 Union of CHARSETS, as a set of intervals.

(fn CHARSETS)
(defalias 'rx--charset-union #[257 "\300\301\302\303\304\"#\207" [rx--foldl rx--union-intervals nil mapcar rx--charset-intervals] 7 (#$ . 14617)])
(defconst rx--charset-all (byte-code "\300\301 BC\207" [0 max-char] 2))
#@65 Intersection of CHARSETS, as a set of intervals.

(fn CHARSETS)
(defalias 'rx--charset-intersection #[257 "\301\302\303\304\"#\207" [rx--charset-all rx--foldl rx--intersect-intervals mapcar rx--charset-intervals] 7 (#$ . 14900)])
#@126 Translate an (or ...) construct of charsets.  Return (REGEXP . PRECEDENCE).
If NEGATED, negate the sense.

(fn NEGATED BODY)
(defalias 'rx--translate-union #[514 "\300\301!\"\207" [rx--intervals-to-alt rx--charset-union] 6 (#$ . 15139)])
#@124 Translate an (intersection ...) construct.  Return (REGEXP . PRECEDENCE).
If NEGATED, negate the sense.

(fn NEGATED BODY)
(defalias 'rx--translate-intersection #[514 "\300\301!\"\207" [rx--intervals-to-alt rx--charset-intersection] 6 (#$ . 15386)])
#@76 ITEM is (REGEXP . PRECEDENCE); return a regexp of precedence t.

(fn ITEM)
(defalias 'rx--atomic-regexp #[257 "\211A\300=\203\n\211@\207\301
@!\207" [t rx--bracket] 3 (#$ . 15644)])
#@33 

(fn MIN-COUNT MAX-COUNT BODY)
(defalias 'rx--translate-counted-repetition #[771 "\300
!\211@\2031\301\302!\303\304!\204\305\202(W\205(\305\304!P\306RC\"\307B\2022\211\207" [rx--translate-seq append rx--atomic-regexp "\\{" number-to-string "," "\\}" t] 11 (#$ . 15833)])
#@27 

(fn NAME MIN-ARGS BODY)
(defalias 'rx--check-repeat-arg #[771 "\211GY\204\300\301\211\302U\203\303\202\304$\210\305
@!?\205$\300\306\"\207" [error "rx `%s' requires at least %d argument%s" 1 "" "s" natnump "rx `%s' first argument must be nonnegative"] 9 (#$ . 16128)])
#@18 

(fn NAME BODY)
(defalias 'rx--translate-bounded-repetition #[514 "\211@
A@AA\300!\203\300!\203X\204 \301\302\"\210\303#\207" [natnump error "rx `%s' range error" rx--translate-counted-repetition] 9 (#$ . 16416)])
#@13 

(fn BODY)
(defalias 'rx--translate-repeat #[257 "\300\301\302#\210\211G\302U\203\303
@@A#\207\304\301\"\207" [rx--check-repeat-arg repeat 2 rx--translate-counted-repetition rx--translate-bounded-repetition] 5 (#$ . 16652)])
#@13 

(fn BODY)
(defalias 'rx--translate-** #[257 "\300\301\302#\210\303\301\"\207" [rx--check-repeat-arg ** 2 rx--translate-bounded-repetition] 5 (#$ . 16890)])
#@13 

(fn BODY)
(defalias 'rx--translate->= #[257 "\300\301\302#\210\303
@\304A#\207" [rx--check-repeat-arg >= 1 rx--translate-counted-repetition nil] 5 (#$ . 17056)])
#@13 

(fn BODY)
(defalias 'rx--translate-= #[257 "\300\301\302#\210\303
@@A#\207" [rx--check-repeat-arg = 1 rx--translate-counted-repetition] 5 (#$ . 17228)])
(defvar rx--greedy t)
#@142 Translate a repetition; OP-STRING is one of "*", "+" or "?".
GREEDY is a boolean.  Return (REGEXP . PRECEDENCE).

(fn OP-STRING GREEDY BODY)
(defalias 'rx--translate-rep #[771 "\300
!\211@\203\301\302!?\205\303PC\"\304B\202\211\207" [rx--translate-seq append rx--atomic-regexp "?" seq] 8 (#$ . 17415)])
#@101 Translate the sequence BODY with greediness GREEDY.
Return (REGEXP . PRECEDENCE).

(fn GREEDY BODY)
(defalias 'rx--control-greedy #[514 "
\301
!)\207" [rx--greedy rx--translate-seq] 4 (#$ . 17734)])
#@71 Translate the `group' form.  Return (REGEXP . PRECEDENCE).

(fn BODY)
(defalias 'rx--translate-group #[257 "\300\301\302!@\303#\304B\207" [rx--enclose "\\(" rx--translate-seq "\\)" t] 5 (#$ . 17940)])
#@73 Translate the `group-n' form.  Return (REGEXP . PRECEDENCE).

(fn BODY)
(defalias 'rx--translate-group-n #[257 "\211@\250\203
\211@\300V\204\301\302!\210\303\304\305@!\306Q\307A!@\310#\311B\207" [0 error "rx `group-n' requires a positive number as first argument" rx--enclose "\\(?" number-to-string ":" rx--translate-seq "\\)" t] 5 (#$ . 18148)])
#@73 Translate the `backref' form.  Return (REGEXP . PRECEDENCE).

(fn BODY)
(defalias 'rx--translate-backref #[257 "\211G\300U\203\211@\250\203\301\300@\302#\204\303\304!\210\305\306@!D\307B\207" [1 <= 9 error "rx `backref' requires an argument in the range 1..9" "\\" number-to-string t] 5 (#$ . 18507)])
(defconst rx--syntax-codes '((whitespace . 45) (punctuation . 46) (word . 119) (symbol . 95) (open-parenthesis . 40) (close-parenthesis . 41) (expression-prefix . 39) (string-quote . 34) (paired-delimiter . 36) (escape . 92) (character-quote . 47) (comment-start . 60) (comment-end . 62) (string-delimiter . 124) (comment-delimiter . 33)))
#@80 Translate the `syntax' form.  Return (REGEXP . PRECEDENCE).

(fn NEGATED BODY)
(defalias 'rx--translate-syntax #[514 "\211\203	\211A\203
\301\302!\210\211@\211\236A\211\204Q\303!\203*\304\"\203*
\262
\202H
9\203H\305!\211G\306U\203G\307
!\304
\"\203F\211\262\210\210\211\204Q\301\310\"\210\311\312\203[\313\202\\\314#C\315B\207" [rx--syntax-codes error "rx `syntax' form takes exactly one argument" characterp rassq symbol-name 1 string-to-char "Unknown rx syntax name `%s'" string 92 83 115 t] 9 (#$ . 19163)])
(defconst rx--categories '((space-for-indent . 32) (base . 46) (consonant . 48) (base-vowel . 49) (upper-diacritical-mark . 50) (lower-diacritical-mark . 51) (tone-mark . 52) (symbol . 53) (digit . 54) (vowel-modifying-diacritical-mark . 55) (vowel-sign . 56) (semivowel-lower . 57) (not-at-end-of-line . 60) (not-at-beginning-of-line . 62) (alpha-numeric-two-byte . 65) (chinese-two-byte . 67) (chinse-two-byte . 67) (greek-two-byte . 71) (japanese-hiragana-two-byte . 72) (indian-two-byte . 73) (japanese-katakana-two-byte . 75) (strong-left-to-right . 76) (korean-hangul-two-byte . 78) (strong-right-to-left . 82) (cyrillic-two-byte . 89) (combining-diacritic . 94) (ascii . 97) (arabic . 98) (chinese . 99) (ethiopic . 101) (greek . 103) (korean . 104) (indian . 105) (japanese . 106) (japanese-katakana . 107) (latin . 108) (lao . 111) (tibetan . 113) (japanese-roman . 114) (thai . 116) (vietnamese . 118) (hebrew . 119) (cyrillic . 121) (can-break . 124)))
#@82 Translate the `category' form.  Return (REGEXP . PRECEDENCE).

(fn NEGATED BODY)
(defalias 'rx--translate-category #[514 "\211\203	\211A\203
\301\302!\210\211@\2119\203'\211\236\211\204 \301\303\"\210\211A\262
\2025\304
!\2031\211\2025\301\305\"\306\307\203?\310\202@\311#C\312B\207" [rx--categories error "rx `category' form takes exactly one argument" "Unknown rx category `%s'" characterp "Invalid rx `category' argument `%s'" string 92 67 99 t] 8 (#$ . 20667)])
#@60 Whether to allow certain forms to be evaluated at runtime.
(defvar rx--delayed-evaluation nil (#$ . 21153))
#@73 Translate the `literal' form.  Return (REGEXP . PRECEDENCE).

(fn BODY)
(defalias 'rx--translate-literal #[257 "\211\203	\211A\203
\301\302!\210\211@\211;\203(\303
!C
G\304U\203#\305\202$\306B\2028\2035\303
DC\306B\2028\301\307!\207" [rx--delayed-evaluation error "rx `literal' form takes exactly one argument" regexp-quote 1 t seq "rx `literal' form with non-string argument"] 5 (#$ . 21267)])
#@60 Expand `eval' arguments.  Return a new rx form.

(fn BODY)
(defalias 'rx--expand-eval #[257 "\211\203	\211A\203
\300\301!\210\302
@!\207" [error "rx `eval' form takes exactly one argument" eval] 3 (#$ . 21677)])
#@70 Translate the `eval' form.  Return (REGEXP . PRECEDENCE).

(fn BODY)
(defalias 'rx--translate-eval #[257 "\300\301!!\207" [rx--translate rx--expand-eval] 4 (#$ . 21897)])
(defvar rx--regexp-atomic-regexp nil)
#@72 Translate the `regexp' form.  Return (REGEXP . PRECEDENCE).

(fn BODY)
(defalias 'rx--translate-regexp #[257 "\211\203	\211A\203
\303\304!\210\211@\211;\2034\204\305\306\307\"\211C\310\307\311#)\266\203\2050\307B\202B\n\203?\211C\310B\202B\303\312!\207" [rx--regexp-atomic-regexp inhibit-changing-match-data rx--delayed-evaluation error "rx `regexp' form takes exactly one argument" rx-to-string (seq bos (or (seq "[" (opt "^") (opt "]") (* (or (seq "[:" (+ (any "a-z")) ":]") (not (any "]")))) "]") anything (seq "\\" (or anything (seq (any "sScC_") anything) (seq "(" (* (or (not (any "\\")) (seq "\\" (not (any ")"))))) "\\)")))) eos) t nil string-match "rx `regexp' form with non-string argument"] 10 (#$ . 22113)])
#@131 Translate a compatibility form from `rx-constituents'.
DEF is the definition tuple.  Return (REGEXP . PRECEDENCE).

(fn DEF FORM)
(defalias 'rx--translate-compat-form #[514 "
@A@\3008\3018GS\211W\203\302\303@#\210\203/\211V\203/\302\304@#\210
\203D\305A\"\204D\302\306@#\210!\211;\204T\302\307@\"\210\211C\310B\262
\207" [2 3 error "The `%s' form takes at least %d argument(s)" "The `%s' form takes at most %d argument(s)" rx--every "The `%s' form requires arguments satisfying `%s'" "The `%s' form did not expand to a string" nil] 11 (#$ . 22857)])
#@263 Substitute BINDINGS in FORM.  BINDINGS is an alist of (NAME . VALUES)
where VALUES is a list to splice into FORM wherever NAME occurs.
Return the substitution result wrapped in a list, since a single value
can expand to any number of values.

(fn BINDINGS FORM)
(defalias 'rx--substitute #[514 "\2119\203\211\236\211\203\211A\202
C\207\211:\203Z\211A<\2031\300\301\302\303\304\305!\306\"\307\310%\"C\207\311@\"\311A\"
\203V
A\204V\211\203V\211A\204V
@
@BC\202Y\312\313!\207\211C\207" [mapcan make-byte-code 257 "\301\302\300\"!\207" vconcat vector [copy-sequence rx--substitute] 5 "\n\n(fn X)" rx--substitute error "Cannot substitute a &rest parameter into a dotted pair"] 9 (#$ . 23446)])
#@98 Return TEMPLATE with variables in ARGLIST replaced with VALUES.

(fn OP VALUES ARGLIST TEMPLATE)
(defalias 'rx--expand-template #[1028 "\300\211\203e\211@\211\301=\203,
A\204\302\303	\"\210
A@BB\262\300\262\300\262\202]\211\204O\302\304\n\nG\301>\203C\305\202D\306G\301
>GZ%\210\211@CBB\262A\262\210\210\211A\262
\202
\203u\302\307GG$\210\310\"\211\203\207\211A\204\207\211@\202\214\302\311	\"\262
\207" [nil &rest error "Expanding rx def `%s': missing &rest parameter name" "Expanding rx def `%s': too few arguments (got %d, need %s%d)" "at least " "" "Expanding rx def `%s': too many arguments (got %d, need %d)" rx--substitute "Expanding rx def `%s': must result in a single value"] 17 (#$ . 24164)])
#@82 Translate an rx form (list structure).  Return (REGEXP . PRECEDENCE).

(fn FORM)
(defalias 'rx--translate-form #[257 "\211A
@\211\302\267\202\331\303!\2020
\304!\2020
\305\306\"\2020
\305\307\"\2020
\310\306\"\2020
\311\306\"\2020
\312!\2020
\313!\2020
\314!\2020
\315!\2020
\316\317#\2020
\316\320#\2020
\316\321#\2020
\316\317\307#\2020
\316\320\307#\2020
\316\321\307#\2020
\316\317\306#\2020
\316\320\306#\2020
\316\321\306#\2020
\322\306\"\2020
\322\307\"\2020
\323!\2020
\324!\2020
\325!\2020
\326\306\"\2020
\326\307\"\2020
\327\306\"\2020
\330!\2020
\331!\2020
\332!\2020
\211\2119\204\346\333\334\"\202.
\335!\211\205\360\336
!\262
\206.
\211	\236\211\203
\211A:\204
\211A9\203
\211A	\236\202
\211@
	>A\236\262
\202\370\211\205%
\337
A\"\262
\206.
\333\340\"\262
\262
\207" [rx--greedy rx-constituents #s(hash-table size 45 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (sequence 10 and 10 : 10 seq 10 | 16 or 16 char 22 in 22 any 22 not-char 29 not 36 intersection 43 repeat 50 = 56 >= 62 ** 68 0+ 74 zero-or-more 74 1+ 82 one-or-more 82 optional 90 opt 90 zero-or-one 90 * 98 + 106 32 114 \? 114 *\? 122 +\? 130 63 138 \?\? 138 minimal-match 146 maximal-match 153 submatch 160 group 160 submatch-n 166 group-n 166 backref 172 syntax 178 not-syntax 185 category 192 literal 199 eval 205 regex 211 regexp 211)) rx--translate-seq rx--translate-or rx--translate-any nil t rx--translate-not rx--translate-intersection rx--translate-repeat rx--translate-= rx--translate->= rx--translate-** rx--translate-rep "*" "+" "?" rx--control-greedy rx--translate-group rx--translate-group-n rx--translate-backref rx--translate-syntax rx--translate-category rx--translate-literal rx--translate-eval rx--translate-regexp error "Bad rx operator `%S'" rx--expand-def rx--translate rx--translate-compat-form "Unknown rx form `%s'"] 8 (#$ . 24918)])
#@44 List of built-in rx function-like symbols.
(defconst rx--builtin-forms '(seq sequence : and or | any in char not-char not intersection repeat = >= ** zero-or-more 0+ * one-or-more 1+ + zero-or-one opt optional \? *\? +\? \?\? minimal-match maximal-match group submatch group-n submatch-n backref syntax not-syntax category literal eval regexp regex) (#$ . 26828))
#@44 List of built-in rx variable-like symbols.
(defconst rx--builtin-symbols (byte-code "\301\302\303\304\"\"\207" [rx--char-classes append (nonl not-newline any anychar anything unmatchable bol eol line-start line-end bos eos string-start string-end bow eow word-start word-end symbol-start symbol-end point word-boundary not-word-boundary not-wordchar) mapcar car] 5) (#$ . 27198))
#@68 List of built-in rx names.  These cannot be redefined by the user.
(defconst rx--builtin-names (append rx--builtin-forms rx--builtin-symbols) (#$ . 27585))
#@77 Translate the rx-expression ITEM.  Return (REGEXP . PRECEDENCE).

(fn ITEM)
(defalias 'rx--translate #[257 "\211;\203\"\211G\300U\203\301\302B\207\303
!C
G\304U\203\305\202 \302B\207\306
!\2031\303\307!!C\305B\207\2119\203:\310
!\207\211:\203C\311
!\207\312\313\"\207" [0 nil seq regexp-quote 1 t characterp char-to-string rx--translate-symbol rx--translate-form error "Bad rx expression: %S"] 4 (#$ . 27747)])
#@325 Translate FORM from `rx' sexp syntax into a string regexp.
The arguments to `literal' and `regexp' forms inside FORM must be
constant strings.
If NO-GROUP is non-nil, don't bracket the result in a non-capturing
group.

For extending the `rx' notation in FORM, use `rx-define' or `rx-let-eval'.

(fn FORM &optional NO-GROUP)
(defalias 'rx-to-string #[513 "\300!
\203\f\211@\202\301
!\302\303\"\207" [rx--translate rx--atomic-regexp apply concat] 7 (#$ . 28176)])
#@85 Translate the rx-expression FORM to a Lisp expression yielding a regexp.

(fn FORM)
(defalias 'rx--to-expr #[257 "\301\302
!@\303
\203G\303\203#@;\203#@
B\262
A\262\202\f\304\305\237\"\211G\306U\2044\211B\262\266
\203
@
B\262

A\262\202\211\204O\307\202]\211A\203[\305
\237B\202]\211@)\207" [rx--delayed-evaluation t rx--translate nil apply concat 0 ""] 7 (#$ . 28649)])
#@5601 Translate regular expressions REGEXPS in sexp form to a regexp string.
Each argument is one of the forms below; RX is a subform, and RX... stands
for zero or more RXs.  For details, see Info node `(elisp) Rx Notation'.
See `rx-to-string' for the corresponding function.

STRING         Match a literal string.
CHAR           Match a literal character.

(seq RX...)    Match the RXs in sequence.  Alias: :, sequence, and.
(or RX...)     Match one of the RXs.  Alias: |.

(zero-or-more RX...) Match RXs zero or more times.  Alias: 0+.
(one-or-more RX...)  Match RXs one or more times.  Alias: 1+.
(zero-or-one RX...)  Match RXs or the empty string.  Alias: opt, optional.
(* RX...)       Match RXs zero or more times; greedy.
(+ RX...)       Match RXs one or more times; greedy.
(? RX...)       Match RXs or the empty string; greedy.
(*? RX...)      Match RXs zero or more times; non-greedy.
(+? RX...)      Match RXs one or more times; non-greedy.
(?? RX...)      Match RXs or the empty string; non-greedy.
(= N RX...)     Match RXs exactly N times.
(>= N RX...)    Match RXs N or more times.
(** N M RX...)  Match RXs N to M times.  Alias: repeat.
(minimal-match RX)  Match RX, with zero-or-more, one-or-more, zero-or-one
                and aliases using non-greedy matching.
(maximal-match RX)  Match RX, with zero-or-more, one-or-more, zero-or-one
                and aliases using greedy matching, which is the default.

(any SET...)    Match a character from one of the SETs.  Each SET is a
                character, a string, a range as string "A-Z" or cons
                (?A . ?Z), or a character class (see below).  Alias: in, char.
(not CHARSPEC)  Match one character not matched by CHARSPEC.  CHARSPEC
                can be a character, single-char string, (any ...), (or ...),
                (intersection ...), (syntax ...), (category ...),
                or a character class.
(intersection CHARSET...) Match all CHARSETs.
                CHARSET is (any...), (not...), (or...) or (intersection...),
                a character or a single-char string.
not-newline     Match any character except a newline.  Alias: nonl.
anychar         Match any character.  Alias: anything.
unmatchable     Never match anything at all.

CHARCLASS       Match a character from a character class.  One of:
 alpha, alphabetic, letter   Alphabetic characters (defined by Unicode).
 alnum, alphanumeric         Alphabetic or decimal digit chars (Unicode).
 digit numeric, num          0-9.
 xdigit, hex-digit, hex      0-9, A-F, a-f.
 cntrl, control              ASCII codes 0-31.
 blank                       Horizontal whitespace (Unicode).
 space, whitespace, white    Chars with whitespace syntax.
 lower, lower-case           Lower-case chars, from current case table.
 upper, upper-case           Upper-case chars, from current case table.
 graph, graphic              Graphic characters (Unicode).
 print, printing             Whitespace or graphic (Unicode).
 punct, punctuation          Not control, space, letter or digit (ASCII);
                              not word syntax (non-ASCII).
 word, wordchar              Characters with word syntax.
 ascii                       ASCII characters (codes 0-127).
 nonascii                    Non-ASCII characters (but not raw bytes).

(syntax SYNTAX)  Match a character with syntax SYNTAX, being one of:
  whitespace, punctuation, word, symbol, open-parenthesis,
  close-parenthesis, expression-prefix, string-quote,
  paired-delimiter, escape, character-quote, comment-start,
  comment-end, string-delimiter, comment-delimiter

(category CAT)   Match a character in category CAT, being one of:
  space-for-indent, base, consonant, base-vowel,
  upper-diacritical-mark, lower-diacritical-mark, tone-mark, symbol,
  digit, vowel-modifying-diacritical-mark, vowel-sign,
  semivowel-lower, not-at-end-of-line, not-at-beginning-of-line,
  alpha-numeric-two-byte, chinese-two-byte, greek-two-byte,
  japanese-hiragana-two-byte, indian-two-byte,
  japanese-katakana-two-byte, strong-left-to-right,
  korean-hangul-two-byte, strong-right-to-left, cyrillic-two-byte,
  combining-diacritic, ascii, arabic, chinese, ethiopic, greek,
  korean, indian, japanese, japanese-katakana, latin, lao,
  tibetan, japanese-roman, thai, vietnamese, hebrew, cyrillic,
  can-break

Zero-width assertions: these all match the empty string in specific places.
 line-start         At the beginning of a line.  Alias: bol.
 line-end           At the end of a line.  Alias: eol.
 string-start       At the start of the string or buffer.
                     Alias: buffer-start, bos, bot.
 string-end         At the end of the string or buffer.
                     Alias: buffer-end, eos, eot.
 point              At point.
 word-start         At the beginning of a word.  Alias: bow.
 word-end           At the end of a word.  Alias: eow.
 word-boundary      At the beginning or end of a word.
 not-word-boundary  Not at the beginning or end of a word.
 symbol-start       At the beginning of a symbol.
 symbol-end         At the end of a symbol.

(group RX...)  Match RXs and define a capture group.  Alias: submatch.
(group-n N RX...) Match RXs and define capture group N.  Alias: submatch-n.
(backref N)    Match the text that capture group N matched.

(literal EXPR) Match the literal string from evaluating EXPR at run time.
(regexp EXPR)  Match the string regexp from evaluating EXPR at run time.
(eval EXPR)    Match the rx sexp from evaluating EXPR at compile time.

Additional constructs can be defined using `rx-define' and `rx-let',
which see.

(fn REGEXPS...)
(defalias 'rx '(macro . #[128 "\302\236A\303\304B!)\207" [macroexpand-all-environment rx--local-definitions :rx-locals rx--to-expr seq] 4 (#$ . 29052)]))
#@99 Make a definitions entry out of TAIL.
TAIL is on the form ([ARGLIST] DEFINITION).

(fn NAME TAIL)
(defalias 'rx--make-binding #[514 "
9\204\n\301\302\"\210
>\203\301\303\"\210\211:\203f\211@
A\211\204*
\211C\262
\202e\211:\203`\211@
A\211\204T
\211<\203E\304\305\"\204L\301\306	#\210\211D\266\202\202[\301\307#\266\202\202e\301\307#\207\301\307#\207" [rx--builtin-names error "Bad `rx' definition name: %S" "Cannot redefine built-in rx name `%s'" rx--every symbolp "Bad argument list for `rx' definition %s: %S" "Bad `rx' definition of %s: %S"] 12 (#$ . 34815)])
#@111 Make a definitions entry out of BINDSPEC.
BINDSPEC is on the form (NAME [ARGLIST] DEFINITION).

(fn BINDSPEC)
(defalias 'rx--make-named-binding #[257 "\211:\204\n\300\301\"\210\211@\302@A\"B\207" [error "Bad `rx-let' binding: %S" rx--make-binding] 5 (#$ . 35413)])
#@18 

(fn BINDSPECS)
(defalias 'rx--extend-local-defs #[257 "\301\302\303\"\"\207" [rx--local-definitions append mapcar rx--make-named-binding] 5 (#$ . 35688)])
#@844 Evaluate BODY with local BINDINGS for `rx-to-string'.
BINDINGS, after evaluation, is a list of definitions each on the form
(NAME [(ARGS...)] RX), in effect for calls to `rx-to-string'
in BODY.

For bindings without an ARGS list, NAME is defined as an alias
for the `rx' expression RX.  Where ARGS is supplied, NAME is
defined as an `rx' form with ARGS as argument list.  The
parameters are bound from the values in the (NAME ...) form and
are substituted in RX.  ARGS can contain `&rest' parameters,
whose values are spliced into RX where the parameter name occurs.

Any previous definitions with the same names are shadowed during
the expansion of BODY only.
For extensions when using the `rx' macro, use `rx-let'.
To make global rx extensions, use `rx-define'.
For more details, see Info node `(elisp) Extending Rx'.

(fn BINDINGS BODY...)
(defalias 'rx-let-eval '(macro . #[385 "\300\301\302DDCBB\207" [let rx--local-definitions rx--extend-local-defs] 6 (#$ . 35854)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put rx-let-eval lisp-indent-function 1 put edebug-form-spec (form body)] 5)
#@858 Evaluate BODY with local BINDINGS for `rx'.
BINDINGS is an unevaluated list of bindings each on the form
(NAME [(ARGS...)] RX).
They are bound lexically and are available in `rx' expressions in
BODY only.

For bindings without an ARGS list, NAME is defined as an alias
for the `rx' expression RX.  Where ARGS is supplied, NAME is
defined as an `rx' form with ARGS as argument list.  The
parameters are bound from the values in the (NAME ...) form and
are substituted in RX.  ARGS can contain `&rest' parameters,
whose values are spliced into RX where the parameter name occurs.

Any previous definitions with the same names are shadowed during
the expansion of BODY only.
For local extensions to `rx-to-string', use `rx-let-eval'.
To make global rx extensions, use `rx-define'.
For more details, see Info node `(elisp) Extending Rx'.

(fn BINDINGS BODY...)
(defalias 'rx-let '(macro . #[385 "\301\236A\302\303\"\304\305B\301\306\"BB\"\207" [macroexpand-all-environment :rx-locals mapcar rx--make-named-binding macroexpand-all progn append] 10 (#$ . 36975)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put rx-let lisp-indent-function 1 put edebug-form-spec (sexp body)] 5)
#@646 Define NAME as a global `rx' definition.
If the ARGS list is omitted, define NAME as an alias for the `rx'
expression RX.

If the ARGS list is supplied, define NAME as an `rx' form with
ARGS as argument list.  The parameters are bound from the values
in the (NAME ...) form and are substituted in RX.
ARGS can contain `&rest' parameters, whose values are spliced
into RX where the parameter name occurs.

Any previous global definition of NAME is overwritten with the new one.
To make local rx extensions, use `rx-let' for `rx',
`rx-let-eval' for `rx-to-string'.
For more details, see Info node `(elisp) Extending Rx'.

(fn NAME [(ARGS...)] RX)
(defalias 'rx-define '(macro . #[385 "\300\301\302D\303\302\304\"DF\302DE\207" [eval-and-compile put quote 'rx-definition rx--make-binding] 10 (#$ . 38181)]))
(byte-code "\300\301\302\303#\300\207" [function-put rx-define lisp-indent-function 1] 4)
#@151 Transform RX, an rx-expression augmented with `let' and named `backref',
into a plain rx-expression, collecting names into `rx--pcase-vars'.

(fn RX)
(defalias 'rx--pcase-transform #[257 "\301
:\203\"

@\211\302\267\202\374A\211:\203A\211@
A\211\211>G\211\303U\203.
B\211G\202/\211\304
\305\306B!E\266\202\266\202\266\202\202^
\2119\204M\211\307>\205Q\211\310>?\262
\203]
\"\202^\262
\202
A\211:\203\332\211@
A\211\204\270
\2119\262
\203\230
\211>G\211\303U\203\216\311\312\313\314\315#\"\210\316
D\262
\262
\202\325\2119\204\244\211\307>\205\250\211\310>?\262
\203\264\"\202\325\202\325\2119\204\304\211\307>\205\310\211\310>?\262
\203\324\"\202\325\266\202\202\367
\2119\204\346\211\307>\205\352\211\310>?\262
\203\366
\"\202\367\262
\202
A
\2119\204\n
\211\307>\205
\211\310>?\262
\203

\"\202
\262
\262
\202#

\207" [rx--pcase-vars #[514 "\211\300\301\"B\207" [mapcar rx--pcase-transform] 6 "\n\n(fn REST HEAD)"] #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (let 14 backref 99)) 0 group-n rx--pcase-transform seq (32 63) (literal regexp regex eval) error "rx `backref' variable must be one of: %s" mapconcat symbol-name " " backref] 15 (#$ . 39088)])
#@752 A pattern that matches strings against `rx' REGEXPS in sexp form.
REGEXPS are interpreted as in `rx'.  The pattern matches any
string that is a match for REGEXPS, as if by `string-match'.

In addition to the usual `rx' syntax, REGEXPS can contain the
following constructs:

  (let REF RX...)  binds the symbol REF to a submatch that matches
                   the regular expressions RX.  REF is bound in
                   CODE to the string of the submatch or nil, but
                   can also be used in `backref'.
  (backref REF)    matches whatever the submatch REF matched.
                   REF can be a number, as usual, or a name
                   introduced by a previous (let REF ...)
                   construct.

(fn &rest REGEXPS)
(defalias 'rx--pcase-macroexpander #[128 "\301\302\303\304B!!\305\306\307DD\310C\311\312\313\314\315\316!\317\"\320\321%\322!\"\262
)BB\207" [rx--pcase-vars nil rx--to-expr rx--pcase-transform seq and pred string-match 0 mapcar make-byte-code 257 "\300\211\242T\240\210\301\302\300\242DE\207" vconcat vector [app match-string] 4 "\n\n(fn NAME)" reverse] 12 (#$ . 40354)])
(byte-code "\300\301\302\303#\300\304\305\301#\306\307\310\303#\210\311\307\310\312#\210\313\304!\207" [define-symbol-prop rx--pcase-macroexpander edebug-form-spec nil rx pcase-macroexpander defalias rx-submatch-n rx-to-string make-obsolete "27.1" provide] 6)