lisp/progmodes/octave-mod.el

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