Linux server.edchosting.com 4.18.0-553.79.1.lve.el7h.x86_64 #1 SMP Wed Oct 15 16:34:46 UTC 2025 x86_64
LiteSpeed
Server IP : 75.98.162.185 & Your IP : 216.73.216.163
Domains :
Cant Read [ /etc/named.conf ]
User : goons4good
Terminal
Auto Root
Create File
Create Folder
Localroot Suggester
Backdoor Destroyer
Readme
/
usr /
share /
emacs /
24.3 /
lisp /
emacs-lisp /
Delete
Unzip
Name
Size
Permission
Date
Action
advice.elc
58.25
KB
-rw-r--r--
2023-06-07 04:04
authors.elc
30.49
KB
-rw-r--r--
2023-06-07 04:04
autoload.elc
21.31
KB
-rw-r--r--
2023-06-07 03:59
avl-tree.elc
27.02
KB
-rw-r--r--
2023-06-07 04:04
backquote.elc
4.4
KB
-rw-r--r--
2023-06-07 04:18
benchmark.elc
3.18
KB
-rw-r--r--
2023-06-07 04:04
bindat.elc
10.69
KB
-rw-r--r--
2023-06-07 04:04
byte-opt.elc
35.7
KB
-rw-r--r--
2023-06-07 03:59
byte-run.elc
12.35
KB
-rw-r--r--
2023-06-07 04:18
bytecomp.elc
136.26
KB
-rw-r--r--
2023-06-07 03:59
cconv.elc
15.61
KB
-rw-r--r--
2023-06-07 03:59
chart.elc
22.14
KB
-rw-r--r--
2023-06-07 04:04
check-declare.elc
8.87
KB
-rw-r--r--
2023-06-07 04:04
checkdoc.elc
67.42
KB
-rw-r--r--
2023-06-07 04:04
cl-extra.elc
20.01
KB
-rw-r--r--
2023-06-07 04:04
cl-indent.elc
16.34
KB
-rw-r--r--
2023-06-07 04:04
cl-lib.elc
34.86
KB
-rw-r--r--
2023-06-07 04:04
cl-loaddefs.el
39.75
KB
-rw-r--r--
2013-01-01 15:37
cl-macs.elc
71.79
KB
-rw-r--r--
2023-06-07 04:04
cl-seq.elc
40.03
KB
-rw-r--r--
2023-06-07 04:04
cl.elc
16
KB
-rw-r--r--
2023-06-07 04:04
copyright.elc
10.29
KB
-rw-r--r--
2023-06-07 04:04
crm.elc
7.76
KB
-rw-r--r--
2023-06-07 04:04
debug.elc
26.92
KB
-rw-r--r--
2023-06-07 04:04
derived.elc
11.27
KB
-rw-r--r--
2023-06-07 04:04
disass.elc
5.48
KB
-rw-r--r--
2023-06-07 04:04
easy-mmode.elc
16.81
KB
-rw-r--r--
2023-06-07 04:04
easymenu.elc
20.03
KB
-rw-r--r--
2023-06-07 04:04
edebug.elc
101.25
KB
-rw-r--r--
2023-06-07 04:04
eieio-base.elc
13.18
KB
-rw-r--r--
2023-06-07 04:04
eieio-custom.elc
14.55
KB
-rw-r--r--
2023-06-07 04:04
eieio-datadebug.elc
3.9
KB
-rw-r--r--
2023-06-07 04:04
eieio-opt.elc
20.79
KB
-rw-r--r--
2023-06-07 04:04
eieio-speedbar.elc
12.55
KB
-rw-r--r--
2023-06-07 04:04
eieio.elc
89.24
KB
-rw-r--r--
2023-06-07 04:04
eldoc.elc
15.33
KB
-rw-r--r--
2023-06-07 04:04
elint.elc
31.22
KB
-rw-r--r--
2023-06-07 04:04
elp.elc
12.43
KB
-rw-r--r--
2023-06-07 04:04
ert-x.elc
9.78
KB
-rw-r--r--
2023-06-07 04:04
ert.elc
169.71
KB
-rw-r--r--
2023-06-07 04:04
ewoc.elc
26.49
KB
-rw-r--r--
2023-06-07 04:04
find-func.elc
17.4
KB
-rw-r--r--
2023-06-07 04:04
find-gc.elc
3.54
KB
-rw-r--r--
2023-06-07 04:04
float-sup.elc
1.36
KB
-rw-r--r--
2023-06-07 04:19
generic.elc
6.68
KB
-rw-r--r--
2023-06-07 04:04
gulp.elc
4.69
KB
-rw-r--r--
2023-06-07 04:04
gv.elc
17.81
KB
-rw-r--r--
2023-06-07 04:04
helper.elc
4.03
KB
-rw-r--r--
2023-06-07 04:04
lisp-mnt.elc
22.41
KB
-rw-r--r--
2023-06-07 04:04
lisp-mode.elc
44.27
KB
-rw-r--r--
2023-06-07 04:19
lisp.elc
18.56
KB
-rw-r--r--
2023-06-07 04:19
macroexp.elc
12.84
KB
-rw-r--r--
2023-06-07 04:18
map-ynp.elc
6.42
KB
-rw-r--r--
2023-06-07 04:18
package-x.elc
8.32
KB
-rw-r--r--
2023-06-07 04:04
package.elc
54.49
KB
-rw-r--r--
2023-06-07 04:04
pcase.elc
15.98
KB
-rw-r--r--
2023-06-07 04:04
pp.elc
5.56
KB
-rw-r--r--
2023-06-07 04:04
re-builder.elc
22.81
KB
-rw-r--r--
2023-06-07 04:04
regexp-opt.elc
4.87
KB
-rw-r--r--
2023-06-07 04:19
regi.elc
6.09
KB
-rw-r--r--
2023-06-07 04:04
ring.elc
6.58
KB
-rw-r--r--
2023-06-07 04:04
rx.elc
27.41
KB
-rw-r--r--
2023-06-07 04:04
shadow.elc
9.75
KB
-rw-r--r--
2023-06-07 04:04
smie.elc
35.4
KB
-rw-r--r--
2023-06-07 04:04
syntax.elc
13.69
KB
-rw-r--r--
2023-06-07 04:19
tabulated-list.elc
19.12
KB
-rw-r--r--
2023-06-07 04:19
tcover-ses.elc
15
KB
-rw-r--r--
2023-06-07 04:04
tcover-unsafep.elc
4.02
KB
-rw-r--r--
2023-06-07 04:04
testcover.elc
13.4
KB
-rw-r--r--
2023-06-07 04:04
timer.elc
22.94
KB
-rw-r--r--
2023-06-07 04:19
tq.elc
3.89
KB
-rw-r--r--
2023-06-07 04:04
trace.elc
5.24
KB
-rw-r--r--
2023-06-07 04:04
unsafep.elc
4.92
KB
-rw-r--r--
2023-06-07 04:04
warnings.elc
9.53
KB
-rw-r--r--
2023-06-07 04:04
Save
Rename
;ELC ;;; Compiled by mockbuild@buildfarm06.corp.cloudlinux.com on Wed Jun 7 08:04:55 2023 ;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/rx.el ;;; in Emacs version 24.3.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")) (#$ . 553)) #@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)) (#$ . 3423)) #@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) (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)) (#$ . 4039)) #@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 (#$ . 5176)) #@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=\203 \306\202 \307=\203 \310\311\203U 9\203U \n\236A \203. ;\2020 :\203 \211\n\236\n>A\236A\211 \203Q \203J \f;\202L \f:\204Q \f)\202 )\207" [op old-op rx-constituents head new-op 32 \? 63 \?\? nil] 4 (#$ . 5344)]) #@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 \n W\2031 \306\314@ #\210\f\203B \n\fV\203B \306\315@\f#\210 ??\205q A\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 (#$ . 5915)]) #@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 (#$ . 6479)]) #@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 (#$ . 6927)]) #@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 (#$ . 7199)]) #@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 (#$ . 7528)]) #@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 (#$ . 7722)]) #@53 Condense by side effect ARGS as range for Rx `any'. (defalias 'rx-any-condense-range #[(args) "\306\211\307\310\n\"\210\311\312\"\211\306 \fA\211\203I \f\211 @A) \211 @@)SY\203C \f@\f\211 @A) \211 @A)]\241\210\f A\241\210\202 \211\202 *\313\314\315\316\"\"\317 !\244*\207" [l str args d tail x 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 (#$ . 8088)]) #@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\f SH\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 (#$ . 8625)]) #@29 Check arg ARG for Rx `any'. (defalias 'rx-check-any #[(arg) "\250\203 C\2079\203) \302\303\304\217\211\203 \305\306 \"\204\" \307\310\"\210 \311\312O)C\207\242\250\2038 \243\250\2038 C\207;\203A \313!\207\307\314!\207" [arg translation nil (rx-form arg) ((error)) 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 (#$ . 9056)]) #@78 Parse and produce code from FORM, which is `(any ARG ...)'. ARG is optional. (defalias 'rx-any #[(form) "\306!\210\307\310\311\312\313A\"\"!\314\211\315 >\2037 \315\316\315 \"B\317 >\204, \317 \236\203\343 \320\317 \"\317C\244\202\343 \315 \236\211\203k \n\316\n \"B\317 >\203W \316\317 \"\317C\244\202\343 \317 \236\211\203\343 \n\316\n \"B\241\210\202\343 \321\315 \"\211\203\222 \315\320\315 \"B\317 >\204\207 \317 \236\203\343 \320\317 \"\317C\244\202\343 \317 >\203\242 \317\316\317 \"B\202\343 \317 \236\211\203\264 \n\316\n \"B\202\343 @\322=\204\303 @\242\322=\203\343 A\203\333 \211 A@) @ \211 AA)BB\202\342 \320\322 \"\322C\244 A\204 @\247\203 \323\324 @!!\211G\325U\204 @\322\232\203 \326=\204 \202\327\330\331 \314#\332Q+\207" [form args m s x 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 (#$ . 9535)]) #@29 Check arg ARG for Rx `not'. (defalias 'rx-check-not #[(arg) "9\203 \301\302\303\304\305\217\"\204& \306=\204& :\203! @\307>\204& \310\311\"\210\312\207" [arg string-match "\\`\\[\\[:[-a-z]+:\\]\\]\\'" nil (rx-form arg) ((error "")) word-boundary (not any in syntax category) error "rx `not' syntax error: %s" t] 5 (#$ . 10658)]) #@57 Parse and produce code from FORM. FORM is `(not ...)'. (defalias 'rx-not #[(form) "\305!\210\306\211A@)\307\"\310\311\312 \"\203@ \313\232\203! \314\202} G\315U\2037 \f\307=\2047 \316 \317\320O!\202} \321 \317\310OP\202} \322H\323=\203Q \324 \325\310OP\202} \311\326 \"\203e \322\317O\226 \317\310OP\202} \311\327 \"\203y \322\317O\227 \317\310OP\202} \324 \330Q*\207" [form x case-fold-search result rx-parent rx-check rx-form ! nil string-match "\\`\\[^" "[^]" "[^^]" 4 regexp-quote 2 3 "[" 0 91 "[^" 1 "\\`\\\\[scbw]" "\\`\\\\[SCBW]" "]"] 5 (#$ . 10999)]) #@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 (#$ . 11575)]) #@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 (#$ . 11755)]) #@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 (#$ . 11947)]) #@47 Parse and produce code from FORM `(= N ...)'. (defalias 'rx-= #[(form) "\301!\210\302\303\"\211A@\250\203 A@\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 (#$ . 12391)]) #@48 Parse and produce code from FORM `(>= N ...)'. (defalias 'rx->= #[(form) "\301!\210\302\303\"\211A@\250\203 A@\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 (#$ . 12703)]) #@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 (#$ . 13019)]) #@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\203H A@\250\2037 A@\306V\204; \307\310!\210\311\312\313\3048\314\"A@#\207\3048\250\203p \3048\306W\204p A@\250\203p A@\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 (#$ . 13211)]) #@62 Parse and produce code from FORM, which is `(submatch ...)'. (defalias 'rx-submatch #[(form) "\302G\303U\203 \304\211A@)!\202 \305\306A\307#\310Q\207" [form x "\\(" 2 rx-form mapconcat #[(re) "\301\302\"\207" [re rx-form :] 3] nil "\\)"] 6 (#$ . 13806)]) #@66 Parse and produce code from FORM, which is `(submatch-n N ...)'. (defalias 'rx-submatch-n #[(form) "A@\303\304 !\305G\306U\203 \307\3108!\202\" \311\312\211AA)\313#\314\260)\207" [form n x "\\(?" number-to-string ":" 3 rx-form 2 mapconcat #[(re) "\301\302\"\207" [re rx-form :] 3] nil "\\)"] 8 (#$ . 14074)]) #@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 (#$ . 14398)]) #@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 (#$ . 14570)]) #@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) "\306!\210\307!\211@\310>\203 \311\202' @\312>\203 \313\202' \203& \311\202' \313@\314>\2032 \315\202> @\316>\203= \317\202> \313\320\321\211 A@)\322\"\n Q \323>\205T \"*\207" [form rx-greedy-flag op suffix x rx-parent rx-check rx-trans-forms (* + 32) "" (*\? +\? 63) "?" (* *\? 0+ zero-or-more) "*" (+ +\? 1+ one-or-more) "+" rx-group-if rx-form * (t *)] 5 (#$ . 14777)]) #@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 (#$ . 15525)]) #@63 Parse and produce code from FORM, which is `(syntax SYMBOL)'. (defalias 'rx-syntax #[(form) "\306!\210\211A@)\211 \236A\211 \204= \307\n!\203 \n\2024 \n9\2034 \310\n!\211 G\311U\2033 \312H)\f\204= \313\314\n\"\210\315\316\f\"*\207" [form x sym rx-syntax syntax name rx-check characterp symbol-name 1 0 error "Unknown rx syntax `%s'" format "\\s%c"] 4 (#$ . 16876)]) #@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 (#$ . 17256)]) #@65 Parse and produce code from FORM, which is `(category SYMBOL)'. (defalias 'rx-category #[(form) "\304!\210\211A@)\250\203 \211A@)\202 \211A@)\n\236A\305\306 \")\207" [form x rx-categories char rx-check format "\\c%c"] 4 (#$ . 17468)]) #@59 Parse and produce code from FORM, which is `(eval FORM)'. (defalias 'rx-eval #[(form) "\303!\210\304\305\211A@)!\n\"\207" [form x rx-parent rx-check rx-form eval] 4 (#$ . 17719)]) #@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) "\304!\210@\305=\306\211A@) \")\207" [form rx-greedy-flag x rx-parent rx-check maximal-match rx-form] 4 (#$ . 17909)]) #@63 Parse and produce code from FORM, which is `(regexp STRING)'. (defalias 'rx-regexp #[(form) "\303!\210\304\211A@)\n\"\207" [form x rx-parent rx-check rx-group-if] 4 (#$ . 18281)]) #@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 (#$ . 18471)]) #@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 (#$ . 19136)]) #@8448 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 space and tab only. `graphic', `graph' matches graphic characters--everything except ASCII control chars, space, and DEL. `printing', `print' matches printing characters--everything except ASCII control chars and DEL. `alphanumeric', `alnum' matches letters and digits. (But at present, for multibyte characters, it matches anything that has word syntax.) `letter', `alphabetic', `alpha' matches letters. (But at present, for multibyte characters, it matches anything that has word syntax.) `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) `chinse-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 (#$ . 19428)])) (provide 'rx)