;ELC ;;; compiled by roland@churchy.gnu.ai.mit.edu on Fri May 12 12:12:16 1995 ;;; from file /gd/gnu/emacs/19.0/lisp/fortran.el ;;; emacs version 19.28.91.1. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19"))) (error "`/gd/gnu/emacs/19.0/lisp/fortran.el' was compiled for Emacs 19")) (byte-code "\nB" ["version 1.30.5.1" fortran-mode-version current-load-list] 2) #@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. (defvar fortran-tab-mode-default nil (#$ . -575)) #@59 String to appear in mode line when TAB format mode is on. (defvar fortran-tab-mode-string nil (#$ . 858)) #@42 *Extra indentation applied to DO blocks. (defvar fortran-do-indent 3 (#$ . -970)) #@42 *Extra indentation applied to IF blocks. (defvar fortran-if-indent 3 (#$ . -1058)) #@75 *Extra indentation applied to STRUCTURE, UNION, MAP and INTERFACE blocks. (defvar fortran-structure-indent 3 (#$ . -1147)) #@59 *Extra indentation applied to Fortran continuation lines. (defvar fortran-continuation-indent 5 (#$ . -1276)) #@380 *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'. (defvar fortran-comment-indent-style (quote fixed) (#$ . -1393)) #@66 *Amount of extra indentation for text within full-line comments. (defvar fortran-comment-line-extra-indent 0 (#$ . -1843)) #@53 *Delimiter inserted to start new full-line comment. (defvar comment-line-start nil (#$ . -1972)) #@52 *Regexp to match the start of a full-line comment. (defvar comment-line-start-skip nil (#$ . -2075)) #@69 *Minimum statement indentation for fixed format continuation style. (defvar fortran-minimum-statement-indent-fixed 6 (#$ . -2182)) #@67 *Minimum statement indentation for TAB format continuation style. (defvar fortran-minimum-statement-indent-tab (max tab-width 6) (#$ . -2319)) #@86 *Single-character string inserted for Fortran comment indentation. Normally a space. (defvar fortran-comment-indent-char " " (#$ . -2468)) #@107 *Maximum indentation for Fortran line numbers. 5 means right-justify them within their five-column field. (defvar fortran-line-number-indent 1 (#$ . -2614)) #@76 *Non-nil causes all numbered lines to be treated as possible DO loop ends. (defvar fortran-check-all-num-for-matching-do nil (#$ . -2777)) #@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. (defvar fortran-blink-matching-if nil (#$ . -2923)) #@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 $. (defvar fortran-continuation-string "$" (#$ . -3135)) #@80 *String inserted by \[fortran-comment-region] at start of each line in region. (defvar fortran-comment-region "c$$$" (#$ . -3546)) #@80 *Non-nil causes line number digits to be moved to the correct column as typed. (defvar fortran-electric-line-number t (#$ . -3683)) #@72 *Non-nil displays a startup message when Fortran mode is first called. (defvar fortran-startup-message t (#$ . -3821)) #@107 *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 5 60 70\n[ ]|{ | | | | | | | | | | | | |}\n" (#$ . -3947)) #@105 *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 5 60 70\n[ ]| { | | | | | | | | | | | | |}\n" (#$ . -4259)) #@48 Address of mailing list for Fortran mode bugs. (defconst bug-fortran-mode "bug-fortran-mode@erl.mit.edu" (#$ . 4566)) #@46 Syntax table in use in Fortran mode buffers. (defvar fortran-mode-syntax-table nil (#$ . 4690)) #@80 Number of lines to scan to determine whether to use fixed or TAB format style. (defvar fortran-analyze-depth 100 (#$ . 4792)) #@74 *Non-nil causes `fortran-do-auto-fill' to break lines before delimiters. (defvar fortran-break-before-delimiters t (#$ . -4924)) (byte-code "[ ##############" [fortran-mode-syntax-table make-syntax-table modify-syntax-entry 59 "w" 13 " " 43 "." 45 61 42 47 39 "\"" 34 92 "/" 46 95 33 "<" 10 ">"] 4) #@102 For consideration as a value of `fortran-font-lock-keywords'. This does fairly subdued highlighting. (defconst fortran-font-lock-keywords-1 (byte-code " QB \"˰DPE)" ["c!*" comment-chars "^[" "].*" font-lock-comment-face (fortran-match-!-comment . font-lock-comment-face) "^[^" " ]" make-string 71 46 "\\(.*\\)" (1 font-lock-comment-face) ("'[^'\n]*'?" . 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)] 8) (#$ . 5307)) #@98 For consideration as a value of `fortran-font-lock-keywords'. This does a lot more highlighting. (defconst fortran-font-lock-keywords-2 (byte-code " Ͱ\fRQEQQEB+\"" [append fortran-font-lock-keywords-1 "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\\(lose\\|ontinue\\)\\|" "e\\(lse\\(\\|if\\)\\|nd\\(\\|do\\|if\\)\\)\\|format\\|" "i\\(f\\|n\\(clude\\|quire\\)\\)\\|open\\|print\\|" "re\\(ad\\|turn\\)\\|stop\\|then\\|w\\(hile\\|rite\\)" "and\\|eq\\|false\\|g[et]\\|l[et]\\|n\\(e\\|ot\\)\\|or\\|true" flogicals fkeywords type-types "\\<\\(" "\\)\\>[0-9 /*]*\\(\\sw+\\)?" (1 font-lock-type-face) (15 font-lock-variable-name-face nil t) "\\)\\>" "\\.\\(" "\\)\\." "\\<\\(do\\|go *to\\)\\>[ ]*\\([0-9]+\\)?" (1 font-lock-keyword-face) (2 font-lock-reference-face nil t) "^ *\\([0-9]+\\)" font-lock-reference-face] 14) (#$ . 5893)) #@97 For consideration as a value of `fortran-font-lock-keywords'. This does even more highlighting. (defconst fortran-font-lock-keywords-3 (byte-code " EE\"" [append fortran-font-lock-keywords-2 ", *\\(e\\(nd\\|rr\\)\\)\\> *\\(= *\\([0-9]+\\)\\)?" (1 font-lock-keyword-face) (4 font-lock-reference-face nil t) ("^ \\([^ 0]\\)" 1 font-lock-string-face) ("^ \\([1-9]\\)" 1 font-lock-string-face)] 5) (#$ . 7182)) #@54 Additional expressions to highlight in Fortran mode. (defvar fortran-font-lock-keywords (byte-code " = \f" [font-lock-maximum-decoration fortran-font-lock-keywords-1 2 fortran-font-lock-keywords-2 fortran-font-lock-keywords-3] 2) (#$ . 7606)) #@30 Keymap used in Fortran mode. (defvar fortran-mode-map nil (#$ . 7867)) (byte-code " ########################!+-B-+U./\"+$+$+$+$+$+$+$+@A$+BC$+DE$+FG$+HI$+JK$+LM$+NO$+PQ$+RS$+TU$+VW$+XY$+Z[$+\\]$+^_$+`a$+bc$+de$+fg$+hi$+jk$+lm$+no$+pq$+rs$+tu$+vw$+xy$+z{$+|}$+~$+$+$+$+$+$+$+$+$+$+$+$+$+$+$+$+$+$+$+$/.)" [fortran-mode-map make-sparse-keymap define-key ";" fortran-abbrev-start ";" fortran-comment-region "" beginning-of-fortran-subprogram "" end-of-fortran-subprogram ";" fortran-indent-comment "" mark-fortran-subprogram "\n" fortran-split-line "\n" fortran-indent-new-line "" fortran-indent-subprogram "" fortran-window-create-momentarily "" fortran-column-ruler "" fortran-previous-statement "" fortran-next-statement " " fortran-indent-line "0" fortran-electric-line-number "1" "2" "3" "4" "5" "6" "7" "8" "9" boundp fortran-mode-abbrev-table nil current-load-list abbrevs-changed ac 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) #@3111 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-do-auto-fill' breaks lines before delimiters. (default t) fortran-startup-message Set to nil to inhibit message first time Fortran mode is used. 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 " \f #\n!!\f!!!!!!!!!!!!#%!!!!!!+ !" [kill-all-local-variables fortran-startup-message message "Emacs Fortran mode %s. Bugs to %s" fortran-mode-version bug-fortran-mode nil fortran-mode-abbrev-table local-abbrev-table set-syntax-table fortran-mode-syntax-table make-local-variable font-lock-defaults (fortran-font-lock-keywords t t) fortran-break-before-delimiters t indent-line-function 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 require-final-newline abbrev-all-caps indent-tabs-mode 72 fill-column use-local-map fortran-mode-map "Fortran" mode-name fortran-mode major-mode fortran-comment-line-extra-indent fortran-minimum-statement-indent-fixed fortran-minimum-statement-indent-tab fortran-column-ruler-fixed fortran-column-ruler-tab fortran-tab-mode-string " TAB-format" fortran-analyze-file-format run-hooks fortran-mode-hook] 4 (#$ . 10421) nil]) (defalias 'fortran-comment-hook #[nil "xi\\ ])" [" " nil 1 comment-column] 2]) #@351 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 "y\n!\f + (bi U?* j D!D j c!P Yycu c;kHm iZ\"" [0 looking-at comment-line-start-skip fortran-indent-line fortran-find-comment-start-skip comment-start-skip fortran-comment-hook delete-horizontal-space nil comment-start "^[ ]*$" "\n" -1 comment-line-start insert-char fortran-comment-indent-char calculate-fortran-indent] 4 (#$ . 14787) 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) " \fœby/ cyU^` W^ c !\f\f!A`Ǖ|yU]` W]\f!A`Ǖ|A)\nb ʼn\nʼn*" [make-marker point-marker save-point end-region-mark end-region nil beg-region 0 arg fortran-comment-region 1 regexp-quote com looking-at] 4 (#$ . 15601) "*r\nP"]) #@111 Typing ;\[help-command] or ;? lists all the Fortran abbrevs. Any other key combination is executed normally. (defalias 'fortran-abbrev-start #[nil "\nc = =  C)" [nil c last-command-char read-event 63 help-char fortran-abbrev-help unread-command-events] 2 (#$ . 16177) nil]) #@53 List the currently defined abbrevs in Fortran mode. (defalias 'fortran-abbrev-help #[nil "! !!" [message "Listing abbrev table..." display-buffer fortran-prepare-abbrev-list-buffer "Listing abbrev table...done"] 2 (#$ . 16480) nil]) (defalias 'fortran-prepare-abbrev-list-buffer #[nil "!q \"eb! )!" [get-buffer-create "*Abbrevs*" erase-buffer insert-abbrev-table-description fortran-mode-abbrev-table t set-buffer-modified-p nil edit-abbrevs-mode] 3]) #@270 Inserts 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 " \n\n y ! !=!y`\"`)$" [momentary-string-display indent-tabs-mode fortran-column-ruler-tab fortran-column-ruler-fixed 0 window-start selected-window window-point nil "Type SPC or any command to erase ruler."] 5 (#$ . 16967) nil]) #@81 Makes the window 72 columns wide. See also `fortran-window-create-momentarily'. (defalias 'fortran-window-create #[nil "" [error (byte-code " W ZZ!!!\" !)" [2 window-min-width 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 "!‡" [message "No room for Fortran window." error] 2)))] 3 (#$ . 17532) nil]) #@148 Momentarily makes 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) "\nU ‹ " [arg 1 ((byte-code " ?! ! C)" [fortran-window-create error message "Type SPC to continue editing." read-event char string-to-char " " unread-command-events] 4)) fortran-window-create] 2 (#$ . 18022) "p"]) #@67 Break line at point and insert continuation marker and alignment. (defalias 'fortran-split-line #[nil " y !) Ʊ.(c \".  " [delete-horizontal-space 0 looking-at comment-line-start-skip "\n" comment-line-start " " indent-tabs-mode "\n " insert-char fortran-numerical-continuation-char 1 "\n " fortran-continuation-string fortran-indent-line] 3 (#$ . 18485) 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 "y!`\\fZŦ\\)" [-1 looking-at " [1-9]" 1 48 9 49] 2 (#$ . 18886)]) #@159 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) "x`w`|" [chars nil] 3 (#$ . 19208) "*s"]) #@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) " !!!iU'y!)f 1\n3 iUQy!)Q =Q =fъy`)#)f!l!!xc " [arg fortran-electric-line-number self-insert-command prefix-numeric-value 1 5 0 looking-at " " indent-tabs-mode fortran-minimum-statement-indent-tab fortran-minimum-statement-indent-fixed " " last-command fortran-indent-line fortran-indent-new-line re-search-backward "[^ 0-9]" t "[0-9]" " " nil last-command-char] 4 (#$ . 19468) "P"]) #@65 Moves point to the beginning of the current Fortran subprogram. (defalias 'beginning-of-fortran-subprogram #[nil "y#!y)" [t case-fold-search -2 re-search-backward "^[ 0-9]*end\\b[ ]*[^ =(a-z]" nil move looking-at 1] 4 (#$ . 20117) nil]) #@59 Moves point to the end of the current Fortran subprogram. (defalias 'end-of-fortran-subprogram #[nil "y#ǔby)" [t case-fold-search 1 re-search-forward "^[ 0-9]*end\\b[ ]*[^ =(a-z]" nil move 0] 4 (#$ . 20379) nil]) #@83 Put mark at end of Fortran subprogram, point at beginning. The marks are pushed. (defalias 'mark-fortran-subprogram #[nil " `! " [end-of-fortran-subprogram push-mark beginning-of-fortran-subprogram] 2 (#$ . 20614) 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 "y !?\"!P!\"!\"!yUM !#!#!#!# P!# [\n[!j d j\n?j*" [nil continue-test not-first-statement 0 looking-at comment-line-start-skip "[ ]*" regexp-quote fortran-continuation-string " [^ 0\n]" " [1-9]" -1 "[ ]*$" comment-start-skip message "Incomplete continuation statement." fortran-previous-statement first-statement] 4 (#$ . 20848) 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 "yyUm?4 !!!!\nP! ?:)" [nil not-last-statement 0 1 looking-at comment-line-start-skip "[ ]*$" " [^ 0\n]" " [1-9]" "[ ]*" comment-start-skip last-statement] 3 (#$ . 21484) nil]) (defalias 'fortran-blink-matching-if #[nil " `yw!)O $;\f W;\fby``{P)\nF\n\"O\fb! b," [window-start nil message endif-point matching-if top-of-window 0 " 0-9" looking-at "end[ ]*if\\b" fortran-beginning-if "No matching if." "Matches " "%s" sit-for 1] 4]) (defalias 'fortran-blink-matching-do #[nil " `yw!)O $;\f W;\fby``{P)\nF\n\"O\fb! b," [window-start nil message enddo-point matching-do top-of-window 0 " 0-9" looking-at "end[ ]*do\\b" fortran-beginning-do "No matching do." "Matches " "%s" sit-for 1] 4]) #@99 Put mark at end of Fortran DO [WHILE]-ENDDO construct, point at beginning. The marks are pushed. (defalias 'fortran-mark-do #[nil "  ! \nb b*" [nil do-point enddo-point fortran-end-do fortran-beginning-do message "No matching do." push-mark] 2 (#$ . 22535) nil]) (defalias 'fortran-end-do #[nil "yw!)UN =N!Nw!>Z!\\UV`*" [0 " 0-9" nil looking-at "end[ ]*do\\b" 1 count fortran-next-statement last-statement "^[ 0-9]*end\\b[ ]*[^ =(a-z]" "do[ ]+[^0-9]"] 3]) (defalias 'fortran-beginning-do #[nil "yw!)UN =N!Nw!>Z!\\UV`*" [0 " 0-9" nil looking-at "do[ ]+" 1 count fortran-previous-statement first-statement "^[ 0-9]*end\\b[ ]*[^ =(a-z]" "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 "  ! \nb b*" [nil if-point endif-point fortran-end-if fortran-beginning-if message "No matching if." push-mark] 2 (#$ . 23383) nil]) (defalias 'fortran-end-if #[nil "yw!)Uz =z!zw!>Z!!p\fyUj!a!j!\fN\f)v\\)U`*" [0 " 0-9" nil looking-at "end[ ]*if\\b" 1 count fortran-next-statement last-statement "^[ 0-9]*end\\b[ ]*[^ =(a-z]" "if[ ]*(" ".*)[ ]*then\\b[ ]*[^ (=a-z0-9]" then-test " [^ 0\n]" " [1-9]" ".*then\\b[ ]*[^ (=a-z0-9]"] 3]) (defalias 'fortran-beginning-if #[nil " = w!D Ɏ!C yU@!7!@! $ )*)K͔U =!w!! yU!!! w )Z)O!O\\QU`*" [fortran-previous-statement first-statement fortran-next-statement " 0-9" nil looking-at "if[ ]*(" match-data match-data ((store-match-data match-data)) ".*)[ ]*then\\b[ ]*[^ (=a-z0-9]" then-test 1 0 " [^ 0\n]" " [1-9]" ".*then\\b[ ]*[^ (=a-z0-9]" count "^[ 0-9]*end\\b[ ]*[^ =(a-z]" "end[ ]*if\\b"] 3]) #@75 Indents current Fortran line based on its contents and on previous lines. (defalias 'fortran-indent-line #[nil " y U`\\#$ $ !6y !6 6 )i WA !Zi)VZ )d )" [calculate-fortran-indent cfi 0 fortran-current-line-indentation re-search-forward "^[ ]*[0-9]+" 4 t fortran-line-number-indented-correctly-p fortran-indent-to-column looking-at comment-line-start-skip fortran-find-comment-start-skip fortran-indent-comment move-to-column auto-fill-function nil fill-column fortran-do-auto-fill fortran-blink-matching-if fortran-blink-matching-do] 4 (#$ . 24627) 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 " yw!*!*!*\n!!- ) " [abbrev-mode expand-abbrev 0 " " nil looking-at "[0-9]" "end" "else" regexp-quote fortran-continuation-string fortran-indent-line newline] 3 (#$ . 25254) nil]) #@63 Properly indents the Fortran subprogram which contains point. (defalias 'fortran-indent-subprogram #[nil " !` #)!" [mark-fortran-subprogram message "Indenting subprogram..." indent-region mark nil "Indenting subprogram...done."] 4 (#$ . 25658) nil]) #@63 Calculates the Fortran indent column based on previous lines. (defalias 'calculate-fortran-indent #[nil "\n \f\f \" `eU. 2 w!q!gyUa!X!a!E)\\!\\!\\!\\!\\!\\!\\!\\!\\! )y!8\"!/#=%\\*#=* %\\8)!P!F!F!P*\\8!^88,}!} }Z8w!Z8!Z8!Z8!Z8!Z8!Z8! Z8!Z8!Z8!&Z8!8 U8 \") ]," [nil t indent-tabs-mode fortran-minimum-statement-indent-tab fortran-minimum-statement-indent-fixed fortran-minimum-statement-indent case-fold-search first-statement icol fortran-previous-statement fortran-current-line-indentation " 0-9" looking-at "if[ ]*(" ".*)[ ]*then\\b[ ]*[^ _$(=a-z0-9]" then-test 1 0 " [^ 0\n]" " [1-9]" ".*then\\b[ ]*[^ _$(=a-z0-9]" fortran-if-indent "\\(else\\|elseif\\)\\b" "select[ ]*case[ ](.*)\\b" "case[ ]*(.*)[ ]*\n" "case[ ]*default\\b" "\\(otherwise\\|else[ ]*where\\)\\b" "where[ ]*(.*)[ ]*\n" "do\\b" fortran-do-indent "\\(structure\\|union\\|map\\|interface\\)\\b[ ]*[^ =(a-z]" fortran-structure-indent "end\\b[ ]*[^ =(a-z]" "[ ]*$" comment-line-start-skip fortran-comment-indent-style relative fortran-comment-line-extra-indent fixed "[ ]*" regexp-quote fortran-continuation-string fortran-continuation-indent "[ ]*#" fortran-check-all-num-for-matching-do "[ ]*[0-9]+" fortran-check-for-matching-do "end[ ]*if\\b" "end[ ]*where\\b" "continue\\b" "end[ ]*do\\b" "end[ ]*\\(structure\\|union\\|map\\|interface\\)\\b[ ]*[^ =(a-z]" "end[ ]*select\\b[ ]*[^ =(a-z]" message "Warning: `end' not in column %d. Probably an unclosed block."] 5 (#$ . 25927)]) #@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 "y\n! b ;  !w7!,!3b7wwi)" [0 looking-at comment-line-start-skip fortran-comment-indent-char char-to-string nil " [^ 0\n]" " [1-9]" "[ 0-9]" " "] 2 (#$ . 27858)]) #@512 Indents 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) "y\n!2 \f;\fH\fb !P! \niZ\")!R\fDb!cc!s\fm!c \"u m!!\f\fj! \"ju!`ZZW!^j)w \nj\" bi U? j)" [0 looking-at comment-line-start-skip fortran-comment-indent-style fortran-comment-indent-char char delete-horizontal-regexp " " char-to-string insert-char col " [1-9]" indent-tabs-mode delete-char 2 " " fortran-continuation-string " [^ 0\n]" 6 " " fortran-numerical-continuation-char 1 delete-horizontal-space regexp-quote fortran-minimum-statement-indent-tab fortran-minimum-statement-indent-fixed 5 "[0-9]+" extra-space message "Warning: line number exceeds 5-digit limit." fortran-line-number-indent "0-9" nil comment-start-skip fortran-find-comment-start-skip fortran-comment-hook] 5 (#$ . 28431)]) #@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 "ywi Xi UwiU)" [0 " " nil fortran-line-number-indent "0-9" 5] 2 (#$ . 29871)]) #@99 When called from a numbered statement, returns t if matching DO is found. Otherwise return a nil. (defalias 'fortran-check-for-matching-do #[nil "y!6ww`w`{y ϰ#6 P!+" [nil t case-fold-search charnum 0 looking-at "[ ]*[0-9]+" " " "0" "0-9" re-search-backward "\\(^[ 0-9]*end\\b[ ]*[^ =(a-z]\\)\\|" "\\(^[ 0-9]*do[ ]*0*" "\\b\\)\\|" "\\(^[ ]*0*" "\\b\\)" "^[ 0-9]*do[ ]*0*"] 8 (#$ . 30134)]) #@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 " `)#)<ĔĕĔ!' b );b `)#ĕb*" [re-search-forward comment-start-skip nil t 0 save-match-end save-match-beginning fortran-is-in-string-p fortran-find-comment-start-skip] 4 (#$ . 30578) nil]) (defalias 'fortran-match-!-comment #[(limit) "\f#`! ??%`S`\f^D!)" [nil found search-forward "!" limit t fortran-is-in-string-p store-match-data] 4]) #@81 Return non-nil if POS (a buffer position) is inside a Fortran string, nil else. (defalias 'fortran-is-in-string-p #[(where) "bn\fy\f!)%! \n \f  \f!\\l\\ 8nnh!nyVgm8 :nvwiUuiWg!u`)  ^\n\f #`\n^\n)`W`\n % 8 = 8-)" [where nil 0 looking-at comment-line-start-skip (0 nil nil nil nil nil 0) comment-start regexp-quote t end-of-line parse-limit not-done quoted-comment-start parse-state fortran-next-statement fortran-previous-statement 3 char-to-string 1 " 0-9" 5 fortran-continuation-string re-search-forward parse-partial-sexp] 7 (#$ . 31137)]) #@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) " ?!Vĉ " [arg auto-fill-function prefix-numeric-value 0 fortran-indent-line force-mode-line-update] 2 (#$ . 31833) "P"]) (defalias 'fortran-do-auto-fill #[nil "`y`)`)\n \\^\nb!?F\n!`!E\n#?`A`T)F)\nT!x`TXq\nT!\f#q\nbn~#u!ux``T)\n#`!?xi\nTW)bn)?bi)\nTVb bi) \\Vb )." [opoint 0 bol nil eol fortran-current-line-indentation bos looking-at comment-line-start-skip move-to-column fill-column fortran-is-in-string-p re-search-backward "[^']'[^']" t fortran-break-before-delimiters quote "^ \n,'+-/*=)" re-search-forward "[ \n,'+-/*)=]" "[ ]" -1 "'" 1 " *" fill-point comment-start-skip " " fortran-break-line calculate-fortran-indent fortran-continuation-indent] 5 nil nil]) (defalias 'fortran-break-line #[nil "`y`)`), ,\f#` {` |)y!:!)Qy ! T \ni\fb j\nc)," [0 nil comment-string eol bol opoint comment-start-skip fortran-find-comment-start-skip re-search-backward t 1 looking-at " [^ 0\n]" " [1-9]" delete-indentation delete-char 2 delete-horizontal-space fortran-do-auto-fill fortran-split-line fortran-comment-hook] 4]) #@208 Returns 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 "ebm'!'!' V'y T!1ǂE!;ƂEDǂE*" [0 i looking-at " " " " fortran-analyze-depth nil t fortran-tab-mode-default] 2 (#$ . 33377)]) (byte-code " \n B!" [fortran-tab-mode-string minor-mode-alist (fortran-tab-mode-string (indent-tabs-mode fortran-tab-mode-string)) provide fortran] 2)