HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add 2011 to FSF/AIST copyright years.
[bpt/emacs.git] / lisp / progmodes / octave-mod.el
CommitLineData
092af6d8 1;;; octave-mod.el --- editing Octave source files under Emacs
f2727dfb 2
5df4f04c 3;; Copyright (C) 1997, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
034babe1 4;; Free Software Foundation, Inc.
f2727dfb 5
f7fba1a8 6;; Author: Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>
f2727dfb 7;; Author: John Eaton <jwe@bevo.che.wisc.edu>
f7fba1a8 8;; Maintainer: Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>
f2727dfb
RS		 9;; Keywords: languages
10
11;; This file is part of GNU Emacs.
12
b1fc2b50 13;; GNU Emacs is free software: you can redistribute it and/or modify
f2727dfb 14;; it under the terms of the GNU General Public License as published by
b1fc2b50
GM		 15;; the Free Software Foundation, either version 3 of the License, or
16;; (at your option) any later version.
f2727dfb
RS		 17
18;; GNU Emacs is distributed in the hope that it will be useful,
19;; but WITHOUT ANY WARRANTY; without even the implied warranty of
20;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21;; GNU General Public License for more details.
22
23;; You should have received a copy of the GNU General Public License
b1fc2b50 24;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
f2727dfb
RS		 25
26;;; Commentary:
27
d1e49742
RS		 28;; This package provides Emacs support for Octave.
29;; It defines Octave mode, a major mode for editing
30;; Octave code.
31
d1e49742
RS		 32;; The file octave-inf.el contains code for interacting with an inferior
33;; Octave process using comint.
f2727dfb 34
5d8137ab 35;; See the documentation of `octave-mode' and
d1e49742 36;; `run-octave' for further information on usage and customization.
f2727dfb 37
d1e49742 38;;; Code:
2454554e 39(require 'custom)
f2727dfb 40
28d16ed3
AS		 41(defgroup octave nil
42 "Major mode for editing Octave source files."
8ec3bce0 43 :link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces)
28d16ed3
AS		 44 :group 'languages)
45
e09735aa
RS		 46(defvar inferior-octave-output-list nil)
47(defvar inferior-octave-output-string nil)
48(defvar inferior-octave-receive-in-progress nil)
49
004a00f4
DN		 50(declare-function inferior-octave-send-list-and-digest "octave-inf" (list))
51
e7017ef9 52(defconst octave-maintainer-address
f7fba1a8 53 "Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>, bug-gnu-emacs@gnu.org"
e7017ef9
RS		 54 "Current maintainer of the Emacs Octave package.")
55
7210c33f
SM		 56(define-abbrev-table 'octave-abbrev-table
57 (mapcar (lambda (e) (append e '(nil 0 t)))
58 '(("`a" "all_va_args")
59 ("`b" "break")
60 ("`cs" "case")
61 ("`ca" "catch")
62 ("`c" "continue")
63 ("`el" "else")
64 ("`eli" "elseif")
65 ("`et" "end_try_catch")
66 ("`eu" "end_unwind_protect")
67 ("`ef" "endfor")
68 ("`efu" "endfunction")
69 ("`ei" "endif")
70 ("`es" "endswitch")
71 ("`ew" "endwhile")
72 ("`f" "for")
73 ("`fu" "function")
74 ("`gl" "global")
75 ("`gp" "gplot")
76 ("`gs" "gsplot")
77 ("`if" "if ()")
78 ("`o" "otherwise")
79 ("`rp" "replot")
80 ("`r" "return")
81 ("`s" "switch")
82 ("`t" "try")
83 ("`u" "until ()")
84 ("`up" "unwind_protect")
85 ("`upc" "unwind_protect_cleanup")
86 ("`w" "while ()")))
e7017ef9 87 "Abbrev table for Octave's reserved words.
99158127 88Used in `octave-mode' and inferior-octave-mode buffers.
7210c33f
SM		 89All Octave abbrevs start with a grave accent (`)."
90 :regexp "\\(?:[^`]\\|^\\)\\(\\(?:\\<\\|`\\)\\w+\\)\\W*")
e7017ef9
RS		 91
92(defvar octave-comment-char ?#
93 "Character to start an Octave comment.")
94(defvar octave-comment-start
cb3d3ec1 95 (string octave-comment-char ?\ )
e7017ef9
RS		 96 "String to insert to start a new Octave in-line comment.")
97(defvar octave-comment-start-skip "\\s<+\\s-*"
98 "Regexp to match the start of an Octave comment up to its body.")
99
100(defvar octave-begin-keywords
490a8abe 101 '("do" "for" "function" "if" "switch" "try" "unwind_protect" "while"))
e7017ef9 102(defvar octave-else-keywords
6e6d2764 103 '("case" "catch" "else" "elseif" "otherwise" "unwind_protect_cleanup"))
e7017ef9 104(defvar octave-end-keywords
490a8abe 105 '("endfor" "endfunction" "endif" "endswitch" "end_try_catch"
b2ad70b6 106 "end_unwind_protect" "endwhile" "until" "end"))
e7017ef9
RS		 107
108(defvar octave-reserved-words
6e6d2764
KH		 109 (append octave-begin-keywords
110 octave-else-keywords
111 octave-end-keywords
490a8abe 112 '("break" "continue" "end" "global" "persistent" "return"))
e7017ef9
RS		 113 "Reserved words in Octave.")
114
115(defvar octave-text-functions
116 '("casesen" "cd" "chdir" "clear" "diary" "dir" "document" "echo"
490a8abe
GM		 117 "edit_history" "format" "help" "history" "hold"
118 "load" "ls" "more" "run_history" "save" "type"
e7017ef9 119 "which" "who" "whos")
490a8abe 120 "Text functions in Octave.")
e7017ef9
RS		 121
122(defvar octave-variables
490a8abe
GM		 123 '("DEFAULT_EXEC_PATH" "DEFAULT_LOADPATH"
124 "EDITOR" "EXEC_PATH" "F_DUPFD" "F_GETFD" "F_GETFL" "F_SETFD"
125 "F_SETFL" "I" "IMAGE_PATH" "Inf" "J"
126 "NaN" "OCTAVE_VERSION" "O_APPEND" "O_CREAT" "O_EXCL"
e7017ef9
RS		 127 "O_NONBLOCK" "O_RDONLY" "O_RDWR" "O_TRUNC" "O_WRONLY" "PAGER" "PS1"
128 "PS2" "PS4" "PWD" "SEEK_CUR" "SEEK_END" "SEEK_SET" "__F_DUPFD__"
129 "__F_GETFD__" "__F_GETFL__" "__F_SETFD__" "__F_SETFL__" "__I__"
130 "__Inf__" "__J__" "__NaN__" "__OCTAVE_VERSION__" "__O_APPEND__"
131 "__O_CREAT__" "__O_EXCL__" "__O_NONBLOCK__" "__O_RDONLY__"
132 "__O_RDWR__" "__O_TRUNC__" "__O_WRONLY__" "__PWD__" "__SEEK_CUR__"
133 "__SEEK_END__" "__SEEK_SET__" "__argv__" "__e__" "__eps__"
490a8abe 134 "__i__" "__inf__" "__j__" "__nan__" "__pi__"
e7017ef9
RS		 135 "__program_invocation_name__" "__program_name__" "__realmax__"
136 "__realmin__" "__stderr__" "__stdin__" "__stdout__" "ans" "argv"
490a8abe
GM		 137 "beep_on_error" "completion_append_char"
138 "crash_dumps_octave_core" "default_save_format"
139 "e" "echo_executing_commands" "eps"
140 "error_text" "gnuplot_binary" "history_file"
141 "history_size" "ignore_function_time_stamp"
142 "inf" "nan" "nargin" "output_max_field_width" "output_precision"
e7017ef9 143 "page_output_immediately" "page_screen_output" "pi"
e7017ef9 144 "print_answer_id_name" "print_empty_dimensions"
490a8abe
GM		 145 "program_invocation_name" "program_name"
146 "realmax" "realmin" "return_last_computed_value" "save_precision"
147 "saving_history" "sighup_dumps_octave_core" "sigterm_dumps_octave_core"
e7017ef9
RS		 148 "silent_functions" "split_long_rows" "stderr" "stdin" "stdout"
149 "string_fill_char" "struct_levels_to_print"
490a8abe 150 "suppress_verbose_help_message")
e7017ef9
RS		 151 "Builtin variables in Octave.")
152
153(defvar octave-function-header-regexp
154 (concat "^\\s-*\\<\\(function\\)\\>"
155 "\\([^=;\n]*=[ \t]*\\|[ \t]*\\)\\(\\w+\\)\\>")
156 "Regexp to match an Octave function header.
157The string `function' and its name are given by the first and third
158parenthetical grouping.")
159
160(defvar octave-font-lock-keywords
161 (list
162 ;; Fontify all builtin keywords.
163 (cons (concat "\\<\\("
164 (mapconcat 'identity octave-reserved-words "\\|")
165 (mapconcat 'identity octave-text-functions "\\|")
166 "\\)\\>")
167 'font-lock-keyword-face)
168 ;; Fontify all builtin operators.
169 (cons "\\(&\\||\\|<=\\|>=\\|==\\|<\\|>\\|!=\\|!\\)"
cb41203e
GM		 170 (if (boundp 'font-lock-builtin-face)
171 'font-lock-builtin-face
172 'font-lock-preprocessor-face))
e7017ef9
RS		 173 ;; Fontify all builtin variables.
174 (cons (concat "\\<\\("
175 (mapconcat 'identity octave-variables "\\|")
176 "\\)\\>")
177 'font-lock-variable-name-face)
178 ;; Fontify all function declarations.
179 (list octave-function-header-regexp
180 '(1 font-lock-keyword-face)
181 '(3 font-lock-function-name-face nil t)))
182 "Additional Octave expressions to highlight.")
183
28d16ed3 184(defcustom inferior-octave-buffer "*Inferior Octave*"
e22bbd48 185 "Name of buffer for running an inferior Octave process."
28d16ed3
AS		 186 :type 'string
187 :group 'octave-inferior)
e7017ef9
RS		 188
189(defvar inferior-octave-process nil)
190\f
e22bbd48 191(defvar octave-mode-map
f2727dfb
RS		 192 (let ((map (make-sparse-keymap)))
193 (define-key map "`" 'octave-abbrev-start)
194 (define-key map ";" 'octave-electric-semi)
195 (define-key map " " 'octave-electric-space)
196 (define-key map "\n" 'octave-reindent-then-newline-and-indent)
f2727dfb 197 (define-key map "\e;" 'octave-indent-for-comment)
a1506d29 198 (define-key map "\e\n" 'octave-indent-new-comment-line)
f2727dfb
RS		 199 (define-key map "\e\t" 'octave-complete-symbol)
200 (define-key map "\M-\C-a" 'octave-beginning-of-defun)
201 (define-key map "\M-\C-e" 'octave-end-of-defun)
202 (define-key map "\M-\C-h" 'octave-mark-defun)
a1506d29 203 (define-key map "\M-\C-q" 'octave-indent-defun)
f2727dfb 204 (define-key map "\C-c;" 'octave-comment-region)
a1506d29 205 (define-key map "\C-c:" 'octave-uncomment-region)
f2727dfb
RS		 206 (define-key map "\C-c\C-b" 'octave-submit-bug-report)
207 (define-key map "\C-c\C-p" 'octave-previous-code-line)
208 (define-key map "\C-c\C-n" 'octave-next-code-line)
209 (define-key map "\C-c\C-a" 'octave-beginning-of-line)
a1506d29 210 (define-key map "\C-c\C-e" 'octave-end-of-line)
f2727dfb
RS		 211 (define-key map "\C-c\M-\C-n" 'octave-forward-block)
212 (define-key map "\C-c\M-\C-p" 'octave-backward-block)
213 (define-key map "\C-c\M-\C-u" 'octave-backward-up-block)
214 (define-key map "\C-c\M-\C-d" 'octave-down-block)
215 (define-key map "\C-c\M-\C-h" 'octave-mark-block)
216 (define-key map "\C-c]" 'octave-close-block)
34a463f1 217 (define-key map "\C-c\C-f" 'octave-insert-defun)
f2727dfb 218 (define-key map "\C-c\C-h" 'octave-help)
34a463f1
RS		 219 (define-key map "\C-c\C-il" 'octave-send-line)
220 (define-key map "\C-c\C-ib" 'octave-send-block)
221 (define-key map "\C-c\C-if" 'octave-send-defun)
a1506d29 222 (define-key map "\C-c\C-ir" 'octave-send-region)
34a463f1
RS		 223 (define-key map "\C-c\C-is" 'octave-show-process-buffer)
224 (define-key map "\C-c\C-ih" 'octave-hide-process-buffer)
225 (define-key map "\C-c\C-ik" 'octave-kill-process)
226 (define-key map "\C-c\C-i\C-l" 'octave-send-line)
227 (define-key map "\C-c\C-i\C-b" 'octave-send-block)
228 (define-key map "\C-c\C-i\C-f" 'octave-send-defun)
a1506d29 229 (define-key map "\C-c\C-i\C-r" 'octave-send-region)
34a463f1
RS		 230 (define-key map "\C-c\C-i\C-s" 'octave-show-process-buffer)
231 (define-key map "\C-c\C-i\C-h" 'octave-hide-process-buffer)
232 (define-key map "\C-c\C-i\C-k" 'octave-kill-process)
e22bbd48
SM		 233 map)
234 "Keymap used in Octave mode.")
235
f2727dfb
RS		 236
237(defvar octave-mode-menu
e22bbd48 238 '("Octave"
67885e8c 239 ("Lines"
e22bbd48
SM		 240 ["Previous Code Line" octave-previous-code-line t]
241 ["Next Code Line" octave-next-code-line t]
242 ["Begin of Continuation" octave-beginning-of-line t]
243 ["End of Continuation" octave-end-of-line t]
244 ["Split Line at Point" octave-indent-new-comment-line t])
67885e8c 245 ("Blocks"
e22bbd48
SM		 246 ["Next Block" octave-forward-block t]
247 ["Previous Block" octave-backward-block t]
248 ["Down Block" octave-down-block t]
249 ["Up Block" octave-backward-up-block t]
250 ["Mark Block" octave-mark-block t]
251 ["Close Block" octave-close-block t])
67885e8c 252 ("Functions"
e22bbd48
SM		 253 ["Begin of Function" octave-beginning-of-defun t]
254 ["End of Function" octave-end-of-defun t]
255 ["Mark Function" octave-mark-defun t]
256 ["Indent Function" octave-indent-defun t]
257 ["Insert Function" octave-insert-defun t])
258 "-"
67885e8c 259 ("Debug"
e22bbd48
SM		 260 ["Send Current Line" octave-send-line t]
261 ["Send Current Block" octave-send-block t]
262 ["Send Current Function" octave-send-defun t]
263 ["Send Region" octave-send-region t]
264 ["Show Process Buffer" octave-show-process-buffer t]
265 ["Hide Process Buffer" octave-hide-process-buffer t]
266 ["Kill Process" octave-kill-process t])
267 "-"
268 ["Indent Line" indent-according-to-mode t]
269 ["Complete Symbol" octave-complete-symbol t]
270 "-"
271 ["Toggle Abbrev Mode" abbrev-mode t]
272 ["Toggle Auto-Fill Mode" auto-fill-mode t]
273 "-"
274 ["Submit Bug Report" octave-submit-bug-report t]
275 "-"
276 ["Describe Octave Mode" octave-describe-major-mode t]
277 ["Lookup Octave Index" octave-help t])
f2727dfb
RS		 278 "Menu for Octave mode.")
279
cb3d3ec1 280(defvar octave-mode-syntax-table
f2727dfb
RS		 281 (let ((table (make-syntax-table)))
282 (modify-syntax-entry ?\r " " table)
283 (modify-syntax-entry ?+ "." table)
284 (modify-syntax-entry ?- "." table)
285 (modify-syntax-entry ?= "." table)
286 (modify-syntax-entry ?* "." table)
287 (modify-syntax-entry ?/ "." table)
288 (modify-syntax-entry ?> "." table)
289 (modify-syntax-entry ?< "." table)
290 (modify-syntax-entry ?& "." table)
291 (modify-syntax-entry ?| "." table)
292 (modify-syntax-entry ?! "." table)
293 (modify-syntax-entry ?\\ "\\" table)
294 (modify-syntax-entry ?\' "." table)
7210c33f
SM		 295 ;; Was "w" for abbrevs, but now that it's not necessary any more,
296 (modify-syntax-entry ?\` "." table)
f2727dfb
RS		 297 (modify-syntax-entry ?\" "\"" table)
298 (modify-syntax-entry ?. "w" table)
299 (modify-syntax-entry ?_ "w" table)
cb3d3ec1 300 (modify-syntax-entry ?\% "<" table)
f2727dfb
RS		 301 (modify-syntax-entry ?\# "<" table)
302 (modify-syntax-entry ?\n ">" table)
cb3d3ec1
SM		 303 table)
304 "Syntax table in use in `octave-mode' buffers.")
f2727dfb 305
28d16ed3 306(defcustom octave-auto-indent nil
e22bbd48 307 "Non-nil means indent line after a semicolon or space in Octave mode."
28d16ed3 308 :type 'boolean
2454554e 309 :group 'octave)
d83ee578 310
28d16ed3 311(defcustom octave-auto-newline nil
e22bbd48 312 "Non-nil means automatically newline after a semicolon in Octave mode."
28d16ed3
AS		 313 :type 'boolean
314 :group 'octave)
f2727dfb 315
28d16ed3 316(defcustom octave-blink-matching-block t
e22bbd48 317 "Control the blinking of matching Octave block keywords.
f2727dfb 318Non-nil means show matching begin of block when inserting a space,
28d16ed3
AS		 319newline or semicolon after an else or end keyword."
320 :type 'boolean
321 :group 'octave)
322(defcustom octave-block-offset 2
e22bbd48 323 "Extra indentation applied to statements in Octave block structures."
28d16ed3
AS		 324 :type 'integer
325 :group 'octave)
f2727dfb
RS		 326
327(defvar octave-block-begin-regexp
328 (concat "\\<\\("
329 (mapconcat 'identity octave-begin-keywords "\\|")
330 "\\)\\>"))
331(defvar octave-block-else-regexp
332 (concat "\\<\\("
333 (mapconcat 'identity octave-else-keywords "\\|")
334 "\\)\\>"))
335(defvar octave-block-end-regexp
336 (concat "\\<\\("
337 (mapconcat 'identity octave-end-keywords "\\|")
338 "\\)\\>"))
339(defvar octave-block-begin-or-end-regexp
340 (concat octave-block-begin-regexp "\\|" octave-block-end-regexp))
341(defvar octave-block-else-or-end-regexp
342 (concat octave-block-else-regexp "\\|" octave-block-end-regexp))
343(defvar octave-block-match-alist
490a8abe 344 '(("do" . ("until"))
b2ad70b6 345 ("for" . ("endfor" "end"))
490a8abe 346 ("function" . ("endfunction"))
b2ad70b6
CY		 347 ("if" . ("else" "elseif" "endif" "end"))
348 ("switch" . ("case" "otherwise" "endswitch" "end"))
490a8abe
GM		 349 ("try" . ("catch" "end_try_catch"))
350 ("unwind_protect" . ("unwind_protect_cleanup" "end_unwind_protect"))
b2ad70b6 351 ("while" . ("endwhile" "end")))
f2727dfb
RS		 352 "Alist with Octave's matching block keywords.
353Has Octave's begin keywords as keys and a list of the matching else or
354end keywords as associated values.")
355
356(defvar octave-block-comment-start
357 (concat (make-string 2 octave-comment-char) " ")
358 "String to insert to start a new Octave comment on an empty line.")
359
28d16ed3 360(defcustom octave-continuation-offset 4
e22bbd48 361 "Extra indentation applied to Octave continuation lines."
28d16ed3
AS		 362 :type 'integer
363 :group 'octave)
f2727dfb
RS		 364(defvar octave-continuation-regexp
365 "[^#%\n]*\\(\\\\\\|\\.\\.\\.\\)\\s-*\\(\\s<.*\\)?$")
28d16ed3 366(defcustom octave-continuation-string "\\"
e22bbd48 367 "Character string used for Octave continuation lines. Normally \\."
28d16ed3
AS		 368 :type 'string
369 :group 'octave)
f2727dfb
RS		 370
371(defvar octave-completion-alist nil
372 "Alist of Octave symbols for completion in Octave mode.
373Each element looks like (VAR . VAR), where the car and cdr are the same
374symbol (an Octave command or variable name).
a1506d29 375Currently, only builtin variables can be completed.")
f2727dfb
RS		 376
377(defvar octave-mode-imenu-generic-expression
378 (list
379 ;; Functions
380 (list nil octave-function-header-regexp 3))
381 "Imenu expression for Octave mode. See `imenu-generic-expression'.")
382
28d16ed3 383(defcustom octave-mode-hook nil
e22bbd48 384 "Hook to be run when Octave mode is started."
28d16ed3
AS		 385 :type 'hook
386 :group 'octave)
387
388(defcustom octave-send-show-buffer t
e22bbd48 389 "Non-nil means display `inferior-octave-buffer' after sending to it."
28d16ed3
AS		 390 :type 'boolean
391 :group 'octave)
392(defcustom octave-send-line-auto-forward t
e22bbd48 393 "Control auto-forward after sending to the inferior Octave process.
28d16ed3
AS		 394Non-nil means always go to the next Octave code line after sending."
395 :type 'boolean
396 :group 'octave)
397(defcustom octave-send-echo-input t
e22bbd48 398 "Non-nil means echo input sent to the inferior Octave process."
28d16ed3
AS		 399 :type 'boolean
400 :group 'octave)
f2727dfb
RS		 401
402\f
403;;;###autoload
404(defun octave-mode ()
405 "Major mode for editing Octave code.
406
407This mode makes it easier to write Octave code by helping with
408indentation, doing some of the typing for you (with Abbrev mode) and by
0472835f 409showing keywords, comments, strings, etc. in different faces (with
f2727dfb
RS		 410Font Lock mode on terminals that support it).
411
412Octave itself is a high-level language, primarily intended for numerical
413computations. It provides a convenient command line interface for
414solving linear and nonlinear problems numerically. Function definitions
415can also be stored in files, and it can be used in a batch mode (which
416is why you need this mode!).
417
418The latest released version of Octave is always available via anonymous
490a8abe 419ftp from ftp.octave.org in the directory `/pub/octave'. Complete
f2727dfb
RS		 420source and binaries for several popular systems are available.
421
422Type \\[list-abbrevs] to display the built-in abbrevs for Octave keywords.
423
424Keybindings
425===========
426
427\\{octave-mode-map}
428
429Variables you can use to customize Octave mode
430==============================================
431
e22bbd48 432`octave-auto-indent'
d83ee578
KH		 433 Non-nil means indent current line after a semicolon or space.
434 Default is nil.
435
e22bbd48 436`octave-auto-newline'
f2727dfb
RS		 437 Non-nil means auto-insert a newline and indent after a semicolon.
438 Default is nil.
439
e22bbd48 440`octave-blink-matching-block'
f2727dfb
RS		 441 Non-nil means show matching begin of block when inserting a space,
442 newline or semicolon after an else or end keyword. Default is t.
443
e22bbd48 444`octave-block-offset'
f2727dfb
RS		 445 Extra indentation applied to statements in block structures.
446 Default is 2.
447
e22bbd48 448`octave-continuation-offset'
f2727dfb
RS		 449 Extra indentation applied to Octave continuation lines.
450 Default is 4.
451
e22bbd48 452`octave-continuation-string'
f2727dfb
RS		 453 String used for Octave continuation lines.
454 Default is a backslash.
455
e22bbd48 456`octave-send-echo-input'
f2727dfb
RS		 457 Non-nil means always display `inferior-octave-buffer' after sending a
458 command to the inferior Octave process.
459
e22bbd48 460`octave-send-line-auto-forward'
f2727dfb
RS		 461 Non-nil means always go to the next unsent line of Octave code after
462 sending a line to the inferior Octave process.
463
e22bbd48 464`octave-send-echo-input'
f2727dfb
RS		 465 Non-nil means echo input sent to the inferior Octave process.
466
467Turning on Octave mode runs the hook `octave-mode-hook'.
468
469To begin using this mode for all `.m' files that you edit, add the
470following lines to your `.emacs' file:
471
e22bbd48 472 (add-to-list 'auto-mode-alist '(\"\\\\.m\\\\'\" . octave-mode))
f2727dfb 473
490a8abe 474To automatically turn on the abbrev and auto-fill features,
f2727dfb
RS		 475add the following lines to your `.emacs' file as well:
476
477 (add-hook 'octave-mode-hook
478 (lambda ()
479 (abbrev-mode 1)
e22bbd48 480 (auto-fill-mode 1)))
f2727dfb
RS		 481
482To submit a problem report, enter \\[octave-submit-bug-report] from \
483an Octave mode buffer.
484This automatically sets up a mail buffer with version information
485already added. You just need to add a description of the problem,
486including a reproducible test case and send the message."
487 (interactive)
488 (kill-all-local-variables)
489
490 (use-local-map octave-mode-map)
491 (setq major-mode 'octave-mode)
492 (setq mode-name "Octave")
493 (setq local-abbrev-table octave-abbrev-table)
494 (set-syntax-table octave-mode-syntax-table)
a1506d29 495
f2727dfb
RS		 496 (make-local-variable 'indent-line-function)
497 (setq indent-line-function 'octave-indent-line)
498
a1506d29 499 (make-local-variable 'comment-start)
f2727dfb
RS		 500 (setq comment-start octave-comment-start)
501 (make-local-variable 'comment-end)
502 (setq comment-end "")
503 (make-local-variable 'comment-column)
a1506d29 504 (setq comment-column 32)
f2727dfb
RS		 505 (make-local-variable 'comment-start-skip)
506 (setq comment-start-skip "\\s<+\\s-*")
507 (make-local-variable 'comment-indent-function)
508 (setq comment-indent-function 'octave-comment-indent)
509
510 (make-local-variable 'parse-sexp-ignore-comments)
511 (setq parse-sexp-ignore-comments t)
512 (make-local-variable 'paragraph-start)
513 (setq paragraph-start (concat "\\s-*$\\|" page-delimiter))
514 (make-local-variable 'paragraph-separate)
515 (setq paragraph-separate paragraph-start)
516 (make-local-variable 'paragraph-ignore-fill-prefix)
517 (setq paragraph-ignore-fill-prefix t)
518 (make-local-variable 'fill-paragraph-function)
519 (setq fill-paragraph-function 'octave-fill-paragraph)
520 (make-local-variable 'adaptive-fill-regexp)
521 (setq adaptive-fill-regexp nil)
522 (make-local-variable 'fill-column)
523 (setq fill-column 72)
524 (make-local-variable 'normal-auto-fill-function)
525 (setq normal-auto-fill-function 'octave-auto-fill)
526
527 (make-local-variable 'font-lock-defaults)
528 (setq font-lock-defaults '(octave-font-lock-keywords nil nil))
529
530 (make-local-variable 'imenu-generic-expression)
c0b08eb0
DL		 531 (setq imenu-generic-expression octave-mode-imenu-generic-expression
532 imenu-case-fold-search nil)
f2727dfb
RS		 533
534 (octave-add-octave-menu)
535 (octave-initialize-completions)
9a969196 536 (run-mode-hooks 'octave-mode-hook))
5d8137ab
SM		 537
538(defun octave-help ()
539 "Get help on Octave symbols from the Octave info files.
540Look up symbol in the function, operator and variable indices of the info files."
541 (let ((info-lookup-mode 'octave-mode))
542 (call-interactively 'info-lookup-symbol)))
f2727dfb
RS		 543\f
544;;; Miscellaneous useful functions
545(defun octave-describe-major-mode ()
546 "Describe the current major mode."
547 (interactive)
548 (describe-function major-mode))
549
f2727dfb 550(defsubst octave-in-comment-p ()
e7f767c2 551 "Return t if point is inside an Octave comment."
f2727dfb
RS		 552 (interactive)
553 (save-excursion
cb3d3ec1 554 (nth 4 (parse-partial-sexp (line-beginning-position) (point)))))
f2727dfb
RS		 555
556(defsubst octave-in-string-p ()
e7f767c2 557 "Return t if point is inside an Octave string."
f2727dfb
RS		 558 (interactive)
559 (save-excursion
cb3d3ec1 560 (nth 3 (parse-partial-sexp (line-beginning-position) (point)))))
f2727dfb
RS		 561
562(defsubst octave-not-in-string-or-comment-p ()
e7f767c2 563 "Return t if point is not inside an Octave string or comment."
cb3d3ec1 564 (let ((pps (parse-partial-sexp (line-beginning-position) (point))))
f2727dfb
RS		 565 (not (or (nth 3 pps) (nth 4 pps)))))
566
567(defun octave-in-block-p ()
e7f767c2 568 "Return t if point is inside an Octave block.
f2727dfb
RS		 569The block is taken to start at the first letter of the begin keyword and
570to end after the end keyword."
571 (let ((pos (point)))
572 (save-excursion
573 (condition-case nil
574 (progn
575 (skip-syntax-forward "w")
576 (octave-up-block -1)
577 (octave-forward-block)
578 t)
579 (error nil))
580 (< pos (point)))))
581
a584f30f 582(defun octave-looking-at-kw (regexp)
050a4b35 583 "Like `looking-at', but sets `case-fold-search' nil."
a584f30f
GM		 584 (let ((case-fold-search nil))
585 (looking-at regexp)))
586
050a4b35
GM		 587(defun octave-re-search-forward-kw (regexp count)
588 "Like `re-search-forward', but sets `case-fold-search' nil, and moves point."
a584f30f 589 (let ((case-fold-search nil))
050a4b35 590 (re-search-forward regexp nil 'move count)))
a584f30f 591
050a4b35
GM		 592(defun octave-re-search-backward-kw (regexp count)
593 "Like `re-search-backward', but sets `case-fold-search' nil, and moves point."
a584f30f 594 (let ((case-fold-search nil))
050a4b35 595 (re-search-backward regexp nil 'move count)))
a584f30f 596
f2727dfb 597(defun octave-in-defun-p ()
e7f767c2 598 "Return t if point is inside an Octave function declaration.
f2727dfb
RS		 599The function is taken to start at the `f' of `function' and to end after
600the end keyword."
601 (let ((pos (point)))
602 (save-excursion
a584f30f 603 (or (and (octave-looking-at-kw "\\<function\\>")
f2727dfb
RS		 604 (octave-not-in-string-or-comment-p))
605 (and (octave-beginning-of-defun)
606 (condition-case nil
607 (progn
608 (octave-forward-block)
609 t)
610 (error nil))
611 (< pos (point)))))))
612
d83ee578
KH		 613(defun octave-maybe-insert-continuation-string ()
614 (if (or (octave-in-comment-p)
615 (save-excursion
616 (beginning-of-line)
617 (looking-at octave-continuation-regexp)))
618 nil
619 (delete-horizontal-space)
620 (insert (concat " " octave-continuation-string))))
621
f2727dfb
RS		 622;;; Comments
623(defun octave-comment-region (beg end &optional arg)
624 "Comment or uncomment each line in the region as Octave code.
625See `comment-region'."
626 (interactive "r\nP")
627 (let ((comment-start (char-to-string octave-comment-char)))
628 (comment-region beg end arg)))
a1506d29 629
f2727dfb
RS		 630(defun octave-uncomment-region (beg end &optional arg)
631 "Uncomment each line in the region as Octave code."
632 (interactive "r\nP")
633 (or arg (setq arg 1))
634 (octave-comment-region beg end (- arg)))
635
636\f
637;;; Indentation
638(defun calculate-octave-indent ()
639 "Return appropriate indentation for current line as Octave code.
640Returns an integer (the column to indent to) unless the line is a
641comment line with fixed goal golumn. In that case, returns a list whose
642car is the column to indent to, and whose cdr is the current indentation
643level."
644 (let ((is-continuation-line
645 (save-excursion
646 (if (zerop (octave-previous-code-line))
647 (looking-at octave-continuation-regexp))))
648 (icol 0))
649 (save-excursion
650 (beginning-of-line)
651 ;; If we can move backward out one level of parentheses, take 1
652 ;; plus the indentation of that parenthesis. Otherwise, go back
653 ;; to the beginning of the previous code line, and compute the
654 ;; offset this line gives.
655 (if (condition-case nil
656 (progn
657 (up-list -1)
658 t)
659 (error nil))
660 (setq icol (+ 1 (current-column)))
661 (if (zerop (octave-previous-code-line))
662 (progn
663 (octave-beginning-of-line)
664 (back-to-indentation)
665 (setq icol (current-column))
666 (let ((bot (point))
cb3d3ec1 667 (eol (line-end-position)))
f2727dfb
RS		 668 (while (< (point) eol)
669 (if (octave-not-in-string-or-comment-p)
670 (cond
a584f30f 671 ((octave-looking-at-kw "\\<switch\\>")
6e6d2764 672 (setq icol (+ icol (* 2 octave-block-offset))))
a584f30f 673 ((octave-looking-at-kw octave-block-begin-regexp)
f2727dfb 674 (setq icol (+ icol octave-block-offset)))
a584f30f 675 ((octave-looking-at-kw octave-block-else-regexp)
f2727dfb
RS		 676 (if (= bot (point))
677 (setq icol (+ icol octave-block-offset))))
a584f30f 678 ((octave-looking-at-kw octave-block-end-regexp)
b2ad70b6
CY		 679 (if (and (not (= bot (point)))
680 ;; special case for `end' keyword,
681 ;; applied to all keywords
682 (not (octave-end-as-array-index-p)))
6e6d2764
KH		 683 (setq icol (- icol
684 (octave-block-end-offset)))))))
f2727dfb
RS		 685 (forward-char)))
686 (if is-continuation-line
687 (setq icol (+ icol octave-continuation-offset)))))))
688 (save-excursion
689 (back-to-indentation)
690 (cond
a584f30f 691 ((and (octave-looking-at-kw octave-block-else-regexp)
f2727dfb
RS		 692 (octave-not-in-string-or-comment-p))
693 (setq icol (- icol octave-block-offset)))
a584f30f 694 ((and (octave-looking-at-kw octave-block-end-regexp)
6e6d2764
KH		 695 (octave-not-in-string-or-comment-p))
696 (setq icol (- icol (octave-block-end-offset))))
d83ee578
KH		 697 ((or (looking-at "\\s<\\s<\\s<\\S<")
698 (octave-before-magic-comment-p))
f2727dfb
RS		 699 (setq icol (list 0 icol)))
700 ((looking-at "\\s<\\S<")
701 (setq icol (list comment-column icol)))))
702 icol))
703
b2ad70b6
CY		 704;; FIXME: this should probably also make sure we are actually looking
705;; at the "end" keyword.
706(defun octave-end-as-array-index-p ()
707 (save-excursion
708 (condition-case nil
709 ;; Check if point is between parens
710 (progn (up-list 1) t)
711 (error nil))))
712
6e6d2764
KH		 713(defun octave-block-end-offset ()
714 (save-excursion
715 (octave-backward-up-block 1)
716 (* octave-block-offset
717 (if (string-match (match-string 0) "switch") 2 1))))
718
d83ee578
KH		 719(defun octave-before-magic-comment-p ()
720 (save-excursion
721 (beginning-of-line)
722 (and (bobp) (looking-at "\\s-*#!"))))
723
f2727dfb 724(defun octave-comment-indent ()
d83ee578
KH		 725 (if (or (looking-at "\\s<\\s<\\s<")
726 (octave-before-magic-comment-p))
f2727dfb
RS		 727 0
728 (if (looking-at "\\s<\\s<")
729 (calculate-octave-indent)
730 (skip-syntax-backward " ")
6e6d2764 731 (max (if (bolp) 0 (+ 1 (current-column)))
f2727dfb
RS		 732 comment-column))))
733
734(defun octave-indent-for-comment ()
735 "Maybe insert and indent an Octave comment.
736If there is no comment already on this line, create a code-level comment
52dcc114 737\(started by two comment characters) if the line is empty, or an in-line
a1506d29 738comment (started by one comment character) otherwise.
f2727dfb
RS		 739Point is left after the start of the comment which is properly aligned."
740 (interactive)
0c93f715
EZ		 741 (beginning-of-line)
742 (if (looking-at "^\\s-*$")
743 (insert octave-block-comment-start)
744 (indent-for-comment))
f2727dfb
RS		 745 (indent-according-to-mode))
746
747(defun octave-indent-line (&optional arg)
748 "Indent current line as Octave code.
749With optional ARG, use this as offset unless this line is a comment with
750fixed goal column."
751 (interactive)
752 (or arg (setq arg 0))
753 (let ((icol (calculate-octave-indent))
754 (relpos (- (current-column) (current-indentation))))
755 (if (listp icol)
756 (setq icol (car icol))
757 (setq icol (+ icol arg)))
758 (if (< icol 0)
759 (error "Unmatched end keyword")
760 (indent-line-to icol)
761 (if (> relpos 0)
762 (move-to-column (+ icol relpos))))))
763
764(defun octave-indent-new-comment-line ()
765 "Break Octave line at point, continuing comment if within one.
766If within code, insert `octave-continuation-string' before breaking the
a1506d29
JB		 767line. If within a string, signal an error.
768The new line is properly indented."
f2727dfb
RS		 769 (interactive)
770 (delete-horizontal-space)
771 (cond
772 ((octave-in-comment-p)
773 (indent-new-comment-line))
774 ((octave-in-string-p)
775 (error "Cannot split a code line inside a string"))
776 (t
777 (insert (concat " " octave-continuation-string))
778 (octave-reindent-then-newline-and-indent))))
779
780(defun octave-indent-defun ()
e22bbd48 781 "Properly indent the Octave function which contains point."
f2727dfb
RS		 782 (interactive)
783 (save-excursion
784 (octave-mark-defun)
785 (message "Indenting function...")
786 (indent-region (point) (mark) nil))
787 (message "Indenting function...done."))
788
789\f
790;;; Motion
791(defun octave-next-code-line (&optional arg)
792 "Move ARG lines of Octave code forward (backward if ARG is negative).
793Skips past all empty and comment lines. Default for ARG is 1.
794
795On success, return 0. Otherwise, go as far as possible and return -1."
796 (interactive "p")
797 (or arg (setq arg 1))
798 (beginning-of-line)
799 (let ((n 0)
800 (inc (if (> arg 0) 1 -1)))
801 (while (and (/= arg 0) (= n 0))
802 (setq n (forward-line inc))
803 (while (and (= n 0)
804 (looking-at "\\s-*\\($\\|\\s<\\)"))
805 (setq n (forward-line inc)))
806 (setq arg (- arg inc)))
807 n))
a1506d29 808
f2727dfb
RS		 809(defun octave-previous-code-line (&optional arg)
810 "Move ARG lines of Octave code backward (forward if ARG is negative).
811Skips past all empty and comment lines. Default for ARG is 1.
812
813On success, return 0. Otherwise, go as far as possible and return -1."
814 (interactive "p")
815 (or arg (setq arg 1))
816 (octave-next-code-line (- arg)))
817
818(defun octave-beginning-of-line ()
819 "Move point to beginning of current Octave line.
820If on an empty or comment line, go to the beginning of that line.
821Otherwise, move backward to the beginning of the first Octave code line
822which is not inside a continuation statement, i.e., which does not
823follow a code line ending in `...' or `\\', or is inside an open
824parenthesis list."
825 (interactive)
826 (beginning-of-line)
827 (if (not (looking-at "\\s-*\\($\\|\\s<\\)"))
828 (while (or (condition-case nil
829 (progn
830 (up-list -1)
831 (beginning-of-line)
832 t)
833 (error nil))
834 (and (or (looking-at "\\s-*\\($\\|\\s<\\)")
835 (save-excursion
836 (if (zerop (octave-previous-code-line))
837 (looking-at octave-continuation-regexp))))
838 (zerop (forward-line -1)))))))
839
840(defun octave-end-of-line ()
841 "Move point to end of current Octave line.
842If on an empty or comment line, go to the end of that line.
843Otherwise, move forward to the end of the first Octave code line which
844does not end in `...' or `\\' or is inside an open parenthesis list."
845 (interactive)
846 (end-of-line)
847 (if (save-excursion
848 (beginning-of-line)
849 (looking-at "\\s-*\\($\\|\\s<\\)"))
850 ()
851 (while (or (condition-case nil
852 (progn
853 (up-list 1)
854 (end-of-line)
855 t)
856 (error nil))
857 (and (save-excursion
858 (beginning-of-line)
859 (or (looking-at "\\s-*\\($\\|\\s<\\)")
860 (looking-at octave-continuation-regexp)))
861 (zerop (forward-line 1)))))
862 (end-of-line)))
a1506d29 863
e22bbd48
SM		 864(defun octave-scan-blocks (count depth)
865 "Scan from point by COUNT Octave begin-end blocks.
f2727dfb
RS		 866Returns the character number of the position thus found.
867
868If DEPTH is nonzero, block depth begins counting from that value.
869Only places where the depth in blocks becomes zero are candidates for
870stopping; COUNT such places are counted.
871
872If the beginning or end of the buffer is reached and the depth is wrong,
873an error is signaled."
874 (let ((min-depth (if (> depth 0) 0 depth))
875 (inc (if (> count 0) 1 -1)))
876 (save-excursion
877 (while (/= count 0)
878 (catch 'foo
a584f30f 879 (while (or (octave-re-search-forward-kw
050a4b35 880 octave-block-begin-or-end-regexp inc)
f2727dfb
RS		 881 (if (/= depth 0)
882 (error "Unbalanced block")))
883 (if (octave-not-in-string-or-comment-p)
884 (progn
885 (cond
886 ((match-end 1)
887 (setq depth (+ depth inc)))
888 ((match-end 2)
889 (setq depth (- depth inc))))
890 (if (< depth min-depth)
891 (error "Containing expression ends prematurely"))
892 (if (= depth 0)
893 (throw 'foo nil))))))
894 (setq count (- count inc)))
895 (point))))
896
897(defun octave-forward-block (&optional arg)
898 "Move forward across one balanced Octave begin-end block.
899With argument, do it that many times.
900Negative arg -N means move backward across N blocks."
901 (interactive "p")
902 (or arg (setq arg 1))
e22bbd48 903 (goto-char (or (octave-scan-blocks arg 0) (buffer-end arg))))
f2727dfb
RS		 904
905(defun octave-backward-block (&optional arg)
906 "Move backward across one balanced Octave begin-end block.
907With argument, do it that many times.
908Negative arg -N means move forward across N blocks."
909 (interactive "p")
910 (or arg (setq arg 1))
911 (octave-forward-block (- arg)))
912
913(defun octave-down-block (arg)
914 "Move forward down one begin-end block level of Octave code.
915With argument, do this that many times.
916A negative argument means move backward but still go down a level.
917In Lisp programs, an argument is required."
918 (interactive "p")
919 (let ((inc (if (> arg 0) 1 -1)))
920 (while (/= arg 0)
e22bbd48 921 (goto-char (or (octave-scan-blocks inc -1)
f2727dfb
RS		 922 (buffer-end arg)))
923 (setq arg (- arg inc)))))
924
925(defun octave-backward-up-block (arg)
926 "Move backward out of one begin-end block level of Octave code.
927With argument, do this that many times.
928A negative argument means move forward but still to a less deep spot.
929In Lisp programs, an argument is required."
930 (interactive "p")
931 (octave-up-block (- arg)))
932
933(defun octave-up-block (arg)
934 "Move forward out of one begin-end block level of Octave code.
935With argument, do this that many times.
936A negative argument means move backward but still to a less deep spot.
937In Lisp programs, an argument is required."
938 (interactive "p")
939 (let ((inc (if (> arg 0) 1 -1)))
940 (while (/= arg 0)
e22bbd48 941 (goto-char (or (octave-scan-blocks inc 1)
f2727dfb
RS		 942 (buffer-end arg)))
943 (setq arg (- arg inc)))))
944
945(defun octave-mark-block ()
946 "Put point at the beginning of this Octave block, mark at the end.
947The block marked is the one that contains point or follows point."
948 (interactive)
949 (let ((pos (point)))
950 (if (or (and (octave-in-block-p)
951 (skip-syntax-forward "w"))
952 (condition-case nil
953 (progn
954 (octave-down-block 1)
955 (octave-in-block-p))
956 (error nil)))
957 (progn
958 (octave-up-block -1)
959 (push-mark (point))
960 (octave-forward-block)
961 (exchange-point-and-mark))
962 (goto-char pos)
963 (message "No block to mark found"))))
964
965(defun octave-close-block ()
966 "Close the current Octave block on a separate line.
967An error is signaled if no block to close is found."
968 (interactive)
969 (let (bb-keyword)
970 (condition-case nil
971 (progn
972 (save-excursion
973 (octave-backward-up-block 1)
974 (setq bb-keyword (buffer-substring-no-properties
975 (match-beginning 1) (match-end 1))))
976 (if (save-excursion
977 (beginning-of-line)
978 (looking-at "^\\s-*$"))
979 (indent-according-to-mode)
980 (octave-reindent-then-newline-and-indent))
981 (insert (car (reverse
982 (assoc bb-keyword
983 octave-block-match-alist))))
984 (octave-reindent-then-newline-and-indent)
985 t)
986 (error (message "No block to close found")))))
987
988(defun octave-blink-matching-block-open ()
989 "Blink the matching Octave begin block keyword.
990If point is right after an Octave else or end type block keyword, move
991cursor momentarily to the corresponding begin keyword.
992Signal an error if the keywords are incompatible."
993 (interactive)
994 (let (bb-keyword bb-arg eb-keyword pos eol)
995 (if (and (octave-not-in-string-or-comment-p)
996 (looking-at "\\>")
997 (save-excursion
998 (skip-syntax-backward "w")
a584f30f 999 (octave-looking-at-kw octave-block-else-or-end-regexp)))
f2727dfb
RS		 1000 (save-excursion
1001 (cond
1002 ((match-end 1)
1003 (setq eb-keyword
1004 (buffer-substring-no-properties
1005 (match-beginning 1) (match-end 1)))
1006 (octave-backward-up-block 1))
1007 ((match-end 2)
1008 (setq eb-keyword
1009 (buffer-substring-no-properties
1010 (match-beginning 2) (match-end 2)))
1011 (octave-backward-block)))
1012 (setq pos (match-end 0)
1013 bb-keyword
1014 (buffer-substring-no-properties
1015 (match-beginning 0) pos)
1016 pos (+ pos 1)
cb3d3ec1 1017 eol (line-end-position)
f2727dfb
RS		 1018 bb-arg
1019 (save-excursion
1020 (save-restriction
1021 (goto-char pos)
1022 (while (and (skip-syntax-forward "^<" eol)
1023 (octave-in-string-p)
1024 (not (forward-char 1))))
1025 (skip-syntax-backward " ")
1026 (buffer-substring-no-properties pos (point)))))
1027 (if (member eb-keyword
1028 (cdr (assoc bb-keyword octave-block-match-alist)))
1029 (progn
1030 (message "Matches `%s %s'" bb-keyword bb-arg)
1031 (if (pos-visible-in-window-p)
1032 (sit-for blink-matching-delay)))
1033 (error "Block keywords `%s' and `%s' do not match"
1034 bb-keyword eb-keyword))))))
1035
1036(defun octave-beginning-of-defun (&optional arg)
1037 "Move backward to the beginning of an Octave function.
1038With positive ARG, do it that many times. Negative argument -N means
1039move forward to Nth following beginning of a function.
1040Returns t unless search stops at the beginning or end of the buffer."
1041 (interactive "p")
1042 (let* ((arg (or arg 1))
1043 (inc (if (> arg 0) 1 -1))
1044 (found))
1045 (and (not (eobp))
a584f30f 1046 (not (and (> arg 0) (octave-looking-at-kw "\\<function\\>")))
f2727dfb
RS		 1047 (skip-syntax-forward "w"))
1048 (while (and (/= arg 0)
1049 (setq found
050a4b35 1050 (octave-re-search-backward-kw "\\<function\\>" inc)))
f2727dfb
RS		 1051 (if (octave-not-in-string-or-comment-p)
1052 (setq arg (- arg inc))))
1053 (if found
1054 (progn
1055 (and (< inc 0) (goto-char (match-beginning 0)))
1056 t))))
1057
1058(defun octave-end-of-defun (&optional arg)
1059 "Move forward to the end of an Octave function.
1060With positive ARG, do it that many times. Negative argument -N means
1061move back to Nth preceding end of a function.
1062
1063An end of a function occurs right after the end keyword matching the
1064`function' keyword that starts the function."
1065 (interactive "p")
1066 (or arg (setq arg 1))
1067 (and (< arg 0) (skip-syntax-backward "w"))
a1506d29 1068 (and (> arg 0) (skip-syntax-forward "w"))
f2727dfb
RS		 1069 (if (octave-in-defun-p)
1070 (setq arg (- arg 1)))
1071 (if (= arg 0) (setq arg -1))
1072 (if (octave-beginning-of-defun (- arg))
1073 (octave-forward-block)))
1074
1075(defun octave-mark-defun ()
1076 "Put point at the beginning of this Octave function, mark at its end.
1077The function marked is the one containing point or following point."
1078 (interactive)
1079 (let ((pos (point)))
1080 (if (or (octave-in-defun-p)
1081 (and (octave-beginning-of-defun -1)
1082 (octave-in-defun-p)))
1083 (progn
1084 (skip-syntax-forward "w")
1085 (octave-beginning-of-defun)
1086 (push-mark (point))
1087 (octave-end-of-defun)
1088 (exchange-point-and-mark))
1089 (goto-char pos)
1090 (message "No function to mark found"))))
a1506d29 1091
f2727dfb
RS		 1092\f
1093;;; Filling
1094(defun octave-auto-fill ()
d83ee578
KH		 1095 "Perform auto-fill in Octave mode.
1096Returns nil if no feasible place to break the line could be found, and t
1097otherwise."
1098 (let (fc give-up)
1099 (if (or (null (setq fc (current-fill-column)))
1100 (save-excursion
a1506d29 1101 (beginning-of-line)
d83ee578 1102 (and auto-fill-inhibit-regexp
a584f30f 1103 (octave-looking-at-kw auto-fill-inhibit-regexp))))
d83ee578
KH		 1104 nil ; Can't do anything
1105 (if (and (not (octave-in-comment-p))
1106 (> (current-column) fc))
1107 (setq fc (- fc (+ (length octave-continuation-string) 1))))
1108 (while (and (not give-up) (> (current-column) fc))
1109 (let* ((opoint (point))
1110 (fpoint
1111 (save-excursion
1112 (move-to-column (+ fc 1))
1113 (skip-chars-backward "^ \t\n")
1114 ;; If we're at the beginning of the line, break after
1115 ;; the first word
1116 (if (bolp)
1117 (re-search-forward "[ \t]" opoint t))
1118 ;; If we're in a comment line, don't break after the
1119 ;; comment chars
1120 (if (save-excursion
1121 (skip-syntax-backward " <")
1122 (bolp))
cb3d3ec1 1123 (re-search-forward "[ \t]" (line-end-position)
d83ee578
KH		 1124 'move))
1125 ;; If we're not in a comment line and just ahead the
1126 ;; continuation string, don't break here.
1127 (if (and (not (octave-in-comment-p))
1128 (looking-at
1129 (concat "\\s-*"
1130 (regexp-quote
1131 octave-continuation-string)
1132 "\\s-*$")))
1133 (end-of-line))
1134 (skip-chars-backward " \t")
1135 (point))))
1136 (if (save-excursion
1137 (goto-char fpoint)
1138 (not (or (bolp) (eolp))))
1139 (let ((prev-column (current-column)))
1140 (if (save-excursion
1141 (skip-chars-backward " \t")
1142 (= (point) fpoint))
1143 (progn
1144 (octave-maybe-insert-continuation-string)
1145 (indent-new-comment-line t))
1146 (save-excursion
1147 (goto-char fpoint)
1148 (octave-maybe-insert-continuation-string)
1149 (indent-new-comment-line t)))
1150 (if (>= (current-column) prev-column)
1151 (setq give-up t)))
1152 (setq give-up t))))
1153 (not give-up))))
f2727dfb
RS		 1154
1155(defun octave-fill-paragraph (&optional arg)
1156 "Fill paragraph of Octave code, handling Octave comments."
e22bbd48
SM		 1157 ;; FIXME: now that the default fill-paragraph takes care of similar issues,
1158 ;; this seems obsolete. --Stef
f2727dfb 1159 (interactive "P")
a1506d29 1160 (save-excursion
f2727dfb
RS		 1161 (let ((end (progn (forward-paragraph) (point)))
1162 (beg (progn
1163 (forward-paragraph -1)
1164 (skip-chars-forward " \t\n")
1165 (beginning-of-line)
1166 (point)))
1167 (cfc (current-fill-column))
1168 (ind (calculate-octave-indent))
1169 comment-prefix)
1170 (save-restriction
1171 (goto-char beg)
1172 (narrow-to-region beg end)
1173 (if (listp ind) (setq ind (nth 1 ind)))
1174 (while (not (eobp))
1175 (condition-case nil
1176 (octave-indent-line ind)
1177 (error nil))
1178 (if (and (> ind 0)
1179 (not
1180 (save-excursion
1181 (beginning-of-line)
1182 (looking-at "^\\s-*\\($\\|\\s<+\\)"))))
1183 (setq ind 0))
1184 (move-to-column cfc)
1185 ;; First check whether we need to combine non-empty comment lines
1186 (if (and (< (current-column) cfc)
1187 (octave-in-comment-p)
1188 (not (save-excursion
1189 (beginning-of-line)
1190 (looking-at "^\\s-*\\s<+\\s-*$"))))
1191 ;; This is a nonempty comment line which does not extend
6c83d99f 1192 ;; past the fill column. If it is followed by a nonempty
f2727dfb
RS		 1193 ;; comment line with the same comment prefix, try to
1194 ;; combine them, and repeat this until either we reach the
1195 ;; fill-column or there is nothing more to combine.
1196 (progn
1197 ;; Get the comment prefix
1198 (save-excursion
1199 (beginning-of-line)
1200 (while (and (re-search-forward "\\s<+")
1201 (not (octave-in-comment-p))))
1202 (setq comment-prefix (match-string 0)))
1203 ;; And keep combining ...
1204 (while (and (< (current-column) cfc)
1205 (save-excursion
1206 (forward-line 1)
1207 (and (looking-at
1208 (concat "^\\s-*"
1209 comment-prefix
1210 "\\S<"))
1211 (not (looking-at
1212 (concat "^\\s-*"
1213 comment-prefix
1214 "\\s-*$"))))))
1215 (delete-char 1)
1216 (re-search-forward comment-prefix)
1217 (delete-region (match-beginning 0) (match-end 0))
1218 (fixup-whitespace)
1219 (move-to-column cfc))))
d83ee578
KH		 1220 ;; We might also try to combine continued code lines> Perhaps
1221 ;; some other time ...
f2727dfb
RS		 1222 (skip-chars-forward "^ \t\n")
1223 (delete-horizontal-space)
1224 (if (or (< (current-column) cfc)
1225 (and (= (current-column) cfc) (eolp)))
1226 (forward-line 1)
1227 (if (not (eolp)) (insert " "))
d83ee578
KH		 1228 (or (octave-auto-fill)
1229 (forward-line 1)))))
f2727dfb
RS		 1230 t)))
1231
1232\f
1233;;; Completions
1234(defun octave-initialize-completions ()
1235 "Create an alist for Octave completions."
1236 (if octave-completion-alist
1237 ()
1238 (setq octave-completion-alist
1239 (mapcar '(lambda (var) (cons var var))
1240 (append octave-reserved-words
1241 octave-text-functions
1242 octave-variables)))))
1243
1244(defun octave-complete-symbol ()
1245 "Perform completion on Octave symbol preceding point.
1246Compare that symbol against Octave's reserved words and builtin
1247variables."
f2727dfb
RS		 1248 (interactive)
1249 (let* ((end (point))
69a94a37
SM		 1250 (beg (save-excursion (backward-sexp 1) (point))))
1251 (completion-in-region beg end octave-completion-alist)))
a1506d29 1252
f2727dfb
RS		 1253\f
1254;;; Electric characters && friends
1255(defun octave-reindent-then-newline-and-indent ()
1256 "Reindent current Octave line, insert newline, and indent the new line.
1257If Abbrev mode is on, expand abbrevs first."
1258 (interactive)
1259 (if abbrev-mode (expand-abbrev))
1260 (if octave-blink-matching-block
1261 (octave-blink-matching-block-open))
1262 (save-excursion
1263 (delete-region (point) (progn (skip-chars-backward " \t") (point)))
1264 (indent-according-to-mode))
1265 (insert "\n")
1266 (indent-according-to-mode))
1267
1268(defun octave-electric-semi ()
1269 "Insert a semicolon in Octave mode.
d83ee578 1270Maybe expand abbrevs and blink matching block open keywords.
0472835f 1271Reindent the line if `octave-auto-indent' is non-nil.
d83ee578 1272Insert a newline if `octave-auto-newline' is non-nil."
f2727dfb
RS		 1273 (interactive)
1274 (if (not (octave-not-in-string-or-comment-p))
1275 (insert ";")
1276 (if abbrev-mode (expand-abbrev))
1277 (if octave-blink-matching-block
1278 (octave-blink-matching-block-open))
d83ee578
KH		 1279 (if octave-auto-indent
1280 (indent-according-to-mode))
f2727dfb
RS		 1281 (insert ";")
1282 (if octave-auto-newline
1283 (newline-and-indent))))
1284
1285(defun octave-electric-space ()
1286 "Insert a space in Octave mode.
d83ee578 1287Maybe expand abbrevs and blink matching block open keywords.
0472835f 1288Reindent the line if `octave-auto-indent' is non-nil."
f2727dfb 1289 (interactive)
1ba983e8 1290 (setq last-command-event ? )
d9f9aa72
EZ		 1291 (if (and octave-auto-indent
1292 (not (octave-not-in-string-or-comment-p)))
f2727dfb
RS		 1293 (progn
1294 (indent-according-to-mode)
1295 (self-insert-command 1))
1296 (if abbrev-mode (expand-abbrev))
1297 (if octave-blink-matching-block
1298 (octave-blink-matching-block-open))
d83ee578
KH		 1299 (if (and octave-auto-indent
1300 (save-excursion
1301 (skip-syntax-backward " ")
1302 (not (bolp))))
f2727dfb
RS		 1303 (indent-according-to-mode))
1304 (self-insert-command 1)))
1305
1306(defun octave-abbrev-start ()
1307 "Start entering an Octave abbreviation.
1308If Abbrev mode is turned on, typing ` (grave accent) followed by ? or
1309\\[help-command] lists all Octave abbrevs. Any other key combination is
1310executed normally.
1311Note that all Octave mode abbrevs start with a grave accent."
1312 (interactive)
1313 (if (not abbrev-mode)
1314 (self-insert-command 1)
1315 (let (c)
1ba983e8 1316 (insert last-command-event)
f8246027 1317 (if (if (featurep 'xemacs)
aa82f4fb
KH		 1318 (or (eq (event-to-character (setq c (next-event))) ??)
1319 (eq (event-to-character c) help-char))
1320 (or (eq (setq c (read-event)) ??)
1321 (eq c help-char)))
1322 (let ((abbrev-table-name-list '(octave-abbrev-table)))
f2727dfb
RS		 1323 (list-abbrevs))
1324 (setq unread-command-events (list c))))))
1325
1326(defun octave-insert-defun (name args vals)
1327 "Insert an Octave function skeleton.
1328Prompt for the function's name, arguments and return values (to be
1329entered without parens)."
1330 (interactive
1331 (list
1332 (read-from-minibuffer "Function name: "
1333 (substring (buffer-name) 0 -2))
1334 (read-from-minibuffer "Arguments: ")
1335 (read-from-minibuffer "Return values: ")))
1336 (let ((string (format "%s %s (%s)"
1337 (cond
1338 ((string-equal vals "")
1339 vals)
1340 ((string-match "[ ,]" vals)
1341 (concat " [" vals "] ="))
1342 (t
1343 (concat " " vals " =")))
1344 name
1345 args))
1346 (prefix octave-block-comment-start))
1347 (if (not (bobp)) (newline))
1348 (insert "function" string)
1349 (indent-according-to-mode)
1350 (newline 2)
1351 (insert prefix "usage: " string)
a1506d29 1352 (reindent-then-newline-and-indent)
f2727dfb 1353 (insert prefix)
a1506d29 1354 (reindent-then-newline-and-indent)
f2727dfb
RS		 1355 (insert prefix)
1356 (indent-according-to-mode)
1357 (save-excursion
1358 (newline 2)
1359 (insert "endfunction")
1360 (indent-according-to-mode))))
a1506d29 1361
f2727dfb
RS		 1362\f
1363;;; Menu
1364(defun octave-add-octave-menu ()
e22bbd48 1365 "Add the `Octave' menu to the menu bar in Octave mode."
a1506d29 1366 (require 'easymenu)
f2727dfb
RS		 1367 (easy-menu-define octave-mode-menu-map octave-mode-map
1368 "Menu keymap for Octave mode." octave-mode-menu)
1369 (easy-menu-add octave-mode-menu-map octave-mode-map))
1370
1371\f
1372;;; Communication with the inferior Octave process
1373(defun octave-kill-process ()
1374 "Kill inferior Octave process and its buffer."
1375 (interactive)
1376 (if inferior-octave-process
1377 (progn
1378 (process-send-string inferior-octave-process "quit;\n")
1379 (accept-process-output inferior-octave-process)))
1380 (if inferior-octave-buffer
1381 (kill-buffer inferior-octave-buffer)))
1382
1383(defun octave-show-process-buffer ()
1384 "Make sure that `inferior-octave-buffer' is displayed."
1385 (interactive)
1386 (if (get-buffer inferior-octave-buffer)
1387 (display-buffer inferior-octave-buffer)
1388 (message "No buffer named %s" inferior-octave-buffer)))
1389
1390(defun octave-hide-process-buffer ()
1391 "Delete all windows that display `inferior-octave-buffer'."
1392 (interactive)
1393 (if (get-buffer inferior-octave-buffer)
1394 (delete-windows-on inferior-octave-buffer)
1395 (message "No buffer named %s" inferior-octave-buffer)))
1396
1397(defun octave-send-region (beg end)
1398 "Send current region to the inferior Octave process."
1399 (interactive "r")
a1506d29 1400 (inferior-octave t)
f2727dfb
RS		 1401 (let ((proc inferior-octave-process)
1402 (string (buffer-substring-no-properties beg end))
1403 line)
5d8137ab 1404 (with-current-buffer inferior-octave-buffer
f2727dfb
RS		 1405 (setq inferior-octave-output-list nil)
1406 (while (not (string-equal string ""))
1407 (if (string-match "\n" string)
1408 (setq line (substring string 0 (match-beginning 0))
1409 string (substring string (match-end 0)))
1410 (setq line string string ""))
1411 (setq inferior-octave-receive-in-progress t)
1412 (inferior-octave-send-list-and-digest (list (concat line "\n")))
1413 (while inferior-octave-receive-in-progress
1414 (accept-process-output proc))
1415 (insert-before-markers
1416 (mapconcat 'identity
1417 (append
1418 (if octave-send-echo-input (list line) (list ""))
1419 (mapcar 'inferior-octave-strip-ctrl-g
1420 inferior-octave-output-list)
1421 (list inferior-octave-output-string))
1422 "\n")))))
1423 (if octave-send-show-buffer
1424 (display-buffer inferior-octave-buffer)))
1425
1426(defun octave-send-block ()
a1506d29 1427 "Send current Octave block to the inferior Octave process."
f2727dfb
RS		 1428 (interactive)
1429 (save-excursion
1430 (octave-mark-block)
1431 (octave-send-region (point) (mark))))
1432
1433(defun octave-send-defun ()
1434 "Send current Octave function to the inferior Octave process."
1435 (interactive)
1436 (save-excursion
1437 (octave-mark-defun)
1438 (octave-send-region (point) (mark))))
1439
1440(defun octave-send-line (&optional arg)
1441 "Send current Octave code line to the inferior Octave process.
1442With positive prefix ARG, send that many lines.
1443If `octave-send-line-auto-forward' is non-nil, go to the next unsent
1444code line."
1445 (interactive "P")
1446 (or arg (setq arg 1))
1447 (if (> arg 0)
1448 (let (beg end)
1449 (beginning-of-line)
1450 (setq beg (point))
1451 (octave-next-code-line (- arg 1))
1452 (end-of-line)
1453 (setq end (point))
1454 (if octave-send-line-auto-forward
1455 (octave-next-code-line 1))
1456 (octave-send-region beg end))))
1457
1458(defun octave-eval-print-last-sexp ()
1459 "Evaluate Octave sexp before point and print value into current buffer."
1460 (interactive)
1461 (inferior-octave t)
1462 (let ((standard-output (current-buffer))
1463 (print-escape-newlines nil)
1464 (opoint (point)))
1465 (terpri)
a1506d29 1466 (prin1
f2727dfb
RS		 1467 (save-excursion
1468 (forward-sexp -1)
1469 (inferior-octave-send-list-and-digest
1470 (list (concat (buffer-substring-no-properties (point) opoint)
1471 "\n")))
1472 (mapconcat 'identity inferior-octave-output-list "\n")))
1473 (terpri)))
d1e49742 1474\f
d1e49742
RS		 1475;;; Bug reporting
1476(defun octave-submit-bug-report ()
1477 "Submit a bug report on the Emacs Octave package via mail."
1478 (interactive)
1479 (require 'reporter)
1480 (and
1481 (y-or-n-p "Do you want to submit a bug report? ")
1482 (reporter-submit-bug-report
1483 octave-maintainer-address
1484 (concat "Emacs version " emacs-version)
1485 (list
d83ee578 1486 'octave-auto-indent
d1e49742
RS		 1487 'octave-auto-newline
1488 'octave-blink-matching-block
1489 'octave-block-offset
1490 'octave-comment-char
1491 'octave-continuation-offset
1492 'octave-continuation-string
d1e49742
RS		 1493 'octave-send-echo-input
1494 'octave-send-line-auto-forward
1495 'octave-send-show-buffer))))
1496
5d8137ab 1497;; provide ourself
d1e49742 1498
e7017ef9 1499(provide 'octave-mod)
d1e49742 1500
e22bbd48 1501;; arch-tag: 05f1ce09-be87-4c00-803e-4919ffa26c23
d1e49742 1502;;; octave-mod.el ends here
Unnamed repository; edit this file 'description' to name the repository.