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@octave.org>
   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 ?\s)
  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                  (regexp-opt (append octave-reserved-words
 165                                      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 "\\<" (regexp-opt octave-variables) "\\>")
 175          'font-lock-variable-name-face)
 176    ;; Fontify all function declarations.
 177    (list octave-function-header-regexp
 178          '(1 font-lock-keyword-face)
 179          '(3 font-lock-function-name-face nil t)))
 180   "Additional Octave expressions to highlight.")
 181
 182 (defvar octave-font-lock-syntactic-keywords
 183   ;; Try to distinguish the string-quotes from the transpose-quotes.
 184   '(("[[({,; ]\\('\\)" (1 "\"'"))
 185     (octave-font-lock-close-quotes)))
 186
 187 (defun octave-font-lock-close-quotes (limit)
 188   "Fix the syntax-table of the closing quotes of single-quote strings."
 189   ;; Freely inspired from perl-font-lock-special-syntactic-constructs.
 190   (let ((state (syntax-ppss)))
 191     (while (< (point) limit)
 192       (cond
 193        ((eq (nth 3 state) ?\')
 194         ;; A '..' string.
 195         (save-excursion
 196           (when (re-search-forward "\\(?:\\=\\|[^']\\)\\(?:''\\)*\\('\\)[^']"
 197                                    nil t)
 198             (goto-char (1- (point)))
 199             ;; Remove any syntax-table property we may have applied to
 200             ;; some of the (doubled) single quotes within the string.
 201             ;; Since these are the only chars on which we place properties,
 202             ;; we take a shortcut and just remove all properties.
 203             (remove-text-properties (1+ (nth 8 state)) (match-beginning 1)
 204                                     '(syntax-table nil))
 205             (when (eq (char-before (match-beginning 1)) ?\\)
 206               ;; Backslash cannot escape a single quote.
 207               (put-text-property (1- (match-beginning 1)) (match-beginning 1)
 208                                  'syntax-table (string-to-syntax ".")))
 209             (put-text-property (match-beginning 1) (match-end 1)
 210                                'syntax-table (string-to-syntax "\"'"))))))
 211
 212       (setq state (parse-partial-sexp (point) limit nil nil state
 213                                       'syntax-table)))))
 214
 215 (defcustom inferior-octave-buffer "*Inferior Octave*"
 216   "Name of buffer for running an inferior Octave process."
 217   :type 'string
 218   :group 'octave-inferior)
 219
 220 (defvar inferior-octave-process nil)
 221 \f
 222 (defvar octave-mode-map
 223   (let ((map (make-sparse-keymap)))
 224     (define-key map "`" 'octave-abbrev-start)
 225     (define-key map ";" 'octave-electric-semi)
 226     (define-key map " " 'octave-electric-space)
 227     (define-key map "\n" 'octave-reindent-then-newline-and-indent)
 228     (define-key map "\e\n" 'octave-indent-new-comment-line)
 229     (define-key map "\M-\C-q" 'octave-indent-defun)
 230     (define-key map "\C-c\C-b" 'octave-submit-bug-report)
 231     (define-key map "\C-c\C-p" 'octave-previous-code-line)
 232     (define-key map "\C-c\C-n" 'octave-next-code-line)
 233     (define-key map "\C-c\C-a" 'octave-beginning-of-line)
 234     (define-key map "\C-c\C-e" 'octave-end-of-line)
 235     (define-key map [remap down-list] 'smie-down-list)
 236     (define-key map "\C-c\M-\C-h" 'octave-mark-block)
 237     (define-key map "\C-c]" 'smie-close-block)
 238     (define-key map "\C-c/" 'smie-close-block)
 239     (define-key map "\C-c\C-f" 'octave-insert-defun)
 240     (define-key map "\C-c\C-h" 'octave-help)
 241     (define-key map "\C-c\C-il" 'octave-send-line)
 242     (define-key map "\C-c\C-ib" 'octave-send-block)
 243     (define-key map "\C-c\C-if" 'octave-send-defun)
 244     (define-key map "\C-c\C-ir" 'octave-send-region)
 245     (define-key map "\C-c\C-is" 'octave-show-process-buffer)
 246     (define-key map "\C-c\C-ih" 'octave-hide-process-buffer)
 247     (define-key map "\C-c\C-ik" 'octave-kill-process)
 248     (define-key map "\C-c\C-i\C-l" 'octave-send-line)
 249     (define-key map "\C-c\C-i\C-b" 'octave-send-block)
 250     (define-key map "\C-c\C-i\C-f" 'octave-send-defun)
 251     (define-key map "\C-c\C-i\C-r" 'octave-send-region)
 252     (define-key map "\C-c\C-i\C-s" 'octave-show-process-buffer)
 253     (define-key map "\C-c\C-i\C-h" 'octave-hide-process-buffer)
 254     (define-key map "\C-c\C-i\C-k" 'octave-kill-process)
 255     map)
 256   "Keymap used in Octave mode.")
 257
 258
 259
 260 (easy-menu-define octave-mode-menu octave-mode-map
 261   "Menu for Octave mode."
 262   '("Octave"
 263     ("Lines"
 264       ["Previous Code Line"     octave-previous-code-line t]
 265       ["Next Code Line"         octave-next-code-line t]
 266       ["Begin of Continuation"  octave-beginning-of-line t]
 267       ["End of Continuation"    octave-end-of-line t]
 268       ["Split Line at Point"    octave-indent-new-comment-line t])
 269     ("Blocks"
 270       ["Mark Block"             octave-mark-block t]
 271       ["Close Block"            smie-close-block t])
 272     ("Functions"
 273       ["Indent Function"        octave-indent-defun t]
 274       ["Insert Function"        octave-insert-defun t])
 275     "-"
 276     ("Debug"
 277       ["Send Current Line"      octave-send-line t]
 278       ["Send Current Block"     octave-send-block t]
 279       ["Send Current Function"  octave-send-defun t]
 280       ["Send Region"            octave-send-region t]
 281       ["Show Process Buffer"    octave-show-process-buffer t]
 282       ["Hide Process Buffer"    octave-hide-process-buffer t]
 283       ["Kill Process"           octave-kill-process t])
 284     "-"
 285     ["Indent Line"              indent-according-to-mode t]
 286     ["Complete Symbol"          completion-at-point t]
 287     "-"
 288     ["Toggle Abbrev Mode"       abbrev-mode
 289      :style toggle :selected abbrev-mode]
 290     ["Toggle Auto-Fill Mode"    auto-fill-mode
 291      :style toggle :selected auto-fill-function]
 292     "-"
 293     ["Submit Bug Report"        octave-submit-bug-report t]
 294     "-"
 295     ["Describe Octave Mode"     describe-mode t]
 296     ["Lookup Octave Index"      info-lookup-symbol t]))
 297
 298 (defvar octave-mode-syntax-table
 299   (let ((table (make-syntax-table)))
 300     (modify-syntax-entry ?\r " "  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 ?& "."   table)
 309     (modify-syntax-entry ?| "."   table)
 310     (modify-syntax-entry ?! "."   table)
 311     (modify-syntax-entry ?\\ "\\" table)
 312     (modify-syntax-entry ?\' "."  table)
 313     ;; Was "w" for abbrevs, but now that it's not necessary any more,
 314     (modify-syntax-entry ?\` "."  table)
 315     (modify-syntax-entry ?\" "\"" table)
 316     (modify-syntax-entry ?. "w"   table)
 317     (modify-syntax-entry ?_ "w"   table)
 318     ;; The "b" flag only applies to the second letter of the comstart
 319     ;; and the first letter of the comend, i.e. the "4b" below is ineffective.
 320     ;; If we try to put `b' on the single-line comments, we get a similar
 321     ;; problem where the % and # chars appear as first chars of the 2-char
 322     ;; comend, so the multi-line ender is also turned into style-b.
 323     ;; So we need the new "c" comment style.
 324     (modify-syntax-entry ?\% "< 13"  table)
 325     (modify-syntax-entry ?\# "< 13"  table)
 326     (modify-syntax-entry ?\{ "(} 2c"  table)
 327     (modify-syntax-entry ?\} "){ 4c"  table)
 328     (modify-syntax-entry ?\n ">"  table)
 329     table)
 330   "Syntax table in use in `octave-mode' buffers.")
 331
 332 (defcustom octave-auto-indent nil
 333   "Non-nil means indent line after a semicolon or space in Octave mode."
 334   :type 'boolean
 335   :group 'octave)
 336
 337 (defcustom octave-auto-newline nil
 338   "Non-nil means automatically newline after a semicolon in Octave mode."
 339   :type 'boolean
 340   :group 'octave)
 341
 342 (defcustom octave-blink-matching-block t
 343   "Control the blinking of matching Octave block keywords.
 344 Non-nil means show matching begin of block when inserting a space,
 345 newline or semicolon after an else or end keyword."
 346   :type 'boolean
 347   :group 'octave)
 348
 349 (defcustom octave-block-offset 2
 350   "Extra indentation applied to statements in Octave block structures."
 351   :type 'integer
 352   :group 'octave)
 353
 354 (defvar octave-block-comment-start
 355   (concat (make-string 2 octave-comment-char) " ")
 356   "String to insert to start a new Octave comment on an empty line.")
 357
 358 (defcustom octave-continuation-offset 4
 359   "Extra indentation applied to Octave continuation lines."
 360   :type 'integer
 361   :group 'octave)
 362 (eval-and-compile
 363   (defconst octave-continuation-marker-regexp "\\\\\\|\\.\\.\\."))
 364 (defvar octave-continuation-regexp
 365   (concat "[^#%\n]*\\(" octave-continuation-marker-regexp
 366           "\\)\\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 ;;; SMIE indentation
 405
 406 (require 'smie)
 407
 408 (defconst octave-operator-table
 409   '((assoc ";" "\n") (assoc ",") ; The doc claims they have equal precedence!?
 410     (right "=" "+=" "-=" "*=" "/=")
 411     (assoc "&&") (assoc "||") ; The doc claims they have equal precedence!?
 412     (assoc "&") (assoc "|")   ; The doc claims they have equal precedence!?
 413     (nonassoc "<" "<=" "==" ">=" ">" "!=" "~=")
 414     (nonassoc ":")                      ;No idea what this is.
 415     (assoc "+" "-")
 416     (assoc "*" "/" "\\" ".\\" ".*" "./")
 417     (nonassoc "'" ".'")
 418     (nonassoc "++" "--" "!" "~")        ;And unary "+" and "-".
 419     (right "^" "**" ".^" ".**")
 420     ;; It's not really an operator, but for indentation purposes it
 421     ;; could be convenient to treat it as one.
 422     (assoc "...")))
 423
 424 (defconst octave-smie-bnf-table
 425   '((atom)
 426     ;; We can't distinguish the first element in a sequence with
 427     ;; precedence grammars, so we can't distinguish the condition
 428     ;; if the `if' from the subsequent body, for example.
 429     ;; This has to be done later in the indentation rules.
 430     (exp (exp "\n" exp)
 431          ;; We need to mention at least one of the operators in this part
 432          ;; of the grammar: if the BNF and the operator table have
 433          ;; no overlap, SMIE can't know how they relate.
 434          (exp ";" exp)
 435          ("try" exp "catch" exp "end_try_catch")
 436          ("try" exp "catch" exp "end")
 437          ("unwind_protect" exp
 438           "unwind_protect_cleanup" exp "end_unwind_protect")
 439          ("unwind_protect" exp "unwind_protect_cleanup" exp "end")
 440          ("for" exp "endfor")
 441          ("for" exp "end")
 442          ("do" exp "until" atom)
 443          ("while" exp "endwhile")
 444          ("while" exp "end")
 445          ("if" exp "endif")
 446          ("if" exp "else" exp "endif")
 447          ("if" exp "elseif" exp "else" exp "endif")
 448          ("if" exp "elseif" exp "elseif" exp "else" exp "endif")
 449          ("if" exp "elseif" exp "elseif" exp "else" exp "end")
 450          ("switch" exp "case" exp "endswitch")
 451          ("switch" exp "case" exp "otherwise" exp "endswitch")
 452          ("switch" exp "case" exp "case" exp "otherwise" exp "endswitch")
 453          ("switch" exp "case" exp "case" exp "otherwise" exp "end")
 454          ("function" exp "endfunction")
 455          ("function" exp "end"))
 456     ;; (fundesc (atom "=" atom))
 457     ))
 458
 459 (defconst octave-smie-closer-alist
 460   (smie-bnf-closer-alist octave-smie-bnf-table))
 461
 462 (defconst octave-smie-op-levels
 463   (smie-prec2-levels
 464    (smie-merge-prec2s
 465     (smie-bnf-precedence-table
 466      octave-smie-bnf-table
 467      '((assoc "\n" ";")))
 468
 469     (smie-precs-precedence-table
 470      (append octave-operator-table
 471              '((nonassoc " -dummy- "))) ;Bogus anchor at the end.
 472      ))))
 473
 474 ;; Tokenizing needs to be refined so that ";;" is treated as two
 475 ;; tokens and also so as to recognize the \n separator (and
 476 ;; corresponding continuation lines).
 477
 478 (defconst octave-operator-regexp
 479   (regexp-opt (apply 'append (mapcar 'cdr octave-operator-table))))
 480
 481 (defun octave-smie-backward-token ()
 482   (let ((pos (point)))
 483     (forward-comment (- (point)))
 484     (cond
 485      ((and (not (eq (char-before) ?\;)) ;Coalesce ";" and "\n".
 486            (> pos (line-end-position))
 487            (if (looking-back octave-continuation-marker-regexp (- (point) 3))
 488                (progn
 489                  (goto-char (match-beginning 0))
 490                  (forward-comment (- (point)))
 491                  nil)
 492              t)
 493            ;; Ignore it if it's within parentheses.
 494            (let ((ppss (syntax-ppss)))
 495              (not (and (nth 1 ppss)
 496                        (eq ?\( (char-after (nth 1 ppss)))))))
 497       (skip-chars-forward " \t")
 498       ;; Why bother distinguishing \n and ;?
 499       ";") ;;"\n"
 500      ((and (looking-back octave-operator-regexp (- (point) 3) 'greedy)
 501            ;; Don't mistake a string quote for a transpose.
 502            (not (looking-back "\\s\"" (1- (point)))))
 503       (goto-char (match-beginning 0))
 504       (match-string-no-properties 0))
 505      (t
 506       (smie-default-backward-token)))))
 507
 508 (defun octave-smie-forward-token ()
 509   (skip-chars-forward " \t")
 510   (when (looking-at (eval-when-compile
 511                       (concat "\\(" octave-continuation-marker-regexp
 512                               "\\)[ \t]*\\($\\|[%#]\\)")))
 513     (goto-char (match-end 1))
 514     (forward-comment 1))
 515   (cond
 516    ((and (looking-at "$\\|[%#]")
 517          ;; Ignore it if it's within parentheses.
 518          (prog1 (let ((ppss (syntax-ppss)))
 519                   (not (and (nth 1 ppss)
 520                             (eq ?\( (char-after (nth 1 ppss))))))
 521            (forward-comment (point-max))))
 522     ;; Why bother distinguishing \n and ;?
 523     ";") ;;"\n"
 524    ((looking-at ";[ \t]*\\($\\|[%#]\\)")
 525     ;; Combine the ; with the subsequent \n.
 526     (goto-char (match-beginning 1))
 527     (forward-comment 1)
 528     ";")
 529    ((and (looking-at octave-operator-regexp)
 530          ;; Don't mistake a string quote for a transpose.
 531          (not (looking-at "\\s\"")))
 532     (goto-char (match-end 0))
 533     (match-string-no-properties 0))
 534    (t
 535     (smie-default-forward-token))))
 536
 537 (defconst octave-smie-indent-rules
 538   '((";"
 539      (:parent ("function" "if" "while" "else" "elseif" "for" "otherwise"
 540                "case" "try" "catch" "unwind_protect" "unwind_protect_cleanup")
 541       ;; FIXME: don't hardcode 2.
 542       (+ parent octave-block-offset))
 543      ;; (:parent "switch" 4) ;For (invalid) code between switch and case.
 544      0)
 545     ((:before . "case") octave-block-offset)))
 546
 547 ;;;###autoload
 548 (define-derived-mode octave-mode prog-mode "Octave"
 549   "Major mode for editing Octave code.
 550
 551 This mode makes it easier to write Octave code by helping with
 552 indentation, doing some of the typing for you (with Abbrev mode) and by
 553 showing keywords, comments, strings, etc. in different faces (with
 554 Font Lock mode on terminals that support it).
 555
 556 Octave itself is a high-level language, primarily intended for numerical
 557 computations.  It provides a convenient command line interface for
 558 solving linear and nonlinear problems numerically.  Function definitions
 559 can also be stored in files, and it can be used in a batch mode (which
 560 is why you need this mode!).
 561
 562 The latest released version of Octave is always available via anonymous
 563 ftp from ftp.octave.org in the directory `/pub/octave'.  Complete
 564 source and binaries for several popular systems are available.
 565
 566 Type \\[list-abbrevs] to display the built-in abbrevs for Octave keywords.
 567
 568 Keybindings
 569 ===========
 570
 571 \\{octave-mode-map}
 572
 573 Variables you can use to customize Octave mode
 574 ==============================================
 575
 576 `octave-auto-indent'
 577   Non-nil means indent current line after a semicolon or space.
 578   Default is nil.
 579
 580 `octave-auto-newline'
 581   Non-nil means auto-insert a newline and indent after a semicolon.
 582   Default is nil.
 583
 584 `octave-blink-matching-block'
 585   Non-nil means show matching begin of block when inserting a space,
 586   newline or semicolon after an else or end keyword.  Default is t.
 587
 588 `octave-block-offset'
 589   Extra indentation applied to statements in block structures.
 590   Default is 2.
 591
 592 `octave-continuation-offset'
 593   Extra indentation applied to Octave continuation lines.
 594   Default is 4.
 595
 596 `octave-continuation-string'
 597   String used for Octave continuation lines.
 598   Default is a backslash.
 599
 600 `octave-send-echo-input'
 601   Non-nil means always display `inferior-octave-buffer' after sending a
 602   command to the inferior Octave process.
 603
 604 `octave-send-line-auto-forward'
 605   Non-nil means always go to the next unsent line of Octave code after
 606   sending a line to the inferior Octave process.
 607
 608 `octave-send-echo-input'
 609   Non-nil means echo input sent to the inferior Octave process.
 610
 611 Turning on Octave mode runs the hook `octave-mode-hook'.
 612
 613 To begin using this mode for all `.m' files that you edit, add the
 614 following lines to your `.emacs' file:
 615
 616   (add-to-list 'auto-mode-alist '(\"\\\\.m\\\\'\" . octave-mode))
 617
 618 To automatically turn on the abbrev and auto-fill features,
 619 add the following lines to your `.emacs' file as well:
 620
 621   (add-hook 'octave-mode-hook
 622             (lambda ()
 623               (abbrev-mode 1)
 624               (auto-fill-mode 1)))
 625
 626 To submit a problem report, enter \\[octave-submit-bug-report] from \
 627 an Octave mode buffer.
 628 This automatically sets up a mail buffer with version information
 629 already added.  You just need to add a description of the problem,
 630 including a reproducible test case and send the message."
 631   (setq local-abbrev-table octave-abbrev-table)
 632
 633   (smie-setup octave-smie-op-levels octave-smie-indent-rules)
 634   (set (make-local-variable 'smie-indent-basic) 'octave-block-offset)
 635   (set (make-local-variable 'smie-backward-token-function)
 636        'octave-smie-backward-token)
 637   (set (make-local-variable 'smie-forward-token-function)
 638        'octave-smie-forward-token)
 639   (set (make-local-variable 'forward-sexp-function)
 640        'smie-forward-sexp-command)
 641   (set (make-local-variable 'smie-closer-alist) octave-smie-closer-alist)
 642   ;; Only needed for interactive calls to blink-matching-open.
 643   (set (make-local-variable 'blink-matching-check-function)
 644        #'smie-blink-matching-check)
 645
 646   (when octave-blink-matching-block
 647     (add-hook 'post-self-insert-hook #'smie-blink-matching-open 'append 'local)
 648     (set (make-local-variable 'smie-blink-matching-triggers)
 649          (append smie-blink-matching-triggers '(\;)
 650                  ;; Rather than wait for SPC or ; to blink, try to blink as
 651                  ;; soon as we type the last char of a block ender.
 652                  ;; But strip ?d from this list so that we don't blink twice
 653                  ;; when the user writes "endif" (once at "end" and another
 654                  ;; time at "endif").
 655                  (delq ?d (delete-dups
 656                            (mapcar (lambda (kw)
 657                                      (aref (cdr kw) (1- (length (cdr kw)))))
 658                                    smie-closer-alist))))))
 659
 660   ;; FIXME: maybe we should use (cons ?\; electric-indent-chars)
 661   ;; since only ; is really octave-specific.
 662   (set (make-local-variable 'electric-indent-chars) '(?\; ?\s ?\n))
 663
 664   (set (make-local-variable 'comment-start) octave-comment-start)
 665   (set (make-local-variable 'comment-end) "")
 666   ;; Don't set it here: it's not really a property of the language,
 667   ;; just a personal preference of the author.
 668   ;; (set (make-local-variable 'comment-column) 32)
 669   (set (make-local-variable 'comment-start-skip) "\\s<+\\s-*")
 670   (set (make-local-variable 'comment-add) 1)
 671
 672   (set (make-local-variable 'parse-sexp-ignore-comments) t)
 673   (set (make-local-variable 'paragraph-start)
 674        (concat "\\s-*$\\|" page-delimiter))
 675   (set (make-local-variable 'paragraph-separate) paragraph-start)
 676   (set (make-local-variable 'paragraph-ignore-fill-prefix) t)
 677   (set (make-local-variable 'fill-paragraph-function) 'octave-fill-paragraph)
 678   ;; FIXME: Why disable it?
 679   ;; (set (make-local-variable 'adaptive-fill-regexp) nil)
 680   ;; Again, this is not a property of the language, don't set it here.
 681   ;; (set (make-local-variable 'fill-column) 72)
 682   (set (make-local-variable 'normal-auto-fill-function) 'octave-auto-fill)
 683
 684   (set (make-local-variable 'font-lock-defaults)
 685        '(octave-font-lock-keywords nil nil nil nil
 686          (font-lock-syntactic-keywords . octave-font-lock-syntactic-keywords)
 687          (parse-sexp-lookup-properties . t)))
 688
 689   (set (make-local-variable 'imenu-generic-expression)
 690        octave-mode-imenu-generic-expression)
 691   (set (make-local-variable 'imenu-case-fold-search) nil)
 692
 693   (add-hook 'completion-at-point-functions
 694             'octave-completion-at-point-function nil t)
 695   (set (make-local-variable 'beginning-of-defun-function)
 696        'octave-beginning-of-defun)
 697
 698   (easy-menu-add octave-mode-menu)
 699   (octave-initialize-completions)
 700   (run-mode-hooks 'octave-mode-hook))
 701
 702 (defvar info-lookup-mode)
 703
 704 (defun octave-help ()
 705   "Get help on Octave symbols from the Octave info files.
 706 Look up symbol in the function, operator and variable indices of the info files."
 707   (let ((info-lookup-mode 'octave-mode))
 708     (call-interactively 'info-lookup-symbol)))
 709 \f
 710 ;;; Miscellaneous useful functions
 711
 712 (defsubst octave-in-comment-p ()
 713   "Return t if point is inside an Octave comment."
 714   (save-excursion
 715     ;; FIXME: use syntax-ppss?
 716     (nth 4 (parse-partial-sexp (line-beginning-position) (point)))))
 717
 718 (defsubst octave-in-string-p ()
 719   "Return t if point is inside an Octave string."
 720   (save-excursion
 721     ;; FIXME: use syntax-ppss?
 722     (nth 3 (parse-partial-sexp (line-beginning-position) (point)))))
 723
 724 (defsubst octave-not-in-string-or-comment-p ()
 725   "Return t if point is not inside an Octave string or comment."
 726   ;; FIXME: Use syntax-ppss?
 727   (let ((pps (parse-partial-sexp (line-beginning-position) (point))))
 728     (not (or (nth 3 pps) (nth 4 pps)))))
 729
 730
 731 (defun octave-looking-at-kw (regexp)
 732   "Like `looking-at', but sets `case-fold-search' nil."
 733   (let ((case-fold-search nil))
 734     (looking-at regexp)))
 735
 736 (defun octave-maybe-insert-continuation-string ()
 737   (if (or (octave-in-comment-p)
 738           (save-excursion
 739             (beginning-of-line)
 740             (looking-at octave-continuation-regexp)))
 741       nil
 742     (delete-horizontal-space)
 743     (insert (concat " " octave-continuation-string))))
 744
 745 \f
 746 ;;; Indentation
 747
 748 (defun octave-indent-new-comment-line ()
 749   "Break Octave line at point, continuing comment if within one.
 750 If within code, insert `octave-continuation-string' before breaking the
 751 line.  If within a string, signal an error.
 752 The new line is properly indented."
 753   (interactive)
 754   (delete-horizontal-space)
 755   (cond
 756    ((octave-in-comment-p)
 757     (indent-new-comment-line))
 758    ((octave-in-string-p)
 759     (error "Cannot split a code line inside a string"))
 760    (t
 761     (insert (concat " " octave-continuation-string))
 762     (octave-reindent-then-newline-and-indent))))
 763
 764 (defun octave-indent-defun ()
 765   "Properly indent the Octave function which contains point."
 766   (interactive)
 767   (save-excursion
 768     (mark-defun)
 769     (message "Indenting function...")
 770     (indent-region (point) (mark) nil))
 771   (message "Indenting function...done."))
 772
 773 \f
 774 ;;; Motion
 775 (defun octave-next-code-line (&optional arg)
 776   "Move ARG lines of Octave code forward (backward if ARG is negative).
 777 Skips past all empty and comment lines.  Default for ARG is 1.
 778
 779 On success, return 0.  Otherwise, go as far as possible and return -1."
 780   (interactive "p")
 781   (or arg (setq arg 1))
 782   (beginning-of-line)
 783   (let ((n 0)
 784         (inc (if (> arg 0) 1 -1)))
 785     (while (and (/= arg 0) (= n 0))
 786       (setq n (forward-line inc))
 787       (while (and (= n 0)
 788                   (looking-at "\\s-*\\($\\|\\s<\\)"))
 789         (setq n (forward-line inc)))
 790       (setq arg (- arg inc)))
 791     n))
 792
 793 (defun octave-previous-code-line (&optional arg)
 794   "Move ARG lines of Octave code backward (forward if ARG is negative).
 795 Skips past all empty and comment lines.  Default for ARG is 1.
 796
 797 On success, return 0.  Otherwise, go as far as possible and return -1."
 798   (interactive "p")
 799   (or arg (setq arg 1))
 800   (octave-next-code-line (- arg)))
 801
 802 (defun octave-beginning-of-line ()
 803   "Move point to beginning of current Octave line.
 804 If on an empty or comment line, go to the beginning of that line.
 805 Otherwise, move backward to the beginning of the first Octave code line
 806 which is not inside a continuation statement, i.e., which does not
 807 follow a code line ending in `...' or `\\', or is inside an open
 808 parenthesis list."
 809   (interactive)
 810   (beginning-of-line)
 811   (if (not (looking-at "\\s-*\\($\\|\\s<\\)"))
 812       (while (or (condition-case nil
 813                      (progn
 814                        (up-list -1)
 815                        (beginning-of-line)
 816                        t)
 817                    (error nil))
 818                  (and (or (looking-at "\\s-*\\($\\|\\s<\\)")
 819                           (save-excursion
 820                             (if (zerop (octave-previous-code-line))
 821                                 (looking-at octave-continuation-regexp))))
 822                       (zerop (forward-line -1)))))))
 823
 824 (defun octave-end-of-line ()
 825   "Move point to end of current Octave line.
 826 If on an empty or comment line, go to the end of that line.
 827 Otherwise, move forward to the end of the first Octave code line which
 828 does not end in `...' or `\\' or is inside an open parenthesis list."
 829   (interactive)
 830   (end-of-line)
 831   (if (save-excursion
 832         (beginning-of-line)
 833         (looking-at "\\s-*\\($\\|\\s<\\)"))
 834       ()
 835     (while (or (condition-case nil
 836                    (progn
 837                      (up-list 1)
 838                      (end-of-line)
 839                      t)
 840                  (error nil))
 841                (and (save-excursion
 842                       (beginning-of-line)
 843                       (or (looking-at "\\s-*\\($\\|\\s<\\)")
 844                           (looking-at octave-continuation-regexp)))
 845                     (zerop (forward-line 1)))))
 846     (end-of-line)))
 847
 848 (defun octave-mark-block ()
 849   "Put point at the beginning of this Octave block, mark at the end.
 850 The block marked is the one that contains point or follows point."
 851   (interactive)
 852   (unless (or (looking-at "\\s(")
 853               (save-excursion
 854                 (let* ((token (funcall smie-forward-token-function))
 855                        (level (assoc token smie-op-levels)))
 856                   (and level (null (cadr level))))))
 857     (backward-up-list 1))
 858   (mark-sexp))
 859
 860 (defun octave-beginning-of-defun (&optional arg)
 861   "Move backward to the beginning of an Octave function.
 862 With positive ARG, do it that many times.  Negative argument -N means
 863 move forward to Nth following beginning of a function.
 864 Returns t unless search stops at the beginning or end of the buffer."
 865   (let* ((arg (or arg 1))
 866          (inc (if (> arg 0) 1 -1))
 867          (found nil)
 868          (case-fold-search nil))
 869     (and (not (eobp))
 870          (not (and (> arg 0) (looking-at "\\<function\\>")))
 871          (skip-syntax-forward "w"))
 872     (while (and (/= arg 0)
 873                 (setq found
 874                       (re-search-backward "\\<function\\>" inc)))
 875       (if (octave-not-in-string-or-comment-p)
 876           (setq arg (- arg inc))))
 877     (if found
 878         (progn
 879           (and (< inc 0) (goto-char (match-beginning 0)))
 880           t))))
 881
 882 \f
 883 ;;; Filling
 884 (defun octave-auto-fill ()
 885   "Perform auto-fill in Octave mode.
 886 Returns nil if no feasible place to break the line could be found, and t
 887 otherwise."
 888   (let (fc give-up)
 889     (if (or (null (setq fc (current-fill-column)))
 890             (save-excursion
 891               (beginning-of-line)
 892               (and auto-fill-inhibit-regexp
 893                    (octave-looking-at-kw auto-fill-inhibit-regexp))))
 894         nil                             ; Can't do anything
 895       (if (and (not (octave-in-comment-p))
 896                (> (current-column) fc))
 897           (setq fc (- fc (+ (length octave-continuation-string) 1))))
 898       (while (and (not give-up) (> (current-column) fc))
 899         (let* ((opoint (point))
 900                (fpoint
 901                 (save-excursion
 902                   (move-to-column (+ fc 1))
 903                   (skip-chars-backward "^ \t\n")
 904                   ;; If we're at the beginning of the line, break after
 905                   ;; the first word
 906                   (if (bolp)
 907                       (re-search-forward "[ \t]" opoint t))
 908                   ;; If we're in a comment line, don't break after the
 909                   ;; comment chars
 910                   (if (save-excursion
 911                         (skip-syntax-backward " <")
 912                         (bolp))
 913                       (re-search-forward "[ \t]" (line-end-position)
 914                                          'move))
 915                   ;; If we're not in a comment line and just ahead the
 916                   ;; continuation string, don't break here.
 917                   (if (and (not (octave-in-comment-p))
 918                            (looking-at
 919                             (concat "\\s-*"
 920                                     (regexp-quote
 921                                      octave-continuation-string)
 922                                     "\\s-*$")))
 923                       (end-of-line))
 924                   (skip-chars-backward " \t")
 925                   (point))))
 926           (if (save-excursion
 927                 (goto-char fpoint)
 928                 (not (or (bolp) (eolp))))
 929               (let ((prev-column (current-column)))
 930                 (if (save-excursion
 931                       (skip-chars-backward " \t")
 932                       (= (point) fpoint))
 933                     (progn
 934                       (octave-maybe-insert-continuation-string)
 935                       (indent-new-comment-line t))
 936                   (save-excursion
 937                     (goto-char fpoint)
 938                     (octave-maybe-insert-continuation-string)
 939                     (indent-new-comment-line t)))
 940                 (if (>= (current-column) prev-column)
 941                     (setq give-up t)))
 942             (setq give-up t))))
 943       (not give-up))))
 944
 945 (defun octave-fill-paragraph (&optional arg)
 946   "Fill paragraph of Octave code, handling Octave comments."
 947   ;; FIXME: difference with generic fill-paragraph:
 948   ;; - code lines are only split, never joined.
 949   ;; - \n that end comments are never removed.
 950   ;; - insert continuation marker when splitting code lines.
 951   (interactive "P")
 952   (save-excursion
 953     (let ((end (progn (forward-paragraph) (copy-marker (point) t)))
 954           (beg (progn
 955                  (forward-paragraph -1)
 956                  (skip-chars-forward " \t\n")
 957                  (beginning-of-line)
 958                  (point)))
 959           (cfc (current-fill-column))
 960           comment-prefix)
 961       (goto-char beg)
 962       (while (< (point) end)
 963         (condition-case nil
 964             (indent-according-to-mode)
 965           (error nil))
 966         (move-to-column cfc)
 967         ;; First check whether we need to combine non-empty comment lines
 968         (if (and (< (current-column) cfc)
 969                  (octave-in-comment-p)
 970                  (not (save-excursion
 971                         (beginning-of-line)
 972                         (looking-at "^\\s-*\\s<+\\s-*$"))))
 973             ;; This is a nonempty comment line which does not extend
 974             ;; past the fill column.  If it is followed by a nonempty
 975             ;; comment line with the same comment prefix, try to
 976             ;; combine them, and repeat this until either we reach the
 977             ;; fill-column or there is nothing more to combine.
 978             (progn
 979               ;; Get the comment prefix
 980               (save-excursion
 981                 (beginning-of-line)
 982                 (while (and (re-search-forward "\\s<+")
 983                             (not (octave-in-comment-p))))
 984                 (setq comment-prefix (match-string 0)))
 985               ;; And keep combining ...
 986               (while (and (< (current-column) cfc)
 987                           (save-excursion
 988                             (forward-line 1)
 989                             (and (looking-at
 990                                   (concat "^\\s-*"
 991                                           comment-prefix
 992                                           "\\S<"))
 993                                  (not (looking-at
 994                                        (concat "^\\s-*"
 995                                                comment-prefix
 996                                                "\\s-*$"))))))
 997                 (delete-char 1)
 998                 (re-search-forward comment-prefix)
 999                 (delete-region (match-beginning 0) (match-end 0))
1000                 (fixup-whitespace)
1001                 (move-to-column cfc))))
1002         ;; We might also try to combine continued code lines>  Perhaps
1003         ;; some other time ...
1004         (skip-chars-forward "^ \t\n")
1005         (delete-horizontal-space)
1006         (if (or (< (current-column) cfc)
1007                 (and (= (current-column) cfc) (eolp)))
1008             (forward-line 1)
1009           (if (not (eolp)) (insert " "))
1010           (or (octave-auto-fill)
1011               (forward-line 1))))
1012       t)))
1013
1014 \f
1015 ;;; Completions
1016 (defun octave-initialize-completions ()
1017   "Create an alist for Octave completions."
1018   (if octave-completion-alist
1019       ()
1020     (setq octave-completion-alist
1021           (append octave-reserved-words
1022                   octave-text-functions
1023                   octave-variables))))
1024
1025 (defun octave-completion-at-point-function ()
1026   "Find the text to complete and the corresponding table."
1027   (let* ((beg (save-excursion (backward-sexp 1) (point)))
1028          (end (point)))
1029     (if (< beg (point))
1030         ;; Extend region past point, if applicable.
1031         (save-excursion (goto-char beg) (forward-sexp 1)
1032                         (setq end (max end (point)))))
1033     (list beg end octave-completion-alist)))
1034
1035 (defun octave-complete-symbol ()
1036   "Perform completion on Octave symbol preceding point.
1037 Compare that symbol against Octave's reserved words and builtin
1038 variables."
1039   (interactive)
1040   (apply 'completion-in-region (octave-completion-at-point-function)))
1041 \f
1042 ;;; Electric characters && friends
1043 (defun octave-reindent-then-newline-and-indent ()
1044   "Reindent current Octave line, insert newline, and indent the new line.
1045 If Abbrev mode is on, expand abbrevs first."
1046   ;; FIXME: None of this is Octave-specific.
1047   (interactive)
1048   (reindent-then-newline-and-indent))
1049
1050 (defun octave-electric-semi ()
1051   "Insert a semicolon in Octave mode.
1052 Maybe expand abbrevs and blink matching block open keywords.
1053 Reindent the line if `octave-auto-indent' is non-nil.
1054 Insert a newline if `octave-auto-newline' is non-nil."
1055   (interactive)
1056   (setq last-command-event ?\;)
1057   (if (not (octave-not-in-string-or-comment-p))
1058       (self-insert-command 1)
1059     (if octave-auto-indent
1060         (indent-according-to-mode))
1061     (self-insert-command 1)
1062     (if octave-auto-newline
1063         (newline-and-indent))))
1064
1065 (defun octave-electric-space ()
1066   "Insert a space in Octave mode.
1067 Maybe expand abbrevs and blink matching block open keywords.
1068 Reindent the line if `octave-auto-indent' is non-nil."
1069   (interactive)
1070   (setq last-command-event ? )
1071   (if (and octave-auto-indent
1072            (not (octave-not-in-string-or-comment-p)))
1073       (progn
1074         (indent-according-to-mode)
1075         (self-insert-command 1))
1076     (if (and octave-auto-indent
1077              (save-excursion
1078                (skip-syntax-backward " ")
1079                (not (bolp))))
1080         (indent-according-to-mode))
1081     (self-insert-command 1)))
1082
1083 (defun octave-abbrev-start ()
1084   "Start entering an Octave abbreviation.
1085 If Abbrev mode is turned on, typing ` (grave accent) followed by ? or
1086 \\[help-command] lists all Octave abbrevs.  Any other key combination is
1087 executed normally.
1088 Note that all Octave mode abbrevs start with a grave accent."
1089   (interactive)
1090   (if (not abbrev-mode)
1091       (self-insert-command 1)
1092     (let (c)
1093       (insert last-command-event)
1094       (if (if (featurep 'xemacs)
1095               (or (eq (event-to-character (setq c (next-event))) ??)
1096                   (eq (event-to-character c) help-char))
1097             (or (eq (setq c (read-event)) ??)
1098                 (eq c help-char)))
1099           (let ((abbrev-table-name-list '(octave-abbrev-table)))
1100             (list-abbrevs))
1101         (setq unread-command-events (list c))))))
1102
1103 (define-skeleton octave-insert-defun
1104   "Insert an Octave function skeleton.
1105 Prompt for the function's name, arguments and return values (to be
1106 entered without parens)."
1107   (let* ((defname (substring (buffer-name) 0 -2))
1108          (name (read-string (format "Function name (default %s): " defname)
1109                             nil nil defname))
1110          (args (read-string "Arguments: "))
1111          (vals (read-string "Return values: ")))
1112     (format "%s%s (%s)"
1113             (cond
1114              ((string-equal vals "") vals)
1115              ((string-match "[ ,]" vals) (concat "[" vals "] = "))
1116              (t (concat vals " = ")))
1117             name
1118             args))
1119   \n "function " > str \n \n
1120   octave-block-comment-start "usage: " str \n
1121   octave-block-comment-start \n octave-block-comment-start
1122   \n _ \n
1123   "endfunction" > \n)
1124 \f
1125 ;;; Communication with the inferior Octave process
1126 (defun octave-kill-process ()
1127   "Kill inferior Octave process and its buffer."
1128   (interactive)
1129   (if inferior-octave-process
1130       (progn
1131         (process-send-string inferior-octave-process "quit;\n")
1132         (accept-process-output inferior-octave-process)))
1133   (if inferior-octave-buffer
1134       (kill-buffer inferior-octave-buffer)))
1135
1136 (defun octave-show-process-buffer ()
1137   "Make sure that `inferior-octave-buffer' is displayed."
1138   (interactive)
1139   (if (get-buffer inferior-octave-buffer)
1140       (display-buffer inferior-octave-buffer)
1141     (message "No buffer named %s" inferior-octave-buffer)))
1142
1143 (defun octave-hide-process-buffer ()
1144   "Delete all windows that display `inferior-octave-buffer'."
1145   (interactive)
1146   (if (get-buffer inferior-octave-buffer)
1147       (delete-windows-on inferior-octave-buffer)
1148     (message "No buffer named %s" inferior-octave-buffer)))
1149
1150 (defun octave-send-region (beg end)
1151   "Send current region to the inferior Octave process."
1152   (interactive "r")
1153   (inferior-octave t)
1154   (let ((proc inferior-octave-process)
1155         (string (buffer-substring-no-properties beg end))
1156         line)
1157     (with-current-buffer inferior-octave-buffer
1158       (setq inferior-octave-output-list nil)
1159       (while (not (string-equal string ""))
1160         (if (string-match "\n" string)
1161             (setq line (substring string 0 (match-beginning 0))
1162                   string (substring string (match-end 0)))
1163           (setq line string string ""))
1164         (setq inferior-octave-receive-in-progress t)
1165         (inferior-octave-send-list-and-digest (list (concat line "\n")))
1166         (while inferior-octave-receive-in-progress
1167           (accept-process-output proc))
1168         (insert-before-markers
1169          (mapconcat 'identity
1170                     (append
1171                      (if octave-send-echo-input (list line) (list ""))
1172                      (mapcar 'inferior-octave-strip-ctrl-g
1173                              inferior-octave-output-list)
1174                      (list inferior-octave-output-string))
1175                     "\n")))))
1176   (if octave-send-show-buffer
1177       (display-buffer inferior-octave-buffer)))
1178
1179 (defun octave-send-block ()
1180   "Send current Octave block to the inferior Octave process."
1181   (interactive)
1182   (save-excursion
1183     (octave-mark-block)
1184     (octave-send-region (point) (mark))))
1185
1186 (defun octave-send-defun ()
1187   "Send current Octave function to the inferior Octave process."
1188   (interactive)
1189   (save-excursion
1190     (mark-defun)
1191     (octave-send-region (point) (mark))))
1192
1193 (defun octave-send-line (&optional arg)
1194   "Send current Octave code line to the inferior Octave process.
1195 With positive prefix ARG, send that many lines.
1196 If `octave-send-line-auto-forward' is non-nil, go to the next unsent
1197 code line."
1198   (interactive "P")
1199   (or arg (setq arg 1))
1200   (if (> arg 0)
1201       (let (beg end)
1202         (beginning-of-line)
1203         (setq beg (point))
1204         (octave-next-code-line (- arg 1))
1205         (end-of-line)
1206         (setq end (point))
1207         (if octave-send-line-auto-forward
1208             (octave-next-code-line 1))
1209         (octave-send-region beg end))))
1210
1211 (defun octave-eval-print-last-sexp ()
1212   "Evaluate Octave sexp before point and print value into current buffer."
1213   (interactive)
1214   (inferior-octave t)
1215   (let ((standard-output (current-buffer))
1216         (print-escape-newlines nil)
1217         (opoint (point)))
1218     (terpri)
1219     (prin1
1220      (save-excursion
1221        (forward-sexp -1)
1222        (inferior-octave-send-list-and-digest
1223         (list (concat (buffer-substring-no-properties (point) opoint)
1224                       "\n")))
1225        (mapconcat 'identity inferior-octave-output-list "\n")))
1226     (terpri)))
1227 \f
1228 ;;; Bug reporting
1229 (defun octave-submit-bug-report ()
1230   "Submit a bug report on the Emacs Octave package via mail."
1231   (interactive)
1232   (require 'reporter)
1233   (and
1234    (y-or-n-p "Do you want to submit a bug report? ")
1235    (reporter-submit-bug-report
1236     octave-maintainer-address
1237     (concat "Emacs version " emacs-version)
1238     (list
1239      'octave-auto-indent
1240      'octave-auto-newline
1241      'octave-blink-matching-block
1242      'octave-block-offset
1243      'octave-comment-char
1244      'octave-continuation-offset
1245      'octave-continuation-string
1246      'octave-send-echo-input
1247      'octave-send-line-auto-forward
1248      'octave-send-show-buffer))))
1249
1250 ;; provide ourself
1251
1252 (provide 'octave-mod)
1253
1254 ;; arch-tag: 05f1ce09-be87-4c00-803e-4919ffa26c23
1255 ;;; octave-mod.el ends here