* lisp/progmodes/f90.el (f90-mode-syntax-table): Use symbol syntax for "_".
Change all regexps to use things like \_< and \_>. * lisp/progmodes/ada-mode.el (ada-mode-abbrev-table): Consolidate declaration. (ada-mode-syntax-table, ada-mode-symbol-syntax-table): Initialize in the declaration. (ada-create-syntax-table): Remove. (ada-capitalize-word): Don't mess with the syntax of "_" since it already has the right syntax nowadays. (ada-goto-next-word): Don't change the syntax of "_". * lisp/progmodes/autoconf.el (autoconf-definition-regexp) (autoconf-font-lock-keywords, autoconf-current-defun-function): Handle a _ with symbol syntax. (autoconf-mode): Don't change the syntax-table for imenu and font-lock. * lisp/progmodes/vera-mode.el (vera-underscore-is-part-of-word): * lisp/progmodes/prolog.el (prolog-underscore-wordchar-flag) (prolog-char-quote-workaround): * lisp/progmodes/cperl-mode.el (cperl-under-as-char): * lisp/progmodes/vhdl-mode.el (vhdl-underscore-is-part-of-word): Mark as obsolete. (vhdl-mode-syntax-table, vhdl-mode-ext-syntax-table): Initialize in their declaration. (vhdl-mode-syntax-table-init): Remove. * lisp/progmodes/ld-script.el (ld-script-mode-syntax-table): Use symbol syntax for "_". (ld-script-font-lock-keywords): Change regexps to use things like \_< and \_>. * lisp/progmodes/m4-mode.el (m4-mode-syntax-table): Add comment on last change. * lisp/font-lock.el (lisp-font-lock-keywords-2): Don't highlight obsolete with-wrapper-hook. * lisp/mh-e/mh-comp.el (mh-regexp-in-field-p): Minor simplification.
This commit is contained in:
Stefan Monnier
parent
86cec47883
commit
1d5963cc63
15 changed files with 307 additions and 286 deletions
|
|
@ -1,3 +1,41 @@
|
|||
2013-05-08 Stefan Monnier <monnier@iro.umontreal.ca>
|
||||
|
||||
* progmodes/vera-mode.el (vera-underscore-is-part-of-word):
|
||||
* progmodes/prolog.el (prolog-underscore-wordchar-flag)
|
||||
(prolog-char-quote-workaround):
|
||||
* progmodes/cperl-mode.el (cperl-under-as-char):
|
||||
* progmodes/vhdl-mode.el (vhdl-underscore-is-part-of-word):
|
||||
Mark as obsolete.
|
||||
(vhdl-mode-syntax-table, vhdl-mode-ext-syntax-table): Initialize in
|
||||
their declaration.
|
||||
(vhdl-mode-syntax-table-init): Remove.
|
||||
|
||||
* progmodes/m4-mode.el (m4-mode-syntax-table): Add comment on last change.
|
||||
|
||||
* progmodes/ld-script.el (ld-script-mode-syntax-table): Use symbol
|
||||
syntax for "_".
|
||||
(ld-script-font-lock-keywords):
|
||||
Change regexps to use things like \_< and \_>.
|
||||
|
||||
* progmodes/f90.el (f90-mode-syntax-table): Use symbol syntax for "_".
|
||||
Change all regexps to use things like \_< and \_>.
|
||||
|
||||
* progmodes/autoconf.el (autoconf-definition-regexp)
|
||||
(autoconf-font-lock-keywords, autoconf-current-defun-function):
|
||||
Handle a _ with symbol syntax.
|
||||
(autoconf-mode): Don't change the syntax-table for imenu and font-lock.
|
||||
|
||||
* progmodes/ada-mode.el (ada-mode-abbrev-table): Consolidate declaration.
|
||||
(ada-mode-syntax-table, ada-mode-symbol-syntax-table): Initialize in
|
||||
the declaration.
|
||||
(ada-create-syntax-table): Remove.
|
||||
(ada-capitalize-word): Don't mess with the syntax of "_" since it
|
||||
already has the right syntax nowadays.
|
||||
(ada-goto-next-word): Don't change the syntax of "_".
|
||||
|
||||
* font-lock.el (lisp-font-lock-keywords-2): Don't highlight obsolete
|
||||
with-wrapper-hook.
|
||||
|
||||
2013-05-08 Sam Steingold <sds@gnu.org>
|
||||
|
||||
* thingatpt.el (thing-at-point): Accept optional second argument
|
||||
|
|
|
|||
|
|
@ -2298,7 +2298,7 @@ in which C preprocessor directives are used. e.g. `asm-mode' and
|
|||
"with-selected-window" "with-selected-frame"
|
||||
"with-silent-modifications" "with-syntax-table"
|
||||
"with-temp-buffer" "with-temp-file" "with-temp-message"
|
||||
"with-timeout" "with-timeout-handler" "with-wrapper-hook") t)
|
||||
"with-timeout" "with-timeout-handler") t)
|
||||
"\\_>")
|
||||
. 1)
|
||||
;; Control structures. Common Lisp forms.
|
||||
|
|
|
|||
|
|
@ -1,3 +1,7 @@
|
|||
2013-05-08 Stefan Monnier <monnier@iro.umontreal.ca>
|
||||
|
||||
* mh-comp.el (mh-regexp-in-field-p): Minor simplification.
|
||||
|
||||
2013-03-02 Bill Wohler <wohler@newt.com>
|
||||
|
||||
Release MH-E version 8.5.
|
||||
|
|
|
|||
|
|
@ -1205,17 +1205,17 @@ discarded."
|
|||
(let ((search-result nil))
|
||||
(while fields
|
||||
(let ((field (car fields))
|
||||
(syntax-table mh-regexp-in-field-syntax-table))
|
||||
(if (null syntax-table)
|
||||
(let ((case-fold-search t))
|
||||
(cond
|
||||
((string-match field "^To$\\|^[BD]?cc$\\|^From$")
|
||||
(setq syntax-table mh-addr-syntax-table))
|
||||
((string-match field "^Fcc$")
|
||||
(setq syntax-table mh-fcc-syntax-table))
|
||||
(t
|
||||
(setq syntax-table (syntax-table)))
|
||||
)))
|
||||
(syntax-table
|
||||
(or mh-regexp-in-field-syntax-table
|
||||
(let ((case-fold-search t))
|
||||
(cond
|
||||
((string-match field "^To$\\|^[BD]?cc$\\|^From$")
|
||||
mh-addr-syntax-table)
|
||||
((string-match field "^Fcc$")
|
||||
mh-fcc-syntax-table)
|
||||
(t
|
||||
(syntax-table)))
|
||||
))))
|
||||
(if (and (mh-goto-header-field field)
|
||||
(set-syntax-table syntax-table)
|
||||
(re-search-forward
|
||||
|
|
|
|||
|
|
@ -457,15 +457,8 @@ The extensions should include a `.' if needed.")
|
|||
(defvar ada-mode-extra-prefix "\C-c\C-q"
|
||||
"Prefix key to access `ada-mode-extra-map' functions.")
|
||||
|
||||
(defvar ada-mode-abbrev-table nil
|
||||
(define-abbrev-table 'ada-mode-abbrev-table ()
|
||||
"Local abbrev table for Ada mode.")
|
||||
(define-abbrev-table 'ada-mode-abbrev-table ())
|
||||
|
||||
(defvar ada-mode-syntax-table nil
|
||||
"Syntax table to be used for editing Ada source code.")
|
||||
|
||||
(defvar ada-mode-symbol-syntax-table nil
|
||||
"Syntax table for Ada, where `_' is a word constituent.")
|
||||
|
||||
(eval-when-compile
|
||||
;; These values are used in eval-when-compile expressions.
|
||||
|
|
@ -845,61 +838,58 @@ the 4 file locations can be clicked on and jumped to."
|
|||
;; better is available on XEmacs.
|
||||
;;-------------------------------------------------------------------------
|
||||
|
||||
(defun ada-create-syntax-table ()
|
||||
"Create the two syntax tables use in the Ada mode.
|
||||
The standard table declares `_' as a symbol constituent, the second one
|
||||
declares it as a word constituent."
|
||||
(interactive)
|
||||
(setq ada-mode-syntax-table (make-syntax-table))
|
||||
(defvar ada-mode-syntax-table
|
||||
(let ((st (make-syntax-table)))
|
||||
;; Define string brackets (`%' is alternative string bracket, but
|
||||
;; almost never used as such and throws font-lock and indentation
|
||||
;; off the track.)
|
||||
(modify-syntax-entry ?% "$" st)
|
||||
(modify-syntax-entry ?\" "\"" st)
|
||||
|
||||
;; define string brackets (`%' is alternative string bracket, but
|
||||
;; almost never used as such and throws font-lock and indentation
|
||||
;; off the track.)
|
||||
(modify-syntax-entry ?% "$" ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\" "\"" ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?: "." st)
|
||||
(modify-syntax-entry ?\; "." st)
|
||||
(modify-syntax-entry ?& "." st)
|
||||
(modify-syntax-entry ?\| "." st)
|
||||
(modify-syntax-entry ?+ "." st)
|
||||
(modify-syntax-entry ?* "." st)
|
||||
(modify-syntax-entry ?/ "." st)
|
||||
(modify-syntax-entry ?= "." st)
|
||||
(modify-syntax-entry ?< "." st)
|
||||
(modify-syntax-entry ?> "." st)
|
||||
(modify-syntax-entry ?$ "." st)
|
||||
(modify-syntax-entry ?\[ "." st)
|
||||
(modify-syntax-entry ?\] "." st)
|
||||
(modify-syntax-entry ?\{ "." st)
|
||||
(modify-syntax-entry ?\} "." st)
|
||||
(modify-syntax-entry ?. "." st)
|
||||
(modify-syntax-entry ?\\ "." st)
|
||||
(modify-syntax-entry ?\' "." st)
|
||||
|
||||
(modify-syntax-entry ?: "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\; "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?& "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\| "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?+ "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?* "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?/ "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?= "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?< "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?> "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?$ "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\[ "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\] "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\{ "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\} "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?. "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\\ "." ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\' "." ada-mode-syntax-table)
|
||||
;; A single hyphen is punctuation, but a double hyphen starts a comment.
|
||||
(modify-syntax-entry ?- ". 12" st)
|
||||
|
||||
;; a single hyphen is punctuation, but a double hyphen starts a comment
|
||||
(modify-syntax-entry ?- ". 12" ada-mode-syntax-table)
|
||||
;; See the comment above on grammar related function for the special
|
||||
;; setup for '#'.
|
||||
(modify-syntax-entry ?# (if (featurep 'xemacs) "<" "$") st)
|
||||
|
||||
;; See the comment above on grammar related function for the special
|
||||
;; setup for '#'.
|
||||
(if (featurep 'xemacs)
|
||||
(modify-syntax-entry ?# "<" ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?# "$" ada-mode-syntax-table))
|
||||
;; And \f and \n end a comment.
|
||||
(modify-syntax-entry ?\f "> " st)
|
||||
(modify-syntax-entry ?\n "> " st)
|
||||
|
||||
;; and \f and \n end a comment
|
||||
(modify-syntax-entry ?\f "> " ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\n "> " ada-mode-syntax-table)
|
||||
;; Define what belongs in Ada symbols.
|
||||
(modify-syntax-entry ?_ "_" st)
|
||||
|
||||
;; define what belongs in Ada symbols
|
||||
(modify-syntax-entry ?_ "_" ada-mode-syntax-table)
|
||||
;; Define parentheses to match.
|
||||
(modify-syntax-entry ?\( "()" st)
|
||||
(modify-syntax-entry ?\) ")(" st)
|
||||
st)
|
||||
"Syntax table to be used for editing Ada source code.")
|
||||
|
||||
;; define parentheses to match
|
||||
(modify-syntax-entry ?\( "()" ada-mode-syntax-table)
|
||||
(modify-syntax-entry ?\) ")(" ada-mode-syntax-table)
|
||||
|
||||
(setq ada-mode-symbol-syntax-table (copy-syntax-table ada-mode-syntax-table))
|
||||
(modify-syntax-entry ?_ "w" ada-mode-symbol-syntax-table)
|
||||
)
|
||||
(defvar ada-mode-symbol-syntax-table
|
||||
(let ((st (make-syntax-table ada-mode-syntax-table)))
|
||||
(modify-syntax-entry ?_ "w" st)
|
||||
st)
|
||||
"Syntax table for Ada, where `_' is a word constituent.")
|
||||
|
||||
;; Support of special characters in XEmacs (see the comments at the beginning
|
||||
;; of the section on Grammar related functions).
|
||||
|
|
@ -1293,7 +1283,7 @@ the file name."
|
|||
(if ada-popup-key
|
||||
(define-key ada-mode-map ada-popup-key 'ada-popup-menu))
|
||||
|
||||
;; Support for Abbreviations (the user still need to "M-x abbrev-mode"
|
||||
;; Support for Abbreviations (the user still needs to "M-x abbrev-mode").
|
||||
(setq local-abbrev-table ada-mode-abbrev-table)
|
||||
|
||||
;; Support for which-function mode
|
||||
|
|
@ -1625,9 +1615,8 @@ ARG is the prefix the user entered with \\[universal-argument]."
|
|||
(let ((lastk last-command-event))
|
||||
|
||||
(with-syntax-table ada-mode-symbol-syntax-table
|
||||
(cond ((or (eq lastk ?\n)
|
||||
(eq lastk ?\r))
|
||||
;; horrible kludge
|
||||
(cond ((memq lastk '(?\n ?\r))
|
||||
;; Horrible kludge.
|
||||
(insert " ")
|
||||
(ada-adjust-case)
|
||||
;; horrible dekludge
|
||||
|
|
@ -1706,9 +1695,7 @@ ARG is ignored, and is there for compatibility with `capitalize-word' only."
|
|||
(interactive)
|
||||
(let ((end (save-excursion (skip-syntax-forward "w") (point)))
|
||||
(begin (save-excursion (skip-syntax-backward "w") (point))))
|
||||
(modify-syntax-entry ?_ "_")
|
||||
(capitalize-region begin end)
|
||||
(modify-syntax-entry ?_ "w")))
|
||||
(capitalize-region begin end)))
|
||||
|
||||
(defun ada-adjust-case-region (from to)
|
||||
"Adjust the case of all words in the region between FROM and TO.
|
||||
|
|
@ -2165,7 +2152,7 @@ and the offset."
|
|||
(unwind-protect
|
||||
(with-syntax-table ada-mode-symbol-syntax-table
|
||||
|
||||
;; This need to be done here so that the advice is not always
|
||||
;; This needs to be done here so that the advice is not always
|
||||
;; activated (this might interact badly with other modes)
|
||||
(if (featurep 'xemacs)
|
||||
(ad-activate 'parse-partial-sexp t))
|
||||
|
|
@ -3419,27 +3406,23 @@ Stop the search at LIMIT."
|
|||
If BACKWARD is non-nil, jump to the beginning of the previous word.
|
||||
Return the new position of point or nil if not found."
|
||||
(let ((match-cons nil)
|
||||
(orgpoint (point))
|
||||
(old-syntax (char-to-string (char-syntax ?_))))
|
||||
(modify-syntax-entry ?_ "w")
|
||||
(orgpoint (point)))
|
||||
(unless backward
|
||||
(skip-syntax-forward "w"))
|
||||
(skip-syntax-forward "w_"))
|
||||
(if (setq match-cons
|
||||
(ada-search-ignore-string-comment "\\w" backward nil t))
|
||||
(ada-search-ignore-string-comment "\\sw\\|\\s_" backward nil t))
|
||||
;;
|
||||
;; move to the beginning of the word found
|
||||
;;
|
||||
(progn
|
||||
(goto-char (car match-cons))
|
||||
(skip-syntax-backward "w")
|
||||
(skip-syntax-backward "w_")
|
||||
(point))
|
||||
;;
|
||||
;; if not found, restore old position of point
|
||||
;;
|
||||
(goto-char orgpoint)
|
||||
'nil)
|
||||
(modify-syntax-entry ?_ old-syntax))
|
||||
)
|
||||
'nil)))
|
||||
|
||||
|
||||
(defun ada-check-matching-start (keyword)
|
||||
|
|
@ -5431,9 +5414,6 @@ This function typically is to be hooked into `ff-file-created-hook'."
|
|||
(ada-create-keymap)
|
||||
(ada-create-menu)
|
||||
|
||||
;; Create the syntax tables, but do not activate them
|
||||
(ada-create-syntax-table)
|
||||
|
||||
;; Add the default extensions (and set up speedbar)
|
||||
(ada-add-extensions ".ads" ".adb")
|
||||
;; This two files are generated by GNAT when running with -gnatD
|
||||
|
|
|
|||
|
|
@ -41,10 +41,10 @@
|
|||
"Hook run by `autoconf-mode'.")
|
||||
|
||||
(defconst autoconf-definition-regexp
|
||||
"A\\(?:H_TEMPLATE\\|C_\\(?:SUBST\\|DEFINE\\(?:_UNQUOTED\\)?\\)\\)(\\[*\\(\\sw+\\)\\]*")
|
||||
"A\\(?:H_TEMPLATE\\|C_\\(?:SUBST\\|DEFINE\\(?:_UNQUOTED\\)?\\)\\)(\\[*\\(\\(?:\\sw\\|\\s_\\)+\\)\\]*")
|
||||
|
||||
(defvar autoconf-font-lock-keywords
|
||||
`(("\\_<A[CHMS]_\\sw+" . font-lock-keyword-face)
|
||||
`(("\\_<A[CHMS]_\\(?:\\sw\\|\\s_\\)+" . font-lock-keyword-face)
|
||||
(,autoconf-definition-regexp
|
||||
1 font-lock-function-name-face)
|
||||
;; Are any other M4 keywords really appropriate for configure.ac,
|
||||
|
|
@ -67,13 +67,11 @@
|
|||
This version looks back for an AC_DEFINE or AC_SUBST. It will stop
|
||||
searching backwards at another AC_... command."
|
||||
(save-excursion
|
||||
(with-syntax-table (copy-syntax-table autoconf-mode-syntax-table)
|
||||
(modify-syntax-entry ?_ "w")
|
||||
(skip-syntax-forward "w" (line-end-position))
|
||||
(if (re-search-backward autoconf-definition-regexp
|
||||
(save-excursion (beginning-of-defun) (point))
|
||||
t)
|
||||
(match-string-no-properties 1)))))
|
||||
(skip-syntax-forward "w_" (line-end-position))
|
||||
(if (re-search-backward autoconf-definition-regexp
|
||||
(save-excursion (beginning-of-defun) (point))
|
||||
t)
|
||||
(match-string-no-properties 1))))
|
||||
|
||||
;;;###autoload
|
||||
(define-derived-mode autoconf-mode prog-mode "Autoconf"
|
||||
|
|
@ -85,9 +83,8 @@ searching backwards at another AC_... command."
|
|||
(setq-local syntax-propertize-function
|
||||
(syntax-propertize-rules ("\\<dnl\\>" (0 "<"))))
|
||||
(setq-local font-lock-defaults
|
||||
`(autoconf-font-lock-keywords nil nil (("_" . "w"))))
|
||||
`(autoconf-font-lock-keywords nil nil))
|
||||
(setq-local imenu-generic-expression autoconf-imenu-generic-expression)
|
||||
(setq-local imenu-syntax-alist '(("_" . "w")))
|
||||
(setq-local indent-line-function #'indent-relative)
|
||||
(setq-local add-log-current-defun-function
|
||||
#'autoconf-current-defun-function))
|
||||
|
|
|
|||
|
|
@ -565,6 +565,7 @@ If nil, the value of `cperl-indent-level' will be used."
|
|||
"*Non-nil means that the _ (underline) should be treated as word char."
|
||||
:type 'boolean
|
||||
:group 'cperl)
|
||||
(make-obsolete-variable 'cperl-under-as-char 'superword-mode "24.4")
|
||||
|
||||
(defcustom cperl-extra-perl-args ""
|
||||
"*Extra arguments to use when starting Perl.
|
||||
|
|
|
|||
|
|
@ -367,7 +367,7 @@ The options are 'downcase-word, 'upcase-word, 'capitalize-word and nil."
|
|||
"Keyword-regexp for font-lock level >= 3.")
|
||||
|
||||
(defconst f90-procedures-re
|
||||
(concat "\\<"
|
||||
(concat "\\_<"
|
||||
(regexp-opt
|
||||
'("abs" "achar" "acos" "adjustl" "adjustr" "aimag" "aint"
|
||||
"all" "allocated" "anint" "any" "asin" "associated"
|
||||
|
|
@ -491,16 +491,16 @@ The options are 'downcase-word, 'upcase-word, 'capitalize-word and nil."
|
|||
Set the match data so that subexpression 1,2 are the TYPE, and
|
||||
type-name parts, respectively."
|
||||
(let (found l)
|
||||
(while (and (re-search-forward "\\<\\(\\(?:end[ \t]*\\)?type\\)\\>[ \t]*"
|
||||
(while (and (re-search-forward "\\_<\\(\\(?:end[ \t]*\\)?type\\)\\_>[ \t]*"
|
||||
limit t)
|
||||
(not (setq found
|
||||
(progn
|
||||
(setq l (match-data))
|
||||
(unless (looking-at "\\(is\\>\\|(\\)")
|
||||
(when (if (looking-at "\\(\\sw+\\)")
|
||||
(unless (looking-at "\\(is\\_>\\|(\\)")
|
||||
(when (if (looking-at "\\(\\(?:\\sw\\|\\s_\\)+\\)")
|
||||
(goto-char (match-end 0))
|
||||
(re-search-forward
|
||||
"[ \t]*::[ \t]*\\(\\sw+\\)"
|
||||
"[ \t]*::[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)"
|
||||
(line-end-position) t))
|
||||
;; 0 is wrong, but we don't use it.
|
||||
(set-match-data
|
||||
|
|
@ -512,33 +512,33 @@ type-name parts, respectively."
|
|||
(defvar f90-font-lock-keywords-1
|
||||
(list
|
||||
;; Special highlighting of "module procedure".
|
||||
'("\\<\\(module[ \t]*procedure\\)\\>\\([^()\n]*::\\)?[ \t]*\\([^&!\n]*\\)"
|
||||
'("\\_<\\(module[ \t]*procedure\\)\\_>\\([^()\n]*::\\)?[ \t]*\\([^&!\n]*\\)"
|
||||
(1 font-lock-keyword-face) (3 font-lock-function-name-face nil t))
|
||||
;; Highlight definition of derived type.
|
||||
;;; '("\\<\\(\\(?:end[ \t]*\\)?type\\)\\>\\([^()\n]*::\\)?[ \t]*\\(\\sw+\\)"
|
||||
;;; '("\\_<\\(\\(?:end[ \t]*\\)?type\\)\\_>\\([^()\n]*::\\)?[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)"
|
||||
;;; (1 font-lock-keyword-face) (3 font-lock-function-name-face))
|
||||
'(f90-typedef-matcher
|
||||
(1 font-lock-keyword-face) (2 font-lock-function-name-face))
|
||||
;; F2003. Prevent operators being highlighted as functions.
|
||||
'("\\<\\(\\(?:end[ \t]*\\)?interface[ \t]*\\(?:assignment\\|operator\\|\
|
||||
'("\\_<\\(\\(?:end[ \t]*\\)?interface[ \t]*\\(?:assignment\\|operator\\|\
|
||||
read\\|write\\)\\)[ \t]*(" (1 font-lock-keyword-face t))
|
||||
;; Other functions and declarations. Named interfaces = F2003.
|
||||
;; F2008: end submodule submodule_name.
|
||||
'("\\<\\(\\(?:end[ \t]*\\)?\\(program\\|\\(?:sub\\)?module\\|\
|
||||
'("\\_<\\(\\(?:end[ \t]*\\)?\\(program\\|\\(?:sub\\)?module\\|\
|
||||
function\\|associate\\|subroutine\\|interface\\)\\|use\\|call\\)\
|
||||
\\>[ \t]*\\(\\sw+\\)?"
|
||||
\\_>[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?"
|
||||
(1 font-lock-keyword-face) (3 font-lock-function-name-face nil t))
|
||||
;; F2008: submodule (parent_name) submodule_name.
|
||||
'("\\<\\(submodule\\)\\>[ \t]*([^)\n]+)[ \t]*\\(\\sw+\\)?"
|
||||
'("\\_<\\(submodule\\)\\_>[ \t]*([^)\n]+)[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?"
|
||||
(1 font-lock-keyword-face) (2 font-lock-function-name-face nil t))
|
||||
;; F2003.
|
||||
'("\\<\\(use\\)[ \t]*,[ \t]*\\(\\(?:non_\\)?intrinsic\\)[ \t]*::[ \t]*\
|
||||
\\(\\sw+\\)"
|
||||
'("\\_<\\(use\\)[ \t]*,[ \t]*\\(\\(?:non_\\)?intrinsic\\)[ \t]*::[ \t]*\
|
||||
\\(\\(?:\\sw\\|\\s_\\)+\\)"
|
||||
(1 font-lock-keyword-face) (2 font-lock-keyword-face)
|
||||
(3 font-lock-function-name-face))
|
||||
"\\<\\(\\(end[ \t]*\\)?block[ \t]*data\\|contains\\)\\>"
|
||||
"\\_<\\(\\(end[ \t]*\\)?block[ \t]*data\\|contains\\)\\_>"
|
||||
;; "abstract interface" is F2003.
|
||||
'("\\<abstract[ \t]*interface\\>" (0 font-lock-keyword-face t)))
|
||||
'("\\_<abstract[ \t]*interface\\_>" (0 font-lock-keyword-face t)))
|
||||
"This does fairly subdued highlighting of comments and function calls.")
|
||||
|
||||
;; NB not explicitly handling this, yet it seems to work.
|
||||
|
|
@ -550,7 +550,7 @@ and variable-name parts, respectively."
|
|||
;; Matcher functions must return nil only when there are no more
|
||||
;; matches within the search range.
|
||||
(let (found l)
|
||||
(while (and (re-search-forward "\\<\\(type\\|class\\)[ \t]*(" limit t)
|
||||
(while (and (re-search-forward "\\_<\\(type\\|class\\)[ \t]*(" limit t)
|
||||
(not
|
||||
(setq found
|
||||
(condition-case nil
|
||||
|
|
@ -565,7 +565,7 @@ and variable-name parts, respectively."
|
|||
(when
|
||||
(re-search-forward
|
||||
;; type (foo) bar, qux
|
||||
(if (looking-at "\\sw+")
|
||||
(if (looking-at "\\(?:\\sw\\|\\s_\\)+")
|
||||
"\\([^&!\n]+\\)"
|
||||
;; type (foo), stuff :: bar, qux
|
||||
"::[ \t]*\\([^&!\n]+\\)")
|
||||
|
|
@ -608,53 +608,53 @@ enumerator\\|generic\\|procedure\\|logical\\|double[ \t]*precision\\)\
|
|||
;; integer( kind=1 ) function foo()
|
||||
;; thanks to the happy accident described above.
|
||||
;; Not anchored, so don't need to worry about "pure" etc.
|
||||
'("\\<\\(\\(real\\|integer\\|c\\(haracter\\|omplex\\)\\|\
|
||||
'("\\_<\\(\\(real\\|integer\\|c\\(haracter\\|omplex\\)\\|\
|
||||
logical\\|double[ \t]*precision\\|\
|
||||
\\(?:type\\|class\\)[ \t]*([ \t]*\\sw+[ \t]*)\\)[ \t]*\\)\
|
||||
\\(function\\)\\>[ \t]*\\(\\sw+\\)[ \t]*\\(([^&!\n]*)\\)"
|
||||
\\(?:type\\|class\\)[ \t]*([ \t]*\\(?:\\sw\\|\\s_\\)+[ \t]*)\\)[ \t]*\\)\
|
||||
\\(function\\)\\_>[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*\\(([^&!\n]*)\\)"
|
||||
(1 font-lock-type-face t) (4 font-lock-keyword-face t)
|
||||
(5 font-lock-function-name-face t) (6 'default t))
|
||||
;; enum (F2003; must be followed by ", bind(C)").
|
||||
'("\\<\\(enum\\)[ \t]*," (1 font-lock-keyword-face))
|
||||
'("\\_<\\(enum\\)[ \t]*," (1 font-lock-keyword-face))
|
||||
;; end do, enum (F2003), if, select, where, and forall constructs.
|
||||
;; block, critical (F2008).
|
||||
;; Note that "block data" may get somewhat mixed up with F2008 blocks,
|
||||
;; but since the former is obsolete I'm not going to worry about it.
|
||||
'("\\<\\(end[ \t]*\\(do\\|if\\|enum\\|select\\|forall\\|where\\|\
|
||||
block\\|critical\\)\\)\\>\
|
||||
\\([ \t]+\\(\\sw+\\)\\)?"
|
||||
'("\\_<\\(end[ \t]*\\(do\\|if\\|enum\\|select\\|forall\\|where\\|\
|
||||
block\\|critical\\)\\)\\_>\
|
||||
\\([ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?"
|
||||
(1 font-lock-keyword-face) (3 font-lock-constant-face nil t))
|
||||
'("^[ \t0-9]*\\(\\(\\sw+\\)[ \t]*:[ \t]*\\)?\\(\\(if\\|\
|
||||
'("^[ \t0-9]*\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:[ \t]*\\)?\\(\\(if\\|\
|
||||
do\\([ \t]*while\\)?\\|select[ \t]*\\(?:case\\|type\\)\\|where\\|\
|
||||
forall\\|block\\|critical\\)\\)\\>"
|
||||
forall\\|block\\|critical\\)\\)\\_>"
|
||||
(2 font-lock-constant-face nil t) (3 font-lock-keyword-face))
|
||||
;; Implicit declaration.
|
||||
'("\\<\\(implicit\\)[ \t]*\\(real\\|integer\\|c\\(haracter\\|omplex\\)\
|
||||
'("\\_<\\(implicit\\)[ \t]*\\(real\\|integer\\|c\\(haracter\\|omplex\\)\
|
||||
\\|enumerator\\|procedure\\|\
|
||||
logical\\|double[ \t]*precision\\|type[ \t]*(\\sw+)\\|none\\)[ \t]*"
|
||||
logical\\|double[ \t]*precision\\|type[ \t]*(\\(?:\\sw\\|\\s_\\)+)\\|none\\)[ \t]*"
|
||||
(1 font-lock-keyword-face) (2 font-lock-type-face))
|
||||
'("\\<\\(namelist\\|common\\)[ \t]*\/\\(\\sw+\\)?\/"
|
||||
'("\\_<\\(namelist\\|common\\)[ \t]*\/\\(\\(?:\\sw\\|\\s_\\)+\\)?\/"
|
||||
(1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
|
||||
"\\<else\\([ \t]*if\\|where\\)?\\>"
|
||||
"\\_<else\\([ \t]*if\\|where\\)?\\_>"
|
||||
'("\\(&\\)[ \t]*\\(!\\|$\\)" (1 font-lock-keyword-face))
|
||||
"\\<\\(then\\|continue\\|format\\|include\\|stop\\|return\\)\\>"
|
||||
'("\\<\\(exit\\|cycle\\)[ \t]*\\(\\sw+\\)?\\>"
|
||||
"\\_<\\(then\\|continue\\|format\\|include\\|stop\\|return\\)\\_>"
|
||||
'("\\_<\\(exit\\|cycle\\)[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?\\_>"
|
||||
(1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
|
||||
'("\\<\\(case\\)[ \t]*\\(default\\|(\\)" . 1)
|
||||
'("\\_<\\(case\\)[ \t]*\\(default\\|(\\)" . 1)
|
||||
;; F2003 "class default".
|
||||
'("\\<\\(class\\)[ \t]*default" . 1)
|
||||
'("\\_<\\(class\\)[ \t]*default" . 1)
|
||||
;; F2003 "type is" in a "select type" block.
|
||||
'("\\<\\(\\(type\\|class\\)[ \t]*is\\)[ \t]*(" (1 font-lock-keyword-face t))
|
||||
'("\\<\\(do\\|go[ \t]*to\\)\\>[ \t]*\\([0-9]+\\)"
|
||||
'("\\_<\\(\\(type\\|class\\)[ \t]*is\\)[ \t]*(" (1 font-lock-keyword-face t))
|
||||
'("\\_<\\(do\\|go[ \t]*to\\)\\_>[ \t]*\\([0-9]+\\)"
|
||||
(1 font-lock-keyword-face) (2 font-lock-constant-face))
|
||||
;; Line numbers (lines whose first character after number is letter).
|
||||
'("^[ \t]*\\([0-9]+\\)[ \t]*[a-z]+" (1 font-lock-constant-face t))
|
||||
;; Override eg for "#include".
|
||||
'("^#[ \t]*\\w+" (0 font-lock-preprocessor-face t)
|
||||
("\\<defined\\>" nil nil (0 font-lock-preprocessor-face)))
|
||||
'("^#[ \t]*\\(?:\\sw\\|\\s_\\)+" (0 font-lock-preprocessor-face t)
|
||||
("\\_<defined\\_>" nil nil (0 font-lock-preprocessor-face)))
|
||||
'("^#" ("\\(&&\\|||\\)" nil nil (0 font-lock-constant-face t)))
|
||||
'("^#[ \t]*define[ \t]+\\(\\w+\\)(" (1 font-lock-function-name-face))
|
||||
'("^#[ \t]*define[ \t]+\\(\\w+\\)" (1 font-lock-variable-name-face))
|
||||
'("^#[ \t]*define[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)(" (1 font-lock-function-name-face))
|
||||
'("^#[ \t]*define[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)" (1 font-lock-variable-name-face))
|
||||
'("^#[ \t]*include[ \t]+\\(<.+>\\)" (1 font-lock-string-face))))
|
||||
"Highlights declarations, do-loops and other constructs.")
|
||||
|
||||
|
|
@ -666,9 +666,9 @@ logical\\|double[ \t]*precision\\|type[ \t]*(\\sw+)\\|none\\)[ \t]*"
|
|||
;; FIXME why isn't this font-lock-builtin-face, which
|
||||
;; otherwise we hardly use, as in fortran.el?
|
||||
(list f90-procedures-re '(1 font-lock-keyword-face keep))
|
||||
"\\<real\\>" ; avoid overwriting real defs
|
||||
"\\_<real\\_>" ; avoid overwriting real defs
|
||||
;; As an attribute, but not as an optional argument.
|
||||
'("\\<\\(asynchronous\\)[ \t]*[^=]" . 1)))
|
||||
'("\\_<\\(asynchronous\\)[ \t]*[^=]" . 1)))
|
||||
"Highlights all F90 keywords and intrinsic procedures.")
|
||||
|
||||
(defvar f90-font-lock-keywords-4
|
||||
|
|
@ -687,8 +687,7 @@ Can be overridden by the value of `font-lock-maximum-decoration'.")
|
|||
(let ((table (make-syntax-table)))
|
||||
(modify-syntax-entry ?\! "<" table) ; begin comment
|
||||
(modify-syntax-entry ?\n ">" table) ; end comment
|
||||
;; FIXME: This goes against the convention: it should be "_".
|
||||
(modify-syntax-entry ?_ "w" table) ; underscore in names
|
||||
(modify-syntax-entry ?_ "_" table) ; underscore in names
|
||||
(modify-syntax-entry ?\' "\"" table) ; string quote
|
||||
(modify-syntax-entry ?\" "\"" table) ; string quote
|
||||
;; FIXME: We used to set ` to word syntax for the benefit of abbrevs, but
|
||||
|
|
@ -850,7 +849,7 @@ Can be overridden by the value of `font-lock-maximum-decoration'.")
|
|||
"enum" "associate"
|
||||
;; F2008.
|
||||
"submodule" "block" "critical"))
|
||||
"\\)\\>")
|
||||
"\\)\\_>")
|
||||
"Regexp potentially indicating a \"block\" of F90 code.")
|
||||
|
||||
(defconst f90-program-block-re
|
||||
|
|
@ -866,15 +865,15 @@ Can be overridden by the value of `font-lock-maximum-decoration'.")
|
|||
(defconst f90-end-if-re
|
||||
(concat "end[ \t]*"
|
||||
(regexp-opt '("if" "select" "where" "forall") 'paren)
|
||||
"\\>")
|
||||
"\\_>")
|
||||
"Regexp matching the end of an IF, SELECT, WHERE, FORALL block.")
|
||||
|
||||
(defconst f90-end-type-re
|
||||
"end[ \t]*\\(type\\|enum\\|interface\\|block[ \t]*data\\)\\>"
|
||||
"end[ \t]*\\(type\\|enum\\|interface\\|block[ \t]*data\\)\\_>"
|
||||
"Regexp matching the end of a TYPE, ENUM, INTERFACE, BLOCK DATA section.")
|
||||
|
||||
(defconst f90-end-associate-re
|
||||
"end[ \t]*associate\\>"
|
||||
"end[ \t]*associate\\_>"
|
||||
"Regexp matching the end of an ASSOCIATE block.")
|
||||
|
||||
;; This is for a TYPE block, not a variable of derived TYPE.
|
||||
|
|
@ -885,12 +884,12 @@ Can be overridden by the value of `font-lock-maximum-decoration'.")
|
|||
;; type, stuff :: word
|
||||
;; type, bind(c) :: word
|
||||
;; NOT "type ("
|
||||
"\\<\\(type\\)\\>\\(?:\\(?:[^()\n]*\\|\
|
||||
.*,[ \t]*bind[ \t]*([ \t]*c[ \t]*)[ \t]*\\)::\\)?[ \t]*\\(\\sw+\\)"
|
||||
"\\_<\\(type\\)\\_>\\(?:\\(?:[^()\n]*\\|\
|
||||
.*,[ \t]*bind[ \t]*([ \t]*c[ \t]*)[ \t]*\\)::\\)?[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)"
|
||||
"Regexp matching the definition of a derived type.")
|
||||
|
||||
(defconst f90-typeis-re
|
||||
"\\<\\(class\\|type\\)[ \t]*is[ \t]*("
|
||||
"\\_<\\(class\\|type\\)[ \t]*is[ \t]*("
|
||||
"Regexp matching a CLASS/TYPE IS statement.")
|
||||
|
||||
(defconst f90-no-break-re
|
||||
|
|
@ -909,12 +908,12 @@ allowed. This minor issue currently only affects \"(/\" and \"/)\".")
|
|||
|
||||
;; Hideshow support.
|
||||
(defconst f90-end-block-re
|
||||
(concat "^[ \t0-9]*\\<end[ \t]*"
|
||||
(concat "^[ \t0-9]*\\_<end[ \t]*"
|
||||
(regexp-opt '("do" "if" "forall" "function" "interface"
|
||||
"module" "program" "select" "subroutine"
|
||||
"type" "where" "enum" "associate" "submodule"
|
||||
"block" "critical") t)
|
||||
"\\>")
|
||||
"\\_>")
|
||||
"Regexp matching the end of an F90 \"block\", from the line start.
|
||||
Used in the F90 entry in `hs-special-modes-alist'.")
|
||||
|
||||
|
|
@ -924,11 +923,11 @@ Used in the F90 entry in `hs-special-modes-alist'.")
|
|||
(concat
|
||||
"^[ \t0-9]*" ; statement number
|
||||
"\\(\\("
|
||||
"\\(\\sw+[ \t]*:[ \t]*\\)?" ; structure label
|
||||
"\\(\\(?:\\sw\\|\\s_\\)+[ \t]*:[ \t]*\\)?" ; structure label
|
||||
"\\(do\\|select[ \t]*\\(case\\|type\\)\\|"
|
||||
;; See comments in fortran-start-block-re for the problems of IF.
|
||||
"if[ \t]*(\\(.*\\|"
|
||||
".*\n\\([^if]*\\([^i].\\|.[^f]\\|.\\>\\)\\)\\)\\<then\\|"
|
||||
".*\n\\([^if]*\\([^i].\\|.[^f]\\|.\\_>\\)\\)\\)\\_<then\\|"
|
||||
;; Distinguish WHERE block from isolated WHERE.
|
||||
"\\(where\\|forall\\)[ \t]*(.*)[ \t]*\\(!\\|$\\)\\)\\)"
|
||||
"\\|"
|
||||
|
|
@ -938,7 +937,7 @@ Used in the F90 entry in `hs-special-modes-alist'.")
|
|||
"type[ \t,]\\("
|
||||
"[^i(!\n\"\& \t]\\|" ; not-i(
|
||||
"i[^s!\n\"\& \t]\\|" ; i not-s
|
||||
"is\\sw\\)\\|"
|
||||
"is\\(?:\\sw\\|\\s_\\)\\)\\|"
|
||||
;; "abstract interface" is F2003; "submodule" is F2008.
|
||||
"program\\|\\(?:abstract[ \t]*\\)?interface\\|\\(?:sub\\)?module\\|"
|
||||
;; "enum", but not "enumerator".
|
||||
|
|
@ -966,10 +965,10 @@ Set subexpression 1 in the match-data to the name of the type."
|
|||
(not (setq found
|
||||
(save-excursion
|
||||
(goto-char (match-end 0))
|
||||
(unless (looking-at "\\(is\\>\\|(\\)")
|
||||
(or (looking-at "\\(\\sw+\\)")
|
||||
(unless (looking-at "\\(is\\_>\\|(\\)")
|
||||
(or (looking-at "\\(\\(?:\\sw\\|\\s_\\)+\\)")
|
||||
(re-search-forward
|
||||
"[ \t]*::[ \t]*\\(\\sw+\\)"
|
||||
"[ \t]*::[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)"
|
||||
(line-end-position) t))))))))
|
||||
found))
|
||||
|
||||
|
|
@ -978,36 +977,35 @@ Set subexpression 1 in the match-data to the name of the type."
|
|||
(not-n "[^n!\n\"\& \t]") (not-d "[^d!\n\"\& \t]")
|
||||
;; (not-ib "[^i(!\n\"\& \t]") (not-s "[^s!\n\"\& \t]")
|
||||
)
|
||||
(list
|
||||
'(nil "^[ \t0-9]*program[ \t]+\\(\\sw+\\)" 1)
|
||||
'("Submodules" "^[ \t0-9]*submodule[ \t]*([^)\n]+)[ \t]*\
|
||||
\\(\\sw+\\)[ \t]*\\(!\\|$\\)" 1)
|
||||
'("Modules" "^[ \t0-9]*module[ \t]+\\(\\sw+\\)[ \t]*\\(!\\|$\\)" 1)
|
||||
(list "Types" 'f90-imenu-type-matcher 1)
|
||||
;; Does not handle: "type[, stuff] :: foo".
|
||||
;;; (format "^[ \t0-9]*type[ \t]+\\(\\(%s\\|i%s\\|is\\sw\\)\\sw*\\)"
|
||||
;;; not-ib not-s)
|
||||
;;; 1)
|
||||
;; Can't get the subexpression numbers to match in the two branches.
|
||||
;;; (format "^[ \t0-9]*type\\([ \t]*,.*\\(::\\)[ \t]*\\(\\sw+\\)\\|[ \t]+\\(\\(%s\\|i%s\\|is\\sw\\)\\sw*\\)\\)" not-ib not-s)
|
||||
;;; 3)
|
||||
(list
|
||||
"Procedures"
|
||||
(concat
|
||||
"^[ \t0-9]*"
|
||||
"\\("
|
||||
;; At least three non-space characters before function/subroutine.
|
||||
;; Check that the last three non-space characters do not spell E N D.
|
||||
"[^!\"\&\n]*\\("
|
||||
not-e good-char good-char "\\|"
|
||||
good-char not-n good-char "\\|"
|
||||
good-char good-char not-d "\\)"
|
||||
"\\|"
|
||||
;; Less than three non-space characters before function/subroutine.
|
||||
good-char "?" good-char "?"
|
||||
"\\)"
|
||||
"[ \t]*\\(function\\|subroutine\\)[ \t]+\\(\\sw+\\)")
|
||||
4)))
|
||||
`((nil "^[ \t0-9]*program[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)" 1)
|
||||
("Submodules" "^[ \t0-9]*submodule[ \t]*([^)\n]+)[ \t]*\
|
||||
\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*\\(!\\|$\\)" 1)
|
||||
("Modules" "^[ \t0-9]*module[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*\\(!\\|$\\)" 1)
|
||||
'("Types" f90-imenu-type-matcher 1)
|
||||
;; Does not handle: "type[, stuff] :: foo".
|
||||
;;(format "^[ \t0-9]*type[ \t]+\\(\\(%s\\|i%s\\|is\\(?:\\sw\\|\\s_\\)\\)\\(?:\\sw\\|\\s_\\)*\\)"
|
||||
;; not-ib not-s)
|
||||
;;1)
|
||||
;; Can't get the subexpression numbers to match in the two branches.
|
||||
;; FIXME: Now with \(?N:..\) we can get the numbers to match!
|
||||
;;(format "^[ \t0-9]*type\\([ \t]*,.*\\(::\\)[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\|[ \t]+\\(\\(%s\\|i%s\\|is\\(?:\\sw\\|\\s_\\)\\)\\(?:\\sw\\|\\s_\\)*\\)\\)" not-ib not-s)
|
||||
;;3)
|
||||
("Procedures"
|
||||
,(concat
|
||||
"^[ \t0-9]*"
|
||||
"\\("
|
||||
;; At least three non-space characters before function/subroutine.
|
||||
;; Check that the last three non-space characters do not spell E N D.
|
||||
"[^!\"\&\n]*\\("
|
||||
not-e good-char good-char "\\|"
|
||||
good-char not-n good-char "\\|"
|
||||
good-char good-char not-d "\\)"
|
||||
"\\|"
|
||||
;; Less than three non-space characters before function/subroutine.
|
||||
good-char "?" good-char "?"
|
||||
"\\)"
|
||||
"[ \t]*\\(function\\|subroutine\\)[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)")
|
||||
4)))
|
||||
"Value for `imenu-generic-expression' in F90 mode.")
|
||||
|
||||
(defun f90-add-imenu-menu ()
|
||||
|
|
@ -1144,7 +1142,7 @@ Variables controlling indentation style and extra features:
|
|||
whether to blink the matching beginning (default 'blink).
|
||||
`f90-auto-keyword-case'
|
||||
Automatic change of case of keywords (default nil).
|
||||
The possibilities are 'downcase-word, 'upcase-word, 'capitalize-word.
|
||||
The possibilities are `downcase-word', `upcase-word', `capitalize-word'.
|
||||
`f90-leave-line-no'
|
||||
Do not left-justify line numbers (default nil).
|
||||
|
||||
|
|
@ -1256,13 +1254,13 @@ whitespace, if any."
|
|||
(defsubst f90-looking-at-do ()
|
||||
"Return (\"do\" NAME) if a do statement starts after point.
|
||||
NAME is nil if the statement has no label."
|
||||
(if (looking-at "\\(\\(\\sw+\\)[ \t]*:\\)?[ \t]*\\(do\\)\\>")
|
||||
(if (looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:\\)?[ \t]*\\(do\\)\\_>")
|
||||
(list (match-string 3) (match-string 2))))
|
||||
|
||||
(defsubst f90-looking-at-select-case ()
|
||||
"Return (\"select\" NAME) if a select statement starts after point.
|
||||
NAME is nil if the statement has no label."
|
||||
(if (looking-at "\\(\\(\\sw+\\)[ \t]*:\\)?[ \t]*\
|
||||
(if (looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:\\)?[ \t]*\
|
||||
\\(select\\)[ \t]*\\(case\\|type\\)[ \t]*(")
|
||||
(list (match-string 3) (match-string 2))))
|
||||
|
||||
|
|
@ -1270,50 +1268,50 @@ NAME is nil if the statement has no label."
|
|||
"Return (\"if\" NAME) if an if () then statement starts after point.
|
||||
NAME is nil if the statement has no label."
|
||||
(save-excursion
|
||||
(when (looking-at "\\(\\(\\sw+\\)[ \t]*:\\)?[ \t]*\\(if\\)\\>")
|
||||
(when (looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:\\)?[ \t]*\\(if\\)\\_>")
|
||||
(let ((struct (match-string 3))
|
||||
(label (match-string 2))
|
||||
(pos (scan-lists (point) 1 0)))
|
||||
(and pos (goto-char pos))
|
||||
(skip-chars-forward " \t")
|
||||
(if (or (looking-at "then\\>")
|
||||
(if (or (looking-at "then\\_>")
|
||||
(when (f90-line-continued)
|
||||
(f90-next-statement)
|
||||
(skip-chars-forward " \t0-9&")
|
||||
(looking-at "then\\>")))
|
||||
(looking-at "then\\_>")))
|
||||
(list struct label))))))
|
||||
|
||||
;; FIXME label?
|
||||
(defsubst f90-looking-at-associate ()
|
||||
"Return (\"associate\") if an associate block starts after point."
|
||||
(if (looking-at "\\<\\(associate\\)[ \t]*(")
|
||||
(if (looking-at "\\_<\\(associate\\)[ \t]*(")
|
||||
(list (match-string 1))))
|
||||
|
||||
(defsubst f90-looking-at-critical ()
|
||||
"Return (KIND NAME) if a critical or block block starts after point."
|
||||
(if (looking-at "\\(\\(\\sw+\\)[ \t]*:\\)?[ \t]*\\(critical\\|block\\)\\>")
|
||||
(if (looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:\\)?[ \t]*\\(critical\\|block\\)\\_>")
|
||||
(let ((struct (match-string 3))
|
||||
(label (match-string 2)))
|
||||
(if (or (not (string-equal "block" struct))
|
||||
(save-excursion
|
||||
(skip-chars-forward " \t")
|
||||
(not (looking-at "data\\>"))))
|
||||
(not (looking-at "data\\_>"))))
|
||||
(list struct label)))))
|
||||
|
||||
(defsubst f90-looking-at-end-critical ()
|
||||
"Return non-nil if a critical or block block ends after point."
|
||||
(if (looking-at "end[ \t]*\\(critical\\|block\\)\\>")
|
||||
(if (looking-at "end[ \t]*\\(critical\\|block\\)\\_>")
|
||||
(or (not (string-equal "block" (match-string 1)))
|
||||
(save-excursion
|
||||
(skip-chars-forward " \t")
|
||||
(not (looking-at "data\\>"))))))
|
||||
(not (looking-at "data\\_>"))))))
|
||||
|
||||
(defsubst f90-looking-at-where-or-forall ()
|
||||
"Return (KIND NAME) if a where or forall block starts after point.
|
||||
NAME is nil if the statement has no label."
|
||||
(save-excursion
|
||||
(when (looking-at "\\(\\(\\sw+\\)[ \t]*:\\)?[ \t]*\
|
||||
\\(where\\|forall\\)\\>")
|
||||
(when (looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ \t]*:\\)?[ \t]*\
|
||||
\\(where\\|forall\\)\\_>")
|
||||
(let ((struct (match-string 3))
|
||||
(label (match-string 2))
|
||||
(pos (scan-lists (point) 1 0)))
|
||||
|
|
@ -1326,43 +1324,43 @@ NAME is nil if the statement has no label."
|
|||
NAME is non-nil only for type and certain interfaces."
|
||||
(cond
|
||||
((save-excursion
|
||||
(and (looking-at "\\<type\\>[ \t]*")
|
||||
(and (looking-at "\\_<type\\_>[ \t]*")
|
||||
(goto-char (match-end 0))
|
||||
(not (looking-at "\\(is\\>\\|(\\)"))
|
||||
(or (looking-at "\\(\\sw+\\)")
|
||||
(re-search-forward "[ \t]*::[ \t]*\\(\\sw+\\)"
|
||||
(not (looking-at "\\(is\\_>\\|(\\)"))
|
||||
(or (looking-at "\\(\\(?:\\sw\\|\\s_\\)+\\)")
|
||||
(re-search-forward "[ \t]*::[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)"
|
||||
(line-end-position) t))))
|
||||
(list "type" (match-string 1)))
|
||||
;;; ((and (not (looking-at f90-typeis-re))
|
||||
;;; (looking-at f90-type-def-re))
|
||||
;;; (list (match-string 1) (match-string 2)))
|
||||
((looking-at "\\<\\(interface\\)\\>[ \t]*")
|
||||
((looking-at "\\_<\\(interface\\)\\_>[ \t]*")
|
||||
(list (match-string 1)
|
||||
(save-excursion
|
||||
(goto-char (match-end 0))
|
||||
(if (or (looking-at "\\(operator\\|assignment\\|read\\|\
|
||||
write\\)[ \t]*([^)\n]*)")
|
||||
(looking-at "\\sw+"))
|
||||
(looking-at "\\(?:\\sw\\|\\s_\\)+"))
|
||||
(match-string 0)))))
|
||||
((looking-at "\\(enum\\|block[ \t]*data\\)\\>")
|
||||
((looking-at "\\(enum\\|block[ \t]*data\\)\\_>")
|
||||
(list (match-string 1) nil))
|
||||
((looking-at "abstract[ \t]*\\(interface\\)\\>")
|
||||
((looking-at "abstract[ \t]*\\(interface\\)\\_>")
|
||||
(list (match-string 1) nil))))
|
||||
|
||||
(defsubst f90-looking-at-program-block-start ()
|
||||
"Return (KIND NAME) if a program block with name NAME starts after point."
|
||||
;;;NAME is nil for an un-named main PROGRAM block."
|
||||
(cond
|
||||
((looking-at "\\(program\\)[ \t]+\\(\\sw+\\)\\>")
|
||||
((looking-at "\\(program\\)[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>")
|
||||
(list (match-string 1) (match-string 2)))
|
||||
((and (not (looking-at "module[ \t]*procedure\\>"))
|
||||
(looking-at "\\(module\\)[ \t]+\\(\\sw+\\)\\>"))
|
||||
((and (not (looking-at "module[ \t]*procedure\\_>"))
|
||||
(looking-at "\\(module\\)[ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>"))
|
||||
(list (match-string 1) (match-string 2)))
|
||||
((looking-at "\\(submodule\\)[ \t]*([^)\n]+)[ \t]*\\(\\sw+\\)\\>")
|
||||
((looking-at "\\(submodule\\)[ \t]*([^)\n]+)[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>")
|
||||
(list (match-string 1) (match-string 2)))
|
||||
((and (not (looking-at "end[ \t]*\\(function\\|subroutine\\)"))
|
||||
(looking-at "[^!'\"\&\n]*\\(function\\|subroutine\\)[ \t]+\
|
||||
\\(\\sw+\\)"))
|
||||
\\(\\(?:\\sw\\|\\s_\\)+\\)"))
|
||||
(list (match-string 1) (match-string 2)))))
|
||||
;; Following will match an un-named main program block; however
|
||||
;; one needs to check if there is an actual PROGRAM statement after
|
||||
|
|
@ -1378,7 +1376,7 @@ write\\)[ \t]*([^)\n]*)")
|
|||
\\(?:assignment\\|operator\\|read\\|write\\)[ \t]*([^)\n]*)\\)")
|
||||
(list (match-string 1) (match-string 2)))
|
||||
((looking-at (concat "end[ \t]*" f90-blocks-re
|
||||
"?\\([ \t]+\\(\\sw+\\)\\)?\\>"))
|
||||
"?\\([ \t]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?\\_>"))
|
||||
(list (match-string 1) (match-string 3)))))
|
||||
|
||||
(defsubst f90-comment-indent ()
|
||||
|
|
@ -1435,10 +1433,10 @@ if all else fails."
|
|||
(not (or (looking-at "end")
|
||||
(looking-at "\\(do\\|if\\|else\\(if\\|where\\)?\
|
||||
\\|select[ \t]*\\(case\\|type\\)\\|case\\|where\\|forall\\|\
|
||||
block\\|critical\\)\\>")
|
||||
block\\|critical\\)\\_>")
|
||||
(looking-at "\\(program\\|\\(?:sub\\)?module\\|\
|
||||
\\(?:abstract[ \t]*\\)?interface\\|block[ \t]*data\\)\\>")
|
||||
(looking-at "\\(contains\\|\\sw+[ \t]*:\\)")
|
||||
\\(?:abstract[ \t]*\\)?interface\\|block[ \t]*data\\)\\_>")
|
||||
(looking-at "\\(contains\\|\\(?:\\sw\\|\\s_\\)+[ \t]*:\\)")
|
||||
(looking-at f90-type-def-re)
|
||||
(re-search-forward "\\(function\\|subroutine\\)"
|
||||
(line-end-position) t)))))
|
||||
|
|
@ -1504,7 +1502,7 @@ Does not check type and subprogram indentation."
|
|||
(setq icol (- icol f90-associate-indent)))
|
||||
((f90-looking-at-end-critical)
|
||||
(setq icol (- icol f90-critical-indent)))
|
||||
((looking-at "end[ \t]*do\\>")
|
||||
((looking-at "end[ \t]*do\\_>")
|
||||
(setq icol (- icol f90-do-indent))))
|
||||
(end-of-line))
|
||||
icol)))
|
||||
|
|
@ -1571,7 +1569,7 @@ Does not check type and subprogram indentation."
|
|||
(cond ((or (looking-at f90-else-like-re)
|
||||
(looking-at f90-end-if-re))
|
||||
(setq icol (- icol f90-if-indent)))
|
||||
((looking-at "end[ \t]*do\\>")
|
||||
((looking-at "end[ \t]*do\\_>")
|
||||
(setq icol (- icol f90-do-indent)))
|
||||
((looking-at f90-end-type-re)
|
||||
(setq icol (- icol f90-type-indent)))
|
||||
|
|
@ -1692,7 +1690,7 @@ Interactively, pushes mark before moving point."
|
|||
(setq start-list (cons start-this start-list) ; not add-to-list!
|
||||
count (1+ count)))
|
||||
((looking-at (concat "end[ \t]*" f90-blocks-re
|
||||
"[ \t]*\\(\\sw+\\)?"))
|
||||
"[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?"))
|
||||
(setq end-type (match-string 1)
|
||||
end-label (match-string 2)
|
||||
count (1- count))
|
||||
|
|
@ -1737,7 +1735,7 @@ Interactively, pushes mark before moving point."
|
|||
(skip-chars-forward " \t0-9")
|
||||
(cond ((or (f90-in-string) (f90-in-comment)))
|
||||
((looking-at (concat "end[ \t]*" f90-blocks-re
|
||||
"[ \t]*\\(\\sw+\\)?"))
|
||||
"[ \t]*\\(\\(?:\\sw\\|\\s_\\)+\\)?"))
|
||||
(setq end-list (cons (list (match-string 1) (match-string 2))
|
||||
end-list)
|
||||
count (1+ count)))
|
||||
|
|
@ -1983,7 +1981,7 @@ If run in the middle of a line, the line is not broken."
|
|||
(car end-struct) (cadr end-struct))))
|
||||
(setq ind-b
|
||||
(cond ((looking-at f90-end-if-re) f90-if-indent)
|
||||
((looking-at "end[ \t]*do\\>") f90-do-indent)
|
||||
((looking-at "end[ \t]*do\\_>") f90-do-indent)
|
||||
((looking-at f90-end-type-re) f90-type-indent)
|
||||
((looking-at f90-end-associate-re)
|
||||
f90-associate-indent)
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@
|
|||
(modify-syntax-entry ?\) ")(" st)
|
||||
(modify-syntax-entry ?\[ "(]" st)
|
||||
(modify-syntax-entry ?\] ")[" st)
|
||||
(modify-syntax-entry ?_ "w" st)
|
||||
(modify-syntax-entry ?_ "_" st)
|
||||
(modify-syntax-entry ?. "_" st)
|
||||
(modify-syntax-entry ?\\ "\\" st)
|
||||
(modify-syntax-entry ?: "." st)
|
||||
|
|
@ -154,10 +154,10 @@
|
|||
|
||||
(defvar ld-script-font-lock-keywords
|
||||
(append
|
||||
`((,(regexp-opt ld-script-keywords 'words)
|
||||
1 font-lock-keyword-face)
|
||||
(,(regexp-opt ld-script-builtins 'words)
|
||||
1 font-lock-builtin-face)
|
||||
`((,(concat "\\_<" (regexp-opt ld-script-keywords) "\\_>")
|
||||
0 font-lock-keyword-face)
|
||||
(,(concat "\\_<" (regexp-opt ld-script-builtins) "\\_>")
|
||||
0 font-lock-builtin-face)
|
||||
;; 3.6.7 Output Section Discarding
|
||||
;; 3.6.4.1 Input Section Basics
|
||||
;; 3.6.8.7 Output Section Phdr
|
||||
|
|
|
|||
|
|
@ -88,8 +88,12 @@ If m4 is not in your PATH, set this to an absolute file name."
|
|||
(modify-syntax-entry ?\n ">#" table)
|
||||
(modify-syntax-entry ?{ "_" table)
|
||||
(modify-syntax-entry ?} "_" table)
|
||||
(modify-syntax-entry ?* "w" table)
|
||||
;; FIXME: This symbol syntax for underscore looks OK on its own, but it's
|
||||
;; odd that it should have the same syntax as { and } are these really
|
||||
;; valid in m4 symbols?
|
||||
(modify-syntax-entry ?_ "_" table)
|
||||
;; FIXME: These three chars with word syntax look wrong.
|
||||
(modify-syntax-entry ?* "w" table)
|
||||
(modify-syntax-entry ?\" "w" table)
|
||||
(modify-syntax-entry ?\" "w" table)
|
||||
table)
|
||||
|
|
|
|||
|
|
@ -794,6 +794,7 @@ The environment marked is the one that contains point or follows point."
|
|||
|
||||
(defvar meta-common-mode-syntax-table
|
||||
(let ((st (make-syntax-table)))
|
||||
;; FIXME: This goes against the convention!
|
||||
;; underscores are word constituents
|
||||
(modify-syntax-entry ?_ "w" st)
|
||||
;; miscellaneous non-word symbols
|
||||
|
|
|
|||
|
|
@ -772,6 +772,8 @@ Relevant only when `prolog-imenu-flag' is non-nil."
|
|||
:version "24.1"
|
||||
:group 'prolog-other
|
||||
:type 'boolean)
|
||||
(make-obsolete-variable 'prolog-underscore-wordchar-flag
|
||||
'superword-mode "24.4")
|
||||
|
||||
(defcustom prolog-use-sicstus-sd nil
|
||||
"If non-nil, use the source level debugger of SICStus 3#7 and later."
|
||||
|
|
@ -785,6 +787,7 @@ This is really kludgy, and unneeded (i.e. obsolete) in Emacs>=24."
|
|||
:version "24.1"
|
||||
:group 'prolog-other
|
||||
:type 'boolean)
|
||||
(make-obsolete-variable 'prolog-char-quote-workaround nil "24.1")
|
||||
|
||||
|
||||
;;-------------------------------------------------------------------
|
||||
|
|
@ -802,10 +805,7 @@ This is really kludgy, and unneeded (i.e. obsolete) in Emacs>=24."
|
|||
;; - In atoms \x<hex> sometimes needs a terminating \ (ISO-style)
|
||||
;; and sometimes not.
|
||||
(let ((table (make-syntax-table)))
|
||||
(if prolog-underscore-wordchar-flag
|
||||
(modify-syntax-entry ?_ "w" table)
|
||||
(modify-syntax-entry ?_ "_" table))
|
||||
|
||||
(modify-syntax-entry ?_ (if prolog-underscore-wordchar-flag "w" "_") table)
|
||||
(modify-syntax-entry ?+ "." table)
|
||||
(modify-syntax-entry ?- "." table)
|
||||
(modify-syntax-entry ?= "." table)
|
||||
|
|
@ -815,7 +815,8 @@ This is really kludgy, and unneeded (i.e. obsolete) in Emacs>=24."
|
|||
(modify-syntax-entry ?\' "\"" table)
|
||||
|
||||
;; Any better way to handle the 0'<char> construct?!?
|
||||
(when prolog-char-quote-workaround
|
||||
(when (and prolog-char-quote-workaround
|
||||
(not (fboundp 'syntax-propertize-rules)))
|
||||
(modify-syntax-entry ?0 "\\" table))
|
||||
|
||||
(modify-syntax-entry ?% "<" table)
|
||||
|
|
|
|||
|
|
@ -101,6 +101,8 @@ select and move operations. All parts of an identifier separated by underscore
|
|||
are treated as single words otherwise."
|
||||
:type 'boolean
|
||||
:group 'vera)
|
||||
(make-obsolete-variable 'vera-underscore-is-part-of-word
|
||||
'superword-mode "24.4")
|
||||
|
||||
(defcustom vera-intelligent-tab t
|
||||
"Non-nil means `TAB' does indentation, word completion and tab insertion.
|
||||
|
|
|
|||
|
|
@ -2784,6 +2784,8 @@ find the errors."
|
|||
(modify-syntax-entry ?> "." table)
|
||||
(modify-syntax-entry ?& "." table)
|
||||
(modify-syntax-entry ?| "." table)
|
||||
;; FIXME: This goes against Emacs conventions. Use "_" syntax instead and
|
||||
;; then use regexps with things like "\\_<...\\_>".
|
||||
(modify-syntax-entry ?` "w" table)
|
||||
(modify-syntax-entry ?_ "w" table)
|
||||
(modify-syntax-entry ?\' "." table)
|
||||
|
|
|
|||
|
|
@ -1872,14 +1872,11 @@ NOTE: Activate the new setting by restarting Emacs."
|
|||
"Non-nil means consider the underscore character `_' as part of word.
|
||||
An identifier containing underscores is then treated as a single word in
|
||||
select and move operations. All parts of an identifier separated by underscore
|
||||
are treated as single words otherwise.
|
||||
|
||||
NOTE: Activate the new setting in a VHDL buffer by using the menu entry
|
||||
\"Activate Options\"."
|
||||
are treated as single words otherwise."
|
||||
:type 'boolean
|
||||
:set (lambda (variable value)
|
||||
(vhdl-custom-set variable value 'vhdl-mode-syntax-table-init))
|
||||
:group 'vhdl-misc)
|
||||
(make-obsolete-variable 'vhdl-underscore-is-part-of-word
|
||||
'superword-mode "24.4")
|
||||
|
||||
|
||||
(defgroup vhdl-related nil
|
||||
|
|
@ -2433,6 +2430,7 @@ old environment. Used for consistent searching."
|
|||
(progn (set-buffer (create-file-buffer ,file-name))
|
||||
(setq file-opened t)
|
||||
(vhdl-insert-file-contents ,file-name)
|
||||
;; FIXME: This modifies a global syntax-table!
|
||||
(modify-syntax-entry ?\- ". 12" (syntax-table))
|
||||
(modify-syntax-entry ?\n ">" (syntax-table))
|
||||
(modify-syntax-entry ?\^M ">" (syntax-table))
|
||||
|
|
@ -2864,56 +2862,51 @@ STRING are replaced by `-' and substrings are converted to lower case."
|
|||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;; Syntax table
|
||||
|
||||
(defvar vhdl-mode-syntax-table nil
|
||||
(defvar vhdl-mode-syntax-table
|
||||
(let ((st (make-syntax-table)))
|
||||
;; define punctuation
|
||||
(modify-syntax-entry ?\# "." st)
|
||||
(modify-syntax-entry ?\$ "." st)
|
||||
(modify-syntax-entry ?\% "." st)
|
||||
(modify-syntax-entry ?\& "." st)
|
||||
(modify-syntax-entry ?\' "." st)
|
||||
(modify-syntax-entry ?\* "." st)
|
||||
(modify-syntax-entry ?\+ "." st)
|
||||
(modify-syntax-entry ?\. "." st)
|
||||
(modify-syntax-entry ?\/ "." st)
|
||||
(modify-syntax-entry ?\: "." st)
|
||||
(modify-syntax-entry ?\; "." st)
|
||||
(modify-syntax-entry ?\< "." st)
|
||||
(modify-syntax-entry ?\= "." st)
|
||||
(modify-syntax-entry ?\> "." st)
|
||||
(modify-syntax-entry ?\\ "." st)
|
||||
(modify-syntax-entry ?\| "." st)
|
||||
;; define string
|
||||
(modify-syntax-entry ?\" "\"" st)
|
||||
;; define underscore
|
||||
(modify-syntax-entry ?\_ (if vhdl-underscore-is-part-of-word "w" "_") st)
|
||||
;; a single hyphen is punctuation, but a double hyphen starts a comment
|
||||
(modify-syntax-entry ?\- ". 12" st)
|
||||
;; and \n and \^M end a comment
|
||||
(modify-syntax-entry ?\n ">" st)
|
||||
(modify-syntax-entry ?\^M ">" st)
|
||||
;; define parentheses to match
|
||||
(modify-syntax-entry ?\( "()" st)
|
||||
(modify-syntax-entry ?\) ")(" st)
|
||||
(modify-syntax-entry ?\[ "(]" st)
|
||||
(modify-syntax-entry ?\] ")[" st)
|
||||
(modify-syntax-entry ?\{ "(}" st)
|
||||
(modify-syntax-entry ?\} "){" st)
|
||||
st)
|
||||
"Syntax table used in `vhdl-mode' buffers.")
|
||||
|
||||
(defvar vhdl-mode-ext-syntax-table nil
|
||||
(defvar vhdl-mode-ext-syntax-table
|
||||
;; Extended syntax table including '_' (for simpler search regexps).
|
||||
(let ((st (copy-syntax-table vhdl-mode-syntax-table)))
|
||||
(modify-syntax-entry ?_ "w" st)
|
||||
st)
|
||||
"Syntax table extended by `_' used in `vhdl-mode' buffers.")
|
||||
|
||||
(defun vhdl-mode-syntax-table-init ()
|
||||
"Initialize `vhdl-mode-syntax-table'."
|
||||
(setq vhdl-mode-syntax-table (make-syntax-table))
|
||||
;; define punctuation
|
||||
(modify-syntax-entry ?\# "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\$ "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\% "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\& "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\' "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\* "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\+ "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\. "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\/ "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\: "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\; "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\< "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\= "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\> "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\\ "." vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\| "." vhdl-mode-syntax-table)
|
||||
;; define string
|
||||
(modify-syntax-entry ?\" "\"" vhdl-mode-syntax-table)
|
||||
;; define underscore
|
||||
(when vhdl-underscore-is-part-of-word
|
||||
(modify-syntax-entry ?\_ "w" vhdl-mode-syntax-table))
|
||||
;; a single hyphen is punctuation, but a double hyphen starts a comment
|
||||
(modify-syntax-entry ?\- ". 12" vhdl-mode-syntax-table)
|
||||
;; and \n and \^M end a comment
|
||||
(modify-syntax-entry ?\n ">" vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\^M ">" vhdl-mode-syntax-table)
|
||||
;; define parentheses to match
|
||||
(modify-syntax-entry ?\( "()" vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\) ")(" vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\[ "(]" vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\] ")[" vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\{ "(}" vhdl-mode-syntax-table)
|
||||
(modify-syntax-entry ?\} "){" vhdl-mode-syntax-table)
|
||||
;; extended syntax table including '_' (for simpler search regexps)
|
||||
(setq vhdl-mode-ext-syntax-table (copy-syntax-table vhdl-mode-syntax-table))
|
||||
(modify-syntax-entry ?_ "w" vhdl-mode-ext-syntax-table))
|
||||
|
||||
;; initialize syntax table for VHDL Mode
|
||||
(vhdl-mode-syntax-table-init)
|
||||
|
||||
(defvar vhdl-syntactic-context nil
|
||||
"Buffer local variable containing syntactic analysis list.")
|
||||
(make-variable-buffer-local 'vhdl-syntactic-context)
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue