;ELC   
;;; Compiled by rms@psilocin.ai.mit.edu on Wed Jul  8 20:22:22 1998
;;; from file /gd/gnu/emacs/lisp/progmodes/fortran.el
;;; in Emacs version 20.2.97.2
;;; with bytecomp version 2.47
;;; with all optimizations.

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

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


(byte-code "\302\303!\210\304\305\306\307\310%\210\304\311\306\312	\313\305&\210\304\314\306\315	\313\305&\207" [:group :prefix require easymenu custom-declare-group fortran nil "Fortran mode for Emacs" languages fortran-indent "Indentation variables in Fortran mode" "fortran-" fortran-comment "Comment-handling variables in Fortran mode"] 8)
#@228 *Default tabbing/carriage control style for empty files in Fortran mode.
A value of t specifies tab-digit style of continuation control.
A value of nil specifies that continuation lines are marked
with a character in column 6.
(custom-declare-variable 'fortran-tab-mode-default 'nil '(#$ . -962) :type 'boolean :group 'fortran-indent)
#@59 String to appear in mode line when TAB format mode is on.
(custom-declare-variable 'fortran-tab-mode-string 'nil '(#$ . 1303) :type '(choice (const nil) string) :group 'fortran-indent)
(make-variable-buffer-local 'fortran-tab-mode-string)
#@42 *Extra indentation applied to DO blocks.
(custom-declare-variable 'fortran-do-indent '3 '(#$ . -1548) :type 'integer :group 'fortran-indent)
#@42 *Extra indentation applied to IF blocks.
(custom-declare-variable 'fortran-if-indent '3 '(#$ . -1695) :type 'integer :group 'fortran-indent)
#@75 *Extra indentation applied to STRUCTURE, UNION, MAP and INTERFACE blocks.
(custom-declare-variable 'fortran-structure-indent '3 '(#$ . -1842) :type 'integer :group 'fortran-indent)
#@59 *Extra indentation applied to Fortran continuation lines.
(custom-declare-variable 'fortran-continuation-indent '5 '(#$ . -2029) :type 'integer :group 'fortran-indent)
#@404 *How to indent comments.
nil forces comment lines not to be touched,
'fixed makes fixed comment indentation to `fortran-comment-line-extra-indent'
columns beyond `fortran-minimum-statement-indent-fixed' (for
`indent-tabs-mode' of nil) or `fortran-minimum-statement-indent-tab' (for
`indent-tabs-mode' of t), and 'relative indents to current
Fortran indentation plus `fortran-comment-line-extra-indent'.
(custom-declare-variable 'fortran-comment-indent-style ''fixed '(#$ . -2204) :type '(radio (const :tag "Untouched" nil) (const fixed) (const relative)) :group 'fortran-indent)
#@66 *Amount of extra indentation for text within full-line comments.
(custom-declare-variable 'fortran-comment-line-extra-indent '0 '(#$ . -2789) :type 'integer :group 'fortran-indent :group 'fortran-comment)
#@53 *Delimiter inserted to start new full-line comment.
(custom-declare-variable 'comment-line-start 'nil '(#$ . -3000) :type '(choice string (const nil)) :group 'fortran-comment)
#@52 *Regexp to match the start of a full-line comment.
(custom-declare-variable 'comment-line-start-skip 'nil '(#$ . -3182) :type '(choice string (const nil)) :group 'fortran-comment)
#@69 *Minimum statement indentation for fixed format continuation style.
(custom-declare-variable 'fortran-minimum-statement-indent-fixed '6 '(#$ . -3368) :type 'integer :group 'fortran-indent)
#@67 *Minimum statement indentation for TAB format continuation style.
(custom-declare-variable 'fortran-minimum-statement-indent-tab '(max tab-width 6) '(#$ . -3563) :type 'integer :group 'fortran-indent)
#@86 *Single-character string inserted for Fortran comment indentation.
Normally a space.
(custom-declare-variable 'fortran-comment-indent-char '" " '(#$ . -3770) :type 'string :group 'fortran-comment)
#@107 *Maximum indentation for Fortran line numbers.
5 means right-justify them within their five-column field.
(custom-declare-variable 'fortran-line-number-indent '1 '(#$ . -3974) :type 'integer :group 'fortran-indent)
#@76 *Non-nil causes all numbered lines to be treated as possible DO loop ends.
(custom-declare-variable 'fortran-check-all-num-for-matching-do 'nil '(#$ . -4195) :type 'boolean :group 'fortran)
#@154 *Non-nil causes \[fortran-indent-line] on ENDIF statement to blink on matching IF.
Also, from an ENDDO statement blink on matching DO [WHILE] statement.
(custom-declare-variable 'fortran-blink-matching-if 'nil '(#$ . -4392) :type 'boolean :group 'fortran)
#@352 *Single-character string used for Fortran continuation lines.
In fixed format continuation style, this character is inserted in
column 6 by \[fortran-split-line] to begin a continuation line.
Also, if \[fortran-indent-line] finds this at the beginning of a line, it will
convert the line into a continuation line of the appropriate style.
Normally $.
(custom-declare-variable 'fortran-continuation-string '"$" '(#$ . -4655) :type 'string :group 'fortran)
#@80 *String inserted by \[fortran-comment-region] at start of each line in region.
(custom-declare-variable 'fortran-comment-region '"c$$$" '(#$ . -5116) :type 'string :group 'fortran-comment)
#@80 *Non-nil causes line number digits to be moved to the correct column as typed.
(custom-declare-variable 'fortran-electric-line-number 't '(#$ . -5311) :type 'boolean :group 'fortran)
#@106 String displayed above current line by \[fortran-column-ruler].
This variable used in fixed format mode.
(defvar fortran-column-ruler-fixed "0   4 6  10        20        30        40        50        60        70\n[   ]|{   |    |    |    |    |    |    |    |    |    |    |    |    |}\n" (#$ . 5501))
#@104 String displayed above current line by \[fortran-column-ruler].
This variable used in TAB format mode.
(defvar fortran-column-ruler-tab "0       810        20        30        40        50        60        70\n[   ]|  { |    |    |    |    |    |    |    |    |    |    |    |    |}\n" (#$ . 5811))
#@46 Syntax table in use in Fortran mode buffers.
(defvar fortran-mode-syntax-table nil (#$ . 6116))
#@80 Number of lines to scan to determine whether to use fixed or TAB format style.
(defvar fortran-analyze-depth 100 (#$ . 6218))
#@59 *Non-nil causes filling to break lines before delimiters.
(custom-declare-variable 'fortran-break-before-delimiters 't '(#$ . -6350) :type 'boolean :group 'fortran)
(byte-code "\204a \301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\310#\210\302\312\310#\210\302\313\310#\210\302\314\310#\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\301\207" [fortran-mode-syntax-table make-syntax-table modify-syntax-entry 59 "w" 13 " " 43 "." 45 61 42 47 39 "\"" 34 92 "/" 46 "_" 95 36 33 "<" 10 ">"] 4)
#@46 Subdued level highlighting for Fortran mode.
(defconst fortran-font-lock-keywords-1 nil (#$ . 6973))
#@45 Medium level highlighting for Fortran mode.
(defconst fortran-font-lock-keywords-2 nil (#$ . 7080))
#@44 Gaudy level highlighting for Fortran mode.
(defconst fortran-font-lock-keywords-3 nil (#$ . 7186))
(byte-code "\306\307\310\311\312\313Q\314B\315\316\317\320\321\322\"\323\260\324D\325\326\327\330E\257\331\f\332\n\333Q\334B\332	\333Q\335\336Q\337\340\341E\342\343B\257\"\331\f\332\n\344Q\345\346EC\347\350\351E\fG\233A$*,\314\207" [fortran-logicals fortran-keywords fortran-type-types comment-chars fortran-font-lock-keywords-1 fortran-font-lock-keywords-2 "c!*" "byte\\|c\\(haracter\\|om\\(mon\\|plex\\)\\)\\|d\\(ata\\|imension\\|ouble\\[ 	\\]\\*\\(complex\\|precision\\)\\)\\|e\\(nd\\[ 	\\]\\*\\(map\\|structure\\|union\\)\\|quivalence\\|xternal\\)\\|i\\(mplicit\\[ 	\\]\\*\\(byte\\|c\\(haracter\\|omplex\\)\\|double\\[ 	\\]\\*\\(complex\\|precision\\)\\|integer\\|logical\\|none\\|real\\)\\|nt\\(eger\\|rinsic\\)\\)\\|logical\\|map\\|none\\|parameter\\|re\\(al\\|cord\\)\\|s\\(ave\\|tructure\\)\\|union" "c\\(ase\\|lose\\|ontinue\\)\\|e\\(lse\\(if\\)?\\|nd\\(do\\|if\\)?\\)\\|format\\(\\)?\\|i\\(f\\|n\\(clude\\|quire\\)\\)\\|open\\|print\\|re\\(ad\\|turn\\)\\|s\\(elect\\|top\\)\\|then\\|w\\(hile\\|rite\\)" "and\\|eq\\|false\\|g[et]\\|l[et]\\|n\\(e\\|ot\\)\\|or\\|true" "^[" "].*" font-lock-comment-face (fortran-match-!-comment . font-lock-comment-face) "^[^" "	\n]" make-string 71 46 "\\(.*\\)" (1 font-lock-comment-face) ("\\(\\s\"\\)\"[^\n]*\\1?" . font-lock-string-face) "\\<\\(block[ 	]*data\\|call\\|entry\\|function\\|program\\|subroutine\\)\\>[ 	]*\\(\\sw+\\)?" (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t) append "\\<\\(" "\\)\\>" font-lock-type-face "\\.\\(" "\\)\\." "\\<\\(do\\|go *to\\)\\>[ 	]*\\([0-9]+\\)?" (1 font-lock-keyword-face) (2 font-lock-constant-face nil t) "^ *\\([0-9]+\\)" font-lock-constant-face "\\)\\>[ 	(/]*\\(*\\)?" (1 font-lock-type-face) (font-lock-match-c-style-declaration-item-and-skip-to-next (and (match-beginning 15) (forward-sexp)) 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)) ("^     \\([^ 0]\\)" 1 font-lock-string-face) ("^	\\([1-9]\\)" 1 font-lock-string-face) fortran-font-lock-keywords-3] 8)
#@51 Default expressions to highlight in Fortran mode.
(defvar fortran-font-lock-keywords fortran-font-lock-keywords-1 (#$ . 9388))
#@69 imenu generic expression for `imenu-default-create-index-function'.
(defvar fortran-imenu-generic-expression (byte-code "\301\302\303Q\304E\301\305\306ED\207" [fortran-continuation-string nil "^\\s-+\\(\\(\\sw\\|\\s-\\|[*()+]\\)*\\<function\\|subroutine\\|entry\\|block\\s-*data\\|program\\)[ 	" "]+\\(\\sw+\\)" 3 "^\\s-+\\(block\\s-*data\\)\\s-*$" 1] 4) (#$ . 9521))
#@30 Keymap used in Fortran mode.
(defvar fortran-mode-map nil (#$ . 9896))
(byte-code "\204\302 \306 \307\310\311#\210\307\312\313#\210\307\314\315#\210\307\316\317#\210\307\320\321#\210\307\322\323#\210\307\324\325#\210\307\326\327#\210\307\330\331#\210\307\332\333#\210\307\334\335#\210\307\336\337#\210\307\340\341#\210\307\342\343#\210\307\344\343#\210\307\345\346#\210\307\347\350#\210\307\351\350#\210\307\352\350#\210\307\353\350#\210\307\354\350#\210\307\355\350#\210\307\356\350#\210\307\357\350#\210\307\360\350#\210\307\361\350#\210\362\301!\204\302 \362\301!\204\261 \363\301\nB\364\301\365\366#\210\367\301\366\370$\210\362\303!\204\312 \363\303\nB\204P\f\371\303\363\"\210\372\373\374\363$\210\372\375\376\363$\210\372\377\201@ \363$\210\372\201A \201B \363$\210\372\201C \201D \363$\210\372\201E \201F \363$\210\372\201G \201H \363$\210\372\201I \201J \363$\210\372\201K \201L \363$\210\372\201M \201N \363$\210\372\201O \201P \363$\210\372\201Q \201R \363$\210\372\201S \201T \363$\210\372\201U \201V \363$\210\372\201W \201X \363$\210\372\201Y \201Z \363$\210\372\201[ \201\\ \363$\210\372\201] \201^ \363$\210\372\201_ \201` \363$\210\372\201a \201b \363$\210\372\201c \201d \363$\210\372\201e \201f \363$\210\372\201g \201h \363$\210\372\201i \201j \363$\210\372\201k \201l \363$\210\372\201m \201n \363$\210\372\201o \201p \363$\210\372\201q \201r \363$\210\372\201s \201t \363$\210\372\201u \201v \363$\210\372\201w \201x \363$\210\372\201y \201z \363$\210\372\201{ \201| \363$\210\372\201} \201~ \363$\210\372\201 \201\200 \363$\210\372\201\201 \201\202 \363$\210\372\201\203 \201\204 \363$\210\372\201\205 \201\206 \363$\210\372\201\207 \201\210 \363$\210\372\201\211 \201\212 \363$\210\372\201\213 \201\214 \363$\210\372\201\215 \201\216 \363$\210\372\201\217 \201\220 \363$\210\372\201\221 \201\222 \363$\210\372\201\223 \201\224 \363$\210\372\201\225 \201\226 \363$\210\372\201\227 \201\230 \363$\210\372\201\231 \201\232 \363$\210\372\201\233 \201\234 \363$\210\372\201\235 \201\236 \363$\210\372\201\237 \201\240 \363$\210\372\201\241 \201\242 \363$\210\372\201\243 \201\244 \363$\210\372\201\245 \201\246 \363$\210\372\201\247 \201\250 \363$\210\372\201\251 \201\252 \363$\210\372\201\253 \201\254 \363$\210\372\201\255 \201\256 \363$\210)\363\207" [fortran-mode-map fortran-mode-menu current-load-list fortran-mode-abbrev-table abbrevs-changed ac make-sparse-keymap define-key ";" fortran-abbrev-start ";" fortran-comment-region "\201" beginning-of-fortran-subprogram "\205" end-of-fortran-subprogram "\273" fortran-indent-comment "\210" mark-fortran-subprogram "\212" fortran-split-line "\n" fortran-indent-new-line "\221" fortran-indent-subprogram "" fortran-window-create-momentarily "" fortran-column-ruler "" fortran-previous-statement "" fortran-next-statement "" fortran-join-line "\336" "nd" fortran-narrow-to-subprogram "0" fortran-electric-line-number "1" "2" "3" "4" "5" "6" "7" "8" "9" boundp nil put variable-documentation "" easy-menu-do-define ("Fortran" ["Toggle Auto-fill" fortran-auto-fill-mode :style toggle :selected (eq auto-fill-function 'fortran-do-auto-fill)] ["Toggle abbrev-mode" abbrev-mode :style toggle :selected abbrev-mode] "----" ["Comment-out Region" fortran-comment-region mark-active] ["Uncomment-out 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" beginning-of-fortran-subprogram t] ["End of Subprogram" end-of-fortran-subprogram t] ("Mark" ["Subprogram" mark-fortran-subprogram t] ["IF Block" fortran-mark-if t] ["DO Block" fortran-mark-do t]) ["Narrow to Subprogram" fortran-narrow-to-subprogram t] ["Widen" widen t] "----" ["Temporary column ruler" fortran-column-ruler t] ["72-column window" fortran-window-create t] ["Full Width Window" (enlarge-window-horizontally (- (frame-width) (window-width))) (< (window-width) (frame-width))] ["Momentary 72-column window" fortran-window-create-momentarily t] "----" ["Break Line at Point" fortran-split-line t] ["Join Continuation Line" fortran-join-line t] ["Fill Statement/Comment" fill-paragraph t] "----" ["Add imenu menu" (progn (imenu-add-menubar-index) (menu-bar-mode 1)) (not (and (boundp 'imenu--index-alist) imenu--index-alist))]) define-abbrev-table define-abbrev ";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"] 5)
#@3009 Major mode for editing Fortran code.
\[fortran-indent-line] indents the current Fortran line correctly.
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:

 comment-start
    Normally nil in Fortran mode.  If you want 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 within full-line comments. (default 0)
 fortran-comment-indent-style
    nil    means don't change indentation of text in full-line comments,
    fixed  means indent that text at `fortran-comment-line-extra-indent' beyond
           the value of `fortran-minimum-statement-indent-fixed' (for fixed
           format continuation style) or `fortran-minimum-statement-indent-tab'
           (for TAB format continuation style).
    relative  means indent at `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 Fortran statements in fixed format mode. (def.6)
 fortran-minimum-statement-indent-tab
    Minimum indentation for Fortran statements in TAB format mode. (default 9)
 fortran-line-number-indent
    Maximum indentation for line numbers.  A line number will get
    less than this much indentation if necessary to avoid reaching
    column 5.  (default 1)
 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 statement to blink on
    matching IF.  Also, from an ENDDO statement, blink on matching DO [WHILE]
    statement.  (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
    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 `fortran-fill' to break lines 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 \210\307\n!\210\310\303!\210\311\310\304!\210\312\310\305!\210\313\310\314!\210\315\f\310\316!\210\317\310\320!\210\321\310\322!\210\323\310\324!\210\325\310\326!\210\312\310\327!\210\312\310\330!\210\325\310\331!\332L\210\333-!\210\334.\335/\310\336!\210\310\337!\210\310\340!\210\310\341!\210\310\342!\210\3430\344 \3121\310\345!\2102%\3463\310\347!\350L\210\310\305!\313L\210\310\351!\352L\210\353\354!\207" [fortran-mode-abbrev-table local-abbrev-table fortran-mode-syntax-table font-lock-defaults fortran-break-before-delimiters indent-line-function kill-all-local-variables set-syntax-table make-local-variable ((fortran-font-lock-keywords fortran-font-lock-keywords-1 fortran-font-lock-keywords-2 fortran-font-lock-keywords-3) t t ((47 . "$/") ("_$" . "w"))) t fortran-indent-line comment-indent-function fortran-comment-hook comment-line-start-skip "^[Cc*]\\(\\([^ 	\n]\\)\\2\\2*\\)?[ 	]*\\|^#.*" comment-line-start "c" comment-start-skip "![ 	]*" comment-start nil require-final-newline abbrev-all-caps indent-tabs-mode fill-column 72 use-local-map "Fortran" fortran-mode fortran-comment-line-extra-indent fortran-minimum-statement-indent-fixed fortran-minimum-statement-indent-tab fortran-column-ruler-fixed fortran-column-ruler-tab " TAB-format" fortran-analyze-file-format imenu-generic-expression (("_$" . "w")) fill-paragraph-function fortran-fill-paragraph indent-region-function #[(start end) "\304\211\305\n\304#*\207" [indent-region-function fortran-blink-matching-if start end nil indent-region] 4] run-hooks fortran-mode-hook fortran-mode-map mode-name major-mode fortran-tab-mode-string imenu-case-fold-search fortran-imenu-generic-expression imenu-syntax-alist] 2 (#$ . 15324) nil])
(defalias 'fortran-comment-hook #[nil "\212\301\302x\210iT])\207" [comment-column " 	" nil] 2])
#@353 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.
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 "\305y\210\306!\203\f \307 \207\310 \203+ 	\203( \305\224b\210i\311 U?\205* \312 \210\311 j\207\313\207\n\203B \306\314!\204B \313\210\312 \210\311 j\210\nc\207\306\314!\203N \312 \210\202W \305y\210\315c\210\316u\210c\210\317\f;\203f \f\305H\202g \f\320 iZ\"\207" [comment-line-start-skip comment-start-skip comment-start comment-line-start fortran-comment-indent-char 0 looking-at fortran-indent-line fortran-find-comment-start-skip fortran-comment-hook delete-horizontal-space nil "^[ 	]*$" "\n" -1 insert-char fortran-calculate-indent] 4 (#$ . 20210) nil])
#@225 Comments every line in the region.
Puts `fortran-comment-region' at the beginning of every line in the region.
BEG-REGION and END-REGION are args which specify the region boundaries.
With non-nil ARG, uncomments the region.
(defalias 'fortran-comment-region #[(beg-region end-region arg) "\306 \307 \211\n\310\223\210b\210\311y\210\f\204+ c\210\312y\311U\203Y `	W\203Y c\210\202 \313!\314!\203< `\311\225|\210\312y\311U\203X `	W\203X \314!\203< `\311\225|\210\202< )b\210	\310\211\223\210\310\211\223*\207" [save-point end-region-mark end-region beg-region arg fortran-comment-region make-marker point-marker nil 0 1 regexp-quote looking-at com] 4 (#$ . 21174) "*r\nP"])
#@110 Typing ;\[help-command] or ;? lists all the Fortran abbrevs.
Any other key combination is executed normally.
(defalias 'fortran-abbrev-start #[nil "\304	c\210\305 \211\306=\204 \n=\203 \307 \202 C\211)\207" [c last-command-char help-char unread-command-events nil read-event 63 fortran-abbrev-help] 2 (#$ . 21867) nil])
#@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 (#$ . 22201) nil])
(defalias 'fortran-prepare-abbrev-list-buffer #[nil "\212\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])
#@269 Insert a column ruler momentarily above current line, till next keystroke.
The ruler is defined by the value of `fortran-column-ruler-fixed' when in fixed
format mode, and `fortran-column-ruler-tab' when in TAB format mode.
The key typed is executed unless it is SPC.
(defalias 'fortran-column-ruler #[nil "\303\203	 	\202\n \n\212\304y\210\305\306 !\307\306 !=\203! \310y\210`\202\" `)\310\311$\207" [indent-tabs-mode fortran-column-ruler-tab fortran-column-ruler-fixed momentary-string-display 0 window-start selected-window window-point nil "Type SPC or any command to erase ruler."] 5 (#$ . 22772) nil])
#@80 Make the window 72 columns wide.
See also `fortran-window-create-momentarily'.
(defalias 'fortran-window-create #[nil "\300\301\302\217\207" [error (byte-code "\301\302 \303 W\203 \304\303 \302 Z\305Z!\210\306\307!\210\310\305!\210\311\312\313\"\210\314\315 !)\207" [window-min-width 2 window-width frame-width enlarge-window-horizontally 1 split-window-horizontally 73 other-window switch-to-buffer " fortran-window-extra" t select-window previous-window] 3) ((error (byte-code "\300\301!\210\302\207" [message "No room for Fortran window." error] 2)))] 3 (#$ . 23387) nil])
#@147 Momentarily make the window 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 \301U\203 \302\213\207\303 \207" [arg 1 ((byte-code "\302 \303\232?\205 \304\305!\210\306 \211\307\310!\232\206 C\211)\207" [char unread-command-events fortran-window-create error message "Type SPC to continue editing." read-event string-to-char " "] 4)) fortran-window-create] 2 (#$ . 23972) "p"])
#@67 Break line at point and insert continuation marker and alignment.
(defalias 'fortran-split-line #[nil "\304 \210\212\305y\210\306!)\203 \307	\310\261\210\202) \n\203$ \311\312 \261\210\202) \313\261\210\314 \207" [comment-line-start-skip comment-line-start indent-tabs-mode fortran-continuation-string delete-horizontal-space 0 looking-at "\n" " " "\n	" fortran-numerical-continuation-char "\n " fortran-indent-line] 3 (#$ . 24502) nil])
(defalias 'fortran-remove-continuation #[nil "\300\301!\205 \302\303!\210\304 \210\305\207" [looking-at "\\(     [^ 0\n]\\|	[1-9]\\|&\\)" replace-match "" delete-indentation t] 2])
#@61 Join a continuation line to the previous one and re-indent.
(defalias 'fortran-join-line #[nil "\212\300y\210\301 \204 \302\303!\210\304 )\207" [0 fortran-remove-continuation error "Not a continuation line" fortran-indent-line] 2 (#$ . 25134) nil])
#@180 Return a digit for tab-digit style of continuation lines.
If, previous line is a tab-digit continuation line, returns that digit
plus one.  Otherwise return 1.  Zero not allowed.
(defalias 'fortran-numerical-continuation-char #[nil "\212\300y\210\301\302!\203 `Tf\303Z\304\246\305\\\202 \305)\207" [-1 looking-at "	[1-9]" 48 9 49] 2 (#$ . 25391)])
#@158 Delete all characters in CHARS around point.
CHARS is like the inside of a [...] in a regular expression
except that ] is never special and quotes ^, - or .
(defalias 'delete-horizontal-regexp #[(chars) "\301x\210`\301w\210`|\207" [chars nil] 3 (#$ . 25748) "*s"])
(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\312y\210\313\314!)\204a \n\203/ \2020 \fiU\203L \212\312y\210\313\315!)\203L \316=\204L \317=\203a \212\320\321\212\312y\210`)\322#)\204a \313\323!\203g \306\307!!\207\324\325x\210c\210\316 \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 0 looking-at "     " "	" fortran-indent-line fortran-indent-new-line re-search-backward "[^ 	0-9]" t "[0-9]" " 	" nil last-command-char] 4 (#$ . 26078) "P"])
(byte-code "\303\300!\204 \304\300	B\303\302!\204 \305P\302	B\303\207" [fortran-end-prog-re1 current-load-list fortran-end-prog-re boundp "end\\b[ 	]*\\(\\(program\\|subroutine\\|function\\)[ 	]*\\)?[^ 	=(a-z]" "^[ 	0-9]*"] 2)
#@65 Moves point to the beginning of the current Fortran subprogram.
(defalias 'beginning-of-fortran-subprogram #[nil "\302\303y\210\304	\305\306#\205 \305y)\207" [case-fold-search fortran-end-prog-re t -2 re-search-backward nil move] 4 (#$ . 27107) nil])
#@59 Moves point to the end of the current Fortran subprogram.
(defalias 'end-of-fortran-subprogram #[nil "\302\212\303y\210\304	!)\203 \305y\202! \306y\210\307	\305\310#\210\303\224b\210\305y)\207" [case-fold-search fortran-end-prog-re t 0 looking-at nil 1 re-search-forward move] 4 (#$ . 27366) nil])
#@82 Put mark at end of Fortran subprogram, point at beginning.
The marks are pushed.
(defalias 'mark-fortran-subprogram #[nil "\300 \210\301`!\210\302 \207" [end-of-fortran-subprogram push-mark beginning-of-fortran-subprogram] 2 (#$ . 27672) nil])
#@180 Moves 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.
(defalias 'fortran-previous-statement #[nil "\305\211\306y\210\307\n!?\205! \307\310\311!P!\206! \307\312!\206! \307\313!\314y\306U\211\203K \307\n!\204\" \307\315!\204\" \307\312!\204\" \307\313!\204\" \307\310\fP!\204\" \203Y 	\204Y \316\317!\202h \203b \320 \202h 	?\205h \321*\207" [continue-test not-first-statement comment-line-start-skip fortran-continuation-string comment-start-skip nil 0 looking-at "[ 	]*" regexp-quote "     [^ 0\n]" "	[1-9]" -1 "[ 	]*$" message "Incomplete continuation statement." fortran-previous-statement first-statement] 4 (#$ . 27923) nil])
#@174 Moves 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.
(defalias 'fortran-next-statement #[nil "\303\304y\210\305y\304U\205 m?\211\2033 \306	!\204 \306\307!\204 \306\310!\204 \306\311!\204 \306\312\nP!\204 ?\2059 \313)\207" [not-last-statement comment-line-start-skip comment-start-skip nil 0 1 looking-at "[ 	]*$" "     [^ 0\n]" "	[1-9]" "[ 	]*" last-statement] 3 (#$ . 28692) nil])
#@119 Make text outside the current subprogram invisible.
The subprogram visible is the one that contains or follows point.
(defalias 'fortran-narrow-to-subprogram #[nil "\212\300 \210\301 \302 })\207" [mark-fortran-subprogram region-beginning region-end] 2 (#$ . 29210) nil])
(defalias 'fortran-blink-matching-if #[nil "\305 `\306\307\211\212\310y\210\311\307w\210\312\313!)\205Q \314 \211\204& \315\202= 	\fW\203= \212	b\210\310y\210\316`\307\210`{P)\203H \300\317\"\202Q 	b\210\320\321!\210b-\207" [message matching-if case-fold-search endif-point top-of-window window-start t nil 0 " 	0-9" looking-at "end[ 	]*if\\b" fortran-beginning-if "No matching if." "Matches " "%s" sit-for 1] 5])
(defalias 'fortran-blink-matching-do #[nil "\305 `\306\307\211\212\310y\210\311\307w\210\312\313!)\205Q \314 \211\204& \315\202= 	\fW\203= \212	b\210\310y\210\316`\307\210`{P)\203H \300\317\"\202Q 	b\210\320\321!\210b-\207" [message matching-do case-fold-search enddo-point top-of-window window-start t nil 0 " 	0-9" looking-at "end[ 	]*do\\b" fortran-beginning-do "No matching do." "Matches " "%s" sit-for 1] 5])
#@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 \210b*\207" [do-point enddo-point nil fortran-end-do fortran-beginning-do message "No matching do." push-mark] 2 (#$ . 30339) nil])
(defalias 'fortran-end-do #[nil "\303\212\304y\210\305\306w\210\307\310!)\203 \304\224\202R \212\311	\304U\204J \312 \313=\204J \307\n!\204J \305\306w\210\307\310!\203= 	S\211\202 \307\314!\203 	T\211\202 	\304U\205Q `*)\207" [case-fold-search count fortran-end-prog-re t 0 " 	0-9" nil looking-at "end[ 	]*do\\b" 1 fortran-next-statement last-statement "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?do[ 	]+[^0-9]"] 3])
(defalias 'fortran-beginning-do #[nil "\303\212\304y\210\305\306w\210\307\310!)\203 \304\224\202R \212\311	\304U\204J \312 \313=\204J \307\n!\204J \305\306w\210\307\314!\203= 	S\211\202 \307\315!\203 	T\211\202 	\304U\205Q `*)\207" [case-fold-search count fortran-end-prog-re t 0 " 	0-9" nil looking-at "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?do[ 	]+" 1 fortran-previous-statement first-statement "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?do[ 	]+[^0-9]" "end[ 	]*do\\b"] 3])
#@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 \210b*\207" [if-point endif-point nil fortran-end-if fortran-beginning-if message "No matching if." push-mark] 2 (#$ . 31555) nil])
(byte-code "\302\300!\204 \303\300	B\302\207" [fortran-if-start-re current-load-list boundp "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?if[ 	]*("] 2)
(defalias 'fortran-end-if #[nil "\305\212\306y\210\307\310w\210\311\312!)\203 \306\224\202{ \212\313	\306U\204s \314 \315=\204s \311\n!\204s \307\310w\210\311\312!\203= 	S\211\202 \311!\203 \212\311\316!\204l \310\313y\306U\203g \311\317!\204_ \311\320!\203g \311\321!\211\203L \f)\203o 	T)\202 	\306U\205z `*)\207" [case-fold-search count fortran-end-prog-re fortran-if-start-re then-test t 0 " 	0-9" nil looking-at "end[ 	]*if\\b" 1 fortran-next-statement last-statement ".*)[ 	]*then\\b[ 	]*[^ 	(=a-z0-9]" "     [^ 0\n]" "	[1-9]" ".*then\\b[ 	]*[^ 	(=a-z0-9]"] 3])
(defalias 'fortran-beginning-if #[nil "\306\212\307 \310=\204 \311 \210\312\313w\210\314	!\205B \315 \316\216\314\317!\206A \313\320y\321U\203? \314\322!\2047 \314\323!\203? \314\324!\211\203$ )*)\203K \321\224\202\260 \212\320\f\321U\204\250 \307 \310=\204\250 \314!\204\250 \312\313w\210\314	!\203\233 \212\314\317!\204\224 \313\320y\321U\203\217 \314\322!\204\207 \314\323!\203\217 \314\324!\211\203t )\203\227 \fS)\202N \314\325!\203N \fT\211\202O \f\321U\205\257 `*)\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 ((set-match-data save-match-data-internal)) ".*)[ 	]*then\\b[ 	]*[^ 	(=a-z0-9]" 1 0 "     [^ 0\n]" "	[1-9]" ".*then\\b[ 	]*[^ 	(=a-z0-9]" "end[ 	]*if\\b"] 3])
#@74 Indent current Fortran line based on its contents and on previous lines.
(defalias 'fortran-indent-line #[nil "\305 \212\306y\210\307 U\203 \310\311`\312\\\313#\203$ \314 \204$ \315!\210\2025 \306y\210\316	!\2045 \317 \2035 \320 \210)iW\203@ \321!\210\n\203W \212\322\210i)V\203W \212\322\210\323 \210)\f\205` \304 \210\324 )\207" [cfi comment-line-start-skip auto-fill-function fill-column fortran-blink-matching-if fortran-calculate-indent 0 fortran-current-line-indentation re-search-forward "^[ 	]*[0-9]+" 4 t fortran-line-number-indented-correctly-p fortran-indent-to-column looking-at fortran-find-comment-start-skip fortran-indent-comment move-to-column nil fortran-fill fortran-blink-matching-do] 4 (#$ . 33455) nil])
#@141 Reindent the current Fortran line, insert a newline and indent the newline.
An abbrev before point is expanded if `abbrev-mode' is non-nil.
(defalias 'fortran-indent-new-line #[nil "\203 \303 \210\212\304y\210\305\306w\210\307\310\311!\204+ \310\312!\204+ \310\313!\204+ \310\314\n!!\203. \315 \210*\316 \210\315 \207" [abbrev-mode case-fold-search fortran-continuation-string expand-abbrev 0 " 	" nil t looking-at "[0-9]" "end" "else" regexp-quote fortran-indent-line newline] 3 (#$ . 34197) nil])
#@62 Properly indent the Fortran subprogram which contains point.
(defalias 'fortran-indent-subprogram #[nil "\212\300 \210\301\302!\210\303`\304 \305#\210)\301\306!\207" [mark-fortran-subprogram message "Indenting subprogram..." indent-region mark nil "Indenting subprogram...done."] 4 (#$ . 34705) nil])
#@63 Calculates the Fortran indent column based on previous lines.
(defalias 'fortran-calculate-indent #[nil "\306\211\307\203 	\202\f \n*\212\310 \211\203 *\202\370 `eU\203+ *\202/ \311 *\312\306w\210\313\314!\203n \313\315!\204d \306+\316y\317U\203^ \313\320!\204U \313\321!\203^ \313\322!\211+\203B +)\203\370 *,\\*\202\370 \313\323!\203~ *,\\*\202\370 \313\324!\203\216 *,\\*\202\370 \313\325!\203\236 *,\\*\202\370 \313\326!\203\256 *,\\*\202\370 \313\327!\203\276 *,\\*\202\370 \313\330!\203\316 *,\\*\202\370 \313\331!\203\336 *-\\*\202\370 \313\332!\203\356 *.\\*\202\370 \313/!\203\370 *)\212\317y\210\313\333!\204\3130!\203-1\334=\203*2\\*\202(1\335=\203(2\\*\317\202\313\336\3373!P!\204D\313\320!\204D\313\321!\203N*4\\*\202\313\340!\203\\\317\317*\202\2045\203z\313\341!\203z\342 \203z*-Z*\202\312\306w\210\313\343!\203\216*,Z*\202\313\323!\203\236*,Z*\202\313\344!\203\256*,Z*\202\313\327!\203\276*,Z*\202\313\345!\203\323\342 \203\323*-Z*\202\313\346!\203\343*-Z*\202\313\347!\203\363*.Z*\202\313/!\203*U\204\350\351\"\210)*],\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]" 1 0 "     [^ 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]" "[ 	]*$" relative fixed "[ 	]*" regexp-quote "[ 	]*#" "[ 	]*[0-9]+" fortran-check-for-matching-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 comment-line-start-skip fortran-comment-indent-style fortran-comment-line-extra-indent fortran-continuation-string fortran-continuation-indent fortran-check-all-num-for-matching-do] 5 (#$ . 35012)])
#@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\302y\210\303!\203  \302\225b\210	;\203 	\202 \304	!\305w\210\2027 \303\306!\204, \303\307!\2033 \302\225b\210\2027 \310\305w\210\311\305w\210i)\207" [comment-line-start-skip fortran-comment-indent-char 0 looking-at char-to-string nil "     [^ 0\n]" "	[1-9]" "[ 	0-9]" " 	"] 2 (#$ . 37444)])
#@511 Indent current line with spaces 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\306y\210\307!\2031 	\205\360 \n;\203 \n\306H\202 \n\306\225b\210\310\311\312!P!\210\313\fiZ\")\202\360 \307\314!\203P \203B \306\225b\210\202\316 \315\316!\210\317c\210c\210\202\316 \307\320!\203p \203j \315\321!\210\322c\210\313\323 \324\"\210\202\316 \321u\210\202\316 \325 \210m\204\316 \307\326!!\203\247 \203\236 \203\215  \202\217 !j\210\315\324!\210\313\323 \324\"\210\202\316 \327j\210\324u\210\202\316 \307\330!\203\316 \327\306\225`ZZ\211\"\306W\203\302 \331\332!\210\202\311 #\"^j\210)\333\334w\210\325 \210\fj\210$\205\360 \335 \205\360 \306\224b\210i\336 U?\205\360 \325 \210\336 j)\207" [comment-line-start-skip fortran-comment-indent-style fortran-comment-indent-char char col indent-tabs-mode 0 looking-at delete-horizontal-regexp " 	" char-to-string insert-char "	[1-9]" delete-char 2 "     " "     [^ 0\n]" 6 "	" fortran-numerical-continuation-char 1 delete-horizontal-space regexp-quote 5 "[0-9]+" message "Warning: line number exceeds 5-digit limit." "0-9" nil fortran-find-comment-start-skip fortran-comment-hook fortran-continuation-string fortran-minimum-statement-indent-tab fortran-minimum-statement-indent-fixed extra-space fortran-line-number-indent comment-start-skip] 5 (#$ . 38109)])
#@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\301y\210\302\303w\210iX\205 iU\206 \304\303w\210i\305U)\207" [fortran-line-number-indent 0 " 	" nil "0-9" 5] 2 (#$ . 39910)])
#@96 When called from a numbered statement, return t if matching DO is found.
Otherwise return nil.
(defalias 'fortran-check-for-matching-do #[nil "\303\304\212\305y\210\306\307!\2058 \310\303w\210\311\303w\210`\312\303w\210`{\305y\210\313\314\n\315\316	\317\320	\321\260	\303\304#\2058 \306\322	P!+\207" [case-fold-search charnum fortran-end-prog-re nil t 0 looking-at "[ 	]*[0-9]+" " 	" "0" "0-9" re-search-backward "\\(" "\\)\\|" "\\(^[ 	0-9]*do[ 	]*0*" "\\b\\)\\|" "\\(^[ 	]*0*" "\\b\\)" "^[ 	0-9]*do[ 	]*0*"] 10 (#$ . 40212)])
#@110 Move to past `comment-start-skip' found on current line.
Return t if `comment-start-skip' found, nil if not.
(defalias 'fortran-find-comment-start-skip #[nil "\212\303\212\304\210`)\305#)\205: \306\224\306\225\307\306\224!\203& \212	b\210\310 )\2029 \nb\210\303\212\304\210`)\305#\210\306\225b\210\305*\207" [comment-start-skip save-match-end save-match-beginning re-search-forward nil t 0 fortran-is-in-string-p fortran-find-comment-start-skip] 4 (#$ . 40749) nil])
(defalias 'fortran-match-!-comment #[(limit) "\302\303\304	\305#\211\203 \306`!\204 \205# \307`S\302\210`	^D!\210\305)\207" [found limit nil search-forward "!" t fortran-is-in-string-p set-match-data] 4])
#@74 Return non-nil iff WHERE (a buffer position) is inside a Fortran string.
(defalias 'fortran-is-in-string-p #[(where) "\212b\210n\203\f \306\202\303 \212\307y\210\310	!)\203 \306\202\303 \311\n\205# \312\n!\313\306\211\314 \210\315 \210\203\276 \310	!\204T l\204T \3168\204a \n\203a \n\317h!\232\203a \306y\307V\2033 \306\211\2024 n\203i \320\306w\210i\321U\203u \322u\210\202\207 i\321W\203\207 \317g!\232\203\207 \322u\210\212\306\210`)^\n\203\245 \212\323\313#\203\244 `\f^)`W\203\270 \324`\f\306\211%\2023 \306\211\2047 \3168-)\207" [where comment-line-start-skip comment-start end-of-line parse-limit not-done nil 0 looking-at (0 nil nil nil nil nil 0) regexp-quote t fortran-next-statement fortran-previous-statement 3 char-to-string " 	0-9" 5 1 re-search-forward parse-partial-sexp quoted-comment-start parse-state fortran-continuation-string] 7 (#$ . 41439)])
#@227 Toggle fortran-auto-fill mode.
With ARG, turn `fortran-auto-fill' mode on iff ARG is positive.
In `fortran-auto-fill' mode, inserting a space at a column beyond `fill-column'
automatically breaks the line at a previous space.
(defalias 'fortran-auto-fill-mode #[(arg) "\204	 	?\202 \302!\303V\205 \304\211\305 \210\207" [arg auto-fill-function prefix-numeric-value 0 fortran-do-auto-fill force-mode-line-update] 2 (#$ . 42345) "P"])
(defalias 'fortran-do-auto-fill #[nil "iV\205 \301 \207" [fill-column fortran-indent-line] 2])
(defalias 'fortran-fill #[nil "`\212\306y\210`)\212\307\210`)\211	\310 \\^\212	b\210\311\f!?\205? \312!\210\313`!\205? \212\314\315	\316#\210\203< `\202> `T))\211\206\223 \212\312T!\210\317\307x\210`TX\203g \312T!\210\320\321\n\316#\204g 	b\210n\203t \320\322\316#\210\202\207 \323 \210\311\324!\203\203 \307u\210\202\207 \325\307x\210\203\220 `\202\222 `T)\212\314	\316#\205\256 \313`!?\205\256 \326\307x\210iTW)\206\271 \212b\210n)?\205\353 \212b\210i)TV\203\323 b\210\327 \202\353 \212\212b\210i)\330 \\V\205\352 b\210\327 ).\207" [opoint bol eol bos comment-line-start-skip fill-column 0 nil fortran-current-line-indentation looking-at move-to-column fortran-is-in-string-p re-search-backward "\\S\"\\s\"\\S\"" t "^ 	\n,'+-/*=)" re-search-forward "[	\n,'+-/*)=]" "[ 	]" backward-char "\\s\"" " 	*" " 	" fortran-break-line fortran-calculate-indent fortran-break-before-delimiters quote fill-point comment-start-skip fortran-continuation-indent] 5 nil nil])
(defalias 'fortran-break-line #[nil "`\212\305y\210`)\212\306\210`)\306\212\f\203* \307 \203* \310\f\n\311#\210`	{`	|\210)\212\306y\210\312\313!\2068 \312\314!)\203M \306\210`\305\225|\210\315 \210\316 \210\202P \317 \210\205e \212\nb\210\306\210\315 \210\320 j\210c),\207" [comment-string eol bol opoint comment-start-skip 0 nil fortran-find-comment-start-skip re-search-backward t looking-at "     [^ 0\n]" "	[1-9]" delete-horizontal-space fortran-fill fortran-split-line fortran-comment-hook] 4])
#@207 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 in the
file before the end or the first `fortran-analyze-depth' lines.
(defalias 'fortran-analyze-file-format #[nil "\303\212eb\210\303m\204' \304\305!\204' \304\306!\204' 	V\204' \307y\210T\202 \304\305!\2031 \310\202D \304\306!\203; \307\202D \n\203C \310\202D \307*\207" [i fortran-analyze-depth fortran-tab-mode-default 0 looking-at "	" "      " nil t] 2 (#$ . 44392)])
(byte-code "\301\236\204\n \302B\301\207" [minor-mode-alist fortran-tab-mode-string (fortran-tab-mode-string (indent-tabs-mode fortran-tab-mode-string))] 2)
#@121 Fill surrounding comment block as paragraphs, else fill statement.

Intended as the value of `fill-paragraph-function'.
(defalias 'fortran-fill-paragraph #[(&optional justify) "\212\306y\210\307\310!\204 \311 \210\202h \312\313\314R\212\315y\306U\203$ \307	!\204 \307	!\204- \316y\210\317 )\212\316y\210\307	!\2042 \317 )\320\n\316#\210\316\306y\210\307!\210\321\306!\316\322\n#\210+\n\316\211\223\210\316\211\223\210+)\323\207" [comment-line-start-skip non-empty-comment start end fill-prefix paragraph-ignore-fill-prefix 0 looking-at "[Cc*]" fortran-fill-statement "\\(" "\\)" "[^ 	\n]" -1 nil point-marker indent-region match-string fill-region t fill-paragraph-function justify] 4 (#$ . 45074) "P"])
#@47 Fill a fortran statement up to `fill-column'.
(defalias 'fortran-fill-statement #[nil "\212\302y\210\303\304!\206 \303!\206 	\205 \303\305	P!)\2043 \212\306 \210\307 \210\310 \210\311y\210\312 \204' \307 \210)\310 \207" [comment-line-start-skip comment-start-skip 0 looking-at "[ 	]*$" "[ 	]*" fortran-next-statement fortran-previous-statement fortran-indent-line nil fortran-remove-continuation] 3 (#$ . 45800) nil])
(provide 'fortran)