matlab.elc

;ELC
;;; Compiled by Administrator@ALTU on Mon May 19 20:17:08 2008
;;; from file c:/emacs/matlab.el
;;; in Emacs version 23.0.0.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`matlab.el' was compiled for Emacs 19.29 or later"))

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


(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require easymenu tempo derived] 2)
#@33 Current version of MATLAB mode.
(defconst matlab-mode-version "2.3" (#$ . 649))
(byte-code "\301\302\303\217\210\304\305!\203\306\307!\204!\310\311M\210\312\313M\210\314\315M\210\316\317M\210\320\321\"\203N\322\323\324\"\210\322\325\326\"\210\322\327\330\"\210\322\331\332\"\210\322\333\334\"\210\322\335\336\"\210\322\337\340\"\210\202q\322\323\341\"\210\322\325\342\"\210\322\327\343\"\210\322\331\344\"\210\322\333\345\"\210\322\335\346\"\210\322\337\347\"\210\306\350!\203\204\322\351\350\"\210\322\352\353\"\210\202\237\306\354!\203\227\322\351\354\"\210\322\352\355\"\210\202\237\351\356M\210\352\357M\210\301\207" [emacs-version nil (byte-code "\300\301!\207" [require custom] 2) ((error)) featurep custom fboundp custom-declare-variable defgroup (macro . #[(&rest args) "\300\207" [nil] 1]) custom-add-option (macro . #[(&rest args) "\300\207" [nil] 1]) defface (macro . #[(&rest args) "\300\207" [nil] 1]) defcustom (macro . #[(var value doc &rest args) "\303	\nF\207" [var value doc defvar] 4]) string-match "X[Ee]macs" defalias matlab-make-overlay make-extent matlab-overlay-put set-extent-property matlab-delete-overlay delete-extent matlab-overlay-start extent-start matlab-overlay-end extent-end matlab-cancel-timer delete-itimer matlab-run-with-idle-timer #[(secs repeat function &rest args) "\300\301\302\217\207" [nil (byte-code "\304\305\306	\n\205\n	\307\211&\207" [function secs repeat args apply start-itimer "matlab" t] 9) ((error (byte-code "\303\304	\n\205		$\207" [function secs repeat start-itimer "matlab"] 5)))] 3] make-overlay overlay-put delete-overlay overlay-start overlay-end cancel-timer run-with-idle-timer point-at-bol matlab-point-at-bol matlab-point-at-eol point-at-eol line-beginning-position line-end-position (macro . #[nil "\212\300 \210`)\207" [beginning-of-line] 1]) (macro . #[nil "\212\300\210`)\207" [nil] 1])] 3)
#@67 Execute BODY only if the active buffer is a MATLAB
M-file buffer.
(defalias 'matlab-run-in-matlab-mode-only '(macro . #[(&rest body) "\301\302\303B\304BBB\207" [body if (eq major-mode 'matlab-mode) progn ((error "This command works only in a MATLAB M-file buffer."))] 4 (#$ . 2534)]))
#@42 Return non-nil if Emacs Link is running.
(defalias 'matlab-with-emacs-link #[nil "\301\302!\205\207" [matlab-eei-process featurep matlab-eei] 2 (#$ . 2826)])
(custom-declare-group 'matlab nil "MATLAB mode." :prefix "matlab-" :group 'languages)
#@49 *The basic indentation amount in `matlab-mode'.
(custom-declare-variable 'matlab-indent-level '2 '(#$ . -3079) :group 'matlab :type 'integer)
#@70 *Basic indentation after continuation if no other methods are found.
(custom-declare-variable 'matlab-cont-level '4 '(#$ . -3227) :group 'matlab :type 'integer)
#@206 *Specify if ellipses are required at the end of a line for continuation.
Future versions of Matlab may not require ellipses ... , so a heuristic determining if
there is to be continuation is used instead.
(custom-declare-variable 'matlab-cont-requires-ellipsis 't '(#$ . -3395) :group 'matlab :type 'integer)
#@465 *How far to indent case/otherwise statements in a switch.
This can be an integer, which is the distance to indent the CASE and
OTHERWISE commands, and how far to indent commands appearing in CASE
and OTHERWISE blocks.  It can also be a cons cell which is of form
  (CASEINDENT . COMMANDINDENT)
where CASEINDENT is the indentation of the CASE and OTHERWISE
statements, and COMMANDINDENT is the indentation of commands appearing
after the CASE or OTHERWISE command.
(custom-declare-variable 'matlab-case-level ''(1 . 1) '(#$ . -3711) :group 'matlab :type 'sexp)
#@39 *If non-nil, indent body of function.
(custom-declare-variable 'matlab-indent-function 'nil '(#$ . -4277) :group 'matlab :type 'boolean)
#@226 *Regex describing functions whose first arg is special.
This specialness means that all following parameters which appear on
continued lines should appear indented to line up with the second
argument, not the first argument.
(custom-declare-variable 'matlab-indent-past-arg1-functions '"[sg]et\\(_param\\)?\\|waitfor" '(#$ . -4421) :group 'matlab :type 'string)
#@192 *The maximum length to indent when indenting past arg1.
If arg1 is exceptionally long, then only this number of characters
will be indented beyond the open paren starting the parameter list.
(custom-declare-variable 'matlab-arg1-max-indent-length '15 '(#$ . -4790))
#@357 Alist of maximum indentations when lining up code.
Each element is of the form (CHAR . INDENT) where char is a character
the indent engine is using, and INDENT is the maximum indentation
allowed.  Indent could be of the form (MAXIMUM . INDENT), where
MAXIMUM is the maximum allowed calculated indent, and INDENT is the
amount to use if MAXIMUM is reached.
(custom-declare-variable 'matlab-maximum-indents ''((61 10 . 4) (40 . 50) (91 . 20) (123 . 20)) '(#$ . 5063) :group 'matlab :type '(repeat (cons (character :tag "Open List Character") (sexp :tag "Number (max) or cons (max indent)"))))
#@215 *If true, add in a few simulink customizations.
This variable's state is mostly useful when set at load time when
simulink font lock keywords can be removed.  This will handle
additional cases as the need arrises.
(custom-declare-variable 'matlab-handle-simulink 't '(#$ . -5661) :group 'matlab :type 'boolean)
#@73 *If true, set variable `auto-fill-function' to our function at startup.
(custom-declare-variable 'matlab-auto-fill 't '(#$ . -5978) :group 'matlab :type 'boolean)
#@453 Number of characters around `fill-column' we can fudge filling.
Basically, there are places that are very convenient to fill at, but
might not be the closest fill spot, or occur after `fill-column'.
If they occur within this fudge factor, we will use them.
Also, if none of the above occur, and we find a symbol to break at,
but an open paren (group) starts or ends within this fudge factor,
move there to boost the amount of fill leverage we can get.
(custom-declare-variable 'matlab-fill-fudge '10 '(#$ . 6148) :group 'matlab :type 'integer)
#@170 The longest line allowed when auto-filling code.
This overcomes situations where the `fill-column' plus the
`matlab-fill-fudge' is greater than some hard desired limit.
(custom-declare-variable 'matlab-fill-fudge-hard-maximum '79 '(#$ . 6699) :group 'matlab :type 'integer)
#@108 Text used to perform continuation on code lines.
This is used to generate and identify continuation lines.
(custom-declare-variable 'matlab-elipsis-string '"..." '(#$ . 6980))
#@77 *If true, `auto-fill-mode' causes code lines to be automatically continued.
(custom-declare-variable 'matlab-fill-code 't '(#$ . -7162) :group 'matlab :type 'boolean)
#@143 *Non-nil means to count the ellipsis when auto filling.
This effectively shortens the `fill-column' by the length of
`matlab-elipsis-string'.
(custom-declare-variable 'matlab-fill-count-ellipsis-flag 't '(#$ . -7336))
#@199 *Non-nil means that when auto-fill is on, strings are broken across lines.
If `matlab-fill-count-ellipsis-flag' is non nil, this shortens the
`fill-column' by the length of `matlab-elipsis-string'.
(custom-declare-variable 'matlab-fill-strings-flag 't '(#$ . -7561))
#@52 *The goal comment column in `matlab-mode' buffers.
(custom-declare-variable 'matlab-comment-column '40 '(#$ . -7834) :group 'matlab :type 'integer)
#@70 *Amount of anti-indentation to use for comments in relation to code.
(custom-declare-variable 'matlab-comment-anti-indent '0 '(#$ . -7988) :group 'matlab :type 'integer)
#@45 *String to start comment on line by itself.
(custom-declare-variable 'matlab-comment-line-s '"% " '(#$ . -8164) :group 'matlab :type 'string)
#@45 *String to start comment on line with code.
(custom-declare-variable 'matlab-comment-on-line-s '"% " '(#$ . -8312) :group 'matlab :type 'string)
#@79 *String inserted by \[matlab-comment-region] at start of each line in region.
(custom-declare-variable 'matlab-comment-region-s '"% $$$ " '(#$ . -8463) :group 'matlab :type 'string)
#@53 *Non-nil means to verify M whenever we save a file.
(custom-declare-variable 'matlab-verify-on-save-flag 't '(#$ . -8651) :group 'matlab :type 'boolean)
#@184 List of function symbols which perform a verification and fix to M code.
Each function gets no arguments, and returns nothing.  They can move
point, but it will be restored for them.
(custom-declare-variable 'matlab-mode-verify-fix-functions ''(matlab-mode-vf-functionname) '(#$ . 8811) :group 'matlab :type '(repeat (choice :tag "Function: " '(matlab-mode-vf-functionname matlab-mode-vf-block-matches-forward matlab-mode-vf-block-matches-backward matlab-mode-vf-quietafy-buffer))))
#@66 *Largest buffer size allowed for block verification during save.
(custom-declare-variable 'matlab-block-verify-max-buffer-size '50000 '(#$ . -9300) :group 'matlab :type 'integer)
#@50 *If non-nil, show the version number on startup.
(custom-declare-variable 'matlab-vers-on-startup 't '(#$ . -9485) :group 'matlab :type 'boolean)
#@140 *Non-nil means to highlight the matching if/end/whatever.
The highlighting only occurs when the cursor is on a block start or end
keyword.
(custom-declare-variable 'matlab-highlight-block-match-flag 't '(#$ . -9638) :group 'matlab :type 'boolean)
#@127 *Non-nil means to show code details in the minibuffer.
This will only work if `matlab-highlight-block-match-flag' is non-nil.
(custom-declare-variable 'matlab-show-periodic-code-details-flag 'nil '(#$ . -9892) :group 'matlab :type 'boolean)
#@53 *List of functions to call on entry to MATLAB mode.
(custom-declare-variable 'matlab-mode-hook 'nil '(#$ . -10139) :group 'matlab :type 'hook)
#@385 *How the `matlab-complete-symbol' interfaces with the user.
Valid values are:

'increment - which means that new strings are tried with each
             successive call until all methods are exhausted.
             (Similar to `hippie-expand'.)
'complete  - Which means that if there is no single completion, then
             all possibilities are displayed in a completion buffer.
(custom-declare-variable 'matlab-completion-technique ''complete '(#$ . -10289) :group 'matlab :type '(radio (const :tag "Incremental completion (hippie-expand)." increment) (const :tag "Show completion buffer." complete)))
(byte-code "\301\302!\203/\303\304!\203/\305\306!\203\306\202\307\310\311\312\313\314!\315\316!FDC\317\320\321%\210)\202B\305\306!\203=\322\306\311\"\210\202B\322\307\311\"\210\301\207" [l-region-face featurep custom fboundp custom-declare-variable facep region zmacs-region custom-declare-face matlab-region-face t :background face-background :foreground face-foreground "*Face used to highlight a matlab region." :group matlab copy-face] 8)
#@46 Self reference for unterminated string face.
(defvar matlab-unterminated-string-face 'matlab-unterminated-string-face (#$ . 11358))
#@39 Self reference for simulink keywords.
(defvar matlab-simulink-keyword-face 'matlab-simulink-keyword-face (#$ . 11496))
#@74 Make adjustments for font lock.
If font lock is not loaded, lay in wait.
(defalias 'matlab-font-lock-adjustments #[nil "\302\303!\2039\304\305!\2039\306\307\310\311\312!\313\314!\315\310\257DC\316\317\320%\210\306\321\310\311\312	!\313\314	!\315\310\257DC\322#\210\202g\323\300!\203G\324\300\307\"\210\202K\325\307!\210\326\307\310\"\210\323\301!\203^\324\301\321\"\210\202b\325\321!\210\326\321\310\"\210\327\330\331\"\207" [font-lock-string-face font-lock-type-face featurep custom fboundp custom-declare-variable custom-declare-face matlab-unterminated-string-face t :background face-background :foreground face-foreground :underline "*Face used to highlight unterminated strings." :group matlab matlab-simulink-keyword-face "*Face used to highlight simulink specific functions." facep copy-face make-face set-face-underline-p remove-hook font-lock-mode-hook matlab-font-lock-adjustments] 9 (#$ . 11621)])
(byte-code "\300\301!\203\f\302 \210\202\303\304\302\"\210\300\207" [featurep font-lock matlab-font-lock-adjustments add-hook font-lock-mode-hook] 3)
#@40 List of templates used in MATLAB mode.
(defvar matlab-tempo-tags nil (#$ . 12700))
#@49 The syntax table used in `matlab-mode' buffers.
(defvar matlab-mode-syntax-table (byte-code "\301\302 !\303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\303\316\313#\210\303\317\313#\210\303\320\313#\210\303\321\313#\210\303\322\313#\210\303\323\313#\210\303\324\313#\210\303\325\313#\210\303\326\313#\210\303\327\313#\210)\207" [st make-syntax-table standard-syntax-table modify-syntax-entry 95 "_" 37 "<" 10 ">" 92 "." 9 " " 43 45 42 39 47 61 60 62 38 124] 4) (#$ . 12789))
#@47 The syntax table used when navigating blocks.
(defvar matlab-mode-special-syntax-table (byte-code "\302!\303\304\305	#\210	)\207" [matlab-mode-syntax-table st copy-syntax-table modify-syntax-entry 95 "w"] 4) (#$ . 13324))
#@49 The abbrev table used in `matlab-mode' buffers.
(defvar matlab-mode-abbrev-table nil (#$ . 13554))
(define-abbrev-table 'matlab-mode-abbrev-table nil)
#@61 The help key map for `matlab-mode' and `matlab-shell-mode'.
(defvar matlab-help-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210)\207" [km make-sparse-keymap define-key "r" matlab-shell-run-command "f" matlab-shell-describe-command "a" matlab-shell-apropos "v" matlab-shell-describe-variable "t" matlab-shell-topic-browser] 4) (#$ . 13711))
#@58 Keymap used for inserting simple texts based on context.
(defvar matlab-insert-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\332#\210)\207" [km make-sparse-keymap define-key "c" matlab-insert-next-case "e" matlab-insert-end-block "i" tempo-template-matlab-if "I" tempo-template-matlab-if-else "f" tempo-template-matlab-for "s" tempo-template-matlab-switch "t" tempo-template-matlab-try "w" tempo-template-matlab-while "F" tempo-template-matlab-function "'" matlab-stringify-region "" matlab-ispell-strings "" matlab-ispell-comments] 4) (#$ . 14123))
#@35 The keymap used in `matlab-mode'.
(defvar matlab-mode-map (byte-code "\304 \305\306\307#\210\305\310\311#\210\305\312\313#\210\305\314\315#\210\305\316	#\210\305\317\320#\210\305\321\322#\210\305\323\324#\210\305\325\326#\210\305\327\330#\210\305\331\332#\210\305\333\334#\210\305\335\n#\210\305\336\337#\210\305\340\341#\210\305\342\343#\210\305\344\345#\210\305\346\347#\210\305\350\351#\210\305\352\353#\210\305\354\355#\210\305\356\357#\210\305\360\361#\210\305\362\363#\210\305\364\365#\210\305\366\367#\210\370\371\"\203\257\305\372\373#\210\202\265\305\374\373#\210\375\376\311#\210)\207" [km matlab-insert-map matlab-help-map emacs-version make-sparse-keymap define-key [return] matlab-return ";" matlab-comment-region ":" matlab-uncomment-region [(control c) return] matlab-comment-return [(control c) (control c)] [(control c) (control f)] matlab-fill-comment-line [(control c) (control j)] matlab-justify-line [(control c) (control q)] matlab-fill-region [(control c) (control s)] matlab-shell-save-and-go [(control c) (control r)] matlab-shell-run-region [(control c) (control t)] matlab-show-line-info [(control c) 46] matlab-find-file-on-path [(control h) (control m)] [(control j)] matlab-linefeed "\215" newline [(meta \;)] matlab-comment [(meta q)] matlab-fill-paragraph [(meta a)] matlab-beginning-of-command [(meta e)] matlab-end-of-command [(meta j)] matlab-comment-line-break-function [(meta s)] matlab-show-matlab-shell-buffer "\211" matlab-complete-symbol [(meta control f)] matlab-forward-sexp [(meta control b)] matlab-backward-sexp [(meta control a)] matlab-beginning-of-defun [(meta control e)] matlab-end-of-defun string-match "XEmacs" [(control meta button1)] matlab-find-file-click [(control meta mouse-2)] substitute-key-definition comment-region] 4) (#$ . 14866))
#@190 Regexp used to represent the character before the string char '.
The ' character has restrictions on what starts a string which is needed
when attempting to understand the current context.
(defvar matlab-string-start-regexp "\\(^\\|[^]})a-zA-Z0-9_.']\\)" (#$ . 16705))
#@191 Regexp used to represent the character pattern for ending a string.
The ' character can be used as a transpose, and can transpose transposes.
Therefore, to end, we must check all that goop.
(defvar matlab-string-end-regexp "[^'\n]*\\(''[^'\n]*\\)*'" (#$ . 16981))
#@115 When font locking strings, call this function for normal strings.
Argument LIMIT is the maximum distance to scan.
(defalias 'matlab-font-lock-string-match-normal #[(limit) "\303\304	\305\306\260\n\"\207" [matlab-string-start-regexp matlab-string-end-regexp limit matlab-font-lock-string-match-here "\\('" "\\)" "\\([^']\\|$\\)"] 6 (#$ . 17252)])
#@115 When font locking strings, call this function for normal strings.
Argument LIMIT is the maximum distance to scan.
(defalias 'matlab-font-lock-string-match-unterminated #[(limit) "\302\303P	\"\207" [matlab-string-start-regexp limit matlab-font-lock-string-match-here "\\('[^'\n]*\\(''[^'\n]*\\)*\\)$"] 3 (#$ . 17607)])
#@192 When font-locking strings, call this function to determine a match.
Argument REGEX is the expression to scan for.  Match 2 must be the string.
Argument LIMIT is the maximum distance to scan.
(defalias 'matlab-font-lock-string-match-here #[(regex limit) "\303\304	\n\305#\203-\306\225\306\224b\210\307 \206\"n?\205\"\212\310u\210\311 )b\210\203-\303\202\2055b\210\305)\207" [e regex limit nil re-search-forward t 2 matlab-cursor-in-comment -1 matlab-cursor-in-string] 4 (#$ . 17933)])
#@118 When font-locking comments, call this function to determine a match.
Argument LIMIT is the maximum distance to scan.
(defalias 'matlab-font-lock-comment-match #[(limit) "\302\303\304	\305#\203\306\225\307\310\224\311\"\312\235\203\302\202\205$b\210\305)\207" [e limit nil re-search-forward "\\(%[^%\n]*\\)" t 1 get-text-property 0 face (font-lock-string-face matlab-unterminated-string-face)] 4 (#$ . 18437)])
#@183 Find code that is if'd out with if(0), and mark it as a comment.
The if(0) and else/end construct sould be highlighted differently.
Argument LIMIT is the maximum distance to search.
(defalias 'matlab-find-unreachable-code #[(limit) "`W\205&\306\307\310#\205&\311\224\311\225\312\211\211\211\211
b\210\312\313\314\217.\207" [limit e3 b3 e2 b2 e1 re-search-forward "\\<\\(if\\>\\s-*(?\\s-*0\\s-*)?$\\)" t 1 nil (byte-code "\306\307!\210\310v\210\311\312 !\203\313\224\313\225\306 \210\310v\210\311\314 !\2032\313\224\313\225\2046\n\2026\315\316!\210\317\f\f
\n	\f	\257\n!\210\307\207" [b3 e3 b2 e2 b1 e1 matlab-forward-sexp t -1 looking-at matlab-block-mid-re 0 matlab-block-end-re error "Eh?" set-match-data] 11) ((error)) b1] 7 (#$ . 18866)])
#@122 List of keywords for MATLAB used in highlighting.
Customizing this variable is only useful if `regexp-opt' is available.
(custom-declare-variable 'matlab-keyword-list ''("global" "persistent" "for" "while" "if" "elseif" "else" "endfunction" "return" "break" "continue" "switch" "case" "otherwise" "try" "catch" "tic" "toc") '(#$ . 19643) :group 'matlab :type '(repeat (string :tag "Keyword: ")))
#@128 List of handle graphics functions used in highlighting.
Customizing this variable is only useful if `regexp-opt' is available.
(custom-declare-variable 'matlab-handle-graphics-list ''("figure" "axes" "axis" "line" "surface" "patch" "text" "light" "image" "set" "get" "uicontrol" "uimenu" "uitoolbar" "uitoggletool" "uipushtool" "uicontext" "uicontextmenu" "setfont" "setcolor") '(#$ . 20046) :group 'matlab :type '(repeat (string :tag "HG Keyword: ")))
#@117 List of debug commands used in highlighting.
Customizing this variable is only useful if `regexp-opt' is available.
(custom-declare-variable 'matlab-debug-list ''("dbstop" "dbclear" "dbcont" "dbdown" "dbmex" "dbstack" "dbstatus" "dbstep" "dbtype" "dbup" "dbquit") '(#$ . 20506) :group 'matlab :type '(repeat (string :tag "Debug Keyword: ")))
#@42 Expressions to highlight in MATLAB mode.
(defvar matlab-font-lock-keywords (byte-code "\302\303\304\305\306\307!\203\310\307!\311Q\202\312\313D\314\315\316\306\307!\203(\310\307	!\311Q\202)\317\320D\257	\207" [matlab-keyword-list matlab-handle-graphics-list (matlab-font-lock-string-match-normal 2 font-lock-string-face) (matlab-font-lock-string-match-unterminated 2 matlab-unterminated-string-face) (matlab-font-lock-comment-match 1 font-lock-comment-face) ("%#\\([a-z]+\\)" (1 'bold prepend)) fboundp regexp-opt "\\<\\(" "\\)\\>" "\\<\\(break\\|ca\\(se\\|tch\\)\\|e\\(lse\\(\\|if\\)\\|ndfunction\\)\\|for\\|global\\|if\\|otherwise\\|return\\|switch\\|try\\|while\\|tic\\|toc\\)\\>" (0 font-lock-keyword-face) ("\\(^\\|[;,]\\)[ 	]*\\(end\\)\\b" 2 (if (matlab-valid-end-construct-p) font-lock-keyword-face nil)) (matlab-find-unreachable-code (1 'underline prepend) (2 'underline prepend) (3 'underline prepend) (4 font-lock-comment-face prepend)) ("^\\s-*global\\s-+" ("\\(\\w+\\)\\(\\s-*=[^,; 	\n]+\\|[, 	;]+\\|$\\)" nil nil (1 font-lock-variable-name-face))) "\\<\\(ax\\(es\\|is\\)\\|figure\\|get\\|image\\|li\\(ght\\|ne\\)\\|patch\\|s\\(et\\(\\|color\\|font\\)\\|urface\\)\\|text\\|ui\\(cont\\(ext\\(\\|menu\\)\\|rol\\)\\|menu\\|\\(toggle\\|push\\)tool\\|toolbar\\)\\)\\>" (0 font-lock-type-face)] 11) (#$ . 20854))
#@42 Expressions to highlight in MATLAB mode.
(defvar matlab-gaudy-font-lock-keywords (byte-code "\302\303\304\305\306F\307\310\311E\312\313D\314\315\316\317\320	\321Q\322D\257\"\207" [matlab-font-lock-keywords matlab-indent-past-arg1-functions append "^\\s-*\\(function\\)\\>[ 	\n.]*\\(\\[[^]]*\\]\\|\\sw+\\)[ 	\n.]*=[ 	\n.]*\\(\\sw+\\)[ 	\n.]*\\(([^)]*)\\)?\\s-*\\([,;\n%]\\|$\\)" (1 font-lock-keyword-face append) (2 font-lock-variable-name-face append) (3 font-lock-function-name-face append) "^\\s-*\\(function\\)[ 	\n.]+\\(\\sw+\\)[ 	\n.]*\\(([^)]*)\\)?\\s-*\\([,;\n%]\\|$\\)" (1 font-lock-keyword-face append) (2 font-lock-function-name-face append) "^\\s-*function\\>[ 	\n.]*\\(\\(\\[[^]]*\\]\\|\\sw+\\)[ 	\n.]*=[ 	\n.]*\\)?\\sw+\\s-*(" ("\\s-*\\(\\sw+\\)\\s-*[,)]" nil nil (1 font-lock-variable-name-face)) ("\\<\\(for\\)\\s-+\\(\\sw+\\)\\s-*=\\s-*\\(\\([^\n,;%(]+\\|([^\n%)]+)\\)+\\)" (1 font-lock-keyword-face) (2 font-lock-variable-name-face append) (3 font-lock-reference-face append)) ("\\<\\(case\\|switch\\)\\s-+\\({[^}\n]+}\\|[^,%\n]+\\)" (1 font-lock-keyword-face) (2 font-lock-reference-face)) ("\\<\\(eps\\|pi\\|inf\\|Inf\\|NaN\\|nan\\|ans\\|i\\|j\\|^>>\\)\\>" 1 font-lock-reference-face) ("\\<[0-9]\\.?\\(i\\|j\\)\\>" 1 font-lock-reference-face) "\\<" "\\s-*" ("(\\s-*\\(\\w+\\)\\s-*\\(,\\|)\\)" nil nil (1 font-lock-variable-name-face))] 12) (#$ . 22186))
#@42 Expressions to highlight in MATLAB mode.
(defvar matlab-really-gaudy-font-lock-keywords (byte-code "\305\306\307	\310\311\312\260\313D\307	\310\314R\315D\307	\310\316\317\320\260\321D\322\323\324!\203-\325\324\n!\326Q\202.\327\330D\257\205;\331\332\fEC#\207" [matlab-gaudy-font-lock-keywords matlab-comment-line-s matlab-debug-list matlab-handle-simulink matlab-simulink-keyword-face append ("\\([<>~]=?\\|\\.[/*^']\\|==\\|\\<xor\\>\\|[-!^&|*+\\/~:]\\)" 1 font-lock-type-face) "^" "\\s-*" "\\(\\([A-Z]+\\s-*=\\s-+\\|\\[[^]]+]\\s-*=\\s-+\\|\\)" "\\([A-Z][0-9A-Z]+\\)\\(([^)\n]+)\\| \\)\\)" (1 font-lock-reference-face prepend) "See also\\s-+" ("\\([A-Z][A-Z0-9]+\\)\\([,.]\\| and\\|$\\) *" nil nil (1 font-lock-reference-face prepend)) "\\(\\$" "Revision" "[^\n$]+\\$\\)" (1 font-lock-reference-face prepend) ("[^.]\\(\\.\\.\\.+\\)\\([^\n]*\\)" (1 'underline) (2 font-lock-comment-face)) fboundp regexp-opt "\\<\\(" "\\)\\>" "\\<\\(db\\(c\\(lear\\|ont\\)\\|down\\|mex\\|quit\\|st\\(a\\(ck\\|tus\\)\\|ep\\|op\\)\\|type\\|up\\)\\)\\>" (0 'bold) "\\<\\(\\([sg]et_param\\|sim\\([gs]et\\)?\\|\\(mld\\|ss\\)[A-Z]\\w+\\)\\|\\(new\\|open\\|close\\|save\\|find\\)_system\\|\\(add\\|delete\\|replace\\)_\\(block\\|line\\)\\|simulink\\|bd\\(root\\|close\\)\\)\\>" 1] 11) (#$ . 23567))
#@78 Additional keywords used by MATLAB when reporting errors in interactivemode.
(defvar matlab-shell-font-lock-keywords (list '("^\\(Error in\\|Syntax error in\\)\\s-+==>\\s-+\\(.+\\)$" (1 font-lock-comment-face) (2 font-lock-string-face)) '("^\\(On line [0-9]+\\)" 1 font-lock-comment-face) '("\\(\\?\\?\\?[^\n]+\\)" 1 font-lock-comment-face) '("\\<\\(demo\\|whatsnew\\|info\\|subscribe\\|help\\|doc\\|lookfor\\|what\\|whos?\\|cd\\|clear\\|load\\|save\\|helpdesk\\|helpwin\\)\\>" 1 font-lock-keyword-face) '(" M A T L A B " 0 'underline) '("All Rights Reserved" 0 'italic) '("\\((c)\\s-+Copyright[^\n]+\\)" 1 font-lock-comment-face) '("\\(Version\\)\\s-+\\([^\n]+\\)" (1 font-lock-function-name-face) (2 font-lock-variable-name-face))) (#$ . 24854))
(byte-code "\301B\302\301!\204\303\301\304\"\210\301\207" [current-load-list matlab-hilit19-patterns default-boundp set-default (("\\(^\\|[^%]\\)\\(%[ 	].*\\|%\\)$" 2 comment) ("\\(^\\|[;,]\\)[ 	]*\\(function\\|global\\|for\\|while\\|if\\|elseif\\|else\\|end\\(function\\)?\\|return\\|switch\\|case\\|otherwise\\|try\\|catch\\)\\b" 2 keyword))] 3)
#@52 Expression to get matlab function/procedure names.
(defvar fume-function-name-regexp-matlab "^\\s-*function\\>[ 	\n.]*\\(\\(\\[[^]]*\\]\\|\\sw+\\)[ 	\n.]*=[ 	\n.]*\\)?\\([a-zA-Z0-9_]+\\)" (#$ . 25960))
(byte-code "\300\301!\203\302\301\303\"\210\300\207" [boundp fume-function-name-regexp-alist add-to-list (matlab-mode . fume-function-name-regexp-matlab)] 3)
#@50 Searches for the next matlab function in BUFFER.
(defalias 'fume-find-next-matlab-function-name #[(buffer) "\301!\207" [buffer fume-find-next-sexp] 2 (#$ . 26328)])
(byte-code "\300\301!\203\302\303\304\"\210\300\207" [boundp fume-function-name-regexp-alist add-to-list fume-find-function-name-method-alist (matlab-mode . fume-find-next-matlab-function-name)] 3)
#@61 Expressions which find function headings in MATLAB M files.
(defvar matlab-imenu-generic-expression (byte-code "\301\302BBC\207" [fume-function-name-regexp-matlab nil (3)] 3) (#$ . 26700))
#@2751 MATLAB-mode is a major mode for editing MATLAB dot-m files.
\<matlab-mode-map>
Convenient editing commands are:
 \[matlab-comment-region]   - Comment/Uncomment out a region of code.
 \[matlab-fill-comment-line] - Fill the current comment line.
 \[matlab-fill-region] - Fill code and comments in region.
 \[matlab-fill-paragraph]     - Refill the current command or comment.
 \[matlab-complete-symbol]   - Symbol completion of matlab symbolsbased on the local syntax.

Convenient navigation commands are:
 \[matlab-beginning-of-command]   - Move to the beginning of a command.
 \[matlab-end-of-command]   - Move to the end of a command.
 \[matlab-beginning-of-defun] - Move to the beginning of a function.
 \[matlab-end-of-defun] - Move do the end of a function.
 \[matlab-forward-sexp] - Move forward over a syntactic block of code.
 \[matlab-backward-sexp] - Move backwards over a syntactic block of code.

Convenient template insertion commands:
 \[tempo-template-matlab-function] - Insert a function definition.
 \[tempo-template-matlab-if] - Insert an IF END block.
 \[tempo-template-matlab-for] - Insert a FOR END block.
 \[tempo-template-matlab-switch] - Insert a SWITCH END statement.
 \[matlab-insert-next-case] - Insert the next CASE condition in a SWITCH.
 \[matlab-insert-end-block] - Insert a matched END statement.  With optional ARG, reindent.
 \[matlab-stringify-region] - Convert plaintext in region to a string with correctly quoted chars.

Variables:
  `matlab-indent-level'		Level to indent blocks.
  `matlab-cont-level'		Level to indent continuation lines.
  `matlab-cont-requires-ellipsis' Does your MATLAB support implied elipsis.
  `matlab-case-level'		Level to unindent case statements.
  `matlab-indent-past-arg1-functions'
                                Regexp of functions to indent past the first
                                  argument on continuation lines.
  `matlab-maximum-indents'      List of maximum indents during lineups.
  `matlab-comment-column'       Goal column for on-line comments.
  `fill-column'			Column used in auto-fill.
  `matlab-indent-function'	If non-nil, indents body of MATLAB functions.
  `matlab-return-function'	Customize RET handling with this function
  `matlab-auto-fill'            Non-nil, do auto-fill at startup
  `matlab-fill-code'            Non-nil, auto-fill code.
  `matlab-fill-strings'         Non-nil, auto-fill strings.
  `matlab-verify-on-save-flag'  Non-nil, enable code checks on save
  `matlab-highlight-block-match-flag'
                                Enable matching block begin/end keywords
  `matlab-vers-on-startup'	If t, show version on start-up.
  `matlab-handle-simulink'      If t, enable simulink keyword highlighting.

All Key Bindings:
\{matlab-mode-map}
(defalias 'matlab-mode #[nil "\306 \210\307!\210\310\311\312\313!\203\314\313\310\"\210\315
!\210\3164\317\320!\210\321\317\322!\210\3235P\317\324!\210\317\325!\210\326\317\327!\210\330\317\331!\210\332\317\333!\2106\317\334!\210\335\317\336!\210\337\317\340!\2107 \317\341!\210\"\203w\342!\317\343!\210\342#\317\344!\210\317\345!\2108%\317\346!\210\347\346\350\"\210\317\351!\210\3529)\")\317\353!\210\317\354!\210\355,\356\357!\210:\203\266\360 \210\361\362!\210;\205\301\363 \207" [matlab-mode-map major-mode mode-name matlab-mode-abbrev-table local-abbrev-table matlab-mode-syntax-table kill-all-local-variables use-local-map matlab-mode "MATLAB" boundp whitespace-modes add-to-list set-syntax-table nil make-local-variable indent-line-function matlab-indent-line paragraph-start "^$\\|" paragraph-separate paragraph-ignore-fill-prefix t comment-start-skip "%\\s-+" comment-start "%" comment-column comment-indent-function matlab-comment-indent add-log-current-defun-function matlab-current-defun fill-column auto-fill-function matlab-auto-fill normal-auto-fill-function fill-prefix imenu-generic-expression write-contents-hooks add-hook matlab-mode-verify-fix-file-fn tempo-local-tags append matlab-shell-save-and-go-history font-lock-defaults ((matlab-font-lock-keywords matlab-gaudy-font-lock-keywords matlab-really-gaudy-font-lock-keywords) t nil ((95 . "w"))) matlab-enable-block-highlighting 1 matlab-frame-init run-hooks matlab-mode-hook matlab-show-version indent-tabs-mode page-delimiter matlab-comment-column default-fill-column matlab-imenu-generic-expression matlab-tempo-tags window-system matlab-vers-on-startup] 3 (#$ . 26898) nil])
#@44 Show the version number in the minibuffer.
(defalias 'matlab-show-version #[nil "\301\302\"\207" [matlab-mode-version message "matlab-mode, version %s"] 3 (#$ . 31352) nil])
#@47 Recurse backwards until a code line is found.
(defalias 'matlab-find-prev-line #[nil "\300y\300U?\205\301 \204\302 \203\303 \207\304\207" [-1 matlab-ltype-empty matlab-ltype-comm-ignore matlab-find-prev-line t] 2 (#$ . 31533)])
#@60 Go to the previous line of code.  Return nil if not found.
(defalias 'matlab-prev-line #[nil "`\301 \203\302\202b\210\303)\207" [old-point matlab-find-prev-line t nil] 1 (#$ . 31773) nil])
#@70 Return a list that is a subset of LST where all elements are unique.
(defalias 'matlab-uniquafy-list #[(lst) "\302	\203	@\203	@\235\204	@B	A\211\204\237)\207" [nlst lst nil] 3 (#$ . 31974)])
#@70 Set the current environment for syntax-navigation and execute FORMS.
(defalias 'matlab-navigation-syntax '(macro . #[(&rest forms) "\301\302\303\304\305\304BE\306EE\207" [forms let ((oldsyntax (syntax-table)) (case-fold-search nil)) unwind-protect progn (set-syntax-table matlab-mode-special-syntax-table) (set-syntax-table oldsyntax)] 7 (#$ . 32185)]))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put matlab-navigation-syntax lisp-indent-function 0 add-hook edebug-setup-hook #[nil "\300\301\302\303#\207" [put matlab-navigation-syntax edebug-form-spec def-body] 4]] 4)
#@108 Move forwards or backwards up a list by COUNT.
Optional argument RESTRICT is where to restrict the search.
(defalias 'matlab-up-list #[(count &optional restrict) "\306V\203\n\307\202\310`\311_\307U\203`\306U\204d\312\313\f\314#\315 \316\216\317 *\203;\312\313\f\314#\211\204&	\204F\nb\210\320\321!\210\322\306!\323\324\"\203YS\202\\T)\202\320\325!\210	+\207" [count ms origin dir restrict save-match-data-internal 0 -1 1 nil re-search-backward "\\s(\\|\\s)" t match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) matlab-cursor-in-string-or-comment error "Scan Error: List missmatch" match-string string-match "\\s(" "Not implemented" s] 4 (#$ . 32774)])
#@115 Return non-nil if the end after point terminates a block.
Return nil if it is being used to dereference an array.
(defalias 'matlab-valid-end-construct-p #[nil "`\302\303\304\305\217*\207" [err1 p t nil (byte-code "\214\212\302 \210`\303\210`V\203\303\304 \210`}\210)\212\305\306!\210\303\307\310\217*\207" [p err1 matlab-beginning-of-command nil error matlab-up-list -1 (byte-code "\300\301!\210\302\207" [forward-sexp 1 nil] 2) ((error))] 3) ((error err1))] 3 (#$ . 33511)])
#@65 Regular expression defining the beginning of a MATLAB function.
(defconst matlab-defun-regex "^\\s-*function[ 	.[]" (#$ . 34001))
#@76 Keywords which mark the beginning of an indented block.
Includes function.
(defconst matlab-block-beg-pre-if "function\\|for\\|while\\|if\\|switch\\|try\\|tic" (#$ . 34137))
#@76 Keywords which mark the beginning of an indented block.
Excludes function.
(defconst matlab-block-beg-pre-no-if "for\\|while\\|if\\|switch\\|try\\|tic" (#$ . 34317))
#@70 Partial regular expression to recognize MATLAB block-begin keywords.
(defalias 'matlab-block-beg-pre #[nil "\203	\207\n\207" [matlab-indent-function matlab-block-beg-pre-if matlab-block-beg-pre-no-if] 1 (#$ . 34489)])
#@68 Partial regular expression to recognize MATLAB mid-block keywords.
(defconst matlab-block-mid-pre "elseif\\|else\\|catch" (#$ . 34716))
#@68 Partial regular expression to recognize MATLAB block-end keywords.
(defconst matlab-block-end-pre-if "end\\(function\\)?\\|function\\|toc" (#$ . 34858))
#@68 Partial regular expression to recognize MATLAB block-end keywords.
(defconst matlab-block-end-pre-no-if "end\\|toc" (#$ . 35017))
#@68 Partial regular expression to recognize MATLAB block-end keywords.
(defalias 'matlab-block-end-pre #[nil "\203	\207\n\207" [matlab-indent-function matlab-block-end-pre-if matlab-block-end-pre-no-if] 1 (#$ . 35153)])
#@218 Keywords which initialize new blocks, but don't have explicit ends.
Thus, they are endless.  A new case or otherwise will end a previous
endless block, and and end will end this block, plus any outside normal
blocks.
(defconst matlab-endless-blocks "case\\|otherwise" (#$ . 35379))
#@60 Regular expression for keywords which begin MATLAB blocks.
(defalias 'matlab-block-re #[nil "\302\303 \304\304\305 \304	\306\260	\207" [matlab-block-mid-pre matlab-endless-blocks "\\(^\\|[;,]\\)\\s-*\\(" matlab-block-beg-pre "\\|" matlab-block-end-pre "\\)\\b"] 9 (#$ . 35667)])
#@60 Expression used to scan over matching pairs of begin/ends.
(defalias 'matlab-block-scan-re #[nil "\300\301 \302\303 \304\260\207" ["\\(^\\|[;,]\\)\\s-*\\(" matlab-block-beg-pre "\\|" matlab-block-end-pre "\\)\\b"] 5 (#$ . 35953)])
#@51 Expression used to find the beginning of a block.
(defalias 'matlab-block-beg-re #[nil "\300\301 \302Q\207" ["\\(" matlab-block-beg-pre "\\)"] 3 (#$ . 36191)])
#@57 Expression used to find block center parts (like else).
(defalias 'matlab-block-mid-re #[nil "\301\302Q\207" [matlab-block-mid-pre "\\(" "\\)"] 3 (#$ . 36357)])
#@54 Expression used to end a block.  Usually just `end'.
(defalias 'matlab-block-end-re #[nil "\300\301 \302Q\207" ["\\(" matlab-block-end-pre "\\)"] 3 (#$ . 36525)])
#@60 Expression representing and end if functions are excluded.
(defalias 'matlab-block-end-no-function-re #[nil "\301\302Q\207" [matlab-block-end-pre-no-if "\\<\\(" "\\)\\>"] 3 (#$ . 36694)])
#@64 Expression of block starters that do not have associated ends.
(defalias 'matlab-endless-blocks-re #[nil "\301\302Q\207" [matlab-endless-blocks "\\(" "\\)"] 3 (#$ . 36889)])
#@161 Expression to match a function start line.
There are no reliable numeric matches in this expression.
Know that `match-end' of 0 is the end of the functin name.
(defalias 'matlab-match-function-re #[nil "\300\207" ["\\(^\\s-*function\\b[ 	\n.]*\\)\\(\\(\\[[^]]*\\]\\|\\sw+\\)[ 	\n.]*=[ 	\n.]*\\)?\\(\\sw+\\)"] 1 (#$ . 37071)])
#@53 *The regular expression for skipping comment start.
(defconst matlab-cline-start-skip "[ 	]*%[ 	]*" (#$ . -37403))
#@47 Keywords that appear on a line by themselves.
(defvar matlab-keywords-solo '("break" "case" "else" "elseif" "end" "for" "function" "if" "tic" "toc" "otherwise" "profile" "switch" "while") (#$ . 37524))
#@89 List of MATLAB keywords that have return arguments.
This list still needs lots of help.
(defvar matlab-keywords-return '("acos" "acosh" "acot" "acoth" "acsch" "asech" "asin" "asinh" "atan" "atan2" "atanh" "cos" "cosh" "coth" "csc" "csch" "exp" "log" "log10" "log2" "sec" "sech" "sin" "sinh" "tanh" "abs" "sign" "sqrt") (#$ . 37732))
#@66 List of keywords that are typically used as boolean expressions.
(defvar matlab-keywords-boolean '("all" "any" "exist" "isempty" "isequal" "ishold" "isfinite" "isglobal" "isinf" "isletter" "islogical" "isnan" "isprime" "isreal" "isspace" "logical") (#$ . 38071))
#@49 List of properties belonging to all HG objects.
(defvar matlab-core-properties '("ButtonDownFcn" "Children" "Clipping" "CreateFcn" "DeleteFcn" "BusyAction" "HandleVisibility" "HitTest" "Interruptible" "Parent" "Selected" "SelectionHighlight" "Tag" "Type" "UIContextMenu" "UserData" "Visible") (#$ . 38340))
#@52 List of property lists on a per object type basis.
(defvar matlab-property-lists '(("root" "CallbackObject" "Language" "CurrentFigure" "Diary" "DiaryFile" "Echo" "ErrorMessage" "Format" "FormatSpacing" "PointerLocation" "PointerWindow" "Profile" "ProfileFile" "ProfileCount" "ProfileInterval" "RecursionLimit" "ScreenDepth" "ScreenSize" "ShowHiddenHandles" "TerminalHideGraphCommand" "TerminalOneWindow" "TerminalDimensions" "TerminalProtocol" "TerminalShowGraphCommand" "Units" "AutomaticFileUpdates") ("axes" "AmbientLightColor" "Box" "CameraPosition" "CameraPositionMode" "CameraTarget" "CameraTargetMode" "CameraUpVector" "CameraUpVectorMode" "CameraViewAngle" "CameraViewAngleMode" "CLim" "CLimMode" "Color" "CurrentPoint" "ColorOrder" "DataAspectRatio" "DataAspectRatioMode" "DrawMode" "FontAngle" "FontName" "FontSize" "FontUnits" "FontWeight" "GridLineStyle" "Layer" "LineStyleOrder" "LineWidth" "NextPlot" "PlotBoxAspectRatio" "PlotBoxAspectRatioMode" "Projection" "Position" "TickLength" "TickDir" "TickDirMode" "Title" "Units" "View" "XColor" "XDir" "XGrid" "XLabel" "XAxisLocation" "XLim" "XLimMode" "XScale" "XTick" "XTickLabel" "XTickLabelMode" "XTickMode" "YColor" "YDir" "YGrid" "YLabel" "YAxisLocation" "YLim" "YLimMode" "YScale" "YTick" "YTickLabel" "YTickLabelMode" "YTickMode" "ZColor" "ZDir" "ZGrid" "ZLabel" "ZLim" "ZLimMode" "ZScale" "ZTick" "ZTickLabel" "ZTickLabelMode" "ZTickMode") ("figure" "BackingStore" "CloseRequestFcn" "Color" "Colormap" "CurrentAxes" "CurrentCharacter" "CurrentObject" "CurrentPoint" "Dithermap" "DithermapMode" "FixedColors" "IntegerHandle" "InvertHardcopy" "KeyPressFcn" "MenuBar" "MinColormap" "Name" "NextPlot" "NumberTitle" "PaperUnits" "PaperOrientation" "PaperPosition" "PaperPositionMode" "PaperSize" "PaperType" "Pointer" "PointerShapeCData" "PointerShapeHotSpot" "Position" "Renderer" "RendererMode" "Resize" "ResizeFcn" "SelectionType" "ShareColors" "Units" "WindowButtonDownFcn" "WindowButtonMotionFcn" "WindowButtonUpFcn" "WindowStyle") ("image" "CData" "CDataMapping" "EraseMode" "XData" "YData") ("light" "Position" "Color" "Style") ("line" "Color" "EraseMode" "LineStyle" "LineWidth" "Marker" "MarkerSize" "MarkerEdgeColor" "MarkerFaceColor" "XData" "YData" "ZData") ("patch" "CData" "CDataMapping" "FaceVertexCData" "EdgeColor" "EraseMode" "FaceColor" "Faces" "LineStyle" "LineWidth" "Marker" "MarkerEdgeColor" "MarkerFaceColor" "MarkerSize" "Vertices" "XData" "YData" "ZData" "FaceLighting" "EdgeLighting" "BackFaceLighting" "AmbientStrength" "DiffuseStrength" "SpecularStrength" "SpecularExponent" "SpecularColorReflectance" "VertexNormals" "NormalMode") ("surface" "CData" "CDataMapping" "EdgeColor" "EraseMode" "FaceColor" "LineStyle" "LineWidth" "Marker" "MarkerEdgeColor" "MarkerFaceColor" "MarkerSize" "MeshStyle" "XData" "YData" "ZData" "FaceLighting" "EdgeLighting" "BackFaceLighting" "AmbientStrength" "DiffuseStrength" "SpecularStrength" "SpecularExponent" "SpecularColorReflectance" "VertexNormals" "NormalMode") ("text\\|title\\|xlabel\\|ylabel\\|zlabel" "Color" "EraseMode" "Editing" "Extent" "FontAngle" "FontName" "FontSize" "FontUnits" "FontWeight" "HorizontalAlignment" "Position" "Rotation" "String" "Units" "Interpreter" "VerticalAlignment") ("uicontextmenu" "Callback") ("uicontrol" "BackgroundColor" "Callback" "CData" "Enable" "Extent" "FontAngle" "FontName" "FontSize" "FontUnits" "FontWeight" "ForegroundColor" "HorizontalAlignment" "ListboxTop" "Max" "Min" "Position" "String" "Style" "SliderStep" "TooltipString" "Units" "Value") ("uimenu" "Accelerator" "Callback" "Checked" "Enable" "ForegroundColor" "Label" "Position" "Separator") ("uipushtool\\|uitoggletool\\|uitoolbar" "Cdata" "Callback" "Separator" "Visible")) (#$ . 38653))
#@50 Expression for commands that have unknown types.
(defvar matlab-unknown-type-commands "[gs]et\\|findobj\\|waitfor" (#$ . 42385))
#@34 Return a list of all properties.
(defalias 'matlab-all-known-properties #[nil "	\n\203\304\n@A\"\nA\211\204\305!*\207" [matlab-core-properties matlab-property-lists tl lst append matlab-uniquafy-list] 4 (#$ . 42520)])
#@35 List of all the known properties.
(defvar matlab-all-known-properties (matlab-all-known-properties) (#$ . 42755))
#@59 Regexp of all builtin functions that take property lists.
(defalias 'matlab-property-function '(macro . #[nil "\300\207" [(let ((r matlab-unknown-type-commands) (tl matlab-property-lists)) (while tl (setq r (concat r "\\|" (car (car tl))) tl (cdr tl))) r)] 1 (#$ . 42875)]))
#@171 When this is set to non-nil, then forward/backward sexp stops off screen.
This is so the block highlighter doesn't gobble up lots of time when
a block is not terminated.
(defvar matlab-scan-on-screen-only nil (#$ . 43157))
#@176 Go backwards one balanced set of MATLAB expressions.
If optional AUTOEND, then pretend we are at an end.
If optional NOERROR, then we return t on success, and nil on failure.
(defalias 'matlab-backward-sexp #[(&optional autoend noerror) "\306 \307\310\216\311\n!\210\204,\212\312v\210\313\314 !\205\315 ?\206\"\316 )\203,\317\312!\202\222\2043\312v\210\307`\320\204\220\203I\321 \203\220\322\323 \307\320#\203|\324\224b\210\313\314 !\203p\316 \204:\315 \203:\325v\210\326 \210\202:\316 \204:\320\211\202<
b\210\203\211\307\202:\327\330!\210\202:\f++\207" [case-fold-search oldsyntax matlab-mode-special-syntax-table autoend returnme start syntax-table nil ((set-syntax-table oldsyntax)) set-syntax-table -1 looking-at matlab-block-end-no-function-re matlab-valid-end-construct-p matlab-cursor-in-string-or-comment forward-sexp t pos-visible-in-window-p re-search-backward matlab-block-scan-re 2 1 matlab-backward-sexp error "Unstarted END construct" done matlab-scan-on-screen-only noerror] 5 (#$ . 43387) "P"])
#@131 Go forward one balanced set of MATLAB expressions.
Optional argument INCLUDEELSE will stop on ELSE if it matches the starting IF.
(defalias 'matlab-forward-sexp #[(&optional includeelse) "\306 \307\310\216\311\n!\210\312\307w\210\313\314\315 \316\317 \320\260!\203\"\321 \203(\322\323!\202\223\323v\210\307\211\2036\324 \2028\325 \315 \204\211\326
\307\327#\211\203\211 \203Z\330 \203\211\331\224b\210\313\f!\203u\321 \203o\323v\210\202@\332 \210\202@\323v\210\321 \204@\333 \203@\327\211\203E?\205\222\334\335!,+\207" [case-fold-search oldsyntax matlab-mode-special-syntax-table includeelse expr-look expr-scan syntax-table nil ((set-syntax-table oldsyntax)) set-syntax-table " 	\n;" looking-at "\\(" matlab-block-beg-pre "\\|" matlab-block-mid-re "\\)\\>" matlab-cursor-in-string-or-comment forward-sexp 1 matlab-block-re matlab-block-scan-re re-search-forward t pos-visible-in-window-p 2 matlab-forward-sexp matlab-valid-end-construct-p error "Unterminated block" s done matlab-scan-on-screen-only] 7 (#$ . 44443) "P"])
#@46 Go to the beginning of the current function.
(defalias 'matlab-beginning-of-defun #[nil "\301\302\303#\206\neb\207" [matlab-defun-regex re-search-backward nil t] 4 (#$ . 45508) nil])
#@40 Go to the end of the current function.
(defalias 'matlab-end-of-defun #[nil "\301!\203\n\302\225b\210\303\304\305#\203\306y\210\305\207db\207" [matlab-defun-regex looking-at 0 re-search-forward nil t -1] 4 (#$ . 45699) nil])
#@42 Return the name of the current function.
(defalias 'matlab-current-defun #[nil "\212\300 \210\301\302 !\205\303\225b\210\304 )\207" [matlab-beginning-of-defun looking-at matlab-match-function-re 0 current-word] 2 (#$ . 45935)])
#@68 Go to the beginning of an M command.
Travels across continuations.
(defalias 'matlab-beginning-of-command #[nil "\302 \210\303\212\304\305\303\306#)\212\307 \205\310 )\204&\311 \204&\312!\211\203A\212\302 \210o)\204A	\2039	b\210\202<\307 \210\303\202
\313 *\207" [r p beginning-of-line nil re-search-backward "^\\s-*\\(%\\|if\\|else\\(if\\)\\|while\\|for\\|$\\)\\>" t matlab-prev-line matlab-lattr-cont matlab-ltype-continued-comm matlab-lattr-array-cont back-to-indentation] 5 (#$ . 46171) nil])
#@85 Go to the end of an M command.
Optional BEGINNING is where the command starts from.
(defalias 'matlab-end-of-command #[(&optional beginning) "\301 \204\212\302y\210m?\205\303 \206\304!)\203,\212\305 \210\306\307 !)\204,\302y\210\202\310\207" [beginning matlab-lattr-cont 1 matlab-ltype-continued-comm matlab-lattr-array-cont beginning-of-line looking-at matlab-block-scan-re nil] 2 (#$ . 46688) nil])
#@36 Return t if current line is empty.
(defalias 'matlab-ltype-empty #[nil "\212\300 \210\301\302!)\207" [beginning-of-line looking-at "^[ 	]*$"] 2 (#$ . 47107)])
#@52 Return t if current line is a MATLAB comment line.
(defalias 'matlab-ltype-comm #[nil "\212\300 \210\301\302!)\207" [beginning-of-line looking-at "[ 	]*%.*$"] 2 (#$ . 47272)])
#@59 Return t if current line is a MATLAB comment region line.
(defalias 'matlab-ltype-comm-ignore #[nil "\212\301 \210\302\303P!)\207" [matlab-comment-region-s beginning-of-line looking-at "[ 	]*"] 3 (#$ . 47454)])
#@66 Return t if the current line is part of the MATLAB help comment.
(defalias 'matlab-ltype-help-comm #[nil "\212\300 \205\300 \203o\204\301 \203\302 \210\202\303 )\207" [matlab-ltype-comm matlab-prev-line beginning-of-line matlab-ltype-function-definition] 1 (#$ . 47672)])
#@63 Return t if the current line is an ENDFUNCTION style comment.
(defalias 'matlab-ltype-endfunction-comm #[nil "\212\300 \205)\301 \210\302\303!\203\304\202)\300 \204\305 \203'm\204'\306y\210\202\307 )\207" [matlab-ltype-comm beginning-of-line looking-at "^[ 	]*%[ 	]*endfunction" t matlab-ltype-empty 1 matlab-ltype-function-definition] 2 (#$ . 47960)])
#@57 Return column of previous line's comment start, or nil.
(defalias 'matlab-ltype-continued-comm #[nil "\212\301 \210\302 ?\206o?\205\303y\210\304 \211\205b\210i))\207" [col beginning-of-line matlab-ltype-comm -1 matlab-lattr-comm] 2 (#$ . 48329)])
#@56 Return t if the current line is a function definition.
(defalias 'matlab-ltype-function-definition #[nil "\212\301 \210\302!)\207" [matlab-defun-regex beginning-of-line looking-at] 2 (#$ . 48590)])
#@49 Return t if current line is a MATLAB code line.
(defalias 'matlab-ltype-code #[nil "\300 ?\205	\301 ?\207" [matlab-ltype-empty matlab-ltype-comm] 1 (#$ . 48795)])
#@45 Return t if current line contain a comment.
(defalias 'matlab-lattr-comm #[nil "\212\300 )\207" [matlab-comment-on-line] 1 (#$ . 48965)])
#@137 Return non-nil if this line has implied continuation on the next.
This is only useful for new versions of MATLAB where ... is optional.
(defalias 'matlab-lattr-implied-continuation #[nil "\301 ?\205%\302\212\302\210\303\302x\210`\304\302x\210`U?\211\204\"\302\305\306\217\210))\207" [imp matlab-lattr-comm nil " 	" "-+=/*.^&~<>" (byte-code "\301\210\302\303!\210\304\305!\301\207" [imp nil matlab-up-list -1 looking-at "("] 2) ((error))] 4 (#$ . 49110)])
#@220 Return non-nil if current line ends in ... and optional comment.
If `matlab-cont-requires-ellipsis' is nil, then we need to apply
a heuristic to determine if this line would use continuation
based on what it ends with.
(defalias 'matlab-lattr-cont #[nil "\212\301 \210\302\303\304 \305#\203\306\224b\210\307 ?\206?\205\310 )\207" [matlab-cont-requires-ellipsis beginning-of-line re-search-forward "[^ 	.][ 	]*\\.\\.+[ 	]*\\(%.*\\)?$" matlab-point-at-eol t 0 matlab-cursor-in-comment matlab-lattr-implied-continuation] 4 (#$ . 49580)])
#@172 Return non-nil if current line is in an array.
If the entirety of the array is on this line, return nil.
Optional option RESTRICT is the distrance to restrict the search.
(defalias 'matlab-lattr-array-cont #[(&optional restrict) "\300\301\302\217\207" [nil (byte-code "\212\301 \210\302\303\"\210\304\305!\205`)\207" [restrict beginning-of-line matlab-up-list -1 looking-at "[[{]"] 3) ((error))] 3 (#$ . 50129)])
#@107 Return non-nil if the current line closes an array.
by close, the first character is the end of an array.
(defalias 'matlab-lattr-array-end #[nil "\212\300 \210\301\302!\205\f\303 )\207" [back-to-indentation looking-at "[]}]" matlab-lattr-array-cont] 2 (#$ . 50552)])
#@198 Return a number representing the number of unterminated block constructs.
This is any block, such as if, or for that doesn't have an END on this line.
Optional EOL indicates a virtual end of line.
(defalias 'matlab-lattr-block-cont #[(&optional eol) "\306\212\307 \210\214`	\206\310 }\210\311 \312\313\216\314\f!\210\315\316\317 \320Q\312\321#\203=\322 \204T`\323v\210\312\324\325\217\210)\202\306U?\205E.\207" [v eol case-fold-search oldsyntax matlab-mode-special-syntax-table p 0 beginning-of-line matlab-point-at-eol syntax-table nil ((set-syntax-table oldsyntax)) set-syntax-table re-search-forward "\\<" matlab-block-beg-re "\\>" t matlab-cursor-in-string-or-comment -1 (byte-code "\301 \210S\301\207" [v matlab-forward-sexp] 1) ((error (goto-char p)))] 4 (#$ . 50828)])
#@141 Return the number of middle block continuations.
This should be 1 or nil, and only true if the line starts with one of these
special items.
(defalias 'matlab-lattr-middle-block-cont #[nil "\212\300 \210\301\302 \303P!\205!\304\305 \306 \307#\203 \310 \203 \311\202!\312)\207" [back-to-indentation looking-at matlab-block-mid-re "\\>" re-search-forward matlab-block-end-pre matlab-point-at-eol t matlab-valid-end-construct-p 0 1] 4 (#$ . 51630)])
#@141 Return the number of middle block continuations.
This should be 1 or nil, and only true if the line starts with one of these
special items.
(defalias 'matlab-lattr-endless-block-cont #[nil "\212\300 \210\301\302 \303P!\205\304)\207" [back-to-indentation looking-at matlab-endless-blocks-re "\\>" 1] 3 (#$ . 52087)])
#@64 Return the number of closing block constructs. (not used yet).
(defalias 'matlab-lattr-block-close #[nil "\301\212\302\210\214\303 `}\210\304\305 \302\306#\203%\307 \203%T\302\310\311\217\210\202\f\301U?\205-+\207" [v 0 nil matlab-point-at-bol re-search-backward matlab-block-end-re t matlab-valid-end-construct-p (byte-code "\301\302!\210S\301\207" [v matlab-backward-sexp t] 2) ((error))] 4 (#$ . 52411)])
#@53 Return t if this line begins with an end construct.
(defalias 'matlab-lattr-local-end #[nil "\212\301 \210\302\303\304\305 \306Q!\205\307 *\207" [matlab-indent-function back-to-indentation nil looking-at "\\<" matlab-block-end-re "\\>" matlab-valid-end-construct-p] 4 (#$ . 52837)])
#@264 Return the semantics of the current position.
Values are nil 'solo, 'value, and 'boolean.  Boolean is a subset of
value.  nil means there is no semantic content (ie, string or comment.)
If optional PREFIX, then return 'solo if that is the only thing on the
line.
(defalias 'matlab-lattr-semantics #[(&optional prefix) "\305 \204\203\212\306 \210\307\310\311Q!)\203\312\207\212\313 \210\307\314!)\203&\315\207\212\313 \210\307\316	\n\203B\f\317@@QA\211\2044\f*\320Q!)\203M\321\207\322\207" [prefix matlab-unknown-type-commands matlab-property-lists tl r matlab-ltype-empty beginning-of-line looking-at "\\s-*" "\\s-*$" solo matlab-beginning-of-command "\\s-*\\(if\\|elseif\\|while\\)\\>" boolean "\\s-*\\(" "\\|" "\\)\\>" property value] 6 (#$ . 53130)])
#@64 Return a string representing the function called nearby point.
(defalias 'matlab-function-called-at-point #[nil "\212\300 \210\301\302!\203\303\304!\202&\305\306\307 \310#\203%\301\311!\203%\303\304!\202&\312)\207" [beginning-of-line looking-at "\\s-*\\([a-zA-Z]\\w+\\)[^=][^=]" match-string 1 re-search-forward "=" matlab-point-at-eol t "\\s-*\\([a-zA-Z]\\w+\\)\\s-*[^=]" nil] 4 (#$ . 53909)])
#@64 Return t if the cursor is in a valid MATLAB comment or string.
(defalias 'matlab-cursor-in-string-or-comment #[nil "\214\306 \307 }\210`T\310\311P\212eb\210\312\313\314\f!P\310\315#\203c`X\203ch\316U\2042h\317U\203:b\210\315\202i\320U\204K\212\321u\210\322	!)\203\312
\310\315#\211\203]`V\202_\315)\202)\n,\207" [matlab-string-start-regexp sregex returnme p matlab-elipsis-string matlab-string-end-regexp matlab-point-at-bol matlab-point-at-eol nil "'" re-search-forward "'\\|%\\|" regexp-quote t 37 46 1 -2 looking-at f] 5 (#$ . 54316)])
#@54 Return t if the cursor is in a valid MATLAB comment.
(defalias 'matlab-cursor-in-comment #[nil "\303 \304\216\214\305 \306 }\210\212\307\310\311\312\n!\313Q\307\314#\203&\315 \204&`\202	\2032\315 \2032	b\210\316\311\312\n!P!\205?\315 ?-\207" [save-match-data-internal prev-match matlab-elipsis-string match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) matlab-point-at-bol matlab-point-at-eol nil re-search-backward "%\\|" regexp-quote "+" t matlab-cursor-in-string looking-at] 4 (#$ . 54886)])
#@166 Return t if the cursor is in a valid MATLAB string.
If the optional argument INCOMPLETE is non-nil, then return t if we
are in what could be a an incomplete string.
(defalias 'matlab-cursor-in-string #[(&optional incomplete) "\306 \307\214\310 \311 }\210`T\n\312P\307\212eb\210\203#\313\312!\2048\314\315\316!P\307\317#\203\207`
X\203\207\307\203@\320\225b\210h\321U\204Lh\322U\203R
b\210\202i\323U\204g\204g\212\324u\210\313\f!)\203\314\307\317#\211\204}\203}\317\202\203`
V\317)\202-\325	!\210*\207" [returnme m matlab-string-start-regexp instring sregex p match-data nil matlab-point-at-bol matlab-point-at-eol "'" looking-at re-search-forward "'\\|%\\|" regexp-quote t 0 37 46 1 -2 set-match-data matlab-elipsis-string matlab-string-end-regexp f incomplete] 5 (#$ . 55443)])
#@122 Place the cursor on the beginning of a valid comment on this line.
If there isn't one, then return nil, point otherwise.
(defalias 'matlab-comment-on-line #[nil "\303 `\304\305 \210\306\307\n\310#\203\212\311u\210\312\310!)\204\nn\204$\311u\210\313\307!\2034\312\310!\2044`\2028	b\210\304+\207" [signal-error-on-buffer-boundary p eol matlab-point-at-eol nil beginning-of-line re-search-forward "%" t -1 matlab-cursor-in-string looking-at] 4 (#$ . 56268) nil])
#@33 Indent a line in `matlab-mode'.
(defalias 'matlab-indent-line #[nil "\302 i\212\303 \210	iU\204\304 \210\305 \210	j\210)	X\205\"\306	!*\207" [c i matlab-calc-indent back-to-indentation beginning-of-line delete-horizontal-space move-to-column] 2 (#$ . 56744) nil])
#@65 Return the appropriate indentation for this line as an integer.
(defalias 'matlab-calc-indent #[nil "\212\303 \210\304 )\212\305 \204\306 \210\307y\210\303 \210\310 )\311	Y\203&\312\202'	!\211A@+\207" [tli ci sem matlab-beginning-of-command matlab-point-at-bol matlab-prev-line beginning-of-line -1 matlab-next-line-indentation matlab-calculate-indentation 0] 4 (#$ . 57020) nil])
#@385 Calculate out the indentation of the current line.
Return a list of descriptions for this line.  Return format is:
 '(TYPE DEPTHNUMBER)
where TYPE is one of (comment, code, function, blockstart, blockmid,
blockendless, blockend) DEPTHNUMBER is how many characters to indent
this line.
  Argument CURRENT-INDENTATION is what the previous line thinks
this line's indentation should be.
(defalias 'matlab-calculate-indentation #[(current-indentation) "\306\307 \2039\310 \204\311 \203\312\313D\202
\314 \211\203&\315	D\202
\316 \2031\317\313D\202
\315\n\\D\202
\320 \203D\321\313D\202
\322 \203W\323\212\324 \210\306\325\326\217)D\202
\327 \203j\330\331!\332\306\333\334\217)D\202
\335 \203x\336\306\337\340\217D\202
\341 \203\327\342\212\343 \210\344\345!\210g\346
/\"\2110\205\2440A<\203\2410A@\202\2440A10\205\2740A<\203\2710AA\202\2740A\2112\203\321i\nZ1V\203\3212S\202\322i-D\202
\212\324 \210\343 \210`\347 \210`U)\203\356\350\nD\202
\351 \203\367\352\202

\353 \203
\354\202

\350\306\355\356\217D*\207" [current-indentation tmp ci matlab-comment-anti-indent m fc nil matlab-ltype-comm matlab-ltype-help-comm matlab-ltype-comm-ignore comment-help 0 matlab-ltype-continued-comm comment matlab-ltype-endfunction-comm comment-endfunction matlab-ltype-function-definition function matlab-lattr-local-end blockend beginning-of-line (byte-code "\301\302!\210\303 \203
\304\305!\210\306v\210\307 \310`!S_\\\207" [matlab-indent-level matlab-backward-sexp t matlab-ltype-function-definition error #1="" 1 current-indentation matlab-lattr-block-cont] 3) ((error (error "Unmatched end"))) matlab-lattr-middle-block-cont match-string 1 blockmid (byte-code "\212\300 \210\301\302!\210\303 \203\304\305!\210i)\207" [beginning-of-line matlab-backward-sexp t matlab-ltype-function-definition error #1#] 2) ((error (error "Unmatched %s" m))) matlab-lattr-endless-block-cont blockendless (byte-code "\212\301 \210\302\303!\210\304\305!\204\306\307!\210i<\203@\202\\)\207" [matlab-case-level beginning-of-line matlab-backward-sexp t looking-at "switch\\>" error #1#] 2) ((error (error "Unmatched case/otherwise part"))) matlab-lattr-array-end array-end back-to-indentation matlab-up-list -1 assoc matlab-beginning-of-command code matlab-ltype-empty empty matlab-lattr-array-cont array-cont (byte-code "\212\306 \210`)\212\307 \210\310\311!\210`V\203\312\313!\210ig\314U\203\201\212\315 \313\316\216\317\f!\210\311v\210\320
!,\203\201`\321\322\323 \324#\203P\212\310\311!\210`V)\204:h\325U\203`\320\326!\204`\324\202e\327	!\210\313)\203\201\330\313w\210i	ZV\203}	\\\202\355i\202\355g\331 \"\211!\205\241!A<\203\236!A@\202\241!A\"!\205\271!A<\203\266!AA\202\271!A#\332u\210\330\313w\210\320\333!\203\324\334 \211$%\\)\202\354#\203\353i&Z\"V\203\353&#\\\202\354i,+\207" [boc parendepth case-fold-search oldsyntax matlab-mode-special-syntax-table matlab-indent-past-arg1-functions matlab-beginning-of-command beginning-of-line matlab-up-list -1 error nil 40 syntax-table ((set-syntax-table oldsyntax)) set-syntax-table looking-at re-search-forward "," matlab-point-at-eol t 44 "\\s-*\\(\\.\\.\\.\\|$\\|)\\)" move-to-column " 	" assoc 1 "\\.\\.\\.\\|$" current-indentation start-paren matlab-arg1-max-indent-length fc matlab-maximum-indents mi max ind cci matlab-cont-level ci] 5) ((error (byte-code "\212\305 \210\306\307\310 \311#\203\312 \204h\313U\204	\\\202c\314\315w\210i\316\313\n\"\317\320!\2037AA\\\202b\203a\fZA<\203JA@\202LAV\203aA<\203]AA\202_A\\\f*)\207" [ci matlab-cont-level matlab-maximum-indents mi cc matlab-beginning-of-command re-search-forward "=" matlab-point-at-eol t matlab-cursor-in-string-or-comment 61 " 	" nil assoc looking-at "\\.\\.\\.\\|$"] 4))) matlab-maximum-indents mi max ind] 5 (#$ . 57416)])
#@67 Calculate the indentation for lines preceeding this command line.
(defalias 'matlab-next-line-indentation #[nil "\306 \307 \310 \205\f\311 	\312U?\205'\313 \205'\311 ?\205'\314 ?\205'\315 ?\316 \2067\312_\\
\206@\312_\\<\203NA\202P\f\206U\312_\\\203`\202a\312\\\n\203k	[\202l\312\\-\207" [matlab-indent-function matlab-comment-anti-indent rc hc ec mc matlab-lattr-block-cont matlab-lattr-middle-block-cont matlab-lattr-endless-block-cont matlab-ltype-help-comm 0 matlab-ltype-comm matlab-ltype-continued-comm matlab-ltype-endfunction-comm current-indentation bc matlab-indent-level matlab-case-level] 6 (#$ . 61287)])
#@163 Function to handle return key.
Must be one of:
    'matlab-plain-ret
    'matlab-indent-after-ret
    'matlab-indent-end-before-ret
    'matlab-indent-before-ret
(custom-declare-variable 'matlab-return-function ''matlab-indent-end-before-ret '(#$ . 61948) :group 'matlab :type '(choice (function-item matlab-plain-ret) (function-item matlab-indent-after-ret) (function-item matlab-indent-end-before-ret) (function-item matlab-indent-before-ret)))
#@42 Handle carriage return in `matlab-mode'.
(defalias 'matlab-return #[nil " \207" [matlab-return-function] 1 (#$ . 62401) nil])
#@19 Vanilla new line.
(defalias 'matlab-plain-ret #[nil "\300 \207" [newline] 1 (#$ . 62534) nil])
#@24 Indent after new line.
(defalias 'matlab-indent-after-ret #[nil "\300 \210\301 \207" [newline matlab-indent-line] 1 (#$ . 62635) nil])
#@61 Indent line if block end, start new line, and indent again.
(defalias 'matlab-indent-end-before-ret #[nil "\212\300 \210\301\302\303 \304\305 \304\306 \307\260!)\203\310\311\312\217\210\313 \210\314 \207" [beginning-of-line looking-at "^\\s-*\\(" matlab-block-end-re "\\|" matlab-block-mid-re matlab-endless-blocks-re "\\)" nil (matlab-indent-line) ((error)) newline matlab-indent-line] 8 (#$ . 62776) nil])
#@48 Indent line, start new line, and indent again.
(defalias 'matlab-indent-before-ret #[nil "\300 \210\301 \210\300 \207" [matlab-indent-line newline] 1 (#$ . 63193) nil])
#@106 Handle line feed in `matlab-mode'.
Has effect of `matlab-return' with (not matlab-indent-before-return).
(defalias 'matlab-linefeed #[nil "\300 \210\301 \210\300 \207" [matlab-indent-line newline] 1 (#$ . 63369) nil])
#@49 Handle carriage return for MATLAB comment line.
(defalias 'matlab-comment-return #[nil "\303 \203\304 \210\305 \210c\210\306 \210\307 \207\310 \203\"\305 \210	j\210\nc\207\305 \210\311 \210\307 \207" [fill-prefix comment-column matlab-comment-on-line-s matlab-ltype-comm matlab-set-comm-fill-prefix newline matlab-reset-fill-prefix matlab-indent-line matlab-lattr-comm matlab-comment] 1 (#$ . 63593) nil])
#@76 If the previous line is a comment-line then set up a comment on this line.
(defalias 'matlab-comm-from-prev #[nil "\212\301y\302U\205+\303 \205+\304 \210\305y\210\306 \210\307 \210\310\311!\203#\312\305!\210\307 \210c\210\313 )\207" [fill-prefix -1 0 matlab-ltype-comm matlab-set-comm-fill-prefix 1 beginning-of-line delete-horizontal-space looking-at "%" delete-char matlab-reset-fill-prefix] 2 (#$ . 64009)])
#@36 Add a comment to the current line.
(defalias 'matlab-comment #[nil "\303 \203\304 \210\305 \203\306\307w\207c\210\310 \207\311 \203#\304 \210\306\307w\207\305 \203H\312 \210\313\314!\210\315u\210i	V\203;\316 \210i	W\203D	j\210\317\307w\207\307\210\320\321\322\323#\210\307u\210\316 \210i	W\203c	j\210\202f\324c\210\nc\207" [matlab-comment-line-s comment-column matlab-comment-on-line-s matlab-ltype-empty matlab-comm-from-prev matlab-lattr-comm " 	%" nil matlab-indent-line matlab-ltype-comm beginning-of-line re-search-forward "[^%]%[ 	]" -2 delete-horizontal-space "% 	" re-search-backward "[^ 	\n^]" 0 t " "] 4 (#$ . 64430) nil])
#@132 Break the current line, and if in a comment, continue it.
Optional argument SOFT indicates that the newline is soft, and not hard.
(defalias 'matlab-comment-line-break-function #[(&optional soft) "\301 \204\302 \207\203\303\304!\210\202\305\306!\210\307c\210\310 \210\311\207" [soft matlab-cursor-in-comment matlab-return insert-and-inherit 10 newline 1 "% " matlab-indent-line nil] 2 (#$ . 65082) nil])
#@41 Indent a comment line in `matlab-mode'.
(defalias 'matlab-comment-indent #[nil "\300 \207" [matlab-calc-indent] 1 (#$ . 65500)])
#@231 Comments every line in the region.
Puts `matlab-comment-region-s' at the beginning of every line in the region.
BEG-REGION and END-REGION are arguments which specify the region boundaries.
With non-nil ARG, uncomments the region.
(defalias 'matlab-comment-region #[(beg-region end-region arg) "\306 \307 \211\n\310\223\210b\210\311 \210\f\204+
c\210\312y\313U\203Y`	W\203Y
c\210\202\314
!\315!\203<`\313\225|\210\312y\313U\203X`	W\203X\315!\203<`\313\225|\210\202<)b\210	\310\211\223\210\310\211\223*\207" [save-point end-region-mark end-region beg-region arg matlab-comment-region-s make-marker point-marker nil beginning-of-line 1 0 regexp-quote looking-at com] 4 (#$ . 65636) "*r\nP"])
#@109 Uncomment the current region if it is commented out.
Argument BEG and END indicate the region to uncomment.
(defalias 'matlab-uncomment-region #[(beg end) "\302	\303#\207" [beg end matlab-comment-region t] 4 (#$ . 66353) "*r"])
#@55 Set the `fill-prefix' for the current (comment) line.
(defalias 'matlab-set-comm-fill-prefix #[nil "\303 \205+\212\304 \210\305 \306\307\310	\311#\203\312 \204\313\314!\315iGZ\316\"P+\211\207" [pf e fill-prefix matlab-lattr-comm beginning-of-line matlab-point-at-eol nil re-search-forward "%[ 	]*\\($$$ \\)?" t matlab-cursor-in-string match-string 0 make-string 32] 4 (#$ . 66588) nil])
#@63 Set the `fill-prefix' for the current post-code comment line.
(defalias 'matlab-set-comm-fill-prefix-post-code #[nil "\300 \207" [matlab-set-comm-fill-prefix] 1 (#$ . 66992) nil])
#@26 Reset the `fill-prefix'.
(defalias 'matlab-reset-fill-prefix #[nil "\301\211\207" [fill-prefix nil] 2 (#$ . 67178)])
#@281 For the current line, position the cursor where we want to break the line.
Basically, spaces are best, then operators.  Always less than `fill-column'
unless we decide we can fudge the numbers.  Return nil if this line should
not be broken.  This function will ONLY work on code.
(defalias 'matlab-find-convenient-line-break #[nil "\306 ?\205k
\214\307 \310 }\210\311!\210\312`\313 \206\307 \211b\210iZV\2034i\\W\2034\314\202j
	b\210\212\315\316\312\314#)\212\317\316\312\314#)\f\206M\310 `Z`
\206X\307 Z
\203q\212
b\210`\212\320 \210`)X\203p\312)\f\203\213W\203\213W\203\213\fb\210\314\202\251
\203\245W\203\245W\203\245
b\210\314\202\251	b\210\312,\206j
\317\321\312\314#\210\322\323!\203\301\317\321\312\314#\204\263\322\321!\203\322`\212\320 \210`)X\203\341	b\210\317\324\312\314#\203f
\314\202j
\325u\210i\212\312\326\327\217\210\212\330u\210\322\331!)\203\371\330v\210i)\212\312\332\333\217\210i) !\" #W\203E
 \\X\203E
\211\\\334\\ \"ZX\204/
 X\203E
\212\311 !\210\322\335!)\204E
\311 !\210\314\202b
\211\\\334\\\"!ZY\203\\
\311!!\210\314\202b
\311\"!\210\314+\206j
	b\210\312+\207" [fill-column orig pos matlab-fill-fudge after before matlab-lattr-cont matlab-point-at-bol matlab-point-at-eol move-to-column nil matlab-lattr-comm t re-search-forward "[ 	]" re-search-backward back-to-indentation "\\(\\s-\\|\\s.\\)+" looking-at "\\^\\|\\.\\|'" "\\s.+" 1 (matlab-up-list -1) ((error)) -1 "\\w" (matlab-up-list 1) ((error)) 0 "\\^" afterd befored endlst startlst okpos matlab-fill-fudge-hard-maximum] 6 (#$ . 67303)])
#@164 Do auto filling.
Set variable `auto-fill-function' to this symbol to enable MATLAB style auto
filling which will automatically insert `...' and the end of a line.
(defalias 'matlab-auto-fill #[nil "	\n\203!\212\306	!\210o\204\307u\210\310\311!\203\312\202\313)\202\"\314Zi	V\205
\315 \2034\316\202
\317 \204I\212\306	!\210\320 )\203T\321 \203T\322 \210\323 \210\324 \202
\325 \205
\326 ?\205
\205
\327 \211`\316\223\210\330\f\331\"\210\332 \203
\310\311!\203\206\212\307u\210\310\311!)\204\225\333 \210\334
\335\261\210\336 \210\202
+\203
`\316,-\337\340\316\331#\203\261\307u\210\341\342!\204\240`,\341\343!\204\301\344\316x\210\307u\210\341\343!\203\316-b\210\202\337,b\210\345u\210\346c\210-b\210\345u\210\344\316w\210\347
\335\261\210\336 \210\340c\210\212\350\340\f\331#\203\376\341\342!\204\360\307u\210\341\351!\204

\345u\210\352c\210+\fb)*\207" [fill-prefix fill-column matlab-fill-count-ellipsis-flag matlab-fill-code m matlab-elipsis-string move-to-column -1 matlab-cursor-in-string incomplete 4 3 0 matlab-ltype-comm-ignore nil matlab-ltype-comm matlab-cursor-in-comment matlab-lattr-comm matlab-set-comm-fill-prefix do-auto-fill matlab-reset-fill-prefix matlab-ltype-code matlab-lattr-cont make-marker set-marker-insertion-type t matlab-find-convenient-line-break delete-horizontal-space " " "\n" matlab-indent-line re-search-backward "'" looking-at "''" "\\[" " 	" 1 "[" "' " re-search-forward "'\\s-*]" "]" matlab-fill-strings-flag pos2 pos] 5 (#$ . 68903) nil])
#@53 Join current comment line to the next comment line.
(defalias 'matlab-join-comment-lines #[nil "\300\210\301\302!\203\303\304\305\211\300$\207\306\307!\207" [nil looking-at "\n[ 	]*%" replace-match " " t error "No following comment to join with"] 5 (#$ . 70431) nil])
#@110 Fill the region between BEG-REGION and END-REGION.
Non-nil JUSTIFY-FLAG means justify comment lines as well.
(defalias 'matlab-fill-region #[(beg-region end-region &optional justify-flag) "\304 \211	\305\223\210\nb\210\306 \210`W\205!\307!\210\310y\210\306 \210\202)\207" [end-reg-mk end-region beg-region justify-flag make-marker nil beginning-of-line matlab-fill-paragraph 1] 4 (#$ . 70709) "*r\nP"])
#@85 Fill the current comment line.
With optional argument, JUSTIFY the comment as well.
(defalias 'matlab-fill-comment-line #[(&optional justify) "\303 \204	\304\305!\210\306 \210\307!\203o\204\310y\210\306 \210\202\f\307!\204(\311y\210\214`\212\307!\203C\212\312\210m)\204C\311y\210\306 \210\202+\307!\204L\310y\210\312\210`)}\210\303 \210\307\313!\210\314i\315\"\316\317!P\320ed\n#*\207" [matlab-cline-start-skip fill-prefix justify matlab-comment-on-line error "No comment to fill" beginning-of-line looking-at -1 1 nil "%[ 	]*" make-string 32 match-string 0 fill-region] 4 (#$ . 71124) nil])
#@42 Delete space on end of line and justify.
(defalias 'matlab-justify-line #[nil "\212\300\210\301 \210\302 )\207" [nil delete-horizontal-space justify-current-line] 1 (#$ . 71740) nil])
#@159 When in a comment, fill the current paragraph.
Paragraphs are always assumed to be in a comment.
ARG is passed to `fill-paragraph' and will justify the text.
(defalias 'matlab-fill-paragraph #[(arg) "\306 \204\307 \2037\310 \2047\311\211\312\212\313 \210`)\212\314 \210`)\312\315 \210\214\nd	T^}\210\316#!.\207\317 \203\323\214\212\313 \210\320 \210`)\212\314 \210`)}\210eb\210\321\322\312\323#\203\224m\204\224\324 \210\310 \203q\325\224b\210\326u\210`\327 |\210m\204y\330\326!\210\324 \210\331\332!\203\216\307 \203\216\330\326!\210\324 \210\333c\210\202Qdb\210i$%\\V\204\250i&V\203\305`\334 \210`U\203\265\335\336!\210#\203\227\212\337y\210\340 \210)\202\227#\205\321\212\337y\210\340 ))\207\341\342!\207" [fill-prefix end start paragraph-ignore-fill-prefix paragraph-start paragraph-separate matlab-ltype-comm matlab-cursor-in-comment matlab-lattr-cont "%[a-zA-Z]\\|%[ 	]*$\\|[ 	]*$" nil matlab-beginning-of-command matlab-end-of-command matlab-set-comm-fill-prefix fill-paragraph matlab-ltype-code beginning-of-line re-search-forward "$" t delete-horizontal-space 0 1 matlab-point-at-eol delete-char looking-at "% *" " " matlab-auto-fill error "Fill algorith failed!" -1 matlab-justify-line message "Paragraph Fill not supported in this context." arg fill-column matlab-fill-fudge matlab-fill-fudge-hard-maximum] 6 (#$ . 71932) "P"])
#@422 Return a list of most recent variables starting with PREFIX as a string.
Reverse searches for the following are done first:
  1) Assignment
  2) if|for|while|switch <var>
  3) global variables
  4) function arguments.
All elements are saved in a list, which is then uniqafied.
If NEXT is non-nil, then the next element from the saved list is used.
If the list is empty, then searches continue backwards through the code.
(defalias 'matlab-find-recent-variable-list #[(prefix) "\306 \307\310\216\311\n!\210\212\312\313\307\314#\203\315\224\202e)\316\212\307\312\317
\320Q\314#\203;\fG\321W\203;\322\323!\fB\202 \f\237*\212\307\312\324!\325
\326\260\314#\203`\fG\321W\203`\322\327!\fB\202A\f\237*\212\312\330\314#\205\240\307\211\211\"#\315\225b\210\331\332!\203\235\322\323!#\315\225\"\333
#\"\315\232\203\226#\fB\"b\210\202x\f\237+)\212\312\313\314#\205\343\334\335\336 \314#\205\343\307\211\211\"#\331\337!\203\340\322\323!#\315\225\"\333
#\"\315\232\203\331#\fB\"b\210\202\273\f\237+)$$\307%$\203
$@\203\375$@%B%$A\211$\204\357\340%\237!.\207" [case-fold-search oldsyntax matlab-mode-special-syntax-table bounds lst prefix syntax-table nil ((set-syntax-table oldsyntax)) set-syntax-table re-search-backward "^\\s-*function\\>" t 0 append "^\\s-*\\(" "\\w+\\)\\s-*=" 10 match-string 1 "\\<\\(" "\\)\\s-+(?\\s-*\\(" "\\w+\\)\\>" 2 "^\\s-*global\\s-+" looking-at "\\(\\w+\\)\\([ 	]+\\|$\\)" string-match re-search-forward "\\<\\(\\w+\\)(" matlab-point-at-eol "\\(\\w+\\)\\s-*[,)]\\s-*" matlab-uniquafy-list matlab-block-beg-pre-no-if e m syms fl] 9 (#$ . 73309)])
#@46 Maintained by `matlab-find-recent-variable'.
(defvar matlab-most-recent-variable-list nil (#$ . 74942))
#@190 Return the most recently used variable starting with PREFIX as a string.
See `matlab-find-recent-variable-list' for details.
In NEXT is non-nil, than continue through the list of elements.
(defalias 'matlab-find-recent-variable #[(prefix &optional next) "\203
	@	A)\207\306\n!\307
\310=\203\f\202$\f@\fA*\207" [next matlab-most-recent-variable-list prefix first syms matlab-completion-technique matlab-find-recent-variable-list nil complete] 2 (#$ . 75053)])
#@60 Return a list of user defined functions that match PREFIX.
(defalias 'matlab-find-user-functions-list #[(prefix) "\306 \307\310\216\311\n!\210\312\212eb\210\307\313\314\307\315#\203/\313\316\f\317Q\320 \315#\203\321\322!B\202\237*\307\323
\307\324\f\325Q#\203]\326\327@\"\210@\330\211\224OBA\211\204C*\"\307\211\203\200@\203w@BA\211\204i\331\237!-\207" [case-fold-search oldsyntax matlab-mode-special-syntax-table lst prefix default-directory syntax-table nil ((set-syntax-table oldsyntax)) set-syntax-table append re-search-forward "^\\s-*function\\>" t "\\(" "\\w+\\)\\s-*\\($\\|(\\)" matlab-point-at-eol match-string 1 directory-files "^" "[a-zA-Z][a-zA-Z0-9_]+\\.m$" string-match "\\.m" 0 matlab-uniquafy-list files fl syms] 10 (#$ . 75531)])
#@45 Maintained by `matlab-find-user-functions'.
(defvar matlab-user-function-list nil (#$ . 76334))
#@130 Return a user function that match PREFIX and return it.
If optional argument NEXT is non-nil, then return the next found
object.
(defalias 'matlab-find-user-functions #[(prefix &optional next) "\203
	@	A)\207\306\n!\307
\310=\203\f\202$\f@\fA*\207" [next matlab-user-function-list prefix first syms matlab-completion-technique matlab-find-user-functions-list nil complete] 2 (#$ . 76437)])
#@93 Maintained by `matalb-generic-list-expand'.
Holds sub-lists of symbols left to be expanded.
(defvar matlab-generic-list-placeholder nil (#$ . 76846))
#@177 Return an element from LIST that start with PREFIX.
If optional NEXT argument is non nil, then the next element in the
list is used.  nil is returned if there are not matches.
(defalias 'matlab-generic-list-expand #[(list prefix &optional next) "\203
	@	A)\207\306\307\n!P\310\211\2034\311
@\"\203+@BA\211\204\237\f\312=\203B\202I@A\f+\207" [next matlab-generic-list-placeholder prefix fl first re "^" regexp-quote nil string-match complete list matlab-completion-technique] 4 (#$ . 77003)])
#@102 Return PREFIX matching elements for solo symbols.
If NEXT then the next patch from the list is used.
(defalias 'matlab-solo-completions #[(prefix &optional next) "\303	\n#\207" [matlab-keywords-solo prefix next matlab-generic-list-expand] 4 (#$ . 77536)])
#@103 Return PREFIX matching elements for value symbols.
If NEXT then the next patch from the list is used.
(defalias 'matlab-value-completions #[(prefix &optional next) "\303	\n#\207" [matlab-keywords-return prefix next matlab-generic-list-expand] 4 (#$ . 77800)])
#@105 Return PREFIX matching elements for boolean symbols.
If NEXT then the next patch from the list is used.
(defalias 'matlab-boolean-completions #[(prefix &optional next) "\303	\n#\207" [matlab-keywords-boolean prefix next matlab-generic-list-expand] 4 (#$ . 78068)])
#@118 Return PREFIX matching elements for property names in strings.
If NEXT then the next property from the list is used.
(defalias 'matlab-property-completions #[(prefix &optional next) "\306 \307\211\203$\n\204$@@\f\230\203@AA\211\204
\n\2030\310\n
\"\2023\f\311\n
#\211<\203P	G\312U\203P	@\313PC\202Y	;\203Y	\313P	,\207" [matlab-property-lists expandto foundlst lst f matlab-core-properties matlab-function-called-at-point nil append matlab-generic-list-expand 1 "'" matlab-all-known-properties prefix next] 5 (#$ . 78341)])
#@91 Maintained by `matlab-complete-symbol'.
The prefix used for the first completion command.
(defvar matlab-last-prefix nil (#$ . 78901))
#@97 Maintained by `matlab-complete-symbol'.
The last type of semantic used while completing things.
(defvar matlab-last-semantic nil (#$ . 79042))
#@44 List of searching things we will be doing.
(defvar matlab-completion-search-state nil (#$ . 79191))
#@789 Complete a partially typed symbol in a MATLAB mode buffer.
If the previously entered command was also `matlab-complete-symbol'
then undo the last completion, and find a new one.
  The types of symbols tried are based on the semantics of the current
cursor position.  There are two types of symbols.  For example, if the
cursor is in an if statement, boolean style functions and symbols are
tried first.  If the line is blank, then flow control, or high level
functions are tried first.
  The completion technique is controlled with `matlab-completion-technique'
It defaults to incremental completion described above.  If a
completion list is preferred, then change this to 'complete.  If you
just want a completion list once, then use the universal argument ARG
to change it temporarily.
(defalias 'matlab-complete-symbol #[(&optional arg) "\306 \307\310\216\311\n!\210\312=\204h\313\235\203\314\202$\315\212\316v\210`)`\"\317\f!*\203=+\320=\2039\321\202?\320\202?++\312=\204x\f,
-
\322=\203W\323\202v
\324=\203a\325\202v
\326=\203k\327\202v
\330=\203u\331\202v\332.+\321=\203\320\307\312=/00\204\261.\203\261\333\334.@\"\210.@,/\"\2110\204\207.A.\307/\202\207`\fG[u\210`|\2100\203\3050c\202\314,c\210\333\335!*\202H
+\320=\205H
\336\337\340\341.\"\"\2111\204\356\333\335!\210\342 \202G
1G\343U\203
`\fG[u\210`|\2101@c\202G
1G\344U\203
\333\335!\202G
\340\3451\"2\346\f2\"\2113;\203=
\f3\230\204=
`\fG[u\210`|\2103c\202F
\347\220\350\3511!!\221*).\207" [case-fold-search oldsyntax matlab-mode-special-syntax-table last-command prefix sem syntax-table nil ((set-syntax-table oldsyntax)) set-syntax-table matlab-complete-symbol (32 9 10 44 40 91 39) "" buffer-substring-no-properties -1 matlab-lattr-semantics complete increment solo (matlab-solo-completions matlab-find-user-functions matlab-find-recent-variable) boolean (matlab-find-recent-variable matlab-boolean-completions matlab-find-user-functions matlab-value-completions) value (matlab-find-recent-variable matlab-find-user-functions matlab-value-completions matlab-boolean-completions) property (matlab-property-completions matlab-find-user-functions matlab-find-recent-variable matlab-value-completions) (matlab-find-recent-variable matlab-find-user-functions matlab-value-completions matlab-boolean-completions) message "Expand with %S" "No completions." apply append mapcar #[(f) "	!\207" [f prefix] 2] ding 1 0 #[(a) "C\207" [a] 1] try-completion "*Completions*" display-completion-list matlab-uniquafy-list arg matlab-completion-technique matlab-last-prefix matlab-last-semantic matlab-completion-search-state donext r allsyms al c] 6 (#$ . 79298) "P"])
#@134 Insert and END block based on the current syntax.
Optional argument REINDENT indicates if the specified block should be re-indented.
(defalias 'matlab-insert-end-block #[(&optional reindent) "\303 \204\304\210\305c\210\306\304\212\304\307\310\217\210)	\204 \311\312!\2029\313c\210	;\203-\314	\261\210\315 \210\n\2059\316`\304#*\207" [begin valid reindent matlab-ltype-empty nil "\n" t (byte-code "\302\303!\210`\304`\212\305\306\307\303#\210`)\"\307\207" [begin valid matlab-backward-sexp t buffer-substring-no-properties re-search-forward "[\n,;.]" nil] 6) ((error (byte-code "\301\211\207" [valid nil] 2))) error "No block to end" "end" " % " matlab-indent-line indent-region] 4 (#$ . 81997) "P"])
(byte-code "\300\301\302\303\304\305%\210\300\306\307\310\311\305%\210\300\312\313\314\315\305%\210\300\316\317\314\315\305%\210\300\320\321\322\323\305%\210\300\324\325\326\327\305%\207" [tempo-define-template "matlab-for" ("for " p "=" p "," > n> r> & "end" > %) "for" "Insert a MATLAB for statement" matlab-tempo-tags "matlab-while" ("while (" p ")," > n> r> & "end" > %) "while" "Insert a MATLAB while statement" "matlab-if" ("if " p > n r> "end" > n) "if" "Insert a MATLAB if statement" "matlab-if-else" ("if " p > n r> "else" > n "end" > n) "matlab-try" ("try " > n r> "catch" > n p > n "end" > n) "try" "Insert a MATLAB try catch statement" "matlab-switch" ("switch " p > n "otherwise" > n r> "end" > n) "switch" "Insert a MATLAB switch statement with region in the otherwise clause."] 6)
#@55 Insert a case statement inside this switch statement.
(defalias 'matlab-insert-next-case #[nil "\301\212\302\303\304\217\210)\204\305\306!\210)\307 \204\302\210\310c\210\311j\210\312c\210\313 \207" [valid t nil (byte-code "\301\302!\210\303\304!\301\207" [valid matlab-backward-sexp t looking-at "switch"] 2) ((error (byte-code "\301\211\207" [valid nil] 2))) error "Not in a switch statement" matlab-ltype-empty "\n" 0 "case " matlab-indent-line] 3 (#$ . 83513) nil])
(tempo-define-template "matlab-function" '("function " (P "output argument(s): " output t) (if (string-match "," (tempo-lookup-named 'output)) '(l "[" (s output) "]") '(l (s output))) (if (= 0 (length (tempo-lookup-named 'output))) nil " = ") (if (= 1 (count-lines 1 (point))) (tempo-save-named 'fname (file-name-nondirectory (file-name-sans-extension (buffer-file-name)))) '(l (P "function name: " fname t))) (tempo-lookup-named 'fname) "(" (P "input argument(s): ") ")" n "% " (upcase (tempo-lookup-named 'fname)) " - " (P "H1 line: ") n "%   " p n) "function" "Insert a MATLAB function statement" 'matlab-tempo-tags)
#@268 Put MATLAB 's around region, and quote all quotes in the string.
Stringification allows you to type in normal MATLAB code, mark it, and
then turn it into a MATLAB string that will output exactly what's in
the region.  BEGIN and END mark the region to be stringified.
(defalias 'matlab-stringify-region #[(begin end) "\212b\210\303\304	\305#\203\306\307!\210\310 \211	\311\223\210b\210\312c\210\303\312\n\305#\203,\312c\210\202\nb\210\312c*\207" [begin end m re-search-forward "\n" t error "You may only stringify regions that encompass less than one line" make-marker nil "'"] 5 (#$ . 84618) "r"])
#@99 Spell check valid strings in region with Ispell.
Argument BEGIN and END mark the region boundary.
(defalias 'matlab-ispell-strings-region #[(begin end) "\302\303!\210\212b\210\304	!\205\305\306\224\306\225\"\205\202)\207" [begin end require ispell matlab-font-lock-string-match-normal ispell-region 2] 3 (#$ . 85230) "r"])
#@99 Spell check valid strings in the current buffer with Ispell.
Calls `matlab-ispell-strings-region'
(defalias 'matlab-ispell-strings #[nil "\300ed\"\207" [matlab-ispell-strings-region] 3 (#$ . 85566) nil])
#@111 Spell check comments in the current buffer with Ispell.
Optional ARG means to only check the current comment.
(defalias 'matlab-ispell-comments #[(&optional arg) "ed\n\203\303 \203\212\304 \210`)\212\305 \210`)\212	b\210\306 \210\307!\2054\310\311\224\311\225\"\2054\202\"+\207" [end beg arg matlab-ltype-comm matlab-beginning-of-command matlab-end-of-command beginning-of-line matlab-font-lock-comment-match ispell-region 1] 3 (#$ . 85777) "P"])
#@123 Convert a MATLAB M file into a Latex document for printing.
Author: Uwe Brauer oub@eucmos.sim.ucm.es
Created: 14 Feb 2002
(defalias 'matlab-generate-latex #[nil "\214\212eb\210\300c\210\301 \210db\210\302c\210~\210*\303\304!\210\305 \210\303\304!\207" ["\\documentclass[12pt]{report}\n\n\\usepackage{listings}\n\\lstloadlanguages{Matlab}\n\\lstset{language=Matlab,keywordstyle=\\bfseries,labelstep=1,escapechar=\\#}\n\\begin{document}\n\\begin{lstlisting}{}" newline "\n\\end{lstlisting}\n\\end{document}" font-lock-mode nil LaTeX-mode] 2 (#$ . 86243) "*"])
#@47 The timer representing the block highlighter.
(defvar matlab-block-highlighter-timer nil (#$ . 86807))
#@137 Start or stop the block highlighter.
Optional ARG is 1 to force enable, and -1 to disable.
If ARG is nil, then highlighting is toggled.
(defalias 'matlab-enable-block-highlighting #[(&optional arg) "\303\304!\204\305\205+	\204\306\n\235\203\307\202\310	\311V\203'\312\302\306\"\207\313\302\306\"\207" [matlab-highlight-block-match-flag arg post-command-hook fboundp matlab-run-with-idle-timer nil matlab-start-block-highlight-timer -1 1 0 add-hook remove-hook] 3 (#$ . 86917) "P"])
#@31 The last highlighted overlay.
(defvar matlab-block-highlight-overlay nil (#$ . 87418))
(make-variable-buffer-local 'matlab-block-highlight-overlay)
#@21 Last started timer.
(defvar matlab-block-highlight-timer nil (#$ . 87572))
(make-variable-buffer-local 'matlab-block-highlight-timer)
#@51 Set up a one-shot timer if we are in MATLAB mode.
(defalias 'matlab-start-block-highlight-timer #[nil "\303=\205$	\203\304\216\305	!\210)\n\203\306\216\307\n!\210)\310\311\312\313p$\211\207" [major-mode matlab-block-highlight-overlay matlab-block-highlight-timer matlab-mode ((byte-code "\301\211\207" [matlab-block-highlight-overlay nil] 2)) matlab-delete-overlay ((byte-code "\301\211\207" [matlab-block-highlight-timer nil] 2)) matlab-cancel-timer matlab-run-with-idle-timer 1 nil matlab-highlight-block-match] 5 (#$ . 87712)])
#@115 Highlight a matching block if available.
BUFF-WHEN-LAUNCHED is the buffer that was active when the timer was set.
(defalias 'matlab-highlight-block-match #[(&optional buff-when-launched) "\306	\204\n\306\211\207	\205\213	p=\205\213\306\307
\203\310 \210\311 ?\205\212\212n\204>\312\313!\204>\212\314u\210\312\313!)\204>\314v\210\312\315 \316P!\203m\312\317!\204m\320 \210\314v\210\312!\205\211\321`\322v\210`p#\323\324\325#\202\211\312\326 \316P!\205\211\312\317!?\205\211\327 \205\211\322v\210\306\330\331\217)*\207" [matlab-block-highlight-timer buff-when-launched matlab-highlight-block-match-flag matlab-scan-on-screen-only inhibit-quit matlab-show-periodic-code-details-flag nil t matlab-show-line-info matlab-cursor-in-string-or-comment looking-at "\\s-" -1 matlab-block-beg-re "\\>" "function" matlab-forward-sexp matlab-make-overlay 1 matlab-overlay-put face matlab-region-face matlab-block-end-pre matlab-valid-end-construct-p (byte-code "\301 \210\302\303 !\205\304`\305v\210`p#\306\307\310#\207" [matlab-block-highlight-overlay matlab-backward-sexp looking-at matlab-block-beg-re matlab-make-overlay 1 matlab-overlay-put face matlab-region-face] 4) ((error (message "Unstarted block at cursor."))) matlab-block-end-pre-if matlab-block-highlight-overlay] 4 (#$ . 88259)])
#@56 Verify the current buffer from `write-contents-hooks'.
(defalias 'matlab-mode-verify-fix-file-fn #[nil "\203\n\302d	V!\210\303\207" [matlab-verify-on-save-flag matlab-block-verify-max-buffer-size matlab-mode-verify-fix-file nil] 3 (#$ . 89577)])
#@233 Verify the current buffer satisfies all M things that might be useful.
We will merely loop across a list of verifiers/fixers in
`matlab-mode-verify-fix-functions'.
If optional FAST is non-nil, do not perform usually lengthy checks.
(defalias 'matlab-mode-verify-fix-file #[(&optional fast) "`	\203	@!\210	A\211\204\nb\210*t\205\304\305!\207" [matlab-mode-verify-fix-functions l p fast message "Done."] 3 (#$ . 89832) nil])
#@79 Verify/Fix the function name of this file.
Optional argument FAST is ignored.
(defalias 'matlab-mode-vf-functionname #[(&optional fast) "\306 \307\310\216\311\n!\210eb\210\312 \204\313 \203%\314 dU\204%\315y\210\202\307\316\317\320 !!\321\322 !\205b\323\225\323\225b\210\324v\210`
{\211\230?\205a\325
\326#\205a
b\210
|\210c*-\207" [case-fold-search oldsyntax matlab-mode-special-syntax-table bn func begin syntax-table nil ((set-syntax-table oldsyntax)) set-syntax-table matlab-ltype-empty matlab-ltype-comm matlab-point-at-eol 1 file-name-sans-extension file-name-nondirectory buffer-file-name looking-at matlab-match-function-re 0 -1 matlab-mode-highlight-ask "Function and file names are different. Fix?" end] 5 (#$ . 90272)])
#@147 Verify/Fix unterminated (or un-ended) blocks.
This only checks block regions like if/end.
Optional argument FAST causes this check to be skipped.
(defalias 'matlab-mode-vf-block-matches-forward #[(&optional fast) "eb\210\306\307\310 \311Q\312 \313\314\216\315\f!\210
?\205\\	\205\\\316\313\306#\205\\\317v\210`\313\320\321\217\210	\204Mb\203M\322`\212\323v\210`)\324#\204M\325\326!\210)\327\330`\331_d\245\332\245\"\210\202-\207" [expr go case-fold-search oldsyntax matlab-mode-special-syntax-table fast t "\\<\\(" matlab-block-beg-pre "\\)\\>" syntax-table nil ((set-syntax-table oldsyntax)) set-syntax-table re-search-forward -1 (byte-code "\302 \204\303\304!\204\305 \210\306v\210\303\307P!\204!\310\202!\311v\210\310\207" [matlab-block-end-pre-no-if go matlab-cursor-in-string-or-comment looking-at "function" matlab-forward-sexp -1 "\\>" nil 1] 3) ((error (byte-code "\301\211\207" [go nil] 2))) matlab-mode-highlight-ask 1 "Unterminated block.  Continue anyway?" error "Unterminated Block found!" message "Block-check: %d%%" 100 2 s] 4 (#$ . 91035)])
#@104 Verify/fix unstarted (or dangling end) blocks.
Optional argument FAST causes this check to be skipped.
(defalias 'matlab-mode-vf-block-matches-backward #[(&optional fast) "db\210\306\307\310 \311Q\312 \313\314\216\315\f!\210
?\205`	\205`\316\313\306#\205`\317v\210`\313\320\321\217\210	\204Mb\203M\322`\212\323v\210`)\324#\204M\325\326!\210)\327\330d`Z\331_d\245\332\245\333\\\"\210\202-\207" [expr go case-fold-search oldsyntax matlab-mode-special-syntax-table fast t "\\<\\(" matlab-block-end-no-function-re "\\)\\>" syntax-table nil ((set-syntax-table oldsyntax)) set-syntax-table re-search-backward 1 (byte-code "\300 \204\301 \203\302 \210\202\303v\210\300\207" [matlab-cursor-in-string-or-comment matlab-valid-end-construct-p matlab-backward-sexp -1] 1) ((error (byte-code "\301\211\207" [go nil] 2))) matlab-mode-highlight-ask -1 "Unstarted block.  Continue anyway?" error "Unstarted Block found!" message "Block-check: %d%%" 100 2 50 s] 4 (#$ . 92125)])
#@71 Highlight from BEGIN to END while asking PROMPT as a yes-no question.
(defalias 'matlab-mode-highlight-ask #[(begin end prompt) "\304	p#\305\305\306\307\217\210\n*\207" [begin end ans mo matlab-make-overlay nil (byte-code "\303\304\305#\210\306	!\307!\207" [mo prompt ans matlab-overlay-put face matlab-region-face y-or-n-p matlab-delete-overlay] 4) ((quit (byte-code "\301!\210\302\303!\207" [mo matlab-delete-overlay error "Quit"] 2)))] 4 (#$ . 93117)])
#@170 Find all commands that do not end in ;, and add one.
This has the effect of removing any extraneous output that may not be
desired.  Optional argument FAST is not used.
(defalias 'matlab-mode-vf-quietafy-buffer #[(&optional fast) "\212\303 \210\304\305\212\306\210m)\204\204\307\310\311	!H!\210	\\\211\312V\204)	\304W\2034[\211\211\\\304\\	\\\313`!\210\314 \203D\315 \210\316\306x\210h\317U\204~\320\321!\204~\212\322 \210\323\324!)\204~`\316\306x\210\n`U\204q\n`|\210\325y\210\202}\326``T\327#\203}\330c\210)\331y\210\202+\307\332!\207" [dir msgpos p beginning-of-buffer 0 0.2 nil message ["Scanning o...." "Scanning .o..." "Scanning ..o.." "Scanning ...o." "Scanning ....o"] floor 5 matlab-end-of-command matlab-cursor-in-comment matlab-comment-on-line " 	" 59 matlab-cursor-in-string t beginning-of-line looking-at "\\s-*\\(function\\|for\\|while\\|try\\|catch\\|switch\\|otherwise\\|case\\|break\\|if\\|else\\|end\\|return\\|disp\\|$\\|%\\)" -1 matlab-mode-highlight-ask "Add Semi colon here? " ";" 1 "Scanning .... done"] 5 (#$ . 93587) nil])
#@43 Set up hilit19 support for `matlab-mode'.
(defalias 'matlab-mode-hilit #[nil "\205\306\307\310\211\311\312!\210\313\314
\"\207" [window-system hilit-mode-enable-list hilit-background-mode hilit-inhibit-hooks hilit-inhibit-rebinding matlab-hilit19-patterns (not text-mode) light nil require hilit19 hilit-set-mode-patterns matlab-mode] 4 (#$ . 94662) nil])
#@47 Keymap used in MATLAB mode to provide a menu.
(defvar matlab-mode-menu-keymap nil (#$ . 95031))
#@35 Initialize Emacs 19+ menu system.
(defalias 'matlab-frame-init #[nil "\302\301\303\304#\210\305\301!\204\306\301\307\"\210\310\301\304\311$\210\312	\"\207" [matlab-mode-map matlab-mode-menu put variable-documentation "MATLAB menu" default-boundp set-default nil easy-menu-do-define ("MATLAB" ["Start MATLAB" matlab-shell (not (matlab-with-emacs-link))] ["Save and go" matlab-shell-save-and-go t] ["Run Region" matlab-shell-run-region t] ["Version" matlab-show-version t] "----" ["Find M file" matlab-find-file-on-path t] ("Auto Fix" ["Verify/Fix source" matlab-mode-verify-fix-file t] ["Spell check strings" matlab-ispell-strings t] ["Spell check comments" matlab-ispell-comments t] ["Quietafy source" matlab-mode-vf-quietafy-buffer t]) ("Navigate" ["Beginning of Command" matlab-beginning-of-command t] ["End of Command" matlab-end-of-command t] ["Forward Block" matlab-forward-sexp t] ["Backward Block" matlab-backward-sexp t] ["Beginning of Function" matlab-beginning-of-defun t] ["End of Function" matlab-end-of-defun t]) ("Format" ["Justify Line" matlab-justify-line t] ["Fill Region" matlab-fill-region t] ["Fill Comment Paragraph" matlab-fill-paragraph (save-excursion (matlab-comment-on-line))] ["Join Comment" matlab-join-comment-lines (save-excursion (matlab-comment-on-line))] ["Comment Region" matlab-comment-region t] ["Uncomment Region" matlab-uncomment-region t]) ("Insert" ["Complete Symbol" matlab-complete-symbol t] ["Comment" matlab-comment t] ["if end" tempo-template-matlab-if t] ["if else end" tempo-template-matlab-if-else t] ["for end" tempo-template-matlab-for t] ["switch otherwise end" tempo-template-matlab-switch t] ["Next case" matlab-insert-next-case t] ["try catch end" tempo-template-matlab-try t] ["while end" tempo-template-matlab-while t] ["End of block" matlab-insert-end-block t] ["Function" tempo-template-matlab-function t] ["Stringify Region" matlab-stringify-region t]) ("Customize" ["Indent Function Body" (setq matlab-indent-function (not matlab-indent-function)) :style toggle :selected matlab-indent-function] ["Verify File on Save" (setq matlab-verify-on-save-flag (not matlab-verify-on-save-flag)) :style toggle :selected matlab-verify-on-save-flag] ["Auto Fill does Code" (setq matlab-fill-code (not matlab-fill-code)) :style toggle :selected matlab-fill-code] ["Periodic Code Details" (setq matlab-show-periodic-code-details-flag (not matlab-show-periodic-code-details-flag)) :style toggle :selected matlab-show-periodic-code-details-flag] ["Highlight Matching Blocks" (matlab-enable-block-highlighting) :style toggle :selected (member 'matlab-start-block-highlight-timer post-command-hook)] ["Customize" (customize-group 'matlab) (and (featurep 'custom) (fboundp 'custom-declare-variable))]) "----" ["Run M Command" matlab-shell-run-command (matlab-shell-active-p)] ["Describe Command" matlab-shell-describe-command (matlab-shell-active-p)] ["Describe Variable" matlab-shell-describe-variable (matlab-shell-active-p)] ["Command Apropos" matlab-shell-apropos (matlab-shell-active-p)] ["Topic Browser" matlab-shell-topic-browser (matlab-shell-active-p)]) easy-menu-add] 5 (#$ . 95133) nil])
(custom-declare-group 'matlab-shell nil "MATLAB shell mode." :prefix "matlab-shell-" :group 'matlab)
#@73 *The name of the command to be run which will start the MATLAB process.
(custom-declare-variable 'matlab-shell-command '"matlab" '(#$ . -98384) :group 'matlab-shell :type 'string)
#@59 *Command line parameters run with `matlab-shell-command'.
(custom-declare-variable 'matlab-shell-command-switches ''nil '(#$ . -98570) :group 'matlab-shell :type '(list :tag "Switch: "))
#@42 *If `matlab-shell-command' echoes input.
(custom-declare-variable 'matlab-shell-echoes 't '(#$ . -98763) :group 'matlab-shell :type 'boolean)
#@87 *Location of the history file.
This file is read to initialize the comint input ring.
(custom-declare-variable 'matlab-shell-history-file '"~/.matlab/R12/history.m" '(#$ . -98911))
#@38 *Number of history elements to keep.
(custom-declare-variable 'matlab-shell-input-ring-size '32 '(#$ . -99098) :group 'matlab-shell :type 'integer)
#@63 *Non-nil means to use GUD mode when running the MATLAB shell.
(custom-declare-variable 'matlab-shell-enable-gud-flag 't '(#$ . -99252) :group 'matlab-shell :type 'boolean)
#@59 *List of functions to call on entry to MATLAB shell mode.
(custom-declare-variable 'matlab-shell-mode-hook 'nil '(#$ . -99430) :group 'matlab-shell :type 'hook)
#@90 Name used to create `matlab-shell' mode buffers.
This name will have *'s surrounding it.
(defvar matlab-shell-buffer-name "MATLAB" (#$ . 99597))
#@41 Return t if the MATLAB shell is active.
(defalias 'matlab-shell-active-p #[nil "\301\302\302Q!\205\212\302\302Qq\210\303p!\205p)\207" [matlab-shell-buffer-name get-buffer "*" comint-check-proc] 4 (#$ . 99748)])
#@37 Keymap used in `matlab-shell-mode'.
(defvar matlab-shell-mode-map nil (#$ . 99971))
#@41 Keyword symbol used for font-lock mode.
(defvar matlab-shell-font-lock-keywords-1 (append matlab-font-lock-keywords matlab-shell-font-lock-keywords) (#$ . 100061))
#@50 Keyword symbol used for gaudy font-lock symbols.
(defvar matlab-shell-font-lock-keywords-2 (append matlab-shell-font-lock-keywords-1 matlab-gaudy-font-lock-keywords) (#$ . 100231))
#@57 Keyword symbol used for really gaudy font-lock symbols.
(defvar matlab-shell-font-lock-keywords-3 (append matlab-shell-font-lock-keywords-2 matlab-really-gaudy-font-lock-keywords) (#$ . 100418))
#@152 Create a buffer with MATLAB running as a subprocess.

MATLAB shell cannot work on the MS Windows platform because MATLAB is not
a console application.
(defalias 'matlab-shell #[nil "\306=\204\f\307=\203	\310\230\203\311\312!\210\313\314!\210\313\315!\210\n\203(\316\317!\204.\320\321!\210\322\323\324\324Q!\210\325 ?\205\333\326 \210\f\204\242\327\304!\316\330!\203U\330
>\"\210\202Z
>\244\331\332\333
?$\210\334
\335@#\210\334
\336\337#\210\334
\340\341#\210\334
\342\343#\210\334
\344\345#\210\334
\346\343#\210\334
\347\345#\210\334
\350\351#\210\334
\352\353#\210\334
\354\353#\210
)\323\355\356	\322A%!\210\357B\360 \210\n\203\331\361 \210\362\363!\210\3643\362\365!\210\3665\367\370p!\371\"\210\372\370p!\373\"\210\374 \210\375 \207" [window-system matlab-shell-command matlab-shell-enable-gud-flag matlab-shell-buffer-name matlab-shell-mode-map km pc w32 "matlab" error "MATLAB cannot be run as a inferior process.  Try C-h f matlab-shell RET" require shell gud fboundp gud-def message "Sorry, your emacs cannot use the MATLAB Shell GUD features." nil switch-to-buffer "*" matlab-shell-active-p kill-all-local-variables make-sparse-keymap set-keymap-parent substitute-key-definition next-error matlab-shell-last-error define-key [(control h) (control m)] "." matlab-find-file-on-path [(tab)] comint-dynamic-complete-filename [(control up)] comint-previous-matching-input-from-input [(control down)] comint-next-matching-input-from-input [up] [down] [(control return)] comint-kill-input "" matlab-shell-delete-backwards-no-prompt [(backspace)] apply make-comint t comint-mode gud-mode make-local-variable gud-marker-filter gud-matlab-marker-filter gud-find-file gud-matlab-find-file set-process-filter get-buffer-process gud-filter set-process-sentinel gud-sentinel gud-set-buffer matlab-shell-mode comint-mode-map global-map matlab-help-map matlab-shell-command-switches shell-dirtrackp] 7 (#$ . 100620) nil])
#@24 *The MATLAB logo file.
(custom-declare-variable 'matlab-shell-logo '(if (fboundp 'locate-data-file) (locate-data-file "matlab.xpm") (expand-file-name "matlab.xpm" data-directory)) '(#$ . -102573) :group 'matlab-shell :type '(choice (const :tag "None" nil) (file :tag "File" "")))
#@80 Replace the text logo with a real logo.
STR is passed from the commint filter.
(defalias 'matlab-shell-hack-logo #[(str) "\302\303\"\205+\212\304\305e\306#\203&\307\224\307\225|\210\310\311\312\"c\210\313\314``\"\315	!\"\210)\316\317\320\"\207" [str matlab-shell-logo string-match "< M A T L A B >" re-search-backward "^[ 	]+< M A T L A B (R) >" t 0 make-string 16 32 set-extent-begin-glyph make-extent make-glyph remove-hook comint-output-filter-functions matlab-shell-hack-logo] 4 (#$ . 102859)])
#@1007 Run MATLAB as a subprocess in an Emacs buffer.

This mode will allow standard Emacs shell commands/completion to occur
with MATLAB running as an inferior process.  Additionally, this shell
mode is integrated with `matlab-mode', a major mode for editing M
code.

> From an M file buffer:
\<matlab-mode-map>
\[matlab-shell-save-and-go] - Save the current M file, and run it in a MATLAB shell.

> From Shell mode:
\<matlab-shell-mode-map>
\[matlab-shell-last-error] - find location of last MATLAB runtime error in the offending M file.

> From an M file, or from Shell mode:
\<matlab-mode-map>
\[matlab-shell-run-command] - Run COMMAND and show result in a popup buffer.
\[matlab-shell-describe-variable] - Show variable contents in a popup buffer.
\[matlab-shell-describe-command] - Show online documentation for a command in a popup buffer.
\[matlab-shell-apropos] - Show output from LOOKFOR command in a popup buffer.
\[matlab-shell-topic-browser] - Topic browser using HELP.

> Keymap:
\{matlab-mode-map}
(defalias 'matlab-shell-mode #[nil "\306\307\310\311C\312
@\313\314!\210\315\316!\203\317\320\316\"\210\321\322A\"\2037B;\2037\323B!\2037\317\324\325\"\210\326\327!\210\330\331C!\210\332D!\210\326\333!\210\334\326\335!\210E\326\336!\210F\315\337!\203i\337\340!\210\326\341!\210\342\343\344\345#\210\346\343!\204~\347\343\350\"\210\351\343C\345\352$\210\353#C\"\210G\203\200
\354\355\356\"\210\357\360\355\"\210\361\362H\363\"\355\"\210\354\364\365\"\210\357\366\364\"\210\361\362H\367\"\364\"\210\354\370\371\"\210\357\372\370\"\210\361\362H\373\"\370\"\210\354\374\375\"\210\357\376\374\"\210\361\362H\377\"\374\"\210\354\201J\201K\"\210\357\201L\201J\"\210\361\362H\201M\"\201J\"\210\354\201N\201O\"\210\357\201P\201N\"\210\361\362H\201Q\"\201N\"\210\354\201R\201S\"\210\357\201T\201R\"\210\361\362H\201U\"\201R\"\210\354\201V\201W\"\210\357\201X\201V\"\210\361\362H\201Y\"\201V\"\210\315\201Z!\203g
\201Z \210\315\201[!\203w
\201[\201\\!\210\350!Id\350\223\210\201]\201^!\210\201_ \207" [major-mode mode-name comint-prompt-regexp comint-delimiter-argument-list comint-dynamic-complete-functions matlab-shell-echoes matlab-shell-mode "M-Shell" "^\\(K\\|EDU\\)?>> *" [59] (comint-replace-by-expanded-history) require shell fboundp shell-directory-tracker add-hook comint-input-filter-functions string-match "XEmacs" file-readable-p comint-output-filter-functions matlab-shell-hack-logo make-local-variable comment-start "%" use-local-map set-syntax-table font-lock-defaults ((matlab-shell-font-lock-keywords-1 matlab-shell-font-lock-keywords-2 matlab-shell-font-lock-keywords-3) t nil ((95 . "w"))) comint-input-ring-size comint-input=ring-file-name comint-read-input-ring t gud-marker-acc put matlab-shell-menu variable-documentation "MATLAB shell menu" default-boundp set-default nil easy-menu-do-define ("MATLAB" ["Goto last error" matlab-shell-last-error t] "----" ["Stop On Errors" matlab-shell-dbstop-error t] ["Don't Stop On Errors" matlab-shell-dbclear-error t] "----" ["Run Command" matlab-shell-run-command t] ["Describe Variable" matlab-shell-describe-variable t] ["Describe Command" matlab-shell-describe-command t] ["Lookfor Command" matlab-shell-apropos t] ["Topic Browser" matlab-shell-topic-browser t] "----" ["Demos" matlab-shell-demos t] ["Close Current Figure" matlab-shell-close-current-figure t] ["Close Figures" matlab-shell-close-figures t] "----" ["Exit" matlab-shell-exit t]) easy-menu-add defalias gud-break #[#1=(arg) "\301\302\"\207" [arg gud-call "dbstop at %l in %f"] 3 "Set breakpoint at current line." #2="p"] local-set-key "" global-set-key vconcat "" gud-remove #[#1# "\301\302\"\207" [arg gud-call "dbclear at %l in %f"] 3 "Remove breakpoint at current line" #2#] "" "" gud-step #[#1# "\301\302\"\207" [arg gud-call "dbstep %p"] 3 "Step one source line with display." #2#] "" "" gud-cont #[#1# "\301\302\"\207" [arg gud-call "dbcont"] 3 "Continue with display." #2#] "" "" comint-process-echoes emacs-version matlab-shell-logo matlab-shell-mode-map matlab-mode-syntax-table matlab-shell-input-ring-size matlab-shell-history-file matlab-shell-enable-gud-flag gud-key-prefix comint-last-output-start gud-finish #[#1# "\301\302\"\207" [arg gud-call "dbquit"] 3 "Finish executing current function." #2#] "" "" gud-up #[#1# "\301\302\"\207" [arg gud-call "dbup %p"] 3 "Up N stack frames (numeric arg)." #2#] "<" "<" gud-down #[#1# "\301\302\"\207" [arg gud-call "dbdown %p"] 3 "Down N stack frames (numeric arg)." #2#] ">" ">" gud-print #[#1# "\301\302\"\207" [arg gud-call "%e"] 3 "Evaluate M expression at point." #2#] "" "" gud-make-debug-menu gud-overload-functions ((gud-massage-args . gud-matlab-massage-args) (gud-marker-filter . gud-matlab-marker-filter) (gud-find-file . gud-matlab-find-file)) run-hooks matlab-shell-mode-hook matlab-show-version] 5 (#$ . 103369)])
#@52 Regular expression for finding a file line-number.
(defvar gud-matlab-marker-regexp-1 "^K>>" (#$ . 108289))
#@197 Regular expression for finding a file line-number.
Please note: The > character represents the current stack frame, so if there
are several frames, this makes sure we pick the right one to popup.
(defvar gud-matlab-marker-regexp-2 "^> In \\([-.a-zA-Z0-9_/@]+\\) \\((\\w+) \\|\\)at line \\([0-9]+\\)[ \n]+" (#$ . 108404))
#@64 A prefix to scan for to know if output might be scarfed later.
(defvar gud-matlab-marker-regexp-prefix "^> In " (#$ . 108731))
#@53 Regular expression finding where an error occurred.
(defvar gud-matlab-error-regexp "\\(Error in ==>\\|Syntax error in ==>\\|In\\) \\([-@.a-zA-Z_0-9/ \\\\:]+\\).*[\n ][Oa][nt] line \\([0-9]+\\) ?" (#$ . 108864))
#@144 Store the previously returned frame for MATLABs difficult debugging output.
It is reset to nil whenever we are not prompted by the K>> output.
(defvar matlab-last-frame-returned nil (#$ . 109083))
#@52 Set to t if we requested a debugger command trace.
(defvar matlab-one-db-request nil (#$ . 109286))
#@139 Argument massager for starting matlab file.
I don't think I have to do anything, but I'm not sure.
FILE is ignored, and ARGS is returned.
(defalias 'gud-matlab-massage-args #[(file args) "\207" [args] 1 (#$ . 109393)])
#@107 Filters STRING for the Unified Debugger based on MATLAB output.
Swiped ruthlessly from GDB mode in gud.el
(defalias 'gud-matlab-marker-filter #[(string) "\306\307	\"\203 	\310\224H\311U\203\312\313!\210\314\315\313\211	$\202)\n	P\315\316
\313=\203>\307\317\n\"\203>\n\310\225\316O\320
\313=\204t\307\n\"\203t\321\322\n\"\323\n\324\224\324\225O!B\f\n\310
\203f\310\224\202h\310\225OP\n\310\225\316O\202>\203~\202\224
\204\224\307\n\"\203\224\313\325\326!\327\"\210
\320=\203\253\307\330\n\"\203\253\316\315\n\310\225\316O\307\331\n\"\203\303\f\n\310\211\225OP\n\310\225\316O\202\253\307 \n\"\204\347\f\nP\315\307\332\f\"\203\347!\203\347\316\211\"!\333\310!\210\203\356#\f*\207" [garbage string gud-marker-acc frame output matlab-one-db-request "\\(\\|\\[H0\\|\\[H\\[2J\\|H\\[2J\\)" string-match 0 7 beep t replace-match "" nil "db[a-z]+[ \n]+" prompt match-string 1 string-to-int 3 process-send-string get-buffer-process "dbstack\n" "^K?>> $" "^[^\n]*\n" "^>> $" sit-for gud-matlab-marker-regexp-2 matlab-last-frame-returned gud-matlab-marker-regexp-1 gud-comint-buffer gud-matlab-marker-regexp-prefix gud-last-last-frame overlay-arrow-position gud-last-frame] 6 (#$ . 109620)])
#@46 Find file F when debugging frames in MATLAB.
(defalias 'gud-matlab-find-file #[(f) "\212\303\304\"\203\305\224\306I\210\202\307	!\211q\210\310\311!\203$\311 \210\n+\207" [f realfname buf string-match "\\.\\(p\\)$" 1 109 find-file-noselect fboundp gud-make-debug-menu] 4 (#$ . 110871)])
#@128 Delete one char backwards without destroying the matlab prompt.
Optional argument ARG describes the number of chars to delete.
(defalias 'matlab-shell-delete-backwards-no-prompt #[(&optional arg) "\212\303 \210\304\305!\203\306\225\202`)\250\203[\202\307\211`	\\X\203,\310	!\202/\311\312!*\207" [arg numchars promptend beginning-of-line looking-at "K?>> " 0 -1 delete-char error "Beginning of line"] 4 (#$ . 111175) "P"])
#@53 Switch to the buffer containing the matlab process.
(defalias 'matlab-show-matlab-shell-buffer #[nil "\302\302Q\303	!\203\304	!\202\305\306!)\207" [matlab-shell-buffer-name msbn "*" get-buffer switch-to-buffer-other-window message "There is not an active MATLAB process."] 3 (#$ . 111617) nil])
#@54 Keep track of parameters passed to the MATLAB shell.
(defvar matlab-shell-save-and-go-history '("()") (#$ . 111924))
#@108 Add string to the input-ring and run comint-input-filter-functions on
it, as is done in comint-send-input.
(defalias 'matlab-shell-add-to-input-history #[(string) "	!\203$\n\203\306!\203\307!\204\310\311\"	\230\204$\312	\"\210\313\314	\315P\"\210\316\305!\2033\f\317\211\207" [comint-input-filter string comint-input-ignoredups comint-input-ring comint-input-ring-index comint-save-input-ring-index ring-p ring-empty-p ring-ref 0 ring-insert run-hook-with-args comint-input-filter-functions "\n" boundp nil] 4 (#$ . 112048)])
#@54 Save this M file, and evaluate it in a MATLAB shell.
(defalias 'matlab-shell-save-and-go #[nil "\306=\204\n\307\310!\210\311p!\204\312\313!\210\314\315\311 !!\316	\316Q\317\320 \210\212eb\210\321\210\322\323!\210\324\325!)\203>\326\327
@\305#\330 \203H\331 \202{\332!\204Q\333 \210\334\335\"\203b\336\334\335\"!\210\202i\337\316	\316Q!\210\f\340\nQ$\341$!\210\342$\343P!)+\207" [major-mode matlab-shell-buffer-name param msbn fn-name matlab-shell-save-and-go-history matlab-mode error "Save and go is only useful in a MATLAB buffer!" buffer-file-name call-interactively write-file file-name-sans-extension file-name-nondirectory "*" "" save-buffer nil forward-sexp -1 looking-at "([a-zA-Z]" read-string "Parameters: " matlab-with-emacs-link matlab-eei-run get-buffer matlab-shell get-buffer-window t select-window switch-to-buffer " " matlab-shell-add-to-input-history matlab-shell-send-string "\n" cmd] 4 (#$ . 112596) nil])
#@110 Run region from BEG to END and display result in MATLAB shell.
This command requires an active MATLAB shell.
(defalias 'matlab-shell-run-region #[(beg end) "	V\203\306	\n)\307	\"\310P\311\312\"\203-\313\211\224O\310\313\225\306OQ\202)\306\211\314\315 \203D\316	\"\202{\212\317 \211q\210\320 \204U\321\322!\210\323 \210\324!\210`\325 {`\325 |\210\326!\210
c\210)q\210db\210\327!,\207" [beg end mid str inhibit-field-text-motion lastcmd nil buffer-substring-no-properties "\n" string-match "\n\\s-*\n" 0 t matlab-with-emacs-link matlab-eei-eval-region matlab-shell-buffer-barf-not-running matlab-on-prompt-p error "MATLAB shell must be non-busy to do that" beginning-of-line re-search-forward matlab-point-at-eol matlab-shell-send-string display-buffer msbn command comint-prompt-regexp] 6 (#$ . 113550) "r"])
#@165 Get the word closest to point, but do not change position.
Has a preference for looking backward when not directly on a symbol.
Snatched and hacked from dired-x.el
(defalias 'matlab-read-word-at-point #[nil "\304\305 \306 \307\212\310\311\312Q!\204\"\313\314Q\nx\210o\204\"\315u\210\316\311\312Q\317g!\"\247\203<\nx\210`	w\210\202>``{-\207" [start eol bol word-chars "a-zA-Z0-9_" matlab-point-at-bol matlab-point-at-eol nil looking-at "[" "]" "^" "{}()[]" -1 string-match char-to-string] 4 (#$ . 114404)])
#@44 Get the line under point, if command line.
(defalias 'matlab-read-line-at-point #[nil "\304=\203\"\212\305\306 \210\307\n\260
!\204\310\202 \311\n!\210`\312 {*\207\212\212\313y\210\314 )\2033\313y\210\202#\306 \210`\314 \203C\315y\210\2028\316\210`{*\207" [major-mode inhibit-field-text-motion comint-prompt-regexp start matlab-shell-mode t beginning-of-line looking-at "" search-forward-regexp matlab-point-at-eol -1 matlab-lattr-cont 1 nil] 2 (#$ . 114932)])
#@42 Return number of non-empty lines in STR.
(defalias 'matlab-non-empty-lines-in-string #[(str) "\303\211\304\305\n#\203	T\303\225\202	*\207" [start count str 0 string-match "^.+$"] 4 (#$ . 115412)])
#@129 Print output to temp buffer, or a message if empty string.
BUFFER is the buffer to output to, and OUTPUT is the text to insert.
(defalias 'matlab-output-to-temp-buffer #[(buffer output) "\303!\211\304U\203\305\306!\2024	\307U\203&\310\311\"\210\305\304\224\304\225O!\2024\n\220\312!\221\210\212\nq\210\313 ))\207" [output lines-found buffer matlab-non-empty-lines-in-string 0 message "(MATLAB command completed with no output)" 1 string-match "^.+$" princ matlab-shell-help-mode] 5 (#$ . 115625)])
#@91 Run COMMAND and display result in a buffer.
This command requires an active MATLAB shell.
(defalias 'matlab-shell-run-command #[(command) "\302!\303\304	\")\207" [command doc matlab-shell-collect-command-output matlab-output-to-temp-buffer "*MATLAB Help*"] 3 (#$ . 116139) (list (read-from-minibuffer "MATLAB command line: " (cons (matlab-read-line-at-point) 0)))])
#@169 Get the contents of VARIABLE and display them in a buffer.
This uses the WHOS (MATLAB 5) command to find viable commands.
This command requires an active MATLAB shell.
(defalias 'matlab-shell-describe-variable #[(variable) "\302\303P!\304\305	\")\207" [variable doc matlab-shell-collect-command-output "whos " matlab-output-to-temp-buffer "*MATLAB Help*"] 3 (#$ . 116514) (list (read-from-minibuffer "MATLAB variable: " (cons (matlab-read-word-at-point) 0)))])
#@173 Describe COMMAND textually by fetching it's doc from the MATLAB shell.
This uses the lookfor command to find viable commands.
This command requires an active MATLAB shell.
(defalias 'matlab-shell-describe-command #[(command) "\302\303P!\304\305	\")\207" [command doc matlab-shell-collect-command-output "help " matlab-output-to-temp-buffer "*MATLAB Help*"] 3 (#$ . 116984) (byte-code "\302 \303\304	\203\305\306	\"\202\307!\211\310\230\203	C\202!C*\207" [val fn matlab-function-called-at-point nil read-string format "Describe function (default %s): " "Describe function: " ""] 5)])
#@117 Look for any active commands in MATLAB matching MATLABREGEX.
This uses the lookfor command to find viable commands.
(defalias 'matlab-shell-apropos #[(matlabregex) "\302\303P!\304\305	\")\207" [matlabregex ap matlab-shell-collect-command-output "lookfor " matlab-output-to-temp-buffer "*MATLAB Apropos*"] 3 (#$ . 117587) (list (read-from-minibuffer "MATLAB command subexpression: " (cons (matlab-read-word-at-point) 0)))])
#@41 Return t if we MATLAB can accept input.
(defalias 'matlab-on-prompt-p #[nil "\212\302db\210\303 \210\304	!*\207" [inhibit-field-text-motion comint-prompt-regexp t beginning-of-line looking-at] 2 (#$ . 118018)])
#@46 Return t if we MATLAB is on an empty prompt.
(defalias 'matlab-on-empty-prompt-p #[nil "\212\302db\210\303 \210\304	\305P!*\207" [inhibit-field-text-motion comint-prompt-regexp t beginning-of-line looking-at "\\s-*$"] 3 (#$ . 118236)])
#@60 Return a running MATLAB buffer iff it is currently active.
(defalias 'matlab-shell-buffer-barf-not-running #[nil "\300 \206\301\302!\207" [matlab-shell-active-p error "You need to run the command `matlab-shell' to do that!"] 2 (#$ . 118479)])
#@247 If there is a MATLAB shell, run the MATLAB COMMAND and return it's output.
It's output is returned as a string with no face properties.  The text output
of the command is removed from the MATLAB buffer so there will be no
indication that it ran.
(defalias 'matlab-shell-collect-command-output #[(command) "\306 \307\211\211\310\212\fq\210\311 \204\312\313!\210db\210\314 \210\315
!\210`\316 {`\316 |\210`\317\320p!\321P\"\210\322\323!\210db\210`Y\204J\324 \204Z\325\320p!!\210db\210\322\326!\210\202?\322\327!\210\212b\210\314 \210\330\212b\210\314 \210\331y\210`)\212db\210\314 \210`)\"d|\210)	c\210)\n-\207" [inhibit-field-text-motion lastcmd str pos msbn comint-prompt-regexp matlab-shell-buffer-barf-not-running nil t matlab-on-prompt-p error "MATLAB shell must be non-busy to do that" beginning-of-line re-search-forward matlab-point-at-eol comint-send-string get-buffer-process "\n" message "MATLAB ... Executing command." matlab-on-empty-prompt-p accept-process-output "MATLAB reading..." "MATLAB reading...done" buffer-substring-no-properties 1 command] 5 (#$ . 118731)])
#@54 Send STRING to the currently running matlab process.
(defalias 'matlab-shell-send-string #[(string) "\204\303p!db\210\nc\210\304	!`\305\223\210)\306\303p!\n\"\207" [matlab-shell-echoes proc string get-buffer-process process-mark nil comint-send-string] 3 (#$ . 119836)])
#@144 In the MATLAB interactive buffer, find the last MATLAB error, and go there.
To reference old errors, put the cursor just after the error text.
(defalias 'matlab-shell-last-error #[nil "\303\211\212\303\210\304\n\303\305#\204\306\307!\210\310\311\224\311\225\"\310\312\224\312\225\")\313	!\210\314\315!!*\207" [el eb gud-matlab-error-regexp nil re-search-backward t error "No errors found!" buffer-substring-no-properties 2 3 find-file-other-window goto-line string-to-int] 4 (#$ . 120118) nil])
#@17 Stop on errors.
(defalias 'matlab-shell-dbstop-error #[nil "\300\301p!\302\"\207" [comint-send-string get-buffer-process "dbstop if error\n"] 3 (#$ . 120627) nil])
#@23 Don't stop on errors.
(defalias 'matlab-shell-dbclear-error #[nil "\300\301p!\302\"\207" [comint-send-string get-buffer-process "dbclear if error\n"] 3 (#$ . 120797) nil])
#@15 MATLAB demos.
(defalias 'matlab-shell-demos #[nil "\300\301p!\302\"\207" [comint-send-string get-buffer-process "demo\n"] 3 (#$ . 120975) nil])
#@25 Close any open figures.
(defalias 'matlab-shell-close-figures #[nil "\300\301p!\302\"\207" [comint-send-string get-buffer-process "close all\n"] 3 (#$ . 121125) nil])
#@23 Close current figure.
(defalias 'matlab-shell-close-current-figure #[nil "\300\301p!\302\"\207" [comint-send-string get-buffer-process "delete(gcf)\n"] 3 (#$ . 121298) nil])
#@20 Exit MATLAB shell.
(defalias 'matlab-shell-exit #[nil "\300\301p!\302\"\210\303\304!\207" [comint-send-string get-buffer-process "exit\n" kill-buffer nil] 3 (#$ . 121478) nil])
#@27 *MATLAB shell topic hook.
(custom-declare-variable 'matlab-shell-topic-mode-hook 'nil '(#$ . -121661) :group 'matlab-shell :type 'hook)
#@60 The currently viewed topic in a MATLAB shell topic buffer.
(defvar matlab-shell-topic-current-topic nil (#$ . 121803))
#@115 Create a topic browser by querying an active MATLAB shell using HELP.
Maintain state in our topic browser buffer.
(defalias 'matlab-shell-topic-browser #[nil "\302\303!\204\304\305\303!\306	!\210\307\230?\205\310 \210\311\307!)\207" [matlab-shell-topic-current-topic b get-buffer "*MATLAB Topic*" nil get-buffer-create switch-to-buffer "" matlab-shell-topic-mode matlab-shell-topic-browser-create-contents] 2 (#$ . 121929) nil])
#@56 These are keywords we also want to put mouse-faces on.
(defvar matlab-shell-topic-mouse-face-keywords '(("^\\(\\w+/\\w+\\)[ 	]+-" 1 font-lock-reference-face) ("^[ 	]+\\(\\w+\\)[ 	]+-" 1 font-lock-function-name-face) ("[ 	]+See also " ("\\(\\w+\\)\\([,.]\\| and\\|$\\) *" nil nil (1 font-lock-reference-face)))) (#$ . 122371))
#@57 Keywords useful for highlighting a MATLAB TOPIC buffer.
(defvar matlab-shell-topic-font-lock-keywords (append matlab-shell-topic-mouse-face-keywords '(("^[^:\n]+:$" 0 font-lock-keyword-face) ("^[ 	]+\\([^.\n]+[a-zA-Z.]\\)$" 1 'underline))) (#$ . 122703))
#@36 Keywords for regular help buffers.
(defvar matlab-shell-help-font-lock-keywords (append matlab-shell-topic-mouse-face-keywords '(("[ 	]\\([A-Z]+\\)\\s-*=\\s-*\\([A-Z]+[0-9]*\\)(" (1 font-lock-variable-name-face) (2 font-lock-function-name-face)) ("[ 	]\\([A-Z]+[0-9]*\\)(" (1 font-lock-function-name-face)) ("[ 	]\\([A-Z]+[0-9]*\\)(" ("'?\\(\\w+\\)'?\\([,)]\\) *" nil nil (1 font-lock-variable-name-face))) ("\\<\\([A-Z]+[0-9]*\\)\\>" 1 font-lock-reference-face))) (#$ . 122964))
(byte-code "\302\303!\204\304\303\305\"\210\306\307N\204\310\306\307\311#\210\312\313!\204#\310\313\314\315#\210\313B\316\313!\2043\317\313\320 \"\210\312\321!\204?\310\321\314\315#\210\321B\316\321!\204O\317\321\322 \"\210\310\301\314\315#\210\301B\316\301!\204i\317\301\323\301\324\"\210	\"\210\310\315\325\303#\207" [current-load-list matlab-shell-help-mode-abbrev-table fboundp view-major-mode defalias view-mode matlab-shell-help-mode-hook variable-documentation put "Hook run when entering M-Help mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp matlab-shell-help-mode-map definition-name matlab-shell-help-mode default-boundp set-default make-sparse-keymap matlab-shell-help-mode-syntax-table make-syntax-table define-abbrev-table nil derived-mode-parent] 5)
#@154 Major mode for viewing MATLAB help text.
Entry to this mode runs the normal hook `matlab-shell-help-mode-hook'.

Commands:
\{matlab-shell-help-mode-map}
(defalias 'matlab-shell-help-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!\210\325\f!\210 !\306\326!\210\327\330\331!\203d\203d\204d\332\333!\210\334\"\"\210\335 \210)\336\337!\207" [delay-mode-hooks major-mode mode-name matlab-shell-help-mode-map matlab-shell-help-mode-syntax-table parent make-local-variable t view-major-mode matlab-shell-help-mode "M-Help" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table use-local-map set-syntax-table font-lock-defaults ((matlab-shell-help-font-lock-keywords) t nil ((95 . "w"))) boundp global-font-lock-mode font-lock-mode 1 easy-menu-add matlab-shell-topic-mouse-highlight-subtopics run-mode-hooks matlab-shell-help-mode-hook matlab-shell-help-mode-abbrev-table local-abbrev-table matlab-shell-help-mode-menu] 6 (#$ . 124324) nil])
(byte-code "\303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312	#\210\313\314\n\"\203(\303\315\316#\210\202.\303\317\316#\210\303\207" [matlab-shell-help-mode-map matlab-help-map emacs-version define-key [return] matlab-shell-topic-choose "t" matlab-shell-topic-browser "q" bury-buffer [(control h) (control m)] string-match "XEmacs" [button2] matlab-shell-topic-click [mouse-2]] 4)
#@25 MATLAB shell topic menu
(defvar matlab-shell-help-mode-menu nil (#$ . 125888))
(byte-code "\303\304\305\306$\210\307\310N\204\311\307\310\312#\210\313\314!\204\311\314\315\316#\210\314	B\317\314!\204/\320\314\321 \"\210\313\322!\204;\311\322\315\316#\210\322	B\317\322!\204K\320\322\323 \"\210\311\302\315\316#\210\302	B\317\302!\204e\320\302\324\302\325\"\210\n\"\210\311\316\326\327#\207" [matlab-shell-help-mode-map current-load-list matlab-shell-topic-mode-abbrev-table easy-menu-do-define matlab-shell-help-mode-menu "MATLAB shell topic menu" ("MATLAB Help" ["Describe This Command" matlab-shell-topic-choose t] "----" ["Describe Command" matlab-shell-describe-command t] ["Describe Variable" matlab-shell-describe-variable t] ["Command Apropos" matlab-shell-apropos t] ["Topic Browser" matlab-shell-topic-browser t] "----" ["Exit" bury-buffer t]) matlab-shell-topic-mode-hook variable-documentation put "Hook run when entering M-Topic mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp matlab-shell-topic-mode-map definition-name matlab-shell-topic-mode default-boundp set-default make-sparse-keymap matlab-shell-topic-mode-syntax-table make-syntax-table define-abbrev-table nil derived-mode-parent matlab-shell-help-mode] 5)
#@370 Major mode for browsing MATLAB HELP topics.
The output of the MATLAB command HELP with no parameters creates a listing
of known help topics at a given installation.  This mode parses that listing
and allows selecting a topic and getting more help for it.
Entry to this mode runs the normal hook `matlab-shell-topic-mode-hook'.

Commands:
\{matlab-shell-topic-mode-map}
(defalias 'matlab-shell-topic-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!\210\325\f!\210\326\327\330 \"\203W\331!\332\"\"\210)\333\334!\207" [delay-mode-hooks major-mode mode-name matlab-shell-topic-mode-map matlab-shell-topic-mode-syntax-table parent make-local-variable t matlab-shell-help-mode matlab-shell-topic-mode "M-Topic" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table use-local-map set-syntax-table ((matlab-shell-topic-font-lock-keywords) t t ((95 . "w"))) string-match "XEmacs" matlab-shell-topic-highlight-line easy-menu-add run-mode-hooks matlab-shell-topic-mode-hook matlab-shell-topic-mode-abbrev-table local-abbrev-table font-lock-defaults emacs-version mode-motion-hook matlab-shell-topic-mode-menu] 6 (#$ . 127229) nil])
#@25 MATLAB shell topic menu
(defvar matlab-shell-topic-mode-menu nil (#$ . 128578))
(easy-menu-do-define 'matlab-shell-topic-mode-menu matlab-shell-topic-mode-map "MATLAB shell topic menu" '("MATLAB Topic" ["Select This Topic" matlab-shell-topic-choose t] ["Top Level Topics" matlab-shell-topic-browser t] "----" ["Exit" bury-buffer t]))
#@56 Fill in a topic browser with the output from SUBTOPIC.
(defalias 'matlab-shell-topic-browser-create-contents #[(subtopic) "\303\304!\210\305 \210\306\307P!c\210eb\210\310y\210e`|\210\311\312\n\"\204$\313 \210\303\310!\207" [subtopic matlab-shell-topic-current-topic emacs-version toggle-read-only -1 erase-buffer matlab-shell-collect-command-output "help " 1 string-match "XEmacs" matlab-shell-topic-mouse-highlight-subtopics] 3 (#$ . 128918)])
#@98 Click on an item in a MATLAB topic buffer we want more information on.
Must be bound to event E.
(defalias 'matlab-shell-topic-click #[(e) "\301!\210\302 \207" [e mouse-set-point matlab-shell-topic-choose] 2 (#$ . 129373) "e"])
#@212 Choose the topic to expand on that is under the cursor.
This can fill the topic buffer with new information.  If the topic is a
command, use `matlab-shell-describe-command' instead of changing the topic
buffer.
(defalias 'matlab-shell-topic-choose #[nil "\303\211`\212\304 \210\305\306!\203\307\310!\202S\305\311!\203$\307\310!\202S\305\312!\204<\212\313u\210\305\314!)\204<\315\316!\210\202Sb\210\317v\210\305\320!\204O\315\321!\210\202S\307\310!)\322\323\n\206[	\"\210\n\203h\324\n\227!\202k\325	!+\207" [p fun topic nil beginning-of-line looking-at "^\\w+/\\(\\w+\\)[ 	]+-" match-string 1 "^[ 	]+\\(\\(\\w\\|_\\)+\\)[ 	]+-" "^[ 	]+See also" -2 ",$" error "You did not click on a subtopic, function or reference" -1 "\\(\\(\\w\\|_\\)+\\)\\([.,]\\| and\\|\n\\)" "You must click on a reference" message "Opening item %s..." matlab-shell-topic-browser-create-contents matlab-shell-describe-command] 3 (#$ . 129609) nil])
#@61 Put a `mouse-face' on all clickable targets in this buffer.
(defalias 'matlab-shell-topic-mouse-highlight-subtopics #[nil "\212\211\205Qeb\210\303	@@\304\305#\203I	@A@\211\247\203*\306\n\224\n\225\307\310$\210\202E\303\n@\304\305#\203E\306\311\n8@\224\311\n8@\225\307\310$\210\202*)\202\n	A\211\204\304*\207" [matlab-shell-topic-mouse-face-keywords el cd re-search-forward nil t put-text-property mouse-face highlight 3] 6 (#$ . 130555)])
#@107 A value of `mode-motion-hook' which will highlight topics under the mouse.
EVENT is the user mouse event.
(defalias 'matlab-shell-topic-highlight-line #[(event) "\304!\211\205\305!	\205	=?\205\212\306\213)*\207" [event buffer point mouse-grabbed-buffer event-buffer event-point ((byte-code "q\210\304	!\210\n\204\305!\207\nb\210\306\210`\307 \210\310\311!\204&\310\312!\203,\313`\n#\207\305!\207" [buffer event point mode-motion-extent mode-motion-ensure-extent-ok detach-extent nil beginning-of-line looking-at "^\\w+/\\(\\w+\\)[ 	]+-" "^[ 	]+\\(\\(\\w\\|_\\)+\\)[ 	]+-" set-extent-endpoints] 4))] 3 (#$ . 131014)])
#@48 Create the path in `matlab-mode-install-path'.
(defalias 'matlab-mode-determine-mfile-path #[nil "\304!\211\2042\n\211\2031	\2041\305@\306Q!\203*\307@\306Q!@\204*@A\211\204)	\203G\310\311	\"\203C	\312\211\224O	\313P	)\207" [matlab-shell-command path exec-path pl file-name-directory file-exists-p "/" file-attributes string-match "/bin$" 0 "/toolbox/"] 5 (#$ . 131658)])
#@272 Base path pointing to the locations of all the m files used by matlab.
All directories under each element of `matlab-mode-install-path' are
checked, so only top level toolbox directories need be added.
Paths should be added in the order in which they should be searched.
(custom-declare-variable 'matlab-mode-install-path '(list (matlab-mode-determine-mfile-path)) '(#$ . 132058) :group 'matlab-shell :type '(repeat (string :tag "Path: ")))
#@52 Return the pathname or nil of PATH under FILENAME.
(defalias 'matlab-find-file-under-path #[(path filename) "\304	P!\203\f	P\207\305!\205\306\307\310\307$\310\211\203J\n\204J\311@!@\203C\312\313@\"\204C\312\314@\"\204C\315@\316P	\"A\211\204\n*\207" [path filename found dirs file-exists-p file-directory-p directory-files t nil file-attributes string-match "/\\.\\.?$" "@" matlab-find-file-under-path "/"] 6 (#$ . 132505)])
#@238 Find FILENAME on the current MATLAB path.
The MATLAB path is determined by `matlab-mode-install-path' and the
current directory.  You must add user-installed paths into
`matlab-mode-install-path' if you would like to have them included.
(defalias 'matlab-find-file-on-path #[(filename) "\305\230\203\n\306\307!\210\310\311\"\204\312P\313	\314\fP!\203%\fP\204F\n\203F\n@;\203@\315\316\n@#\210\317\n@\"\nA\202%\203P\320!\202T\306\321\"*\207" [filename matlab-mode-install-path dirs fname default-directory "" error "You must specify an M file" string-match "\\.m$" ".m" nil file-exists-p message "Searching for %s in %s" matlab-find-file-under-path find-file "File %s not found on any known paths.  Check `matlab-mode-install-path'"] 4 (#$ . 132959) (list (let ((default (matlab-read-word-at-point))) (if default (let ((s (read-string (concat "File (default " default "): ")))) (if (string= s "") default s)) (read-string "File: "))))])
#@60 Find the file clicked on with event E on the current path.
(defalias 'matlab-find-file-click #[(e) "\302!\210\303 \211\204\304\305!\210\306	!)\207" [e f mouse-set-point matlab-read-word-at-point error "To find an M file, click on a word" matlab-find-file-on-path] 3 (#$ . 133927) "e"])
#@66 Display type and attributes of current line.  Used in debugging.
(defalias 'matlab-show-line-info #[nil "\303\304\305 !\306 \211\307\310	@!\311\312	A@!\313\312!\260\314 \203&\n\315P\316 \203/\n\317P\320\n!+\207" [nexti indent msg "line-info:" matlab-calculate-indentation current-indentation matlab-next-line-indentation " Line type: " symbol-name " This Line: " int-to-string " Next Line: " matlab-lattr-cont " w/cont" matlab-lattr-comm " w/comm" message] 9 (#$ . 134223) nil])
(provide 'matlab)