(tab-stop . nil))
(make-assignment
- (regexp . "^\\s-*\\w+\\(\\s-*\\):?=\\(\\s-*\\)\\([^\t\n \\\\]\\|$\\)")
+ (regexp . "^\\s-*\\w+\\(\\s-*\\):?=\\(\\s-*\\)\\([^\t\n \\]\\|$\\)")
(group . (1 2))
(modes . '(makefile-mode))
(tab-stop . nil))
(lambda (end reverse)
(funcall (if reverse 're-search-backward
're-search-forward)
- (concat "[^ \t\n\\\\]"
+ (concat "[^ \t\n\\]"
(regexp-quote comment-start)
"\\(.+\\)$") end t))))
(modes . align-open-comment-modes))
(defun auth-source-pass--parse-secret (contents)
"Parse the password-store data in the string CONTENTS and return its secret.
The secret is the first line of CONTENTS."
- (car (split-string contents "\\\n" t)))
+ (car (split-string contents "\n" t)))
(defun auth-source-pass--parse-data (contents)
"Parse the password-store data in the string CONTENTS and return an alist.
CONTENTS is the contents of a password-store formatted file."
- (let ((lines (split-string contents "\\\n" t "\\\s")))
+ (let ((lines (split-string contents "\n" t "\\\s")))
(seq-remove #'null
(mapcar (lambda (line)
(let ((pair (mapcar (lambda (s) (string-trim s))
(interactive)
(forward-line 1)
(beginning-of-line)
- (skip-chars-forward " *-><[]" (point-at-eol)))
+ (skip-chars-forward "- *><[]" (point-at-eol)))
(defun data-debug-prev ()
"Go to the previous line in the Ddebug buffer."
(interactive)
(forward-line -1)
(beginning-of-line)
- (skip-chars-forward " *-><[]" (point-at-eol)))
+ (skip-chars-forward "- *><[]" (point-at-eol)))
(defun data-debug-next-expando ()
"Go to the next line in the Ddebug buffer.
(data-debug-current-line-expanded-p))
(data-debug-contract-current-line)
(data-debug-expand-current-line))
- (skip-chars-forward " *-><[]" (point-at-eol)))
+ (skip-chars-forward "- *><[]" (point-at-eol)))
(defun data-debug-expand-or-contract-mouse (event)
"Expand or contract anything at event EVENT."
(defun comint-within-quotes (beg end)
"Return t if the number of quotes between BEG and END is odd.
Quotes are single and double."
- (let ((countsq (comint-how-many-region "\\(^\\|[^\\\\]\\)'" beg end))
- (countdq (comint-how-many-region "\\(^\\|[^\\\\]\\)\"" beg end)))
+ (let ((countsq (comint-how-many-region "\\(^\\|[^\\]\\)'" beg end))
+ (countdq (comint-how-many-region "\\(^\\|[^\\]\\)\"" beg end)))
(or (= (mod countsq 2) 1) (= (mod countdq 2) 1))))
(defun comint-how-many-region (regexp beg end)
(line-end-position))))))))
;; Continuation of above. Make sure our sentence is capitalized.
(save-excursion
- (skip-chars-forward "\"\\*")
+ (skip-chars-forward "\"*")
(if (looking-at "[a-z]")
(if (checkdoc-autofix-ask-replace
(match-beginning 0) (match-end 0)
(let (save-pos dist compl-list string-to-complete completion-result)
(save-excursion
- (setq dist (skip-chars-backward "[a-zA-Z!=>&~]")
+ (setq dist (skip-chars-backward "a-zA-Z!=>&~")
save-pos (point)))
(if (or (= dist 0)
(let ((cdepth (min (length (apply 'concat
(split-string
(match-string-no-properties 0)
- "[ \t [:alnum:]]+")))
+ "[\t [:alnum:]]+")))
gnus-message-max-citation-depth))
(mlist (make-list (* (1+ gnus-message-max-citation-depth) 2) nil))
(start (point-at-bol))
(defun nnir-imap-end-of-input ()
"Are we at the end of input?"
- (skip-chars-forward "[[:blank:]]")
+ (skip-chars-forward "[:blank:]")
(looking-at "$"))
;; multipart names.
;; #### should . be in here?
(defconst mail-extr-all-letters
- (purecopy (concat mail-extr-all-letters-but-separators "---")))
+ (purecopy (concat mail-extr-all-letters-but-separators "-")))
;; Any character that can start a name.
;; Keep this set as minimal as possible.
(defconst mail-extr-leading-garbage "\\W+")
-;; (defconst mail-extr-non-name-chars
-;; (purecopy (concat "^" mail-extr-all-letters ".")))
;; (defconst mail-extr-non-begin-name-chars
;; (purecopy (concat "^" mail-extr-first-letters)))
;; (defconst mail-extr-non-end-name-chars
;; (purecopy (concat "^" mail-extr-last-letters)))
-;; Matches an initial not followed by both a period and a space.
-;; (defconst mail-extr-bad-initials-pattern
-;; (purecopy
-;; (format "\\(\\([^%s]\\|\\`\\)[%s]\\)\\(\\.\\([^ ]\\)\\| \\|\\([^%s .]\\)\\|\\'\\)"
-;; mail-extr-all-letters mail-extr-first-letters mail-extr-all-letters)))
-
;; Matches periods used instead of spaces. Must not match the period
;; following an initial.
(defconst mail-extr-bad-dot-pattern
(if (and (not (file-name-quoted-p filename))
(file-name-absolute-p filename)
(string-match-p (if (memq system-type '(windows-nt ms-dos))
- "[/\\\\]~" "/~")
+ "[/\\]~" "/~")
(file-local-name filename)))
(file-name-quote filename)
(minibuffer--double-dollars filename)))
(and rng-collecting-text (rng-flush-text))
(let ((target-names (rng-match-possible-start-tag-names)))
`(,(1+ lt-pos)
- ,(save-excursion (skip-chars-forward "[[:alnum:]_.-:]") (point))
+ ,(save-excursion (skip-chars-forward "-[:alnum:]_.:") (point))
,(apply-partially #'rng-complete-qname-function
target-names nil extra-strings)
:exit-function
(cdar rng-open-elements))
(cdar rng-open-elements))))
`(,(+ (match-beginning 0) 2)
- ,(save-excursion (skip-chars-forward "[[:alnum:]_.-:]") (point))
+ ,(save-excursion (skip-chars-forward "-[:alnum:]_.:") (point))
,(list start-tag-name) ;Sole completion candidate.
:exit-function
,(lambda (_completion status)
"xmlns"))
rng-undeclared-prefixes)))
`(,attribute-start
- ,(save-excursion (skip-chars-forward "[[:alnum:]_.-:]") (point))
+ ,(save-excursion (skip-chars-forward "-[:alnum:]_.:") (point))
,(apply-partially #'rng-complete-qname-function
target-names t extra-strings)
:exit-function
(while (and (not (eolp)) cont)
;;(re-search-forward "[^/]*/")
(re-search-forward "[^/]*\\(/\\|\n\\)")
- (if (not (vip-looking-back "[^\\\\]\\(\\\\\\\\\\)*\\\\/"))
+ (if (not (vip-looking-back "[^\\]\\(\\\\\\\\\\)*\\\\/"))
(setq cont nil))))
(backward-char 1)
(setq ex-token (buffer-substring (point) (mark)))
(while (and (not (eolp)) cont)
;;(re-search-forward "[^\\?]*\\?")
(re-search-forward "[^\\?]*\\(\\?\\|\n\\)")
- (if (not (vip-looking-back "[^\\\\]\\(\\\\\\\\\\)*\\\\\\?"))
+ (if (not (vip-looking-back "[^\\]\\(\\\\\\\\\\)*\\\\\\?"))
(setq cont nil))
(backward-char 1)
(if (not (looking-at "\n")) (forward-char 1))))
(while (and (not (eolp)) cont)
(re-search-forward "[^/]*\\(/\\|\n\\)")
;;(re-search-forward "[^/]*/")
- (if (not (vip-looking-back "[^\\\\]\\(\\\\\\\\\\)*\\\\/"))
+ (if (not (vip-looking-back "[^\\]\\(\\\\\\\\\\)*\\\\/"))
(setq cont nil))))
(setq ex-token
(if (= (mark) (point)) ""
(not (equal (char-after (point-at-bol)) ?*))
(save-excursion
(move-beginning-of-line 1)
- (skip-chars-backward "[ \t\n]")
+ (skip-chars-backward " \t\n")
;; org-drawer-regexp matches a whole line but while
;; looking-back, we just ignore trailing whitespaces
(or (looking-back (substring org-drawer-regexp 0 -1)
(unless (equal tags "")
(let* ((level (save-excursion
(beginning-of-line)
- (skip-chars-forward "\\*")))
+ (skip-chars-forward "*")))
(offset (if (bound-and-true-p org-indent-mode)
(* (1- org-indent-indentation-per-level)
(1- level))
(unless inc (setq inc 1))
(let ((pos (point))
(beg (skip-chars-backward "-+^/*0-9eE."))
- (end (skip-chars-forward "-+^/*0-9eE^.")) nap)
+ (end (skip-chars-forward "-+^/*0-9eE.")) nap)
(setq nap (buffer-substring-no-properties
(+ pos beg) (+ pos beg end)))
(delete-region (+ pos beg) (+ pos beg end))
(defun org-fill-line-break-nobreak-p ()
"Non-nil when a new line at point would create an Org line break."
(save-excursion
- (skip-chars-backward "[ \t]")
+ (skip-chars-backward " \t")
(skip-chars-backward "\\\\")
(looking-at "\\\\\\\\\\($\\|[^\\]\\)")))
(push (point) begins)
(while
(progn
- (skip-chars-forward "^ \t\n\\")
+ (skip-chars-forward "^ \t\n")
(when (eq (char-after) ?\\)
(forward-char 1)
(unless (eolp)
(interactive "d")
(goto-char pos)
- (skip-chars-backward "-a-zA-Z0-9_:./\\")
+ (skip-chars-backward "-a-zA-Z0-9_:./\\\\")
(cond
;; special case: looking at a filename:line not at the beginning of a line
;; or a simple line reference "at line ..."
(defsubst cperl-highlight-charclass (endbracket dashface bsface onec-space)
(let ((l '(1 5 7)) ll lle lll
;; 2 groups, the first takes the whole match (include \[trnfabe])
- (singleChar (concat "\\(" "[^\\\\]" "\\|" "\\\\[^cdg-mo-qsu-zA-Z0-9_]" "\\|" "\\\\c." "\\|" "\\\\x" "\\([0-9a-fA-F][0-9a-fA-F]?\\|\\={[0-9a-fA-F]+}\\)" "\\|" "\\\\0?[0-7][0-7]?[0-7]?" "\\|" "\\\\N{[^{}]*}" "\\)")))
+ (singleChar (concat "\\(" "[^\\]" "\\|" "\\\\[^cdg-mo-qsu-zA-Z0-9_]" "\\|" "\\\\c." "\\|" "\\\\x" "\\([0-9a-fA-F][0-9a-fA-F]?\\|\\={[0-9a-fA-F]+}\\)" "\\|" "\\\\0?[0-7][0-7]?[0-7]?" "\\|" "\\\\N{[^{}]*}" "\\)")))
(while ; look for unescaped - between non-classes
(re-search-forward
;; On 19.33, certain simplifications lead
;; to bugs (as in [^a-z] \\| [trnfabe] )
(concat ; 1: SingleChar (include \[trnfabe])
singleChar
- ;;"\\(" "[^\\\\]" "\\|" "\\\\[^cdg-mo-qsu-zA-Z0-9_]" "\\|" "\\\\c." "\\|" "\\\\x" "\\([0-9a-fA-F][0-9a-fA-F]?\\|\\={[0-9a-fA-F]+}\\)" "\\|" "\\\\0?[0-7][0-7]?[0-7]?" "\\|" "\\\\N{[^{}]*}" "\\)"
+ ;;"\\(" "[^\\]" "\\|" "\\\\[^cdg-mo-qsu-zA-Z0-9_]" "\\|" "\\\\c." "\\|" "\\\\x" "\\([0-9a-fA-F][0-9a-fA-F]?\\|\\={[0-9a-fA-F]+}\\)" "\\|" "\\\\0?[0-7][0-7]?[0-7]?" "\\|" "\\\\N{[^{}]*}" "\\)"
"\\(" ; 3: DASH SingleChar (match optionally)
"\\(-\\)" ; 4: DASH
singleChar ; 5: SingleChar
- ;;"\\(" "[^\\\\]" "\\|" "\\\\[^cdg-mo-qsu-zA-Z0-9_]" "\\|" "\\\\c." "\\|" "\\\\x" "\\([0-9a-fA-F][0-9a-fA-F]?\\|\\={[0-9a-fA-F]+}\\)" "\\|" "\\\\0?[0-7][0-7]?[0-7]?" "\\|" "\\\\N{[^{}]*}" "\\)"
+ ;;"\\(" "[^\\]" "\\|" "\\\\[^cdg-mo-qsu-zA-Z0-9_]" "\\|" "\\\\c." "\\|" "\\\\x" "\\([0-9a-fA-F][0-9a-fA-F]?\\|\\={[0-9a-fA-F]+}\\)" "\\|" "\\\\0?[0-7][0-7]?[0-7]?" "\\|" "\\\\N{[^{}]*}" "\\)"
"\\)?"
"\\|"
"\\(" ; 7: other escapes
;; Apparently, I can't put \] into a charclass
;; in m]]: m][\\\]\]] produces [\\]]
;;; POSIX? [:word:] [:^word:] only inside []
-;;; "\\=\\(\\\\.\\|[^][\\\\]\\|\\[:\\^?\sw+:]\\|\\[[^:]\\)*]")
+;;; "\\=\\(\\\\.\\|[^][\\]\\|\\[:\\^?\sw+:]\\|\\[[^:]\\)*]")
(while ; look for unescaped ]
(and argument
(re-search-forward
(if (eq (char-after b) ?\] )
- "\\=\\(\\\\[^]]\\|[^]\\\\]\\)*\\\\]"
- "\\=\\(\\\\.\\|[^]\\\\]\\)*]")
+ "\\=\\(\\\\[^]]\\|[^]\\]\\)*\\\\]"
+ "\\=\\(\\\\.\\|[^]\\]\\)*]")
(1- e) 'toend))
;; Is this ] an end of POSIX class?
(if (save-excursion
;; Works also if the outside delimiters are ().
(or;;(if (eq (char-after b) ?\) )
;;(re-search-forward
- ;; "[^\\\\]\\(\\\\\\\\\\)*\\\\)"
+ ;; "[^\\]\\(\\\\\\\\\\)*\\\\)"
;; (1- e) 'toend)
(search-forward ")" (1- e) 'toend)
;;)
".->" ; a->b
"->" ; a SPACE ->b
"\\[-" ; a[-1]
- "\\\\[&$@*\\\\]" ; \&func
+ "\\\\[&$@*\\]" ; \&func
"^=" ; =head
"\\$." ; $|
"<<[a-zA-Z_'\"`]" ; <<FOO, <<'FOO'
(error "Cannot find `(' which starts a group"))
(setq done
(save-excursion
- (skip-chars-backward "\\")
+ (skip-chars-backward "\\\\")
(looking-at "\\(\\\\\\\\\\)*(")))
(or done (forward-char -1)))))
(defun ebnf-yac-skip-spaces ()
(skip-chars-forward
(if ebnf-yac-skip-char
- "\n\r\t !#$&()*+-.0123456789=?@[\\\\]^_`~"
+ "-\n\r\t !#$&()*+,.0123456789=?@[\\\\]^_`~"
"\n\r\t ")
ebnf-limit)
(< (point) ebnf-limit))
(let* ((temp-master-file-name (flymake-proc--init-create-temp-source-and-master-buffer-copy
'flymake-proc-get-include-dirs-dot 'flymake-proc-create-temp-inplace
'("\\.tex\\'")
- "[ \t]*\\in\\(?:put\\|clude\\)[ \t]*{\\(.*%s\\)}")))
+ "[ \t]*in\\(?:put\\|clude\\)[ \t]*{\\(.*%s\\)}")))
(when temp-master-file-name
(flymake-proc--get-tex-args temp-master-file-name))))
(beg)
(progn
(end-of-line)
- (skip-chars-backward " \t\f\t\n" beg)
+ (skip-chars-backward " \t\f\n" beg)
(if (eq (point) beg)
(line-beginning-position 2)
(point)))))
(goto-char (match-end 0)))
(t
;; Move past line number.
- (skip-chars-forward "[ \t0-9]")))
+ (skip-chars-forward " \t0-9")))
;; Move past whitespace.
(skip-chars-forward " \t")
(current-column)))
;; x[i+4].name.g*. But it is complicated because we would have
;; to really parse this expression. For now, we allow only
;; substructures, like "aaa.bbb.ccc.ddd"
- (skip-chars-backward "[a-zA-Z0-9._$]")
+ (skip-chars-backward "a-zA-Z0-9._$")
(setq start (point)) ;; remember the start of the completion pos.
(and (< (point) pos)
(not (equal (char-before) ?!)) ; no sysvars
(case-fold-search t))
(cond ((save-excursion
;; Check if the context is right for system variable
- (skip-chars-backward "[a-zA-Z0-9_$]")
+ (skip-chars-backward "a-zA-Z0-9_$")
(equal (char-before) ?!))
(setq idlwave-completion-help-info '(idlwave-complete-sysvar-help))
(idlwave-complete-in-buffer 'sysvar 'sysvar
(progn
(if (and (eq prolog-system 'mercury)
(looking-at
- (format ":-[ \t]*\\(pred\\|mode\\)[ \t]+\\(%s+\\)"
+ (format ":-[ \t]*\\(pred\\|mode\\)[ \t]+\\(\\(?:%s\\)+\\)"
prolog-atom-regexp)))
;; Skip predicate declarations
(progn
(predname
(if (looking-at prolog-atom-char-regexp)
(progn
- (skip-chars-forward "^ (\\.")
+ (skip-chars-forward "^ (.")
(buffer-substring op (point)))
""))
(arity 0))
(cond ((looking-at "\\?\\(\\\\[CM]-\\)*\\\\?\\S ")
(goto-char (match-end 0)))
((progn
- (skip-chars-forward ",.:;|&^~=!?\\+\\-\\*")
+ (skip-chars-forward "-,.:;|&^~=!?+*")
(looking-at "\\s("))
(goto-char (scan-sexps (point) 1)))
((and (looking-at (concat "\\<\\(" ruby-block-beg-re
(let ((i (or arg 1)))
(condition-case nil
(while (> i 0)
- (skip-chars-backward " \t\n,.:;|&^~=!?\\+\\-\\*")
+ (skip-chars-backward "- \t\n,.:;|&^~=!?+*")
(forward-char -1)
(cond ((looking-at "\\s)")
(goto-char (scan-sexps (1+ (point)) -1))
((looking-at "\\s\"\\|\\\\\\S_")
(let ((c (char-to-string (char-before (match-end 0)))))
(while (and (search-backward c)
- (eq (logand (skip-chars-backward "\\") 1)
+ (eq (logand (skip-chars-backward "\\\\") 1)
1))))
nil)
((looking-at "\\s.\\|\\s\\")
(looking-at "[(,]")))
(not (save-excursion ; Not `endif, or user define
(backward-char 1)
- (skip-chars-backward "[a-zA-Z0-9_`]")
+ (skip-chars-backward "a-zA-Z0-9_`")
(looking-at "`"))))
(insert ","))))
(defun term-within-quotes (beg end)
"Return t if the number of quotes between BEG and END is odd.
Quotes are single and double."
- (let ((countsq (term-how-many-region "\\(^\\|[^\\\\]\\)'" beg end))
- (countdq (term-how-many-region "\\(^\\|[^\\\\]\\)\"" beg end)))
+ (let ((countsq (term-how-many-region "\\(^\\|[^\\]\\)'" beg end))
+ (countdq (term-how-many-region "\\(^\\|[^\\]\\)\"" beg end)))
(or (= (mod countsq 2) 1) (= (mod countdq 2) 1))))
(defun term-how-many-region (regexp beg end)
(defvar bib-capitalize-title-stop-words
(concat
- "the\\|and\\|of\\|is\\|a\\|an\\|of\\|for\\|in\\|to\\|in\\|on\\|at\\|"
+ "the\\|and\\|of\\|is\\|a\\|an\\|for\\|in\\|to\\|on\\|at\\|"
"by\\|with\\|that\\|its")
"Words not to be capitalized in a title (unless the first word).")
(defvar r2b-capitalize-title-stop-words
(concat
- "the\\|and\\|of\\|is\\|a\\|an\\|of\\|for\\|in\\|to\\|in\\|on\\|at\\|"
+ "the\\|and\\|of\\|is\\|a\\|an\\|for\\|in\\|to\\|on\\|at\\|"
"by\\|with\\|that\\|its")
"Words not to be capitalized in a title (unless the first word).")
(eq (following-char) ?\{))
(cl-incf cnt)))
(if (and (= n cnt)
- (> (skip-chars-forward "{\\[") 0))
+ (> (skip-chars-forward "{[") 0))
(reftex-context-substring)
nil))))
"The SVN revision of this file.
SVN revision is the upstream (docutils) revision.")
(defconst rst-svn-timestamp
- (rst-extract-version "\\$" "LastChangedDate: " ".+?+" " "
+ (rst-extract-version "\\$" "LastChangedDate: " ".+" " "
"$LastChangedDate: 2017-01-08 10:54:35 +0100 (Sun, 08 Jan 2017) $")
"The SVN time stamp of this file.")
(url-http-debug "url-http-parse-response called in (%s)" (buffer-name))
(goto-char (point-min))
(skip-chars-forward " \t\n") ; Skip any blank crap
- (skip-chars-forward "HTTP/") ; Skip HTTP Version
+ (skip-chars-forward "/HPT") ; Skip HTTP Version "HTTP/".
(setq url-http-response-version
(buffer-substring (point)
(progn
(insert "(/ x /)")
(f90-do-auto-fill)
(beginning-of-line)
- (skip-chars-forward "[ \t]")
+ (skip-chars-forward " \t")
(should (equal "&(/" (buffer-substring (point) (+ 3 (point)))))))
;; TODO bug#5593
projects / emacs.git / commitdiff