;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301\302\303\304\305\304\306\307\310&	\210\300\311\302\312\313\314\307\301&\210\300\315\302\316\313\314\307\301&\210\317\320\321\322\323DD\324\325\326\327\330\307\311&	\210\317\331\321\322\332DD\333\325\334\335\336\307\311&	\210\317\337\321\322\340DD\341\325\342\327\343\307\311&	\210\317\344\321\322\345DD\346\325\342\327\343\307\311&	\210\317\347\321\322\350DD\351\325\342\327\343\307\311&	\210\317\352\321\322\353DD\354\325\342\327\343\307\311&	\210\317\355\321\322\356DD\357\325\360\327\361\307\311&	\210\317\362\321\322\363DD\364\325\342\327\343\307\311\307\315&\210\317\365\321\322\366DD\367\370\371\325\334\327\372\307\315&\210\317\373\321\322\374DD\375\370\371\325\376\327\372\307\315&\210\317\377\321\322\201@DD\201A\370\201B\325\376\327\372\307\311&\210\317\201C\321\322\201DDD\201E\325\342\327\343\307\311&	\210\317\201F\321\322\201GDD\201H\325\342\327\343\307\311&	\210\317\201I\321\322\201JDD\201K\325\334\327\201L\307\315&	\210\317\201M\321\322\201NDD\201O\325\342\327\343\307\311&	\210\317\201P\321\322\201QDD\201R\325\326\327\330\307\301&	\210\317\201S\321\322\201TDD\201U\325\326\327\330\307\301&	\210\317\201V\321\322\201WDD\201X\325\334\327\201Y\307\301&	\210\317\201Z\321\322\201[DD\201\\\325\334\327\372\307\315&	\210\317\201]\321\322\201^DD\201_\325\326\327\330\307\301&	\210\317\201`\321\322\201aDD\201b\325\334\327\372\307\301&	\210\317\201c\321\322\201dDD\201e\325\334\327\372\307\301&	\210\317\201f\321\322\201gDD\201h\325\342\327\343\307\301&	\210\317\201i\321\322\201jDD\201k\325\326\327\330\307\301&	\210\317\201l\321\322\201mDD\201n\325\342\327\343\201o\201p\201q\201r\370\201s\307\301&\210\201t\201l!\210\317\201u\321\322\201vDD\201w\325\201x\307\301&\207" [custom-declare-group fortran nil "Major mode for editing fixed format Fortran code." :link (custom-group-link :tag "Font Lock Faces group" font-lock-faces) (custom-manual "(emacs)Fortran") :group languages fortran-indent "Indentation variables in Fortran mode." :prefix "fortran-" fortran-comment "Comment-handling variables in Fortran mode." custom-declare-variable fortran-tab-mode-default funcall function #[0 "\300\207" [nil] 1 #1=""] "Default tabbing/carriage control style for empty files in Fortran mode.\nA non-nil value specifies tab-digit style of continuation control.\nA value of nil specifies that continuation lines are marked\nwith a character in column 6." :type boolean :safe booleanp fortran-tab-mode-string #[0 "\300\301\302\303\304\305\306\307\310\311\"&\207" [propertize "/t" help-echo "This buffer is in Fortran TAB mode" mouse-face mode-line-highlight local-map make-mode-line-mouse-map mouse-1 #[0 "\300\301!\207" [describe-variable fortran-tab-mode-string] 2 nil nil]] 10 #1#] "String to appear in mode line in TAB format buffers.\nSee Info node `(emacs)ForIndent Cont'." string :risky t fortran-do-indent #[0 "\300\207" [3] 1 #1#] "Extra indentation applied to DO blocks." integer integerp fortran-if-indent #[0 "\300\207" [3] 1 #1#] "Extra indentation applied to IF, SELECT CASE and WHERE blocks." fortran-structure-indent #[0 "\300\207" [3] 1 #1#] "Extra indentation applied to STRUCTURE, UNION, MAP and INTERFACE blocks." fortran-continuation-indent #[0 "\300\207" [5] 1 #1#] "Extra indentation applied to continuation lines." fortran-comment-indent-style #[0 "\300\207" [fixed] 1 #1#] "How to indent comments.\nnil forces comment lines not to be touched;\n`fixed' indents to `fortran-comment-line-extra-indent' columns beyond\n  `fortran-minimum-statement-indent-fixed' (if `indent-tabs-mode' nil), or\n  `fortran-minimum-statement-indent-tab' (if `indent-tabs-mode' non-nil);\n`relative' indents to current Fortran indentation plus\n  `fortran-comment-line-extra-indent'." (radio (const :tag "Untouched" nil) (const fixed) (const relative)) #[257 "\211\300>\207" [(nil fixed relative)] 3 "\n\n(fn VALUE)"] fortran-comment-line-extra-indent #[0 "\300\207" [0] 1 #1#] "Amount of extra indentation for text within full-line comments." fortran-comment-line-start #[0 "\300\207" ["C"] 1 #1#] "Delimiter inserted to start new full-line comment.\nYou might want to change this to \"*\", for instance; or \"!\" to\nallow trailing comments on a line." :version "21.1" stringp fortran-comment-line-start-skip #[0 "\300\207" ["^[CcDd*!]\\(\\([^ 	\n]\\)\\2+\\)?[ 	]*"] 1 #1#] "Regexp to match the start of a full-line comment." regexp fortran-directive-re #[0 "\300\207" ["^[ 	]*#.*"] 1 #1#] "Regexp to match a directive line.\nThe matching text will be fontified with `font-lock-preprocessor-face'.\nThe matching line will be given zero indentation." "22.1" fortran-minimum-statement-indent-fixed #[0 "\300\207" [6] 1 #1#] "Minimum statement indentation for fixed format continuation style." fortran-minimum-statement-indent-tab #[0 "\301]\207" [tab-width 6] 2 #1#] "Minimum statement indentation for TAB format continuation style." fortran-comment-indent-char #[0 "\300\207" [" "] 1 #1#] "Single-character string inserted for Fortran comment indentation.\nNormally a space." #[257 "\300
!\206\211;\205\211G\301U\207" [characterp 1] 3 "\n\n(fn VALUE)"] fortran-line-number-indent #[0 "\300\207" [1] 1 #1#] "Maximum indentation for Fortran line numbers.\n5 means right-justify them within their five-column field." fortran-check-all-num-for-matching-do #[0 "\300\207" [nil] 1 #1#] "Non-nil causes all numbered lines to be treated as possible DO loop ends." fortran-blink-matching-if #[0 "\300\207" [nil] 1 #1#] "Non-nil causes \\[fortran-indent-line] on ENDIF to blink on matching IF.\nAlso, from an ENDDO statement blink on matching DO [WHILE] statement." fortran-continuation-string #[0 "\300\207" ["$"] 1 #1#] "Single-character string used for Fortran continuation lines.\nIn fixed format continuation style, this character is inserted in\ncolumn 6 by \\[fortran-split-line] to begin a continuation line.\nAlso, if \\[fortran-indent-line] finds this at the beginning of a\nline, it will convert the line into a continuation line of the\nappropriate style.  Normally \"$\"." #[257 "\211;\205	\211G\300U\207" [1] 3 "\n\n(fn VALUE)"] fortran-comment-region #[0 "\300\207" ["c$$$"] 1 #1#] "String inserted by \\[fortran-comment-region] at start of each line in region." fortran-electric-line-number #[0 "\300\207" [t] 1 #1#] "Non-nil causes line numbers to be moved to the correct column as typed." fortran-column-ruler-fixed #[0 "\300\207" ["0   4 6  10        20        30        40        50        60        70\n[   ]|{   |    |    |    |    |    |    |    |    |    |    |    |    |}\n"] 1 #1#] "String displayed above current line by \\[fortran-column-ruler].\nThis variable is used in fixed format mode.\nSee the variable `fortran-column-ruler-tab' for TAB format mode." fortran-column-ruler-tab #[0 "\300\207" ["0       810        20        30        40        50        60        70\n[   ]|  { |    |    |    |    |    |    |    |    |    |    |    |    |}\n"] 1 #1#] "String displayed above current line by \\[fortran-column-ruler].\nThis variable is used in TAB format mode.\nSee the variable `fortran-column-ruler-fixed' for fixed format mode." fortran-analyze-depth #[0 "\300\207" [100] 1 #1#] "Number of lines to scan to identify fixed or TAB format style." fortran-break-before-delimiters #[0 "\300\207" [t] 1 #1#] "Non-nil causes filling to break lines before delimiters.\nDelimiters are characters matching the regexp `fortran-break-delimiters-re'." fortran-line-length #[0 "\300\207" [72] 1 #1#] "Maximum number of characters in a line of fixed-form Fortran code.\nCharacters beyond this point are treated as comments.  Setting\nthis variable directly (after fortran mode is loaded) does not\ntake effect.  Use either \\[customize] (which affects all Fortran\nbuffers and the default) or the function\n`fortran-line-length' (which can also operate on just the current\nbuffer).  This corresponds to the g77 compiler option\n`-ffixed-line-length-N'." :initialize custom-initialize-default :set #[514 "\300
\301\"\207" [fortran-line-length t] 5 "\n\n(fn SYMBOL VALUE)"] "23.1" make-variable-buffer-local fortran-mode-hook #[0 "\300\207" [nil] 1 #1#] "Hook run when entering Fortran mode." hook] 16)
#@236 Regexp matching delimiter characters at which lines may be broken.
There are certain tokens comprised entirely of characters
matching this regexp that should not be split, and these are
specified by the constant `fortran-no-break-re'.
(defconst fortran-break-delimiters-re "[-+*/><=, 	]" (#$ . 8296))
#@265 Regexp specifying where not to break lines when filling.
This regexp matches certain tokens comprised entirely of
characters matching the regexp `fortran-break-delimiters-re' that should
not be split by filling.  Each element is assumed to be two
characters long.
(defconst fortran-no-break-re "\\(\\*\\*\\|/[/=]\\|<=\\|=[=>]\\|>=\\)" (#$ . 8604))
#@47 Regexp matching the start of an IF statement.
(defconst fortran-if-start-re "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?if[ 	]*(" (#$ . 8958))
#@65 Regexp matching the start of a subprogram, from the line start.
(defconst fortran-start-prog-re "^[ 	]*\\(program\\|subroutine\\|function\\|[ 	a-z0-9*()]*[ 	]+function\\|\\(block[ 	]*data\\)\\)" (#$ . 9095))
#@51 Regexp possibly matching the end of a subprogram.
(defconst fortran-end-prog-re1 "end\\([ 	]*\\(program\\|subroutine\\|function\\|block[ 	]*data\\)\\>\\([ 	]*\\(\\sw\\|\\s_\\)+\\)?\\)?" (#$ . 9309))
#@105 Regexp possibly matching the end of a subprogram, from the line start.
See also `fortran-end-prog-re1'.
(defconst fortran-end-prog-re (concat "^[ 	0-9]*" fortran-end-prog-re1) (#$ . 9515))
#@32 Regexp matching Fortran types.
(defconst fortran-type-types (byte-code "\300\301\302\303\304\305\306\307\310\311\312\"\311\313\"%\266\203\314\"!\315#\316Q\207" ["\\<" mapconcat identity split-string regexp-opt ("character" "byte" "integer" "logical" "none" "real" "complex" "double precision" "double complex") ("structure" "union" "map") ("record" "dimension" "parameter" "common" "save" "external" "intrinsic" "data" "equivalence") append mapcar #[257 "\300
P\207" ["implicit "] 3 "\n\n(fn X)"] #[257 "\300
P\207" ["end "] 3 "\n\n(fn X)"] paren "[ 	]*" "\\>"] 14) (#$ . 9710))
#@46 Subdued level highlighting for Fortran mode.
(defvar fortran-font-lock-keywords-1 '(("\\<\\(block[ 	]*data\\|call\\|entry\\|function\\|program\\|subroutine\\)\\>[ 	]*\\(\\sw+\\)?" (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t))) (#$ . 10301))
#@45 Medium level highlighting for Fortran mode.
(defvar fortran-font-lock-keywords-2 (byte-code "\302	\303B\304\305\306\307\257\"\207" [fortran-font-lock-keywords-1 fortran-type-types append font-lock-type-face "\\<\\(backspace\\|c\\(?:\\(?:as\\|los\\|ontinu\\|ycl\\)e\\)\\|e\\(?:lse\\(?:if\\|where\\)?\\|nd\\(?:do\\|if\\)?\\|xit\\)\\|format\\|i\\(?:f\\|n\\(?:\\(?:clud\\|quir\\)e\\)\\)\\|open\\|print\\|re\\(?:ad\\|turn\\|wind\\)\\|s\\(?:elect\\|top\\)\\|then\\|w\\(?:\\(?:h\\(?:er\\|il\\)\\|rit\\)e\\)\\)\\>" "\\.\\(and\\|eqv?\\|false\\|g[et]\\|l[et]\\|n\\(?:e\\(?:qv\\)?\\|ot\\)\\|or\\|true\\)\\." ("\\<\\(do\\|go *to\\)\\>[ 	]*\\([0-9]+\\)?" (1 font-lock-keyword-face) (2 font-lock-constant-face nil t)) ("^ *\\([0-9]+\\)" . font-lock-constant-face)] 7) (#$ . 10569))
#@156 Like `font-lock-match-c-style-declaration-item-and-skip-to-next'.
The only difference is, it returns t in a case when the default returns nil.

(fn LIMIT)
(defalias 'fortran-match-and-skip-declaration #[257 "\300\301!\205`\302\225\203,\302\225\302\224Z\303V\203,`\304\305x\210\306\307!\210\300\310!\204+\211b\210\300\301!\210\210\311 \312\313\"\216\3141[\214e}\210\303\225b\210\300\315!\204S\316`\303\"\206Ndb\210\202@\302\225b)0\202]\210\317)\262
\207" [looking-at "[ \n	*]*\\(\\sw+\\)[ 	\n]*\\(((?\\)?" 2 1 " 	\n" nil skip-syntax-backward "w" "\\(\\sw+\\)[ 	\n]*\\sw+[ 	\n]*\\(((?\\)?" match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] (error) "[ 	\n]*\\(\\(,\\)\\|;\\|\\'\\)" scan-sexps t] 5 (#$ . 11346)])
#@44 Gaudy level highlighting for Fortran mode.
(defvar fortran-font-lock-keywords-3 (byte-code "\304	\305P\306\307\310\311\312\313\314	!TD\315BB\316BBB\317BBEC\320\321\322E\n\323BCG\233A%\207" [fortran-font-lock-keywords-1 fortran-type-types fortran-directive-re fortran-font-lock-keywords-2 append "[ 	(/]*\\(\\*\\)?" (1 font-lock-type-face) fortran-match-and-skip-declaration condition-case nil and match-beginning regexp-opt-depth ((forward-sexp) (forward-sexp)) ((error nil)) (nil (1 font-lock-variable-name-face nil t)) (", *\\(e\\(nd\\|rr\\)\\)\\> *\\(= *\\([0-9]+\\)\\)?" (1 font-lock-keyword-face) (4 font-lock-constant-face nil t)) ("^ \\{5\\}\\([^ 0\n]\\)" 1 font-lock-string-face) ("^	\\([1-9]\\)" 1 font-lock-string-face) ((0 font-lock-preprocessor-face t))] 11) (#$ . 12105))
#@111 Maximum highlighting for Fortran mode.
Consists of level 3 plus all other intrinsics not already highlighted.
(defvar fortran-font-lock-keywords-4 (byte-code "\301\302\303DC\"\207" [fortran-font-lock-keywords-3 append "\\<\\(a\\(?:bs\\|cos\\|i\\(?:mag\\|nt\\)\\|log\\(?:10\\)?\\|m\\(?:ax[01]\\|in[01]\\|od\\)\\|nint\\|sin\\|tan2?\\)\\|c\\(?:abs\\|cos\\|exp\\|har\\|log\\|mplx\\|o\\(?:njg\\|sh?\\)\\|s\\(?:in\\|qrt\\)\\)\\|d\\(?:a\\(?:bs\\|cos\\|sin\\|tan2?\\)\\|ble\\|cosh?\\|dim\\|exp\\|i\\(?:m\\|nt\\)\\|log\\(?:10\\)?\\|m\\(?:ax1\\|in1\\|od\\)\\|nint\\|prod\\|s\\(?:i\\(?:gn\\|nh?\\)\\|qrt\\)\\|tanh?\\)\\|exp\\|float\\|i\\(?:abs\\|char\\|d\\(?:i\\(?:m\\|nt\\)\\|nint\\)\\|fix\\|n\\(?:dex\\|t\\)\\|sign\\)\\|l\\(?:en\\|g[et]\\|l[et]\\|og\\(?:10\\)?\\)\\|m\\(?:ax[01]?\\|in[01]?\\|od\\)\\|nint\\|real\\|s\\(?:i\\(?:gn\\|nh?\\)\\|ngl\\|qrt\\)\\|tanh?\\)[ 	]*(" (1 font-lock-builtin-face)] 4) (#$ . 12900))
#@190 Return a value for `syntax-propertize-function' in Fortran mode.
This varies according to the value of LINE-LENGTH.
This is used to fontify fixed-format Fortran comments.

(fn LINE-LENGTH)
(defalias 'fortran-make-syntax-propertize-function #[257 "\300\301\302\303\304S\"\305BE\306\"\207" [eval syntax-propertize-rules ("^[CcDd\\*]" (0 "<")) format "^[^CcDd\\*	\n].\\{%d\\}\\(.+\\)" ((1 "<")) t] 7 (#$ . 13815)])
#@51 Default expressions to highlight in Fortran mode.
(defvar fortran-font-lock-keywords fortran-font-lock-keywords-1 (#$ . 14234))
#@55 Value for `imenu-generic-expression' in Fortran mode.
(defvar fortran-imenu-generic-expression (byte-code "\301\302\303Q\304E\305D\207" [fortran-continuation-string nil "^\\s-+\\(\\(\\sw\\|\\s-\\|[*()+]\\)*\\<function\\|subroutine\\|entry\\|block\\s-*data\\|program\\)[ 	" "]+\\(\\sw+\\)" 3 (nil "^\\s-+\\(block\\s-*data\\)\\s-*$" 1)] 4) (#$ . 14368))
#@148 Regexp potentially indicating the start or end of a Fortran "block".
Omits naked END statements, and DO-loops closed by anything other
than ENDDO.
(defconst fortran-blocks-re "block[ 	]*data\\|select[ 	]*case\\|\\(?:do\\|function\\|i\\(?:f\\|nterface\\)\\|map\\|program\\|s\\(?:\\(?:tructur\\|ubroutin\\)e\\)\\|union\\|where\\)" (#$ . 14728))
#@182 Regexp matching the end of a Fortran "block", from the line start.
Note that only ENDDO is handled for the end of a DO-loop.  Used
in the Fortran entry in `hs-special-modes-alist'.
(defconst fortran-end-block-re (concat "^[ 	0-9]*\\<end[ 	]*\\(" fortran-blocks-re "\\|!\\|$\\)") (#$ . 15078))
#@255 Regexp matching the start of a Fortran "block", from the line start.
A simple regexp cannot do this in fully correct fashion, so this
tries to strike a compromise between complexity and flexibility.
Used in the Fortran entry in `hs-special-modes-alist'.
(defconst fortran-start-block-re "^[ 	0-9]*\\(\\(\\(\\sw+[ 	]*:[ 	]*\\)?\\(if[ 	]*(\\(.*\\|.*\n\\([^if]*\\([^i].\\|.[^f]\\|.\\>\\)\\)\\)\\<then\\|do\\|select[ 	]*case\\|where\\)\\)\\|\\(?:function\\|interface\\|map\\|program\\|s\\(?:\\(?:tructur\\|ubroutin\\)e\\)\\|union\\)\\|block[ 	]*data\\)[ 	]*" (#$ . 15378))
(byte-code "\302\303\304	\305BBB\"\207" [fortran-start-block-re fortran-end-block-re add-to-list hs-special-modes-alist fortran-mode ("^[cC*!]" fortran-end-of-block nil)] 6)
#@36 Syntax table used in Fortran mode.
(defvar fortran-mode-syntax-table (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\303#\210\301\307\303#\210\301\310\303#\210\301\311\303#\210\301\312\303#\210\301\313\303#\210\301\314\315#\210\301\316\315#\210\301\317\320#\210\301\321\322#\210\301\323\322#\210\301\324\322#\210\301\325\326#\210\301\327\330#\210\207" [make-syntax-table modify-syntax-entry 59 "." 13 " " 43 45 61 42 47 37 39 "\"" 34 92 "\\" 46 "_" 95 36 33 "<" 10 ">"] 5) (#$ . 16128))
#@69 Syntax table used to parse Fortran expressions for printing in GUD.
(defvar fortran-gud-syntax-table (byte-code "\301!\302\303\304#\210\207" [fortran-mode-syntax-table make-syntax-table modify-syntax-entry 10 "."] 5) (#$ . 16649))
#@30 Keymap used in Fortran mode.
(defvar fortran-mode-map (byte-code "\300 \301
\302\303#\210\301
\304\305#\210\301
\306\307#\210\301
\310\311#\210\301
\312\313#\210\301
\314\315#\210\301
\316\317#\210\301
\320\321#\210\301
\322\323#\210\301
\324\325#\210\301
\326\327#\210\301
\330\327#\210\301
\331\332#\210\301
\333\332#\210\301
\334\332#\210\301
\335\332#\210\301
\336\332#\210\301
\337\332#\210\301
\340\332#\210\301
\341\332#\210\301
\342\332#\210\301
\343\332#\210\207" [make-sparse-keymap define-key ";" fortran-abbrev-start ";" fortran-comment-region "\212" fortran-split-line "\216" fortran-end-of-block "\220" fortran-beginning-of-block "\221" fortran-indent-subprogram "" fortran-window-create-momentarily "" fortran-column-ruler "" fortran-previous-statement "" fortran-next-statement "" fortran-join-line "\336" "0" fortran-electric-line-number "1" "2" "3" "4" "5" "6" "7" "8" "9"] 5) (#$ . 16888))
(byte-code "\300\301\302\303\304\"\305\306\307%\207" [define-abbrev-table fortran-mode-abbrev-table mapcar #[257 "\211@
A\300\301\302\257\207" [nil :system t] 6 "\n\n(fn E)"] ((";au" . "automatic") (";b" . "byte") (";bd" . "block data") (";ch" . "character") (";cl" . "close") (";c" . "continue") (";cm" . "common") (";cx" . "complex") (";df" . "define") (";di" . "dimension") (";do" . "double") (";dc" . "double complex") (";dp" . "double precision") (";dw" . "do while") (";e" . "else") (";ed" . "enddo") (";el" . "elseif") (";en" . "endif") (";eq" . "equivalence") (";ew" . "endwhere") (";ex" . "external") (";ey" . "entry") (";f" . "format") (";fa" . ".false.") (";fu" . "function") (";g" . "goto") (";im" . "implicit") (";ib" . "implicit byte") (";ic" . "implicit complex") (";ich" . "implicit character") (";ii" . "implicit integer") (";il" . "implicit logical") (";ir" . "implicit real") (";inc" . "include") (";in" . "integer") (";intr" . "intrinsic") (";l" . "logical") (";n" . "namelist") (";o" . "open") (";pa" . "parameter") (";pr" . "program") (";ps" . "pause") (";p" . "print") (";rc" . "record") (";re" . "real") (";r" . "read") (";rt" . "return") (";rw" . "rewind") (";s" . "stop") (";sa" . "save") (";st" . "structure") (";sc" . "static") (";su" . "subroutine") (";tr" . ".true.") (";ty" . "type") (";vo" . "volatile") (";w" . "write") (";wh" . "where")) "Abbrev table for Fortran mode." :regexp "\\(?:[^[:word:]_;]\\|^\\)\\(;?[[:word:]_]+\\)[^[:word:]_]*"] 6)
(defvar fortran-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [fortran-mode-hook variable-documentation put "Hook run after entering Fortran mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp fortran-mode-map definition-name fortran-mode] 4)
(defvar fortran-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\210\302\305\310\311#\207" [fortran-mode-map variable-documentation put purecopy "Keymap for `fortran-mode'." fortran-mode derived-mode-parent prog-mode custom-mode-group fortran] 5)
#@2984 Major mode for editing Fortran code in fixed format.
For free format code, use `f90-mode'.

\[fortran-indent-line] indents the current Fortran line correctly.
Note that DO statements must not share a common CONTINUE.

Type ;? or ;\[help-command] to display a list of built-in abbrevs for Fortran keywords.

Key definitions:
\{fortran-mode-map}

Variables controlling indentation style and extra features:

`fortran-comment-line-start'
  To use comments starting with `!', set this to the string "!".
`fortran-do-indent'
  Extra indentation within DO blocks (default 3).
`fortran-if-indent'
  Extra indentation within IF blocks (default 3).
`fortran-structure-indent'
  Extra indentation within STRUCTURE, UNION, MAP and INTERFACE blocks.
  (default 3)
`fortran-continuation-indent'
  Extra indentation applied to continuation statements (default 5).
`fortran-comment-line-extra-indent'
  Amount of extra indentation for text in full-line comments (default 0).
`fortran-comment-indent-style'
  How to indent the text in full-line comments.  Allowed values are:
  nil         don't change the indentation
  `fixed'     indent to `fortran-comment-line-extra-indent' beyond the
              value of either
                `fortran-minimum-statement-indent-fixed' (fixed format) or
                `fortran-minimum-statement-indent-tab' (TAB format),
              depending on the continuation format in use.
  `relative'  indent to `fortran-comment-line-extra-indent' beyond the
              indentation for a line of code.
  (default `fixed')
`fortran-comment-indent-char'
  Single-character string to be inserted instead of space for
  full-line comment indentation (default " ").
`fortran-minimum-statement-indent-fixed'
  Minimum indentation for statements in fixed format mode (default 6).
`fortran-minimum-statement-indent-tab'
  Minimum indentation for statements in TAB format mode (default 9).
`fortran-line-number-indent'
  Maximum indentation for line numbers (default 1).  A line number will
  get less than this much indentation if necessary to avoid reaching
  column 5.
`fortran-check-all-num-for-matching-do'
  Non-nil causes all numbered lines to be treated as possible "continue"
  statements (default nil).
`fortran-blink-matching-if'
  Non-nil causes \[fortran-indent-line] on an ENDIF (or ENDDO) statement
  to blink on the matching IF (or DO [WHILE]).  (default nil)
`fortran-continuation-string'
  Single-character string to be inserted in column 5 of a continuation
  line (default "$").
`fortran-comment-region'
  String inserted by \[fortran-comment-region] at start of each line in
  the region (default "c$$$").
`fortran-electric-line-number'
  Non-nil causes line number digits to be moved to the correct column
  as typed (default t).
`fortran-break-before-delimiters'
  Non-nil causes lines to be broken before delimiters (default t).

Turning on Fortran mode calls the value of the variable `fortran-mode-hook'
with no args, if that value is non-nil.
(defalias 'fortran-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320!\210\321\f!\210
@\306\322!\210\323\306\324!\210\325\306\326!\210A\306\327!\210\330\306\331!\210\332\306\333!\210B\306\334!\210\335\306\336!\210\337\306\340!\210\341 \306\342!\210\343\"\306\344!\210\345$\306\346!\210\307&\306\347!\210\350'\306\351!\210\352 )\353C\306\354!\210D,\306\355!\210\356-\306\357!\210\360/\306\361!\210\362D!1\306\363!\210\3073\306\364!\210E4\306\365!\210\3665\306\367!\210\3707\306\371!\210\3729\306\373!\210\374;\306\375!\210\376=\306\377!\210\201F?\201G\201H\201I\330\307$\210)\201J\201K!\207" [delay-mode-hooks major-mode mode-name fortran-mode-map fortran-mode-syntax-table fortran-mode-abbrev-table make-local-variable t prog-mode fortran-mode "Fortran" mode-class put keymap-parent set-keymap-parent current-local-map use-local-map set-syntax-table indent-line-function fortran-indent-line indent-region-function #[514 "\302\211\303\302#*\207" [indent-region-function fortran-blink-matching-if nil indent-region] 6 "\n\n(fn START END)"] require-final-newline comment-use-syntax nil comment-padding "$$$" comment-start comment-start-skip "\\(\\)\\(?:^[CcDd*]\\|!\\)\\(?:\\([^ 	\n]\\)\\2+\\)?[ 	]*" comment-indent-function fortran-comment-indent comment-region-function fortran-comment-region uncomment-region-function fortran-uncomment-region comment-insert-comment-function fortran-indent-comment abbrev-all-caps normal-auto-fill-function fortran-auto-fill indent-tabs-mode fortran-analyze-file-format (indent-tabs-mode fortran-tab-mode-string) fill-column fill-paragraph-function fortran-fill-paragraph font-lock-defaults ((fortran-font-lock-keywords fortran-font-lock-keywords-1 fortran-font-lock-keywords-2 fortran-font-lock-keywords-3 fortran-font-lock-keywords-4) nil t ((47 . "$/") ("_$" . "w")) fortran-beginning-of-subprogram) syntax-propertize-function fortran-make-syntax-propertize-function imenu-case-fold-search imenu-generic-expression imenu-syntax-alist (("_$" . "w")) beginning-of-defun-function fortran-beginning-of-subprogram end-of-defun-function fortran-end-of-subprogram add-log-current-defun-function fortran-current-defun dabbrev-case-fold-search case-fold-search gud-find-expr-function local-abbrev-table mode-require-final-newline fortran-comment-line-start mode-line-process fortran-line-length fortran-imenu-generic-expression fortran-gud-find-expr add-hook hack-local-variables-hook fortran-hack-local-variables run-mode-hooks fortran-mode-hook] 5 (#$ . 19991) nil])
#@460 Set the length of fixed-form Fortran lines to NCHARS.
By default this only affects the current buffer, which must be in
Fortran mode.  If the optional argument GLOBAL is non-nil, it affects
all Fortran buffers, and also the default.  The default value of NCHARS
is the current column.  A numeric prefix argument specifies a value to
use instead of the current column.  A non-numeric prefix argument prompts
for the value to use.

(fn NCHARS &optional GLOBAL)
(defalias 'fortran-line-length #[513 "\211\203	\304 \202pC\211\203=\211@r\211q\210\305\306!\2035=\2045\211\307!\310e!\210\2035\303\311!\210)
A\266\202\202\210\211\205F\312\300\"\207" [fortran-line-length fill-column syntax-propertize-function font-lock-mode buffer-list derived-mode-p fortran-mode fortran-make-syntax-propertize-function syntax-ppss-flush-cache 1 set-default] 7 (#$ . 25599) (byte-code "\247\203	\202\203\301\302\303\304!\"\202iC\207" [current-prefix-arg read-number "Line length: " default-value fortran-line-length] 4)])
#@56 Fortran mode adds this to `hack-local-variables-hook'.
(defalias 'fortran-hack-local-variables #[0 "\300!\207" [fortran-line-length] 2 (#$ . 26633)])
(defalias 'fortran-gud-find-expr #[0 "\301 p\302\303#\216\304!\210\305 )\207" [fortran-gud-syntax-table syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table gud-find-c-expr] 6])
#@207 Return the indentation appropriate for the current comment line.
This is 0 for a line matching `fortran-comment-line-start-skip', else
the value of `comment-column' (leaving at least one space after code).
(defalias 'fortran-comment-indent #[0 "\302!\203\303\207\212\304\305x\210iT	])\207" [fortran-comment-line-start-skip comment-column looking-at 0 " 	" nil] 2 (#$ . 27021)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put fortran-comment-indent speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@377 Align or create comment on current line.
Existing comments of all types are recognized and aligned.
If the line has no comment, a side-by-side comment is inserted and aligned,
if the value of `comment-start' is not nil and allows such comments.
Otherwise, a separate-line comment is inserted, on this line
or on a new line inserted before this line if this line is not blank.
(defalias 'fortran-indent-comment #[0 "\306 \210\307\310!\203G\311\224b\210n\203\312 \207i\313!\203\311\202)\212\314\315x\210iT	])U?\205F\316 \210\313!\203;\311\202E\212\314\315x\210iT	])j\207\n\203y\313\317!\204y\320\321\nP\"\203y\315\210\316 \210\313!\203j\311\202t\212\314\315x\210iT	])j\210\nc\207\313\322!\203\205\316 \210\202\216\306 \210\323c\210\324u\210\fc\210\325
;\203\235
\311H\202\236
\326 iZ\"\207" [fortran-comment-line-start-skip comment-column comment-start comment-start-skip fortran-comment-line-start fortran-comment-indent-char beginning-of-line fortran-find-comment-start-skip all 0 fortran-indent-line looking-at " 	" nil delete-horizontal-space "[ 	]*$" string-match " " "^[ 	]*$" 10 -1 insert-char fortran-calculate-indent] 4 (#$ . 27557) "*"])
#@264 Comment every line in the region.
Inserts the string variable `fortran-comment-region' at the beginning of
every line in the region.
BEG-REGION and END-REGION specify the region boundaries.
With non-nil ARG, uncomments the region.

(fn BEG-REGION END-REGION ARG)
(defalias 'fortran-comment-region #[771 "\301!\302 b\210\303 \210\203<\304!\305
!\203`\306\225|\210\307y\306U\2038`W\2038\305
!\203`\306\225|\210\202\210\202Rc\210\307y\306U\203R`W\203Rc\210\202?\211b\210
\310\211\223\210\211\310\211\223\207" [fortran-comment-region copy-marker point-marker beginning-of-line regexp-quote looking-at 0 1 nil] 8 (#$ . 28733) "*r\nP"])
#@71 Uncomment every line in the region.

(fn START END &optional IGNORED)
(defalias 'fortran-uncomment-region #[770 "\300\301#\207" [fortran-comment-region t] 7 (#$ . 29391)])
#@110 Typing ;\[help-command] or ;? lists all the Fortran abbrevs.
Any other key combination is executed normally.
(defalias 'fortran-abbrev-start #[0 "c\210\305 	\203\211\306=\204\211\n=\204\211>\203\307 \207\211\fB\211\207" [last-command-event abbrev-mode help-char help-event-list unread-command-events read-event 63 fortran-abbrev-help] 3 (#$ . 29572) "*"])
#@53 List the currently defined abbrevs in Fortran mode.
(defalias 'fortran-abbrev-help #[0 "\300\301!\210\302\303 !\210\300\304!\207" [message "Listing abbrev table..." display-buffer fortran-prepare-abbrev-list-buffer "Listing abbrev table...done"] 2 (#$ . 29945) nil])
#@57 Create a buffer listing the Fortran mode abbreviations.
(defalias 'fortran-prepare-abbrev-list-buffer #[0 "r\300\301!q\210\302 \210\303\304\305\"\210eb\210\306\307!\210\310 \210)\300\301!\207" [get-buffer-create "*Abbrevs*" erase-buffer insert-abbrev-table-description fortran-mode-abbrev-table t set-buffer-modified-p nil edit-abbrevs-mode] 3 (#$ . 30218)])
#@264 Insert a column ruler momentarily above current line, till next keystroke.
The ruler is defined by the value of `fortran-column-ruler-fixed' in fixed
format mode, and `fortran-column-ruler-tab' in TAB format mode.
The next key typed is executed unless it is SPC.
(defalias 'fortran-column-ruler #[0 "\303\203		\202\n\n\212\304 \210\305 \306 =\203\307\310!\202`)\311\312$\207" [indent-tabs-mode fortran-column-ruler-tab fortran-column-ruler-fixed momentary-string-display beginning-of-line window-start window-point line-beginning-position 2 nil "Type SPC or any command to erase ruler."] 5 (#$ . 30584) nil])
#@112 Make the window `fortran-line-length' (default 72) columns wide.
See also `fortran-window-create-momentarily'.
(defalias 'fortran-window-create #[0 "\303\304 \204\305\306 \307 ZS!\210\310 \303
8
@Z\307 Z\311\n	\\!\210)\210\312\313!\210\314\315\316\"\210\317\320 !)\207" [window-min-width scroll-bar-width fortran-line-length 2 window-full-width-p enlarge-window-horizontally frame-width window-width window-edges split-window-right other-window 1 switch-to-buffer " fortran-window-extra" t select-window previous-window] 4 (#$ . 31207) nil])
#@199 Momentarily make the window `fortran-line-length' (default 72) columns wide.
Optional ARG non-nil and non-unity disables the momentary feature.
See also `fortran-window-create'.

(fn &optional ARG)
(defalias 'fortran-window-create-momentarily #[256 "\211\203\n\211\301U\2036\302 \303\304\"\216\3051\306 0\210\202!\210\307\310!\210\311\312!\210\313 \211\314=\2062\211B\211\262
)\207\306 \207" [unread-command-events 1 current-window-configuration make-closure #[0 "\301\300!\207" [V0 set-window-configuration] 2] (error) fortran-window-create error "No room for Fortran window" message "Type SPC to continue editing." read-event 32] 5 (#$ . 31760) "p"])
#@67 Break line at point and insert continuation marker and alignment.
(defalias 'fortran-split-line #[0 "\302 \210\212`\303 \210\304\305!\205\306\224
W\262
)\203\"\307\310\306!\261\210\2025\2030\307\311\312 \261\210\2025\313	\261\210\314 \207" [indent-tabs-mode fortran-continuation-string delete-horizontal-space beginning-of-line fortran-find-comment-start-skip all 0 10 match-string 9 fortran-numerical-continuation-char "\n " fortran-indent-line] 3 (#$ . 32428) "*"])
#@94 Delete any Fortran continuation characters at point.
Returns t if anything actually deleted.
(defalias 'fortran-remove-continuation #[0 "\300\301!\205\302\303!\210\304 \210\305\207" [looking-at "\\( \\{5\\}[^ 0\n]\\|	[1-9]\\|&\\)" replace-match "" delete-indentation t] 2 (#$ . 32912)])
#@235 Join current line to the previous one and re-indent.
With a prefix argument, repeat this operation that many times.
If the prefix argument ARG is negative, join the next -ARG lines.
Continuation lines are correctly handled.

(fn ARG)
(defalias 'fortran-join-line #[257 "\212\300
V\203\211[\262
\211y\210\211\300U\204&\301 \210\302 \204\303 \210\211S\262
\202\304 )\207" [0 beginning-of-line fortran-remove-continuation delete-indentation fortran-indent-line] 3 (#$ . 33208) "*p"])
#@177 Return a digit for tab-digit style of continuation lines.
If previous line is a tab-digit continuation line, return that digit
plus one, otherwise return 1.  Zero not allowed.
(defalias 'fortran-numerical-continuation-char #[0 "\212\300y\210\301\302!\203\303`Tf\304Z\305\246\\\202\303)\207" [-1 looking-at "	[1-9]" 49 48 9] 3 (#$ . 33703)])
(put 'fortran-electric-line-number 'delete-selection t)
#@140 Self insert, but if part of a Fortran line number indent it automatically.
Auto-indent does not happen if a numeric ARG is used.

(fn ARG)
(defalias 'fortran-electric-line-number #[257 "\211\204\204\211\203\306\307!!\207\306\310!\207i\311U\203'\212\312 \210\313\314!)\204Z	\203/\n\2020iU\203I\315 f\316=\203I\f\317=\204I\f\320=\203Z\212\321\322\315 \323#)\204Z\313\324!\203`\306\307!!\207\325\326x\210
c\210\317 \207" [fortran-electric-line-number indent-tabs-mode fortran-minimum-statement-indent-tab fortran-minimum-statement-indent-fixed last-command last-command-event self-insert-command prefix-numeric-value 1 5 beginning-of-line looking-at " \\{5\\}" line-beginning-position 9 fortran-indent-line fortran-indent-new-line re-search-backward "[^ 	0-9]" t "[0-9]" " 	" nil] 5 (#$ . 34111) "*P"])
#@58 Check a preliminary match against `fortran-end-prog-re'.
(defalias 'fortran-check-end-prog-re #[0 "\301 \302\303\"\216\304\305\306\225\307 \310 \\^{\")\207" [fortran-line-length match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] string-match "^\\s-*\\(\\'\\|\\s<\\)" 0 line-end-position line-beginning-position] 7 (#$ . 34937)])
#@180 Move point to the beginning of the current Fortran subprogram.
If ARG is negative, and point is between subprograms, the
"current" subprogram is the next one.

(fn &optional ARG)
(defalias 'fortran-beginning-of-subprogram #[256 "\211\203\211\303W\203\304 \210\305 \207\306\307n\203\303\202\310!\210\311 \312\313\"\216\314	!\206X\315 \316=\206X\3172L\320\n\321\322#\205K\323 \2036\324\317\306\"\210\20260\204V\314\325!?\205X\326 )\262
)\207" [case-fold-search fortran-start-prog-re fortran-end-prog-re 0 fortran-end-of-subprogram fortran-beginning-of-subprogram t beginning-of-line 1 match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] looking-at fortran-previous-statement first-statement ok re-search-backward nil move fortran-check-end-prog-re throw "^\\([ 	]*[0-9]\\|[ 	]+[^!#]\\)" fortran-next-statement] 6 (#$ . 35306) nil])
#@58 Move point to the end of the current Fortran subprogram.
(defalias 'fortran-end-of-subprogram #[0 "\302\303 \210\304 \305\306\"\216\307	\310\311#\203\312 \203\f\310y)\262
)\207" [case-fold-search fortran-end-prog-re t beginning-of-line match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] re-search-forward nil move fortran-check-end-prog-re] 5 (#$ . 36190) nil])
#@220 Move point to beginning of the previous Fortran statement.
Returns `first-statement' if that statement is the first
non-comment Fortran statement in the file, and nil otherwise.
Directive lines are treated as comments.
(defalias 'fortran-previous-statement #[0 "\304\211\305 \210\306!?\205 \306	!?\205 \306\307\310\n!P!\206 \306\311!\262
\312y\313U\211\262\203Q\306!\204\"\306	!\204\"\306\307\310\n!P!\204\"\306\314!\204\"\306\315\316Q!\204\"\211\203]
\204]\317\320!\207\211\203d\321 \207
?\205j\322\207" [fortran-comment-line-start-skip fortran-directive-re fortran-continuation-string comment-start-skip nil beginning-of-line looking-at "[ 	]*" regexp-quote " \\{5\\}[^ 0\n]\\|	[1-9]" -1 0 "[ 	]*$\\| \\{5\\}[^ 0\n]\\|	[1-9]" "[ 	]*\\(?:" "\\)" message "Incomplete continuation statement." fortran-previous-statement first-statement] 6 (#$ . 36595) nil])
#@214 Move point to beginning of the next Fortran statement.
Returns `last-statement' if that statement is the last
non-comment Fortran statement in the file, and nil otherwise.
Directive lines are treated as comments.
(defalias 'fortran-next-statement #[0 "\303\304 \210\305y\306U\205
m?\211\262\203.\307!\204\307	!\204\307\310!\204\307\311\n\312Q!\204\211?\2054\313\207" [fortran-comment-line-start-skip fortran-directive-re comment-start-skip nil beginning-of-line 1 0 looking-at "[ 	]*$\\|     [^ 0\n]\\|	[1-9]" "[ 	]*\\(?:" "\\)" last-statement] 5 (#$ . 37476) nil])
#@73 Return non-nil if at the start of a line with an IF ... THEN statement.
(defalias 'fortran-looking-at-if-then #[0 "`\300 \211\205\212\211b\210\301 U)\207" [fortran-beginning-if line-beginning-position] 4 (#$ . 38061)])
#@298 Move point forward to the end of the current code block.
With optional argument NUM, go forward that many balanced blocks.
If NUM is negative, go backward to the start of a block.  Does
not check for consistency of block types.  Interactively, pushes
mark before moving point.

(fn &optional NUM)
(defalias 'fortran-end-of-block #[256 "\306\307!\203\310`\311\"\210\211\203\211\312W\203\313
[!\210\311
\206 \314
\315\210\211\312V\203\201\316\317	\n\2036\320\2027\321\322R\315\323#\203\201\324 \210\325\326P!\203O\327 \202R\325\f!\203\\\211T\262
\202{\325
!\204w\325\330!\204r\n\203{\325\331!\203{\332 \203{\211S\262
\315\210\202%\211\312V\205\212\333\334!)\207" [case-fold-search fortran-blocks-re fortran-check-all-num-for-matching-do fortran-if-start-re fortran-start-block-re fortran-end-block-re called-interactively-p any push-mark t 0 fortran-beginning-of-block 1 nil re-search-forward "\\(" "\\|^[ 	]*[0-9]+" "" "\\|continue\\|end\\)\\>" move beginning-of-line looking-at "^[0-9 	]*" fortran-looking-at-if-then "^[0-9 	]*continue" "[ 	]*[0-9]+" fortran-check-for-matching-do error "Missing block end"] 8 (#$ . 38290) "p"])
#@300 Move point backwards to the start of the current code block.
With optional argument NUM, go backward that many balanced
blocks.  If NUM is negative, go forward to the end of a block.
Does not check for consistency of block types.  Interactively,
pushes mark before moving point.

(fn &optional NUM)
(defalias 'fortran-beginning-of-block #[256 "\306\307!\203\310`\311\"\210\211\203\211\312W\203\313
[!\210\311
\206 \314
\315 \210\211\312V\203~\316\317	\n\2036\320\2027\321\322R\323\324#\203~\315 \210\325\326P!\203O\327 \202R\325\f!\203\\\211S\262
\202%\325
!\204w\325\330!\204r\n\203%\325\331!\203%\332 \203%\211T\262
\202%\211\312V\205\207\333\334!)\207" [case-fold-search fortran-blocks-re fortran-check-all-num-for-matching-do fortran-if-start-re fortran-start-block-re fortran-end-block-re called-interactively-p any push-mark t 0 fortran-end-of-block 1 beginning-of-line re-search-backward "\\(" "\\|^[ 	]*[0-9]+" "" "\\|continue\\|end\\)\\>" nil move looking-at "^[0-9 	]*" fortran-looking-at-if-then "^[0-9 	]*continue" "[ 	]*[0-9]+" fortran-check-for-matching-do error "Missing block start"] 8 (#$ . 39452) "p"])
#@136 From a line matching REGEX, blink matching KEYWORD statement line.
Use function FIND-BEGIN to match it.

(fn REGEX KEYWORD FIND-BEGIN)
(defalias 'fortran-blink-match #[771 "\302 `\303\304\211\212\305 \210\306\304w\210\307!)\205T \211\262\204*\310\311Q\262
\202@
W\203@\212
b\210\305 \210\312`\313 {P\262
)\211\203K\314\315\"\202T
b\210\316	!\210b)\207" [case-fold-search blink-matching-delay window-start t nil beginning-of-line " 	0-9" looking-at "No matching " "." "Matches " line-end-position message "%s" sit-for] 11 (#$ . 40604)])
#@67 From an ENDIF or ELSE statement, blink the matching IF statement.
(defalias 'fortran-blink-matching-if #[0 "\300\301\302\303#\207" [fortran-blink-match "e\\(nd[ 	]*if\\|lse\\([ 	]*if\\)?\\)\\b" "if" fortran-beginning-if] 4 (#$ . 41163)])
#@71 From an ENDDO statement, blink the matching DO or DO WHILE statement.
(defalias 'fortran-blink-matching-do #[0 "\300\301\302\303#\207" [fortran-blink-match "end[ 	]*do\\b" "do" fortran-beginning-do] 4 (#$ . 41407)])
#@98 Put mark at end of Fortran DO [WHILE]-ENDDO construct, point at beginning.
The marks are pushed.
(defalias 'fortran-mark-do #[0 "\300\211\301 \211\262\205\302 \211\262\204\303\304!\207
b\210\305 \210\211b\207" [nil fortran-end-do fortran-beginning-do message "No matching do." push-mark] 4 (#$ . 41629) nil])
#@64 Search forward for first unmatched ENDDO.
Return point or nil.
(defalias 'fortran-end-do #[0 "\302\212\303 \210\304\305w\210\306\307!)\203\310\224\202X\212\311\211\310U\204N\312 \313=\204N\306	!\2030\314 \204N\304\305w\210\306\307!\203A\211S\262
\202\306\315!\203\211T\262
\202\211\310U\205U`\262
))\207" [case-fold-search fortran-end-prog-re t beginning-of-line " 	0-9" nil looking-at "end[ 	]*do\\b" 0 1 fortran-next-statement last-statement fortran-check-end-prog-re "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?do[ 	]+[^0-9]"] 3 (#$ . 41950)])
#@125 Search backwards for first unmatched DO [WHILE].
Return point or nil.  Ignores labeled DO loops (ie DO 10 ... 10 CONTINUE).
(defalias 'fortran-beginning-do #[0 "\302\212\303 \210\304\305w\210\306\307!)\203\310\224\202X\212\311\211\310U\204N\312 \313=\204N\306	!\2030\314 \204N\304\305w\210\306\307!\203A\211S\262
\202\306\315!\203\211T\262
\202\211\310U\205U`\262
))\207" [case-fold-search fortran-end-prog-re t beginning-of-line " 	0-9" nil looking-at "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?do[ 	]+[^0-9]" 0 1 fortran-previous-statement first-statement fortran-check-end-prog-re "end[ 	]*do\\b"] 3 (#$ . 42508)])
#@90 Put mark at end of Fortran IF-ENDIF construct, point at beginning.
The marks are pushed.
(defalias 'fortran-mark-if #[0 "\300\211\301 \211\262\205\302 \211\262\204\303\304!\207
b\210\305 \210\211b\207" [nil fortran-end-if fortran-beginning-if message "No matching if." push-mark] 4 (#$ . 43137) nil])
#@65 Search forwards for first unmatched ENDIF.
Return point or nil.
(defalias 'fortran-end-if #[0 "\303\212\304 \210\305\306w\210\307\310!)\203\311\224\202}\212\312\211\311U\204s\313 \314=\204s\307	!\2030\315 \204s\305\306w\210\307\310!\203A\211S\262
\202\307\n!\203\212\307\316!\204k\306\312y\311U\203e\307\317!\203e\307\320!\211\262\203O\211\262
\203o\211T\262
)\202\211\311U\205z`\262
))\207" [case-fold-search fortran-end-prog-re fortran-if-start-re t beginning-of-line " 	0-9" nil looking-at "end[ 	]*if\\b" 0 1 fortran-next-statement last-statement fortran-check-end-prog-re ".*)[ 	]*then\\b[ 	]*[^ 	(=a-z0-9]" " \\{5\\}[^ 0\n]\\|	[1-9]" ".*then\\b[ 	]*[^ 	(=a-z0-9]"] 4 (#$ . 43450)])
#@68 Search backwards for first unmatched IF-THEN.
Return point or nil.
(defalias 'fortran-beginning-if #[0 "\303\212\304 \305=\204
\306 \210\307\310w\210\311	!\205A\312 \313\314\"\216\311\315!\206>\310\316y\317U\203;\311\320!\203;\311\321!\211\262\203%\211\262
)\262
)\203J\317\224\202\261\212\316\211\317U\204\247\304 \305=\204\247\311\n!\203d\322 \204\247\307\310w\210\311	!\203\232\212\311\315!\204\222\310\316y\317U\203\214\311\320!\203\214\311\321!\211\262\203v\211\262
\203\226\211S\262
)\202L\311\323!\203L\211T\262
\202L\211\317U\205\256`\262
))\207" [case-fold-search fortran-if-start-re fortran-end-prog-re t fortran-previous-statement first-statement fortran-next-statement " 	0-9" nil looking-at match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] ".*)[ 	]*then\\b[ 	]*[^ 	(=a-z0-9]" 1 0 " \\{5\\}[^ 0\n]\\|	[1-9]" ".*then\\b[ 	]*[^ 	(=a-z0-9]" fortran-check-end-prog-re "end[ 	]*if\\b"] 4 (#$ . 44166)])
#@74 Indent current Fortran line based on its contents and on previous lines.
(defalias 'fortran-indent-line #[0 "\303 \212\304 \210\211\305 U\203\306\307`\310\\\311#\203#\312 \204#\313
!\210\202.\304 \210\314 \203.\315 \210)i
W\2039\316
!\210\203P\212\317\210i)	V\203P\212\317\210\320 \210)\n\205Y\302 \210\321 \207" [auto-fill-function fill-column fortran-blink-matching-if fortran-calculate-indent beginning-of-line fortran-current-line-indentation re-search-forward "^[ 	]*[0-9]+" 4 t fortran-line-number-indented-correctly-p fortran-indent-to-column fortran-find-comment-start-skip fortran-indent-comment move-to-column nil fortran-fill fortran-blink-matching-do] 5 (#$ . 45141) "*"])
#@66 Function to use for `normal-auto-fill-function' in Fortran mode.
(defalias 'fortran-auto-fill #[0 "i\300 V\205D\301 \212\302 \210\211\303 U\203#\304\305`\306\\\307#\203*\310 \204*\311
!\210\2025\302 \210\312 \2035\313 \210)\314 \210i
W\205B\315
!\262
\207" [current-fill-column fortran-calculate-indent beginning-of-line fortran-current-line-indentation re-search-forward "^[ 	]*[0-9]+" 4 t fortran-line-number-indented-correctly-p fortran-indent-to-column fortran-find-comment-start-skip fortran-indent-comment fortran-fill move-to-column] 5 (#$ . 45845)])
(defalias 'fortran-indent-new-line 'reindent-then-newline-and-indent)
#@58 Properly indent the Fortran subprogram containing point.
(defalias 'fortran-indent-subprogram #[0 "\212\300 \210\301\302!\210\303`\304 \305#\210)\301\306!\207" [mark-defun message "Indenting subprogram..." indent-region mark nil "Indenting subprogram...done."] 4 (#$ . 46486) "*"])
#@63 Calculates the Fortran indent column based on previous lines.
(defalias 'fortran-calculate-indent #[0 "\306\211\307\203	\202\f\n
\212\310 \262\203\211\262\202
`eU\203)\211\262\202-\311 \262\312\306w\210\313\314!\203b\313\315!\204Z\306\316y\317U\203T\313\320!\203T\313\321!\211\262\203>\211\262
\203
\f\\\262\202
\313\322!\203p\f\\\262\202
\313\323!\203~\f\\\262\202
\313\324!\203\214\f\\\262\202
\313\325!\203\232\f\\\262\202
\313\326!\203\250\f\\\262\202
\313\327!\203\266\f\\\262\202
\313\330!\203\304
\\\262\202
\313\331!\203\323.\\\262\202
\313/!\203\345\332 \203\345\211\262\202
0\203
\313\333!\204
\334 \210\313\335!\203
\336 \203

Z\262)\212\334 \210\313\337!\204\3131!\203
\317\262
\317\262\202\3132!\203A
3\340\267\202;
4\\\262\202;
\2114\\\262\317\262
\202\313\341\3425!P!\204R
\313\320!\203i
\343\306w\210\344`!\203`
\345\202d
6\\\262\202\2040\203\205
\313\346!\203\205
\336 \203\205

Z\262\202\312\306w\210\313\347!\203\227
\fZ\262\202\313\322!\203\245
\fZ\262\202\313\350!\203\263
\fZ\262\202\313\326!\203\301
\fZ\262\202\313\351!\203\324
\336 \203\324

Z\262\202\313\352!\203\342

Z\262\202\313\353!\203\361
.Z\262\202\313/!\203\332 \203
U\204\354\355\"\210)\211])\207" [indent-tabs-mode fortran-minimum-statement-indent-tab fortran-minimum-statement-indent-fixed case-fold-search fortran-if-indent fortran-do-indent nil t fortran-previous-statement fortran-current-line-indentation " 	0-9" looking-at "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?if[ 	]*(" ".*)[ 	]*then\\b[ 	]*[^ 	_$(=a-z0-9]" 1 0 " \\{5\\}[^ 0\n]\\|	[1-9]" ".*then\\b[ 	]*[^ 	_$(=a-z0-9]" "else\\(if\\)?\\b" "select[ 	]*case[ 	](.*)" "case[ 	]*(.*)" "case[ 	]*default\\b" "\\(otherwise\\|else[ 	]*where\\)\\b" "where[ 	]*(.*)[ 	]*\n" "do\\b" "\\(structure\\|union\\|map\\|interface\\)\\b[ 	]*[^ 	=(a-z]" fortran-check-end-prog-re "\\(continue\\|end[ 	]*do\\)\\>" beginning-of-line "[ 	]*[0-9]+" fortran-check-for-matching-do "[ 	]*$" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (relative 300 fixed 309)) "[ 	]*" regexp-quote " 	" fortran-is-in-string-p 6 "[ 	]*[0-9]+[ 	]*\\(continue\\|end[ 	]*do\\)\\>" "end[ 	]*\\(if\\|select\\|where\\)\\b" "case[ 	]*\\((.*)\\|default\\>\\)" "continue\\b" "end[ 	]*do\\b" "end[ 	]*\\(structure\\|union\\|map\\|interface\\)\\b[ 	]*[^ 	=(a-z]" message "Warning: `end' not in column %d.  Probably an unclosed block." fortran-structure-indent fortran-end-prog-re1 fortran-check-all-num-for-matching-do fortran-directive-re fortran-comment-line-start-skip fortran-comment-indent-style fortran-comment-line-extra-indent fortran-continuation-string fortran-continuation-indent] 8 (#$ . 46774)])
#@309 Indentation of current line, ignoring Fortran line number or continuation.
This is the column position of the first non-whitespace character
aside from the line number and/or column 5/8 line-continuation character.
For comment lines, returns indentation of the first
non-indentation text within the comment.
(defalias 'fortran-current-line-indentation #[0 "\212\302 \210\303!\203 \304\225b\210	;\203	\202\305	!\306w\210\2021\303\307!\203-\304\225b\210\2021\310\306w\210\311\306w\210i)\207" [fortran-comment-line-start-skip fortran-comment-indent-char beginning-of-line looking-at 0 char-to-string nil " \\{5\\}[^ 0\n]\\|	[1-9]" " 	0-9" " 	"] 2 (#$ . 49555)])
#@509 Indent current line to column COL.
notes: 1) A non-zero/non-blank character in column 5 indicates a continuation
          line, and this continuation character is retained on indentation;
       2) If `fortran-continuation-string' is the first non-whitespace
          character, this is a continuation line;
       3) A non-continuation line which has a number as the first
          non-whitespace character is a numbered line.
       4) A TAB followed by a digit indicates a continuation line.

(fn COL)
(defalias 'fortran-indent-to-column #[257 "\212\306 \210\307!\203:	\205
\n;\203\n\310H\202\n\311\312\313#\310\225b\210\211\314x\210`
\314w\210`|\210\315iZ\"\266\202\202
\307\316!\203Z\203K\310\225b\210\202\322\317\320!\210\315\312\321\"\210\fc\210\202\322\307\322!\203x\203r\317\323!\210\313\324 \325\261\210\202\322\323u\210\202\322\326 \210m\204\322\307\327\f!!\203\255\203\244\203\223
\202\225j\210\317\325!\210\315\324 \325\"\210\202\322\321j\210\325u\210\202\322\307\330!\203\322\321\310\225`ZZ\211\310W\203\307\331\332!\266\202\316
^j\266\333\314w\210\326 \210\211j\210\334 \205
\310\224b\210i\307!\203\354\310\202\367\212\335\314x\210iT ])U?\205
\326 \210\307!\203	
\310\202
\212\335\314x\210iT ])j)\207" [fortran-comment-line-start-skip fortran-comment-indent-style fortran-comment-indent-char indent-tabs-mode fortran-continuation-string fortran-minimum-statement-indent-tab beginning-of-line looking-at 0 string 32 9 nil insert-char "	[1-9]" delete-char 2 5 " \\{5\\}[^ 0\n]" 6 fortran-numerical-continuation-char 1 delete-horizontal-space regexp-quote "[0-9]+" message "Warning: line number exceeds 5-digit limit." "0-9" fortran-find-comment-start-skip " 	" fortran-minimum-statement-indent-fixed fortran-line-number-indent comment-column] 7 (#$ . 50230)])
#@103 Return t if current line's line number is correctly indented.
Do not call if there is no line number.
(defalias 'fortran-line-number-indented-correctly-p #[0 "\212\301 \210\302\303w\210iX\205iU\206\304\303w\210i\305U)\207" [fortran-line-number-indent beginning-of-line " 	" nil "0-9" 5] 2 (#$ . 52062)])
#@96 When called from a numbered statement, return t if matching DO is found.
Otherwise return nil.
(defalias 'fortran-check-for-matching-do #[0 "\301\302
\212\303 \210\304\305!\205;\306\302w\210\307\302w\210`\310\302w\210`{\262
\303 \210\214\212\311 \210\312\313\314\315\260\302\301#\205:\304\316P!**\207" [case-fold-search t nil beginning-of-line looking-at "[ 	]*[0-9]+" " 	" "0" "0-9" narrow-to-defun re-search-backward "\\(^[ 	0-9]*do[ 	]*0*" "\\b\\)\\|\\(^[ 	]*0*" "\\b\\)" "^[ 	0-9]*do[ 	]*0*"] 8 (#$ . 52378)])
#@197 Move to past `comment-start-skip' found on current line.
Return non-nil if `comment-start-skip' found, nil if not.
If ALL is nil, only match comments that start in column > 0.

(fn &optional ALL)
(defalias 'fortran-find-comment-start-skip #[256 "\211\204\205J`\203	\302Q\202	\303
\304 \305#\205H\204*\306\224\307 V\203D\310 \311\312\"\216\313\306\224!)?\262
\204B\314!\203D`\207
b\210\315\266\202\207" [comment-start-skip fortran-comment-line-start-skip "\\|" re-search-forward line-end-position t 0 line-beginning-position match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] fortran-is-in-string-p fortran-find-comment-start-skip nil] 7 (#$ . 52906)])
#@85 Return non-nil if WHERE (a buffer position) is inside a Fortran string.

(fn WHERE)
(defalias 'fortran-is-in-string-p #[257 "\212\211b\210n\203\f\303\202\271\212\304 \210\305!)\203\303\202\271\306	\205#\307	!\310\303\211\311 \210\312 \210\203\264\305!\204Ll\204L\3138\204Y	\203Y	\314h!\232\203Y\303y\315V\203,\303\262\202,n\203a\316\303w\210i\317U\203m\320u\210\202~i\317W\203~\n\314g!\232\203~\320u\210\321 \262

^\262	\203\232\212\322\310#\203\231`^\262)`W\203\256\323`\303\211	%\262\202,\303\262\202,\3138\266\205)\207" [fortran-comment-line-start-skip comment-start fortran-continuation-string nil beginning-of-line looking-at (0 nil nil nil nil nil 0) regexp-quote t fortran-next-statement fortran-previous-statement 3 char-to-string 0 " 	0-9" 5 1 line-end-position re-search-forward parse-partial-sexp] 12 (#$ . 53613)])
(defalias 'fortran-auto-fill-mode 'auto-fill-mode)
#@51 Fill the current line at an appropriate point(s).
(defalias 'fortran-fill #[0 "\306`\307 \310 \211\311 \\^\212b\210\312	!?\205\\\313\211\314\n!\210\315`\211\262!\205Z\212\316\317\320#\210\2037`\2029`T\262
)\321\322\320#\203G\323u\210`
Z\n\324Z\fZV\203Y
\266\202\202\\\211\266\202)\211\206\326\212\314\203l\nT\202m\n!\210\320\211\203\262\313\262
\316
\"\210\204\242\312!\203\234\325i\\\nV\203\226\320\262
\202p\325u\210\202p\326u\210\202p\327u\210\312!\204p\313u\210\202p\210`X\203\311\314\nT!\210\321\330\320#\204\311b\210n\203\324\321\331\320#\210`)\212\332 \210\333 \204\343\320\202\352\334\224b\210`
Y)\205
\212\211b\210n)?\205
\212b\210i)\nT\335 \f\\^V\205
\211b\210\336 \210\313)\207" [auto-fill-function fortran-comment-line-start-skip fill-column fortran-break-before-delimiters fortran-continuation-indent fortran-break-delimiters-re fortran-auto-fill line-beginning-position line-end-position fortran-current-line-indentation looking-at nil move-to-column fortran-is-in-string-p re-search-backward "\\S\"\\s\"\\S\"?" t re-search-forward "\\S\"\\s\"\\S\"" -2 6 2 1 -1 "[-	\n,'+/*)=]" "[ 	]" beginning-of-line fortran-find-comment-start-skip 0 fortran-calculate-indent fortran-break-line fortran-no-break-re] 10 (#$ . 54539)])
#@75 Call `fortran-split-line'.  Joins continuation lines first, then refills.
(defalias 'fortran-break-line #[0 "\302 \212\303 \205\304\305\224\306 \")\212\307y\210\310\311!)\203+\307\210`\305\225|\210\312 \210\313 \210\202.\314 \210\211\205U\212
b\210\307\210\312 \210\310!\203F\305\202P\212\315\307x\210iT	])j\210\211c)\207" [fortran-comment-line-start-skip comment-column line-beginning-position fortran-find-comment-start-skip delete-and-extract-region 0 line-end-position nil looking-at " \\{5\\}[^ 0\n]\\|	[1-9]" delete-horizontal-space fortran-fill fortran-split-line " 	"] 4 (#$ . 55829)])
#@198 Return nil if fixed format is used, t if TAB formatting is used.
Use `fortran-tab-mode-default' if no non-comment statements are found
before the end or in the first `fortran-analyze-depth' lines.
(defalias 'fortran-analyze-file-format #[0 "\302\212eb\210m\204&\303f\304=\204&\305\306!\204&\211V\204&\303y\210\211T\262
\202\303f\304=\2031\307\202<\305\306!\203;\303\202<	)\207" [fortran-analyze-depth fortran-tab-mode-default 0 nil 9 looking-at " \\{6\\}" t] 3 (#$ . 56440)])
#@342 Fill surrounding comment block as paragraphs, else fill statement.
Intended as the value of `fill-paragraph-function'.
A comment block is filled by calling `fill-comment-paragraph' with
argument JUSTIFY, otherwise `fortran-fill-statement' is called.
Always returns non-nil (to prevent `fill-paragraph' being called).

(fn &optional JUSTIFY)
(defalias 'fortran-fill-paragraph #[256 "\300
!\206\f\301 \206\f\302\207" [fill-comment-paragraph fortran-fill-statement t] 3 (#$ . 56934) "*P"])
#@47 Fill a Fortran statement up to `fill-column'.
(defalias 'fortran-fill-statement #[0 "\303\212\304 \210\305\306!\206\305	!\206\n\205\305\307\n\310Q!)\2046\212\311 \210\312 \210\313 \210\314y\210\315 \204*\312 \210)\313 )\207" [auto-fill-function fortran-comment-line-start-skip comment-start-skip fortran-auto-fill beginning-of-line looking-at "[ 	]*$" "[ 	]*\\(?:" "\\)" fortran-next-statement fortran-previous-statement fortran-indent-line nil fortran-remove-continuation] 4 (#$ . 57429) "*"])
#@271 Delete all text in column `fortran-line-length' (default 72) and up.
This is assumed to be sequence numbers.  Normally also deletes
trailing whitespace after stripping such text.  Supplying prefix
arg DO-SPACE prevents stripping the whitespace.

(fn &optional DO-SPACE)
(defalias 'fortran-strip-sequence-nos #[256 "\212eb\210\301\302\303\"\304\305#\205!\306\307\304\211\211\310%\210\211\204\311 \210\202)\207" [fortran-line-length re-search-forward format "^.\\{%d\\}\\(.*\\)" nil t replace-match "" 1 delete-horizontal-space] 7 (#$ . 57940) "*p"])
#@71 Function to use for `add-log-current-defun-function' in Fortran mode.
(defalias 'fortran-current-defun #[0 "\212\302 \210\303\304	\212\305 \210`)\303#\2038\306\307!\2069\304\310\311\303#\203+\312u\210\313\311x\210\202.\311\210\314`\315 \210`\"\2029\316*\207" [case-fold-search fortran-start-prog-re fortran-beginning-of-subprogram t re-search-forward fortran-end-of-subprogram match-string-no-properties 2 "[(\n]" nil -1 " 	" buffer-substring-no-properties backward-sexp "main"] 4 (#$ . 58501)])
#@24 Menu for Fortran mode.
(defvar fortran-menu nil (#$ . 59010))
(byte-code "\302\303\304\305\306\307\310	B\311\310!)\312BB\313BBB$\210\314\310!\207" [fortran-mode-map features easy-menu-do-define fortran-menu "Menu for Fortran mode." "Fortran" ["Manual" (info "(emacs)Fortran") :active t :help "Read the Emacs manual chapter on Fortran mode"] "Customization" fortran custom-menu-create (["Set" Custom-set :active t :help "Set current value of all edited settings in the buffer"] ["Save" Custom-save :active t :help "Set and save all edited settings"] ["Reset to Current" Custom-reset-current :active t :help "Reset all edited settings to current"] ["Reset to Saved" Custom-reset-saved :active t :help "Reset all edited or set settings to saved"] ["Reset to Standard Settings" Custom-reset-standard :active t :help "Erase all customizations in buffer"]) ("--" ["Comment Region" fortran-comment-region mark-active] ["Uncomment Region" (fortran-comment-region (region-beginning) (region-end) 1) mark-active] ["Indent Region" indent-region mark-active] ["Indent Subprogram" fortran-indent-subprogram t] "--" ["Beginning of Subprogram" fortran-beginning-of-subprogram :active t :help "Move point to the start of the current subprogram"] ["End of Subprogram" fortran-end-of-subprogram :active t :help "Move point to the end of the current subprogram"] ("Mark" :help "Mark a region of code" ["Subprogram" mark-defun t] ["IF Block" fortran-mark-if t] ["DO Block" fortran-mark-do t]) ["Narrow to Subprogram" narrow-to-defun t] ["Widen" widen t] "--" ["Temporary Column Ruler" fortran-column-ruler :active t :help "Briefly display Fortran column numbers"] ["72-column Window" fortran-window-create :active t :help "Set window width to Fortran line length"] ["Full Width Window" (enlarge-window-horizontally (- (frame-width) (window-width))) :active (not (window-full-width-p)) :help "Make window full width"] ["Momentary 72-Column Window" fortran-window-create-momentarily :active t :help "Briefly set window width to Fortran line length"] "--" ["Break Line at Point" fortran-split-line :active t :help "Break the current line at point"] ["Join Line" fortran-join-line :active t :help "Join the current line to the previous one"] ["Fill Statement/Comment" fill-paragraph t] "--" ["Toggle Auto Fill" auto-fill-mode :selected auto-fill-function :style toggle :help "Automatically fill text while typing in this buffer"] ["Toggle Abbrev Mode" abbrev-mode :selected abbrev-mode :style toggle :help "Expand abbreviations while typing in this buffer"] ["Add Imenu Menu" imenu-add-menubar-index :active (not (lookup-key (current-local-map) [menu-bar index])) :included (fboundp 'imenu-add-to-menubar) :help "Add an index menu to the menu-bar"]) provide] 9)