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

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

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

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


(byte-code "\300\301\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\302\321\322\323\324\325\307\311&	\210\317\326\327\330\322\331\332\333\307\311&	\210\317\334\335\336\322\337\324\340\307\311&	\210\317\341\335\342\322\337\324\340\307\311&	\210\317\343\335\344\322\337\324\340\307\311&	\210\317\345\346\347\322\337\324\340\307\311&	\210\317\350\351\352\322\353\324\354\307\311&	\210\317\355\356\357\322\337\324\340\307\311\307\315&\210\317\360\361\362\363\364\322\331\324\365\307\315&\210\317\366\367\370\363\364\322\371\324\365\307\315&\210\317\372\373\374\363\375\322\371\324\365\307\311&\210\317\376\377\201@\322\337\324\340\307\311&	\210\317\201A\201B\201C\322\337\324\340\307\311&	\210\317\201D\201E\201F\322\331\324\201G\307\315&	\210\317\201H\201I\201J\322\337\324\340\307\311&	\210\317\201K\302\201L\322\323\324\325\307\301&	\210\317\201M\302\201N\322\323\324\325\307\301&	\210\317\201O\201P\201Q\322\331\324\201R\307\301&	\210\317\201S\201T\201U\322\331\324\365\307\315&	\210\317\201V\333\201W\322\323\324\325\307\301&	\210\317\201X\201Y\201Z\322\331\324\365\307\301&	\210\317\201[\201\\\201]\322\331\324\365\307\301&	\210\317\201^\201_\201`\322\337\324\340\307\301&	\210\317\201a\333\201b\322\323\324\325\307\301&	\210\317\201c\201d\201e\322\337\324\340\201f\201g\201h\201i\363\201j\307\301&\210\201k\201c!\210\317\201l\302\201m\322\201n\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 "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 (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 (lambda nil (interactive) (describe-variable 'fortran-tab-mode-string)))) "String to appear in mode line in TAB format buffers.\nSee Info node `(emacs)ForIndent Cont'." string :risky t fortran-do-indent 3 "Extra indentation applied to DO blocks." integer integerp fortran-if-indent "Extra indentation applied to IF, SELECT CASE and WHERE blocks." fortran-structure-indent "Extra indentation applied to STRUCTURE, UNION, MAP and INTERFACE blocks." fortran-continuation-indent 5 "Extra indentation applied to continuation lines." fortran-comment-indent-style 'fixed "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)) #[(value) "\301>\207" [value (nil fixed relative)] 2] fortran-comment-line-extra-indent 0 "Amount of extra indentation for text within full-line comments." fortran-comment-line-start "C" "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 "^[CcDd*!]\\(\\([^ 	\n]\\)\\2+\\)?[ 	]*" "Regexp to match the start of a full-line comment." regexp fortran-directive-re "^[ 	]*#.*" "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 6 "Minimum statement indentation for fixed format continuation style." fortran-minimum-statement-indent-tab (max tab-width 6) "Minimum statement indentation for TAB format continuation style." fortran-comment-indent-char " " "Single-character string inserted for Fortran comment indentation.\nNormally a space." #[(value) "\301!\206;\205G\302U\207" [value characterp 1] 2] fortran-line-number-indent 1 "Maximum indentation for Fortran line numbers.\n5 means right-justify them within their five-column field." fortran-check-all-num-for-matching-do "Non-nil causes all numbered lines to be treated as possible DO loop ends." fortran-blink-matching-if "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 "$" "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 \"$\"." #[(value) ";\205	G\301U\207" [value 1] 2] fortran-comment-region "c$$$" "String inserted by \\[fortran-comment-region] at start of each line in region." fortran-electric-line-number "Non-nil causes line numbers to be moved to the correct column as typed." fortran-column-ruler-fixed "0   4 6  10        20        30        40        50        60        70\n[   ]|{   |    |    |    |    |    |    |    |    |    |    |    |    |}\n" "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       810        20        30        40        50        60        70\n[   ]|  { |    |    |    |    |    |    |    |    |    |    |    |    |}\n" "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 100 "Number of lines to scan to identify fixed or TAB format style." fortran-break-before-delimiters "Non-nil causes filling to break lines before delimiters.\nDelimiters are characters matching the regexp `fortran-break-delimiters-re'." fortran-line-length 72 "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 #[(_symbol value) "\301\302\"\207" [value fortran-line-length t] 3] "23.1" make-variable-buffer-local fortran-mode-hook "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 "[-+*/><=, 	]" (#$ . 7753))
#@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 "\\(\\*\\*\\|/[/=]\\|<=\\|=[=>]\\|>=\\)" (#$ . 8061))
#@47 Regexp matching the start of an IF statement.
(defconst fortran-if-start-re "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?if[ 	]*(" (#$ . 8415))
#@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\\)\\)" (#$ . 8552))
#@51 Regexp possibly matching the end of a subprogram.
(defconst fortran-end-prog-re1 "end\\([ 	]*\\(program\\|subroutine\\|function\\|block[ 	]*data\\)\\>\\([ 	]*\\(\\sw\\|\\s_\\)+\\)?\\)?" (#$ . 8766))
#@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) (#$ . 8972))
#@32 Regexp matching Fortran types.
(defconst fortran-type-types (byte-code "\303\304\305\306\307\310\311\312\313\314\315\n\"\n\314\316	\"	%+\317\"!\320#\321Q\207" [other-types structured-types simple-types "\\<" 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 #[(x) "\301P\207" [x "implicit "] 2] #[(x) "\301P\207" [x "end "] 2] paren "[ 	]*" "\\>"] 11) (#$ . 9167))
#@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))) (#$ . 9775))
#@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) (#$ . 10042))
#@144 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.
(defalias 'fortran-match-and-skip-declaration #[(limit) "\302\303!\2057\304\225\203-\304\225\304\224Z\305V\203-`\306\307x\210\310\311!\210\302\312!\204,b\210\302\303!\210)\313 \314\216\307\315\316\217*\207" [pos save-match-data-internal looking-at "[ \n	*]*\\(\\sw+\\)[ 	\n]*\\(((?\\)?" 2 1 " 	\n" nil skip-syntax-backward "w" "\\(\\sw+\\)[ 	\n]*\\sw+[ 	\n]*\\(((?\\)?" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) (byte-code "\214e}\210\301\225b\210\302\303!\204\304`\301\"\206db\210\202	\305\225b)\207" [limit 1 looking-at "[ 	\n]*\\(\\(,\\)\\|;\\|\\'\\)" scan-sexps 2] 3) ((error t))] 3 (#$ . 10819)])
#@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) (#$ . 11638))
#@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) (#$ . 12431))
#@172 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.
(defalias 'fortran-make-syntax-propertize-function #[(line-length) "\300\301!\207" [eval (syntax-propertize-rules ("^[cd\\*]" (0 "<")) ((format "^[^cd\\*	\n].\\{%d\\}\\(.+\\)" (1- line-length)) (1 "<")))] 2 (#$ . 13346)])
#@51 Default expressions to highlight in Fortran mode.
(defvar fortran-font-lock-keywords fortran-font-lock-keywords-1 (#$ . 13745))
#@55 Value for `imenu-generic-expression' in Fortran mode.
(defvar fortran-imenu-generic-expression (byte-code "\301\302\303\304\305\306\307\260\310E\311D\207" [fortran-continuation-string nil "^\\s-+\\(" "\\(\\sw\\|\\s-\\|[*()+]\\)*" "\\<function\\|subroutine\\|entry\\|block\\s-*data\\|program\\)" "[ 	" "]+" "\\(\\sw+\\)" 3 (nil "^\\s-+\\(block\\s-*data\\)\\s-*$" 1)] 8) (#$ . 13879))
#@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\\)" (#$ . 14271))
#@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 "\\|!\\|$\\)") (#$ . 14621))
#@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\\)[ 	]*" (#$ . 14921))
(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 "\301 \302\303\304#\210\302\305\306#\210\302\307\304#\210\302\310\304#\210\302\311\304#\210\302\312\304#\210\302\313\304#\210\302\314\304#\210\302\315\316#\210\302\317\316#\210\302\320\321#\210\302\322\323#\210\302\324\323#\210\302\325\323#\210\302\326\327#\210\302\330\331#\210)\207" [table make-syntax-table modify-syntax-entry 59 "." 13 " " 43 45 61 42 47 37 39 "\"" 34 92 "\\" 46 "_" 95 36 33 "<" 10 ">"] 4) (#$ . 15671))
#@69 Syntax table used to parse Fortran expressions for printing in GUD.
(defvar fortran-gud-syntax-table (byte-code "\302!\303\304\305	#\210	)\207" [fortran-mode-syntax-table st make-syntax-table modify-syntax-entry 10 "."] 4) (#$ . 16201))
#@30 Keymap used in Fortran mode.
(defvar fortran-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\302\323\324#\210\302\325\326#\210\302\327\330#\210\302\331\330#\210\302\332\333#\210\302\334\333#\210\302\335\333#\210\302\336\333#\210\302\337\333#\210\302\340\333#\210\302\341\333#\210\302\342\333#\210\302\343\333#\210\302\344\333#\210\345\346!\210\347\350\351\352\353\354\355\356!\357BB\360BBB$\210)\207" [map 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" (lambda (#1=#:def-tmp-var) (defvar fortran-menu #1# #2="Menu for Fortran mode.")) nil easy-menu-do-define fortran-menu #2# "Fortran" ["Manual" (info "(emacs)Fortran") :active t :help "Read the Emacs manual chapter on Fortran mode"] "Customization" custom-menu-create fortran (["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"])] 9) (#$ . 16446))
(byte-code "\300\301\302\303\304\"\305\306\307%\210\310\311N\204\312\310\311\313\314!#\210\315\316!\204%\312\316\317\320#\210\300\207" [define-abbrev-table fortran-mode-abbrev-table mapcar #[(e) "@A\301\302\303\257\207" [e nil :system t] 5] ((";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:]_]*" fortran-mode-hook variable-documentation put purecopy "Hook run when 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] 6)
(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)
#@2976 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 #[nil "\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 #[(start end) "\304\211\305\n\304#*\207" [indent-region-function fortran-blink-matching-if start end nil indent-region] 4] 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 (#$ . 22186) nil])
#@444 Set the length of fixed-form Fortran lines to NCHARS.
This normally 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.
If a numeric prefix argument is specified, it will be used as NCHARS,
otherwise is a non-numeric prefix arg is specified, the length will be
provided via the minibuffer, and otherwise the current column is used.
(defalias 'fortran-line-length #[(nchars &optional global) "\203	\306 \202pC\307\211\203C\n@r	q\210\310\311!\203;\f=\204;\f\211\312\f!\313e!\210\f\203;\314\315!\210)\nA\211\204*\205L\316\303\f\"\207" [global buff --dolist-tail-- fortran-line-length nchars fill-column buffer-list nil derived-mode-p fortran-mode fortran-make-syntax-propertize-function syntax-ppss-flush-cache font-lock-mode 1 set-default syntax-propertize-function] 4 (#$ . 27786) (list (cond ((numberp current-prefix-arg) current-prefix-arg) (current-prefix-arg (read-number "Line length: " (default-value 'fortran-line-length))) (t (current-column))))])
#@56 Fortran mode adds this to `hack-local-variables-hook'.
(defalias 'fortran-hack-local-variables #[nil "\300!\207" [fortran-line-length] 2 (#$ . 28880)])
(defalias 'fortran-gud-find-expr #[nil "\303 p\304\216\305\n!\210\306 +\207" [#1=#:buffer #2=#:table fortran-gud-syntax-table syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table gud-find-c-expr] 2])
#@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 #[nil "\302!\203\303\207\212\304\305x\210iT	])\207" [fortran-comment-line-start-skip comment-column looking-at 0 " 	" nil] 2 (#$ . 29291)])
(put 'fortran-comment-indent 'byte-optimizer 'byte-compile-inline-expand)
#@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 #[nil "\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 (#$ . 29755) "*"])
#@232 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.
(defalias 'fortran-comment-region #[(beg-region end-region arg) "\306!\307 b\210\310 \210\f\203B\311
!\312!\203\"`\313\225|\210\314\315y!\203>`\nW\203>\312!\203\"`\313\225|\210\202\")\202X
c\210\314\315y!\203X`\nW\203X
c\210\202E	b\210\n\316\211\223\210	\316\211\223*\207" [end-region save-point end-region-mark beg-region arg fortran-comment-region copy-marker point-marker beginning-of-line regexp-quote looking-at 0 zerop 1 nil com] 3 (#$ . 30933) "*r\nP"])
#@37 Uncomment every line in the region.
(defalias 'fortran-uncomment-region #[(start end &optional ignored) "\302	\303#\207" [start end fortran-comment-region t] 4 (#$ . 31651)])
#@110 Typing ;\[help-command] or ;? lists all the Fortran abbrevs.
Any other key combination is executed normally.
(defalias 'fortran-abbrev-start #[nil "c\210\306\307!\203\307 \202\310 \306\311!\203\311	!\202	\203:\n\312=\2045\n\f=\2045	
>\203:\313 \202A	\fB\211\f*\207" [last-command-event event char abbrev-mode help-char help-event-list fboundp next-command-event read-event event-to-character 63 fortran-abbrev-help unread-command-events] 2 (#$ . 31834) "*"])
#@53 List the currently defined abbrevs in Fortran mode.
(defalias 'fortran-abbrev-help #[nil "\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 (#$ . 32318) nil])
#@57 Create a buffer listing the Fortran mode abbreviations.
(defalias 'fortran-prepare-abbrev-list-buffer #[nil "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 (#$ . 32593)])
#@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 #[nil "\303\203		\202\n\n\212\304 \210\305\306 !\307\306 !=\203 \310\311!\202!`)\312\313$\207" [indent-tabs-mode fortran-column-ruler-tab fortran-column-ruler-fixed momentary-string-display beginning-of-line window-start selected-window window-point line-beginning-position 2 nil "Type SPC or any command to erase ruler."] 5 (#$ . 32961) nil])
#@112 Make the window `fortran-line-length' (default 72) columns wide.
See also `fortran-window-create-momentarily'.
(defalias 'fortran-window-create #[nil "\304\305 \204\306\307\310 \311 \312#!\210\301 \307\304	8	@\311 #\313\n\\!\210*\314\312!\210\315\316\317\"\210\320\321 !)\207" [window-min-width window-edges scroll-bar-width fortran-line-length 2 window-full-width-p enlarge-window-horizontally - frame-width window-width 1 split-window-right other-window switch-to-buffer " fortran-window-extra" t select-window previous-window] 5 (#$ . 33612) nil])
#@179 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'.
(defalias 'fortran-window-create-momentarily #[(&optional arg) "\203\n\304U\203'\305 \306\216\307\310\311\217\210\312\313!\210\314 \211\315\232\206%\nC\211+\207\316 \207" [arg #1=#:wconfig char unread-command-events 1 current-window-configuration ((set-window-configuration #1#)) nil (fortran-window-create) ((error (error "No room for Fortran window"))) message "Type SPC to continue editing." read-event 32 fortran-window-create] 4 (#$ . 34176) "p"])
#@67 Break line at point and insert continuation marker and alignment.
(defalias 'fortran-split-line #[nil "\303 \210\212`\304 \210\305\306!\205\307\224W*\203!\310\311\307!\261\210\2024	\203/\310\312\313 \261\210\2024\314\n\261\210\315 \207" [pos 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 (#$ . 34821) "*"])
#@94 Delete any Fortran continuation characters at point.
Returns t if anything actually deleted.
(defalias 'fortran-remove-continuation #[nil "\300\301!\205\302\303!\210\304 \210\305\207" [looking-at "\\( \\{5\\}[^ 0\n]\\|	[1-9]\\|&\\)" replace-match "" delete-indentation t] 2 (#$ . 35307)])
#@225 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.
(defalias 'fortran-join-line #[(arg) "\212\301V\203
[\211y\210\302!\204$\303 \210\304 \204\305 \210S\202
\306 )\207" [arg 0 zerop beginning-of-line fortran-remove-continuation delete-indentation fortran-indent-line] 3 (#$ . 35605) "*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 #[nil "\212\300y\210\301\302!\203\303`Tf\304Z\305\246\\\202\303)\207" [-1 looking-at "	[1-9]" 49 48 9] 3 (#$ . 36085)])
(put 'fortran-electric-line-number 'delete-selection t)
#@130 Self insert, but if part of a Fortran line number indent it automatically.
Auto-indent does not happen if a numeric ARG is used.
(defalias 'fortran-electric-line-number #[(arg) "\204	\204\203\306\307!!\207\306\310!\207i\311U\203'\212\312 \210\313\314!)\204Z\n\203/\2020\fiU\203I\315 f\316=\203I
\317=\204I
\320=\203Z\212\321\322\315 \323#)\204Z\313\324!\203`\306\307!!\207\325\326x\210c\210\317 \207" [arg fortran-electric-line-number indent-tabs-mode fortran-minimum-statement-indent-tab fortran-minimum-statement-indent-fixed last-command 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 last-command-event] 4 (#$ . 36495) "*P"])
#@58 Check a preliminary match against `fortran-end-prog-re'.
(defalias 'fortran-check-end-prog-re #[nil "\302 \303\216\304\305\306\225\307 	\310 \\^{\"*\207" [save-match-data-internal fortran-line-length match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "^\\s-*\\(\\'\\|\\s<\\)" 0 line-end-position line-beginning-position] 6 (#$ . 37311)])
#@64 Move point to the beginning of the current Fortran subprogram.
(defalias 'fortran-beginning-of-subprogram #[nil "\303\304n\203\305\202\f\306!\210\307 \310\216\311\n!\206/\312 \313=\206/\314\315\215\204-\311\316!?\205/\317 +\207" [case-fold-search save-match-data-internal fortran-start-prog-re t beginning-of-line 0 1 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) looking-at fortran-previous-statement first-statement ok (byte-code "\301\302\303#\205\304 \203\305\306\307\"\210\202\207" [fortran-end-prog-re re-search-backward nil move fortran-check-end-prog-re throw ok t] 4) "^\\([ 	]*[0-9]\\|[ 	]+[^!#]\\)" fortran-next-statement] 2 (#$ . 37715) nil])
#@58 Move point to the end of the current Fortran subprogram.
(defalias 'fortran-end-of-subprogram #[nil "\303\304 \210\305 \306\216\307\n\310\311#\203\312 \203\n\310y+\207" [case-fold-search save-match-data-internal fortran-end-prog-re t beginning-of-line match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) re-search-forward nil move fortran-check-end-prog-re] 4 (#$ . 38443) nil])
#@219 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 #[nil "\306\211\307 \210\310\n!?\205\"\310!?\205\"\310\311\312\f!P!\206\"\310\313!\314\315y!\211\203P\310\n!\204#\310!\204#\310\311\312\f!P!\204#\310\316!\204#\310\311
P!\204#\203^	\204^\317\320!\202m\203g\321 \202m	?\205m\322*\207" [continue-test not-first-statement 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]" zerop -1 "[ 	]*$\\| \\{5\\}[^ 0\n]\\|	[1-9]" message "Incomplete continuation statement." fortran-previous-statement first-statement] 4 (#$ . 38879) nil])
#@213 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 #[nil "\304\305 \210\306\307y!\205m?\211\203-\310	!\204\310\n!\204\310\311!\204\310\312P!\204?\2053\313)\207" [not-last-statement fortran-comment-line-start-skip fortran-directive-re comment-start-skip nil beginning-of-line zerop 1 looking-at "[ 	]*$\\|     [^ 0\n]\\|	[1-9]" "[ 	]*" last-statement] 3 (#$ . 39769) nil])
#@73 Return non-nil if at the start of a line with an IF ... THEN statement.
(defalias 'fortran-looking-at-if-then #[nil "`\302 \205\212b\210\303 	U)*\207" [i p fortran-beginning-if line-beginning-position] 2 (#$ . 40358)])
#@278 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.
(defalias 'fortran-end-of-block #[(&optional num) "\306\307!\203\310`\311\"\210\203\312W\203\313[!\210\311\206 \314\315\210	\312V\203\201\316\317\f\2036\320\2027\321\322R\315\323#\203\201\324 \210\325\326
P!\203O\327 \202S\325!\203\\	T\202{\325!\204x\325\330!\204s\f\203{\325\331!\203{\332 \203{	S\315\210\202%	\312V\205\212\333\334!*\207" [num count case-fold-search fortran-blocks-re fortran-check-all-num-for-matching-do fortran-if-start-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" fortran-start-block-re fortran-end-block-re] 5 (#$ . 40590) "p"])
#@280 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.
(defalias 'fortran-beginning-of-block #[(&optional num) "\306\307!\203\310`\311\"\210\203\312W\203\313[!\210\311\206 \314\315 \210	\312V\203\200\316\317\f\2036\320\2027\321\322R\323\324#\203\200\315 \210\325\326
P!\203O\327 \202S\325!\203]	S\211\202&\325!\204y\325\330!\204t\f\203%\325\331!\203%\332 \203%	T\211\202&	\312V\205\211\333\334!*\207" [num count case-fold-search fortran-blocks-re fortran-check-all-num-for-matching-do fortran-if-start-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" fortran-start-block-re fortran-end-block-re] 6 (#$ . 41729) "p"])
#@105 From a line matching REGEX, blink matching KEYWORD statement line.
Use function FIND-BEGIN to match it.
(defalias 'fortran-blink-match #[(regex keyword find-begin) "\306 `\307\310\211\212\311 \210\312\310w\210\313
!)\205U \211\204+\314\315Q\202@	\fW\203@\212	b\210\311 \210\316`\317 {P)\203K\300\320\"\202U	b\210\321!\210b-\207" [message matching case-fold-search end-point top-of-window regex window-start t nil beginning-of-line " 	0-9" looking-at "No matching " "." "Matches " line-end-position "%s" sit-for find-begin keyword blink-matching-delay] 5 (#$ . 42871)])
#@67 From an ENDIF or ELSE statement, blink the matching IF statement.
(defalias 'fortran-blink-matching-if #[nil "\300\301\302\303#\207" [fortran-blink-match "e\\(nd[ 	]*if\\|lse\\([ 	]*if\\)?\\)\\b" "if" fortran-beginning-if] 4 (#$ . 43469)])
#@71 From an ENDDO statement, blink the matching DO or DO WHILE statement.
(defalias 'fortran-blink-matching-do #[nil "\300\301\302\303#\207" [fortran-blink-match "end[ 	]*do\\b" "do" fortran-beginning-do] 4 (#$ . 43715)])
#@98 Put mark at end of Fortran DO [WHILE]-ENDDO construct, point at beginning.
The marks are pushed.
(defalias 'fortran-mark-do #[nil "\302\211\303 \211\205 \304 \211\204\305\306!\202 	b\210\307 \210b*\207" [do-point enddo-point nil fortran-end-do fortran-beginning-do message "No matching do." push-mark] 2 (#$ . 43939) nil])
#@64 Search forward for first unmatched ENDDO.
Return point or nil.
(defalias 'fortran-end-do #[nil "\303\212\304 \210\305\306w\210\307\310!)\203\311\224\202U\212\312\313	!\204M\314 \315=\204M\307\n!\2031\316 \204M\305\306w\210\307\310!\203A	S\202\307\317!\203	T\202\313	!\205T`*)\207" [case-fold-search count fortran-end-prog-re t beginning-of-line " 	0-9" nil looking-at "end[ 	]*do\\b" 0 1 zerop fortran-next-statement last-statement fortran-check-end-prog-re "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?do[ 	]+[^0-9]"] 2 (#$ . 44277)])
#@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 #[nil "\304\305\212\306 \210\307\310w\210\311!)\203\312\224\202W\212\313\314\n!\204O\315 \316=\204O\311!\2033\317 \204O\307\310w\210\311!\203C\nS\202\311\320!\203\nT\202\314\n!\205V`**\207" [dostart-re case-fold-search count fortran-end-prog-re t "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?do[ 	]+[^0-9]" beginning-of-line " 	0-9" nil looking-at 0 1 zerop fortran-previous-statement first-statement fortran-check-end-prog-re "end[ 	]*do\\b"] 2 (#$ . 44826)])
#@90 Put mark at end of Fortran IF-ENDIF construct, point at beginning.
The marks are pushed.
(defalias 'fortran-mark-if #[nil "\302\211\303 \211\205 \304 \211\204\305\306!\202 	b\210\307 \210b*\207" [if-point endif-point nil fortran-end-if fortran-beginning-if message "No matching if." push-mark] 2 (#$ . 45459) nil])
#@65 Search forwards for first unmatched ENDIF.
Return point or nil.
(defalias 'fortran-end-if #[nil "\305\212\306 \210\307\310w\210\311\312!)\203\313\224\202y\212\314\315	!\204q\316 \317=\204q\311\n!\2031\320 \204q\307\310w\210\311\312!\203A	S\202\311!\203\212\311\321!\204j\310\315\314y!\203e\311\322!\203e\311\323!\211\203P\f)\203m	T)\202\315	!\205x`*)\207" [case-fold-search count fortran-end-prog-re fortran-if-start-re then-test t beginning-of-line " 	0-9" nil looking-at "end[ 	]*if\\b" 0 1 zerop 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]"] 2 (#$ . 45789)])
#@68 Search backwards for first unmatched IF-THEN.
Return point or nil.
(defalias 'fortran-beginning-if #[nil "\306\212\307 \310=\204
\311 \210\312\313w\210\314	!\205<\315 \316\216\314\317!\206;\313\320\321y!\2039\314\322!\2039\314\323!\211\203$)*)\203E\324\224\202\250\212\321\320\f!\204\240\307 \310=\204\240\314
!\203`\325 \204\240\312\313w\210\314	!\203\224\212\314\317!\204\215\313\320\321y!\203\210\314\322!\203\210\314\323!\211\203s)\203\220\fS)\202H\314\326!\203H\fT\202H\320\f!\205\247`*)\207" [case-fold-search fortran-if-start-re save-match-data-internal then-test count fortran-end-prog-re t fortran-previous-statement first-statement fortran-next-statement " 	0-9" nil looking-at match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) ".*)[ 	]*then\\b[ 	]*[^ 	(=a-z0-9]" zerop 1 " \\{5\\}[^ 0\n]\\|	[1-9]" ".*then\\b[ 	]*[^ 	(=a-z0-9]" 0 fortran-check-end-prog-re "end[ 	]*if\\b"] 2 (#$ . 46496)])
#@74 Indent current Fortran line based on its contents and on previous lines.
(defalias 'fortran-indent-line #[nil "\304 \212\305 \210\306 U\203\307\310`\311\\\312#\203$\313 \204$\314!\210\202/\305 \210\315 \203/\316 \210)iW\203:\317!\210	\203Q\212\320\210i)\nV\203Q\212\320\210\321 \210)\205Z\303 \210\322 )\207" [cfi 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] 4 (#$ . 47483) "*"])
#@66 Function to use for `normal-auto-fill-function' in Fortran mode.
(defalias 'fortran-auto-fill #[nil "i\301 V\205D\302 \212\303 \210\304 U\203$\305\306`\307\\\310#\203+\311 \204+\312!\210\2026\303 \210\313 \2036\314 \210)\315 \210iW\205C\316!)\207" [cfi 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] 4 (#$ . 48192)])
(defalias 'fortran-indent-new-line 'reindent-then-newline-and-indent)
#@58 Properly indent the Fortran subprogram containing point.
(defalias 'fortran-indent-subprogram #[nil "\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 (#$ . 48833) "*"])
#@63 Calculates the Fortran indent column based on previous lines.
(defalias 'fortran-calculate-indent #[nil "\306\211\307\203	\202\f\n0\212\310 \211\2030\202
`eU\203+0\202/\311 0\312\306w\210\313\314!\203h\313\315!\204^\3061\316\317y!\203X\313\320!\203X\313\321!\2111\203B1)\203
02\\0\202
\313\322!\203x02\\0\202
\313\323!\203\21002\\0\202
\313\324!\203\23002\\0\202
\313\325!\203\25002\\0\202
\313\326!\203\27002\\0\202
\313\327!\203\31002\\0\202
\313\330!\203\33003\\0\202
\313\331!\203\35004\\0\202
\3135!\203\372\332 \203\3720\202
6\203
\313\333!\204
\334 \210\313\335!\203
\336 \203
03Z0)\212\334 \210\313\337!\2046\3137!\2034
\340\2110\2026\3138!\203^
9\341=\203L
0:\\0\202Y
9\342=\203Y
:\\0\340\2026\313\343\344;!P!\204o
\313\320!\203\207
\345\306w\210\346`!\203}
\347\202\202
0<\\0\2026
\20466\203\245
\313\350!\203\245
\336 \203\245
03Z0\2026\312\306w\210\313\351!\203\271
02Z0\2026\313\322!\203\311
02Z0\2026\313\352!\203\331
02Z0\2026\313\326!\203\351
02Z0\2026\313\353!\203\376
\336 \203\376
03Z0\2026\313\354!\20303Z0\2026\313\355!\20304Z0\2026\3135!\2036\332 \20360U\2046\356\357\"\210)0],\207" [indent-tabs-mode fortran-minimum-statement-indent-tab fortran-minimum-statement-indent-fixed fortran-minimum-statement-indent case-fold-search first-statement nil t fortran-previous-statement fortran-current-line-indentation " 	0-9" looking-at "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?if[ 	]*(" ".*)[ 	]*then\\b[ 	]*[^ 	_$(=a-z0-9]" zerop 1 " \\{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 "[ 	]*$" 0 relative fixed "[ 	]*" 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." icol then-test fortran-if-indent fortran-do-indent 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] 5 (#$ . 49123)])
#@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 #[nil "\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 (#$ . 51814)])
#@499 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.
(defalias 'fortran-indent-to-column #[(col) "\212\306 \210\307!\203;	\205
\n;\203\n\310H\202\n\311\312\313#\310\225b\210\f\314x\210`\f\314w\210`|\210\315
iZ\"*\202
\307\316!\203]\203M\310\225b\210\202\334\317\320!\210\315\312\321\"\210c\210\202\334\307\322!\203|\203v\317\323!\210\313\324 \325\261\210\202\334\323u\210\202\334\326 \210m\204\334\307\327!!\203\265\203\254\203\233 \202\235!j\210\317\325!\210\315\324 \325\"\210\202\334\321j\210\325u\210\202\334\307\330!\203\334\321\310\225`ZZ\211\"\310W\203\320\331\332!\210\202\327#\"^j\210)\333\314w\210\326 \210
j\210\334 \205
\310\224b\210i\307!\203\366\310\202

\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 char chars col 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 " 	" indent-tabs-mode fortran-continuation-string fortran-minimum-statement-indent-tab fortran-minimum-statement-indent-fixed extra-space fortran-line-number-indent comment-column] 5 (#$ . 52493)])
#@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 #[nil "\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 (#$ . 54341)])
#@96 When called from a numbered statement, return t if matching DO is found.
Otherwise return nil.
(defalias 'fortran-check-for-matching-do #[nil "\302\303\212\304 \210\305\306!\205;\307\303w\210\310\303w\210`\311\303w\210`{\304 \210\214\212\312 \210\313\314\315\316\317\260\303\302#\205:\305\320P!*+\207" [charnum 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*"] 7 (#$ . 54659)])
#@177 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.
(defalias 'fortran-find-comment-start-skip #[(&optional all) "\204	\205H`	\203\n\306	Q\202\n\307\310 \311#\205G\204,\312\224\313 V\203C\314 \315\216\316\312\224!*\203?\317!\203C`\202G\fb\210\320*\207" [all comment-start-skip fortran-comment-line-start-skip css pos save-match-data-internal "\\|" re-search-forward line-end-position t 0 line-beginning-position match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) fortran-is-in-string-p fortran-find-comment-start-skip nil] 4 (#$ . 55200)])
#@73 Return non-nil if WHERE (a buffer position) is inside a Fortran string.
(defalias 'fortran-is-in-string-p #[(where) "\212b\210n\203\f\306\202\277\212\307 \210\310	!)\203\306\202\277\311\n\205#\312\n!\313\306\211\314 \210\315 \210
\203\272\310	!\204Tl\204T\3168\204a\n\203a\n\317h!\232\203a\306y\320V\2033\306\211\2024n\203i\321\306w\210i\322U\203u\323u\210\202\207i\322W\203\207\317g!\232\203\207\323u\210\324 ^\n\203\241\212\325\313#\203\240`\f^)`W\203\264\326`\f\306\211%\2023\306\211\2047\3168-)\207" [where fortran-comment-line-start-skip comment-start end-of-line parse-limit not-done 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 quoted-comment-start parse-state fortran-continuation-string] 7 (#$ . 55936)])
(defalias 'fortran-auto-fill-mode 'auto-fill-mode)
#@51 Fill the current line at an appropriate point(s).
(defalias 'fortran-fill #[nil "\306`\307 \310 \211\n\311 \\^\212\nb\210\312
!?\205g\313\211 !\314\"!\210\315`\211!!\205f\212\316\317\n\320#\210#\203@`\202B`T )\321\322\320#\203P\323u\210` Z\324\"\325$#V\203d!\202f *)\211%\206\354\212\314#\203{\"T\202}\"!\210\320&&\203\310\313&\316'\n\"\210#\204\270\312(!\203\262\326i\\\"V\203\254\320\211&\202\204\326u\210\202\202\327u\210\202\202\330u\210\312(!\204\202\313u\210\202\202)`\fX\203\340\314\"T!\210\321\331\320#\204\340\nb\210n\203\352\321\332	\320#\210`))\212\333 \210\334 \204\373\320\202
\335\224b\210`)Y)\205.
\212)b\210n)?\205.
\212	b\210i)\"T\336 $\\^V\205.
)b\210\337 \210\313.\207" [auto-fill-function opoint bol eol bos fortran-comment-line-start-skip 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 start fcpoint fill-column fortran-break-before-delimiters fortran-continuation-indent quote repeat fortran-break-delimiters-re fortran-no-break-re fill-point] 6 (#$ . 56925)])
#@75 Call `fortran-split-line'.  Joins continuation lines first, then refills.
(defalias 'fortran-break-line #[nil "\304 \212\305 \205\306\307\224\310 \")\212\311y\210\312\313!)\203-\311\210`\307\225|\210\314 \210\315 \210\2020\316 \210\205W\212	b\210\311\210\314 \210\312\n!\203H\307\202R\212\317\311x\210iT])j\210c)*\207" [comment-string bol 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 (#$ . 58286)])
#@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 #[nil "\303\212eb\210m\204&\304f\305=\204&\306\307!\204&	V\204&\304y\210T\202\304f\305=\2031\310\202<\306\307!\203;\304\202<\n*\207" [i fortran-analyze-depth fortran-tab-mode-default 0 nil 9 looking-at " \\{6\\}" t] 2 (#$ . 58916)])
#@318 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).
(defalias 'fortran-fill-paragraph #[(&optional justify) "\301!\206\f\302 \206\f\303\207" [justify fill-comment-paragraph fortran-fill-statement t] 2 (#$ . 59406) "*P"])
#@47 Fill a Fortran statement up to `fill-column'.
(defalias 'fortran-fill-statement #[nil "\303\212\304 \210\305\306!\206\305	!\206\n\205\305\307\nP!)\2045\212\310 \210\311 \210\312 \210\313y\210\314 \204)\311 \210)\312 )\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] 3 (#$ . 59901) "*"])
#@246 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.
(defalias 'fortran-strip-sequence-nos #[(&optional do-space) "\212eb\210\302\303\304\"\305\306#\205!\307\310\305\211\211\311%\210	\204\312 \210\202)\207" [fortran-line-length do-space re-search-forward format "^.\\{%d\\}\\(.*\\)" nil t replace-match "" 1 delete-horizontal-space] 6 (#$ . 60399) "*p"])
#@71 Function to use for `add-log-current-defun-function' in Fortran mode.
(defalias 'fortran-current-defun #[nil "\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 (#$ . 60958)])
(provide 'fortran)