;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:28 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/octave-mod.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\302\303\304\305\306\307\310\311&\207" [require custom custom-declare-group octave nil "Major mode for editing Octave source files." :link (custom-group-link :tag "Font Lock Faces group" font-lock-faces) :group languages] 8)
(defvar inferior-octave-output-list nil)
(defvar inferior-octave-output-string nil)
(defvar inferior-octave-receive-in-progress nil)
#@49 Current maintainer of the Emacs Octave package.
(defconst octave-maintainer-address "Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>, bug-gnu-emacs@gnu.org" (#$ . 947))
(byte-code "\300\301\302\303\304\"\305\306\307%\207" [define-abbrev-table octave-abbrev-table mapcar #[(e) "\301\302\"\207" [e append (nil 0 t)] 3] (("`a" "all_va_args") ("`b" "break") ("`cs" "case") ("`ca" "catch") ("`c" "continue") ("`el" "else") ("`eli" "elseif") ("`et" "end_try_catch") ("`eu" "end_unwind_protect") ("`ef" "endfor") ("`efu" "endfunction") ("`ei" "endif") ("`es" "endswitch") ("`ew" "endwhile") ("`f" "for") ("`fu" "function") ("`gl" "global") ("`gp" "gplot") ("`gs" "gsplot") ("`if" "if ()") ("`o" "otherwise") ("`rp" "replot") ("`r" "return") ("`s" "switch") ("`t" "try") ("`u" "until ()") ("`up" "unwind_protect") ("`upc" "unwind_protect_cleanup") ("`w" "while ()")) "Abbrev table for Octave's reserved words.\nUsed in `octave-mode' and inferior-octave-mode buffers.\nAll Octave abbrevs start with a grave accent (`)." :regexp "\\(?:[^`]\\|^\\)\\(\\(?:\\<\\|`\\)\\w+\\)\\W*"] 6)
#@39 Character to start an Octave comment.
(defvar octave-comment-char 35 (#$ . 2017))
#@57 String to insert to start a new Octave in-line comment.
(defvar octave-comment-start (string octave-comment-char 32) (#$ . 2105))
#@64 Regexp to match the start of an Octave comment up to its body.
(defvar octave-comment-start-skip "\\s<+\\s-*" (#$ . 2241))
(defvar octave-begin-keywords '("do" "for" "function" "if" "switch" "try" "unwind_protect" "while"))
(defvar octave-else-keywords '("case" "catch" "else" "elseif" "otherwise" "unwind_protect_cleanup"))
(defvar octave-end-keywords '("endfor" "endfunction" "endif" "endswitch" "end_try_catch" "end_unwind_protect" "endwhile" "until" "end"))
#@27 Reserved words in Octave.
(defvar octave-reserved-words (append octave-begin-keywords octave-else-keywords octave-end-keywords '("break" "continue" "end" "global" "persistent" "return")) (#$ . 2709))
#@27 Text functions in Octave.
(defvar octave-text-functions '("casesen" "cd" "chdir" "clear" "diary" "dir" "document" "echo" "edit_history" "format" "help" "history" "hold" "load" "ls" "more" "run_history" "save" "type" "which" "who" "whos") (#$ . 2915))
#@30 Builtin variables in Octave.
(defvar octave-variables '("DEFAULT_EXEC_PATH" "DEFAULT_LOADPATH" "EDITOR" "EXEC_PATH" "F_DUPFD" "F_GETFD" "F_GETFL" "F_SETFD" "F_SETFL" "I" "IMAGE_PATH" "Inf" "J" "NaN" "OCTAVE_VERSION" "O_APPEND" "O_CREAT" "O_EXCL" "O_NONBLOCK" "O_RDONLY" "O_RDWR" "O_TRUNC" "O_WRONLY" "PAGER" "PS1" "PS2" "PS4" "PWD" "SEEK_CUR" "SEEK_END" "SEEK_SET" "__F_DUPFD__" "__F_GETFD__" "__F_GETFL__" "__F_SETFD__" "__F_SETFL__" "__I__" "__Inf__" "__J__" "__NaN__" "__OCTAVE_VERSION__" "__O_APPEND__" "__O_CREAT__" "__O_EXCL__" "__O_NONBLOCK__" "__O_RDONLY__" "__O_RDWR__" "__O_TRUNC__" "__O_WRONLY__" "__PWD__" "__SEEK_CUR__" "__SEEK_END__" "__SEEK_SET__" "__argv__" "__e__" "__eps__" "__i__" "__inf__" "__j__" "__nan__" "__pi__" "__program_invocation_name__" "__program_name__" "__realmax__" "__realmin__" "__stderr__" "__stdin__" "__stdout__" "ans" "argv" "beep_on_error" "completion_append_char" "crash_dumps_octave_core" "default_save_format" "e" "echo_executing_commands" "eps" "error_text" "gnuplot_binary" "history_file" "history_size" "ignore_function_time_stamp" "inf" "nan" "nargin" "output_max_field_width" "output_precision" "page_output_immediately" "page_screen_output" "pi" "print_answer_id_name" "print_empty_dimensions" "program_invocation_name" "program_name" "realmax" "realmin" "return_last_computed_value" "save_precision" "saving_history" "sighup_dumps_octave_core" "sigterm_dumps_octave_core" "silent_functions" "split_long_rows" "stderr" "stdin" "stdout" "string_fill_char" "struct_levels_to_print" "suppress_verbose_help_message") (#$ . 3172))
#@136 Regexp to match an Octave function header.
The string `function' and its name are given by the first and third
parenthetical grouping.
(defvar octave-function-header-regexp "^\\s-*\\_<\\(function\\)\\_>\\([^=;\n]*=[ 	]*\\|[ 	]*\\)\\(\\(?:\\w\\|\\s_\\)+\\)\\_>" (#$ . 4755))
#@45 Additional Octave expressions to highlight.
(defvar octave-font-lock-keywords (byte-code "\304\305\306	\"!\307Q\310B\311\312\313!\203\313\202\314B\315\305\n!\316Q\317B\320\321EF\207" [octave-reserved-words octave-text-functions octave-variables octave-function-header-regexp "\\_<\\(" regexp-opt append "\\)\\_>" font-lock-keyword-face "\\(&\\||\\|<=\\|>=\\|==\\|<\\|>\\|!=\\|!\\)" boundp font-lock-builtin-face font-lock-preprocessor-face "\\_<" "\\_>" font-lock-variable-name-face (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t)] 6) (#$ . 5035))
(defalias 'octave-syntax-propertize-function #[(start end) "b\210\302	!\210`	\211b\210`	W\2051\303\304	\305#\2051\306\224\203\307\306\224\306\225\310\311$\210\302	!\210\202*\207" [start end octave-syntax-propertize-sqs re-search-forward "[[({,; ]\\('\\)" t 1 put-text-property syntax-table (7 . 39)] 6])
#@53 Propertize the content/end of single-quote strings.
(defalias 'octave-syntax-propertize-sqs #[(end) "\301\302 8\303=\2050\304\305\306#\2050\307\224b\210\310\224Sf\311=\203(\312\310\224S\310\224\313\314$\210\312\310\224\310\225\313\315$\207" [end 3 syntax-ppss 39 re-search-forward "\\(?:\\=\\|[^']\\)\\(?:''\\)*\\('\\)\\($\\|[^']\\)" move 2 1 92 put-text-property syntax-table (1) (7 . 39)] 5 (#$ . 5926)])
#@56 Name of buffer for running an inferior Octave process.
(custom-declare-variable 'inferior-octave-buffer "*Inferior Octave*" '(#$ . 6343) :type 'string :group 'octave-inferior)
(defvar inferior-octave-process nil)
#@29 Keymap used in Octave mode.
(defvar octave-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\302\323\324#\210\302\325\326#\210\302\327\330#\210\302\331\330#\210\302\332\333#\210\302\334\335#\210\302\336\337#\210\302\340\341#\210\302\342\343#\210\302\344\345#\210\302\346\347#\210\302\350\351#\210\302\352\353#\210\302\354\337#\210\302\355\341#\210\302\356\343#\210\302\357\345#\210\302\360\347#\210\302\361\351#\210\302\362\353#\210)\207" [map make-sparse-keymap define-key "`" octave-abbrev-start "\n" octave-indent-new-comment-line "\221" octave-indent-defun "" octave-submit-bug-report "" octave-previous-code-line "" octave-next-code-line "
" octave-beginning-of-line "" octave-end-of-line [remap down-list] smie-down-list "\210" octave-mark-block "]" smie-close-block "/" "" octave-insert-defun "" info-lookup-symbol "	l" octave-send-line "	b" octave-send-block "	f" octave-send-defun "	r" octave-send-region "	s" octave-show-process-buffer "	h" octave-hide-process-buffer "	k" octave-kill-process "	\f" "	" "	" "	" "	" "	" "	"] 4) (#$ . 6562))
#@23 Menu for Octave mode.
(defvar octave-mode-menu nil (#$ . 7798))
(easy-menu-do-define 'octave-mode-menu octave-mode-map "Menu for Octave mode." '("Octave" ("Lines" ["Previous Code Line" octave-previous-code-line t] ["Next Code Line" octave-next-code-line t] ["Begin of Continuation" octave-beginning-of-line t] ["End of Continuation" octave-end-of-line t] ["Split Line at Point" octave-indent-new-comment-line t]) ("Blocks" ["Mark Block" octave-mark-block t] ["Close Block" smie-close-block t]) ("Functions" ["Indent Function" octave-indent-defun t] ["Insert Function" octave-insert-defun t]) "-" ("Debug" ["Send Current Line" octave-send-line t] ["Send Current Block" octave-send-block t] ["Send Current Function" octave-send-defun t] ["Send Region" octave-send-region t] ["Show Process Buffer" octave-show-process-buffer t] ["Hide Process Buffer" octave-hide-process-buffer t] ["Kill Process" octave-kill-process t]) "-" ["Indent Line" indent-according-to-mode t] ["Complete Symbol" completion-at-point t] "-" ["Toggle Abbrev Mode" abbrev-mode :style toggle :selected abbrev-mode] ["Toggle Auto-Fill Mode" auto-fill-mode :style toggle :selected auto-fill-function] "-" ["Submit Bug Report" octave-submit-bug-report t] "-" ["Describe Octave Mode" describe-mode t] ["Lookup Octave Index" info-lookup-symbol t]))
#@47 Syntax table in use in `octave-mode' buffers.
(defvar octave-mode-syntax-table (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\306#\210\302\310\306#\210\302\311\306#\210\302\312\306#\210\302\313\306#\210\302\314\306#\210\302\315\306#\210\302\316\306#\210\302\317\306#\210\302\320\321#\210\302\322\306#\210\302\323\306#\210\302\324\325#\210\302\326\327#\210\302\330\327#\210\302\331\332#\210\302\333\332#\210\302\334\335#\210\302\336\337#\210\302\340\341#\210)\207" [table make-syntax-table modify-syntax-entry 13 " " 43 "." 45 61 42 47 62 60 38 124 33 92 "\\" 39 96 34 "\"" 46 "_" 95 37 "< 13" 35 123 "(} 2c" 125 "){ 4c" 10 ">"] 4) (#$ . 9115))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\313\306\307&\207" [custom-declare-variable octave-blink-matching-block t "Control the blinking of matching Octave block keywords.\nNon-nil means show matching begin of block when inserting a space,\nnewline or semicolon after an else or end keyword." :type boolean :group octave octave-block-offset 2 "Extra indentation applied to statements in Octave block structures." integer] 8)
#@66 String to insert to start a new Octave comment on an empty line.
(defvar octave-block-comment-start (byte-code "\301\302\"\303P\207" [octave-comment-char make-string 2 " "] 3) (#$ . 10257))
#@57 Extra indentation applied to Octave continuation lines.
(custom-declare-variable 'octave-continuation-offset 4 '(#$ . 10454) :type 'integer :group 'octave)
(defconst octave-continuation-marker-regexp "\\\\\\|\\.\\.\\.")
(defvar octave-continuation-regexp (concat "[^#%\n]*\\(" octave-continuation-marker-regexp "\\)\\s-*\\(\\s<.*\\)?$"))
#@67 Character string used for Octave continuation lines.  Normally \.
(custom-declare-variable 'octave-continuation-string "\\" '(#$ . 10798) :type 'string :group 'octave)
#@225 Alist of Octave symbols for completion in Octave mode.
Each element looks like (VAR . VAR), where the car and cdr are the same
symbol (an Octave command or variable name).
Currently, only builtin variables can be completed.
(defvar octave-completion-alist nil (#$ . 10973))
#@68 Imenu expression for Octave mode.  See `imenu-generic-expression'.
(defvar octave-mode-imenu-generic-expression (byte-code "\301\302EC\207" [octave-function-header-regexp nil 3] 3) (#$ . 11253))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\313\306\307&\210\300\314\311\315\304\313\306\307&\210\300\316\311\317\304\313\306\307&\210\320\321!\207" [custom-declare-variable octave-mode-hook nil "Hook to be run when Octave mode is started." :type hook :group octave octave-send-show-buffer t "Non-nil means display `inferior-octave-buffer' after sending to it." boolean octave-send-line-auto-forward "Control auto-forward after sending to the inferior Octave process.\nNon-nil means always go to the next Octave code line after sending." octave-send-echo-input "Non-nil means echo input sent to the inferior Octave process." require smie] 8)
(defconst octave-operator-table '((assoc ";" "\n") (assoc ",") (right "=" "+=" "-=" "*=" "/=") (assoc "&&") (assoc "||") (assoc "&") (assoc "|") (nonassoc "<" "<=" "==" ">=" ">" "!=" "~=") (nonassoc ":") (assoc "+" "-") (assoc "*" "/" "\\" ".\\" ".*" "./") (nonassoc "'" ".'") (nonassoc "++" "--" "!" "~") (right "^" "**" ".^" ".**") (assoc "...")))
(defconst octave-smie-bnf-table '((atom) (exp (exp "\n" exp) (exp ";" exp) ("try" exp "catch" exp "end_try_catch") ("try" exp "catch" exp "end") ("unwind_protect" exp "unwind_protect_cleanup" exp "end_unwind_protect") ("unwind_protect" exp "unwind_protect_cleanup" exp "end") ("for" exp "endfor") ("for" exp "end") ("do" exp "until" atom) ("while" exp "endwhile") ("while" exp "end") ("if" exp "endif") ("if" exp "else" exp "endif") ("if" exp "elseif" exp "else" exp "endif") ("if" exp "elseif" exp "elseif" exp "else" exp "endif") ("if" exp "elseif" exp "elseif" exp "else" exp "end") ("switch" exp "case" exp "endswitch") ("switch" exp "case" exp "otherwise" exp "endswitch") ("switch" exp "case" exp "case" exp "otherwise" exp "endswitch") ("switch" exp "case" exp "case" exp "otherwise" exp "end") ("function" exp "endfunction") ("function" exp "end"))))
(defconst octave-smie-grammar (byte-code "\302\303\304\305\"\306	!\"!\207" [octave-smie-bnf-table octave-operator-table smie-prec2->grammar smie-merge-prec2s smie-bnf->prec2 ((assoc "\n" ";")) smie-precs->prec2] 5))
(defconst octave-operator-regexp (byte-code "\301\302\303\304\305\"\"!\207" [octave-operator-table regexp-opt apply append mapcar cdr] 6))
(defalias 'octave-smie-backward-token #[nil "`\304`[!\210`Sf\305=\204F\306 V\203F\307	`\310Z\"\203+\311\224b\210\304`[!\210\202F\312 \211A@\205:\nA@f\313=)\204F\314\315w\210\316\202d\307`\310Z\317#\203b\307\320`S\"\204b\311\224b\210\321\311!\202d\322 )\207" [pos octave-continuation-marker-regexp ppss octave-operator-regexp forward-comment 59 line-end-position looking-back 3 0 syntax-ppss 40 " 	" nil ";" greedy "\\s\"" match-string-no-properties smie-default-backward-token] 5])
(defalias 'octave-smie-forward-token #[nil "\302\303w\210\304\305!\203\306\225b\210\307\306!\210\304\310!\2032\311 \211A@\205'A@f\312=)?\307d!\210\2032\313\207\304\314!\203B\306\224b\210\307\306!\210\313\207\304	!\203V\304\315!\204V\316\225b\210\317\316!\207\320 \207" [ppss octave-operator-regexp " 	" nil looking-at "\\(\\\\\\|\\.\\.\\.\\)[ 	]*\\($\\|[%#]\\)" 1 forward-comment "$\\|[%#]" syntax-ppss 40 ";" ";[ 	]*\\($\\|[%#]\\)" "\\s\"" 0 match-string-no-properties smie-default-forward-token] 4])
(defalias 'octave-smie-rules #[(kind token) "	B\211:\205c\n@\nA\306=\203\f\307=\205b
\202b\310=\2035\f\311\232\205b\312 ?\205b
\202b\313=\204?\314\202b\f\315\232\203a\316\317\320\321\322\323\324\325\311\326\327\330\331&\f\203]\332
!\202b\333\202b\314*)\207" [kind token #1=#:val #2=#:xcar #3=#:xcdr octave-block-offset :elem basic :before "case" smie-rule-sibling-p :after nil ";" smie-rule-parent-p "function" "if" "while" "else" "elseif" "for" "otherwise" "try" "catch" "unwind_protect" "unwind_protect_cleanup" smie-rule-parent 0] 14])
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [octave-mode-hook variable-documentation put purecopy "Hook run when entering Octave mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp octave-mode-map definition-name octave-mode] 5)
(defvar octave-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [octave-mode-map variable-documentation put purecopy "Keymap for `octave-mode'." boundp octave-mode-syntax-table definition-name octave-mode] 5)
(defvar octave-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [octave-mode-syntax-table variable-documentation put purecopy "Syntax table for `octave-mode'." octave-mode-abbrev-table definition-name octave-mode] 5)
(defvar octave-mode-abbrev-table (progn (define-abbrev-table 'octave-mode-abbrev-table nil) octave-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [octave-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `octave-mode'." octave-mode derived-mode-parent prog-mode] 5)
#@2588 Major mode for editing Octave code.

This mode makes it easier to write Octave code by helping with
indentation, doing some of the typing for you (with Abbrev mode) and by
showing keywords, comments, strings, etc. in different faces (with
Font Lock mode on terminals that support it).

Octave itself is a high-level language, primarily intended for numerical
computations.  It provides a convenient command line interface for
solving linear and nonlinear problems numerically.  Function definitions
can also be stored in files, and it can be used in a batch mode (which
is why you need this mode!).

The latest released version of Octave is always available via anonymous
ftp from ftp.octave.org in the directory `/pub/octave'.  Complete
source and binaries for several popular systems are available.

Type \[list-abbrevs] to display the built-in abbrevs for Octave keywords.

Keybindings
===========

\{octave-mode-map}

Variables you can use to customize Octave mode
==============================================

`octave-blink-matching-block'
  Non-nil means show matching begin of block when inserting a space,
  newline or semicolon after an else or end keyword.  Default is t.

`octave-block-offset'
  Extra indentation applied to statements in block structures.
  Default is 2.

`octave-continuation-offset'
  Extra indentation applied to Octave continuation lines.
  Default is 4.

`octave-continuation-string'
  String used for Octave continuation lines.
  Default is a backslash.

`octave-send-echo-input'
  Non-nil means always display `inferior-octave-buffer' after sending a
  command to the inferior Octave process.

`octave-send-line-auto-forward'
  Non-nil means always go to the next unsent line of Octave code after
  sending a line to the inferior Octave process.

`octave-send-echo-input'
  Non-nil means echo input sent to the inferior Octave process.

Turning on Octave mode runs the hook `octave-mode-hook'.

To begin using this mode for all `.m' files that you edit, add the
following lines to your init file:

  (add-to-list 'auto-mode-alist '("\\.m\\'" . octave-mode))

To automatically turn on the abbrev and auto-fill features,
add the following lines to your init file as well:

  (add-hook 'octave-mode-hook
	    (lambda ()
	      (abbrev-mode 1)
	      (auto-fill-mode 1)))

To submit a problem report, enter \[octave-submit-bug-report] from an Octave mode buffer.
This automatically sets up a mail buffer with version information
already added.  You just need to add a description of the problem,
including a reproducible test case and send the message.
(defalias 'octave-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324@\325\"\204V@A=\204V\326@\325AC#\210\327!\210\330\f!\210@ABA\331C\332\333\334\335\336&\210\306\337!\210\340\306\341!\210\342!B!D\204\215\343\344\345\346#\210\306\347!\210\342'B'\306\350!\210\351(\306\352!\210E*\306\353!\210\354+\306\355!\210\356-\306\357!\210\360/\306\361!\210\3071\306\362!\210\363FP2\306\364!\21024\306\365!\210\3075\306\366!\210\3676\306\370!\210\3718\306\372!\210\373:\306\374!\210\375<\306\376!\210G>\306\377!\210\201J?\201K\201L\201M\201J\307$\210\306\201H!\210\201NH\201OI!\210\201P \210)\201Q\201R!\207" [delay-mode-hooks major-mode mode-name octave-mode-map octave-mode-syntax-table parent make-local-variable t prog-mode octave-mode "Octave" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table smie-setup octave-smie-rules :forward-token octave-smie-forward-token :backward-token octave-smie-backward-token smie-indent-basic octave-block-offset smie-blink-matching-triggers 59 remove-hook post-self-insert-hook smie-blink-matching-open local electric-indent-chars electric-layout-rules ((59 . after)) comment-start comment-end "" comment-start-skip "\\s<+\\s-*" comment-add 1 parse-sexp-ignore-comments paragraph-start "\\s-*$\\|" paragraph-separate paragraph-ignore-fill-prefix fill-paragraph-function octave-fill-paragraph normal-auto-fill-function octave-auto-fill font-lock-defaults (octave-font-lock-keywords) syntax-propertize-function octave-syntax-propertize-function imenu-generic-expression imenu-case-fold-search octave-mode-abbrev-table local-abbrev-table octave-abbrev-table octave-smie-grammar octave-blink-matching-block octave-comment-start page-delimiter octave-mode-imenu-generic-expression beginning-of-defun-function octave-mode-menu nil add-hook completion-at-point-functions octave-completion-at-point-function octave-beginning-of-defun easy-menu-add octave-initialize-completions run-mode-hooks octave-mode-hook] 8 (#$ . 16547) nil])
#@48 Return t if point is inside an Octave comment.
(defalias 'octave-in-comment-p #[nil "\300\301 8\207" [4 syntax-ppss] 2 (#$ . 21429)])
(put 'octave-in-comment-p 'byte-optimizer 'byte-compile-inline-expand)
#@47 Return t if point is inside an Octave string.
(defalias 'octave-in-string-p #[nil "\300\301 8\207" [3 syntax-ppss] 2 (#$ . 21640)])
(put 'octave-in-string-p 'byte-optimizer 'byte-compile-inline-expand)
#@62 Return t if point is not inside an Octave string or comment.
(defalias 'octave-not-in-string-or-comment-p #[nil "\301 \3028\206\f\3038)?\207" [pps syntax-ppss 3 4] 2 (#$ . 21848)])
(put 'octave-not-in-string-or-comment-p 'byte-optimizer 'byte-compile-inline-expand)
#@53 Like `looking-at', but sets `case-fold-search' nil.
(defalias 'octave-looking-at-kw #[(regexp) "\302\303	!)\207" [case-fold-search regexp nil looking-at] 2 (#$ . 22124)])
(defalias 'octave-maybe-insert-continuation-string #[nil "\302\303 8\206\212\304 \210\305!)?\205\306 \210\307	Pc\207" [octave-continuation-regexp octave-continuation-string 4 syntax-ppss beginning-of-line looking-at delete-horizontal-space " "] 2])
#@214 Break Octave line at point, continuing comment if within one.
If within code, insert `octave-continuation-string' before breaking the
line.  If within a string, signal an error.
The new line is properly indented.
(defalias 'octave-indent-new-comment-line #[nil "\301 \210\302\303 8\203
\304 \207\305\303 8\203\306\307!\207\310Pc\210\311 \207" [octave-continuation-string delete-horizontal-space 4 syntax-ppss indent-new-comment-line 3 error "Cannot split a code line inside a string" " " reindent-then-newline-and-indent] 2 (#$ . 22557) nil])
#@59 Properly indent the Octave function which contains point.
(defalias 'octave-indent-defun #[nil "\212\300 \210\301\302!\210\303`\304 \305#\210)\301\306!\207" [mark-defun message "Indenting function..." indent-region mark nil "Indenting function...done."] 4 (#$ . 23110) nil])
#@205 Move ARG lines of Octave code forward (backward if ARG is negative).
Skips past all empty and comment lines.  Default for ARG is 1.

On success, return 0.  Otherwise, go as far as possible and return -1.
(defalias 'octave-next-code-line #[(&optional arg) "\204\303\304 \210\305\305V\203\303\202\306\305U\204A\n\305U\203A	y\211\305U\2039\307\310!\2039	y\211\202'	Z\211\202\n*\207" [arg inc n 1 beginning-of-line 0 -1 looking-at "\\s-*\\($\\|\\s<\\)"] 4 (#$ . 23392) "p"])
#@205 Move ARG lines of Octave code backward (forward if ARG is negative).
Skips past all empty and comment lines.  Default for ARG is 1.

On success, return 0.  Otherwise, go as far as possible and return -1.
(defalias 'octave-previous-code-line #[(&optional arg) "\204\301\302[!\207" [arg 1 octave-next-code-line] 2 (#$ . 23893) "p"])
#@336 Move point to beginning of current Octave line.
If on an empty or comment line, go to the beginning of that line.
Otherwise, move backward to the beginning of the first Octave code line
which is not inside a continuation statement, i.e., which does not
follow a code line ending in `...' or `\', or is inside an open
parenthesis list.
(defalias 'octave-beginning-of-line #[nil "\301 \210\302\303!?\2050\304\305\306\217\204\n\302\303!\204&\212\307\310 !\205\"\302!)\2050\307\311y!\2050\202\n\207" [octave-continuation-regexp beginning-of-line looking-at "\\s-*\\($\\|\\s<\\)" nil (byte-code "\300\301!\210\302 \210\303\207" [up-list -1 beginning-of-line t] 2) ((error)) zerop octave-previous-code-line -1] 3 (#$ . 24236) nil])
#@242 Move point to end of current Octave line.
If on an empty or comment line, go to the end of that line.
Otherwise, move forward to the end of the first Octave code line which
does not end in `...' or `\' or is inside an open parenthesis list.
(defalias 'octave-end-of-line #[nil "\301\210\212\302 \210\303\304!)?\2050\301\305\306\217\204\212\302 \210\303\304!\206#\303!)\203.\307\310y!\204\301\207" [octave-continuation-regexp nil beginning-of-line looking-at "\\s-*\\($\\|\\s<\\)" (byte-code "\300\301!\210\302\210\303\207" [up-list 1 nil t] 2) ((error)) zerop 1] 3 (#$ . 24977) nil])
#@133 Put point at the beginning of this Octave block, mark at the end.
The block marked is the one that contains point or follows point.
(defalias 'octave-mark-block #[nil "\305\306!\203\307\306`S\"\203\310\311!\210\305\312!\2045\212 \313	\n\"\211\205-\211A@)\247?+\2045\314\315!\210\316 \207" [smie-forward-token-function token smie-grammar level x looking-at "\\sw\\|\\s_" looking-back skip-syntax-forward "w_" "\\s(" assoc backward-up-list 1 mark-sexp] 4 (#$ . 25579) nil])
#@249 Move backward to the beginning of an Octave function.
With positive ARG, do it that many times.  Negative argument -N means
move forward to Nth following beginning of a function.
Returns t unless search stops at the beginning or end of the buffer.
(defalias 'octave-beginning-of-defun #[(&optional arg) "\206\305\211\306V\203\305\202\307\310\211m\204*\306V\203&\311\312!\204*\313\314!\210\306U\204Q\315\312	\"\211\203Q\316 \317\f8\206E\320\f8)\204*	Z\211\202+\n\205`	\306W\203_\306\224b\210\321,\207" [arg inc found case-fold-search pps 1 0 -1 nil looking-at "\\_<function\\_>" skip-syntax-forward "w" re-search-backward syntax-ppss 3 4 t] 4 (#$ . 26070)])
#@119 Perform auto-fill in Octave mode.
Returns nil if no feasible place to break the line could be found, and t
otherwise.
(defalias 'octave-auto-fill #[nil "\306\211\307 \211?\206\212\310 \210\n\205\311\n!)?\205\303\312\313 8\204/i	V\203/	GTZ\204\301i	V\203\301`\212\314	T!\210\315\306x\210n\203O\316\317\f\320#\210\212\321\322!\210n)\203`\316\317\323 \324#\210\312\313 8\204u\325\326\327!\330Q!\203u\306\210\331\306x\210`)\212
b\210n\206\205l)\204\273i\212\331\306x\210`
U)\203\242\332 \210\333\320!\210\202\256\212
b\210\332 \210\333\320!\210)iY\203\267\320)\202\275\320*\202/?*\207" [give-up fc auto-fill-inhibit-regexp octave-continuation-string opoint fpoint nil current-fill-column beginning-of-line octave-looking-at-kw 4 syntax-ppss move-to-column "^ 	\n" re-search-forward "[ 	]" t skip-syntax-backward " <" line-end-position move looking-at "\\s-*" regexp-quote "\\s-*$" " 	" octave-maybe-insert-continuation-string indent-new-comment-line prev-column] 4 (#$ . 26761)])
#@58 Fill paragraph of Octave code, handling Octave comments.
(defalias 'octave-fill-paragraph #[(&optional _arg) "\212\304 \210\305`\306\"\304\307!\210\310\311w\210\312 \210`\313 \311\nb\210`W\203\300\311\314\315\217\210\316	!\210i	W\203\221\317\320 8\203\221\212\312 \210\321\322!)\204\221\212\312 \210\323\324!\203V\317\320 8\203I\325\326!)i	W\203\221\212\327y\210\321\330\331Q!\205u\321\330\332Q!?)\203\221\333\327!\210\323!\210\326\224\326\225|\210\334 \210\316	!\210\202[\335\311w\210\336 \210i	W\204\250i	U\203\256l\203\256\327y\210\202l\204\265\337c\210\340 \204\327y\210\202-\306\207" [comment-prefix cfc beg end forward-paragraph copy-marker t -1 " 	\n" nil beginning-of-line current-fill-column (indent-according-to-mode) ((error)) move-to-column 4 syntax-ppss looking-at "^\\s-*\\s<+\\s-*$" re-search-forward "\\s<+" match-string 0 1 "^\\s-*" "\\S<" "\\s-*$" delete-char fixup-whitespace "^ 	\n" delete-horizontal-space " " octave-auto-fill] 4 (#$ . 27780) "P"])
#@41 Create an alist for Octave completions.
(defalias 'octave-initialize-completions #[nil "?\205\f\304	\n#\211\207" [octave-completion-alist octave-reserved-words octave-text-functions octave-variables append] 4 (#$ . 28785)])
#@56 Find the text to complete and the corresponding table.
(defalias 'octave-completion-at-point-function #[nil "\212\303\304!\210`)``W\203\212\305\304!\210`)	\nE*\207" [beg end octave-completion-alist skip-syntax-backward "w_" skip-syntax-forward] 3 (#$ . 29019)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias octave-complete-symbol completion-at-point nil make-obsolete "24.1"] 4)
#@262 Start entering an Octave abbreviation.
If Abbrev mode is turned on, typing ` (grave accent) followed by ? or
\[help-command] lists all Octave abbrevs.  Any other key combination is
executed normally.
Note that all Octave mode abbrevs start with a grave accent.
(defalias 'octave-abbrev-start #[nil "\303\304!\210\205\305\306 \307	\310\311#\210\307	\312\n!\311#\210	)!\207" [abbrev-mode map help-char self-insert-command 1 set-temporary-overlay-map make-sparse-keymap define-key [63] list-abbrevs vector] 5 (#$ . 29433) nil])
(put 'octave-insert-defun 'no-self-insert t)
#@632 Insert an Octave function skeleton.
Prompt for the function's name, arguments and return values (to be
entered without parens).

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'octave-insert-defun #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ((let* ((defname (substring (buffer-name) 0 -2)) (name (read-string (format "Function name (default %s): " defname) nil nil defname)) (args (read-string "Arguments: ")) (vals (read-string "Return values: "))) (format "%s%s (%s)" (cond ((string-equal vals "") vals) ((string-match "[ ,]" vals) (concat "[" vals "] = ")) (t (concat vals " = "))) name args)) n "function " > str n n octave-block-comment-start "usage: " str n octave-block-comment-start n octave-block-comment-start n _ n "endfunction" > n)] 4 (#$ . 30014) "*P\nP"])
#@46 Kill inferior Octave process and its buffer.
(defalias 'octave-kill-process #[nil "\203
\302\303\"\210\304!\210	\205\305	!\207" [inferior-octave-process inferior-octave-buffer process-send-string "quit;\n" accept-process-output kill-buffer] 3 (#$ . 31280) nil])
#@55 Make sure that `inferior-octave-buffer' is displayed.
(defalias 'octave-show-process-buffer #[nil "\301!\203\n\302!\207\303\304\"\207" [inferior-octave-buffer get-buffer display-buffer message "No buffer named %s"] 3 (#$ . 31554) nil])
#@59 Delete all windows that display `inferior-octave-buffer'.
(defalias 'octave-hide-process-buffer #[nil "\301!\203\n\302!\207\303\304\"\207" [inferior-octave-buffer get-buffer delete-windows-on message "No buffer named %s"] 3 (#$ . 31800) nil])
#@53 Send current region to the inferior Octave process.
(defalias 'octave-send-region #[(beg end) "\306\307!\210\310	\n\"\311rq\210\311\f\312\230\204k\313\314\f\"\2031\f\315\211\224O\f\315\225\311O\2025\f\312\307\316\314PC!\210\203K\317
!\210\202?\320\321\322\323\203YC\202[\312C\324\325\"C#\314#!\210\202,\205u\326!\207" [inferior-octave-process beg end line string proc inferior-octave t buffer-substring-no-properties nil "" string-match "\n" 0 inferior-octave-send-list-and-digest accept-process-output insert-before-markers mapconcat identity append mapcar inferior-octave-strip-ctrl-g display-buffer inferior-octave-buffer inferior-octave-output-list inferior-octave-receive-in-progress octave-send-echo-input inferior-octave-output-string octave-send-show-buffer] 8 (#$ . 32053) "r"])
#@59 Send current Octave block to the inferior Octave process.
(defalias 'octave-send-block #[nil "\212\300 \210\301`\302 \")\207" [octave-mark-block octave-send-region mark] 3 (#$ . 32885) nil])
#@62 Send current Octave function to the inferior Octave process.
(defalias 'octave-send-defun #[nil "\212\300 \210\301`\302 \")\207" [mark-defun octave-send-region mark] 3 (#$ . 33082) nil])
#@191 Send current Octave code line to the inferior Octave process.
With positive prefix ARG, send that many lines.
If `octave-send-line-auto-forward' is non-nil, go to the next unsent
code line.
(defalias 'octave-send-line #[(&optional arg) "\204\304\305V\205,\306\211\307 \210`\310S!\210\306\210`\203'\310\304!\210\311\n	\"*\207" [arg end beg octave-send-line-auto-forward 1 0 nil beginning-of-line octave-next-code-line octave-send-region] 3 (#$ . 33276) "P"])
#@72 Evaluate Octave sexp before point and print value into current buffer.
(defalias 'octave-eval-print-last-sexp #[nil "\304\305!\210p\306`\307 \210\310\212\311\312!\210\313\314`\"\315PC!\210\316\317\315#)!\210\307 +\207" [opoint print-escape-newlines standard-output inferior-octave-output-list inferior-octave t nil terpri prin1 forward-sexp -1 inferior-octave-send-list-and-digest buffer-substring-no-properties "\n" mapconcat identity] 5 (#$ . 33754) nil])
#@59 Submit a bug report on the Emacs Octave package via mail.
(defalias 'octave-submit-bug-report #[nil "\302\303!\210\304\305!\205\306\307	P\310\311\312\313\314\315\316\317\257#\207" [octave-maintainer-address emacs-version require reporter y-or-n-p "Do you want to submit a bug report? " reporter-submit-bug-report "Emacs version " octave-blink-matching-block octave-block-offset octave-comment-char octave-continuation-offset octave-continuation-string octave-send-echo-input octave-send-line-auto-forward octave-send-show-buffer] 11 (#$ . 34223) nil])
(provide 'octave-mod)