| commit | author | age | ||
| 5cb5f7 | 1 | ;ELC |
| C | 2 | ;;; Compiled |
| 3 | ;;; in Emacs version 26.1 | |
| 4 | ;;; with all optimizations. | |
| 5 | ||
| 6 | ;;; This file contains utf-8 non-ASCII characters, | |
| 7 | ;;; and so cannot be loaded into Emacs 22 or earlier. | |
| 8 | (and (boundp 'emacs-version) | |
| 9 | (< (aref emacs-version (1- (length emacs-version))) ?A) | |
| 10 | (string-lessp emacs-version "23") | |
| 11 | (error "`%s' was compiled for Emacs 23 or later" #$)) | |
| 12 | ||
| 13 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 14 | ||
| 15 | ||
| 16 | (autoload 'slot-value "eieio") | |
| 17 | #@42 Remove whitespace at the beginning of S. | |
| 18 | (defalias 's-trim-left #[(s) "\302 \303\216\304\305 \"\203 \306\307\310\211 $\202 *\207" [save-match-data-internal s match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] string-match "\\`[ \n ]+" replace-match "" t] 5 (#$ . 439)]) | |
| 19 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-trim-left pure t side-effect-free] 5) | |
| 20 | #@36 Remove whitespace at the end of S. | |
| 21 | (defalias 's-trim-right #[(s) "\302 \303\216\304\305 \"\203 \306\307\310\211 $\202 *\207" [save-match-data-internal s match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] string-match "[ \n ]+\\'" replace-match "" t] 5 (#$ . 869)]) | |
| 22 | #@50 Remove whitespace at the beginning and end of S. | |
| 23 | (defalias 's-trim #[(s) "\301\302!!\207" [s s-trim-left s-trim-right] 3 (#$ . 1184)]) | |
| 24 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-trim pure t side-effect-free] 5) | |
| 25 | #@63 Convert all adjacent whitespace characters to a single space. | |
| 26 | (defalias 's-collapse-whitespace #[(s) "\301\302\303#\207" [s replace-regexp-in-string "[ \n ]+" " "] 4 (#$ . 1431)]) | |
| 27 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-collapse-whitespace pure t side-effect-free] 5) | |
| 28 | #@190 Split S into substrings bounded by matches for regexp SEPARATOR. | |
| 29 | If OMIT-NULLS is non-nil, zero-length substrings are omitted. | |
| 30 | ||
| 31 | This is a simple wrapper around the built-in `split-string'. | |
| 32 | (defalias 's-split #[(separator s &optional omit-nulls) "\304 \305\216\306 \n #*\207" [save-match-data-internal s separator omit-nulls match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] split-string] 4 (#$ . 1740)]) | |
| 33 | (byte-code "\300\301\302\303#\300\207" [function-put s-split side-effect-free t] 4) | |
| 34 | #@164 Split S up to N times into substrings bounded by matches for regexp SEPARATOR. | |
| 35 | ||
| 36 | If OMIT-NULLS is non-nil, zero-length substrings are omitted. | |
| 37 | ||
| 38 | See also `s-split'. | |
| 39 | (defalias 's-split-up-to #[(separator s n &optional omit-nulls) "\306 \307\216\310\311\312\313!r q\210\314\216\fc\210eb\315 \311\316#\203L \310W\203L \n\310\224{ \203: \317\232\204? B)\310\225bS\202 \nd{ \203] \317\232\204b B, \237,\207" [save-match-data-internal r op #1=#:temp-buffer s separator match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] 0 nil generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#1# buffer-name kill-buffer] 2] re-search-forward t "" n sub omit-nulls] 4 (#$ . 2276)]) | |
| 40 | (byte-code "\300\301\302\303#\300\207" [function-put s-split-up-to side-effect-free t] 4) | |
| 41 | #@56 Splits S into a list of strings on newline characters. | |
| 42 | (defalias 's-lines #[(s) "\301\302\"\207" [s s-split "\\( \n\\|[\n ]\\)"] 3 (#$ . 3111)]) | |
| 43 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-lines pure t side-effect-free] 5) | |
| 44 | #@60 Join all the strings in STRINGS with SEPARATOR in between. | |
| 45 | (defalias 's-join #[(separator strings) "\302\303 #\207" [strings separator mapconcat identity] 4 (#$ . 3369)]) | |
| 46 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-join pure t side-effect-free] 5) | |
| 47 | #@48 Join all the string arguments into one string. | |
| 48 | (defalias 's-concat #[(&rest strings) "\301\302\"\207" [strings apply concat] 3 (#$ . 3652)]) | |
| 49 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-concat pure t side-effect-free] 5) | |
| 50 | #@27 Concatenate PREFIX and S. | |
| 51 | (defalias 's-prepend #[(prefix s) " P\207" [prefix s] 2 (#$ . 3907)]) | |
| 52 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-prepend pure t side-effect-free] 5) | |
| 53 | #@27 Concatenate S and SUFFIX. | |
| 54 | (defalias 's-append #[(suffix s) " P\207" [s suffix] 2 (#$ . 4118)]) | |
| 55 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-append pure t side-effect-free] 5) | |
| 56 | #@40 Make a string of S repeated NUM times. | |
| 57 | (defalias 's-repeat #[(num s) "\303 \304V\203 \nB S\211\202 \305\306\")\207" [ss num s nil 0 apply concat] 4 (#$ . 4327)]) | |
| 58 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-repeat pure t side-effect-free] 5) | |
| 59 | #@37 Remove SUFFIX if it is at end of S. | |
| 60 | (defalias 's-chop-suffix #[(suffix s) "G[\nGGY\203 \n \303O\230\203 \n\304 O\202 \n)\207" [suffix pos s nil 0] 4 (#$ . 4609)]) | |
| 61 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-chop-suffix pure t side-effect-free] 5) | |
| 62 | #@67 Remove SUFFIXES one by one in order, if they are at the end of S. | |
| 63 | (defalias 's-chop-suffixes #[(suffixes s) "\203 \302@ \"A\211\204 \207" [suffixes s s-chop-suffix] 4 (#$ . 4897)]) | |
| 64 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-chop-suffixes pure t side-effect-free] 5) | |
| 65 | #@43 Remove PREFIX if it is at the start of S. | |
| 66 | (defalias 's-chop-prefix #[(prefix s) "G\nGGY\203 \n\303 O\230\203 \n \304O\202 \n)\207" [prefix pos s 0 nil] 4 (#$ . 5206)]) | |
| 67 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-chop-prefix pure t side-effect-free] 5) | |
| 68 | #@69 Remove PREFIXES one by one in order, if they are at the start of S. | |
| 69 | (defalias 's-chop-prefixes #[(prefixes s) "\203 \302@ \"A\211\204 \207" [prefixes s s-chop-prefix] 4 (#$ . 5499)]) | |
| 70 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-chop-prefixes pure t side-effect-free] 5) | |
| 71 | #@54 Returns the longest prefix S1 and S2 have in common. | |
| 72 | (defalias 's-shared-start #[(s1 s2) "G G^\304\n W\203 \nH \nHU\203 \nT\211\202 \304\nO*\207" [s1 s2 i search-length 0] 4 (#$ . 5810)]) | |
| 73 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-shared-start pure t side-effect-free] 5) | |
| 74 | #@54 Returns the longest suffix S1 and S2 have in common. | |
| 75 | (defalias 's-shared-end #[(s1 s2) "G\nG ^ \306\211 \fW\203+ \307 \310#H\n\307 \310#HU\203+ T\211\202 \306U\2035 \311\202: [\312O,\207" [s1 l1 s2 l2 search-length i 0 - 1 "" nil] 7 (#$ . 6126)]) | |
| 76 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-shared-end pure t side-effect-free] 5) | |
| 77 | #@50 Remove one trailing `\n`, `\r` or `\r\n` from S. | |
| 78 | (defalias 's-chomp #[(s) "\301\302\"\207" [s s-chop-suffixes ("\n" " ")] 3 (#$ . 6503)]) | |
| 79 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-chomp pure t side-effect-free] 5) | |
| 80 | #@192 If S is longer than LEN, cut it down and add ELLIPSIS to the end. | |
| 81 | ||
| 82 | The resulting string, including ellipsis, will be LEN characters | |
| 83 | long. | |
| 84 | ||
| 85 | When not specified, ELLIPSIS defaults to ‘...’. | |
| 86 | (defalias 's-truncate #[(len s &optional ellipsis) "\204 \303 G\nV\203 \304\305 \306\nGZO#\207 \207" [ellipsis s len "..." format "%s%s" 0] 6 (#$ . 6755)]) | |
| 87 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-truncate pure t side-effect-free] 5) | |
| 88 | #@56 If S is longer than LEN, wrap the words with newlines. | |
| 89 | (defalias 's-word-wrap #[(len s) "\305 \306\216\307\310!r q\210\311\216\nc\210 \312ed\"\210)ed{-\207" [save-match-data-internal #1=#:temp-buffer s len fill-column match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#1# buffer-name kill-buffer] 2] fill-region] 3 (#$ . 7223)]) | |
| 90 | (byte-code "\300\301\302\303#\300\207" [function-put s-word-wrap side-effect-free t] 4) | |
| 91 | #@65 If S is shorter than LEN, pad it with spaces so it is centered. | |
| 92 | (defalias 's-center #[(len s) "\303 GZ]\304\305\n\306\"\307\" \304\310\n\306\"\307\"Q)\207" [len s extra 0 make-string ceiling 2 32 floor] 6 (#$ . 7751)]) | |
| 93 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-center pure t side-effect-free] 5) | |
| 94 | #@60 If S is shorter than LEN, pad it with PADDING on the left. | |
| 95 | (defalias 's-pad-left #[(len padding s) "\304 GZ]\305\n\306 !\" P)\207" [len s extra padding 0 make-string string-to-char] 4 (#$ . 8085)]) | |
| 96 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-pad-left pure t side-effect-free] 5) | |
| 97 | #@61 If S is shorter than LEN, pad it with PADDING on the right. | |
| 98 | (defalias 's-pad-right #[(len padding s) "\304 GZ] \305\n\306 !\"P)\207" [len s extra padding 0 make-string string-to-char] 5 (#$ . 8400)]) | |
| 99 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-pad-right pure t side-effect-free] 5) | |
| 100 | #@41 Returns up to the LEN first chars of S. | |
| 101 | (defalias 's-left #[(len s) "G V\203\f \302 O\207\207" [s len 0] 3 (#$ . 8718)]) | |
| 102 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-left pure t side-effect-free] 5) | |
| 103 | #@40 Returns up to the LEN last chars of S. | |
| 104 | (defalias 's-right #[(len s) "G\211\nV\203 \nZ O\202 )\207" [s l len] 4 (#$ . 8953)]) | |
| 105 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-right pure t side-effect-free] 5) | |
| 106 | #@142 Does S end with SUFFIX? | |
| 107 | ||
| 108 | If IGNORE-CASE is non-nil, the comparison is done without paying | |
| 109 | attention to case differences. | |
| 110 | ||
| 111 | Alias: `s-suffix?' | |
| 112 | (defalias 's-ends-with\? #[(suffix s &optional ignore-case) "G GZ\211\304Y\205 \305 \306\211\n\306 &\307=)\207" [s suffix start-pos ignore-case 0 compare-strings nil t] 9 (#$ . 9198)]) | |
| 113 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-ends-with\? pure t side-effect-free] 5) | |
| 114 | #@209 Does S start with PREFIX? | |
| 115 | ||
| 116 | If IGNORE-CASE is non-nil, the comparison is done without paying | |
| 117 | attention to case differences. | |
| 118 | ||
| 119 | Alias: `s-prefix?'. This is a simple wrapper around the built-in | |
| 120 | `string-prefix-p'. | |
| 121 | (defalias 's-starts-with\? #[(prefix s &optional ignore-case) "\303 \n#\207" [prefix s ignore-case string-prefix-p] 4 (#$ . 9648)]) | |
| 122 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-starts-with\? pure t side-effect-free] 5) | |
| 123 | (defalias 's--truthy\? #[(val) "??\207" [val] 1]) | |
| 124 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s--truthy\? pure t side-effect-free] 5) | |
| 125 | #@121 Does S contain NEEDLE? | |
| 126 | ||
| 127 | If IGNORE-CASE is non-nil, the comparison is done without paying | |
| 128 | attention to case differences. | |
| 129 | (defalias 's-contains\? #[(needle s &optional ignore-case) "\305\306\n! \307\310 \311#)\266\203!)\207" [ignore-case case-fold-search needle s inhibit-changing-match-data s--truthy\? regexp-quote nil t string-match] 8 (#$ . 10271)]) | |
| 130 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-contains\? pure t side-effect-free] 5) | |
| 131 | #@82 Is S1 equal to S2? | |
| 132 | ||
| 133 | This is a simple wrapper around the built-in `string-equal'. | |
| 134 | (defalias 's-equals\? #[(s1 s2) " \230\207" [s1 s2] 2 (#$ . 10745)]) | |
| 135 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-equals\? pure t side-effect-free] 5) | |
| 136 | #@83 Is S1 less than S2? | |
| 137 | ||
| 138 | This is a simple wrapper around the built-in `string-lessp'. | |
| 139 | (defalias 's-less\? #[(s1 s2) " \231\207" [s1 s2] 2 (#$ . 11011)]) | |
| 140 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-less\? pure t side-effect-free] 5) | |
| 141 | #@139 Does REGEXP match S? | |
| 142 | If START is non-nil the search starts at that index. | |
| 143 | ||
| 144 | This is a simple wrapper around the built-in `string-match-p'. | |
| 145 | (defalias 's-matches\? #[(regexp s &optional start) "\304 \n\305\306#)\266\203!\207" [regexp s start inhibit-changing-match-data s--truthy\? t string-match] 8 (#$ . 11275)]) | |
| 146 | (byte-code "\300\301\302\303#\300\207" [function-put s-matches\? side-effect-free t] 4) | |
| 147 | #@31 Is S nil or the empty string? | |
| 148 | (defalias 's-blank\? #[(s) "?\206 \301\230\207" [s ""] 2 (#$ . 11686)]) | |
| 149 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-blank\? pure t side-effect-free] 5) | |
| 150 | #@66 Is S nil or the empty string or string only contains whitespace? | |
| 151 | (defalias 's-blank-str\? #[(s) "\301!\206 \301\302!!\207" [s s-blank\? s-trim] 3 (#$ . 11905)]) | |
| 152 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-blank-str\? pure t side-effect-free] 5) | |
| 153 | #@44 Is S anything but nil or the empty string? | |
| 154 | (defalias 's-present\? #[(s) "\301!?\207" [s s-blank\?] 2 (#$ . 12187)]) | |
| 155 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-present\? pure t side-effect-free] 5) | |
| 156 | #@54 Return S if it's `s-present?', otherwise return nil. | |
| 157 | (defalias 's-presence #[(s) "\301!\205 \207" [s s-present\?] 2 (#$ . 12420)]) | |
| 158 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-presence pure t side-effect-free] 5) | |
| 159 | #@41 Are all the letters in S in lower case? | |
| 160 | (defalias 's-lowercase\? #[(s) "\303\304 \303\305\306#)\266\203)?\207" [case-fold-search s inhibit-changing-match-data nil "[[:upper:]]" t string-match] 7 (#$ . 12669)]) | |
| 161 | (byte-code "\300\301\302\303#\300\207" [function-put s-lowercase\? side-effect-free t] 4) | |
| 162 | #@41 Are all the letters in S in upper case? | |
| 163 | (defalias 's-uppercase\? #[(s) "\303\304 \303\305\306#)\266\203)?\207" [case-fold-search s inhibit-changing-match-data nil "[[:lower:]]" t string-match] 7 (#$ . 12980)]) | |
| 164 | (byte-code "\300\301\302\303#\300\207" [function-put s-uppercase\? side-effect-free t] 4) | |
| 165 | #@56 Are there both lower case and upper case letters in S? | |
| 166 | (defalias 's-mixedcase\? #[(s) "\303\304\305 \303\306\307#)\266\203\205 \310 \303\306\307#)\266\203!)\207" [case-fold-search s inhibit-changing-match-data nil s--truthy\? "[[:lower:]]" t string-match "[[:upper:]]"] 8 (#$ . 13291)]) | |
| 167 | #@73 In S, is the first letter upper case, and all other letters lower case? | |
| 168 | (defalias 's-capitalized\? #[(s) "\303\304\305 \303\306\307#)\266\203!)\207" [case-fold-search s inhibit-changing-match-data nil s--truthy\? "^[[:upper:]][^[:upper:]]*$" t string-match] 8 (#$ . 13594)]) | |
| 169 | (byte-code "\300\301\302\303#\300\207" [function-put s-capitalized\? side-effect-free t] 4) | |
| 170 | #@16 Is S a number? | |
| 171 | (defalias 's-numeric\? #[(s) "\302\303\304\305\306#)\266\203!\207" [s inhibit-changing-match-data s--truthy\? "^[0-9]+$" nil t string-match] 8 (#$ . 13972)]) | |
| 172 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-numeric\? pure t side-effect-free] 5) | |
| 173 | #@29 Replaces OLD with NEW in S. | |
| 174 | (defalias 's-replace #[(old new s) "\303\304! \n\305\211%\207" [old new s replace-regexp-in-string regexp-quote t] 6 (#$ . 14266)]) | |
| 175 | (byte-code "\300\301\302\303#\300\301\304\303#\305\306\307\"\207" [function-put s-replace pure t side-effect-free defalias s-replace-regexp replace-regexp-in-string] 5) | |
| 176 | (defalias 's--aget #[(alist key) "\302 \"A\207" [key alist assoc-string] 3]) | |
| 177 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s--aget pure t side-effect-free] 5) | |
| 178 | #@79 REPLACEMENTS is a list of cons-cells. Each `car` is replaced with `cdr` in S. | |
| 179 | (defalias 's-replace-all #[(replacements s) "\302\303\304\305\"!\306 \307\211%\207" [replacements s replace-regexp-in-string regexp-opt mapcar car #[(it) "\302 \"\207" [replacements it s--aget] 3] t] 6 (#$ . 14786)]) | |
| 180 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-replace-all pure t side-effect-free] 5) | |
| 181 | #@84 Convert S to lower case. | |
| 182 | ||
| 183 | This is a simple wrapper around the built-in `downcase'. | |
| 184 | (defalias 's-downcase #[(s) "\227\207" [s] 1 (#$ . 15201)]) | |
| 185 | (byte-code "\300\301\302\303#\300\207" [function-put s-downcase side-effect-free t] 4) | |
| 186 | #@82 Convert S to upper case. | |
| 187 | ||
| 188 | This is a simple wrapper around the built-in `upcase'. | |
| 189 | (defalias 's-upcase #[(s) "\226\207" [s] 1 (#$ . 15438)]) | |
| 190 | (byte-code "\300\301\302\303#\300\207" [function-put s-upcase side-effect-free t] 4) | |
| 191 | #@89 Convert the first word's first character to upper case and the rest to lower case in S. | |
| 192 | (defalias 's-capitalize #[(s) "\301\302O\226\302\303O\227P\207" [s 0 1 nil] 4 (#$ . 15669)]) | |
| 193 | (byte-code "\300\301\302\303#\300\207" [function-put s-capitalize side-effect-free t] 4) | |
| 194 | #@144 Convert each word's first character to upper case and the rest to lower case in S. | |
| 195 | ||
| 196 | This is a simple wrapper around the built-in `capitalize'. | |
| 197 | (defalias 's-titleize #[(s) "\301!\207" [s capitalize] 2 (#$ . 15948)]) | |
| 198 | (byte-code "\300\301\302\303#\300\207" [function-put s-titleize side-effect-free t] 4) | |
| 199 | #@211 Threads S through the forms. Inserts S as the last item | |
| 200 | in the first form, making a list of it if it is not a list | |
| 201 | already. If there are more forms, inserts the first form as the | |
| 202 | last item in second form, etc. | |
| 203 | (defalias 's-with '(macro . #[(s form &rest more) "\204 <\203 @\303 A\nC\"B\207 \nD\207\304\211\n EBB\207" [more form s append s-with] 4 (#$ . 16258)])) | |
| 204 | (byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put s-with edebug-form-spec (form &rest [&or (function &rest form) fboundp]) lisp-indent-function 1] 4) | |
| 205 | #@142 Returns first index of NEEDLE in S, or nil. | |
| 206 | ||
| 207 | If IGNORE-CASE is non-nil, the comparison is done without paying | |
| 208 | attention to case differences. | |
| 209 | (defalias 's-index-of #[(needle s &optional ignore-case) "\305\n! \306\307 \310#)\266\203)\207" [ignore-case case-fold-search needle s inhibit-changing-match-data regexp-quote nil t string-match] 7 (#$ . 16795)]) | |
| 210 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-index-of pure t side-effect-free] 5) | |
| 211 | #@26 Return the reverse of S. | |
| 212 | (defalias 's-reverse #[(s) "\306 \307\216\310 !\203G \311\312\"\262\312\313\314!\210 \203@ \211A\242C \315 @ \"\2037 \211A\242\fB\202$ \f\237\n\244)\202 \n\260*\202Q \311\312\"\262\237\260*\207" [save-match-data-internal s output input grapheme ucs-normalize-combining-chars match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] multibyte-string-p append nil require ucs-normalize memql] 4 (#$ . 17269)]) | |
| 213 | (byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-reverse pure t side-effect-free] 5) | |
| 214 | #@184 Return a list of matches for REGEX in STRING. | |
| 215 | ||
| 216 | Each element itself is a list of matches, as per | |
| 217 | `match-string'. Multiple matches at the same position will be | |
| 218 | ignored after the first. | |
| 219 | (defalias 's-match-strings-all #[(regex string) "\306 \307\216\310\311 GW\203I \312\f #\203I \311\224T\310\306 G\313\245\311 U\204? \314 \"B T\211\202) \237\nB+\202 \n\237,\207" [save-match-data-internal i all-strings string regex match match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] nil 0 string-match 2 match-string num-matches strings] 5 (#$ . 17868)]) | |
| 220 | (byte-code "\300\301\302\303#\300\207" [function-put s-match-strings-all side-effect-free t] 4) | |
| 221 | #@88 Return a list of matched positions for REGEXP in STRING. | |
| 222 | SUBEXP-DEPTH is 0 by default. | |
| 223 | (defalias 's-matched-positions-all #[(regexp string &optional subexp-depth) "\204 \306\307 \310\216\306\311\312\f #\2031 GW\2031 \225 \224\225B\nB\306\225)\202 \n\237,\207" [subexp-depth save-match-data-internal result pos regexp string 0 match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] nil string-match m] 4 (#$ . 18575)]) | |
| 224 | (byte-code "\300\301\302\303#\300\207" [function-put s-matched-positions-all side-effect-free t] 4) | |
| 225 | #@274 When the given expression matches the string, this function returns a list | |
| 226 | of the whole matching string and a string for each matched subexpressions. | |
| 227 | If it did not match the returned value is an empty list (nil). | |
| 228 | ||
| 229 | When START is non-nil the search will start at that index. | |
| 230 | (defalias 's-match #[(regexp s &optional start) "\306 \307\216\310 \n #\205@ \306 \311 \203= @ \n A@ \n\205/ \205/ \n\n O\211 \f\fB AA+\202 \f\237**\207" [save-match-data-internal regexp s start result match-data-list match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] string-match nil beg end subs] 5 (#$ . 19151)]) | |
| 231 | (byte-code "\300\301\302\303#\300\207" [function-put s-match side-effect-free t] 4) | |
| 232 | #@45 Slices S up at every index matching REGEXP. | |
| 233 | (defalias 's-slice-at #[(regexp s) "G\304U\203\n \305C\207\306 \307\216\310\311 \312#\211\203* \304\nO\313 \n\310O\"B\202, C+\207" [s save-match-data-internal i regexp 0 "" match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] nil string-match 1 s-slice-at] 7 (#$ . 19883)]) | |
| 234 | (byte-code "\300\301\302\303#\300\207" [function-put s-slice-at side-effect-free t] 4) | |
| 235 | #@29 Split S into list of words. | |
| 236 | (defalias 's-split-words #[(s) "\302\303\304\305\306\307\305\310\307 ##)\311#\207" [case-fold-search s s-split "[^[:word:]0-9]+" nil replace-regexp-in-string "\\([[:lower:]]\\)\\([[:upper:]]\\)" "\\1 \\2" "\\([[:upper:]]\\)\\([[:upper:]][0-9[:lower:]]\\)" t] 9 (#$ . 20339)]) | |
| 237 | (byte-code "\300\301\302\303#\300\207" [function-put s-split-words side-effect-free t] 4) | |
| 238 | #@69 Like MAPCAR, but applies a different function to the first element. | |
| 239 | (defalias 's--mapcar-head #[(fn-head fn-rest list) "\205 @!\303\nA\"B\207" [list fn-head fn-rest mapcar] 4 (#$ . 20740)]) | |
| 240 | #@30 Convert S to lowerCamelCase. | |
| 241 | (defalias 's-lower-camel-case #[(s) "\301\302\303\304\305\306!#\"\207" [s s-join "" s--mapcar-head downcase capitalize s-split-words] 7 (#$ . 20941)]) | |
| 242 | (byte-code "\300\301\302\303#\300\207" [function-put s-lower-camel-case side-effect-free t] 4) | |
| 243 | #@30 Convert S to UpperCamelCase. | |
| 244 | (defalias 's-upper-camel-case #[(s) "\301\302\303\304\305!\"\"\207" [s s-join "" mapcar capitalize s-split-words] 6 (#$ . 21223)]) | |
| 245 | (byte-code "\300\301\302\303#\300\207" [function-put s-upper-camel-case side-effect-free t] 4) | |
| 246 | #@26 Convert S to snake_case. | |
| 247 | (defalias 's-snake-case #[(s) "\301\302\303\304\305!\"\"\207" [s s-join "_" mapcar downcase s-split-words] 6 (#$ . 21485)]) | |
| 248 | (byte-code "\300\301\302\303#\300\207" [function-put s-snake-case side-effect-free t] 4) | |
| 249 | #@28 Convert S to dashed-words. | |
| 250 | (defalias 's-dashed-words #[(s) "\301\302\303\304\305!\"\"\207" [s s-join "-" mapcar downcase s-split-words] 6 (#$ . 21730)]) | |
| 251 | (byte-code "\300\301\302\303#\300\207" [function-put s-dashed-words side-effect-free t] 4) | |
| 252 | #@33 Convert S to Capitalized words. | |
| 253 | (defalias 's-capitalized-words #[(s) "\302!\303\304\305 @!\306\307 A\"B\")\207" [s words s-split-words s-join " " capitalize mapcar downcase] 6 (#$ . 21981)]) | |
| 254 | (byte-code "\300\301\302\303#\300\207" [function-put s-capitalized-words side-effect-free t] 4) | |
| 255 | #@31 Convert S to Titleized Words. | |
| 256 | (defalias 's-titleized-words #[(s) "\301\302\303\304\305!\"\"\207" [s s-join " " mapcar s-titleize s-split-words] 6 (#$ . 22276)]) | |
| 257 | (byte-code "\300\301\302\303#\300\207" [function-put s-titleized-words side-effect-free t] 4) | |
| 258 | #@28 Convert S to its initials. | |
| 259 | (defalias 's-word-initials #[(s) "\301\302\303\304\305!\"\"\207" [s s-join "" mapcar #[(ss) "\301\302O\207" [ss 0 1] 3] s-split-words] 6 (#$ . 22538)]) | |
| 260 | (byte-code "\300\301\302\303#\304\305\306\307#\210\304\305\310\311#\207" [function-put s-word-initials side-effect-free t put s-format-resolve error-conditions (error s-format s-format-resolve) error-message "Cannot resolve a template to values"] 5) | |
| 261 | #@458 Format TEMPLATE with the function REPLACER. | |
| 262 | ||
| 263 | REPLACER takes an argument of the format variable and optionally | |
| 264 | an extra argument which is the EXTRA value from the call to | |
| 265 | `s-format'. | |
| 266 | ||
| 267 | Several standard `s-format' helper functions are recognized and | |
| 268 | adapted for this: | |
| 269 | ||
| 270 | (s-format "${name}" 'gethash hash-table) | |
| 271 | (s-format "${name}" 'aget alist) | |
| 272 | (s-format "$0" 'elt sequence) | |
| 273 | ||
| 274 | The REPLACER function may be used to do any other kind of | |
| 275 | transformation. | |
| 276 | (defalias 's-format #[(template replacer &optional extra) "\302 \303\216\304\305\306 \307\211%*\207" [saved-match-data template match-data #[nil "\301!\207" [saved-match-data set-match-data] 2] replace-regexp-in-string "\\$\\({\\([^}]+\\)}\\|[0-9]+\\)" #[(md) "\306\307\"\211\203 \202 \310\306\311\"!)\312 \313\216\f\314\267\202> \f \"\202Q \315 \"\202Q \f \"\202Q \316 \317 !\"\202Q \320!\210 \203N \f \"\202Q \f !\211 \203_ \321\322\"\202c \323\324\",\207" [md m replacer-match-data var replacer extra match-string 2 string-to-number 1 match-data #[nil "\301!\207" [replacer-match-data set-match-data] 2] #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (gethash 32 aget 39 elt 46 oref 53)) s--aget slot-value intern set-match-data format "%s" signal s-format-resolve saved-match-data v] 5] t] 6 (#$ . 22976)]) | |
| 277 | #@92 If `t' interpolate lisp values as lisp. | |
| 278 | ||
| 279 | `s-lex-format' inserts values with (format "%S"). | |
| 280 | (defvar s-lex-value-as-lisp nil (#$ . 24309)) | |
| 281 | #@23 Expand FMT into lisp. | |
| 282 | (defalias 's-lex-fmt|expand #[(fmt) "\301\302\303\304\305\306\307\310\"\"\"F\207" [fmt s-format 'aget append (list) mapcar #[(matches) "\301A@\302\303\304A@!EE\207" [matches cons format (if s-lex-value-as-lisp "%S" "%s") intern] 6] s-match-strings-all "${\\([^}]+\\)}"] 10 (#$ . 24452)]) | |
| 283 | (byte-code "\300\301\302\303#\300\207" [function-put s-lex-fmt|expand side-effect-free t] 4) | |
| 284 | #@316 `s-format` with the current environment. | |
| 285 | ||
| 286 | FORMAT-STR may use the `s-format' variable reference to refer to | |
| 287 | any variable: | |
| 288 | ||
| 289 | (let ((x 1)) | |
| 290 | (s-lex-format "x is: ${x}")) | |
| 291 | ||
| 292 | The values of the variables are interpolated with "%s" unless | |
| 293 | the variable `s-lex-value-as-lisp' is `t' and then they are | |
| 294 | interpolated with "%S". | |
| 295 | (defalias 's-lex-format '(macro . #[(format-str) "\301!\207" [format-str s-lex-fmt|expand] 2 (#$ . 24866)])) | |
| 296 | (put 's-lex-format 'edebug-form-spec '(form)) | |
| 297 | #@417 Count occurrences of `regexp' in `s'. | |
| 298 | ||
| 299 | `start', inclusive, and `end', exclusive, delimit the part of `s' to | |
| 300 | match. `start' and `end' are both indexed starting at 1; the initial | |
| 301 | character in `s' is index 1. | |
| 302 | ||
| 303 | This function starts looking for the next match from the end of the | |
| 304 | previous match. Hence, it ignores matches that overlap a previously | |
| 305 | found match. To count overlapping matches, use | |
| 306 | `s-count-matches-all'. | |
| 307 | (defalias 's-count-matches #[(regexp s &optional start end) "\306 \307\216\310\311!r q\210\312\216\nc\210eb\210\313 \f\206 \314 \206! d#-\207" [save-match-data-internal #1=#:temp-buffer s regexp start end match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#1# buffer-name kill-buffer] 2] count-matches 1] 4 (#$ . 25344)]) | |
| 308 | (byte-code "\300\301\302\303#\300\207" [function-put s-count-matches side-effect-free t] 4) | |
| 309 | #@452 Count occurrences of `regexp' in `s'. | |
| 310 | ||
| 311 | `start', inclusive, and `end', exclusive, delimit the part of `s' to | |
| 312 | match. `start' and `end' are both indexed starting at 1; the initial | |
| 313 | character in `s' is index 1. | |
| 314 | ||
| 315 | This function starts looking for the next match from the second | |
| 316 | character of the previous match. Hence, it counts matches that | |
| 317 | overlap a previously found match. To ignore matches that overlap a | |
| 318 | previously found match, use `s-count-matches'. | |
| 319 | (defalias 's-count-matches-all #[(regexp s &optional start end) "\306\307\"\310\211\f \205 S \205 SO \311 \312\216 GW\203> \313 \314O\"\2037 \nT T\211\202\" *\n,\207" [regexp anchored-regexp match-count i s start format "^%s" 0 match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] s-matches\? nil end narrowed-s save-match-data-internal] 6 (#$ . 26285)]) | |
| 320 | (byte-code "\300\301\302\303#\300\207" [function-put s-count-matches-all side-effect-free t] 4) | |
| 321 | #@181 Wrap string S with PREFIX and optionally SUFFIX. | |
| 322 | ||
| 323 | Return string S with PREFIX prepended. If SUFFIX is present, it | |
| 324 | is appended, otherwise PREFIX is used as both prefix and | |
| 325 | suffix. | |
| 326 | (defalias 's-wrap #[(s prefix &optional suffix) " \n\206 Q\207" [prefix s suffix] 3 (#$ . 27251)]) | |
| 327 | (byte-code "\300\301\302\303#\300\301\304\303#\305\306\307\"\210\305\310\311\"\210\305\312\313\"\210\305\314\315\"\210\305\316\317\"\210\305\320\321\"\210\305\322\323\"\210\305\324\325\"\210\305\326\327\"\210\305\330\331\"\210\305\332\333\"\210\305\334\335\"\210\305\336\335\"\210\305\337\340\"\210\305\341\335\"\210\305\342\317\"\210\305\343\317\"\210\305\344\345\"\210\346\347!\207" [function-put s-wrap pure t side-effect-free defalias s-blank-p s-blank\? s-blank-str-p s-blank-str\? s-capitalized-p s-capitalized\? s-contains-p s-contains\? s-ends-with-p s-ends-with\? s-equals-p s-equals\? s-less-p s-less\? s-lowercase-p s-lowercase\? s-matches-p s-matches\? s-mixedcase-p s-mixedcase\? s-numeric-p s-numeric\? s-prefix-p s-starts-with\? s-prefix\? s-present-p s-present\? s-starts-with-p s-suffix-p s-suffix\? s-uppercase-p s-uppercase\? provide s] 5) | |
