;;; octave-mod.el --- editing Octave source files under Emacs
-;; Copyright (C) 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1997, 2003 Free Software Foundation, Inc.
;; Author: Kurt Hornik <Kurt.Hornik@ci.tuwien.ac.at>
;; Author: John Eaton <jwe@bevo.che.wisc.edu>
;; `run-octave' for further information on usage and customization.
;;; Code:
+(require 'custom)
(defgroup octave nil
"Major mode for editing Octave source files."
(defvar inferior-octave-receive-in-progress nil)
(defconst octave-maintainer-address
- "Kurt Hornik <Kurt.Hornik@ci.tuwien.ac.at>, bug-gnu-emacs@prep.ai.mit.edu"
+ "Kurt Hornik <Kurt.Hornik@ci.tuwien.ac.at>, bug-gnu-emacs@gnu.org"
"Current maintainer of the Emacs Octave package.")
(defvar octave-abbrev-table nil
"Abbrev table for Octave's reserved words.
-Used in octave-mode and inferior-octave-mode buffers.
+Used in `octave-mode' and inferior-octave-mode buffers.
All Octave abbrevs start with a grave accent (`).")
-(if octave-abbrev-table
- ()
+(unless octave-abbrev-table
(let ((ac abbrevs-changed))
(define-abbrev-table 'octave-abbrev-table ())
- (define-abbrev octave-abbrev-table "`a" "all_va_args" nil)
- (define-abbrev octave-abbrev-table "`b" "break" nil)
- (define-abbrev octave-abbrev-table "`cs" "case" nil)
- (define-abbrev octave-abbrev-table "`ca" "catch" nil)
- (define-abbrev octave-abbrev-table "`c" "continue" nil)
- (define-abbrev octave-abbrev-table "`el" "else" nil)
- (define-abbrev octave-abbrev-table "`eli" "elseif" nil)
- (define-abbrev octave-abbrev-table "`et" "end_try_catch" nil)
- (define-abbrev octave-abbrev-table "`eu" "end_unwind_protect" nil)
- (define-abbrev octave-abbrev-table "`ef" "endfor" nil)
- (define-abbrev octave-abbrev-table "`efu" "endfunction" nil)
- (define-abbrev octave-abbrev-table "`ei" "endif" nil)
- (define-abbrev octave-abbrev-table "`es" "endswitch" nil)
- (define-abbrev octave-abbrev-table "`ew" "endwhile" nil)
- (define-abbrev octave-abbrev-table "`f" "for" nil)
- (define-abbrev octave-abbrev-table "`fu" "function" nil)
- (define-abbrev octave-abbrev-table "`gl" "global" nil)
- (define-abbrev octave-abbrev-table "`gp" "gplot" nil)
- (define-abbrev octave-abbrev-table "`gs" "gsplot" nil)
- (define-abbrev octave-abbrev-table "`if" "if ()" nil)
- (define-abbrev octave-abbrev-table "`o" "otherwise" nil)
- (define-abbrev octave-abbrev-table "`rp" "replot" nil)
- (define-abbrev octave-abbrev-table "`r" "return" nil)
- (define-abbrev octave-abbrev-table "`s" "switch" nil)
- (define-abbrev octave-abbrev-table "`t" "try" nil)
- (define-abbrev octave-abbrev-table "`up" "unwind_protect" nil)
- (define-abbrev octave-abbrev-table "`upc" "unwind_protect_cleanup" nil)
- (define-abbrev octave-abbrev-table "`w" "while ()" nil)
+ (define-abbrev octave-abbrev-table "`a" "all_va_args" nil 0 t)
+ (define-abbrev octave-abbrev-table "`b" "break" nil 0 t)
+ (define-abbrev octave-abbrev-table "`cs" "case" nil 0 t)
+ (define-abbrev octave-abbrev-table "`ca" "catch" nil 0 t)
+ (define-abbrev octave-abbrev-table "`c" "continue" nil 0 t)
+ (define-abbrev octave-abbrev-table "`el" "else" nil 0 t)
+ (define-abbrev octave-abbrev-table "`eli" "elseif" nil 0 t)
+ (define-abbrev octave-abbrev-table "`et" "end_try_catch" nil 0 t)
+ (define-abbrev octave-abbrev-table "`eu" "end_unwind_protect" nil 0 t)
+ (define-abbrev octave-abbrev-table "`ef" "endfor" nil 0 t)
+ (define-abbrev octave-abbrev-table "`efu" "endfunction" nil 0 t)
+ (define-abbrev octave-abbrev-table "`ei" "endif" nil 0 t)
+ (define-abbrev octave-abbrev-table "`es" "endswitch" nil 0 t)
+ (define-abbrev octave-abbrev-table "`ew" "endwhile" nil 0 t)
+ (define-abbrev octave-abbrev-table "`f" "for" nil 0 t)
+ (define-abbrev octave-abbrev-table "`fu" "function" nil 0 t)
+ (define-abbrev octave-abbrev-table "`gl" "global" nil 0 t)
+ (define-abbrev octave-abbrev-table "`gp" "gplot" nil 0 t)
+ (define-abbrev octave-abbrev-table "`gs" "gsplot" nil 0 t)
+ (define-abbrev octave-abbrev-table "`if" "if ()" nil 0 t)
+ (define-abbrev octave-abbrev-table "`o" "otherwise" nil 0 t)
+ (define-abbrev octave-abbrev-table "`rp" "replot" nil 0 t)
+ (define-abbrev octave-abbrev-table "`r" "return" nil 0 t)
+ (define-abbrev octave-abbrev-table "`s" "switch" nil 0 t)
+ (define-abbrev octave-abbrev-table "`t" "try" nil 0 t)
+ (define-abbrev octave-abbrev-table "`up" "unwind_protect" nil 0 t)
+ (define-abbrev octave-abbrev-table "`upc" "unwind_protect_cleanup" nil 0 t)
+ (define-abbrev octave-abbrev-table "`w" "while ()" nil 0 t)
(setq abbrevs-changed ac)))
(defvar octave-comment-char ?#
"Character to start an Octave comment.")
(defvar octave-comment-start
- (concat (make-string 1 octave-comment-char) " ")
+ (string octave-comment-char ?\ )
"String to insert to start a new Octave in-line comment.")
(defvar octave-comment-start-skip "\\s<+\\s-*"
"Regexp to match the start of an Octave comment up to its body.")
'font-lock-keyword-face)
;; Fontify all builtin operators.
(cons "\\(&\\||\\|<=\\|>=\\|==\\|<\\|>\\|!=\\|!\\)"
- 'font-lock-reference-face)
+ (if (boundp 'font-lock-builtin-face)
+ 'font-lock-builtin-face
+ 'font-lock-preprocessor-face))
;; Fontify all builtin variables.
(cons (concat "\\<\\("
(mapconcat 'identity octave-variables "\\|")
(define-key map "\n" 'octave-reindent-then-newline-and-indent)
(define-key map "\t" 'indent-according-to-mode)
(define-key map "\e;" 'octave-indent-for-comment)
- (define-key map "\e\n" 'octave-indent-new-comment-line)
+ (define-key map "\e\n" 'octave-indent-new-comment-line)
(define-key map "\e\t" 'octave-complete-symbol)
(define-key map "\M-\C-a" 'octave-beginning-of-defun)
(define-key map "\M-\C-e" 'octave-end-of-defun)
(define-key map "\M-\C-h" 'octave-mark-defun)
- (define-key map "\M-\C-q" 'octave-indent-defun)
+ (define-key map "\M-\C-q" 'octave-indent-defun)
(define-key map "\C-c;" 'octave-comment-region)
- (define-key map "\C-c:" 'octave-uncomment-region)
+ (define-key map "\C-c:" 'octave-uncomment-region)
(define-key map "\C-c\C-b" 'octave-submit-bug-report)
(define-key map "\C-c\C-p" 'octave-previous-code-line)
(define-key map "\C-c\C-n" 'octave-next-code-line)
(define-key map "\C-c\C-a" 'octave-beginning-of-line)
- (define-key map "\C-c\C-e" 'octave-end-of-line)
+ (define-key map "\C-c\C-e" 'octave-end-of-line)
(define-key map "\C-c\M-\C-n" 'octave-forward-block)
(define-key map "\C-c\M-\C-p" 'octave-backward-block)
(define-key map "\C-c\M-\C-u" 'octave-backward-up-block)
(define-key map "\C-c\M-\C-d" 'octave-down-block)
(define-key map "\C-c\M-\C-h" 'octave-mark-block)
(define-key map "\C-c]" 'octave-close-block)
- (define-key map "\C-cf" 'octave-insert-defun)
+ (define-key map "\C-c\C-f" 'octave-insert-defun)
(define-key map "\C-c\C-h" 'octave-help)
- (define-key map "\C-cil" 'octave-send-line)
- (define-key map "\C-cib" 'octave-send-block)
- (define-key map "\C-cif" 'octave-send-defun)
- (define-key map "\C-cir" 'octave-send-region)
- (define-key map "\C-cis" 'octave-show-process-buffer)
- (define-key map "\C-cih" 'octave-hide-process-buffer)
- (define-key map "\C-cik" 'octave-kill-process)
+ (define-key map "\C-c\C-il" 'octave-send-line)
+ (define-key map "\C-c\C-ib" 'octave-send-block)
+ (define-key map "\C-c\C-if" 'octave-send-defun)
+ (define-key map "\C-c\C-ir" 'octave-send-region)
+ (define-key map "\C-c\C-is" 'octave-show-process-buffer)
+ (define-key map "\C-c\C-ih" 'octave-hide-process-buffer)
+ (define-key map "\C-c\C-ik" 'octave-kill-process)
+ (define-key map "\C-c\C-i\C-l" 'octave-send-line)
+ (define-key map "\C-c\C-i\C-b" 'octave-send-block)
+ (define-key map "\C-c\C-i\C-f" 'octave-send-defun)
+ (define-key map "\C-c\C-i\C-r" 'octave-send-region)
+ (define-key map "\C-c\C-i\C-s" 'octave-show-process-buffer)
+ (define-key map "\C-c\C-i\C-h" 'octave-hide-process-buffer)
+ (define-key map "\C-c\C-i\C-k" 'octave-kill-process)
(setq octave-mode-map map)))
(defvar octave-mode-menu
["Lookup Octave Index" octave-help t])
"Menu for Octave mode.")
-(defvar octave-mode-syntax-table nil
- "Syntax table in use in octave-mode buffers.")
-(if octave-mode-syntax-table
- ()
+(defvar octave-mode-syntax-table
(let ((table (make-syntax-table)))
(modify-syntax-entry ?\r " " table)
(modify-syntax-entry ?+ "." table)
(modify-syntax-entry ?\" "\"" table)
(modify-syntax-entry ?. "w" table)
(modify-syntax-entry ?_ "w" table)
- (modify-syntax-entry ?\% "." table)
+ (modify-syntax-entry ?\% "<" table)
(modify-syntax-entry ?\# "<" table)
(modify-syntax-entry ?\n ">" table)
- (setq octave-mode-syntax-table table)))
+ table)
+ "Syntax table in use in `octave-mode' buffers.")
(defcustom octave-auto-indent nil
"*Non-nil means indent line after a semicolon or space in Octave mode."
"Alist of Octave symbols for completion in Octave mode.
Each element looks like (VAR . VAR), where the car and cdr are the same
symbol (an Octave command or variable name).
-Currently, only builtin variables can be completed.")
+Currently, only builtin variables can be completed.")
(defvar octave-mode-imenu-generic-expression
(list
"Imenu expression for Octave mode. See `imenu-generic-expression'.")
(defcustom octave-mode-startup-message t
- "*Nil means do not display the Octave mode startup message."
+ "*nil means do not display the Octave mode startup message."
:type 'boolean
:group 'octave)
Default is a backslash.
octave-mode-startup-message
- Nil means do not display the Octave mode startup message.
+ nil means do not display the Octave mode startup message.
Default is t.
octave-send-echo-input
(setq mode-name "Octave")
(setq local-abbrev-table octave-abbrev-table)
(set-syntax-table octave-mode-syntax-table)
-
+
(make-local-variable 'indent-line-function)
(setq indent-line-function 'octave-indent-line)
- (make-local-variable 'comment-start)
+ (make-local-variable 'comment-start)
(setq comment-start octave-comment-start)
(make-local-variable 'comment-end)
(setq comment-end "")
(make-local-variable 'comment-column)
- (setq comment-column 32)
+ (setq comment-column 32)
(make-local-variable 'comment-start-skip)
(setq comment-start-skip "\\s<+\\s-*")
(make-local-variable 'comment-indent-function)
(interactive)
(describe-function major-mode))
-(defun octave-point (position)
- "Returns the value of point at certain positions."
- (save-excursion
- (cond
- ((eq position 'bol) (beginning-of-line))
- ((eq position 'eol) (end-of-line))
- ((eq position 'boi) (back-to-indentation))
- ((eq position 'bonl) (forward-line 1))
- ((eq position 'bopl) (forward-line -1))
- (t (error "unknown buffer position requested: %s" position)))
- (point)))
-
(defsubst octave-in-comment-p ()
"Returns t if point is inside an Octave comment, nil otherwise."
(interactive)
(save-excursion
- (nth 4 (parse-partial-sexp (octave-point 'bol) (point)))))
+ (nth 4 (parse-partial-sexp (line-beginning-position) (point)))))
(defsubst octave-in-string-p ()
"Returns t if point is inside an Octave string, nil otherwise."
(interactive)
(save-excursion
- (nth 3 (parse-partial-sexp (octave-point 'bol) (point)))))
+ (nth 3 (parse-partial-sexp (line-beginning-position) (point)))))
(defsubst octave-not-in-string-or-comment-p ()
"Returns t iff point is not inside an Octave string or comment."
- (let ((pps (parse-partial-sexp (octave-point 'bol) (point))))
+ (let ((pps (parse-partial-sexp (line-beginning-position) (point))))
(not (or (nth 3 pps) (nth 4 pps)))))
(defun octave-in-block-p ()
(delete-horizontal-space)
(insert (concat " " octave-continuation-string))))
+(defvar octave-xemacs-p
+ (string-match "XEmacs\\|Lucid" emacs-version))
+
;;; Comments
(defun octave-comment-region (beg end &optional arg)
"Comment or uncomment each line in the region as Octave code.
(interactive "r\nP")
(let ((comment-start (char-to-string octave-comment-char)))
(comment-region beg end arg)))
-
+
(defun octave-uncomment-region (beg end &optional arg)
"Uncomment each line in the region as Octave code."
(interactive "r\nP")
(back-to-indentation)
(setq icol (current-column))
(let ((bot (point))
- (eol (octave-point 'eol)))
+ (eol (line-end-position)))
(while (< (point) eol)
(if (octave-not-in-string-or-comment-p)
(cond
(defun octave-indent-for-comment ()
"Maybe insert and indent an Octave comment.
If there is no comment already on this line, create a code-level comment
-(started by two comment characters) if the line is empty, or an in-line
-comment (started by one comment character) otherwise.
+\(started by two comment characters) if the line is empty, or an in-line
+comment (started by one comment character) otherwise.
Point is left after the start of the comment which is properly aligned."
(interactive)
(indent-for-comment)
(defun octave-indent-new-comment-line ()
"Break Octave line at point, continuing comment if within one.
If within code, insert `octave-continuation-string' before breaking the
-line. If within a string, signal an error.
-The new line is properly indented."
+line. If within a string, signal an error.
+The new line is properly indented."
(interactive)
(delete-horizontal-space)
(cond
(setq n (forward-line inc)))
(setq arg (- arg inc)))
n))
-
+
(defun octave-previous-code-line (&optional arg)
"Move ARG lines of Octave code backward (forward if ARG is negative).
Skips past all empty and comment lines. Default for ARG is 1.
(looking-at octave-continuation-regexp)))
(zerop (forward-line 1)))))
(end-of-line)))
-
+
(defun octave-scan-blocks (from count depth)
"Scan from character number FROM by COUNT Octave begin-end blocks.
Returns the character number of the position thus found.
(buffer-substring-no-properties
(match-beginning 0) pos)
pos (+ pos 1)
- eol (octave-point 'eol)
+ eol (line-end-position)
bb-arg
(save-excursion
(save-restriction
(interactive "p")
(or arg (setq arg 1))
(and (< arg 0) (skip-syntax-backward "w"))
- (and (> arg 0) (skip-syntax-forward "w"))
+ (and (> arg 0) (skip-syntax-forward "w"))
(if (octave-in-defun-p)
(setq arg (- arg 1)))
(if (= arg 0) (setq arg -1))
(exchange-point-and-mark))
(goto-char pos)
(message "No function to mark found"))))
-
+
\f
;;; Filling
(defun octave-auto-fill ()
(let (fc give-up)
(if (or (null (setq fc (current-fill-column)))
(save-excursion
- (beginning-of-line)
+ (beginning-of-line)
(and auto-fill-inhibit-regexp
(looking-at auto-fill-inhibit-regexp))))
nil ; Can't do anything
(if (save-excursion
(skip-syntax-backward " <")
(bolp))
- (re-search-forward "[ \t]" (octave-point 'eol)
+ (re-search-forward "[ \t]" (line-end-position)
'move))
;; If we're not in a comment line and just ahead the
;; continuation string, don't break here.
(defun octave-fill-paragraph (&optional arg)
"Fill paragraph of Octave code, handling Octave comments."
(interactive "P")
- (save-excursion
+ (save-excursion
(let ((end (progn (forward-paragraph) (point)))
(beg (progn
(forward-paragraph -1)
(beginning-of-line)
(looking-at "^\\s-*\\s<+\\s-*$"))))
;; This is a nonempty comment line which does not extend
- ;; past the fill column. If it is followed by an nonempty
+ ;; past the fill column. If it is followed by a nonempty
;; comment line with the same comment prefix, try to
;; combine them, and repeat this until either we reach the
;; fill-column or there is nothing more to combine.
(let ((list (all-completions string octave-completion-alist))
(conf (current-window-configuration)))
;; Taken from comint.el
- (message "Making completion list...")
+ (message "Making completion list...")
(with-output-to-temp-buffer "*Completions*"
(display-completion-list list))
(message "Hit space to flush")
(set-window-configuration conf)
(setq unread-command-events
(listify-key-sequence key))))))))))
-
+
\f
;;; Electric characters && friends
(defun octave-reindent-then-newline-and-indent ()
(self-insert-command 1)
(let (c)
(insert last-command-char)
- (if (or (eq (setq c (read-event)) ??)
- (eq c help-char))
- (let ((abbrev-table-name-list '(octave-mode-abbrev-table)))
+ (if (if octave-xemacs-p
+ (or (eq (event-to-character (setq c (next-event))) ??)
+ (eq (event-to-character c) help-char))
+ (or (eq (setq c (read-event)) ??)
+ (eq c help-char)))
+ (let ((abbrev-table-name-list '(octave-abbrev-table)))
(list-abbrevs))
(setq unread-command-events (list c))))))
(indent-according-to-mode)
(newline 2)
(insert prefix "usage: " string)
- (reindent-then-newline-and-indent)
+ (reindent-then-newline-and-indent)
(insert prefix)
- (reindent-then-newline-and-indent)
+ (reindent-then-newline-and-indent)
(insert prefix)
(indent-according-to-mode)
(save-excursion
(newline 2)
(insert "endfunction")
(indent-according-to-mode))))
-
+
\f
;;; Menu
(defun octave-add-octave-menu ()
"Adds the `Octave' menu to the menu bar in Octave mode."
- (require 'easymenu)
+ (require 'easymenu)
(easy-menu-define octave-mode-menu-map octave-mode-map
"Menu keymap for Octave mode." octave-mode-menu)
(easy-menu-add octave-mode-menu-map octave-mode-map))
(defun octave-send-region (beg end)
"Send current region to the inferior Octave process."
(interactive "r")
- (inferior-octave t)
+ (inferior-octave t)
(let ((proc inferior-octave-process)
(string (buffer-substring-no-properties beg end))
line)
(display-buffer inferior-octave-buffer)))
(defun octave-send-block ()
- "Send current Octave block to the inferior Octave process."
+ "Send current Octave block to the inferior Octave process."
(interactive)
(save-excursion
(octave-mark-block)
(print-escape-newlines nil)
(opoint (point)))
(terpri)
- (prin1
+ (prin1
(save-excursion
(forward-sexp -1)
(inferior-octave-send-list-and-digest
(provide 'octave-mod)
+;;; arch-tag: 05f1ce09-be87-4c00-803e-4919ffa26c23
;;; octave-mod.el ends here