;ELC   
;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:51:09 2003
;;; from file /home/pot/gnu/emacs-pretest.new/lisp/progmodes/fortran.el
;;; in Emacs version 21.3
;;; with bytecomp version 2.85.4.1
;;; with all optimizations.

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

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


(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\302\311\312\313\306\301&\210\300\314\302\315\312\313\306\301&\207" [custom-declare-group fortran nil "Fortran mode for Emacs" :link (custom-manual "(emacs)Fortran") :group languages fortran-indent "Indentation variables in Fortran mode" :prefix "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 '(#$ . -1009) :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 '(#$ . 1351) :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 '(#$ . -1596) :type 'integer :group 'fortran-indent)
#@42 *Extra indentation applied to IF blocks.
(custom-declare-variable 'fortran-if-indent '3 '(#$ . -1743) :type 'integer :group 'fortran-indent)
#@75 *Extra indentation applied to STRUCTURE, UNION, MAP and INTERFACE blocks.
(custom-declare-variable 'fortran-structure-indent '3 '(#$ . -1890) :type 'integer :group 'fortran-indent)
#@59 *Extra indentation applied to Fortran continuation lines.
(custom-declare-variable 'fortran-continuation-indent '5 '(#$ . -2077) :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 '(#$ . -2252) :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 '(#$ . -2837) :type 'integer :group 'fortran-indent :group 'fortran-comment)
#@105 *Delimiter inserted to start new full-line comment.
You might want to change this to "*", for instance.
(custom-declare-variable 'fortran-comment-line-start '"C" '(#$ . -3049) :version "21.1" :type 'string :group 'fortran-comment)
#@52 *Regexp to match the start of a full-line comment.
(custom-declare-variable 'fortran-comment-line-start-skip '"^[CcDd*!]\\(\\([^ 	\n]\\)\\2+\\)?[ 	]*" '(#$ . -3286) :version "21.1" :type 'regexp :group 'fortran-comment)
#@69 *Minimum statement indentation for fixed format continuation style.
(custom-declare-variable 'fortran-minimum-statement-indent-fixed '6 '(#$ . -3512) :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) '(#$ . -3707) :type 'integer :group 'fortran-indent)
#@86 *Single-character string inserted for Fortran comment indentation.
Normally a space.
(custom-declare-variable 'fortran-comment-indent-char '" " '(#$ . -3914) :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 '(#$ . -4118) :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 '(#$ . -4339) :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 '(#$ . -4536) :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 '"$" '(#$ . -4799) :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$$$" '(#$ . -5260) :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 '(#$ . -5455) :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" (#$ . 5645))
#@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" (#$ . 5955))
#@80 Number of lines to scan to determine whether to use fixed or TAB format style.
(defvar fortran-analyze-depth 100 (#$ . 6260))
#@59 *Non-nil causes filling to break lines before delimiters.
(custom-declare-variable 'fortran-break-before-delimiters 't '(#$ . -6392) :type 'boolean :group 'fortran)
#@46 Syntax table in use in Fortran mode buffers.
(defvar fortran-mode-syntax-table (byte-code "\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)\207" [table make-syntax-table modify-syntax-entry 59 "w" 13 " " 43 "." 45 61 42 47 39 "\"" 34 92 "\\" 46 "_" 95 36 33 "<" 10 ">"] 4) (#$ . 6563))
#@46 Subdued level highlighting for Fortran mode.
(defvar fortran-font-lock-keywords-1 nil (#$ . 7085))
#@45 Medium level highlighting for Fortran mode.
(defvar fortran-font-lock-keywords-2 nil (#$ . 7190))
#@44 Gaudy level highlighting for Fortran mode.
(defvar fortran-font-lock-keywords-3 nil (#$ . 7294))
#@88 `font-lock-syntactic-keywords' for Fortran.
These get fixed-format comments fontified.
(defvar fortran-font-lock-syntactic-keywords nil (#$ . 7397))
(byte-code "\306\307\310\311\312\313Q\314\315E\316\317\320\321\260\322\323ED\324\325\326EC\327\330\n\331Q\332B\330	\331Q\333\334Q\335\336\337E\340\341B\257\"3\327\330\n\342Q\343\344\345\346\347\211\350\351\n!\352\\D\353BB\354BB\355BBB\356BBEC\357\360\361E\362CG3\233A%4,\346\207" [fortran-logicals fortran-keywords fortran-type-types comment-chars fortran-font-lock-syntactic-keywords fortran-font-lock-keywords-1 "cd\\*" "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\\(?:\\(?:av\\|tructur\\)e\\)\\|union" "backspace\\|c\\(?:\\(?:as\\|los\\|ontinu\\|ycl\\)e\\)\\|e\\(?:lse\\(?:if\\)?\\|nd\\(?:do\\|if\\)?\\|xit\\)\\|format\\(?:\\)?\\|i\\(?:f\\|n\\(?:\\(?:clud\\|quir\\)e\\)\\)\\|open\\|print\\|re\\(?:ad\\|turn\\|wind\\)\\|s\\(?:elect\\|top\\)\\|then\\|w\\(?:\\(?:hil\\|rit\\)e\\)" "and\\|eq\\|false\\|g[et]\\|l[et]\\|n\\(?:e\\|ot\\)\\|or\\|true" "^[" "]" 0 (11) "^[^" "	\n]" ".\\{71\\}" "\\([^\n]+\\)" 1 (11) "\\<\\(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 condition-case nil and match-beginning regexp-opt-depth 2 ((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)) ("^     \\([^ 0]\\)" 1 font-lock-string-face) ("^	\\([1-9]\\)" 1 font-lock-string-face) ("^# *[a-z]+" . font-lock-keyword-face) fortran-font-lock-keywords-2 fortran-font-lock-keywords-3] 12)
#@51 Default expressions to highlight in Fortran mode.
(defvar fortran-font-lock-keywords fortran-font-lock-keywords-1 (#$ . 9783))
#@69 Imenu generic expression for `imenu-default-create-index-function'.
(defvar fortran-imenu-generic-expression (byte-code "\301\302\303\304\305\306\307\260\310E\301\311\312ED\207" [fortran-continuation-string nil "^\\s-+\\(" "\\(\\sw\\|\\s-\\|[*()+]\\)*" "\\<function\\|subroutine\\|entry\\|block\\s-*data\\|program\\)" "[ 	" "]+" "\\(\\sw+\\)" 3 "^\\s-+\\(block\\s-*data\\)\\s-*$" 1] 8) (#$ . 9916))
#@30 Keymap used in Fortran mode.
(defvar fortran-mode-map (byte-code "\303 \304\305\306#\210\304\307\310#\210\304\311\312#\210\304\313\314#\210\304\315\316#\210\304\317\320#\210\304\321\322#\210\304\323\324#\210\304\325\326#\210\304\327\330#\210\304\331\330#\210\304\332\333#\210\304\334\333#\210\304\335\333#\210\304\336\333#\210\304\337\333#\210\304\340\333#\210\304\341\333#\210\304\342\333#\210\304\343\333#\210\304\344\333#\210\302	B\345\302\346\347#\210\350\302!\204\223 \351\352\302\347\353\354\355\356\357!\360BB\361BBB$\210)\207" [map current-load-list fortran-mode-menu make-sparse-keymap define-key ";" fortran-abbrev-start ";" fortran-comment-region "\273" fortran-indent-comment "\212" fortran-split-line "\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" put variable-documentation "" boundp nil easy-menu-do-define "Fortran" ["Manual" (info "(emacs)Fortran")] "Customization" custom-menu-create fortran (["Set" Custom-set t] ["Save" Custom-save t] ["Reset to Current" Custom-reset-current t] ["Reset to Saved" Custom-reset-saved t] ["Reset to Standard Settings" Custom-reset-standard t]) ("----" ["Toggle Auto-fill" auto-fill-mode :style toggle :selected auto-fill-function] ["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" fortran-beginning-of-subprogram t] ["End of Subprogram" fortran-end-of-subprogram t] ("Mark" ["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 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 Line" fortran-join-line t] ["Fill Statement/Comment" fill-paragraph t] "----" ["Add imenu menu" imenu-add-menubar-index (not (and (boundp 'imenu--index-alist) imenu--index-alist))])] 9) (#$ . 10323))
(byte-code "\303B\304\303!\204$	\305\303\306\"\210\307\310\311\306$\210\307\312\313\306$\210\307\314\315\306$\210\307\316\317\306$\210\307\320\321\306$\210\307\322\323\306$\210\307\324\325\306$\210\307\326\327\306$\210\307\330\331\306$\210\307\332\333\306$\210\307\334\335\306$\210\307\336\337\306$\210\307\340\341\306$\210\307\342\343\306$\210\307\344\345\306$\210\307\346\347\306$\210\307\350\351\306$\210\307\352\353\306$\210\307\354\355\306$\210\307\356\357\306$\210\307\360\361\306$\210\307\362\363\306$\210\307\364\365\306$\210\307\366\367\306$\210\307\370\371\306$\210\307\372\373\306$\210\307\374\375\306$\210\307\376\377\306$\210\307\201@ \201A \306$\210\307\201B \201C \306$\210\307\201D \201E \306$\210\307\201F \201G \306$\210\307\201H \201I \306$\210\307\201J \201K \306$\210\307\201L \201M \306$\210\307\201N \201O \306$\210\307\201P \201Q \306$\210\307\201R \201S \306$\210\307\201T \201U \306$\210\307\201V \201W \306$\210\307\201X \201Y \306$\210\307\201Z \201[ \306$\210\307\201\\ \201] \306$\210\307\201^ \201_ \306$\210\307\201` \201a \306$\210\307\201b \201c \306$\210\307\201d \201e \306$\210\307\201f \201g \306$\210\307\201h \201i \306$\210\307\201j \201k \306$\210\307\201l \201m \306$\210\307\201n \201o \306$\210\307\201p \201q \306$\210\307\201r \201s \306$\210\307\201t \201u \306$\210\307\201v \201w \306$\210\307\201x \201y \306$\210\307\201z \201{ \306$\210\n)\306\207" [current-load-list abbrevs-changed ac fortran-mode-abbrev-table boundp define-abbrev-table nil 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)
#@27 Hook run by Fortran mode.
(custom-declare-variable 'fortran-mode-hook 'nil '(#$ . 15442) :type 'hook :group 'fortran)
#@3004 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'
    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 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 \210\307\n!\210\310\303!\210\311\310\312!\fL\210\310\305!\210\313\310\314!\210\315\f\310\316!\210\317\310\320!\210\321\310\322!\2104\310\323!\210\313\310\324!\210\313\310\325!\210\326\310\327!\330L\210\3315!\210\3326\3337\310\334!\210\310\335!\210\310\336!\210\310\337!\210\310\340!\210\3418\342 \3139:;\343<\310\344!\345L\210\310\346!\347L\210\310\314!\315L\210\310\350!\351L\210\310\352!\353L\210\310\354!\355L\210\310\356!\357L\210\310\360!\361L\210\362\363!\207" [fortran-mode-abbrev-table local-abbrev-table fortran-mode-syntax-table font-lock-defaults fortran-font-lock-syntactic-keywords fortran-break-before-delimiters 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) nil t ((47 . "$/") ("_$" . "w")) fortran-beginning-of-subprogram) font-lock-syntactic-keywords t indent-line-function fortran-indent-line comment-indent-function fortran-comment-indent comment-start-skip "![ 	]*" comment-start require-final-newline abbrev-all-caps indent-tabs-mode nil 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 (("_$" . "w")) fill-paragraph-function fortran-fill-paragraph normal-auto-fill-function fortran-auto-fill indent-region-function #[(start end) "\304\211\305\n\304#*\207" [indent-region-function fortran-blink-matching-if start end nil indent-region] 4] 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 run-hooks fortran-mode-hook fortran-comment-line-start fortran-mode-map mode-name major-mode fortran-tab-mode-string imenu-case-fold-search fortran-imenu-generic-expression imenu-generic-expression imenu-syntax-alist] 2 (#$ . 15568) nil])
(defalias 'fortran-comment-indent #[nil "\212\301\302x\210iT])\207" [comment-column " 	" nil] 2])
(put 'fortran-comment-indent 'byte-optimizer 'byte-compile-inline-expand)
#@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 "\306 \210\307!\203\f \310 \207\311 \203; 	\2038 \312\224b\210i\212\313\314x\210iT\n])U?\205: \315 \210\212\313\314x\210iT\n])j\207\314\207\203Z \307\316!\204Z \314\210\315 \210\212\313\314x\210iT\n])j\210c\207\307\316!\203f \315 \210\202o \306 \210\317c\210\320u\210\fc\210\321;\203~ \312H\202 \322 iZ\"\207" [fortran-comment-line-start-skip comment-start-skip comment-column comment-start fortran-comment-line-start fortran-comment-indent-char beginning-of-line looking-at fortran-indent-line fortran-find-comment-start-skip 0 " 	" nil delete-horizontal-space "^[ 	]*$" 10 -1 insert-char fortran-calculate-indent] 4 (#$ . 20860) 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 b\210\310 \210\f\204' c\210\311y\312U\203U `\nW\203U c\210\202 \313!\314!\2038 `\312\225|\210\311y\312U\203T `\nW\203T \314!\2038 `\312\225|\210\2028 )	b\210\n\315\211\223\210	\315\211\223*\207" [end-region save-point end-region-mark beg-region arg fortran-comment-region copy-marker point-marker beginning-of-line 1 0 regexp-quote looking-at nil com] 3 (#$ . 21905) "*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 (#$ . 22602) 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 (#$ . 22936) 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\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 (#$ . 23507) 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 "\303\304 \305 W\203 \306\305 \304 Z\307Z!\210\301 \303	8	@Z\304 Z\310\n\311\\!\210*\312\307!\210\313\314\315\"\210\316\317 !)\207" [window-min-width window-edges scroll-bar-width 2 window-width frame-width enlarge-window-horizontally 1 split-window-horizontally 72 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 (#$ . 24162) 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 (#$ . 24803) "p"])
#@67 Break line at point and insert continuation marker and alignment.
(defalias 'fortran-split-line #[nil "\304 \210\212\305 \210\306!)\203 \307	\310\261\210\202* \n\203% \307\311\312 \261\210\202* \313\261\210\314 \207" [fortran-comment-line-start-skip fortran-comment-line-start indent-tabs-mode fortran-continuation-string delete-horizontal-space beginning-of-line looking-at 10 32 9 fortran-numerical-continuation-char "\n " fortran-indent-line] 3 (#$ . 25333) 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])
#@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\301V\203 [\211y\210\302!\204$ \303 \210\304 \204 \305 \210S\202 \306 )\207" [arg 0 zerop beginning-of-line fortran-remove-continuation delete-indentation fortran-indent-line] 3 (#$ . 25995) "*p"])
#@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 (#$ . 26475)])
(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\210c\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-char] 4 (#$ . 26888) "P"])
(byte-code "\301B\302\301!\204\f \303\301\207" [current-load-list fortran-end-prog-re1 boundp "end\\([ 	]*\\(program\\|subroutine\\|function\\|block[ 	]*data\\)\\>\\([ 	]*\\(\\sw\\|\\s_\\)+\\)?\\)?"] 2)
#@41 Regexp possibly marking subprogram end.
(defvar fortran-end-prog-re (concat "^[ 	0-9]*" fortran-end-prog-re1) (#$ . 27908))
#@58 Check a preliminary match against `fortran-end-prog-re'.
(defalias 'fortran-check-end-prog-re #[nil "\301 \302\216\303\304\305\225\306 \307 \310\\^{\"*\207" [save-match-data-internal match-data ((set-match-data save-match-data-internal)) string-match "^\\s-*\\(\\'\\|\\s<\\)" 0 line-end-position line-beginning-position 72] 6 (#$ . 28038)])
#@64 Move point to the beginning of the current Fortran subprogram.
(defalias 'fortran-beginning-of-subprogram #[nil "\302 \303\216\304\305\306!\210\307\310\215\205 \311y+\207" [save-match-data-internal case-fold-search match-data ((set-match-data save-match-data-internal)) t beginning-of-line -1 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) nil] 2 (#$ . 28386) nil])
#@58 Move point to the end of the current Fortran subprogram.
(defalias 'fortran-end-of-subprogram #[nil "\303 \304\216\305\212\306 \210\307\n!\205 \310 )\203 \311y\202* \306\312!\210\313\314\215\210\315\224b\210\311y+\207" [save-match-data-internal case-fold-search fortran-end-prog-re match-data ((set-match-data save-match-data-internal)) t beginning-of-line looking-at fortran-check-end-prog-re nil 2 ok (byte-code "\301\302\303#\203 \304 \203  \305\306\307\"\210\202  \302\207" [fortran-end-prog-re re-search-forward nil move fortran-check-end-prog-re throw ok t] 4) 0] 2 (#$ . 28880) nil])
#@179 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.
(defalias 'fortran-previous-statement #[nil "\305\211\306 \210\307\n!?\205\" \307\310!?\205\" \307\311\312!P!\206\" \307\313!\314y\315U\211\203F \307\n!\204# \307\310!\204# \307\316!\204# \307\311\fP!\204# \203T 	\204T \317\320!\202c \203] \321 \202c 	?\205c \322*\207" [continue-test not-first-statement fortran-comment-line-start-skip fortran-continuation-string comment-start-skip nil beginning-of-line looking-at "^[ 	]*#" "[ 	]*" regexp-quote " \\{5\\}[^ 0\n]\\|	[1-9]" -1 0 "[ 	]*$\\| \\{5\\}[^ 0\n]\\|	[1-9]" message "Incomplete continuation statement." fortran-previous-statement first-statement] 4 (#$ . 29484) nil])
#@173 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.
(defalias 'fortran-next-statement #[nil "\303\304 \210\305y\306U\205 m?\211\203- \307	!\204 \307\310!\204 \307\311!\204 \307\312\nP!\204 ?\2053 \313)\207" [not-last-statement fortran-comment-line-start-skip comment-start-skip nil beginning-of-line 1 0 looking-at "^[ 	]*#" "[ 	]*$\\|     [^ 0\n]\\|	[1-9]" "[ 	]*" last-statement] 3 (#$ . 30302) nil])
#@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!)\205T  \211\204+ \314\315Q\202@ 	\fW\203@ \212	b\210\311 \210\316`\317 {P)\203K \300\320\"\202T 	b\210\321\322!\210b-\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 1 find-begin keyword] 5 (#$ . 30840)])
#@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 (#$ . 31421)])
#@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 (#$ . 31667)])
#@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 (#$ . 31891) 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\202W \212\312	\311U\204O \313 \314=\204O \307\n!\2031 \315 \204O \305\306w\210\307\310!\203B 	S\211\202 \307\316!\203 	T\211\202 	\311U\205V `*)\207" [case-fold-search count fortran-end-prog-re t beginning-of-line " 	0-9" nil looking-at "end[ 	]*do\\b" 0 1 fortran-next-statement last-statement fortran-check-end-prog-re "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?do[ 	]+[^0-9]"] 3 (#$ . 32229)])
#@126 Search backwards for first unmatched DO [WHILE].
Return point or nil.  Ignores labelled DO loops (ie DO 10 ... 10 CONTINUE).
(defalias 'fortran-beginning-do #[nil "\304\305\212\306 \210\307\310w\210\311!)\203 \312\224\202Y \212\313\n\312U\204Q \314 \315=\204Q \311!\2033 \316 \204Q \307\310w\210\311!\203D \nS\211\202 \311\317!\203 \nT\211\202 \n\312U\205X `**\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 fortran-previous-statement first-statement fortran-check-end-prog-re "end[ 	]*do\\b"] 3 (#$ . 32780)])
#@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 (#$ . 33416) nil])
(byte-code "\301B\302\301!\204\f \303\301\207" [current-load-list fortran-if-start-re boundp "\\(\\(\\sw\\|\\s_\\)+:[ 	]*\\)?if[ 	]*("] 2)
#@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\202z \212\314	\313U\204r \315 \316=\204r \311\n!\2031 \317 \204r \307\310w\210\311\312!\203B 	S\211\202 \311!\203 \212\311\320!\204k \310\314y\313U\203f \311\321!\203f \311\322!\211\203Q \f)\203n 	T)\202 	\313U\205y `*)\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 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]"] 3 (#$ . 33888)])
#@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\320y\321U\2039 \314\322!\2039 \314\323!\211\203$ )*)\203E \321\224\202\251 \212\320\f\321U\204\241 \307 \310=\204\241 \314!\203` \324 \204\241 \312\313w\210\314	!\203\224 \212\314\317!\204\215 \313\320y\321U\203\210 \314\322!\203\210 \314\323!\211\203s )\203\220 \fS)\202H \314\325!\203H \fT\211\202I \f\321U\205\250 `*)\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 " \\{5\\}[^ 0\n]\\|	[1-9]" ".*then\\b[ 	]*[^ 	(=a-z0-9]" fortran-check-end-prog-re "end[ 	]*if\\b"] 3 (#$ . 34593)])
#@74 Indent current Fortran line based on its contents and on previous lines.
(defalias 'fortran-indent-line #[nil "\305 \212\306 \210\307 U\203 \310\311`\312\\\313#\203$ \314 \204$ \315!\210\2025 \306 \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 fortran-comment-line-start-skip 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 looking-at fortran-find-comment-start-skip fortran-indent-comment move-to-column nil fortran-fill fortran-blink-matching-do] 4 (#$ . 35536) nil])
(defalias 'fortran-auto-fill #[nil "i\302 V\205J \303 \212\304 \210\305 U\203$ \306\307`\310\\\311#\203+ \312 \204+ \313!\210\202< \304 \210\314	!\204< \315 \203< \316 \210)\317 \210iW\205I \320!)\207" [cfi fortran-comment-line-start-skip 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 looking-at fortran-find-comment-start-skip fortran-indent-comment fortran-fill move-to-column] 4])
(defalias 'fortran-indent-new-line 'reindent-then-newline-and-indent)
#@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-defun message "Indenting subprogram..." indent-region mark nil "Indenting subprogram...done."] 4 (#$ . 36913) 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\367 `eU\203+ +\202/ \311 +\312\306w\210\313\314!\203h \313\315!\204^ \306,\316y\317U\203X \313\320!\203X \313\321!\211,\203B ,)\203\367 +-\\+\202\367 \313\322!\203x +-\\+\202\367 \313\323!\203\210 +-\\+\202\367 \313\324!\203\230 +-\\+\202\367 \313\325!\203\250 +-\\+\202\367 \313\326!\203\270 +-\\+\202\367 \313\327!\203\310 +-\\+\202\367 \313\330!\203\330 +.\\+\202\367 \313\331!\203\350 +/\\+\202\367 \3130!\203\367 \332 \203\367 +)\212\333 \210\313\334!\204\3131!\203,2\335=\203+3\\+\202'2\336=\203'3\\+\317\202\313\337\3404!P!\204=\313\320!\203G+5\\+\202\313\341!\203U\317\317+\202\2046\203s\313\342!\203s\343 \203s+.Z+\202\312\306w\210\313\344!\203\207+-Z+\202\313\322!\203\227+-Z+\202\313\345!\203\247+-Z+\202\313\326!\203\267+-Z+\202\313\346!\203\314\343 \203\314+.Z+\202\313\347!\203\334+.Z+\202\313\350!\203\354+/Z+\202\3130!\203\332 \203+U\204\351\352\"\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 " \\{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 beginning-of-line "[ 	]*$" 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 fortran-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 (#$ . 37207)])
#@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 (#$ . 39688)])
#@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\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\"\210c\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$\205\334 \205\310\224b\210i\212\335\314x\210iT%])U?\205\326 \210\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-start-skip comment-column] 5 (#$ . 40367)])
#@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\210iX\205 iU\206 \304\303w\210i\305U)\207" [fortran-line-number-indent beginning-of-line " 	" nil "0-9" 5] 2 (#$ . 42207)])
#@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\320P!*+\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 (#$ . 42525)])
#@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 "\2056 \212\303\304 \305#)\2056 \306\224\306\225\307\306\224!\203& \212	b\210\310 )\2025 \nb\210\303\304 \305#\210\306\225b\210\305*\207" [comment-start-skip save-match-end save-match-beginning re-search-forward line-end-position t 0 fortran-is-in-string-p fortran-find-comment-start-skip] 4 (#$ . 43066) nil])
#@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\277 \212\307 \210\310	!)\203 \306\202\277 \311\n\205# \312\n!\313\306\211\314 \210\315 \210\203\272 \310	!\204T l\204T \3168\204a \n\203a \n\317h!\232\203a \306y\320V\2033 \306\211\2024 n\203i \321\306w\210i\322U\203u \323u\210\202\207 i\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 \3168-)\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 (#$ . 43546)])
(defalias 'fortran-auto-fill-mode 'auto-fill-mode)
(defalias 'fortran-fill #[nil "\306`\307 \310 \211\n\311 \\^\212\nb\210\312!?\205: \313!\210\314`!\205: \212\315\316\n\317#\210\2037 `\2029 `T))\211\206\220 \212\313T!\210\320\321x\210`\fTX\203d \313T!\210\322\323\317#\204d \nb\210n\203q \322\324	\317#\210\202\204 \325u\210\312\326!\203\200 \321u\210\202\204 \327\321x\210\203\215 `\202\217 `T)\212\205\261 \315\n\317#\205\261 \314`!?\205\261 \330\321x\210iTW)\206\274 \212b\210n)?\205\334 \212	b\210i)T\331  \\^V\205\334 b\210\332 \210\321.\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 move-to-column fortran-is-in-string-p re-search-backward "\\S\"\\s\"\\S\"" t "^ 	\n,'+-/*=)" nil re-search-forward "[	\n,'+-/*)=]" "[ 	]" -1 "\\s\"" " 	*" " 	" fortran-calculate-indent fortran-break-line fill-column fortran-break-before-delimiters quote fill-point comment-start-skip fortran-continuation-indent] 5])
(defalias 'fortran-break-line #[nil "`\306 \307 \310\212\f\203\" \311 \203\" \312\f\n\313#\210`	{`	|\210)\212\310y\210\314\315!)\203? \310\210`\316\225|\210\317 \210\320 \210\202B \321 \210\205_ \212\nb\210\310\210\317 \210\212\322\310x\210iT])j\210c),\207" [comment-string eol bol opoint comment-start-skip comment-column line-beginning-position line-end-position nil fortran-find-comment-start-skip re-search-backward t looking-at " \\{5\\}[^ 0\n]\\|	[1-9]" 0 delete-horizontal-space fortran-fill fortran-split-line " 	"] 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( \304f\305=\204( \306\307!\204( 	V\204( \304y\210T\202 \304f\305=\2033 \310\202F \306\307!\203= \304\202F \n\203E \310\202F \304*\207" [i fortran-analyze-depth fortran-tab-mode-default 0 nil 9 looking-at " \\{6\\}" t] 2 (#$ . 46101)])
(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)
#@120 Fill surrounding comment block as paragraphs, else fill statement.
Intended as the value of `fill-paragraph-function'.
(defalias 'fortran-fill-paragraph #[(&optional justify) "\212\306 \210\307!\204 \310 \210\202f \311P\212\312\313y!\203\" \307	!\204 \307	!\204+ \314y\210\315 )\212\314y\210\307	!\2040 \315 )\316\n\314#\210\314\306 \210\307!\210\317\320!\314\321\n#\210+\n\314\211\223\210\314\211\223\210+)\322\207" [fortran-comment-line-start-skip non-empty-comment start end fill-prefix paragraph-ignore-fill-prefix beginning-of-line looking-at fortran-fill-statement "[^ 	\n]" zerop -1 nil point-marker indent-region match-string 0 fill-region t fill-paragraph-function justify] 4 (#$ . 46785) "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 (#$ . 47512) nil])
#@205 Delete all text in column 72 and up (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\301\302\303\304#\205 \305\306\303\211\211\307%\210\204 \310 \210\202 )\207" [do-space re-search-forward "^.\\{72\\}\\(.*\\)" nil t replace-match "" 1 delete-horizontal-space] 6 (#$ . 48010) "p"])
#@71 Function to use for `add-log-current-defun-function' in Fortran mode.
(defalias 'fortran-current-defun #[nil "\212\301 \210\302\303\304\212\305 \210`)\302#\2038 \306\307!\2069 \303\310\311\302#\203+ \312u\210\313\311x\210\202. \311\210\314`\315 \210`\"\2029 \316*\207" [case-fold-search fortran-beginning-of-subprogram t re-search-forward "^[ 	]*\\(program\\|subroutine\\|function\\|[ 	a-z0-9*()]*[ 	]+function\\|\\(block[ 	]*data\\)\\)" fortran-end-of-subprogram match-string-no-properties 2 "[(\n]" nil -1 " 	" buffer-substring-no-properties backward-sexp "main"] 4 (#$ . 48493)])
(provide 'fortran)