HOME

Mini Shell 1.0
DIR:/proc/self/root/usr/share/emacs/26.1/lisp/emacs-lisp/
Current File : //proc/self/root/usr/share/emacs/26.1/lisp/emacs-lisp/rx.elc
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

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


#@642 Alist of sexp form regexp constituents.
Each element of the alist has the form (SYMBOL . DEFN).
SYMBOL is a valid constituent of sexp regular expressions.
If DEFN is a string, SYMBOL is translated into DEFN.
If DEFN is a symbol, use the definition of DEFN, recursively.
Otherwise, DEFN must be a list (FUNCTION MIN-ARGS MAX-ARGS PREDICATE).
FUNCTION is used to produce code for SYMBOL.  MIN-ARGS and MAX-ARGS
are the minimum and maximum number of arguments the function-form
sexp constituent SYMBOL may have in sexp regular expressions.
MAX-ARGS nil means no limit.  PREDICATE, if specified, means that
all arguments must satisfy PREDICATE.
(defvar rx-constituents '((and rx-and 1 nil) (seq . and) (: . and) (sequence . and) (or rx-or 1 nil) (| . or) (not-newline . ".") (nonl . not-newline) (anything rx-anything 0 nil) (any rx-any 1 nil rx-check-any) (any . ".") (in . any) (char . any) (not-char rx-not-char 1 nil rx-check-any) (not rx-not 1 1 rx-check-not) (repeat rx-repeat 2 nil) (= rx-= 2 nil) (>= rx->= 2 nil) (** rx-** 2 nil) (submatch rx-submatch 1 nil) (group . submatch) (submatch-n rx-submatch-n 2 nil) (group-n . submatch-n) (zero-or-more rx-kleene 1 nil) (one-or-more rx-kleene 1 nil) (zero-or-one rx-kleene 1 nil) (\? . zero-or-one) (\?\? . zero-or-one) (* . zero-or-more) (*\? . zero-or-more) (0+ . zero-or-more) (+ . one-or-more) (+\? . one-or-more) (1+ . one-or-more) (optional . zero-or-one) (opt . zero-or-one) (minimal-match rx-greedy 1 1) (maximal-match rx-greedy 1 1) (backref rx-backref 1 1 rx-check-backref) (line-start . "^") (bol . line-start) (line-end . "$") (eol . line-end) (string-start . "\\`") (bos . string-start) (bot . string-start) (string-end . "\\'") (eos . string-end) (eot . string-end) (buffer-start . "\\`") (buffer-end . "\\'") (point . "\\=") (word-start . "\\<") (bow . word-start) (word-end . "\\>") (eow . word-end) (word-boundary . "\\b") (not-word-boundary . "\\B") (symbol-start . "\\_<") (symbol-end . "\\_>") (syntax rx-syntax 1 1) (not-syntax rx-not-syntax 1 1) (category rx-category 1 1 rx-check-category) (eval rx-eval 1 1) (regexp rx-regexp 1 1 stringp) (regex . regexp) (digit . "[[:digit:]]") (numeric . digit) (num . digit) (control . "[[:cntrl:]]") (cntrl . control) (hex-digit . "[[:xdigit:]]") (hex . hex-digit) (xdigit . hex-digit) (blank . "[[:blank:]]") (graphic . "[[:graph:]]") (graph . graphic) (printing . "[[:print:]]") (print . printing) (alphanumeric . "[[:alnum:]]") (alnum . alphanumeric) (letter . "[[:alpha:]]") (alphabetic . letter) (alpha . letter) (ascii . "[[:ascii:]]") (nonascii . "[[:nonascii:]]") (lower . "[[:lower:]]") (lower-case . lower) (punctuation . "[[:punct:]]") (punct . punctuation) (space . "[[:space:]]") (whitespace . space) (white . space) (upper . "[[:upper:]]") (upper-case . upper) (word . "[[:word:]]") (wordchar . word) (not-wordchar . "\\W")) (#$ . 409))
#@265 Alist mapping Rx syntax symbols to syntax characters.
Each entry has the form (SYMBOL . CHAR), where SYMBOL is a valid
symbol in `(syntax SYMBOL)', and CHAR is the syntax character
corresponding to SYMBOL, as it would be used with \s or \S in
regular expressions.
(defconst rx-syntax '((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)) (#$ . 3279))
#@272 Alist mapping symbols to category characters.
Each entry has the form (SYMBOL . CHAR), where SYMBOL is a valid
symbol in `(category SYMBOL)', and CHAR is the category character
corresponding to SYMBOL, as it would be used with `\c' or `\C' in
regular expression strings.
(defconst rx-categories '((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) (korean-hangul-two-byte . 78) (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)) (#$ . 3895))
#@124 Non-nil means produce greedy regular expressions for `zero-or-one',
`zero-or-more', and `one-or-more'.  Dynamically bound.
(defvar rx-greedy-flag t (#$ . 5056))
#@292 Return parsing/code generation info for OP.
If OP is the space character ASCII 32, return info for the symbol `?'.
If OP is the character `?', return info for the symbol `??'.
See also `rx-constituents'.
If HEAD is non-nil, then OP is the head of a sexp, otherwise it's
a standalone symbol.
(defalias 'rx-info #[(op head) "\305\267\202
\306\202
\307\310\203O9\203O\n\236A\203(;\202*:\203	\211\n\236\n>A\236A\211\203K\203D\f;\202F\f:\204K\f)\202)\207" [op old-op rx-constituents head new-op #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (32 6 63 11)) \? \?\? nil] 4 (#$ . 5224)])
#@49 Check FORM according to its car's parsing info.
(defalias 'rx-check #[(form) "<\204\n\306\307\"\210\310@\311\"GS	A@\312	8\313	8\2031\nW\2031\306\314@#\210\f\203B\n\fV\203B\306\315@\f#\210
??\205qA\316\211\205p@
!\204f\306\317@
#\210A\211\204S\316*-\207" [form rx nargs min-args max-args type-pred error "rx `%s' needs argument(s)" rx-info head 2 3 "rx form `%s' requires at least %d args" "rx form `%s' accepts at most %d args" nil "rx form `%s' requires args satisfying `%s'" sub-form --dolist-tail--] 5 (#$ . 5879)])
#@76 Put shy groups around REGEXP if seemingly necessary when GROUP
is non-nil.
(defalias 'rx-group-if #[(regexp group) "\302=\203\303	!\203K\304\202K\305=\2031\303\306\307	\"\203'	\310\211\224O\202(	!\203K\304\202K\311=\203<\304\202K\312=\204K\303	\312\"\203K\304\203T\313	\314Q\207	\207" [group regexp * rx-atomic-p nil : string-match "\\(?:[?*+]\\??\\|\\\\{[0-9]*,?[0-9]*\\\\}\\)\\'" 0 | t "\\(?:" "\\)"] 4 (#$ . 6443)])
#@74 Parse and produce code from FORM.
FORM is of the form `(and FORM1 ...)'.
(defalias 'rx-and #[(form) "\302!\210\303\304\305A\306#	\307>\205	\"\207" [form rx-parent rx-check rx-group-if mapconcat #[(x) "\301\302\"\207" [x rx-form :] 3] nil (* t)] 5 (#$ . 6891)])
#@62 Parse and produce code from FORM, which is `(or FORM1 ...)'.
(defalias 'rx-or #[(form) "\302!\210\303\304\305\306A\">\203\307\310A\311#\202\312A!	\313>\205#	\"\207" [form rx-parent rx-check rx-group-if nil mapcar stringp mapconcat #[(x) "\301\302\"\207" [x rx-form |] 3] "\\|" regexp-opt (: * t)] 5 (#$ . 7163)])
#@22 Match any character.
(defalias 'rx-anything #[(form) ":\203\n\301\302\"\210\303\304\305\306E!\207" [form error "rx `anything' syntax error: %s" rx-or or not-newline 10] 4 (#$ . 7492)])
#@93 Delete by side effect character CHAR from RANGES.
Only both edges of each range is checked.
(defalias 'rx-any-delete-from-range #[(char ranges) "\303	\n>\203\304	\n\"\202R	\n\236\211\2032	TA=\203*\n>	T\240\210\202R	T\240\210\202R\305	\n\"\211\203R	S@=\203M\n>	S\240\210\202R	S\241\210\n)\207" [m char ranges nil delq rassq] 3 (#$ . 7686)])
#@53 Condense by side effect ARGS as range for Rx `any'.
(defalias 'rx-any-condense-range #[(args) "\305\211\306\307\n\"\210\310\311\"\211\305\fA\211\203=\f@A@@SY\2037\f@\f@A@A]\241\210\fA\241\210\202\211\202*\312\313\314\315\"\"\316	!\244*\207" [l str args d tail nil mapc #[(e) ";\203	B\211\207\247\203\211B\nB\211\207\nB\211\207" [e str l] 2] sort car-less-than-car apply nconc mapcar #[(e) "@AU\203\f@C\207@TAU\203@AD\207C\207" [e] 2] delete-dups] 6 (#$ . 8052)])
#@41 Check string argument STR for Rx `any'.
(defalias 'rx-check-any-string #[(str) "\305\306\211\211\fG\305U\203\307\310!\210\311\312\f#\203X\305\224W\203-\313\f\305\224O\306\"\244\305\225\f\305\224H\fSH\n	W\203J\n	BC\244\202\n	U\203\nC\244\202\fGW\203i\313\f\306O\306\"\244,\207" [l c2 c1 i str 0 nil error "String arg for Rx `any' must not be empty" string-match ".-." append] 5 (#$ . 8563)])
#@29 Check arg ARG for Rx `any'.
(defalias 'rx-check-any #[(arg) "\250\203C\2079\2032\3021\303!0\202\210\304\211\203&\305\306	\"\204+\307\310\"\210	\311\312O)C\207\242\250\203A\243\250\203AC\207;\203J\313!\207\307\314!\207" [arg translation (error) rx-form nil string-match "\\`\\[\\[:[-a-z]+:\\]\\]\\'" error "Invalid char class `%s' in Rx `any'" 1 -1 rx-check-any-string "rx `any' requires string, character, char pair or char class args"] 4 (#$ . 8994)])
#@78 Parse and produce code from FORM, which is `(any ARG ...)'.
ARG is optional.
(defalias 'rx-any #[(form) "\305!\210\306\307\310\311\312A\"\"!\313\211\314	>\2037\314\315\314	\"B\316	>\204,\316	\236\203\336\317\316	\"\316C\244\202\336\314	\236\211\203l\n\315\n	\"B\316	>\203W\315\316	\"\316C\244\202\336\316	\236\211\203\336	\n\315\n	A\"B\241\210\202\336\320\314	\"\211\203\223\314\317\314	\"B\316	>\204\210\316	\236\203\336\317\316	\"\316C\244\202\336\316	>\203\243\316\315\316	\"B\202\336\316	\236\211\203\265\n\315\n	\"B\202\336	@\321=\204\304	@\242\321=\203\336	A\203\326	A@	@	AABB\202\335\317\321	\"\321C\244	A\204	@\247\203\322\323	@!!\211G\324U\204	@\321\232\203\f\325=\204\202\326\327\330	\313#\331Q+\207" [form args m s rx-parent rx-check rx-any-condense-range apply nconc mapcar rx-check-any nil 93 delq 45 rx-any-delete-from-range rassq 94 regexp-quote string 1 ! "[" mapconcat #[(e) "\247\203	\301!\207:\2034@TAU\203,@\302>\204,A\303>\204,\301@A\"\207\301@\304A#\207\207" [e string (93 45) (93 45) 45] 4] "]"] 7 (#$ . 9476)])
#@29 Check arg ARG for Rx `not'.
(defalias 'rx-check-not #[(arg) "9\203\301\302\3031\304!0\202\210\305\"\204/\306=\204/:\203*@\307>\204/\310\311\"\210\312\207" [arg string-match "\\`\\[\\[:[-a-z]+:\\]\\]\\'" (error) rx-form "" word-boundary (not any in syntax category) error "rx `not' syntax error: %s" t] 4 (#$ . 10587)])
#@57 Parse and produce code from FORM.  FORM is `(not ...)'.
(defalias 'rx-not #[(form) "\304!\210\305A@\306\"\307\310\311\n\"\203=\n\312\232\203\313\202z\nG\314U\2034\306=\2044\315\n\316\317O!\202z\320\n\316\307OP\202z\n\321H\322=\203N\323\n\324\307OP\202z\310\325\n\"\203b\n\321\316O\226\n\316\307OP\202z\310\326\n\"\203v\n\321\316O\227\n\316\307OP\202z\323\n\327Q*\207" [form case-fold-search result rx-parent rx-check rx-form ! nil string-match "\\`\\[^" "[^]" "[^^]" 4 regexp-quote 2 3 "[" 0 91 "[^" 1 "\\`\\\\[scbw]" "\\`\\\\[SCBW]" "]"] 4 (#$ . 10928)])
#@62 Parse and produce code from FORM.  FORM is `(not-char ...)'.
(defalias 'rx-not-char #[(form) "\301!\210\302\303\304ABD!\207" [form rx-check rx-not not in] 4 (#$ . 11509)])
#@67 Parse and produce code from FORM.  FORM is `(not-syntax SYNTAX)'.
(defalias 'rx-not-syntax #[(form) "\301!\210\302\303\304ABD!\207" [form rx-check rx-not not syntax] 4 (#$ . 11689)])
#@251 If FORM's length is greater than two, transform it to length two.
A form (HEAD REST ...) becomes (HEAD (and REST ...)).
If SKIP is non-nil, allow that number of items after the head, i.e.
`(= N REST ...)' becomes `(= N (and REST ...))' if SKIP is 1.
(defalias 'rx-trans-forms #[(form &optional skip) "\204\303T	\233\211G\304U\203	\202%\305	!	\233\306\nBC\241\210	))\207" [skip form tail 0 1 copy-sequence and] 4 (#$ . 11881)])
#@47 Parse and produce code from FORM `(= N ...)'.
(defalias 'rx-= #[(form) "\301!\210\302\303\"\211A@\250\203A@\304V\204\305\306!\210\307\310\311\3128\313\"A@#\207" [form rx-check rx-trans-forms 1 0 error "rx `=' requires positive integer first arg" format "%s\\{%d\\}" rx-form 2 *] 6 (#$ . 12325)])
#@48 Parse and produce code from FORM `(>= N ...)'.
(defalias 'rx->= #[(form) "\301!\210\302\303\"\211A@\250\203A@\304V\204\305\306!\210\307\310\311\3128\313\"A@#\207" [form rx-check rx-trans-forms 1 0 error "rx `>=' requires positive integer first arg" format "%s\\{%d,\\}" rx-form 2 *] 6 (#$ . 12637)])
#@50 Parse and produce code from FORM `(** N M ...)'.
(defalias 'rx-** #[(form) "\301!\210\302\303\304\305\"AB\306\"\207" [form rx-check rx-form repeat rx-trans-forms 2 *] 5 (#$ . 12953)])
#@97 Parse and produce code from FORM.
FORM is either `(repeat N FORM1)' or `(repeat N M FORMS...)'.
(defalias 'rx-repeat #[(form) "\301!\210G\302V\203\303\304\"\3048\204!@A@\305\233BBG\305U\203HA@\250\2037A@\306V\204;\307\310!\210\311\312\313\3048\314\"A@#\207\3048\250\203p\3048\306W\204pA@\250\203pA@\306W\204p\3048A@W\203t\307\315!\207\311\316\313\3058\314\"A@\3048$\207" [form rx-check 4 rx-trans-forms 2 3 0 error "rx `repeat' requires positive integer first arg" format "%s\\{%d\\}" rx-form * "rx `repeat' range error" "%s\\{%d,%d\\}"] 6 (#$ . 13145)])
#@62 Parse and produce code from FORM, which is `(submatch ...)'.
(defalias 'rx-submatch #[(form) "\301G\302U\203\303A@!\202\304\305A\306#\307Q\207" [form "\\(" 2 rx-form mapconcat #[(re) "\301\302\"\207" [re rx-form :] 3] nil "\\)"] 5 (#$ . 13740)])
#@66 Parse and produce code from FORM, which is `(submatch-n N ...)'.
(defalias 'rx-submatch-n #[(form) "A@\302\303	!\304G\305U\203\306\3078!\202\310\311AA\312#\313\260)\207" [form n "\\(?" number-to-string ":" 3 rx-form 2 mapconcat #[(re) "\301\302\"\207" [re rx-form :] 3] nil "\\)"] 7 (#$ . 14000)])
#@59 Parse and produce code from FORM, which is `(backref N)'.
(defalias 'rx-backref #[(form) "\301!\210\302\303A@\"\207" [form rx-check format "\\%d"] 3 (#$ . 14315)])
#@33 Check arg ARG for Rx `backref'.
(defalias 'rx-check-backref #[(arg) "\250\203\301Y\203\302X\206\303\304\"\207" [arg 1 9 error "rx `backref' requires numeric 1<=arg<=9: %s"] 3 (#$ . 14487)])
#@326 Parse and produce code from FORM.
FORM is `(OP FORM1)', where OP is one of the `zero-or-one',
`zero-or-more' etc.  operators.
If OP is one of `*', `+', `?', produce a greedy regexp.
If OP is one of `*?', `+?', `??', produce a non-greedy regexp.
If OP is anything else, produce a greedy regexp if `rx-greedy-flag'
is non-nil.
(defalias 'rx-kleene #[(form) "\305!\210\306!\211@\307>\203\310\202'@\311>\203\312\202'	\203&\310\202'\312@\313>\2032\314\202>@\315>\203=\316\202>\312\317\320A@\321\"\nQ\f\322>\205Q\f\"*\207" [form rx-greedy-flag op suffix rx-parent rx-check rx-trans-forms (* + 32) "" (*\? +\? 63) "?" (* *\? 0+ zero-or-more) "*" (+ +\? 1+ one-or-more) "+" rx-group-if rx-form * (t *)] 5 (#$ . 14694)])
#@988 Return non-nil if regexp string R is atomic.
An atomic regexp R is one such that a suffix operator
appended to R will apply to all of R.  For example, "a"
"[abc]" and "\(ab\|ab*c\)" are atomic and "ab",
"[ab]c", and "ab\|ab*c" are not atomic.

This function may return false negatives, but it will not
return false positives.  It is nevertheless useful in
situations where an efficiency shortcut can be taken only if a
regexp is atomic.  The function can be improved to detect
more cases of atomic regexps.  Presently, this function
detects the following categories of atomic regexp;

  a group or shy group:  \(...\)
  a character class:     [...]
  a single character:    a

On the other hand, false negatives will be returned for
regexps that are atomic but end in operators, such as
"a+".  I think these are rare.  Probably such cases could
be detected without much effort.  A guarantee of no false
negatives would require a theoretic specification of the set
of all atomic regexps.
(defalias 'rx-atomic-p #[(r &optional lax) "G\211\303X\2068	\304U\203\305H\306U\2028	\307U\203$\310\311\"\2028\n?\2058\310\312\"\2068\310\313\"\2068\314)\207" [r l lax 1 2 0 92 3 string-match "\\`\\(?:\\\\[cCsS_]\\|\\[[^^]\\]\\)" "\\`\\[^?]?\\(?:\\[:[a-z]+:]\\|[^]]\\)*\\]\\'" "\\`\\\\(\\(?:[^\\]\\|\\\\[^)]\\)*\\\\)\\'" nil] 4 (#$ . 15436)])
#@63 Parse and produce code from FORM, which is `(syntax SYMBOL)'.
(defalias 'rx-syntax #[(form) "\305!\210A@\211\n\236A\211\204:\306	!\203	\2021	9\2031\307	!\211G\310U\2030\f\311H)\204:\312\313	\"\210\314\315\"*\207" [form sym rx-syntax syntax name rx-check characterp symbol-name 1 0 error "Unknown rx syntax `%s'" format "\\s%c"] 4 (#$ . 16787)])
#@49 Check the argument FORM of a `(category FORM)'.
(defalias 'rx-check-category #[(form) "\250\204	\236A\204\302\303\"\210\304\207" [form rx-categories error "Unknown category `%s'" t] 3 (#$ . 17154)])
#@65 Parse and produce code from FORM, which is `(category SYMBOL)'.
(defalias 'rx-category #[(form) "\303!\210A@\250\203A@\202A@	\236A\304\305\n\")\207" [form rx-categories char rx-check format "\\c%c"] 3 (#$ . 17366)])
#@59 Parse and produce code from FORM, which is `(eval FORM)'.
(defalias 'rx-eval #[(form) "\302!\210\303\304A@!	\"\207" [form rx-parent rx-check rx-form eval] 3 (#$ . 17597)])
#@213 Parse and produce code from FORM.
If FORM is `(minimal-match FORM1)', non-greedy versions of `*',
`+', and `?' operators will be used in FORM1.  If FORM is
`(maximal-match FORM1)', greedy operators will be used.
(defalias 'rx-greedy #[(form) "\303!\210@\304=\305A@\n\")\207" [form rx-greedy-flag rx-parent rx-check maximal-match rx-form] 3 (#$ . 17778)])
#@63 Parse and produce code from FORM, which is `(regexp STRING)'.
(defalias 'rx-regexp #[(form) "\302!\210\303A@	\"\207" [form rx-parent rx-check rx-group-if] 3 (#$ . 18143)])
#@230 Parse and produce code for regular expression FORM.
FORM is a regular expression in sexp form.
RX-PARENT shows which type of expression calls and controls putting of
shy groups around the result and some more in other functions.
(defalias 'rx-form #[(form &optional rx-parent) ";\203\303\304!	\305=\205\306GW\205	\"\207\250\203$\304\307!!\2079\203H\310\311\"\211;\2037\n\202F\n\204B\312\313\"\202F\n@!)\207:\203d\310@\314\"\211:\204^\312\313@\"\210\n@!)\207\312\315\"\207" [form rx-parent info rx-group-if regexp-quote * 1 char-to-string rx-info nil error "Unknown rx form `%s'" head "rx syntax error at `%s'"] 5 (#$ . 18324)])
#@159 Parse and produce code for regular expression FORM.
FORM is a regular expression in sexp form.
NO-GROUP non-nil means don't put shy groups around the result.
(defalias 'rx-to-string #[(form &optional no-group) "\302\303!	?\"\207" [form no-group rx-group-if rx-form] 3 (#$ . 18989)])
#@8727 Translate regular expressions REGEXPS in sexp form to a regexp string.
REGEXPS is a non-empty sequence of forms of the sort listed below.

Note that `rx' is a Lisp macro; when used in a Lisp program being
compiled, the translation is performed by the compiler.
See `rx-to-string' for how to do such a translation at run-time.

The following are valid subforms of regular expressions in sexp
notation.

STRING
     matches string STRING literally.

CHAR
     matches character CHAR literally.

`not-newline', `nonl'
     matches any character except a newline.

`anything'
     matches any character

`(any SET ...)'
`(in SET ...)'
`(char SET ...)'
     matches any character in SET ....  SET may be a character or string.
     Ranges of characters can be specified as `A-Z' in strings.
     Ranges may also be specified as conses like `(?A . ?Z)'.

     SET may also be the name of a character class: `digit',
     `control', `hex-digit', `blank', `graph', `print', `alnum',
     `alpha', `ascii', `nonascii', `lower', `punct', `space', `upper',
     `word', or one of their synonyms.

`(not (any SET ...))'
     matches any character not in SET ...

`line-start', `bol'
     matches the empty string, but only at the beginning of a line
     in the text being matched

`line-end', `eol'
     is similar to `line-start' but matches only at the end of a line

`string-start', `bos', `bot'
     matches the empty string, but only at the beginning of the
     string being matched against.

`string-end', `eos', `eot'
     matches the empty string, but only at the end of the
     string being matched against.

`buffer-start'
     matches the empty string, but only at the beginning of the
     buffer being matched against.  Actually equivalent to `string-start'.

`buffer-end'
     matches the empty string, but only at the end of the
     buffer being matched against.  Actually equivalent to `string-end'.

`point'
     matches the empty string, but only at point.

`word-start', `bow'
     matches the empty string, but only at the beginning of a word.

`word-end', `eow'
     matches the empty string, but only at the end of a word.

`word-boundary'
     matches the empty string, but only at the beginning or end of a
     word.

`(not word-boundary)'
`not-word-boundary'
     matches the empty string, but not at the beginning or end of a
     word.

`symbol-start'
     matches the empty string, but only at the beginning of a symbol.

`symbol-end'
     matches the empty string, but only at the end of a symbol.

`digit', `numeric', `num'
     matches 0 through 9.

`control', `cntrl'
     matches ASCII control characters.

`hex-digit', `hex', `xdigit'
     matches 0 through 9, a through f and A through F.

`blank'
     matches horizontal whitespace, as defined by Annex C of the
     Unicode Technical Standard #18.  In particular, it matches
     spaces, tabs, and other characters whose Unicode
     `general-category' property indicates they are spacing
     separators.

`graphic', `graph'
     matches graphic characters--everything except whitespace, ASCII
     and non-ASCII control characters, surrogates, and codepoints
     unassigned by Unicode.

`printing', `print'
     matches whitespace and graphic characters.

`alphanumeric', `alnum'
     matches alphabetic characters and digits.  (For multibyte characters,
     it matches according to Unicode character properties.)

`letter', `alphabetic', `alpha'
     matches alphabetic characters.  (For multibyte characters,
     it matches according to Unicode character properties.)

`ascii'
     matches ASCII (unibyte) characters.

`nonascii'
     matches non-ASCII (multibyte) characters.

`lower', `lower-case'
     matches anything lower-case.

`upper', `upper-case'
     matches anything upper-case.

`punctuation', `punct'
     matches punctuation.  (But at present, for multibyte characters,
     it matches anything that has non-word syntax.)

`space', `whitespace', `white'
     matches anything that has whitespace syntax.

`word', `wordchar'
     matches anything that has word syntax.

`not-wordchar'
     matches anything that has non-word syntax.

`(syntax SYNTAX)'
     matches a character with syntax SYNTAX.  SYNTAX must be one
     of the following symbols, or a symbol corresponding to the syntax
     character, e.g. `\.' for `\s.'.

     `whitespace'		(\s- in string notation)
     `punctuation'		(\s.)
     `word'			(\sw)
     `symbol'			(\s_)
     `open-parenthesis'		(\s()
     `close-parenthesis'	(\s))
     `expression-prefix'	(\s')
     `string-quote'		(\s")
     `paired-delimiter'		(\s$)
     `escape'			(\s\)
     `character-quote'		(\s/)
     `comment-start'		(\s<)
     `comment-end'		(\s>)
     `string-delimiter'		(\s|)
     `comment-delimiter'	(\s!)

`(not (syntax SYNTAX))'
     matches a character that doesn't have syntax SYNTAX.

`(category CATEGORY)'
     matches a character with category CATEGORY.  CATEGORY must be
     either a character to use for C, or one of the following symbols.

     `consonant'			(\c0 in string notation)
     `base-vowel'			(\c1)
     `upper-diacritical-mark'		(\c2)
     `lower-diacritical-mark'		(\c3)
     `tone-mark'		        (\c4)
     `symbol'			        (\c5)
     `digit'			        (\c6)
     `vowel-modifying-diacritical-mark'	(\c7)
     `vowel-sign'			(\c8)
     `semivowel-lower'			(\c9)
     `not-at-end-of-line'		(\c<)
     `not-at-beginning-of-line'		(\c>)
     `alpha-numeric-two-byte'		(\cA)
     `chinese-two-byte'			(\cC)
     `greek-two-byte'			(\cG)
     `japanese-hiragana-two-byte'	(\cH)
     `indian-tow-byte'			(\cI)
     `japanese-katakana-two-byte'	(\cK)
     `korean-hangul-two-byte'		(\cN)
     `cyrillic-two-byte'		(\cY)
     `combining-diacritic'		(\c^)
     `ascii'				(\ca)
     `arabic'				(\cb)
     `chinese'				(\cc)
     `ethiopic'				(\ce)
     `greek'				(\cg)
     `korean'				(\ch)
     `indian'				(\ci)
     `japanese'				(\cj)
     `japanese-katakana'		(\ck)
     `latin'				(\cl)
     `lao'				(\co)
     `tibetan'				(\cq)
     `japanese-roman'			(\cr)
     `thai'				(\ct)
     `vietnamese'			(\cv)
     `hebrew'				(\cw)
     `cyrillic'				(\cy)
     `can-break'			(\c|)

`(not (category CATEGORY))'
     matches a character that doesn't have category CATEGORY.

`(and SEXP1 SEXP2 ...)'
`(: SEXP1 SEXP2 ...)'
`(seq SEXP1 SEXP2 ...)'
`(sequence SEXP1 SEXP2 ...)'
     matches what SEXP1 matches, followed by what SEXP2 matches, etc.

`(submatch SEXP1 SEXP2 ...)'
`(group SEXP1 SEXP2 ...)'
     like `and', but makes the match accessible with `match-end',
     `match-beginning', and `match-string'.

`(submatch-n N SEXP1 SEXP2 ...)'
`(group-n N SEXP1 SEXP2 ...)'
     like `group', but make it an explicitly-numbered group with
     group number N.

`(or SEXP1 SEXP2 ...)'
`(| SEXP1 SEXP2 ...)'
     matches anything that matches SEXP1 or SEXP2, etc.  If all
     args are strings, use `regexp-opt' to optimize the resulting
     regular expression.

`(minimal-match SEXP)'
     produce a non-greedy regexp for SEXP.  Normally, regexps matching
     zero or more occurrences of something are "greedy" in that they
     match as much as they can, as long as the overall regexp can
     still match.  A non-greedy regexp matches as little as possible.

`(maximal-match SEXP)'
     produce a greedy regexp for SEXP.  This is the default.

Below, `SEXP ...' represents a sequence of regexp forms, treated as if
enclosed in `(and ...)'.

`(zero-or-more SEXP ...)'
`(0+ SEXP ...)'
     matches zero or more occurrences of what SEXP ... matches.

`(* SEXP ...)'
     like `zero-or-more', but always produces a greedy regexp, independent
     of `rx-greedy-flag'.

`(*? SEXP ...)'
     like `zero-or-more', but always produces a non-greedy regexp,
     independent of `rx-greedy-flag'.

`(one-or-more SEXP ...)'
`(1+ SEXP ...)'
     matches one or more occurrences of SEXP ...

`(+ SEXP ...)'
     like `one-or-more', but always produces a greedy regexp.

`(+? SEXP ...)'
     like `one-or-more', but always produces a non-greedy regexp.

`(zero-or-one SEXP ...)'
`(optional SEXP ...)'
`(opt SEXP ...)'
     matches zero or one occurrences of A.

`(? SEXP ...)'
     like `zero-or-one', but always produces a greedy regexp.

`(?? SEXP ...)'
     like `zero-or-one', but always produces a non-greedy regexp.

`(repeat N SEXP)'
`(= N SEXP ...)'
     matches N occurrences.

`(>= N SEXP ...)'
     matches N or more occurrences.

`(repeat N M SEXP)'
`(** N M SEXP ...)'
     matches N to M occurrences.

`(backref N)'
     matches what was matched previously by submatch N.

`(eval FORM)'
     evaluate FORM and insert result.  If result is a string,
     `regexp-quote' it.

`(regexp REGEXP)'
     include REGEXP in string notation in the result.
(defalias 'rx '(macro . #[(&rest regexps) "\204\301\302!\207A\203\303\304B\305\"\207\303@\305\"\207" [regexps error "No regexp" rx-to-string and t] 3 (#$ . 19281)]))
#@903 Build a `pcase' pattern matching `rx' regexps.
The REGEXPS are interpreted as by `rx'.  The pattern matches if
the regular expression so constructed matches the object, as if
by `string-match'.

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

  (let VAR FORM...)  creates a new explicitly numbered submatch
                     that matches FORM and binds the match to
                     VAR.
  (backref VAR)      creates a backreference to the submatch
                     introduced by a previous (let VAR ...)
                     construct.

The VARs are associated with explicitly numbered submatches
starting from 1.  Multiple occurrences of the same VAR refer to
the same submatch.

If a case matches, the match data is modified as usual so you can
use it in the case body, but you still have to pass the correct
string as argument to `match-string'.
(defalias 'rx--pcase-macroexpander #[(&rest regexps) "\306\307\310\311BB\312\313\314\211\315\257	BB\316\317\nB\320\"\321\322\323DD\314\306\211
:\203H
@\324\325\fDEB\fT
A\211\202*\237.BB\207" [vars rx-constituents regexps regexp i #1=#:--cl-var-- nil let #[(form) "\304!\210A@\2119\204\305\306\307	\301E\"\210\310	\n\311\312$\206&\nG\313\n	C\"\314\315TAABB!*\207" [form var vars i rx-check signal wrong-type-argument symbol cl-position :test eq append rx-form submatch-n] 6] (1 nil) backref #[(form) "\303!\210\304\305A@\211\250\203	\202\306	\n\307\310$T)D!\207" [form var vars rx-check rx-backref backref cl-position :test eq] 8] 1 #[(var) "\250\203	\302!\207	>\203\303\207\304\305	#\207" [var vars rx-check-backref t error "rx `backref' variable must be one of %s: %s"] 4] rx-to-string seq :no-group and pred string-match app match-string var #2=#:--cl-var--] 7 (#$ . 28188)])
(byte-code "\300\301\302\303#\300\304\305\301#\306\304!\207" [define-symbol-prop rx--pcase-macroexpander edebug-form-spec nil rx pcase-macroexpander provide] 5)