;;; meta-mode.el --- major mode for editing Metafont or MetaPost sources
-;; Copyright (C) 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1997, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+;; Free Software Foundation, Inc.
;; Author: Ulrik Vieth <vieth@thphy.uni-duesseldorf.de>
;; Version: 1.0
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
+;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Commentary:
;; a major mode including an approriate syntax table, keymap, and a
;; mode-specific pull-down menu. It also provides a sophisticated set
;; of font-lock patterns, a fancy indentation function adapted from
-;; AUC-TeX's latex.el, and some basic mode-specific editing functions
+;; AUCTeX's latex.el, and some basic mode-specific editing functions
;; such as functions to move to the beginning or end of the enclosing
;; environment, or to mark, re-indent, or comment-out environments.
;; On the other hand, it doesn't yet provide any functionality for
;; these lines to your startup file:
;;
;; (add-hook 'meta-mode-load-hook
-;; '(lambda () (require 'meta-buf)))
+;; (lambda () (require 'meta-buf)))
;;
;; The add-on package loaded this way may in turn make use of the
;; mode-hooks provided in this package to activate additional features
;;
;; This package was begun on February 1, 1997, exactly 20 years after
;; the genesis of TeX took place according to Don Knuth's own account
-;; (cf. ``The Errors of TeX'', reprinted in ``Literate Programming'',
+;; (cf. ``The Errors of TeX'', reprinted in ``Literate Programming'',
;; Chapter 10, p. 249). What better date could there be to choose?
;;
(defgroup meta-font nil
"Major mode for editing Metafont or MetaPost sources."
+ :link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces)
:group 'languages)
;;; Fontification.
(list
;; embedded TeX code in btex ... etex
(cons (concat "\\(btex\\|verbatimtex\\)"
- "[ \t]+\\(.*\\)[ \t]+"
+ "[ \t\f]+\\(.*\\)[ \t\f]+"
"\\(etex\\)")
'((1 font-lock-keyword-face)
(2 font-lock-string-face)
(3 font-lock-keyword-face)))
;; unary macro definitions: def, vardef, let
(cons (concat "\\<" macro-keywords-1 "\\>"
- "[ \t]+\\(\\sw+\\|\\s_+\\|\\s.+\\)")
+ "[ \t\f]+\\(\\sw+\\|\\s_+\\|\\s.+\\)")
'((1 font-lock-keyword-face)
(2 font-lock-function-name-face)))
;; binary macro defintions: <leveldef> x operator y
(cons (concat "\\<" macro-keywords-2 "\\>"
- "[ \t]+\\(\\sw+\\)"
- "[ \t]*\\(\\sw+\\|\\s.+\\)"
- "[ \t]*\\(\\sw+\\)")
+ "[ \t\f]+\\(\\sw+\\)"
+ "[ \t\f]*\\(\\sw+\\|\\s.+\\)"
+ "[ \t\f]*\\(\\sw+\\)")
'((1 font-lock-keyword-face)
(2 font-lock-variable-name-face nil t)
(3 font-lock-function-name-face nil t)
(4 font-lock-variable-name-face nil t)))
;; variable declarations: numeric, pair, color, ...
(cons (concat "\\<" type-keywords "\\>"
- "\\([ \t]+\\(\\sw+\\)\\)*")
+ "\\([ \t\f]+\\(\\sw+\\)\\)*")
'((1 font-lock-type-face)
(font-lock-match-meta-declaration-item-and-skip-to-next
(goto-char (match-end 1)) nil
(1 font-lock-variable-name-face nil t))))
;; argument declarations: expr, suffix, text, ...
(cons (concat "\\<" args-keywords "\\>"
- "\\([ \t]+\\(\\sw+\\|\\s_+\\)\\)*")
+ "\\([ \t\f]+\\(\\sw+\\|\\s_+\\)\\)*")
'((1 font-lock-type-face)
(font-lock-match-meta-declaration-item-and-skip-to-next
(goto-char (match-end 1)) nil
(1 font-lock-variable-name-face nil t))))
;; special case of arguments: expr x of y
- (cons (concat "\\(expr\\)[ \t]+\\(\\sw+\\)"
- "[ \t]+\\(of\\)[ \t]+\\(\\sw+\\)")
+ (cons (concat "\\(expr\\)[ \t\f]+\\(\\sw+\\)"
+ "[ \t\f]+\\(of\\)[ \t\f]+\\(\\sw+\\)")
'((1 font-lock-type-face)
(2 font-lock-variable-name-face)
(3 font-lock-keyword-face nil t)
'font-lock-keyword-face)
;; input, generate
(cons (concat "\\<" input-keywords "\\>"
- "[ \t]+\\(\\sw+\\)")
+ "[ \t\f]+\\(\\sw+\\)")
'((1 font-lock-keyword-face)
(2 font-lock-constant-face)))
;; embedded Metafont/MetaPost code in comments
;; `forward-sexp'. The list of items is expected to be separated
;; by commas and terminated by semicolons or equals signs.
;;
- (if (looking-at "[ \t]*\\(\\sw+\\|\\s_+\\)")
+ (if (looking-at "[ \t\f]*\\(\\sw+\\|\\s_+\\)")
(save-match-data
(condition-case nil
(save-restriction
(narrow-to-region (point-min) limit)
(goto-char (match-end 1))
;; Move over any item value, etc., to the next item.
- (while (not (looking-at "[ \t]*\\(\\(,\\)\\|;\\|=\\|$\\)"))
+ (while (not (looking-at "[ \t\f]*\\(\\(,\\)\\|;\\|=\\|$\\)"))
(goto-char (or (scan-sexps (point) 1) (point-max))))
(goto-char (match-end 2)))
(error t)))))
(message "Making completion list...")
(let ((list (all-completions symbol list nil)))
(with-output-to-temp-buffer "*Completions*"
- (display-completion-list list)))
+ (display-completion-list list symbol)))
(message "Making completion list... done"))))
(funcall (nth 1 entry)))))
(if (and meta-left-comment-regexp
(looking-at meta-left-comment-regexp))
(current-column)
- (skip-chars-backward "\t ")
+ (skip-chars-backward "\t\f ")
(max (if (bolp) 0 (1+ (current-column)))
comment-column)))
(defun meta-indent-calculate ()
"Return the indentation of current line of Metafont or MetaPost source."
+ ;; Indentation within strings is not considered as Meta* don't allow multi
+ ;; line strings.
(save-excursion
(back-to-indentation)
(cond
- ;; Comments to the left margin.
+ ;; Comments to the left margin.
((and meta-left-comment-regexp
(looking-at meta-left-comment-regexp))
0)
- ;; Comments to the right margin.
+ ;; Comments to the right margin.
((and meta-right-comment-regexp
(looking-at meta-right-comment-regexp))
comment-column)
((and meta-ignore-comment-regexp
(looking-at meta-ignore-comment-regexp))
(current-indentation))
+ ;; Beginning of buffer.
+ ((eq (point-at-bol) (point-min))
+ 0)
;; Backindent at end of environments.
- ((looking-at
+ ((meta-indent-looking-at-code
(concat "\\<" meta-end-environment-regexp "\\>"))
- (- (meta-indent-calculate-last) meta-indent-level))
+ (- (meta-indent-current-indentation) meta-indent-level))
;; Backindent at keywords within environments.
- ((looking-at
+ ((meta-indent-looking-at-code
(concat "\\<" meta-within-environment-regexp "\\>"))
- (- (meta-indent-calculate-last) meta-indent-level))
- (t (meta-indent-calculate-last)))))
-
-(defun meta-indent-calculate-last ()
- "Return the indentation of previous line of Metafont or MetaPost source."
- (save-restriction
- (widen)
- (skip-chars-backward "\n\t ")
- (move-to-column (current-indentation))
- ;; Ignore comments.
- (while (and (looking-at comment-start) (not (bobp)))
- (skip-chars-backward "\n\t ")
- (if (not (bobp))
- (move-to-column (current-indentation))))
- (cond
- ((bobp) 0)
- (t (+ (current-indentation)
- (meta-indent-level-count)
- (cond
- ;; Compensate for backindent at end of environments.
- ((looking-at
- (concat "\\<"meta-end-environment-regexp "\\>"))
- meta-indent-level)
- ;; Compensate for backindent within environments.
- ((looking-at
- (concat "\\<" meta-within-environment-regexp "\\>"))
- meta-indent-level)
- (t 0)))))
- ))
+ (- (meta-indent-current-indentation) meta-indent-level))
+ (t (meta-indent-current-indentation)))))
+
+(defun meta-indent-in-string-p ()
+ "Tell if the point is in a string."
+ (or (nth 3 (syntax-ppss))
+ (eq (get-text-property (point) 'face) font-lock-string-face)))
+
+(defun meta-indent-looking-at-code (regexp)
+ "Same as `looking-at' but checks that the point is not in a string."
+ (unless (meta-indent-in-string-p)
+ (looking-at regexp)))
+
+(defun meta-indent-previous-line ()
+ "Go to the previous line of code, skipping comments."
+ (skip-chars-backward "\n\t\f ")
+ (move-to-column (current-indentation))
+ ;; Ignore comments.
+ (while (and (looking-at comment-start) (not (bobp)))
+ (skip-chars-backward "\n\t\f ")
+ (when (not (bobp))
+ (move-to-column (current-indentation)))))
+
+(defun meta-indent-unfinished-line ()
+ "Tell if the current line of code ends with an unfinished expression."
+ (save-excursion
+ (end-of-line)
+ ;; Skip backward the comments.
+ (let ((point-not-in-string (point)))
+ (while (search-backward comment-start (point-at-bol) t)
+ (unless (meta-indent-in-string-p)
+ (setq point-not-in-string (point))))
+ (goto-char point-not-in-string))
+ ;; Search for the end of the previous expression.
+ (if (search-backward ";" (point-at-bol) t)
+ (progn (while (and (meta-indent-in-string-p)
+ (search-backward ";" (point-at-bol) t)))
+ (if (= (char-after) ?\;)
+ (forward-char)
+ (beginning-of-line)))
+ (beginning-of-line))
+ ;; See if the last statement of the line is environment-related,
+ ;; or exists at all.
+ (if (meta-indent-looking-at-code
+ (concat "[ \t\f]*\\($\\|" (regexp-quote comment-start)
+ "\\|\\<" meta-end-environment-regexp "\\>"
+ "\\|\\<" meta-begin-environment-regexp "\\>"
+ "\\|\\<" meta-within-environment-regexp "\\>\\)"))
+ nil
+ t)))
+
+(defun meta-indent-current-indentation ()
+ "Return the indentation wanted for the current line of code."
+ (+ (meta-indent-current-nesting)
+ (if (save-excursion
+ (back-to-indentation)
+ (and (not (looking-at (concat "\\<" meta-end-environment-regexp "\\>"
+ "\\|\\<" meta-within-environment-regexp "\\>")))
+ (progn (meta-indent-previous-line)
+ (meta-indent-unfinished-line))))
+ meta-indent-level
+ 0)))
+
+(defun meta-indent-current-nesting ()
+ "Return the indentation according to the nearest environment keyword."
+ (save-excursion
+ (save-restriction
+ (widen)
+ (back-to-indentation)
+ (let ((to-add 0))
+ ;; If we found some environment marker backward...
+ (if (catch 'found
+ (while (re-search-backward
+ (concat "(\\|)\\|\\<" meta-end-environment-regexp "\\>"
+ "\\|\\<" meta-begin-environment-regexp "\\>"
+ "\\|\\<" meta-within-environment-regexp "\\>")
+ nil t)
+ ;; If we aren't in a string or in a comment, we've found something.
+ (unless (or (meta-indent-in-string-p)
+ (nth 4 (syntax-ppss)))
+ (cond ((= (char-after) ?\()
+ (setq to-add (+ to-add meta-indent-level)))
+ ((= (char-after) ?\))
+ (setq to-add (- to-add meta-indent-level)))
+ (t (throw 'found t))))))
+ (progn
+ ;; ... then use it to compute the current indentation.
+ (back-to-indentation)
+ (+ to-add (current-indentation) (meta-indent-level-count)
+ ;; Compensate for backindent of end and within keywords.
+ (if (meta-indent-looking-at-code
+ (concat "\\<" meta-end-environment-regexp "\\>\\|"
+ "\\<" meta-within-environment-regexp "\\>"))
+ meta-indent-level
+ ;; Compensate for unfinished line.
+ (if (save-excursion
+ (meta-indent-previous-line)
+ (meta-indent-unfinished-line))
+ (- meta-indent-level)
+ 0))))
+ 0)))))
(defun meta-indent-level-count ()
"Count indentation change for begin-end commands in the current line."
(goto-char (match-beginning 0))
(cond
;; Count number of begin-end keywords within line.
- ((looking-at
+ ((meta-indent-looking-at-code
(concat "\\<" meta-begin-environment-regexp "\\>"))
(setq count (+ count meta-indent-level)))
- ((looking-at
+ ((meta-indent-looking-at-code
(concat "\\<" meta-end-environment-regexp "\\>"))
- (setq count (- count meta-indent-level)))
- ;; Count number of open-close parentheses within line.
- ((looking-at "(")
- (setq count (+ count meta-indent-level)))
- ((looking-at ")")
- (setq count (- count meta-indent-level)))
- )))
+ (setq count (- count meta-indent-level))))))
count))))
-\f
-;;; Filling paragraphs.
-
-(defun meta-fill-paragraph (&optional justify)
- "Like \\[fill-paragraph], but handle Metafont or MetaPost comments.
-If any part of the current line is a comment, fill the comment or the
-paragraph of it that point is in, preserving the comment's indentation
-and initial semicolons."
- (interactive "P")
- (let (has-comment ; Non-nil if line contains a comment.
- has-code-and-comment ; Non-nil if line contains code and a comment.
- comment-fill-prefix ; If has-comment, fill-prefix for the comment.
- )
- ;; Figure out what kind of comment we are looking at.
- (save-excursion
- (beginning-of-line)
- (cond
- ;; A line with nothing but a comment on it?
- ((looking-at (concat "[ \t]*" comment-start-skip))
- (setq has-comment t)
- (setq comment-fill-prefix
- (buffer-substring (match-beginning 0) (match-end 0))))
- ;; A line with some code, followed by a comment?
- ((condition-case nil
- (save-restriction
- (narrow-to-region (point-min)
- (save-excursion (end-of-line) (point)))
- (while (not (looking-at (concat comment-start "\\|$")))
- (skip-chars-forward (concat "^" comment-start "\n\"\\\\"))
- (cond
- ((eq (char-after (point)) ?\\) (forward-char 2))
- ((eq (char-after (point)) ?\") (forward-sexp 1))))
- (looking-at comment-start-skip))
- (error nil))
- (setq has-comment t
- has-code-and-comment t)
- (setq comment-fill-prefix
- (concat (make-string (/ (current-column) 8) ?\t)
- (make-string (% (current-column) 8) ?\ )
- (buffer-substring (match-beginning 0) (match-end 0)))))
- ))
- (if (not has-comment)
- (fill-paragraph justify)
- ;; Narrow to include only the comment, and then fill the region.
- (save-excursion
- (save-restriction
- (beginning-of-line)
- (narrow-to-region
- ;; Find the first line we should include in the region to fill.
- (save-excursion
- (while (and (zerop (forward-line -1))
- (looking-at (concat "^[ \t]*" comment-start))))
- (or (looking-at (concat ".*" comment-start))
- (forward-line 1))
- (point))
- ;; Find the beginning of the first line past the region to fill.
- (save-excursion
- (while (progn (forward-line 1)
- (looking-at (concat "^[ \t]*" comment-start))))
- (point)))
- (let* ((paragraph-start
- (concat paragraph-start "\\|[ \t%]*$"))
- (paragraph-separate
- (concat paragraph-start "\\|[ \t%]*$"))
- (paragraph-ignore-fill-prefix nil)
- (fill-prefix comment-fill-prefix)
- (after-line (if has-code-and-comment
- (save-excursion (forward-line 1) (point))))
- (end (progn (forward-paragraph)
- (or (bolp) (newline 1))
- (point)))
- (beg (progn (backward-paragraph)
- (if (eq (point) after-line) (forward-line -1))
- (point)))
- (after-pos (save-excursion
- (goto-char beg)
- (if (not (looking-at fill-prefix))
- (progn
- (re-search-forward comment-start-skip)
- (point)))))
- )
- (fill-region-as-paragraph beg end justify nil after-pos))
- )))
- t))
-
-
\f
;;; Editing commands.
(concat "\\<" meta-begin-defun-regexp "\\>") nil t arg)
(progn (goto-char (match-beginning 0))
(skip-chars-backward "%")
- (skip-chars-backward " \t") t)))
+ (skip-chars-backward " \t\f") t)))
(defun meta-end-of-defun (&optional arg)
"Move forward to end of a defun in Metafont or MetaPost code.
(concat "\\<" meta-end-defun-regexp "\\>") nil t arg)
(progn (goto-char (match-end 0))
(skip-chars-forward ";")
- (skip-chars-forward " \t")
+ (skip-chars-forward " \t\f")
(if (looking-at "\n") (forward-line 1)) t)))
"Abbrev table used in Metafont or MetaPost mode.")
(define-abbrev-table 'meta-mode-abbrev-table ())
-(defvar meta-mode-syntax-table nil
+(defvar meta-mode-syntax-table
+ (let ((st (make-syntax-table)))
+ ;; underscores are word constituents
+ (modify-syntax-entry ?_ "w" st)
+ ;; miscellaneous non-word symbols
+ (modify-syntax-entry ?# "_" st)
+ (modify-syntax-entry ?@ "_" st)
+ (modify-syntax-entry ?$ "_" st)
+ (modify-syntax-entry ?? "_" st)
+ (modify-syntax-entry ?! "_" st)
+ ;; binary operators
+ (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)
+ ;; opening and closing delimiters
+ (modify-syntax-entry ?\( "()" st)
+ (modify-syntax-entry ?\) ")(" st)
+ (modify-syntax-entry ?\[ "(]" st)
+ (modify-syntax-entry ?\] ")[" st)
+ (modify-syntax-entry ?\{ "(}" st)
+ (modify-syntax-entry ?\} "){" st)
+ ;; comment character
+ (modify-syntax-entry ?% "<" st)
+ (modify-syntax-entry ?\n ">" st)
+ ;; escape character, needed for embedded TeX code
+ (modify-syntax-entry ?\\ "\\" st)
+ st)
"Syntax table used in Metafont or MetaPost mode.")
-(if meta-mode-syntax-table
- ()
- (setq meta-mode-syntax-table (make-syntax-table))
- ;; underscores are word constituents
- (modify-syntax-entry ?_ "w" meta-mode-syntax-table)
- ;; miscellaneous non-word symbols
- (modify-syntax-entry ?# "_" meta-mode-syntax-table)
- (modify-syntax-entry ?@ "_" meta-mode-syntax-table)
- (modify-syntax-entry ?$ "_" meta-mode-syntax-table)
- (modify-syntax-entry ?? "_" meta-mode-syntax-table)
- (modify-syntax-entry ?! "_" meta-mode-syntax-table)
- ;; binary operators
- (modify-syntax-entry ?& "." meta-mode-syntax-table)
- (modify-syntax-entry ?+ "." meta-mode-syntax-table)
- (modify-syntax-entry ?- "." meta-mode-syntax-table)
- (modify-syntax-entry ?/ "." meta-mode-syntax-table)
- (modify-syntax-entry ?* "." meta-mode-syntax-table)
- (modify-syntax-entry ?. "." meta-mode-syntax-table)
- (modify-syntax-entry ?: "." meta-mode-syntax-table)
- (modify-syntax-entry ?= "." meta-mode-syntax-table)
- (modify-syntax-entry ?< "." meta-mode-syntax-table)
- (modify-syntax-entry ?> "." meta-mode-syntax-table)
- (modify-syntax-entry ?| "." meta-mode-syntax-table)
- ;; opening and closing delimiters
- (modify-syntax-entry ?\( "()" meta-mode-syntax-table)
- (modify-syntax-entry ?\) ")(" meta-mode-syntax-table)
- (modify-syntax-entry ?\[ "(]" meta-mode-syntax-table)
- (modify-syntax-entry ?\] ")[" meta-mode-syntax-table)
- (modify-syntax-entry ?\{ "(}" meta-mode-syntax-table)
- (modify-syntax-entry ?\} "){" meta-mode-syntax-table)
- ;; comment character
- (modify-syntax-entry ?% "<" meta-mode-syntax-table)
- (modify-syntax-entry ?\n ">" meta-mode-syntax-table)
- ;; escape character, needed for embedded TeX code
- (modify-syntax-entry ?\\ "\\" meta-mode-syntax-table)
- )
-(defvar meta-mode-map nil
+(defvar meta-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map "\C-m" 'reindent-then-newline-and-indent)
+ ;; Comment Paragraphs:
+ ;; (define-key map "\M-a" 'backward-sentence)
+ ;; (define-key map "\M-e" 'forward-sentence)
+ ;; (define-key map "\M-h" 'mark-paragraph)
+ ;; (define-key map "\M-q" 'fill-paragraph)
+ ;; Navigation:
+ (define-key map "\M-\C-a" 'meta-beginning-of-defun)
+ (define-key map "\M-\C-e" 'meta-end-of-defun)
+ (define-key map "\M-\C-h" 'meta-mark-defun)
+ ;; Indentation:
+ (define-key map "\M-\C-q" 'meta-indent-defun)
+ (define-key map "\C-c\C-qe" 'meta-indent-defun)
+ (define-key map "\C-c\C-qr" 'meta-indent-region)
+ (define-key map "\C-c\C-qb" 'meta-indent-buffer)
+ ;; Commenting Out:
+ (define-key map "\C-c%" 'meta-comment-defun)
+ ;; (define-key map "\C-uC-c%" 'meta-uncomment-defun)
+ (define-key map "\C-c;" 'meta-comment-region)
+ (define-key map "\C-c:" 'meta-uncomment-region)
+ ;; Symbol Completion:
+ (define-key map "\M-\t" 'meta-complete-symbol)
+ ;; Shell Commands:
+ ;; (define-key map "\C-c\C-c" 'meta-command-file)
+ ;; (define-key map "\C-c\C-k" 'meta-kill-job)
+ ;; (define-key map "\C-c\C-l" 'meta-recenter-output)
+ map)
"Keymap used in Metafont or MetaPost mode.")
-(if meta-mode-map
- ()
- (setq meta-mode-map (make-sparse-keymap))
- (define-key meta-mode-map "\t" 'meta-indent-line)
- (define-key meta-mode-map "\C-m" 'reindent-then-newline-and-indent)
- ;; Comment Paragraphs:
-; (define-key meta-mode-map "\M-a" 'backward-sentence)
-; (define-key meta-mode-map "\M-e" 'forward-sentence)
-; (define-key meta-mode-map "\M-h" 'mark-paragraph)
-; (define-key meta-mode-map "\M-q" 'fill-paragraph)
- ;; Navigation:
- (define-key meta-mode-map "\M-\C-a" 'meta-beginning-of-defun)
- (define-key meta-mode-map "\M-\C-e" 'meta-end-of-defun)
- (define-key meta-mode-map "\M-\C-h" 'meta-mark-defun)
- ;; Indentation:
- (define-key meta-mode-map "\M-\C-q" 'meta-indent-defun)
- (define-key meta-mode-map "\C-c\C-qe" 'meta-indent-defun)
- (define-key meta-mode-map "\C-c\C-qr" 'meta-indent-region)
- (define-key meta-mode-map "\C-c\C-qb" 'meta-indent-buffer)
- ;; Commenting Out:
- (define-key meta-mode-map "\C-c%" 'meta-comment-defun)
-; (define-key meta-mode-map "\C-uC-c%" 'meta-uncomment-defun)
- (define-key meta-mode-map "\C-c;" 'meta-comment-region)
- (define-key meta-mode-map "\C-c:" 'meta-uncomment-region)
- ;; Symbol Completion:
- (define-key meta-mode-map "\M-\t" 'meta-complete-symbol)
- ;; Shell Commands:
-; (define-key meta-mode-map "\C-c\C-c" 'meta-command-file)
-; (define-key meta-mode-map "\C-c\C-k" 'meta-kill-job)
-; (define-key meta-mode-map "\C-c\C-l" 'meta-recenter-output)
- )
+
(easy-menu-define
meta-mode-menu meta-mode-map
;; Compatibility: XEmacs doesn't have the `mark-active' variable.
(defun meta-mark-active ()
"Return whether the mark and region are currently active in this buffer."
- (or (and (boundp 'mark-active) mark-active) (mark)))
+ (if (boundp 'mark-active) mark-active (mark)))
\f
(make-local-variable 'comment-start)
(make-local-variable 'comment-end)
(make-local-variable 'comment-multi-line)
- (setq comment-start-skip "%+[ \t]*")
+ (setq comment-start-skip "%+[ \t\f]*")
(setq comment-start "%")
(setq comment-end "")
(setq comment-multi-line nil)
+ ;; We use `back-to-indentation' but \f is no indentation sign.
+ (modify-syntax-entry ?\f "_ ")
+
(make-local-variable 'parse-sexp-ignore-comments)
(setq parse-sexp-ignore-comments t)
(make-local-variable 'comment-indent-function)
(setq comment-indent-function 'meta-comment-indent)
- (make-local-variable 'fill-paragraph-function)
- (setq fill-paragraph-function 'meta-fill-paragraph)
(make-local-variable 'indent-line-function)
(setq indent-line-function 'meta-indent-line)
;; No need to define a mode-specific 'indent-region-function.
(setq meta-complete-list
(list (list "\\<\\(\\sw+\\)" 1 'meta-symbol-list)
(list "" 'ispell-complete-word)))
- (run-hooks 'meta-common-mode-hook 'metafont-mode-hook))
+ (run-mode-hooks 'meta-common-mode-hook 'metafont-mode-hook))
;;;###autoload
(defun metapost-mode ()
(setq meta-complete-list
(list (list "\\<\\(\\sw+\\)" 1 'meta-symbol-list)
(list "" 'ispell-complete-word)))
- (run-hooks 'meta-common-mode-hook 'metapost-mode-hook))
+ (run-mode-hooks 'meta-common-mode-hook 'metapost-mode-hook))
;;; Just in case ...
(provide 'meta-mode)
(run-hooks 'meta-mode-load-hook)
+;; arch-tag: ec2916b2-3a83-4cf7-962d-d8019370c006
;;; meta-mode.el ends here