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