(unless (> (length newversion) 2) ; pretest or release candidate?
(with-temp-buffer
(insert-file-contents newsfile)
- (if (re-search-forward "^\\(+++ *\\|--- *\\)$" nil t)
+ (if (re-search-forward "^\\(\\+\\+\\+ *\\|--- *\\)$" nil t)
(display-warning 'admin
"NEWS file still contains temporary markup.
Documentation changes might not have been completed!"))))
; "\end{verbatim}" in text,
; it's special:
(if (and body-content
- (setq bop (string-match "\\end{verbatim}" curr-line)))
+ (setq bop (string-match "\\\\end{verbatim}" curr-line)))
(setq curr-line (concat (substring curr-line 0 bop)
">"
(substring curr-line bop))))
(apply #'vector (nreverse files))))
(defun archive-arc-rename-entry (newname descr)
- (if (string-match "[:\\\\/]" newname)
+ (if (string-match "[:\\/]" newname)
(error "File names in arc files must not contain a directory component"))
(if (> (length newname) 12)
(error "File names in arc files are limited to 12 characters"))
(call-process "lsar" nil t nil "-l" (or file copy))
(if copy (delete-file copy))
(goto-char (point-min))
- (re-search-forward "^\\(\s+=+\s?+\\)+\n")
+ (re-search-forward "^\\(\s+=+\s+\\)+\n")
(while (looking-at (concat "^\s+[0-9.]+\s+D?-+\s+" ; Flags
"\\([0-9-]+\\)\s+" ; Size
"\\([-0-9.%]+\\|-+\\)\s+" ; Ratio
(eval (intern
(concat "var-"
(save-excursion
- (re-search-backward ":\\(.*\\)\\}")
+ (re-search-backward ":\\(.*\\)}")
(match-string 1))))))
(error nil)))
(if yerr
(or (looking-at "{")
(error "Can't hide this curve (wrong format)"))
(forward-char 1)
- (if (looking-at "*")
+ (if (looking-at "\\*")
(if (or (null flag) (<= (prefix-numeric-value flag) 0))
(delete-char 1))
(if (or (null flag) (> (prefix-numeric-value flag) 0))
(setq desc (concat "M-" (substring desc 4))))
(while (string-match "^M-# \\(ESC \\|C-\\)" desc)
(setq desc (concat "M-# " (substring desc (match-end 0)))))
- (if (string-match "\\(DEL\\|\\LFD\\|RET\\|SPC\\|TAB\\)" desc)
+ (if (string-match "\\(DEL\\|LFD\\|RET\\|SPC\\|TAB\\)" desc)
(setq desc (replace-match "<\\&>" nil nil desc)))
(if briefly
(let ((msg (with-current-buffer (get-buffer-create "*Calc Summary*")
right " \\right)"))
((and (eq (aref func 0) ?\\)
(not (or
- (string-match "\\hbox{" func)
- (string-match "\\text{" func)))
+ (string-match "\\\\hbox{" func)
+ (string-match "\\\\text{" func)))
(= (length a) 2)
(or (Math-realp (nth 1 a))
(memq (car (nth 1 a)) '(var *))))
(math-read-token)))))))
(put 'eqn 'math-lang-read
- '((eq (string-match "->\\|<-\\|+-\\|\\\\dots\\|~\\|\\^"
+ '((eq (string-match "->\\|<-\\|\\+-\\|\\\\dots\\|~\\|\\^"
math-exp-str math-exp-pos)
math-exp-pos)
(progn
(beep)
(and (not (calc-minibuffer-contains "[-+]?\\(1[5-9]\\|[2-9][0-9]\\)#.*"))
(search-forward "e" nil t))
- (if (looking-at "+")
+ (if (looking-at "\\+")
(delete-char 1))
(if (looking-at "-")
(delete-char 1)
(let ((e (save-excursion
(makefile-end-of-command)
(point))))
- (while (re-search-forward "\\s-**\\([-a-zA-Z0-9./_@$%(){}]+\\)\\s-*" e t)
+ (while (re-search-forward "\\s-*\\([-a-zA-Z0-9./_@$%(){}]+\\)\\s-*" e t)
(let ((var nil)(varexp nil)
(match (buffer-substring-no-properties
(match-beginning 1)
Etags does not support this feature. TEXT will be the button
string. TOKEN will be the list, and INDENT is the current indentation
level."
- (cond ((string-match "+" text) ;we have to expand this file
+ (cond ((string-match "\\+" text) ;we have to expand this file
(speedbar-change-expand-button-char ?-)
(speedbar-with-writable
(save-excursion
(defun semantic-sb-show-extra (text token indent)
"Display additional information about the token as an expansion.
TEXT TOKEN and INDENT are the details."
- (cond ((string-match "+" text) ;we have to expand this file
+ (cond ((string-match "\\+" text) ;we have to expand this file
(speedbar-change-expand-button-char ?-)
(speedbar-with-writable
(save-excursion
(defun semantic-sb-expand-group (text token indent)
"Expand a group which has semantic tokens.
TEXT TOKEN and INDENT are the details."
- (cond ((string-match "+" text) ;we have to expand this file
+ (cond ((string-match "\\+" text) ;we have to expand this file
(speedbar-change-expand-button-char ?-)
(speedbar-with-writable
(save-excursion
(let (env-var-name
env-var-val)
(save-match-data
- (while (string-match "%\\([^\\\\/]*\\)%" name)
+ (while (string-match "%\\([^\\/]*\\)%" name)
(setq env-var-name (match-string 1 name))
(setq env-var-val (or (getenv env-var-name) ""))
(setq name (replace-match env-var-val t t name))))))
(put 'dired-actual-switches 'safe-local-variable 'dired-safe-switches-p)
-(defvar dired-re-inode-size "[0-9 \t]*[.,0-9]*[BkKMGTPEZY]?[ \t]*"
+(defvar dired-re-inode-size "[0-9 \t]*[.,0-9]*[BkKMGTPEZY]?[ \t]*"
"Regexp for optional initial inode and file size as made by `ls -i -s'.")
;; These regexps must be tested at beginning-of-line, but are also
(cntlst nil))
(save-excursion
(goto-char (point-min))
- (while (re-search-forward "\\-[A-Z][a-z][a-z] +\\(\\w+\\)@\\w+" nil t)
+ (while (re-search-forward "-[A-Z][a-z][a-z] +\\(\\w+\\)@\\w+" nil t)
(let* ((nam (buffer-substring (match-beginning 1) (match-end 1)))
(m (member nam nmlst)))
(message "Scanned username %s" nam)
(defun eieio-sb-expand (text class indent)
"For button TEXT, expand CLASS at the current location.
Argument INDENT is the depth of indentation."
- (cond ((string-match "+" text) ;we have to expand this file
+ (cond ((string-match "\\+" text) ;we have to expand this file
(speedbar-change-expand-button-char ?-)
(speedbar-with-writable
(save-excursion
(defun eieio-speedbar-object-expand (text token indent)
"Expand object represented by TEXT.
TOKEN is the object. INDENT is the current indentation level."
- (cond ((string-match "+" text) ;we have to expand this file
+ (cond ((string-match "\\+" text) ;we have to expand this file
(speedbar-change-expand-button-char ?-)
(oset token expanded t)
(speedbar-with-writable
(rx-check form)
(let ((result (rx-form (cadr form) '!))
case-fold-search)
- (cond ((string-match "\\`\\[^" result)
+ (cond ((string-match "\\`\\[\\^" result)
(cond
((equal result "[^]") "[^^]")
((and (= (length result) 4) (null (eq rx-parent '!)))
((= l 3) (string-match "\\`\\(?:\\\\[cCsS_]\\|\\[[^^]\\]\\)" r))
((null lax)
(cond
- ((string-match "\\`\\[^?\]?\\(?:\\[:[a-z]+:]\\|[^]]\\)*\\]\\'" r))
+ ((string-match "\\`\\[\\^?]?\\(?:\\[:[a-z]+:]\\|[^]]\\)*]\\'" r))
((string-match "\\`\\\\(\\(?:[^\\]\\|\\\\[^)]\\)*\\\\)\\'" r)))))))
(forward-char 1)
(setq ex-token-type 'whole))
((= char ?+)
- (cond ((or (looking-at "+[-+]") (looking-at "+[\n|]"))
+ (cond ((looking-at "\\+[-+\n|]")
(forward-char 1)
(insert "1")
(backward-char 1)
(setq ex-token-type 'plus))
- ((looking-at "+[0-9]")
+ ((looking-at "\\+[0-9]")
(forward-char 1)
(setq ex-token-type 'plus))
(t
(error viper-BadAddress))))
((= char ?-)
- (cond ((or (looking-at "-[-+]") (looking-at "-[\n|]"))
+ (cond ((looking-at "-[-+\n|]")
(forward-char 1)
(insert "1")
(backward-char 1)
(while (and (not (eolp)) cont)
;;(re-search-forward "[^/]*/")
(re-search-forward "[^/]*\\(/\\|\n\\)")
- (if (not (looking-back "[^\\\\]\\(\\\\\\\\\\)*\\\\/"
+ (if (not (looking-back "[^\\]\\(\\\\\\\\\\)*\\\\/"
(line-beginning-position 0)))
(setq cont nil))))
(backward-char 1)
(while (and (not (eolp)) cont)
;;(re-search-forward "[^\\?]*\\?")
(re-search-forward "[^\\?]*\\(\\?\\|\n\\)")
- (if (not (looking-back "[^\\\\]\\(\\\\\\\\\\)*\\\\\\?"
+ (if (not (looking-back "[^\\]\\(\\\\\\\\\\)*\\\\\\?"
(line-beginning-position 0)))
(setq cont nil))
(backward-char 1)
(error
"Global regexp must be inside matching non-alphanumeric chars"))
((= c ??) (error "`?' is not an allowed pattern delimiter here")))
- (if (looking-at "[^\\\\\n]")
+ (if (looking-at "[^\\\n]")
(progn
(forward-char 1)
(set-mark (point))
(error "Missing closing delimiter for global regexp")
(goto-char (point-max))))
(if (not (looking-back
- (format "[^\\\\]\\(\\\\\\\\\\)*\\\\%c" c)
+ (format "[^\\]\\(\\\\\\\\\\)*\\\\%c" c)
(line-beginning-position 0)))
(setq cont nil)
;; we are at an escaped delimiter: unescape it and continue
(message ":set <Variable> [= <Value>]")
(or batch (sit-for 2))
- (while (string-match "^[ \\t\\n]*$"
+ (while (string-match "^[ \t\n]*$"
(setq str
(completing-read ":set " ex-variable-alist)))
(message ":set <Variable> [= <Value>]")
(defun epg--status-SIG_CREATED (context string)
(if (string-match "\\`\\([DCS]\\) \\([0-9]+\\) \\([0-9]+\\) \
-\\([0-9A-Fa-F][0-9A-Fa-F]\\) \\(.*\\) " string)
+\\([0-9A-Fa-f][0-9A-Fa-f]\\) \\(.*\\) " string)
(epg-context-set-result-for
context 'sign
(cons (epg-make-new-signature
t))))
(defun erc-speedbar-expand-server (text server indent)
- (cond ((string-match "+" text)
+ (cond ((string-match "\\+" text)
(speedbar-change-expand-button-char ?-)
(if (speedbar-with-writable
(save-excursion
"For the line matching TEXT, in CHANNEL, expand or contract a line.
INDENT is the current indentation level."
(cond
- ((string-match "+" text)
+ ((string-match "\\+" text)
(speedbar-change-expand-button-char ?-)
(speedbar-with-writable
(save-excursion
(erc-speedbar-expand-channel "+" buffer 1)))))
(defun erc-speedbar-expand-user (text token indent)
- (cond ((string-match "+" text)
+ (cond ((string-match "\\+" text)
(speedbar-change-expand-button-char ?-)
(speedbar-with-writable
(save-excursion
(defun erc-is-message-ctcp-and-not-action-p (message)
"Check if MESSAGE is a CTCP message or not."
(and (erc-is-message-ctcp-p message)
- (not (string-match "^\C-a\\ACTION.*\C-a$" message))))
+ (not (string-match "^\C-aACTION.*\C-a$" message))))
(defun erc-format-privmessage (nick msg privp msgp)
"Format a PRIVMSG in an insertable fashion."
(mapcar #'upcase
(cdr (split-string mode)))))
erc-channel-banlist)))
- ((string-match "^+" mode)
+ ((string-match "^\\+" mode)
;; Add the banned mask(s) to the ban list
(mapc
(lambda (mask)
(defun eshell-parse-drive-letter ()
"An argument beginning with X:[^/] is a drive letter reference."
(when (and (not eshell-current-argument)
- (looking-at "\\([A-Za-z]:\\)\\([^/\\\\]\\|\\'\\)"))
+ (looking-at "\\([A-Za-z]:\\)\\([^/\\]\\|\\'\\)"))
(goto-char (match-end 1))
(let* ((letter (match-string 1))
(regexp (concat "\\`" letter))
(if (and (> len 1)
(eq (aref path (1- len)) ?/)
(not (and (eshell-under-windows-p)
- (string-match "\\`[A-Za-z]:[\\\\/]\\'" path))))
+ (string-match "\\`[A-Za-z]:[\\/]\\'" path))))
(setq path (substring path 0 (1- (length path)))))
(if eshell-pwd-convert-function
(funcall eshell-pwd-convert-function path)
" " args " "
(shell-quote-argument ")")
" "))
- (if (string-match "\\`\\(.*\\) {} \\(\\\\;\\|+\\)\\'"
+ (if (string-match "\\`\\(.*\\) {} \\(\\\\;\\|\\+\\)\\'"
(car find-ls-option))
(format "%s %s %s"
(match-string 1 (car find-ls-option))
(default-bg-mode
(if (or (window-system frame)
(and tty-type
- (string-match "^\\(xterm\\|\\rxvt\\|dtterm\\|eterm\\)"
+ (string-match "^\\(xterm\\|rxvt\\|dtterm\\|eterm\\)"
tty-type)))
'light
'dark))
nil
nil
;; Hostname ? user date request return-code number-of-bytes
- '(("^\\([-a-zA-z0-9.]+\\) - [-A-Za-z]+ \\(\\[.*\\]\\)"
+ '(("^\\([-a-zA-Z0-9.]+\\) - [-A-Za-z]+ \\(\\[.*\\]\\)"
(1 font-lock-constant-face)
(2 font-lock-variable-name-face)))
'("access_log\\'")
;; Regexp suggested by Felix Wiemann in <87oeuomcz9.fsf@news2.ososo.de>
(defcustom gnus-button-valid-localpart-regexp
- "[a-z0-9$%(*-=?[_][^<>\")!;:,{}\n\t @]*"
+ "[a-z$%(*-=?[_][^<>\")!;:,{}\n\t @]*"
"Regular expression that matches a localpart of mail addresses or MIDs."
:version "22.1"
:group 'gnus-article-buttons
;; otherwise collapse to select method.
(let* ((colon (string-match ":" group))
(server (and colon (substring group 0 colon)))
- (plus (and server (string-match "+" server))))
+ (plus (and server (string-match "\\+" server))))
(when server
(if plus
(setq foreign (substring server (+ 1 plus)
;; According to RFC 822 and its successors, the field name must
;; consist of printable US-ASCII characters other than colon,
;; i.e., decimal 33-56 and 59-126.
- '(looking-at "[ \t]\\|[][!\"#$%&'()*+,-./0-9;<=>?@A-Z\\\\^_`a-z{|}~]+:"))
+ '(looking-at "[ \t]\\|[][!\"#$%&'()*+,-./0-9;<=>?@A-Z\\^_`a-z{|}~]+:"))
"Set this non-nil if the system's mailer runs the header and body together.
\(This problem exists on Sunos 4 when sendmail is run in remote mode.)
The value should be an expression to test whether the problem will
(string-match ibuffer-compressed-file-name-regexp
buffer-file-name))
font-lock-doc-face)
- (20 (string-match "^*" (buffer-name)) font-lock-keyword-face)
+ (20 (string-match "^\\*" (buffer-name)) font-lock-keyword-face)
(25 (and (string-match "^ " (buffer-name))
(null buffer-file-name))
italic)
(not (and (eq ido-cur-item 'buffer)
ido-buffer-disable-smart-matches))
(not ido-enable-regexp)
- (not (string-match "$\\'" rex0))
+ (not (string-match "\\$\\'" rex0))
(concat "\\`" rex0 (if slash "/" "") "\\'")))
(suffix-re (and do-full slash
(not (and (eq ido-cur-item 'buffer)
ido-buffer-disable-smart-matches))
(not ido-enable-regexp)
- (not (string-match "$\\'" rex0))
+ (not (string-match "\\$\\'" rex0))
(concat rex0 "/\\'")))
(prefix-re (and full-re (not ido-enable-prefix)
(concat "\\`" rexq)))
(defun info-xref-lock-file-p (filename)
"Return non-nil if FILENAME is an Emacs lock file.
A lock file is \".#foo.txt\" etc per `lock-buffer'."
- (string-match "\\(\\`\\|\\/\\)\\.#" filename))
+ (string-match "\\(\\`\\|/\\)\\.#" filename))
(defun info-xref-subfile-p (filename)
"Return t if FILENAME is an info subfile.
(save-restriction
(narrow-to-region start (point))
(goto-char (point-min))
- (while (re-search-forward "^* \\([^:\n]+:\\(:\\|[^.\n]+\\).\\)" nil 'move)
+ (while (re-search-forward "^\\* \\([^:\n]+:\\(:\\|[^.\n]+\\).\\)" nil 'move)
;; Fold case straight away; `member-ignore-case' here wasteful.
(let ((x (downcase (match-string 1))))
(if (member x seen)
"Unescape double quotes and backslashes in VALUE."
(let ((start 0)
(unquote value))
- (while (string-match "[^\\\"]*\\(\\\\\\)[\\\\\"]" unquote start)
+ (while (string-match "[^\\\"]*\\(\\\\\\)[\\\"]" unquote start)
(setq unquote (replace-match "" t t unquote 1))
(setq start (- (match-end 0) 1)))
unquote))
(let ((start 0)
(parameter-alist))
(while (string-match
- "\\s *\\([^=]+\\)=\\(?:\\([^\\s \"]+\\)\\|\\(?:\"\\(\\(?:[^\\\"]\\|\\\\[\\\\\"]\\)*\\)\"\\)\\)"
+ "\\s *\\([^=]+\\)=\\(?:\\([^\\s \"]+\\)\\|\\(?:\"\\(\\(?:[^\\\"]\\|\\\\[\\\"]\\)*\\)\"\\)\\)"
parameter-string start)
(setq start (match-end 0))
(push (cons (match-string 1 parameter-string)
TEXT is the text of the button we clicked on, a + or - item.
TOKEN is data related to this node (NAME . FILE).
INDENT is the current indentation depth."
- (cond ((string-match "+" text) ;we have to expand this file
+ (cond ((string-match "\\+" text) ;we have to expand this file
(speedbar-change-expand-button-char ?-)
(if (speedbar-with-writable
(save-excursion
;; (allowing for whitespace at bob). Note: 'DOCTYPE NETSCAPE' is
;; useful for Mozilla bookmark files.
(when (and (re-search-forward "\\`[[:space:]\n]*\\(<!doctype[[:space:]\n]+\\(html\\|netscape\\)\\|<html\\)" size t)
- (re-search-forward "<meta\\s-+\\(http-equiv=[\"']?content-type[\"']?\\s-+content=[\"']text/\\sw+;\\s-*\\)?charset=[\"']?\\(.+?\\)[\"'\\s-/>]" size t))
+ (re-search-forward "<meta\\s-+\\(http-equiv=[\"']?content-type[\"']?\\s-+content=[\"']text/\\sw+;\\s-*\\)?charset=[\"']?\\(.+?\\)[\"'[:space:]/>]" size t))
(let* ((match (match-string 2))
(sym (intern (downcase match))))
(if (coding-system-p sym)
(or (eq (get this-command 'isearch-move) 'enabled)
(and (eq isearch-yank-on-move t)
(stringp (nth 1 (interactive-form this-command)))
- (string-match-p "^^" (nth 1 (interactive-form this-command))))
+ (string-match-p "^\\^"
+ (nth 1 (interactive-form this-command))))
(and (eq isearch-yank-on-move 'shift)
this-command-keys-shift-translated)))
(setq this-command-keys-shift-translated nil)
;; Special Ethiopic punctuation.
(goto-char (point-min))
- (while (re-search-forward "\\ce[»\\.\\?]\\|«\\ce" nil t)
+ (while (re-search-forward "\\ce[»\\.?]\\|«\\ce" nil t)
(cond
((= (setq ch (preceding-char)) ?\»)
(delete-char -1)
(save-excursion
(setq deleted-head
(cons (if (and (search-forward (concat rmail-attribute-header ": ") message-end t)
- (looking-at "?D"))
+ (looking-at "\\?D"))
?D
?\s) deleted-head))))
;; Two words -> first.last
(downcase
(format "%s.%s" (match-string 1 string) (match-string 2 string))))
- ((string-match "^\\([-a-zA-Z0-9._]+\\)@[-a-zA-z0-9_]+\\.+[a-zA-Z0-9]+$"
+ ((string-match "^\\([-a-zA-Z0-9._]+\\)@[-a-zA-Z0-9_]+\\.+[a-zA-Z0-9]+$"
string)
;; email only -> downcase username
(downcase (match-string 1 string)))
(goto-char (mh-mail-header-end))
(while
(re-search-forward
- "^#forw \\[\\([^]]+\\)\\] \\(+\\S-+\\) \\(.*\\)$"
+ "^#forw \\[\\([^]]+\\)\\] \\(\\+\\S-+\\) \\(.*\\)$"
(point-max) t)
(let ((description (if (equal (match-string 1)
"forwarded messages")
(let ((point (point)))
(forward-line (if backward-flag 0 1))
(cond ((if backward-flag
- (re-search-backward "^+" (point-min) t)
- (re-search-forward "^+" (point-max) t))
+ (re-search-backward "^\\+" (point-min) t)
+ (re-search-forward "^\\+" (point-max) t))
(beginning-of-line))
((and (if backward-flag
(goto-char (point-max))
(goto-char (point-min)))
nil))
((if backward-flag
- (re-search-backward "^+" (point-min) t)
- (re-search-forward "^+" (point-max) t))
+ (re-search-backward "^\\+" (point-min) t)
+ (re-search-forward "^\\+" (point-max) t))
(beginning-of-line))
(t (goto-char point))))))
(setq which-func-mode t))
(let ((alist ()))
(goto-char (point-min))
- (while (re-search-forward "^+" nil t)
+ (while (re-search-forward "^\\+" nil t)
(save-excursion
(beginning-of-line)
(push (cons (buffer-substring-no-properties
(mh-funcall-if-exists ietf-drums-parse-address
from-field))))
(host (and from
- (string-match "\\([^+]*\\)\\(+.*\\)?@\\(.*\\)" from)
+ (string-match "\\([^+]*\\)\\(\\+.*\\)?@\\(.*\\)" from)
(downcase (match-string 3 from))))
(user (and host (downcase (match-string 1 from))))
(canonical-address (format "%s@%s" user host))
;; We can't reuse env--substitute-vars-regexp because we need to match only
;; potentially-unfinished envvars at end of string.
(concat "\\(?:^\\|[^$]\\(?:\\$\\$\\)*\\)"
- "$\\([[:alnum:]_]*\\|{\\([^}]*\\)\\)\\'"))
+ "\\$\\([[:alnum:]_]*\\|{\\([^}]*\\)\\)\\'"))
(defun completion--embedded-envvar-table (string _pred action)
"Completion table for envvars embedded in a string.
;; seem to believe in the F-switch
(if (or (and symlink (string-match "@\\'" file))
(and directory (string-match "/\\'" file))
- (and executable (string-match "*\\'" file))
+ (and executable (string-match "\\*\\'" file))
(and socket (string-match "=\\'" file)))
(setq file (substring file 0 -1)))))
(puthash file (or symlink directory) tbl)
(defvar goto-address-mail-regexp
;; Actually pretty much any char could appear in the username part. -stef
- "[-a-zA-Z0-9=._+]+@\\([-a-zA-z0-9_]+\\.\\)+[a-zA-Z0-9]+"
+ "[-a-zA-Z0-9=._+]+@\\([-a-zA-Z0-9_]+\\.\\)+[a-zA-Z0-9]+"
"A regular expression probably matching an e-mail address.")
(defvar goto-address-url-regexp
"Find e-mail address around or before point.
Then search backwards to beginning of line for the start of an e-mail
address. If no e-mail address found, return nil."
- (re-search-backward "[^-_A-z0-9.@]" (line-beginning-position) 'lim)
+ (re-search-backward "[^-_A-Za-z0-9.@]" (line-beginning-position) 'lim)
(if (or (looking-at goto-address-mail-regexp) ; already at start
(and (re-search-forward goto-address-mail-regexp
(line-end-position) 'lim)
(goto-char pop3-read-point)
(if (looking-at "-ERR")
(error "%s" (buffer-substring (point) (- match-end 2)))
- (if (not (looking-at "+OK"))
+ (if (not (looking-at "\\+OK"))
(progn (setq pop3-read-point match-end) nil)
(setq pop3-read-point match-end)
(if return
"Send USER information to POP3 server."
(pop3-send-command process (format "USER %s" user))
(let ((response (pop3-read-response process t)))
- (if (not (and response (string-match "+OK" response)))
+ (if (not (and response (string-match "\\+OK" response)))
(error "USER %s not valid" user))))
(defun pop3-pass (process)
"Send authentication information to the server."
(pop3-send-command process (format "PASS %s" pop3-password))
(let ((response (pop3-read-response process t)))
- (if (not (and response (string-match "+OK" response)))
+ (if (not (and response (string-match "\\+OK" response)))
(pop3-quit process))))
(defun pop3-apop (process user)
(let ((hash (md5 (concat pop3-timestamp pass) nil nil 'binary)))
(pop3-send-command process (format "APOP %s %s" user hash))
(let ((response (pop3-read-response process t)))
- (if (not (and response (string-match "+OK" response)))
+ (if (not (and response (string-match "\\+OK" response)))
(pop3-quit process)))))
))
;; The following regexp is a bit sloppy. But it shall serve our
;; purposes. It covers also IPv4 mapped IPv6 addresses, like in
;; "::ffff:192.168.0.1".
-(defconst tramp-ipv6-regexp "\\(?:\\(?:[a-zA-Z0-9]+\\)?:\\)+[a-zA-Z0-9.]+"
+(defconst tramp-ipv6-regexp "\\(?:[a-zA-Z0-9]*:\\)+[a-zA-Z0-9.]+"
"Regexp matching IPv6 addresses.")
(defconst tramp-postfix-ipv6-format-alist
(tramp-compat-funcall 'substitute-env-vars filename 'only-defined))
;; We need an own implementation.
(save-match-data
- (let ((idx (string-match "$\\(\\w+\\)" filename)))
+ (let ((idx (string-match "\\$\\(\\w+\\)" filename)))
;; `$' is coded as `$$'.
(when (and idx
(or (zerop idx) (not (eq ?$ (aref filename (1- idx)))))
(let (lst head)
(with-current-buffer (find-file-noselect file)
(goto-char (point-min))
- (while (re-search-forward "^ *\\([a-FA-F0-9]\\{2\\}\\)[ \t]+" nil t)
+ (while (re-search-forward "^ *\\([a-fA-F0-9]\\{2\\}\\)[ \t]+" nil t)
(let ((row (match-string 1))
(eol (line-end-position)))
- (while (re-search-forward "\\([a-FA-F0-9]\\{2\\}\\)-\\([a-FA-F0-9]\\{2\\}\\)\\|\\([a-FA-F0-9]\\{2\\}\\)" eol t)
+ (while (re-search-forward "\\([a-fA-F0-9]\\{2\\}\\)-\\([a-fA-F0-9]\\{2\\}\\)\\|\\([a-fA-F0-9]\\{2\\}\\)" eol t)
(setq lst
(cons (if (match-beginning 3)
(concat "#x" row (match-string 3))
(defun rng-uri-escape-multibyte (uri)
"Escape multibyte characters in URI."
- (replace-regexp-in-string "[:nonascii:]"
+ (replace-regexp-in-string "[[:nonascii:]]"
'rng-percent-encode
(encode-coding-string uri 'utf-8)))
n)))
(defun rng-xsd-convert-any-uri (string)
- (and (string-match "\\`\\(?:[^%]\\|%[0-9a-fA-F][0-9a-fA-F]\\)?*\\'" string)
+ (and (string-match "\\`\\(?:[^%]\\|%[0-9a-fA-F][0-9a-fA-F]\\)*\\'" string)
(string-match "\\`[^#]*\\(?:#[^#]*\\)?\\'" string)
(string-match "\\`\\(?:[a-zA-Z][-+.A-Za-z0-9]*:.+\\|[^:]*\\(?:[#/?].*\\)?\\)\\'" string)
string))
(with-current-buffer (get-buffer-create pgg-output-buffer)
(buffer-disable-undo)
(erase-buffer)
- (let ((proto (if (string-match "^[a-zA-Z\\+\\.\\\\-]+:" keyserver)
+ (let ((proto (if (string-match "^[a-zA-Z\\+.-]+:" keyserver)
(substring keyserver 0 (1- (match-end 0))))))
(save-excursion
(funcall pgg-insert-url-function
((looking-at "%")
(forward-char 1)
(setq ex-token-type "whole"))
- ((looking-at "+")
- (cond ((or (looking-at "+[-+]") (looking-at "+[\n|]"))
+ ((looking-at "\\+")
+ (cond ((looking-at "\\+[-+\n|]")
(forward-char 1)
(insert "1")
(backward-char 1)
(setq ex-token-type "plus"))
- ((looking-at "+[0-9]")
+ ((looking-at "\\+[0-9]")
(forward-char 1)
(setq ex-token-type "plus"))
(t
(error "Badly formed address"))))
((looking-at "-")
- (cond ((or (looking-at "-[-+]") (looking-at "-[\n|]"))
+ (cond ((looking-at "-[-+\n|]")
(forward-char 1)
(insert "1")
(backward-char 1)
ex-variant t)
(forward-char 2)
(skip-chars-forward " \t")))
- (if (looking-at "+")
+ (if (looking-at "\\+")
(progn
(forward-char 1)
(set-mark (point))
(defun org-babel-string-read (cell)
"Strip nested \"s from around strings."
(org-babel-read (or (and (stringp cell)
- (string-match "\\\"\\(.+\\)\\\"" cell)
+ (string-match "\"\\(.+\\)\"" cell)
(match-string 1 cell))
cell) t))
(goto-char (point-min))
(cond
((eq type 'anniversary)
- (or (re-search-forward "^*[ \t]+Anniversaries" nil t)
+ (or (re-search-forward "^\\*[ \t]+Anniversaries" nil t)
(progn
(or (org-at-heading-p t)
(progn
;; this corner case.
(let ((begin (or (car affiliated) (point)))
(post-affiliated (point))
- (key (progn (looking-at "[ \t]*#\\+\\(\\S-+*\\):")
+ (key (progn (looking-at "[ \t]*#\\+\\(\\S-*\\):")
(upcase (match-string-no-properties 1))))
(value (org-trim (buffer-substring-no-properties
(match-end 0) (point-at-eol))))
(error "Cannot outdent beyond margin")
;; Change bullet if necessary.
(when (and (= (+ top-ind offset) 0)
- (string-match "*"
+ (string-match "\\*"
(org-list-get-bullet beg struct)))
(org-list-set-bullet beg struct
(org-list-bullet-string "-")))
"Return the name of the message folder in an index folder buffer."
(save-excursion
(mh-index-previous-folder)
- (if (re-search-forward "^\\(+.*\\)$" nil t)
+ (if (re-search-forward "^\\(\\+.*\\)$" nil t)
(message "%s" (match-string 1)))))
(defun org-mhe-get-message-folder ()
(cl-incf cnt-error)
(throw 'next t))
(move-marker bos-marker (point))
- (if (re-search-forward "^** Old value[ \t]*$" eos t)
+ (if (re-search-forward "^\\*\\* Old value[ \t]*$" eos t)
(setq old (buffer-substring
(1+ (match-end 0))
(progn (outline-next-heading) (point)))))
- (if (re-search-forward "^** New value[ \t]*$" eos t)
+ (if (re-search-forward "^\\*\\* New value[ \t]*$" eos t)
(setq new (buffer-substring
(1+ (match-end 0))
(progn (outline-next-heading)
,@(org-mouse-list-options-menu (mapcar 'car org-startup-options)
'org-mode-restart))))
((or (eolp)
- (and (looking-at "\\( \\|\t\\)\\(+:[0-9a-zA-Z_:]+\\)?\\( \\|\t\\)+$")
+ (and (looking-at "\\( \\|\t\\)\\(\\+:[0-9a-zA-Z_:]+\\)?\\( \\|\t\\)+$")
(looking-back " \\|\t" (- (point) 2)
(line-beginning-position))))
(org-mouse-popup-global-menu))
(insert "\n")
(insert-file-contents (plist-get params :script))
(goto-char (point-min))
- (while (re-search-forward "$datafile" nil t)
+ (while (re-search-forward "\\$datafile" nil t)
(replace-match data-file nil nil)))
(insert (org-plot/gnuplot-script data-file num-cols params)))
;; Graph table.
(len 0)
dir
ret)
- (when (string-match "^\\(.*\\)\\(org-protocol:/+[a-zA-z0-9][-_a-zA-z0-9]*:/+\\)\\(.*\\)" trigger)
+ (when (string-match "^\\(.*\\)\\(org-protocol:/+[a-zA-Z0-9][-_a-zA-Z0-9]*:/+\\)\\(.*\\)" trigger)
(setq dir (match-string 1 trigger))
(setq len (length dir))
(setcar l (concat dir (match-string 3 trigger))))
(- (org-time-string-to-absolute txt)
(org-time-string-to-absolute txt-up)))
((string-match org-ts-regexp3 txt) 1)
- ((string-match "\\([-+]\\)?\\(?:[0-9]+\\)?\\(?:\.[0-9]+\\)?" txt-up)
+ ((string-match "\\([-+]\\)?[0-9]*\\(?:\\.[0-9]+\\)?" txt-up)
(- (string-to-number txt)
(string-to-number (match-string 0 txt-up))))
(t 1)))
"\n"))))
(defsubst org-table-formula-make-cmp-string (a)
- (when (string-match "\\`$[<>]" a)
+ (when (string-match "\\`\\$[<>]" a)
(let ((arrow (string-to-char (substring a 1))))
;; Fake a high number to make sure this is sorted at the end.
(setq a (org-table-formula-handle-first/last-rc a))
(cond
((not (match-end 2)) m)
;; Is it a column reference?
- ((string-match-p "\\`$\\([0-9]+\\|[<>]+\\)\\'" m) m)
+ ((string-match-p "\\`\\$\\([0-9]+\\|[<>]+\\)\\'" m) m)
;; Since named columns are not possible in
;; LHS, assume this is a named field.
(t (match-string 2 string)))))
(cond
((string-match "\\`@-?I+" old-lhs)
(user-error "Can't assign to hline relative reference"))
- ((string-match "\\`$[<>]" old-lhs)
+ ((string-match "\\`\\$[<>]" old-lhs)
(let ((new (org-table-formula-handle-first/last-rc
old-lhs)))
(when (assoc new eqlist)
(setq startline (org-current-line))
(dolist (entry eql)
(let* ((type (cond
- ((string-match "\\`$\\([0-9]+\\|[<>]+\\)\\'" (car entry))
+ ((string-match "\\`\\$\\([0-9]+\\|[<>]+\\)\\'"
+ (car entry))
'column)
((equal (string-to-char (car entry)) ?@) 'field)
(t 'named)))
((and (equal type "lisp") (string-match "^/" path))
;; Planner has a slash, we do not.
(setq type "elisp" path (substring path 1)))
- ((string-match "^//\\(.?*\\)/\\(<.*>\\)$" path)
+ ((string-match "^//\\(.*\\)/\\(<.*>\\)$" path)
;; A typical message link. Planner has the id after the final slash,
;; we separate it with a hash mark
(setq path (concat (match-string 1 path) "#"
(save-excursion
(skip-chars-backward "[ \t]")
(skip-chars-backward "\\\\")
- (looking-at "\\\\\\\\\\($\\|[^\\\\]\\)")))
+ (looking-at "\\\\\\\\\\($\\|[^\\]\\)")))
(defun org-fill-paragraph-with-timestamp-nobreak-p ()
"Non-nil when a new line at point would split a timestamp."
(replace-regexp-in-string
"-" "•"
(replace-regexp-in-string
- "+" "⁃"
- (replace-regexp-in-string "*" "‣" bul))))))))
+ "\\+" "⁃"
+ (replace-regexp-in-string "\\*" "‣" bul))))))))
(indentation (if (eq list-type 'descriptive) org-ascii-quote-margin
(string-width bullet))))
(concat
(defun org-latex-clean-invalid-line-breaks (data _backend _info)
(replace-regexp-in-string
- "\\(\\end{[A-Za-z0-9*]+}\\|^\\)[ \t]*\\\\\\\\[ \t]*$" "\\1"
+ "\\(\\\\end{[A-Za-z0-9*]+}\\|^\\)[ \t]*\\\\\\\\[ \t]*$" "\\1"
data))
\f
(setq value (replace-match "" nil nil value)))))
(lines
(and (string-match
- ":lines +\"\\(\\(?:[0-9]+\\)?-\\(?:[0-9]+\\)?\\)\""
+ ":lines +\"\\([0-9]*-[0-9]*\\)\""
value)
(prog1 (match-string 1 value)
(setq value (replace-match "" nil nil value)))))
file, minus extension but with directory, and ${full_current} is
replaced by the name including the extension."
- (while (string-match "\\(-[^-$IO]*[IO]\\)?${\\([^}]+\\)}" cmd-string)
+ (while (string-match "\\(-[^-$IO]*[IO]\\)?\\${\\([^}]+\\)}" cmd-string)
(let (value
(name (match-string 2 cmd-string)))
(cond
;; Classes.
("^[ \t]*\\([[:alnum:]_().|!]+\\)::" 1 font-lock-function-name-face)
;; Variables.
- ("$(\\([[:alnum:]_]+\\))" 1 font-lock-variable-name-face)
- ("${\\([[:alnum:]_]+\\)}" 1 font-lock-variable-name-face)
+ ("\\$(\\([[:alnum:]_]+\\))" 1 font-lock-variable-name-face)
+ ("\\${\\([[:alnum:]_]+\\)}" 1 font-lock-variable-name-face)
;; Variable definitions.
("\\_<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
;; File, acl &c in group: { token ... }
(cond
((looking-at "\\(s\\|tr\\)\\>")
(or (re-search-forward
- "\\=\\w+[ \t]*#\\([^\n\\\\#]\\|\\\\[\\\\#]\\)*#\\([^\n\\\\#]\\|\\\\[\\\\#]\\)*"
+ "\\=\\w+[ \t]*#\\([^\n\\#]\\|\\\\[\\#]\\)*#\\([^\n\\#]\\|\\\\[\\#]\\)*"
lim 'move)
(setq stop-in t)))
((looking-at "\\(m\\|q\\([qxwr]\\)?\\)\\>")
(or (re-search-forward
- "\\=\\w+[ \t]*#\\([^\n\\\\#]\\|\\\\[\\\\#]\\)*#"
+ "\\=\\w+[ \t]*#\\([^\n\\#]\\|\\\\[\\#]\\)*#"
lim 'move)
(setq stop-in t)))
(t ; It was fair comment
state-point b nil nil state)
state-point b)
(if (or (nth 3 state) (nth 4 state)
- (looking-at "\\(cut\\|\\end\\)\\>"))
+ (looking-at "\\(cut\\|end\\)\\>"))
(if (or (nth 3 state) (nth 4 state) ignore-max)
nil ; Doing a chunk only
(message "=cut is not preceded by a POD section")
b1 nil) ; error condition
;; We do not search to max, since we may be called from
;; some hook of fontification, and max is random
- (or (re-search-forward "^\n=\\(cut\\|\\end\\)\\>" stop-point 'toend)
+ (or (re-search-forward "^\n=\\(cut\\|end\\)\\>" stop-point 'toend)
(progn
(goto-char b)
- (if (re-search-forward "\n=\\(cut\\|\\end\\)\\>" stop-point 'toend)
+ (if (re-search-forward "\n=\\(cut\\|end\\)\\>" stop-point 'toend)
(progn
(message "=cut is not preceded by an empty line")
(setq b1 t)
;; Looking at:
;; else {
(if (looking-at
- "[ \t]*}?[ \t]*\\<\\(\\els\\(e\\|if\\)\\|continue\\|unless\\|if\\|while\\|for\\(each\\)?\\|until\\)\\>\\(\t*\\|[ \t][ \t]+\\)[^ \t\n#]")
+ "[ \t]*}?[ \t]*\\<\\(els\\(e\\|if\\)\\|continue\\|unless\\|if\\|while\\|for\\(each\\)?\\|until\\)\\>\\(\t*\\|[ \t][ \t]+\\)[^ \t\n#]")
(progn
(forward-word-strictly 1)
(delete-horizontal-space)
;; Looking at (with or without "}" at start, ending after "({"):
;; } foreach my $var () OR {
(if (looking-at
- "[ \t]*\\(}[ \t]*\\)?\\<\\(\\els\\(e\\|if\\)\\|continue\\|if\\|unless\\|while\\|for\\(each\\)?\\(\\([ \t]+\\(state\\|my\\|local\\|our\\)\\)?[ \t]*\\$[_a-zA-Z0-9]+\\)?\\|until\\)\\>\\([ \t]*(\\|[ \t\n]*{\\)\\|[ \t]*{")
+ "[ \t]*\\(}[ \t]*\\)?\\<\\(els\\(e\\|if\\)\\|continue\\|if\\|unless\\|while\\|for\\(each\\)?\\(\\([ \t]+\\(state\\|my\\|local\\|our\\)\\)?[ \t]*\\$[_a-zA-Z0-9]+\\)?\\|until\\)\\>\\([ \t]*(\\|[ \t\n]*{\\)\\|[ \t]*{")
(progn
(setq ml (match-beginning 8)) ; "(" or "{" after control word
(re-search-forward "[({]")
"-[a-zA-Z]" ; File test
"\\\\[a-zA-Z0]" ; Special chars
"^=[a-z][a-zA-Z0-9_]*" ; POD sections
- "[-!&*+,-./<=>?\\\\^|~]+" ; Operator
+ "[-!&*+,./<=>?\\^|~]+" ; Operator
"[a-zA-Z_0-9:]+" ; symbol or number
"x="
"#!")
;; Does not save-excursion
;; Get to the something meaningful
(or (eobp) (eolp) (forward-char 1))
- (re-search-backward "[-a-zA-Z0-9_:!&*+,-./<=>?\\\\^|~$%@]"
+ (re-search-backward "[-a-zA-Z0-9_:!&*+,./<=>?\\^|~$%@]"
(point-at-bol)
'to-beg)
;; (cond
(forward-char -1))
((and (looking-at "\\^") (eq (preceding-char) ?\$)) ; $^I
(forward-char -1))
- ((looking-at "[-!&*+,-./<=>?\\\\^|~]")
- (skip-chars-backward "-!&*+,-./<=>?\\\\^|~")
+ ((looking-at "[-!&*+,./<=>?\\^|~]")
+ (skip-chars-backward "-!&*+,./<=>?\\^|~")
(cond
((and (eq (preceding-char) ?\$)
(not (eq (char-after (- (point) 2)) ?\$))) ; $-
;; Protect fragile " ", "#"
(if have-x nil
(goto-char (1+ b))
- (while (re-search-forward "\\(\\=\\|[^\\\\]\\)\\(\\\\\\\\\\)*[ \t\n#]" e t) ; Need to include (?#) too?
+ (while (re-search-forward "\\(\\=\\|[^\\]\\)\\(\\\\\\\\\\)*[ \t\n#]" e t) ; Need to include (?#) too?
(forward-char -1)
(insert "\\")
(forward-char 1)))
Returns the column offset."
(save-excursion
(beginning-of-line)
- (re-search-forward "^$[ \t]*" nil t)
+ (re-search-forward "^\\$[ \t]*" nil t)
(current-column)))
;; a textual description of the four rules.
(and (string-match "^[^ \t()=,;]+$" tag) ;rule #1
;; Rules #2 and #4, and a check that there's no explicit name.
- (looking-at "[ \t()=,;]?\177\\(?:[0-9]+\\)?,\\(?:[0-9]+\\)?$")
+ (looking-at "[ \t()=,;]?\177[0-9]*,[0-9]*$")
(save-excursion
(backward-char (1+ (length tag)))
(looking-at "[\n \t()=,;]")))) ;rule #3
(when (<= (point) bos)
(move-to-column (1+ fill-column))
;; What is this doing???
- (or (re-search-forward "[\t\n,'+-/*)=]" eol t)
+ (or (re-search-forward "[-\t\n,'+./*)=]" eol t)
(goto-char bol)))
(if (bolp)
(re-search-forward "[ \t]" opoint t))
TEXT is the text of the button we clicked on, a + or - item.
TOKEN is data related to this node.
INDENT is the current indentation depth."
- (cond ((string-match "+" text) ;expand this node
+ (cond ((string-match "\\+" text) ;expand this node
(let* ((var (assoc token gdb-var-list))
(expr (nth 1 var)) (children (nth 2 var)))
(if (or (<= (string-to-number children) gdb-max-children)
(when (not value)
(setq value "<complex data type>"))
(if (or (not value)
- (string-match "\\0x" value))
+ (string-match "0x" value))
(add-text-properties 0 (length name)
`(mouse-face highlight
help-echo "mouse-2: create watch expression"
(": \\(.+\\): \\(?:Permission denied\\|No such \\(?:file or directory\\|device or address\\)\\)$"
1 grep-error-face)
;; remove match from grep-regexp-alist before fontifying
- ("^Grep[/a-zA-z]* started.*"
+ ("^Grep[/a-zA-Z]* started.*"
(0 '(face nil compilation-message nil help-echo nil mouse-face nil) t))
- ("^Grep[/a-zA-z]* finished with \\(?:\\(\\(?:[0-9]+ \\)?matches found\\)\\|\\(no matches found\\)\\).*"
+ ("^Grep[/a-zA-Z]* finished with \\(?:\\(\\(?:[0-9]+ \\)?matches found\\)\\|\\(no matches found\\)\\).*"
(0 '(face nil compilation-message nil help-echo nil mouse-face nil) t)
(1 compilation-info-face nil t)
(2 compilation-warning-face nil t))
- ("^Grep[/a-zA-z]* \\(exited abnormally\\|interrupt\\|killed\\|terminated\\)\\(?:.*with code \\([0-9]+\\)\\)?.*"
+ ("^Grep[/a-zA-Z]* \\(exited abnormally\\|interrupt\\|killed\\|terminated\\)\\(?:.*with code \\([0-9]+\\)\\)?.*"
(0 '(face nil compilation-message nil help-echo nil mouse-face nil) t)
(1 grep-error-face)
(2 grep-error-face nil t))
(split-string
;; Eliminate any subclass references in the class
;; name string. These start with a "$"
- (if (string-match "$.*" p)
+ (if (string-match "\\$.*" p)
(replace-match "" t t p) p)
"\\.") "/")
".java"))
(save-excursion (backward-char) (not (looking-at "[/*]/\\|=>")))
(js--looking-at-operator-p)
(and (progn (backward-char)
- (not (looking-at "+\\+\\|--\\|/[/*]"))))))))))
+ (not (looking-at "\\+\\+\\|--\\|/[/*]"))))))))))
(defun js--skip-term-backward ()
"Skip a term before point; return t if a term was skipped."
(defvar m4-font-lock-keywords
'(("\\(\\_<\\(m4_\\)?dnl\\_>\\).*$" . font-lock-comment-face)
("\\$[*#@0-9]" . font-lock-variable-name-face)
- ("\\$\\@" . font-lock-variable-name-face)
+ ("\\$@" . font-lock-variable-name-face)
("\\$\\*" . font-lock-variable-name-face)
("\\_<\\(m4_\\)?\\(builtin\\|change\\(com\\|quote\\|word\\)\\|d\\(e\\(bug\\(file\\|mode\\)\\|cr\\|f\\(ine\\|n\\)\\)\\|iv\\(ert\\|num\\)\\|nl\\|umpdef\\)\\|e\\(rrprint\\|syscmd\\|val\\)\\|f\\(ile\\|ormat\\)\\|gnu\\|i\\(f\\(def\\|else\\)\\|n\\(c\\(lude\\|r\\)\\|d\\(ex\\|ir\\)\\)\\)\\|l\\(en\\|ine\\)\\|m\\(4\\(exit\\|wrap\\)\\|aketemp\\)\\|p\\(atsubst\\|opdef\\|ushdef\\)\\|regexp\\|s\\(hift\\|include\\|ubstr\\|ys\\(cmd\\|val\\)\\)\\|tra\\(ceo\\(ff\\|n\\)\\|nslit\\)\\|un\\(d\\(efine\\|ivert\\)\\|ix\\)\\)\\_>" . font-lock-keyword-face))
"Default `font-lock-keywords' for M4 mode.")
(let ((count 0))
(narrow-to-region
(point) (save-excursion
- (re-search-forward "[^\\\\\"]%\\|\n\\|\\'" nil t)
+ (re-search-forward "[^\\\"]%\\|\n\\|\\'" nil t)
(backward-char) (point)))
(while (re-search-forward "\\<\\sw+\\>\\|(\\|)" nil t)
(save-excursion
. mixal-font-lock-operation-code-face)
(,(regexp-opt mixal-assembly-pseudoinstructions 'words)
. mixal-font-lock-assembly-pseudoinstruction-face)
- ("^[A-Z0-9a-z]*[ \t]+[A-ZO-9a-z]+[ \t]+\\(=.*=\\)"
+ ("^[A-Z0-9a-z]*[ \t]+[A-Z0-9a-z]+[ \t]+\\(=.*=\\)"
(1 font-lock-constant-face)))
"Keyword highlighting specification for `mixal-mode'.")
;; (makunbound 'mixal-font-lock-keywords)
(setq dir-name (match-string 1 dir-name)
recurse t))
;; Ensure the trailing slash is removed.
- (if (string-match "^\\(.+\\)[\\\\/]$" dir-name)
+ (if (string-match "^\\(.+\\)[\\/]$" dir-name)
(setq dir-name (match-string 1 dir-name)))
(opascal-search-directory unit dir-name recurse)))
(defconst pascal-beg-block-re "\\<\\(begin\\|case\\|record\\|repeat\\)\\>")
(defconst pascal-end-block-re "\\<\\(end\\|until\\)\\>")
(defconst pascal-declaration-re "\\<\\(const\\|label\\|type\\|var\\)\\>")
-(defconst pascal-progbeg-re "\\<\\program\\>")
+(defconst pascal-progbeg-re "\\<program\\>")
(defconst pascal-defun-re "\\<\\(function\\|procedure\\|program\\)\\>")
(defconst pascal-sub-block-re "\\<\\(if\\|else\\|for\\|while\\|with\\)\\>")
(defconst pascal-noindent-re "\\<\\(begin\\|end\\|until\\|else\\)\\>")
"Regexp to match the beginning of a heredoc.")
(defconst ruby-expression-expansion-re
- "\\(?:[^\\]\\|\\=\\)\\(\\\\\\\\\\)*\\(#\\({[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\|\\$[^a-zA-Z \n]\\)\\)"))
+ "\\(?:[^\\]\\|\\=\\)\\(\\\\\\\\\\)*\\(#\\({[^}\n\\]*\\(\\\\.[^}\n\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\|\\$[^a-zA-Z \n]\\)\\)"))
(defun ruby-here-doc-end-match ()
"Return a regexp to find the end of a heredoc.
(goto-char (match-end 0))
(not (looking-at "\\s_")))
((eq option 'expr-qstr)
- (looking-at "[a-zA-Z][a-zA-z0-9_]* +%[^ \t]"))
+ (looking-at "[a-zA-Z][a-zA-Z0-9_]* +%[^ \t]"))
((eq option 'expr-re)
- (looking-at "[a-zA-Z][a-zA-z0-9_]* +/[^ \t]"))
+ (looking-at "[a-zA-Z][a-zA-Z0-9_]* +/[^ \t]"))
(t nil)))))))))
(defun ruby-forward-string (term &optional end no-error expand)
((looking-at "\\?") ;skip ?char
(cond
((and (ruby-expr-beg)
- (looking-at "?\\(\\\\C-\\|\\\\M-\\)*\\\\?."))
+ (looking-at "\\?\\(\\\\C-\\|\\\\M-\\)*\\\\?."))
(goto-char (match-end 0)))
(t
(goto-char pnt))))
(buffer-substring-no-properties (1+ min) (1- max))))
(setq content
(if (equal string-quote "'")
- (replace-regexp-in-string "\\\\\"" "\"" (replace-regexp-in-string "\\(\\`\\|[^\\\\]\\)'" "\\1\\\\'" content))
- (replace-regexp-in-string "\\\\'" "'" (replace-regexp-in-string "\\(\\`\\|[^\\\\]\\)\"" "\\1\\\\\"" content))))
+ (replace-regexp-in-string "\\\\\"" "\"" (replace-regexp-in-string "\\(\\`\\|[^\\]\\)'" "\\1\\\\'" content))
+ (replace-regexp-in-string "\\\\'" "'" (replace-regexp-in-string "\\(\\`\\|[^\\]\\)\"" "\\1\\\\\"" content))))
(let ((orig-point (point)))
(delete-region min max)
(insert
font-lock-constant-face)
nil t))
;; Special globals.
- (,(concat "\\$\\(?:[:\"!@;,/\\._><\\$?~=*&`'+0-9]\\|-[0adFiIlpvw]\\|"
+ (,(concat "\\$\\(?:[:\"!@;,/._><\\$?~=*&`'+0-9]\\|-[0adFiIlpvw]\\|"
(regexp-opt '("LOAD_PATH" "LOADED_FEATURES" "PROGRAM_NAME"
"ERROR_INFO" "ERROR_POSITION"
"FS" "FIELD_SEPARATOR"
"Return a docstring for `sql-help' listing loaded SQL products."
(let ((doc sql--help-docstring))
;; Insert FREE software list
- (when (string-match "^\\(\\s-*\\)[\\\\][\\\\]FREE\\s-*$" doc 0)
+ (when (string-match "^\\(\\s-*\\)[\\][\\]FREE\\s-*$" doc 0)
(setq doc (replace-match (sql-help-list-products (match-string 1 doc) t)
t t doc 0)))
;; Insert non-FREE software list
- (when (string-match "^\\(\\s-*\\)[\\\\][\\\\]NONFREE\\s-*$" doc 0)
+ (when (string-match "^\\(\\s-*\\)[\\][\\]NONFREE\\s-*$" doc 0)
(setq doc (replace-match (sql-help-list-products (match-string 1 doc) nil)
t t doc 0)))
doc))
(defconst verilog-behavioral-block-beg-re
(eval-when-compile (verilog-regexp-words '("initial" "final" "always" "always_comb" "always_latch" "always_ff"
"function" "task"))))
-(defconst verilog-coverpoint-re "\\w+\\s*:\\s*\\(coverpoint\\|cross\\constraint\\)" )
+(defconst verilog-coverpoint-re "\\w+\\s-*:\\s-*\\(coverpoint\\|cross\\constraint\\)" )
(defconst verilog-in-constraint-re ; keywords legal in constraint blocks starting a statement/block
(eval-when-compile (verilog-regexp-words '("if" "else" "solve" "foreach"))))
(skip-chars-forward " \t\n\f")
(while
(cond
- ((looking-at "\\/\\*")
+ ((looking-at "/\\*")
(progn
(setq h (point))
(goto-char (match-end 0))
(error "%s: Unmatched (* *), at char %d" (verilog-point-text) (point))))
;; On pins, parse and advance to next pin
;; Looking at pin, but *not* an // Output comment, or ) to end the inst
- ((looking-at "\\s-*[a-zA-Z0-9`_$({}\\\\][^,]*")
+ ((looking-at "\\s-*[a-zA-Z0-9`_$({}\\][^,]*")
(goto-char (match-end 0))
(setq verilog-read-sub-decls-gate-ios (or (car iolist) "input")
iolist (cdr iolist))
;; Regexp form??
((looking-at
;; Regexp bug in XEmacs disallows ][ inside [], and wants + last
- "\\s-*\\.\\(\\([a-zA-Z0-9`_$+@^.*?|---]\\|[][]\\|\\\\[()|]\\)+\\)\\s-*(\\(.*\\))\\s-*\\(,\\|)\\s-*;\\)")
+ "\\s-*\\.\\(\\([-a-zA-Z0-9`_$+@^.*?]\\|[][]\\|\\\\[()|]\\)+\\)\\s-*(\\(.*\\))\\s-*\\(,\\|)\\s-*;\\)")
(setq rep (match-string-no-properties 3))
(goto-char (match-end 0))
(setq tpl-wild-list
(defun vhdl-resolve-env-variable (string)
"Resolve environment variables in STRING."
- (while (string-match "\\(.*\\)${?\\(\\(\\w\\|_\\)+\\)}?\\(.*\\)" string)
+ (while (string-match "\\(.*\\)\\${?\\(\\(\\w\\|_\\)+\\)}?\\(.*\\)" string)
(setq string (concat (match-string 1 string)
(getenv (match-string 2 string))
(match-string 4 string))))
(defun vhdl-speedbar-expand-project (text token indent)
"Expand/contract the project under the cursor."
(cond
- ((string-match "+" text) ; expand project
+ ((string-match "\\+" text) ; expand project
(speedbar-change-expand-button-char ?-)
(unless (member token vhdl-speedbar-shown-project-list)
(setq vhdl-speedbar-shown-project-list
(defun vhdl-speedbar-expand-entity (text token indent)
"Expand/contract the entity under the cursor."
(cond
- ((string-match "+" text) ; expand entity
+ ((string-match "\\+" text) ; expand entity
(let* ((key (vhdl-speedbar-line-key indent))
(ent-alist (vhdl-aget vhdl-entity-alist key))
(ent-entry (vhdl-aget ent-alist token))
(defun vhdl-speedbar-expand-architecture (text token indent)
"Expand/contract the architecture under the cursor."
(cond
- ((string-match "+" text) ; expand architecture
+ ((string-match "\\+" text) ; expand architecture
(let* ((key (vhdl-speedbar-line-key (1- indent)))
(ent-alist (vhdl-aget vhdl-entity-alist key))
(conf-alist (vhdl-aget vhdl-config-alist key))
(defun vhdl-speedbar-expand-config (text token indent)
"Expand/contract the configuration under the cursor."
(cond
- ((string-match "+" text) ; expand configuration
+ ((string-match "\\+" text) ; expand configuration
(let* ((key (vhdl-speedbar-line-key indent))
(conf-alist (vhdl-aget vhdl-config-alist key))
(conf-entry (vhdl-aget conf-alist token))
(defun vhdl-speedbar-expand-package (text token indent)
"Expand/contract the package under the cursor."
(cond
- ((string-match "+" text) ; expand package
+ ((string-match "\\+" text) ; expand package
(let* ((key (vhdl-speedbar-line-key indent))
(pack-alist (vhdl-aget vhdl-package-alist key))
(pack-entry (vhdl-aget pack-alist token))
(defun vhdl-speedbar-dired (text token indent)
"Speedbar click handler for directory expand button in hierarchy mode."
- (cond ((string-match "+" text) ; we have to expand this dir
+ (cond ((string-match "\\+" text) ; we have to expand this dir
(setq speedbar-shown-directories
(cons (expand-file-name
(concat (speedbar-line-directory indent) token "/"))
Clicking this button expands or contracts a directory. TEXT is the
button clicked which has either a + or -. TOKEN is the directory to be
expanded. INDENT is the current indentation level."
- (cond ((string-match "+" text) ;we have to expand this dir
+ (cond ((string-match "\\+" text) ;we have to expand this dir
(setq speedbar-shown-directories
(cons (expand-file-name
(concat (speedbar-line-directory indent) token "/"))
The parameter TEXT and TOKEN are required, where TEXT is the button
clicked, and TOKEN is the file to expand. INDENT is the current
indentation level."
- (cond ((string-match "+" text) ;we have to expand this file
+ (cond ((string-match "\\+" text) ;we have to expand this file
(let* ((fn (expand-file-name (concat (speedbar-line-directory indent)
token)))
(lst (speedbar-fetch-dynamic-tags fn)))
"Expand a tag sublist. Imenu will return sub-lists of specialized tag types.
Etags does not support this feature. TEXT will be the button string.
TOKEN will be the list, and INDENT is the current indentation level."
- (cond ((string-match "+" text) ;we have to expand this file
+ (cond ((string-match "\\+" text) ;we have to expand this file
(speedbar-change-expand-button-char ?-)
(speedbar-with-writable
(save-excursion
"26.1" 'set)
(defcustom dns-mode-font-lock-keywords
- `((,(concat "^$" (regexp-opt dns-mode-control-entities))
+ `((,(concat "^\\$" (regexp-opt dns-mode-control-entities))
0 ,dns-mode-control-entity-face)
- ("^$[a-z0-9A-Z]+" 0 ,dns-mode-bad-control-entity-face)
+ ("^\\$[a-z0-9A-Z]+" 0 ,dns-mode-bad-control-entity-face)
(,(regexp-opt dns-mode-classes) 0 ,dns-mode-class-face)
(,(regexp-opt dns-mode-types) 0 ,dns-mode-type-face))
"Font lock keywords used to highlight text in DNS master file mode."
(or (string= "" ispell-otherchars)
(not (looking-at ispell-otherchars)))
(or flyspell-consider-dash-as-word-delimiter-flag
- (not (looking-at "\\-")))
+ (not (looking-at "-")))
2)))))
(format " because : %S\n"
(cond
(or (string= "" ispell-otherchars)
(not (looking-at ispell-otherchars)))
(or flyspell-consider-dash-as-word-delimiter-flag
- (not (looking-at "\\-")))))))
+ (not (looking-at "-")))))))
;; Yes because we have reached or typed a word delimiter.
'separator)
((not (integerp flyspell-delay))
;; Error in tex mode when a potential math mode change exists.
(if (and replace (listp replace) (= 2 (length replace)))
(if (and (eq ispell-parser 'tex)
- (string-match "[\\\\][]()[]\\|\\\\begin\\|\\$"
+ (string-match "[\\][]()[]\\|\\\\begin\\|\\$"
(regexp-quote string)))
(error
"Don't start query replace on a line with math characters"
(if item
(progn (end-of-line)
(re-search-forward
- "\\\\bibitem\\|\\end{thebibliography}")
+ "\\\\bibitem\\|\\\\end{thebibliography}")
(1- (match-beginning 0)))
(progn (forward-list 1) (point)))
(error (min (point-max) (+ 300 (point)))))))
(setq names (reftex-get-bib-field "editor" entry)))
(while (string-match "\\band\\b[ \t]*" names)
(setq names (replace-match "\n" nil t names)))
- (while (string-match "[\\.a-zA-Z\\-]+\\.[ \t]*\\|,.*\\|[{}]+" names)
+ (while (string-match "[-.a-zA-Z]+\\.[ \t]*\\|,.*\\|[{}]+" names)
(setq names (replace-match "" nil t names)))
(while (string-match "^[ \t]+\\|[ \t]+$" names)
(setq names (replace-match "" nil t names)))
;; Replace %escapes in a label prefix
(save-match-data
(let (letter (num 0) replace)
- (while (string-match "\\%\\([a-zA-Z]\\)" prefix num)
+ (while (string-match "%\\([a-zA-Z]\\)" prefix num)
(setq letter (match-string 1 prefix))
(setq replace
(save-match-data
;; 3.3. Path
(skip-chars-forward "^?#")
;; 3.4. Query
- (when (looking-at "?")
+ (when (looking-at "\\?")
(skip-chars-forward "^#"))
(setq file (buffer-substring save-pos (point)))
;; 3.5 Fragment
(urlobj nil))
;; The first thing that can go are the search strings
(if (and (>= str-width fr-width)
- (string-match "?" url))
+ (string-match "\\?" url))
(setq url (concat (substring url 0 (match-beginning 0)) "?...")
str-width (length url)))
(if (< str-width fr-width)
" ----\n" hunk))
;;(goto-char (point-min))
(forward-line 1)
- (if (not (save-excursion (re-search-forward "^+" nil t)))
+ (if (not (save-excursion (re-search-forward "^\\+" nil t)))
(delete-region (point) (point-max))
(let ((modif nil) (delete nil))
(if (save-excursion (re-search-forward "^\\+.*\n-"
(file-relative-name filename* rootdir))))
(defvar vc-bzr-error-regexp-alist
- '(("^\\( M[* ]\\|+N \\|-D \\|\\| \\*\\|R[M ] \\) \\(.+\\)" 2 nil nil 1)
+ '(("^\\( M[* ]\\|\\+N \\|-D \\|\\| \\*\\|R[M ] \\) \\(.+\\)" 2 nil nil 1)
("^C \\(.+\\)" 2)
("^Text conflict in \\(.+\\)" 1 nil nil 2)
("^Using saved parent location: \\(.+\\)" 1 nil nil 0))
state."
(let (file status missing)
(goto-char (point-min))
- (while (looking-at "? \\(.*\\)")
+ (while (looking-at "\\? \\(.*\\)")
(setq file (expand-file-name (match-string 1)))
(vc-file-setprop file 'vc-state 'unregistered)
(forward-line 1))
(t ; Ignore -- leave in buffer
;; This does not work too well, but it's only for debugging!
(skip-chars-forward "^ \t")
- (if (looking-at "[ \t]*\\{") (search-forward "\\}"))
+ (if (looking-at "[ \t]*{") (search-forward "}"))
(forward-line 1))))
;; request is not used dynamically by any callees.
;; Ignore -- leave in buffer
;; This does not work too well, but it's only for debugging!
(skip-chars-forward "^ \t")
- (if (looking-at "[ \t]*\\{") (search-forward "\\}"))
+ (if (looking-at "[ \t]*{") (search-forward "}"))
(forward-line 1)))
(defun woman0-so ()
(while
;; Find font requests, paragraph macros and font escapes:
(re-search-forward
- "^[.'][ \t]*\\(\\(\\ft\\)\\|\\(.P\\)\\)\\|\\(\\\\f\\)" nil 1)
+ "^[.'][ \t]*\\(\\(ft\\)\\|\\(.P\\)\\)\\|\\(\\\\f\\)" nil 1)
(let (font beg notfont fescape)
;; Match font indicator and leave point at end of sequence:
(cond ((match-beginning 2)
(defun xdg--substitute-home-env (str)
(if (file-name-absolute-p str) str
(save-match-data
- (and (string-match "^$HOME/" str)
+ (and (string-match "^\\$HOME/" str)
(replace-match "~/" t nil str 0)))))
(defun xdg--user-dirs-parse-line ()
projects / emacs.git / commitdiff