%PDF-
%PDF-
Mini Shell
Mini Shell
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\302\311\312\313\306\301&\210\314\315\316\317\320DD\321\322\323\324\325\306\310& \210\314\326\316\317\327DD\330\322\323\324\325\306\310& \210\314\331\316\317\332DD\333\322\323\324\325\306\310& \210\314\334\316\317\335DD\336\322\323\324\325\306\310& \210\314\337\316\317\340DD\341\322\323\324\325\306\310\342\343& \210\314\344\316\317\345DD\346\322\323\324\325\306\310\342\347& \210\314\350\316\317\351DD\352\322\323\324\325\306\310& \210\314\353\316\317\354DD\355\322\356\324\357\306\310& \210\314\360\316\317\361DD\362\322\363\324\357\306\310& \210\314\364\316\317\365DD\366\322\363\324\357\306\310& \210\314\367\316\317\370DD\371\322\372\324\373\306\301& \210\314\374\316\317\375DD\376\322\377\324\201@ \306\301& \210\314\201A \316\317\201B DD\201C \322\372\324\373\306\301\342\201D & \210\314\201E \316\317\201F DD\201G \322\363\324\357\306\301& \210\314\201H \316\317\201I DD\201J \322\372\324\373\306\301& \210\314\201K \316\317\201L DD\201M \322\201N \324\201O \306\301& \210\314\201P \316\317\201Q DD\201R \322\372\324\373\306\301& \210\314\201S \316\317\201T DD\201U \322\201V \324\201W \201X \201Y \306\301& \207" [custom-declare-group f90 nil "Major mode for editing free format Fortran 90,95 code." :link (custom-group-link :tag "Font Lock Faces group" font-lock-faces) :group languages f90-indent "Indentation in free format Fortran." :prefix "f90-" custom-declare-variable f90-do-indent funcall function #[0 "\300\207" [3] 1] "Extra indentation applied to DO blocks." :type integer :safe integerp f90-if-indent #[0 "\300\207" [3] 1] "Extra indentation applied to IF, SELECT CASE, WHERE and FORALL blocks." f90-type-indent #[0 "\300\207" [3] 1] "Extra indentation applied to TYPE, ENUM, INTERFACE and BLOCK DATA blocks." f90-program-indent #[0 "\300\207" [2] 1] "Extra indentation applied to PROGRAM, MODULE, SUBROUTINE, FUNCTION blocks." f90-associate-indent #[0 "\300\207" [2] 1] "Extra indentation applied to ASSOCIATE blocks." :version "23.1" f90-critical-indent #[0 "\300\207" [2] 1] "Extra indentation applied to BLOCK, CRITICAL blocks." "24.1" f90-continuation-indent #[0 "\300\207" [5] 1] "Extra indentation applied to continuation lines." f90-comment-region #[0 "\300\207" [#1="!!$"] 1 #1#] "String inserted by \\[f90-comment-region] at start of each line in region." string stringp f90-indented-comment-re #[0 "\300\207" [#2="!"] 1 #2#] "Regexp matching comments to indent as code." regexp f90-directive-comment-re #[0 "\300\207" [#3="!hpf\\$"] 1 #3#] "Regexp of comment-like directive like \"!HPF\\\\$\", not to be indented." f90-beginning-ampersand #[0 "\300\207" [t] 1] "Non-nil gives automatic insertion of `&' at start of continuation line." boolean booleanp f90-smart-end #[0 "\300\207" [blink] 1] "Qualification of END statements according to the matching block start.\nFor example, change the END that closes an IF block to END IF.\nIf the block has a label, add it as well (unless `f90-smart-end-names'\nsays not to). Allowed values are `blink', `no-blink', and nil. If nil,\nnothing is done. The other two settings have the same effect, but `blink'\nadditionally blinks the cursor to the start of the block." (choice (const blink) (const no-blink) (const nil)) #[257 "\211\300>\207" [(blink no-blink nil)] 3 "\n\n(fn VALUE)"] f90-smart-end-names #[0 "\300\207" [t] 1] "Whether completion of END statements should insert optional block names.\nFor example, when closing a \"PROGRAM PROGNAME\" block, \"PROGNAME\" is\noptional in the \"END PROGRAM\" statement. The same is true for modules,\nfunctions, subroutines, and types. Some people prefer to omit the name\nfrom the END statement, since it makes it easier to change the name.\n\nThis does not apply to named DO, IF, etc. blocks. If such blocks\nstart with a label, they must end with one.\n\nIf an end statement has a name that does not match the start, it is always\ncorrected, regardless of the value of this variable." "24.4" f90-break-delimiters #[0 "\300\207" [#4="[-+\\*/><=,% ]"] 1 #4#] "Regexp matching delimiter characters at which lines may be broken.\nThere are some common two-character tokens where one or more of\nthe members matches this regexp. Although Fortran allows breaks\nwithin lexical tokens (provided the next line has a beginning ampersand),\nthe constant `f90-no-break-re' ensures that such tokens are not split." f90-break-before-delimiters #[0 "\300\207" [t] 1] "Non-nil causes `f90-do-auto-fill' to break lines before delimiters." f90-auto-keyword-case #[0 "\300\207" [nil] 1] "Automatic case conversion of keywords.\nThe options are `downcase-word', `upcase-word', `capitalize-word' and nil." (choice (const downcase-word) (const upcase-word) (const capitalize-word) (const nil)) #[257 "\211\300>\207" [(downcase-word capitalize-word upcase-word nil)] 3 "\n\n(fn VALUE)"] f90-leave-line-no #[0 "\300\207" [nil] 1] "If non-nil, line numbers are not left justified." f90-mode-hook #[0 "\300\207" [nil] 1] "Hook run when entering F90 mode." hook #[257 "\211\300\235\207" [((f90-add-imenu-menu) nil)] 3 "\n\n(fn VALUE)"] :options (f90-add-imenu-menu)] 12)
#@52 Regexp used by the function `f90-change-keywords'.
(defconst f90-keywords-re "\\_<\\(?:a\\(?:bstract\\|llocat\\(?:\\(?:abl\\)?e\\)\\|s\\(?:s\\(?:ign\\(?:ment\\)?\\|ociate\\)\\|ynchronous\\)\\)\\|b\\(?:ackspace\\|ind\\|lock\\)\\|c\\(?:a\\(?:ll\\|se\\)\\|haracter\\|l\\(?:ass\\|ose\\)\\|o\\(?:dimension\\|m\\(?:mon\\|plex\\)\\|n\\(?:current\\|t\\(?:ains\\|i\\(?:guous\\|nue\\)\\)\\)\\)\\|ritical\\|ycle\\)\\|d\\(?:ata\\|e\\(?:allocate\\|ferred\\)\\|imension\\|o\\(?:uble\\)?\\)\\|e\\(?:l\\(?:emental\\|se\\(?:if\\|where\\)?\\)\\|n\\(?:d\\(?:do\\|file\\|if\\)?\\|try\\|um\\(?:erator\\)?\\)\\|quivalence\\|rror stop\\|x\\(?:it\\|te\\(?:nds\\(?:_type_of\\)?\\|rnal\\)\\)\\)\\|f\\(?:inal\\|or\\(?:all\\|mat\\)\\|unction\\)\\|g\\(?:eneric\\|oto\\)\\|i\\(?:f\\|m\\(?:age_index\\|p\\(?:\\(?:lici\\|or\\)t\\)\\)\\|n\\(?:clude\\|quire\\|t\\(?:e\\(?:ger\\|nt\\|rface\\)\\|rinsic\\)\\)\\)\\|logical\\|module\\|n\\(?:amelist\\|o\\(?:n\\(?:_\\(?:intrinsic\\|overridable\\)\\|e\\)\\|pass\\)\\|ullify\\)\\|o\\(?:nly\\|p\\(?:e\\(?:n\\|rator\\)\\|tional\\)\\)\\|p\\(?:a\\(?:rameter\\|ss\\|use\\)\\|ointer\\|r\\(?:ecision\\|i\\(?:nt\\|vate\\)\\|o\\(?:cedure\\|gram\\|tected\\)\\)\\|u\\(?:blic\\|re\\)\\)\\|re\\(?:a[dl]\\|cursive\\|sult\\|turn\\|wind\\)\\|s\\(?:a\\(?:me_type_as\\|ve\\)\\|e\\(?:lect\\|quence\\)\\|top\\|ub\\(?:\\(?:modul\\|routin\\)e\\)\\|ync \\(?:all\\|memory\\)\\)\\|t\\(?:arget\\|hen\\|ype\\)\\|\\(?:us\\|v\\(?:alu\\|olatil\\)\\|w\\(?:h\\(?:er\\|il\\)\\|rit\\)\\)e\\)\\_>" (#$ . 5544))
#@42 Keyword-regexp for font-lock level >= 3.
(defconst f90-keywords-level-3-re "\\_<\\(?:a\\(?:bstract\\|llocat\\(?:\\(?:abl\\)?e\\)\\|ssign\\(?:ment\\)?\\)\\|backspace\\|c\\(?:lose\\|o\\(?:dimension\\|n\\(?:current\\|tiguous\\)\\)\\)\\|d\\(?:e\\(?:allocate\\|ferred\\)\\|imension\\)\\|e\\(?:lemental\\|n\\(?:dfile\\|try\\)\\|quivalence\\|xternal\\)\\|final\\|i\\(?:mport\\|n\\(?:quire\\|t\\(?:ent\\|rinsic\\)\\)\\)\\|n\\(?:o\\(?:n_\\(?:intrinsic\\|overridable\\)\\|pass\\)\\|ullify\\)\\|o\\(?:nly\\|p\\(?:e\\(?:n\\|rator\\)\\|tional\\)\\)\\|p\\(?:a\\(?:rameter\\|ss\\|use\\)\\|ointer\\|r\\(?:i\\(?:nt\\|vate\\)\\|otected\\)\\|u\\(?:blic\\|re\\)\\)\\|re\\(?:ad\\|cursive\\|sult\\|wind\\)\\|s\\(?:ave\\|e\\(?:lect\\|quence\\)\\|ync \\(?:all\\|memory\\)\\)\\|target\\|\\(?:v\\(?:alu\\|olatil\\)\\|writ\\)e\\)\\_>" (#$ . 7035))
#@59 Regexp whose first part matches F90 intrinsic procedures.
(defconst f90-procedures-re "\\_<\\(a\\(?:bs\\|c\\(?:har\\|osh?\\)\\|djust[lr]\\|i\\(?:mag\\|nt\\)\\|ll\\(?:ocated\\)?\\|n\\(?:int\\|y\\)\\|s\\(?:inh?\\|sociated\\)\\|t\\(?:an[2h]?\\|omic_\\(?:define\\|ref\\)\\)\\)\\|b\\(?:essel_\\(?:j[01n]\\|y[01n]\\)\\|g[et]\\|i\\(?:nd\\|t_size\\)\\|l[et]\\|test\\)\\|c\\(?:_\\(?:associated\\|f\\(?:_p\\(?:\\(?:rocp\\)?ointer\\)\\|unloc\\)\\|loc\\|sizeof\\)\\|eiling\\|har\\|mplx\\|o\\(?:m\\(?:mand_argument_count\\|piler_\\(?:options\\|version\\)\\)\\|njg\\|sh?\\|unt\\)\\|pu_time\\|shift\\)\\|d\\(?:ate_and_time\\|ble\\|i\\(?:gits\\|m\\)\\|ot_product\\|prod\\|shift[lr]\\)\\|e\\(?:oshift\\|psilon\\|rf\\(?:c\\(?:_scaled\\)?\\)?\\|x\\(?:ecute_command_line\\|p\\(?:onent\\)?\\|tends\\(?:_type_of\\)?\\)\\)\\|f\\(?:indloc\\|l\\(?:oor\\|ush\\)\\|raction\\)\\|g\\(?:amma\\|et_\\(?:command\\(?:_argument\\)?\\|environment_variable\\)\\)\\|h\\(?:uge\\|ypot\\)\\|i\\(?:a\\(?:char\\|ll\\|n[dy]\\)\\|b\\(?:clr\\|its\\|set\\)\\|char\\|e\\(?:ee_\\(?:get_underflow_mode\\|s\\(?:et_underflow_mode\\|upport_underflow_control\\)\\)\\|or\\)\\|mage_index\\|n\\(?:dex\\|t\\)\\|or\\|parity\\|s\\(?:_contiguous\\|hftc?\\)\\)\\|kind\\|l\\(?:bound\\|cobound\\|e\\(?:adz\\|n\\(?:_trim\\)?\\)\\|g[et]\\|l[et]\\|o\\(?:ck\\|g\\(?:10\\|_gamma\\|ical\\)?\\)\\)\\|m\\(?:a\\(?:sk[lr]\\|tmul\\|x\\(?:exponent\\|loc\\|val\\)?\\)\\|erge\\(?:_bits\\)?\\|in\\(?:exponent\\|loc\\|val\\)?\\|o\\(?:d\\(?:ulo\\)?\\|ve_alloc\\)\\|vbits\\)\\|n\\(?:e\\(?:arest\\|w_line\\)\\|int\\|o\\(?:rm2\\|t\\)\\|u\\(?:ll\\|m_images\\)\\)\\|p\\(?:a\\(?:ck\\|rity\\)\\|op\\(?:cnt\\|par\\)\\|r\\(?:e\\(?:cision\\|sent\\)\\|oduct\\)\\)\\|r\\(?:a\\(?:dix\\|n\\(?:dom_\\(?:number\\|seed\\)\\|ge\\)\\)\\|e\\(?:peat\\|shape\\)\\|rspacing\\)\\|s\\(?:ame_type_as\\|ca\\(?:le\\|n\\)\\|e\\(?:lected_\\(?:\\(?:char\\|int\\|real\\)_kind\\)\\|t_exponent\\)\\|h\\(?:ape\\|ift[alr]\\)\\|i\\(?:gn\\|nh?\\|ze\\)\\|p\\(?:acing\\|read\\)\\|qrt\\|torage_size\\|um\\|y\\(?:nc images\\|stem_clock\\)\\)\\|t\\(?:anh?\\|his_image\\|iny\\|r\\(?:a\\(?:ilz\\|ns\\(?:fer\\|pose\\)\\)\\|im\\)\\)\\|u\\(?:bound\\|cobound\\|n\\(?:\\(?:lo\\|pa\\)ck\\)\\)\\|verify\\|wait\\)[ ]*(" (#$ . 7862))
#@38 Regexp matching intrinsic operators.
(defconst f90-operators-re "\\.\\(and\\|eqv?\\|false\\|g[et]\\|l[et]\\|n\\(?:e\\(?:qv\\)?\\|ot\\)\\|or\\|true\\)\\." (#$ . 10069))
#@57 Regexp for all HPF keywords, procedures and directives.
(defconst f90-hpf-keywords-re "\\_<\\(?:a\\(?:l\\(?:ign\\|l_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\)\\|ny_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\)\\|block\\|c\\(?:o\\(?:py_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\|unt_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\)\\|yclic\\)\\|d\\(?:istribute\\|ynamic\\)\\|extrinsic\\|grade_\\(?:down\\|up\\)\\|hpf_\\(?:alignment\\|distribution\\|template\\)\\|i\\(?:a\\(?:ll\\(?:_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\)?\\|ny\\(?:_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\)?\\)\\|len\\|n\\(?:\\(?:dependen\\|heri\\)t\\)\\|parity\\(?:_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\)?\\)\\|leadz\\|m\\(?:axval_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\|inval_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\)\\|n\\(?:ew\\|umber_of_processors\\)\\|onto\\|p\\(?:arity\\(?:_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\)?\\|op\\(?:cnt\\|par\\)\\|ro\\(?:cessors\\(?:_shape\\)?\\|duct_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\)\\|ure\\)\\|re\\(?:align\\|distribute\\)\\|sum_\\(?:prefix\\|s\\(?:catter\\|uffix\\)\\)\\|template\\|with\\)\\_>" (#$ . 10243))
#@41 Regexp for Fortran intrinsic constants.
(defconst f90-constants-re "\\_<\\(?:atomic_\\(?:\\(?:int\\|logical\\)_kind\\)\\|c\\(?:_\\(?:alert\\|b\\(?:ackspace\\|ool\\)\\|c\\(?:arriage_return\\|har\\)\\|double\\(?:_complex\\)?\\|f\\(?:loat\\(?:_complex\\)?\\|orm_feed\\|unptr\\)\\|horizontal_tab\\|int\\(?:\\(?:16\\|32\\|64\\|8\\|_\\(?:fast\\(?:16\\|32\\|64\\|8\\)\\|least\\(?:16\\|32\\|64\\|8\\)\\)\\|max\\|ptr\\)_t\\)?\\|long\\(?:_\\(?:double\\(?:_complex\\)?\\|long\\)\\)?\\|n\\(?:ew_line\\|ull_\\(?:\\(?:cha\\|\\(?:fun\\)?pt\\)r\\)\\)\\|ptr\\|s\\(?:hort\\|i\\(?:gned_char\\|ze_t\\)\\)\\|vertical_tab\\)\\|haracter_\\(?:kinds\\|storage_size\\)\\)\\|error_unit\\|file_storage_size\\|i\\(?:eee_\\(?:arithmetic\\|\\(?:exception\\|feature\\)s\\)\\|n\\(?:put_unit\\|t\\(?:16\\|32\\|64\\|8\\|eger_kinds\\)\\)\\|ostat_\\(?:e\\(?:nd\\|or\\)\\|inquire_internal_unit\\)\\|so_\\(?:c_binding\\|fortran_env\\)\\)\\|lo\\(?:ck_type\\|gical_kinds\\)\\|numeric_storage_size\\|output_unit\\|real\\(?:128\\|32\\|64\\|_kinds\\)\\)\\_>" (#$ . 11386))
#@182 Search for the start/end of the definition of a derived type, up to LIMIT.
Set the match data so that subexpression 1,2 are the TYPE, and
type-name parts, respectively.
(fn LIMIT)
(defalias 'f90-typedef-matcher #[257 "\300\211\301\302\303#\203< \304 \262\305\306!?\2056 \305\307!\203! \310\225b\202' \301\311\312 \303#\2056 \313\314\315\224\315\225D\"!\210\303\211\262\203 \207" [nil re-search-forward "\\_<\\(\\(?:end[ ]*\\)?type\\)\\_>[ ]*" t match-data looking-at "\\(is\\_>\\|(\\)" "\\(\\(?:\\sw\\|\\s_\\)+\\)" 0 "[ ]*::[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" line-end-position set-match-data append 1] 8 (#$ . 12422)])
#@71 This does fairly subdued highlighting of comments and function calls.
(defvar f90-font-lock-keywords-1 (list '("\\_<\\(module[ ]*procedure\\)\\_>\\([^()\n]*::\\)?[ ]*\\([^&!\n]*\\)" (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t)) '(f90-typedef-matcher (1 font-lock-keyword-face) (2 font-lock-function-name-face)) '("\\_<\\(\\(?:end[ ]*\\)?interface[ ]*\\(?:assignment\\|operator\\|read\\|write\\)\\)[ ]*(" (1 font-lock-keyword-face t)) '("\\_<\\(\\(?:end[ ]*\\)?\\(program\\|\\(?:module[ ]*\\)?\\(?:function\\|subroutine\\)\\|\\(?:sub\\)?module\\|associate\\|interface\\)\\|use\\|call\\)\\_>[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)?" (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t)) '("\\_<\\(submodule\\)\\_>[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)?" (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t)) '("\\_<\\(use\\)[ ]*,[ ]*\\(\\(?:non_\\)?intrinsic\\)[ ]*::[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" (1 font-lock-keyword-face) (2 font-lock-keyword-face) (3 font-lock-function-name-face)) "\\_<\\(\\(end[ ]*\\)?block[ ]*data\\|contains\\)\\_>" '("\\_<abstract[ ]*interface\\_>" (0 font-lock-keyword-face t))) (#$ . 13055))
#@186 Search for the declaration of variables of derived type, up to LIMIT.
Set the match data so that subexpression 1,2 are the TYPE(...),
and variable-name parts, respectively.
(fn LIMIT)
(defalias 'f90-typedec-matcher #[257 "\300\211\301\302\303#\203N \3041F \305u\210\306 \210\307\224`D\262\310\300w\210\301\311\312!\203) \313\202* \314\315 \303#\205B \316\317@\320\225D\320\224\320\225D#!\210\3030\202H \210\300\211\262\203 \207" [nil re-search-forward "\\_<\\(type\\|class\\)[ ]*(" t (error) -1 forward-sexp 0 " " looking-at "\\(?:\\sw\\|\\s_\\)+" "\\([^&!\n]+\\)" "::[ ]*\\([^&!\n]+\\)" line-end-position set-match-data append 1] 9 (#$ . 14241)])
#@57 Highlights declarations, do-loops and other constructs.
(defvar f90-font-lock-keywords-2 (byte-code "\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\257\"\207" [f90-font-lock-keywords-1 append ("^[ 0-9]*\\(?:pure\\|elemental\\)?[ ]*\\(real\\|integer\\|c\\(haracter\\|omplex\\)\\|enumerator\\|generic\\|procedure\\|logical\\|double[ ]*precision\\)\\(.*::\\|[ ]*(.*)\\)?\\([^&!\n]*\\)" (1 font-lock-type-face t) (4 font-lock-variable-name-face t)) (f90-typedec-matcher (1 font-lock-type-face) (2 font-lock-variable-name-face)) ("\\_<\\(\\(real\\|integer\\|c\\(haracter\\|omplex\\)\\|logical\\|double[ ]*precision\\|\\(?:type\\|class\\)[ ]*([ ]*\\(?:\\sw\\|\\s_\\)+[ ]*)\\)[ ]*\\)\\(function\\)\\_>[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*\\(([^&!\n]*)\\)" (1 font-lock-type-face t) (4 font-lock-keyword-face t) (5 font-lock-function-name-face t) (6 'default t)) ("\\_<\\(enum\\)[ ]*," (1 font-lock-keyword-face)) ("\\_<\\(end[ ]*\\(do\\|if\\|enum\\|select\\|forall\\|where\\|block\\|critical\\)\\)\\_>\\([ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?" (1 font-lock-keyword-face) (3 font-lock-constant-face nil t)) ("^[ 0-9]*\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:[ ]*\\)?\\(\\(if\\|do\\([ ]*while\\)?\\|select[ ]*\\(?:case\\|type\\)\\|where\\|forall\\|block\\|critical\\)\\)\\_>" (2 font-lock-constant-face nil t) (3 font-lock-keyword-face)) ("\\_<\\(implicit\\)[ ]*\\(real\\|integer\\|c\\(haracter\\|omplex\\)\\|enumerator\\|procedure\\|logical\\|double[ ]*precision\\|type[ ]*(\\(?:\\sw\\|\\s_\\)+)\\|none\\)[ ]*" (1 font-lock-keyword-face) (2 font-lock-type-face)) ("\\_<\\(namelist\\|common\\)[ ]*/\\(\\(?:\\sw\\|\\s_\\)+\\)?/" (1 font-lock-keyword-face) (2 font-lock-constant-face nil t)) "\\_<else\\([ ]*if\\|where\\)?\\_>" ("\\(&\\)[ ]*\\(!\\|$\\)" (1 font-lock-keyword-face)) "\\_<\\(then\\|continue\\|format\\|include\\|\\(?:error[ ]+\\)?stop\\|return\\)\\_>" ("\\_<\\(exit\\|cycle\\)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)?\\_>" (1 font-lock-keyword-face) (2 font-lock-constant-face nil t)) ("\\_<\\(case\\)[ ]*\\(default\\|(\\)" . 1) ("\\_<\\(class\\)[ ]*default" . 1) ("\\_<\\(\\(type\\|class\\)[ ]*is\\)[ ]*(" (1 font-lock-keyword-face t)) ("\\_<\\(do\\|go[ ]*to\\)\\_>[ ]*\\([0-9]+\\)" (1 font-lock-keyword-face) (2 font-lock-constant-face)) ("^[ ]*\\([0-9]+\\)[ ]*[a-z]+" (1 font-lock-constant-face t)) ("^#[ ]*\\(?:\\sw\\|\\s_\\)+" (0 font-lock-preprocessor-face t) ("\\_<defined\\_>" nil nil (0 font-lock-preprocessor-face))) ("^#" ("\\(&&\\|||\\)" nil nil (0 font-lock-constant-face t))) ("^#[ ]*define[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)(" (1 font-lock-function-name-face)) ("^#[ ]*define[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" (1 font-lock-variable-name-face)) ("^#[ ]*include[ ]+\\(<.+>\\)" (1 font-lock-string-face))] 24) (#$ . 14906))
#@55 Highlights all F90 keywords and intrinsic procedures.
(defvar f90-font-lock-keywords-3 (byte-code "\304 \n \305D\306\307\257\"\207" [f90-font-lock-keywords-2 f90-keywords-level-3-re f90-operators-re f90-procedures-re append (1 font-lock-keyword-face keep) "\\_<real\\_>" ("\\_<\\(asynchronous\\)[ ]*[^=]" . 1)] 7) (#$ . 17711))
#@52 Highlights all F90 and HPF keywords and constants.
(defvar f90-font-lock-keywords-4 (byte-code "\303 \304B\nD\"\207" [f90-font-lock-keywords-3 f90-constants-re f90-hpf-keywords-re append font-lock-constant-face] 4) (#$ . 18048))
#@113 Default expressions to highlight in F90 mode.
Can be overridden by the value of `font-lock-maximum-decoration'.
(defvar f90-font-lock-keywords f90-font-lock-keywords-2 (#$ . 18285))
#@32 Syntax table used in F90 mode.
(defvar f90-mode-syntax-table (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\311#\210\301\313\307#\210\301\314\315#\210\301\316\317#\210\301\320\317#\210\301\321\317#\210\301\322\317#\210\301\323\317#\210\301\324\317#\210\301\325\326#\210\211\207" [make-syntax-table modify-syntax-entry 33 "<" 10 ">" 95 "_" 39 "\"" 34 96 13 " " 43 "." 45 61 42 47 37 92 "\\"] 5) (#$ . 18473))
#@26 Keymap used in F90 mode.
(defvar f90-mode-map (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\210\301\316\317#\210\301\320\321#\210\301\322\323#\210\301\324\325#\210\301\326\327#\210\301\330\331#\210\301\332\333#\210\301\334\335#\210\301\336\337#\210\301\340\341#\210\301\342\343#\210\301\344\343#\210\301\345\346#\210\301\347\346#\210\301\350\346#\210\301\351\346#\210\301\352\346#\210\353\354!\210\355\356\357\360\361\362\363!\364BB\365BB$\210\211\207" [make-sparse-keymap define-key "`" f90-abbrev-start ";" f90-comment-region "\201" f90-beginning-of-subprogram "\205" f90-end-of-subprogram "\210" f90-mark-subprogram "\216" f90-end-of-block "\220" f90-beginning-of-block "\221" f90-indent-subprogram "\n" f90-indent-new-line "
" f90-break-line "" f90-previous-block "" f90-next-block "" f90-join-lines "" f90-fill-region "" f90-previous-statement "" f90-next-statement "]" f90-insert-end "" "," f90-electric-insert "+" "-" "*" "/" (lambda (#1=#:def-tmp-var) (defvar f90-menu #1# #2="Menu for F90 mode.")) nil easy-menu-do-define f90-menu #2# "F90" "Customization" custom-menu-create f90 (["Set" Custom-set :active t :help "Set current value of all edited settings in the buffer"] ["Save" Custom-save :active t :help "Set and save all edited settings"] ["Reset to Current" Custom-reset-current :active t :help "Reset all edited settings to current"] ["Reset to Saved" Custom-reset-saved :active t :help "Reset all edited or set settings to saved"] ["Reset to Standard Settings" Custom-reset-standard :active t :help "Erase all customizations in buffer"]) ("--" ["Indent Subprogram" f90-indent-subprogram t] ["Mark Subprogram" f90-mark-subprogram :active t :help "Mark the end of the current subprogram, move point to the start"] ["Beginning of Subprogram" f90-beginning-of-subprogram :active t :help "Move point to the start of the current subprogram"] ["End of Subprogram" f90-end-of-subprogram :active t :help "Move point to the end of the current subprogram"] "--" ["(Un)Comment Region" f90-comment-region :active mark-active :help "Comment or uncomment the region"] ["Indent Region" f90-indent-region :active mark-active] ["Fill Region" f90-fill-region :active mark-active :help "Fill long lines in the region"] ["Fill Statement/Comment" fill-paragraph :active t] "--" ["Break Line at Point" f90-break-line :active t :help "Break the current line at point"] ["Join with Previous Line" f90-join-lines :active t :help "Join the current line to the previous one"] ["Insert Block End" f90-insert-end :active t :help "Insert an end statement for the current code block"] "--" ("Highlighting" :help "Fontify this buffer to varying degrees" ["Toggle font-lock-mode" font-lock-mode :selected font-lock-mode :style toggle :help "Fontify text in this buffer"] "--" ["Light highlighting (level 1)" f90-font-lock-1 t] ["Moderate highlighting (level 2)" f90-font-lock-2 t] ["Heavy highlighting (level 3)" f90-font-lock-3 t] ["Maximum highlighting (level 4)" f90-font-lock-4 t]) ("Change Keyword Case" :help "Change the case of keywords in the buffer or region" ["Upcase Keywords (buffer)" f90-upcase-keywords t] ["Capitalize Keywords (buffer)" f90-capitalize-keywords t] ["Downcase Keywords (buffer)" f90-downcase-keywords t] "--" ["Upcase Keywords (region)" f90-upcase-region-keywords mark-active] ["Capitalize Keywords (region)" f90-capitalize-region-keywords mark-active] ["Downcase Keywords (region)" f90-downcase-region-keywords mark-active]) "--" ["Toggle Auto Fill" auto-fill-mode :selected auto-fill-function :style toggle :help "Automatically fill text while typing in this buffer"] ["Toggle Abbrev Mode" abbrev-mode :selected abbrev-mode :style toggle :help "Expand abbreviations while typing in this buffer"] ["Add Imenu Menu" f90-add-imenu-menu :active (not (lookup-key (current-local-map) [menu-bar index])) :included (fboundp 'imenu-add-to-menubar) :help "Add an index menu to the menu-bar"])] 9) (#$ . 18948))
#@59 Set `font-lock-keywords' to F90 level N keywords.
(fn N)
(defalias 'f90-font-lock-n #[257 "\301\302!\210\303\304\305\"!J\306 \207" [font-lock-keywords font-lock-mode 1 intern-soft format "f90-font-lock-keywords-%d" font-lock-flush] 5 (#$ . 22982)])
#@57 Set `font-lock-keywords' to `f90-font-lock-keywords-1'.
(defalias 'f90-font-lock-1 #[0 "\300\301!\207" [f90-font-lock-n 1] 2 (#$ . 23240) nil])
#@57 Set `font-lock-keywords' to `f90-font-lock-keywords-2'.
(defalias 'f90-font-lock-2 #[0 "\300\301!\207" [f90-font-lock-n 2] 2 (#$ . 23390) nil])
#@57 Set `font-lock-keywords' to `f90-font-lock-keywords-3'.
(defalias 'f90-font-lock-3 #[0 "\300\301!\207" [f90-font-lock-n 3] 2 (#$ . 23540) nil])
#@57 Set `font-lock-keywords' to `f90-font-lock-keywords-4'.
(defalias 'f90-font-lock-4 #[0 "\300\301!\207" [f90-font-lock-n 4] 2 (#$ . 23690) nil])
#@54 Regexp potentially indicating a "block" of F90 code.
(defconst f90-blocks-re "\\(\\(?:block[ ]*data\\|\\(?:associate\\|block\\|critical\\|do\\|enum\\|f\\(?:orall\\|unction\\)\\|i\\(?:f\\|nterface\\)\\|module\\|program\\|s\\(?:elect\\|ub\\(?:\\(?:modul\\|routin\\)e\\)\\)\\|\\(?:typ\\|wher\\)e\\)\\)\\_>\\)" (#$ . 23840))
#@56 Regexp used to locate the start/end of a "subprogram".
(defconst f90-program-block-re "\\(function\\|module\\|program\\|sub\\(?:\\(?:modul\\|routin\\)e\\)\\)" (#$ . 24168))
#@71 Regexp matching an ELSE IF, ELSEWHERE, CASE, CLASS/TYPE IS statement.
(defconst f90-else-like-re "\\(else\\([ ]*if\\|where\\)?\\|case[ ]*\\(default\\|(\\)\\|\\(class\\|type\\)[ ]*is[ ]*(\\|class[ ]*default\\)" (#$ . 24347))
#@64 Regexp matching the end of an IF, SELECT, WHERE, FORALL block.
(defconst f90-end-if-re "end[ ]*\\(forall\\|if\\|select\\|where\\)\\_>" (#$ . 24582))
#@73 Regexp matching the end of a TYPE, ENUM, INTERFACE, BLOCK DATA section.
(defconst f90-end-type-re "end[ ]*\\(type\\|enum\\|interface\\|block[ ]*data\\)\\_>" (#$ . 24738))
#@48 Regexp matching the end of an ASSOCIATE block.
(defconst f90-end-associate-re "end[ ]*associate\\_>" (#$ . 24917))
#@51 Regexp matching the definition of a derived type.
(defconst f90-type-def-re "\\_<\\(type\\)\\_>\\(?:\\(?:[^()\n]*\\|.*,[ ]*\\(?:bind\\|extends\\)[ ]*(.*).*\\)::\\)?[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" (#$ . 25039))
#@44 Regexp matching a CLASS/TYPE IS statement.
(defconst f90-typeis-re "\\_<\\(class\\|type\\)[ ]*is[ ]*(" (#$ . 25258))
#@405 Regexp specifying two-character tokens not to split when breaking lines.
Each token has one or more of the characters from `f90-break-delimiters'.
Note that if only one of the characters is from that variable,
then the presence of the token here allows a line-break before or
after the other character, where a break would not normally be
allowed. This minor issue currently only affects "(/" and "/)".
(defconst f90-no-break-re "\\((/\\|\\*\\*\\|/[)/=]\\|<=\\|=[=>]\\|>=\\)" (#$ . 25384))
#@56 Temporary position used to speed up region operations.
(defvar f90-cache-position nil (#$ . 25881))
(make-variable-buffer-local 'f90-cache-position)
#@116 Regexp matching the end of an F90 "block", from the line start.
Used in the F90 entry in `hs-special-modes-alist'.
(defconst f90-end-block-re "^[ 0-9]*\\_<end[ ]*\\(associate\\|block\\|critical\\|do\\|enum\\|f\\(?:orall\\|unction\\)\\|i\\(?:f\\|nterface\\)\\|module\\|program\\|s\\(?:elect\\|ub\\(?:\\(?:modul\\|routin\\)e\\)\\)\\|\\(?:typ\\|wher\\)e\\)\\_>" (#$ . 26037))
#@248 Regexp matching the start of an F90 "block", from the line start.
A simple regexp cannot do this in fully correct fashion, so this
tries to strike a compromise between complexity and flexibility.
Used in the F90 entry in `hs-special-modes-alist'.
(defconst f90-start-block-re "^[ 0-9]*\\(\\(\\(\\(?:\\sw\\|\\s_\\)+[ ]*:[ ]*\\)?\\(do\\|select[ ]*\\(case\\|type\\)\\|if[ ]*(\\(.*\\|.*\n\\([^if]*\\([^i].\\|.[^f]\\|.\\_>\\)\\)\\)\\_<then\\|\\(where\\|forall\\)[ ]*(.*)[ ]*\\(!\\|$\\)\\)\\)\\|\\(?:type\\|class\\)[ ,]\\([^id(!\n\"& ]\\|i[^s!\n\"& ]\\|d[^e!\n\"& ]\\|de[^f!\n\"& ]\\|def[^a!\n\"& ]\\|\\(?:is\\|default\\)\\(?:\\sw\\|\\s_\\)\\)\\|program\\|\\(?:abstract[ ]*\\)?interface\\|\\(?:sub\\)?module\\|function\\|subroutine\\|enum[^e]\\|associate\\|block\\|critical\\)[ ]*" (#$ . 26419))
(byte-code "\302\303\304 \305BBB\"\207" [f90-start-block-re f90-end-block-re add-to-list hs-special-modes-alist f90-mode ("!" f90-end-of-block nil)] 6)
#@113 Search backward for the start of a derived type.
Set subexpression 1 in the match-data to the name of the type.
(defalias 'f90-imenu-type-matcher #[0 "\300\301\302\300\303#\203( \212\304\225b\210\305\306!?\205! \305\307!\206! \310\311\312 \303#)\211\262\203 \211\207" [nil re-search-backward "^[ 0-9]*type[ ]*" t 0 looking-at "\\(is\\_>\\|(\\)" "\\(\\(?:\\sw\\|\\s_\\)+\\)" re-search-forward "[ ]*::[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" line-end-position] 5 (#$ . 27384)])
#@51 Value for `imenu-generic-expression' in F90 mode.
(defvar f90-imenu-generic-expression (byte-code "\300\301\302\303\304\305\306\307\310\311\n\211\312
\f\312\211\313\314\315\260\316BB\257\207" ["[^!\"&\n ]" "[^e!\n\"& ]" "[^n!\n\"& ]" "[^d!\n\"& ]" (nil "^[ 0-9]*program[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" 1) ("Submodules" "^[ 0-9]*submodule[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*\\(!\\|$\\)" 1) ("Modules" "^[ 0-9]*module[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*\\(!\\|$\\)" 1) ("Types" f90-imenu-type-matcher 1) "Procedures" "^[ 0-9]*\\([^!\"&\n]*\\(" "\\|" "\\)\\|" "?" "?\\)[ ]*\\(function\\|subroutine\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" (4)] 26) (#$ . 27863))
#@35 Add an imenu menu to the menubar.
(defalias 'f90-add-imenu-menu #[0 "\300\301 \302\"\203
\303\304\305\"\207\306\307!\210\310 \207" [lookup-key current-local-map [menu-bar index] message "%s" "F90-imenu already exists." imenu-add-to-menubar "F90-imenu" redraw-frame] 3 (#$ . 28562) nil])
(byte-code "\300\301\302\303\304\"\305\306\307%\207" [define-abbrev-table f90-mode-abbrev-table mapcar #[257 "\211@A\300\301\302\257\207" [nil :system t] 6 "\n\n(fn E)"] (("`al" . "allocate") ("`ab" . "allocatable") ("`ai" . "abstract interface") ("`as" . "assignment") ("`asy" . "asynchronous") ("`ba" . "backspace") ("`bd" . "block data") ("`bl" . "block") ("`c" . "character") ("`cl" . "close") ("`cm" . "common") ("`cx" . "complex") ("`cn" . "contains") ("`cr" . "critical") ("`cy" . "cycle") ("`de" . "deallocate") ("`df" . "define") ("`di" . "dimension") ("`dp" . "double precision") ("`dw" . "do while") ("`el" . "else") ("`eli" . "else if") ("`elw" . "elsewhere") ("`em" . "elemental") ("`e" . "enumerator") ("`eq" . "equivalence") ("`ex" . "external") ("`ey" . "entry") ("`fl" . "forall") ("`fo" . "format") ("`fu" . "function") ("`fa" . ".false.") ("`im" . "implicit none") ("`in" . "include") ("`i" . "integer") ("`it" . "intent") ("`if" . "interface") ("`lo" . "logical") ("`mo" . "module") ("`na" . "namelist") ("`nu" . "nullify") ("`op" . "optional") ("`pa" . "parameter") ("`po" . "pointer") ("`pr" . "print") ("`pi" . "private") ("`pm" . "program") ("`pr" . "protected") ("`pu" . "public") ("`r" . "real") ("`rc" . "recursive") ("`rt" . "return") ("`rw" . "rewind") ("`se" . "select") ("`sq" . "sequence") ("`su" . "subroutine") ("`ta" . "target") ("`tr" . ".true.") ("`t" . "type") ("`vo" . "volatile") ("`wh" . "where") ("`wr" . "write")) "Abbrev table for F90 mode." :regexp "\\(?:[^[:word:]_`]\\|^\\)\\(`?[[:word:]_]+\\)[^[:word:]_]*"] 6)
(defvar f90-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [f90-mode-hook variable-documentation put "Hook run after entering F90 mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp f90-mode-map definition-name f90-mode] 4)
(defvar f90-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\311\312 !\210\306\301N\204- \302\306\301\303\313!#\210\302\310\314\315#\210\302\310\316\317#\207" [f90-mode-map variable-documentation put purecopy "Keymap for `f90-mode'." boundp f90-mode-syntax-table definition-name f90-mode (lambda (#1=#:def-tmp-var) (defvar f90-mode-syntax-table #1#)) make-syntax-table "Syntax table for `f90-mode'." derived-mode-parent prog-mode custom-mode-group f90] 5)
#@2314 Major mode for editing Fortran 90,95 code in free format.
For fixed format code, use `fortran-mode'.
\[f90-indent-line] indents the current line.
\[f90-indent-new-line] indents current line and creates a new indented line.
\[f90-indent-subprogram] indents the current subprogram.
Type \=`? or \=`\[help-command] to display a list of built-in abbrevs for F90 keywords.
Key definitions:
\{f90-mode-map}
Variables controlling indentation style and extra features:
`f90-do-indent'
Extra indentation within do blocks (default 3).
`f90-if-indent'
Extra indentation within if/select/where/forall blocks (default 3).
`f90-type-indent'
Extra indentation within type/enum/interface/block-data blocks (default 3).
`f90-program-indent'
Extra indentation within program/module/subroutine/function blocks
(default 2).
`f90-associate-indent'
Extra indentation within associate blocks (default 2).
`f90-critical-indent'
Extra indentation within critical/block blocks (default 2).
`f90-continuation-indent'
Extra indentation applied to continuation lines (default 5).
`f90-comment-region'
String inserted by function \[f90-comment-region] at start of each
line in region (default "!!!$").
`f90-indented-comment-re'
Regexp determining the type of comment to be intended like code
(default "!").
`f90-directive-comment-re'
Regexp of comment-like directive like "!HPF\\$", not to be indented
(default "!hpf\\$").
`f90-break-delimiters'
Regexp holding list of delimiters at which lines may be broken
(default "[-+*/><=,% \t]").
`f90-break-before-delimiters'
Non-nil causes `f90-do-auto-fill' to break lines before delimiters
(default t).
`f90-beginning-ampersand'
Automatic insertion of `&' at beginning of continuation lines (default t).
`f90-smart-end'
From an END statement, check and fill the end using matching block start.
Allowed values are `blink', `no-blink', and nil, which determine
whether to blink the matching beginning (default `blink').
`f90-auto-keyword-case'
Automatic change of case of keywords (default nil).
The possibilities are `downcase-word', `upcase-word', `capitalize-word'.
`f90-leave-line-no'
Do not left-justify line numbers (default nil).
Turning on F90 mode calls the value of the variable `f90-mode-hook'
with no args, if that value is non-nil.
(defalias 'f90-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203 \314\311\313\310\313N#\210\315 !\204' \316 \317 \"\210\320\f!\211\2035 \211\321 =\203; \322\f\323 \"\210\210\324 !\210\325\f!\210
2\306\326!\210\327\306\330!\210\331\306\332!\210\333\306\334!\210\335 \306\336!\210\337 \306\340!\210\307 \306\341!\210\342!\3433\306\344!\210\345$\306\346!\210\347&\306\350!\210\307(\306\351!\2104)\306\352!\210\353*\306\354!\210\355,\306\356!\210\357.)\360\361!\207" [delay-mode-hooks major-mode mode-name f90-mode-map f90-mode-syntax-table f90-mode-abbrev-table make-local-variable t prog-mode f90-mode "F90" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table use-local-map set-syntax-table indent-line-function f90-indent-line indent-region-function f90-indent-region comment-start "!" comment-start-skip "!+ *" comment-indent-function f90-comment-indent abbrev-all-caps normal-auto-fill-function f90-do-auto-fill nil fill-paragraph-function f90-fill-paragraph font-lock-defaults ((f90-font-lock-keywords f90-font-lock-keywords-1 f90-font-lock-keywords-2 f90-font-lock-keywords-3 f90-font-lock-keywords-4) nil t) imenu-case-fold-search imenu-generic-expression beginning-of-defun-function f90-beginning-of-subprogram end-of-defun-function f90-end-of-subprogram add-log-current-defun-function f90-current-defun run-mode-hooks f90-mode-hook local-abbrev-table indent-tabs-mode f90-imenu-generic-expression] 5 (#$ . 31323) nil])
#@137 Return non-nil if point is inside a string.
Checks from `point-min', or `f90-cache-position', if that is non-nil
and lies before point.
(defalias 'f90-in-string #[0 "\203 `V\203 \202 e\301\302`\"8\207" [f90-cache-position 3 parse-partial-sexp] 5 (#$ . 35188)])
(put 'f90-in-string 'byte-optimizer 'byte-compile-inline-expand)
#@138 Return non-nil if point is inside a comment.
Checks from `point-min', or `f90-cache-position', if that is non-nil
and lies before point.
(defalias 'f90-in-comment #[0 "\203 `V\203 \202 e\301\302`\"8\207" [f90-cache-position 4 parse-partial-sexp] 5 (#$ . 35528)])
(put 'f90-in-comment 'byte-optimizer 'byte-compile-inline-expand)
#@171 Return t if the current line is a continued one.
This includes comment or preprocessor lines embedded in continued lines,
but not the last line of a continued statement.
(defalias 'f90-line-continued #[0 "\212\301 \210\302\303!\203 \304y\305U\204 \306\210\203\" `V\203\" \202# e\307\310`\"8\262\203; \311\312\313 \"\210\312\306x\210\202 \314\306x\210h\315U)\207" [f90-cache-position beginning-of-line looking-at "[ ]*\\([!#]\\|$\\)" -1 0 nil 4 parse-partial-sexp search-backward "!" line-beginning-position " " 38] 5 (#$ . 35871)])
(put 'f90-line-continued 'byte-optimizer 'byte-compile-inline-expand)
#@88 Return indentation of current line.
Line-numbers are considered whitespace characters.
(defalias 'f90-current-indentation #[0 "\212\300 \210\301\302w)\207" [beginning-of-line " 0-9" nil] 2 (#$ . 36490)])
(put 'f90-current-indentation 'byte-optimizer 'byte-compile-inline-expand)
#@166 Indent current line to column COL.
If optional argument NO-LINE-NUMBER is nil, jump over a possible
line-number before indenting.
(fn COL &optional NO-LINE-NUMBER)
(defalias 'f90-indent-to #[513 "\300 \210\211\204 \301\302w\210\303 \210\304i\305U\203 \305\202 \306\"\207" [beginning-of-line " 0-9" nil delete-horizontal-space indent-to 0 1] 6 (#$ . 36777)])
(put 'f90-indent-to 'byte-optimizer 'byte-compile-inline-expand)
#@157 If point lies within a comment, return the string starting the comment.
For example, "!" or "!!", followed by the appropriate amount of
whitespace, if any.
(defalias 'f90-get-present-comment-type #[0 "\212\203 `V\203 \202 e\301\302`\"8\262\205J \303 \210\304\305\306 \"\210\2032 `V\2032 \2023 e\307\302`\"8\262\203G \304\305\306 \"\210\202$ \310\311!)\207" [f90-cache-position 4 parse-partial-sexp beginning-of-line re-search-forward "!+[ ]*" line-end-position 3 match-string-no-properties 0] 5 (#$ . 37213)])
(put 'f90-get-present-comment-type 'byte-optimizer 'byte-compile-inline-expand)
#@79 Compare strings A and B neglecting case and allowing for nil value.
(fn A B)
(defalias 'f90-equal-symbols #[514 "\205 \227\205\f \227\232\207" [] 4 (#$ . 37823)])
(put 'f90-equal-symbols 'byte-optimizer 'byte-compile-inline-expand)
#@101 Return ("do" NAME) if a do statement starts after point.
NAME is nil if the statement has no label.
(defalias 'f90-looking-at-do #[0 "\300\301!\205
\302\303!\302\304!D\207" [looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(do\\)\\_>" match-string 3 2] 3 (#$ . 38068)])
(put 'f90-looking-at-do 'byte-optimizer 'byte-compile-inline-expand)
#@109 Return ("select" NAME) if a select statement starts after point.
NAME is nil if the statement has no label.
(defalias 'f90-looking-at-select-case #[0 "\300\301!\205
\302\303!\302\304!D\207" [looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(select\\)[ ]*\\(case\\|type\\)[ ]*(" match-string 3 2] 3 (#$ . 38424)])
(put 'f90-looking-at-select-case 'byte-optimizer 'byte-compile-inline-expand)
#@110 Return ("if" NAME) if an if () then statement starts after point.
NAME is nil if the statement has no label.
(defalias 'f90-looking-at-if-then #[0 "\212\301\302!\205{ \303\304!\303\305!\306`\307\310#\211\203 \211b\210\311\312w\210\301\313!\204v \212\314 \210\301\315!\2034 \316y\310U\204' \312\210\203E `V\203E \202F e\317\320`\"8\262\203^ \321\322\323 \"\210\322\312x\210\2027 \311\312x\210h\324U)\205y \325 \210\326\312w\210\301\313!\205y D\266\203)\207" [f90-cache-position looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(if\\)\\_>" match-string 3 2 scan-lists 1 0 " " nil "then\\_>" beginning-of-line "[ ]*\\([!#]\\|$\\)" -1 4 parse-partial-sexp search-backward "!" line-beginning-position 38 f90-next-statement " 0-9&"] 8 (#$ . 38834)])
(put 'f90-looking-at-if-then 'byte-optimizer 'byte-compile-inline-expand)
#@64 Return ("associate") if an associate block starts after point.
(defalias 'f90-looking-at-associate #[0 "\300\301!\205\n \302\303!C\207" [looking-at "\\_<\\(associate\\)[ ]*(" match-string 1] 2 (#$ . 39679)])
(put 'f90-looking-at-associate 'byte-optimizer 'byte-compile-inline-expand)
#@69 Return (KIND NAME) if a critical or block block starts after point.
(defalias 'f90-looking-at-critical #[0 "\300\301!\205$ \302\303!\302\304!\305\230\203 \212\306\307w\210\300\310!)?\205\" D\266\202\207" [looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(critical\\|block\\)\\_>" match-string 3 2 "block" " " nil "data\\_>"] 4 (#$ . 39970)])
(put 'f90-looking-at-critical 'byte-optimizer 'byte-compile-inline-expand)
#@63 Return non-nil if a critical or block block ends after point.
(defalias 'f90-looking-at-end-critical #[0 "\300\301!\205 \302\303!\304\230?\206 \212\305\306w\210\300\307!)?\207" [looking-at "end[ ]*\\(critical\\|block\\)\\_>" match-string 1 "block" " " nil "data\\_>"] 2 (#$ . 40407)])
(put 'f90-looking-at-end-critical 'byte-optimizer 'byte-compile-inline-expand)
#@110 Return (KIND NAME) if a where or forall block starts after point.
NAME is nil if the statement has no label.
(defalias 'f90-looking-at-where-or-forall #[0 "\212\300\301!\205( \302\303!\302\304!\305`\306\307#\211\203 \211b\210\310\311w\210\300\312!\205& D\266\203)\207" [looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(where\\|forall\\)\\_>" match-string 3 2 scan-lists 1 0 " " nil "\\(!\\|$\\)"] 6 (#$ . 40782)])
(put 'f90-looking-at-where-or-forall 'byte-optimizer 'byte-compile-inline-expand)
#@130 Return (KIND NAME) if a type/enum/interface/block-data starts after point.
NAME is non-nil only for type and certain interfaces.
(defalias 'f90-looking-at-type-like #[0 "\212\300\301!\205 \302\225b\205 \300\303!?\205 \300\304!\206 \305\306\307 \310#)\203* \311\312\313!D\207\300\314!\203J \312\313!\212\302\225b\210\300\315!\204D \300\316!\205G \312\302!)D\207\300\317!\203V \312\313!\320D\207\300\321!\205a \312\313!\320D\207" [looking-at "\\_<type\\_>[ ]*" 0 "\\(is\\_>\\|(\\)" "\\(\\(?:\\sw\\|\\s_\\)+\\)" re-search-forward "[ ]*::[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" line-end-position t "type" match-string 1 "\\_<\\(interface\\)\\_>[ ]*" "\\(operator\\|assignment\\|read\\|write\\)[ ]*([^)\n]*)" "\\(?:\\sw\\|\\s_\\)+" "\\(enum\\|block[ ]*data\\)\\_>" nil "abstract[ ]*\\(interface\\)\\_>"] 4 (#$ . 41299)])
(put 'f90-looking-at-type-like 'byte-optimizer 'byte-compile-inline-expand)
#@74 Return (KIND NAME) if a program block with name NAME starts after point.
(defalias 'f90-looking-at-program-block-start #[0 "\300\301!\203 \302\303!\302\304!D\207\300\305!\204\" \300\306!\203\" \302\303!\302\304!D\207\300\307!\2030 \302\303!\302\304!D\207\300\310!?\205D \300\311!\205D \302\303!\302\304!D\207" [looking-at "\\(program\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" match-string 1 2 "module[ ]*\\(procedure\\|function\\|subroutine\\)\\_>" "\\(module\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "\\(submodule\\)[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "end[ ]*\\(function\\|procedure\\|subroutine\\)" "[^!'\"&\n]*\\(?:module[ ]*\\)?\\(function\\|subroutine\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)"] 3 (#$ . 42200)])
(put 'f90-looking-at-program-block-start 'byte-optimizer 'byte-compile-inline-expand)
#@64 Return (KIND NAME) if a block with name NAME ends after point.
(defalias 'f90-looking-at-program-block-end #[0 "\301\302!\203 \303\304!\303\305!D\207\301\306\307Q!\205 \303\304!\303\310!D\207" [f90-blocks-re looking-at "end[ ]*\\(interface\\)[ ]*\\(\\(?:assignment\\|operator\\|read\\|write\\)[ ]*([^)\n]*)\\)" match-string 1 2 "end[ ]*" "?\\([ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?\\_>" 3] 4 (#$ . 43017)])
(put 'f90-looking-at-program-block-end 'byte-optimizer 'byte-compile-inline-expand)
#@345 Return the indentation to be used for a comment starting at point.
Used for `comment-indent-function' by F90 mode.
"!!!", `f90-directive-comment-re', variable `f90-comment-region' return 0.
`f90-indented-comment-re' (if not trailing code) calls `f90-calculate-indent'.
All others return `comment-column', leaving at least one space after code.
(defalias 'f90-comment-indent #[0 "\304\305!\203 \306\207\203 \304!\203 \306\207\304\307 !!\203 \306\207\304\n!\2031 \212\310\311x\210n)\2031 \312 \207\212\310\311x\210n\203> \306\202@ iT ])\207" [f90-directive-comment-re f90-comment-region f90-indented-comment-re comment-column looking-at "!!!" 0 regexp-quote " " nil f90-calculate-indent] 3 (#$ . 43519)])
(put 'f90-comment-indent 'byte-optimizer 'byte-compile-inline-expand)
#@377 Return continuation properties of present statement.
Possible return values are:
single - statement is not continued.
begin - current line is the first in a continued statement.
end - current line is the last in a continued statement
middle - current line is neither first nor last in a continued statement.
Comment lines embedded amongst continued lines return `middle'.
(defalias 'f90-present-statement-cont #[0 "\301\211\212\302 \205K \212\303 \210\304\305!\203 \306y\307U\204\f \301\210\203* `V\203* \202+ e\310\311`\"8\262\203C \312\313\314 \"\210\313\301x\210\202 \315\301x\210h\316U)\262)\212\303 \210\304\305!\203_ \306y\307U\204R \301\210\203p `V\203p \202q e\310\311`\"8\262\203\211 \312\313\314 \"\210\313\301x\210\202b \315\301x\210h\316U)\262\204\237 \211\204\237 \317\202\306 \204\253 \211\203\253 \320\202\306 \203\267 \211\204\267 \321\202\306 \203\303 \211\203\303 \322\202\306 \323\324!\207" [f90-cache-position nil f90-previous-statement beginning-of-line looking-at "[ ]*\\([!#]\\|$\\)" -1 0 4 parse-partial-sexp search-backward "!" line-beginning-position " " 38 single begin end middle error "The impossible occurred"] 7 (#$ . 44306)])
(put 'f90-present-statement-cont 'byte-optimizer 'byte-compile-inline-expand)
#@158 If `f90-leave-line-no' is nil, left-justify a line number.
Leaves point at the first non-blank character after the line number.
Call from beginning of line.
(defalias 'f90-indent-line-no #[0 "\204
\301\302!\203
\303 \210\304\305w\207" [f90-leave-line-no looking-at "[ ]+[0-9]" delete-horizontal-space " 0-9" nil] 2 (#$ . 45575)])
(put 'f90-indent-line-no 'byte-optimizer 'byte-compile-inline-expand)
#@126 Return nil if point is at the edge of a code block.
Searches line forward for "function" or "subroutine",
if all else fails.
(defalias 'f90-no-block-limit #[0 "\212\301\302!\206% \301\303!\206% \301\304!\206% \301\305!\206% \301!\206% \306\307\310 \311#)?\207" [f90-type-def-re looking-at "end" "\\(do\\|if\\|else\\(if\\|where\\)?\\|select[ ]*\\(case\\|type\\)\\|case\\|where\\|forall\\|\\(?:class\\|type\\)[ ]*is\\|class[ ]*default\\|block\\|critical\\|enum\\|associate\\)\\_>" "\\(program\\|\\(?:sub\\)?module\\|\\(?:abstract[ ]*\\)?interface\\|block[ ]*data\\)\\_>" "\\(contains\\|\\(?:\\sw\\|\\s_\\)+[ ]*:\\)" re-search-forward "\\(function\\|subroutine\\)" line-end-position t] 4 (#$ . 45987)])
(put 'f90-no-block-limit 'byte-optimizer 'byte-compile-inline-expand)
#@61 Change case of current line as per `f90-auto-keyword-case'.
(defalias 'f90-update-line #[0 "\205 \301\302 \303 #\207" [f90-auto-keyword-case f90-change-keywords line-beginning-position line-end-position] 4 (#$ . 46770)])
(put 'f90-update-line 'byte-optimizer 'byte-compile-inline-expand)
#@87 Change keyword case and auto-fill line as operators are inserted.
(fn &optional ARG)
(defalias 'f90-electric-insert #[256 "\302!\210\203 \303 \207 \205 \304 \305 \306 #\207" [auto-fill-function f90-auto-keyword-case self-insert-command f90-do-auto-fill f90-change-keywords line-beginning-position line-end-position] 5 (#$ . 47067) "*p"])
(put 'f90-electric-insert 'delete-selection t)
#@106 Get correct indent for a line starting with line number.
Does not check type and subprogram indentation.
(defalias 'f90-get-correct-indent #[0 "\306 \307\212\310 \203\334 \307\211\212\310 \205T \212\311 \210\312\313!\203\" \314y\315U\204 \307\210\2033 `V\2033 \2024 e\316\317`\"8\262\203L \320\321\322 \"\210\321\307x\210\202% \323\307x\210h\324U)\262)\212\311 \210\312\313!\203h \314y\315U\204[ \307\210\203y `V\203y \202z e\316\317`\"8\262\203\222 \320\321\322 \"\210\321\307x\210\202k \323\307x\210h\324U)\262\204\250 \211\204\250 \325\202\317 \204\264 \211\203\264 \326\202\317 \203\300 \211\204\300 \327\202\317 \203\314 \211\203\314 \330\202\317 \331\332!\266\202\333>\204 \312\334!\204 \335 \262\311 \210\336\337\306 \340#\203\343\311 \210\323\307w\210\312\341!\203 \342\343!\342\344!D\203 \211 \\\262\202\340\212\312\345!\205\206\342\343!\342\344!\346`\347\315#\211\203$\211b\210\323\307w\210\312\350!\204\201\212\311 \210\312\313!\203?\314y\315U\2042\307\210\203P`V\203P\202Qe\316\317`\"8\262\203i\320\321\322 \"\210\321\307x\210\202B\323\307x\210h\324U)\205\204\351 \210\352\307w\210\312\350!\205\204D\266\203)\204\306\212\312\353!\205\262\342\343!\342\344!\346`\347\315#\211\203\243\211b\210\323\307w\210\312\354!\205\260D\266\203)\204\306\312\355!\203\316\342\343!\342\344!D\203\316\211\n\\\262\202\340\312\356!\203\340\342\347!C\203\340\211 \\\262\307\210\336\337\340#\2032\311 \210\357\307w\210\312\341!\203\n\342\343!\342\344!D\203\n\211 \\\262\202,\212\312\345!\205\205\342\343!\342\344!\346`\347\315#\211\203#\211b\210\323\307w\210\312\350!\204\200\212\311 \210\312\313!\203>\314y\315U\2041\307\210\203O`V\203O\202Pe\316\317`\"8\262\203h\320\321\322 \"\210\321\307x\210\202A\323\307x\210h\324U)\205\203\351 \210\352\307w\210\312\350!\205\203D\266\203)\204\305\212\312\353!\205\261\342\343!\342\344!\346`\347\315#\211\203\242\211b\210\323\307w\210\312\354!\205\257D\266\203)\204\305\312\355!\203\315\342\343!\342\344!D\203\315\211\n\\\262\202,\312\356!\203\342\342\347!C\203\342\211 \\\262\202,\312\f!\203\360\211\nZ\262\202,\312
!\203\376\211 Z\262\202,\312\360!\203!\342\347!\361\230\203\212\323\307w\210\312\362!)\204!\2114Z\262\202,\312\363!\203,\211 Z\262\307\210\202\343)\207" [f90-cache-position f90-do-indent f90-if-indent f90-associate-indent f90-end-if-re f90-end-associate-re line-end-position nil f90-previous-statement beginning-of-line looking-at "[ ]*\\([!#]\\|$\\)" -1 0 4 parse-partial-sexp search-backward "!" line-beginning-position " " 38 single begin end middle error "The impossible occurred" (middle end) "[ ]*[0-9]" current-indentation re-search-forward "\\(if\\|do\\|select\\|where\\|forall\\)" t "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(do\\)\\_>" match-string 3 2 "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(if\\)\\_>" scan-lists 1 "then\\_>" f90-next-statement " 0-9&" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(where\\|forall\\)\\_>" "\\(!\\|$\\)" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(select\\)[ ]*\\(case\\|type\\)[ ]*(" "\\_<\\(associate\\)[ ]*(" " 0-9" "end[ ]*\\(critical\\|block\\)\\_>" "block" "data\\_>" "end[ ]*do\\_>" f90-critical-indent] 10 (#$ . 47464)])
#@59 Calculate the indent column based on previous statements.
(defalias 'f90-calculate-indent #[0 "\306\211\307`\212\310 \204} \212\211b\210\311 \210\312\313!)\204s \312\314!\203# \315 \210\316\306w\210\312\317!\2037 \320\321!\320\322!D\202p \312\323!\204M \312\324!\203M \320\321!\320\322!D\202p \312\325!\203] \320\321!\320\322!D\202p \312\326!\204w \312\327!\203w \320\321!\320\322!D\203w \330\202x \262\202\306\211\212\310 \205\310 \212\311 \210\312\314!\203\226 \331y\330U\204\211 \306\210\n\203\247 `\nV\203\247 \n\202\250 e\332\333`\"8\262\203\300 \334\335\336 \"\210\335\306x\210\202\231 \337\306x\210h\340U)\262)\212\311 \210\312\314!\203\334 \331y\330U\204\317 \306\210\n\203\355 `\nV\203\355 \n\202\356 e\332\333`\"8\262\203\334\335\336 \"\210\335\306x\210\202\337 \337\306x\210h\340U)\262\204 \211\204 \341\202C\204(\211\203(\342\202C\2034\211\2044\343\202C\203@\211\203@\344\202C\345\346!\266\202\262\343=\203 \306\211\212\310 \205\230\212\311 \210\312\314!\203f\331y\330U\204Y\306\210\n\203w`\nV\203w\n\202xe\332\333`\"8\262\203\220\334\335\336 \"\210\335\306x\210\202i\337\306x\210h\340U)\262)\212\311 \210\312\314!\203\254\331y\330U\204\237\306\210\n\203\275`\nV\203\275\n\202\276e\332\333`\"8\262\203\326\334\335\336 \"\210\335\306x\210\202\257\337\306x\210h\340U)\262\204\354\211\204\354\341\202\204\370\211\203\370\342\202\203\211\204\343\202\203\211\203\344\202\345\346!\266\202\342=\204 \310 \210\202M\347\267\202<\212\311 \210\316\306w) \\\262\202\350 \262\202\212\311 \210\316\306w)\262\337\306w\210\312\351!\203W\352 \262\202S\212\312\353!\205\322\320\354!\320\322!\355`\321\330#\211\203p\211b\210\337\306w\210\312\356!\204\315\212\311 \210\312\314!\203\213\331y\330U\204~\306\210\n\203\234`\nV\203\234\n\202\235e\332\333`\"8\262\203\265\334\335\336 \"\210\335\306x\210\202\216\337\306x\210h\340U)\205\320\315 \210\357\306w\210\312\356!\205\320D\266\203)\204\212\312\360!\205\376\320\354!\320\322!\355`\321\330#\211\203\357\211b\210\337\306w\210\312\361!\205\374D\266\203)\204\312\362!\203\320\354!\320\322!D\204\312\f!\203
\\\262\202S\312\363!\2039\320\354!\320\322!D\2039@\\\262\202S\212\312\364!\205Y\330\225b\205Y\312\365!?\205Y\312\366!\206Y\367\370\371 \307#)\203e\372\320\321!D\202\240\312\373!\203\207\320\321!\212\330\225b\210\312\374!\204\312\375!\205\202\320\330!)D\202\240\312\376!\203\225\320\321!\306D\202\240\312\377!\203\254\320\321!\306D\203\254A\\\262\202S\312\201H !\203\304\320\321!C\203\304B\\\262\202S\312\201I !\203\372\320\354!\320\322!\201J \230\203\351\212\337\306w\210\312\201K !)?\205\354D\266\202\203\372C\\\262\202S\312\317!\203\n\320\321!\320\322!D\202C\312\323!\204 \312\324!\203 \320\321!\320\322!D\202C\312\325!\2030\320\321!\320\322!D\202C\312\326!\204F\312\327!\203F\320\321!\320\322!D\204N\312\201L !\203S \\\262\211b\210\311 \210\312\201M !\204\312\313!\203m\330\262\202\316\306w\210\312\f!\204~\312D!\203\206
Z\262\202\312\201N !\203\227@Z\262\202\312E!\203\247AZ\262\202\312F!\203\267BZ\262\202\312\201O !\203\340\320\321!\201J \230\203\327\212\337\306w\210\312\201K !)\204\340CZ\262\202\312\201P !\204\312\201Q !\203\372\320\321!\320\322!D\202\312\201R G\201S Q!\203\320\321!\320\354!D\203 Z\262))\207" [case-fold-search f90-program-indent f90-cache-position f90-continuation-indent f90-else-like-re f90-if-indent nil t f90-previous-statement beginning-of-line looking-at "[ ]*#" "[ ]*\\([!#]\\|$\\)" f90-next-statement " 0-9" "\\(program\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" match-string 1 2 "module[ ]*\\(procedure\\|function\\|subroutine\\)\\_>" "\\(module\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "\\(submodule\\)[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "end[ ]*\\(function\\|procedure\\|subroutine\\)" "[^!'\"&\n]*\\(?:module[ ]*\\)?\\(function\\|subroutine\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" 0 -1 4 parse-partial-sexp search-backward "!" line-beginning-position " " 38 single begin end middle error "The impossible occurred" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (begin 550 middle 565)) current-indentation "[0-9]" f90-get-correct-indent "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(if\\)\\_>" 3 scan-lists "then\\_>" " 0-9&" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(where\\|forall\\)\\_>" "\\(!\\|$\\)" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(select\\)[ ]*\\(case\\|type\\)[ ]*(" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(do\\)\\_>" "\\_<type\\_>[ ]*" "\\(is\\_>\\|(\\)" "\\(\\(?:\\sw\\|\\s_\\)+\\)" re-search-forward "[ ]*::[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" line-end-position "type" "\\_<\\(interface\\)\\_>[ ]*" "\\(operator\\|assignment\\|read\\|write\\)[ ]*([^)\n]*)" "\\(?:\\sw\\|\\s_\\)+" "\\(enum\\|block[ ]*data\\)\\_>" "abstract[ ]*\\(interface\\)\\_>" f90-do-indent f90-type-indent f90-associate-indent f90-critical-indent f90-end-if-re f90-end-type-re f90-end-associate-re f90-blocks-re "\\_<\\(associate\\)[ ]*(" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(critical\\|block\\)\\_>" "block" "data\\_>" "contains[ ]*\\($\\|!\\)" "[ ]*$" "end[ ]*do\\_>" "end[ ]*\\(critical\\|block\\)\\_>" "contains[ ]*\\(!\\|$\\)" "end[ ]*\\(interface\\)[ ]*\\(\\(?:assignment\\|operator\\|read\\|write\\)[ ]*([^)\n]*)\\)" "end[ ]*" "?\\([ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?\\_>"] 12 (#$ . 50738) nil])
#@256 Move point to beginning of the previous F90 statement.
If no previous statement is found (i.e. if called from the first
statement in the buffer), move to the start of the buffer and
return nil. A statement is a line which is neither blank nor a
comment.
(defalias 'f90-previous-statement #[0 "\300\301 \210\302y\303U\211\262\203 \304\305!\204 \211\207" [nil beginning-of-line -1 0 looking-at "[ 0-9]*\\(!\\|$\\|#\\)"] 3 (#$ . 56259) nil])
#@95 Move point to beginning of the next F90 statement.
Return nil if no later statement is found.
(defalias 'f90-next-statement #[0 "\300\301 \210\302y\303U\205
m?\211\262\203 \304\305!\204 \211\207" [nil beginning-of-line 1 0 looking-at "[ 0-9]*\\(!\\|$\\|#\\)"] 3 (#$ . 56709) nil])
#@97 Move point to the beginning of the current subprogram.
Return (TYPE NAME), or nil if not found.
(defalias 'f90-beginning-of-subprogram #[0 "\304\305\306\307 \210\310V\203\270 \311 \306\312#\203\270 \307 \210\313\306w\210\n\203+ `\nV\203+ \n\202, e\314\315`\"8\262\204 \316\317!\203G \320\304!\320\321!D\202\201 \316\322!\204] \316\323!\203] \320\304!\320\321!D\202\201 \316\324!\203m \320\304!\320\321!D\202\201 \316\325!?\205\201 \316\326!\205\201 \320\304!\320\321!D\211\262\203\216 S\262\202 \316\327!\203\236 \320\304!\320\321!D\202\256 \316\330 \331Q!\203 \320\304!\320\314!D\203 T\262\202 \307 \210\310U\203\305 \211\202\320 \332\333!\203\317 \334\335!\210\306)\207" [case-fold-search f90-program-block-re f90-cache-position f90-blocks-re 1 t nil beginning-of-line 0 re-search-backward move " 0-9" 3 parse-partial-sexp looking-at "\\(program\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" match-string 2 "module[ ]*\\(procedure\\|function\\|subroutine\\)\\_>" "\\(module\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "\\(submodule\\)[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "end[ ]*\\(function\\|procedure\\|subroutine\\)" "[^!'\"&\n]*\\(?:module[ ]*\\)?\\(function\\|subroutine\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" "end[ ]*\\(interface\\)[ ]*\\(\\(?:assignment\\|operator\\|read\\|write\\)[ ]*([^)\n]*)\\)" "end[ ]*" "?\\([ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?\\_>" called-interactively-p interactive message "No beginning found"] 8 (#$ . 57001) nil])
#@91 Move point to the end of the current subprogram.
Return (TYPE NAME), or nil if not found.
(defalias 'f90-end-of-subprogram #[0 "\304\305\306\306\210\307V\203\272 \310 \306\311#\203\272 \312 \210\313\306w\210\n\203+ `\nV\203+ \n\202, e\314\315`\"8\262\204\264 \316\317!\203G \320\305!\320\321!D\202\200 \316\322!\204] \316\323!\203] \320\305!\320\321!D\202\200 \316\324!\203m \320\305!\320\321!D\202\200 \316\325!\204\212 \316\326!\203\212 \320\305!\320\321!D\203\212 T\262\202\264 \316\327!\203\232 \320\305!\320\321!D\202\252 \316\330 \331Q!\205\252 \320\305!\320\314!D\211\262\203\264 S\262\306\210\202 \307U\203\304 \211\202\317 \332\333!\203\316 \334\335!\210\306)\207" [case-fold-search f90-program-block-re f90-cache-position f90-blocks-re t 1 nil 0 re-search-forward move beginning-of-line " 0-9" 3 parse-partial-sexp looking-at "\\(program\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" match-string 2 "module[ ]*\\(procedure\\|function\\|subroutine\\)\\_>" "\\(module\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "\\(submodule\\)[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "end[ ]*\\(function\\|procedure\\|subroutine\\)" "[^!'\"&\n]*\\(?:module[ ]*\\)?\\(function\\|subroutine\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" "end[ ]*\\(interface\\)[ ]*\\(\\(?:assignment\\|operator\\|read\\|write\\)[ ]*([^)\n]*)\\)" "end[ ]*" "?\\([ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?\\_>" called-interactively-p interactive message "No end found"] 8 (#$ . 58480) nil])
#@374 Move point forward to the end of the current code block.
With optional argument NUM, go forward that many balanced blocks.
If NUM is negative, go backward to the start of a block. Checks
for consistency of block types and labels (if present), and
completes outermost block if `f90-smart-end' is non-nil.
Interactively, pushes mark before moving point.
(fn &optional NUM)
(defalias 'f90-end-of-block #[256 "\304\305!\203 \306`\307\"\210\211\203 \211\310W\203 \311[!\210\205 \312\307\206% \313\314\211\211\211\211\211\314\210\310V\203\256\315\n\314\316#\203\256\317 \210\320\314w\210 \203X ` V\203X \202Y e\321\322`\"8\262\204\250 \203r ` V\203r \202s e\323\322`\"8\262\204\250\324\325!\203\216 \326\321!\326\327!D\2060\324\330!\203\236 \326\321!\326\327!D\2060\212\324\331!\205\276 \310\225b\205\276 \324\332!?\205\276 \324\333!\206\276 \315\334\335 \307#)\203\312 \336\326\313!D\202\324\337!\203\354 \326\313!\212\310\225b\210\324\340!\204\344 \324\341!\205\347 \326\310!)D\202\324\342!\203\372 \326\313!\314D\202\324\343!\203\326\313!\314D\2060\324\344!\203\326\313!C\2060\324\345!\203<\326\321!\326\327!\346\230\2034\212\347\314w\210\324\350!)?\2057D\266\202\2060\324\351!\203L\326\313!\326\327!D\202\205\324\352!\204b\324\353!\203b\326\313!\326\327!D\202\205\324\354!\203r\326\313!\326\327!D\202\205\324\355!\204\210\324\356!\203\210\326\313!\326\327!D\2060\212\324\357!\205\326\321!\326\327!\360`\313\310#\211\203\241\211b\210\347\314w\210\324\361!\204\376\212\317 \210\324\362!\203\274\363y\310U\204\257\314\210 \203\315` V\203\315 \202\316e\323\322`\"8\262\203\346\364\365\366 \"\210\365\314x\210\202\277\347\314x\210h\367U)\205\370 \210\371\314w\210\324\361!\205D\266\203)\2060\212\324\372!\205/\326\321!\326\327!\360`\313\310#\211\203 \211b\210\347\314w\210\324\373!\205-D\266\203)\211\262\203DB\262T\262\202\250\324\374\n\375Q!\203\250\326\313!\262\326\327!\262S\262\203\250@\262A\262@\262A@\262\205y\227\205\227\232\266\202\204\214\376\377#\210\205\224\227\205\232\227\232\266\202\204\250\376\201@ #\210\314\210\2024 \310V\203\273\376\201A !\210\205\314\212\317 \210\320\314w\210\201B )*\207" [f90-smart-end case-fold-search f90-blocks-re f90-cache-position called-interactively-p any push-mark t 0 f90-beginning-of-block no-blink 1 nil re-search-forward move beginning-of-line " 0-9" 3 parse-partial-sexp 4 looking-at "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(do\\)\\_>" match-string 2 "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(select\\)[ ]*\\(case\\|type\\)[ ]*(" "\\_<type\\_>[ ]*" "\\(is\\_>\\|(\\)" "\\(\\(?:\\sw\\|\\s_\\)+\\)" "[ ]*::[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" line-end-position "type" "\\_<\\(interface\\)\\_>[ ]*" "\\(operator\\|assignment\\|read\\|write\\)[ ]*([^)\n]*)" "\\(?:\\sw\\|\\s_\\)+" "\\(enum\\|block[ ]*data\\)\\_>" "abstract[ ]*\\(interface\\)\\_>" "\\_<\\(associate\\)[ ]*(" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(critical\\|block\\)\\_>" "block" " " "data\\_>" "\\(program\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "module[ ]*\\(procedure\\|function\\|subroutine\\)\\_>" "\\(module\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "\\(submodule\\)[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "end[ ]*\\(function\\|procedure\\|subroutine\\)" "[^!'\"&\n]*\\(?:module[ ]*\\)?\\(function\\|subroutine\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(if\\)\\_>" scan-lists "then\\_>" "[ ]*\\([!#]\\|$\\)" -1 search-backward "!" line-beginning-position 38 f90-next-statement " 0-9&" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(where\\|forall\\)\\_>" "\\(!\\|$\\)" "end[ ]*" "[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)?" error "End type `%s' does not match start type `%s'" "End label `%s' does not match start label `%s'" "Missing block end" f90-match-end] 18 (#$ . 59952) "p"])
#@380 Move point backwards to the start of the current code block.
With optional argument NUM, go backward that many balanced blocks.
If NUM is negative, go forward to the end of a block.
Checks for consistency of block types and labels (if present).
Does not check the outermost block, because it may be incomplete.
Interactively, pushes mark before moving point.
(fn &optional NUM)
(defalias 'f90-beginning-of-block #[256 "\303\304!\203 \305`\306\"\210\211\203 \211\307W\203 \310[!\210\306\206 \311\312\211\211\211\211\211\211\313 \210\307V\203\253\314 \312\315#\203\253\313 \210\316\312w\210\n\203Q `\nV\203Q \n\202R e\317\320`\"8\262\204- \n\203k `\nV\203k \n\202l e\321\320`\"8\262\204- \322\323 \324Q!\203\224 \325\311!\325\326!DB\262T\262\202- \322\327!\203\244 \325\317!\325\326!D\206F\322\330!\203\264 \325\317!\325\326!D\206F\212\322\331!\205\324 \307\225b\205\324 \322\332!?\205\324 \322\333!\206\324 \334\335\336 \306#)\203\340 \337\325\311!D\202\322\340!\203\325\311!\212\307\225b\210\322\341!\204\372 \322\342!\205\375 \325\307!)D\202\322\343!\203\325\311!\312D\202\322\344!\203 \325\311!\312D\206F\322\345!\203+\325\311!C\206F\322\346!\203R\325\317!\325\326!\347\230\203J\212\350\312w\210\322\351!)?\205MD\266\202\206F\322\352!\203b\325\311!\325\326!D\202\233\322\353!\204x\322\354!\203x\325\311!\325\326!D\202\233\322\355!\203\210\325\311!\325\326!D\202\233\322\356!\204\236\322\357!\203\236\325\311!\325\326!D\206F\212\322\360!\205\325\317!\325\326!\361`\311\307#\211\203\267\211b\210\350\312w\210\322\362!\204\212\313 \210\322\363!\203\322\364y\307U\204\305\312\210\n\203\343`\nV\203\343\n\202\344e\321\320`\"8\262\203\374\365\366\367 \"\210\366\312x\210\202\325\350\312x\210h\370U)\205\371 \210\372\312w\210\322\362!\205D\266\203)\206F\212\322\373!\205E\325\317!\325\326!\361`\311\307#\211\2036\211b\210\350\312w\210\322\374!\205CD\266\203)\211\262\203- @\262A@\262S\262\203- @\262A\262@\262A@\262\205z\227\205\200\227\232\266\202\204\215\375\376#\210\211\205\225\227\205\233\227\232\266\202\204- \375\377#\210\202- \307V\205\267\375\201@ !)\207" [case-fold-search f90-blocks-re f90-cache-position called-interactively-p any push-mark t 0 f90-end-of-block 1 nil beginning-of-line re-search-backward move " 0-9" 3 parse-partial-sexp 4 looking-at "end[ ]*" "[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)?" match-string 2 "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(do\\)\\_>" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(select\\)[ ]*\\(case\\|type\\)[ ]*(" "\\_<type\\_>[ ]*" "\\(is\\_>\\|(\\)" "\\(\\(?:\\sw\\|\\s_\\)+\\)" re-search-forward "[ ]*::[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" line-end-position "type" "\\_<\\(interface\\)\\_>[ ]*" "\\(operator\\|assignment\\|read\\|write\\)[ ]*([^)\n]*)" "\\(?:\\sw\\|\\s_\\)+" "\\(enum\\|block[ ]*data\\)\\_>" "abstract[ ]*\\(interface\\)\\_>" "\\_<\\(associate\\)[ ]*(" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(critical\\|block\\)\\_>" "block" " " "data\\_>" "\\(program\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "module[ ]*\\(procedure\\|function\\|subroutine\\)\\_>" "\\(module\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "\\(submodule\\)[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "end[ ]*\\(function\\|procedure\\|subroutine\\)" "[^!'\"&\n]*\\(?:module[ ]*\\)?\\(function\\|subroutine\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(if\\)\\_>" scan-lists "then\\_>" "[ ]*\\([!#]\\|$\\)" -1 search-backward "!" line-beginning-position 38 f90-next-statement " 0-9&" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(where\\|forall\\)\\_>" "\\(!\\|$\\)" error "Start type `%s' does not match end type `%s'" "Start label `%s' does not match end label `%s'" "Missing block start"] 18 (#$ . 63871) "p"])
#@213 Move point forward to the next end or start of a code block.
With optional argument NUM, go forward that many blocks.
If NUM is negative, go backwards.
A block is a subroutine, if-endif, etc.
(fn &optional NUM)
(defalias 'f90-next-block #[256 "\303\203 \304!\202\f \305\211\306V\2056\306V\203\" \307 \310\311#\202' \312 \310\311#\2056\313 \210\314\310w\210\n\203? `\nV\203? \n\202@ e\315\316`\"8\262\204$\n\203Y `\nV\203Y \n\202Z e\317\316`\"8\262\204$\320\321!\204 \320\322!\203{ \323\315!\323\324!D\204 \320\325!\203\213 \323\315!\323\324!D\204 \212\320\326!\205\253 \306\225b\205\253 \320\327!?\205\253 \320\330!\206\253 \307\331\332 \303#)\203\267 \333\323\305!D\202\362 \320\334!\203\331 \323\305!\212\306\225b\210\320\335!\204\321 \320\336!\205\324 \323\306!)D\202\362 \320\337!\203\347 \323\305!\310D\202\362 \320\340!\203\365 \323\305!\310D\204 \320\341!\203\323\305!C\204 \320\342!\203)\323\315!\323\324!\343\230\203!\212\344\310w\210\320\345!)?\205$D\266\202\204 \320\346!\2039\323\305!\323\324!D\202r\320\347!\204O\320\350!\203O\323\305!\323\324!D\202r\320\351!\203_\323\305!\323\324!D\202r\320\352!\204u\320\353!\203u\323\305!\323\324!D\204 \212\320\354!\205\360\323\315!\323\324!\355`\305\306#\211\203\216\211b\210\344\310w\210\320\356!\204\353\212\313 \210\320\357!\203\251\360y\306U\204\234\310\210\n\203\272`\nV\203\272\n\202\273e\317\316`\"8\262\203\323\361\362\363 \"\210\362\310x\210\202\254\344\310x\210h\364U)\205\356\365 \210\366\310w\210\320\356!\205\356D\266\203)\204 \212\320\367!\205 \323\315!\323\324!\355`\305\306#\211\203
\211b\210\344\310w\210\320\370!\205D\266\203)\203$\211S\262\306V\2030\310\210\202 \313 \210\202 )\207" [case-fold-search f90-blocks-re f90-cache-position t abs 1 0 re-search-forward nil move re-search-backward beginning-of-line " 0-9" 3 parse-partial-sexp 4 looking-at "end[ ]*" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(do\\)\\_>" match-string 2 "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(select\\)[ ]*\\(case\\|type\\)[ ]*(" "\\_<type\\_>[ ]*" "\\(is\\_>\\|(\\)" "\\(\\(?:\\sw\\|\\s_\\)+\\)" "[ ]*::[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" line-end-position "type" "\\_<\\(interface\\)\\_>[ ]*" "\\(operator\\|assignment\\|read\\|write\\)[ ]*([^)\n]*)" "\\(?:\\sw\\|\\s_\\)+" "\\(enum\\|block[ ]*data\\)\\_>" "abstract[ ]*\\(interface\\)\\_>" "\\_<\\(associate\\)[ ]*(" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(critical\\|block\\)\\_>" "block" " " "data\\_>" "\\(program\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "module[ ]*\\(procedure\\|function\\|subroutine\\)\\_>" "\\(module\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "\\(submodule\\)[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "end[ ]*\\(function\\|procedure\\|subroutine\\)" "[^!'\"&\n]*\\(?:module[ ]*\\)?\\(function\\|subroutine\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(if\\)\\_>" scan-lists "then\\_>" "[ ]*\\([!#]\\|$\\)" -1 search-backward "!" line-beginning-position 38 f90-next-statement " 0-9&" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(where\\|forall\\)\\_>" "\\(!\\|$\\)"] 11 (#$ . 67712) "p"])
#@218 Move point backward to the previous end or start of a code block.
With optional argument NUM, go backward that many blocks.
If NUM is negative, go forwards.
A block is a subroutine, if-endif, etc.
(fn &optional NUM)
(defalias 'f90-previous-block #[256 "\300\206 \301[!\207" [f90-next-block 1] 3 (#$ . 70879) "p"])
#@67 Put mark at end of F90 subprogram, point at beginning, push mark.
(defalias 'f90-mark-subprogram #[0 "`\302\303 \210\304 \210b\210\305 \262\306\302\207" [mark-active deactivate-mark nil f90-end-of-subprogram push-mark f90-beginning-of-subprogram t] 3 (#$ . 71202) nil])
#@191 Comment/uncomment every line in the region.
Insert the variable `f90-comment-region' at the start of every line
in the region, or, if already present, remove it.
(fn BEG-REGION END-REGION)
(defalias 'f90-comment-region #[514 "\301!b\210\302 \210\303\304!!\203 `\305\225|\210\202 c\210\306y\305U\203? `W\203? \303\304!!\2039 `\305\225|\210\202 c\210\202 \211\307\211\223\207" [f90-comment-region copy-marker beginning-of-line looking-at regexp-quote 0 1 nil] 6 (#$ . 71483) "*r"])
#@147 Indent current line as F90 code.
Unless optional argument NO-UPDATE is non-nil, call `f90-update-line'
after indenting.
(fn &optional NO-UPDATE)
(defalias 'f90-indent-line #[256 "\306\307 \310\211\311 \210\212\312 \205S \212\311 \210\313\314!\203! \315y\316U\204 \310\210 \2032 ` V\2032 \2023 e\317\320`\"8\262\203K \321\322\323 \"\210\322\310x\210\202$ \324\310x\210h\325U))\204k \n\204d \313\326!\203d \327 \210\330\310w\210\202r \306\262\324\310w\210g\331U\203\311 \313\332!\203\202 \316\202\304 \203\220 \313 !\203\220 \316\202\304 \313\333\f!!\203\234 \316\202\304 \313
!\203\261 \212\324\310x\210n)\203\261 \334 \202\304 \212\324\310x\210n\203\276 \316\202\300 iT%])\262\202\347 g\335U\203\325 \316\262\202\347 &\203\343 \313\336!\203\343 \337 \210\334 \262iU\204
\311 \210\211\204\372 \330\310w\210\327 \210\340i\316U\203 \316\202\n\341\"\266`W\203b\210'\203!\342 \210\2023\2043(\2033\343(\323 \344 #\210\310\211\223)\207" [case-fold-search f90-cache-position f90-leave-line-no f90-directive-comment-re f90-comment-region f90-indented-comment-re t point-marker nil beginning-of-line f90-previous-statement looking-at "[ ]*\\([!#]\\|$\\)" -1 0 4 parse-partial-sexp search-backward "!" line-beginning-position " " 38 "[ ]+[0-9]" delete-horizontal-space " 0-9" 33 "!!!" regexp-quote f90-calculate-indent 35 "end" f90-match-end indent-to 1 f90-do-auto-fill f90-change-keywords line-end-position comment-column f90-smart-end auto-fill-function f90-auto-keyword-case] 11 (#$ . 71982) "*P"])
#@199 Re-indent current line, insert a newline and indent the newline.
An abbrev before point is expanded if the variable `abbrev-mode' is non-nil.
If run in the middle of a line, the line is not broken.
(defalias 'f90-indent-new-line #[0 "\203 \303 \210\304 \210\305 \210\306\210\307 \210 \203! ` V\203! \202\" e\310\311`\"8\262\212\304 \210\312\313!\203; \314y\315U\204. \306\210 \203L ` V\203L \202M e\316\311`\"8\262\203e \317\320\321 \"\210\320\306x\210\202> \322\306x\210h\323U)\203x \211\204x \324c\210\325 \210\204\207 \211\203\212 \n\203\212 \324c\210\266\305\326!\207" [abbrev-mode f90-cache-position f90-beginning-ampersand expand-abbrev beginning-of-line f90-indent-line nil delete-horizontal-space 3 parse-partial-sexp looking-at "[ ]*\\([!#]\\|$\\)" -1 0 4 search-backward "!" line-beginning-position " " 38 "&" newline no-update] 6 (#$ . 73521) "*"])
#@77 Indent every line in region by forward parsing.
(fn BEG-REGION END-REGION)
(defalias 'f90-indent-region #[514 "\306!\307 \310\311\211\211\211\211\211\211\211\fb\210\312 \210\313\314!\2030 \315\316!\210\317y\320U\2030 ` W\204 \311\211\212\321 \205{ \212\312 \210\313\322!\203I \323y\320U\204< \311\210 \203Z ` V\203Z \202[ e\324\325`\"8\262\203s \326\327\330 \"\210\327\311x\210\202L \331\311x\210h\332U)\262)\212\312 \210\313\322!\203\217 \323y\320U\204\202 \311\210 \203\240 ` V\203\240 \202\241 e\324\325`\"8\262\203\271 \326\327\330 \"\210\327\311x\210\202\222 \331\311x\210h\332U)\262\204\317 \211\204\317 \333\202\366 \204\333 \211\203\333 \334\202\366 \203\347 \211\204\347 \335\202\366 \203\363 \211\203\363 \336\202\366 \337\340!\266\202\262\341>\203\322\321 \203\322\311\211\212\321 \205P\212\312 \210\313\322!\203 \323y\320U\204\311\210 \203/` V\203/ \2020e\324\325`\"8\262\203H\326\327\330 \"\210\327\311x\210\202!\331\311x\210h\332U)\262)\212\312 \210\313\322!\203d\323y\320U\204W\311\210 \203u` V\203u \202ve\324\325`\"8\262\203\216\326\327\330 \"\210\327\311x\210\202g\331\311x\210h\332U)\262\204\244\211\204\244\333\202\313\204\260\211\203\260\334\202\313\203\274\211\204\274\335\202\313\203\310\211\203\310\336\202\313\337\340!\266\202\262\202\372 `\315\316!\210\212\312 \210\342\311w)\262\262\312 \210\342\311w\210\311\262\313\343!\205\375\344\345!\344\346!D\211\262\203\n\202\356\212\313\347!\205\202\344\345!\344\346!\350`\317\320#\211\203 \211b\210\331\311w\210\313\351!\204}\212\312 \210\313\322!\203;\323y\320U\204.\311\210 \203L` V\203L \202Me\324\325`\"8\262\203e\326\327\330 \"\210\327\311x\210\202>\331\311x\210h\332U)\205\200\352 \210\353\311w\210\313\351!\205\200D\266\203)\211\262\204\321\313\354!\205\226\344\345!\344\346!D\211\262\204\321\212\313\355!\205\304\344\345!\344\346!\350`\317\320#\211\203\265\211b\210\331\311w\210\313\356!\205\302D\266\203)\211\262\204\321\313 !\203\325\f\202\356\212\313\357!\205\365\320\225b\205\365\313\360!?\205\365\313\361!\206\365\362\363\364 \310#)\203\365\344\317!D\202<\313\366!\203#\344\317!\212\320\225b\210\313\367!\204\313\370!\205 \344\320!)D\202<\313\371!\2031\344\317!\311D\202<\313\372!\205<\344\317!\311D\211\262\203F
\202\356\313\373!\205P\344\317!C\211\262\203[@\202\356\313\374!\205\344\345!\344\346!\375\230\203z\212\331\311w\210\313\376!)?\205}D\266\202\211\262\203\212A\202\356\313\377!\203\232\344\317!\344\346!D\202\336\313\201O !\204\264\313\201P !\203\264\344\317!\344\346!D\202\336\313\201Q !\203\306\344\317!\344\346!D\202\336\313\201R !?\205\336\313\201S !\205\336\344\317!\344\346!D\211\262\204\354\313\201T !\205\356B\262\203\372\\\262\203B\262\212\312 \210\313\322!\203\323y\320U\204\311\210 \203&` V\203& \202'e\324\325`\"8\262\203?\326\327\330 \"\210\327\311x\210\202\331\311x\210h\332U)\203\317y\320U\203` W\203\313\201U !\203\334\313\201V !\203l\320\202\266C\203|\313C!\203|\320\202\266\313\201W D!!\203\213\320\202\266\313E!\203\243\212\331\311x\210n)\203\243\201X \202\266\212\331\311x\210n\203\260\320\202\262iTF])\311\312 \210\211\204\302\342\311w\210\201Y \210\201Z i\320U\203\325\320\202\326\317\"\266\202\201[ G\\U\204G\\\201\\ \312 \210\211\204\373\342\311w\210\201Y \210\201Z i\320U\203\320\202\317\"\266\202\317y\320U\203m\n` W\203m\n\312 \210H\2048\313\201] !\2038\201Y \210\342\311w\210`\313\201^ !\203L\320\262\202 \313\201_ !\203Z\320\262\202 \313\327!\203\273\313\201V !\203l\320\202\266C\203|\313C!\203|\320\202\266\313\201W D!!\203\213\320\202\266\313E!\203\243\212\331\311x\210n)\203\243\201X \202\266\212\331\311x\210n\203\260\320\202\262iTF])\262\202 \212\313\201` !\206\353\313\201a !\206\353\313\201b !\206\353\313\201c !\206\353\313I!\206\353\362\201d \364 \310#)\204\366\262\202 \313 !\203\fZ\262\202 \313\201T !\203BZ\262\202 \313\343!\205$\344\345!\344\346!D\211\262\203.\n\202\212\313\347!\205\251\344\345!\344\346!\350`\317\320#\211\203G\211b\210\331\311w\210\313\351!\204\244\212\312 \210\313\322!\203b\323y\320U\204U\311\210 \203s` V\203s \202te\324\325`\"8\262\203\214\326\327\330 \"\210\327\311x\210\202e\331\311x\210h\332U)\205\247\352 \210\353\311w\210\313\351!\205\247D\266\203)\211\262\204\362\313\354!\205\275\344\345!\344\346!D\211\262\204\362\212\313\355!\205\353\344\345!\344\346!\350`\317\320#\211\203\334\211b\210\331\311w\210\313\356!\205\351D\266\203)\211\262\203\366\f\202\212\313\357!\205\320\225b\205\313\360!?\205\313\361!\206\362\363\364 \310#)\203\"\365\344\317!D\202]\313\366!\203D\344\317!\212\320\225b\210\313\367!\204<\313\370!\205?\344\320!)D\202]\313\371!\203R\344\317!\311D\202]\313\372!\205]\344\317!\311D\211\262\203g
\202\313\373!\205q\344\317!C\211\262\203|@\202\313\374!\205\240\344\345!\344\346!\375\230\203\233\212\331\311w\210\313\376!)?\205\236D\266\202\211\262\203\253A\202\313\377!\203\273\344\317!\344\346!D\202\377\313\201O !\204\325\313\201P !\203\325\344\317!\344\346!D\202\377\313\201Q !\203\347\344\317!\344\346!D\202\377\313\201R !?\205\377\313\201S !\205\377\344\317!\344\346!D\211\262\205B\211\262\203$\262\203\\\262B\262\202 \313\201e !\2036\344\317!\344\346!D\202K\313\201f J\201g Q!\205K\344\317!\344\345!D\211\262\203\377@\262A\262K\203q\212\201h @A@@A@$\210)\313L!\203|\f\202\354\313\201i !\203\210\n\202\354\313M!\203\223
\202\354\313N!\203\237@\202\354\313\201j !\203\300\344\317!\375\230\203\273\212\331\311w\210\313\376!)\204\300A\202\354\313\201e !\203\322\344\317!\344\346!D\202\347\313\201f J\201g Q!\205\354\344\317!\344\345!D\205\354B\262\203\370Z\262\262\202 \262iU\204- \311\312 \210\211\204 \342\311w\210\201Y \210\201Z i\320U\203) \320\202* \317\"\266\212\312 \210\313\322!\203> \323y\320U\2041 \311\210 \203O ` V\203O \202P e\324\325`\"8\262\203h \326\327\330 \"\210\327\311x\210\202A \331\311x\210h\332U)\203\317y\320U\203` W\203\313\201_ !\203\260 \320\311\312 \210\211\204\226 \342\311w\210\201Y \210\201Z i\320U\203\251 \320\202\252 \317\"\266\202- \313\201U !\2034\n\313\201V !\203\304 \320\202\nC\203\324 \313C!\203\324 \320\202\n\313\201W D!!\203\343 \320\202\n\313E!\203\373 \212\331\311x\210n)\203\373 \201X \202\n\212\331\311x\210n\203\n\320\202\n\niTF])\311\312 \210\211\204\n\342\311w\210\201Y \210\201Z i\320U\203-\n\320\202.\n\317\"\266\202- \201[ G\\U\204- G\\\201\\ \312 \210\211\204S\n\342\311w\210\201Y \210\201Z i\320U\203f\n\320\202g\n\317\"\266\202- \311 b\210\n\311\211\223\210 \311\211\223\210\201k )\207" [case-fold-search f90-cache-position f90-do-indent f90-else-like-re f90-if-indent f90-type-indent copy-marker point-marker t nil beginning-of-line looking-at "[ ]*[0-9]*\\(!\\|#\\|[ ]*$\\)" f90-indent-line no-update 1 0 f90-previous-statement "[ ]*\\([!#]\\|$\\)" -1 4 parse-partial-sexp search-backward "!" line-beginning-position " " 38 single begin end middle error "The impossible occurred" (middle end) " 0-9" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(do\\)\\_>" match-string 3 2 "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(if\\)\\_>" scan-lists "then\\_>" f90-next-statement " 0-9&" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(select\\)[ ]*\\(case\\|type\\)[ ]*(" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(where\\|forall\\)\\_>" "\\(!\\|$\\)" "\\_<type\\_>[ ]*" "\\(is\\_>\\|(\\)" "\\(\\(?:\\sw\\|\\s_\\)+\\)" re-search-forward "[ ]*::[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" line-end-position "type" "\\_<\\(interface\\)\\_>[ ]*" "\\(operator\\|assignment\\|read\\|write\\)[ ]*([^)\n]*)" "\\(?:\\sw\\|\\s_\\)+" "\\(enum\\|block[ ]*data\\)\\_>" "abstract[ ]*\\(interface\\)\\_>" "\\_<\\(associate\\)[ ]*(" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(critical\\|block\\)\\_>" "block" "data\\_>" "\\(program\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" f90-associate-indent f90-critical-indent f90-program-indent f90-directive-comment-re f90-comment-region f90-indented-comment-re comment-column f90-continuation-indent f90-leave-line-no f90-type-def-re f90-blocks-re f90-smart-end f90-end-if-re f90-end-type-re f90-end-associate-re "module[ ]*\\(procedure\\|function\\|subroutine\\)\\_>" "\\(module\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "\\(submodule\\)[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "end[ ]*\\(function\\|procedure\\|subroutine\\)" "[^!'\"&\n]*\\(?:module[ ]*\\)?\\(function\\|subroutine\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" "contains[ ]*\\($\\|!\\)" "[ ]*!" "!!!" regexp-quote f90-calculate-indent delete-horizontal-space indent-to current-indentation no-line-no "[ ]+[0-9]" "[ ]*$" "[ ]*#" "end" "\\(do\\|if\\|else\\(if\\|where\\)?\\|select[ ]*\\(case\\|type\\)\\|case\\|where\\|forall\\|\\(?:class\\|type\\)[ ]*is\\|class[ ]*default\\|block\\|critical\\|enum\\|associate\\)\\_>" "\\(program\\|\\(?:sub\\)?module\\|\\(?:abstract[ ]*\\)?interface\\|block[ ]*data\\)\\_>" "\\(contains\\|\\(?:\\sw\\|\\s_\\)+[ ]*:\\)" "\\(function\\|subroutine\\)" "end[ ]*\\(interface\\)[ ]*\\(\\(?:assignment\\|operator\\|read\\|write\\)[ ]*([^)\n]*)\\)" "end[ ]*" "?\\([ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?\\_>" f90-block-match "end[ ]*do\\_>" "end[ ]*\\(critical\\|block\\)\\_>" deactivate-mark] 21 (#$ . 74402) "*r"])
#@50 Properly indent the subprogram containing point.
(defalias 'f90-indent-subprogram #[0 "\212\300 \211\203\" \301\302@A@#\210\303`\304 \305#\210\301\306@A@#\2020 \301\307!\210\303`\304 \305#\210\301\310!\262)\207" [f90-mark-subprogram message "Indenting %s %s..." indent-region mark nil "Indenting %s %s...done" "Indenting the whole file..." "Indenting the whole file...done"] 5 (#$ . 83904) "*"])
#@235 Break line at point, insert continuation marker(s) and indent.
Unless in a string or comment, or if the optional argument NO-UPDATE
is non-nil, call `f90-update-line' after inserting the continuation marker.
(fn &optional NO-UPDATE)
(defalias 'f90-break-line #[256 "\203 `V\203 \202 e\303\304`\"8\262\203 \305c\210\202\255 \203. `V\203. \202/ e\306\304`\"8\262\203\217 \307 \210\310\212\203M `V\203M \202N e\306\304`\"8\262\205\210 \311 \210\312\313\314 \"\210\203p `V\203p \202q e\303\304`\"8\262\203\205 \312\313\314 \"\210\202b \315\316!)\261\210\202\255 \317c\210\211\204\242 \203\242 \320 \321 \314 #\210\322\323!\210\n\203\255 \317c\210\324 \207" [f90-cache-position f90-auto-keyword-case f90-beginning-ampersand 3 parse-partial-sexp "&\n&" 4 delete-horizontal-space "\n" beginning-of-line re-search-forward "!+[ ]*" line-end-position match-string-no-properties 0 "&" f90-change-keywords line-beginning-position newline 1 indent-according-to-mode] 7 (#$ . 84312) "*P"])
#@58 From `fill-column', search backward for break-delimiter.
(defalias 'f90-find-breakpoint #[0 "\203 `V\203 \202 e\304\305`\"8\262\203 \306\307\310 \"\207\306 \310 \"\210\n\2047 \311 !\2034 \312\2025 \313u\207\314u\210\311 !\206B \315u\207" [f90-cache-position f90-break-delimiters f90-break-before-delimiters f90-no-break-re 4 parse-partial-sexp re-search-backward "\\s-" line-beginning-position looking-at 2 1 -1 nil] 5 (#$ . 85322)])
#@85 Break line if non-white characters beyond `fill-column'.
Update keyword case first.
(defalias 'f90-do-auto-fill #[0 "\203\f \304\305 \306 #\210\307\301!\205. \205. \n\203$ `\nV\203$ \n\202% e\310\311`\"8\262??\205j i V\205j \312 \313 !\210\n\203L `\nV\203L \n\202M e\314\311`\"8\262\204[ \315 \210\316 \210\211b\210\211\317\211\223\266\2022 \207" [f90-auto-keyword-case comment-auto-fill-only-comments f90-cache-position fill-column f90-change-keywords line-beginning-position line-end-position boundp 4 parse-partial-sexp point-marker move-to-column 3 f90-find-breakpoint f90-break-line nil] 6 (#$ . 85771) "*"])
#@199 Join current line to previous, fix whitespace, continuation, comments.
With optional argument ARG, join current line to following line.
Like `join-line', but handles F90 syntax.
(fn &optional ARG)
(defalias 'f90-join-lines #[256 "\301 \210\211\203\n \302y\210h\303=\205t \304\305w\210\306\307!\203 \310\302!\210\301 \210``S|\210\304\305x\210h\311=\2034 \310\312!\210\203B `V\203B \202C e\313\314`\"8\262\203X \306\315!\203X \316\317!\210\203f `V\203f \202g e\320\314`\"8\262\206t \321 \207" [f90-cache-position beginning-of-line 1 10 " " nil looking-at "&" delete-char 38 -1 4 parse-partial-sexp "[ ]*!+" replace-match "" 3 fixup-whitespace] 6 (#$ . 86400) "*P"])
#@100 Fill every line in region by forward parsing. Join lines if possible.
(fn BEG-REGION END-REGION)
(defalias 'f90-fill-region #[514 "\305!\306\307\211\211b\210\211\203O \307\210\310\307x\210h\311=\203% \312\313!\210\202 \212\307\210i) V\203> \314 !\210\315 \210\316\317!\210\202% `W\205H \320y\321U\262`\202
\307\307\211\223\210\322 +\207" [auto-fill-function f90-auto-keyword-case f90-smart-end fill-column f90-cache-position copy-marker t nil " " 38 f90-join-lines forward move-to-column f90-find-breakpoint f90-break-line no-update 1 0 deactivate-mark] 7 (#$ . 87085) "*r"])
#@276 In a comment, fill it as a paragraph, else fill the current statement.
For use as the value of `fill-paragraph-function'.
Passes optional argument JUSTIFY to `fill-comment-paragraph'.
Always returns non-nil (to prevent `fill-paragraph' being called).
(fn &optional JUSTIFY)
(defalias 'f90-fill-paragraph #[256 "\300!\206\" \212\301 \210o\203 `\202 `S\302 \210\303`\"\262)\206\" \304\207" [fill-comment-paragraph f90-next-statement f90-previous-statement f90-fill-region t] 5 (#$ . 87685) "*P"])
#@72 Block types where including the name in the end statement is optional.
(defconst f90-end-block-optional-name '("program" "module" "subroutine" "function" "type") (#$ . 88192))
#@555 Match end-struct with beg-struct and complete end-block if possible.
BEG-BLOCK is the type of block as indicated at the start (e.g., do).
BEG-NAME is the block start name (may be nil).
END-BLOCK is the type of block as indicated at the end (may be nil).
END-NAME is the block end name (may be nil).
If the block type matches `f90-end-block-optional-name', do not add
an end name if `f90-smart-end-names' is nil, but always update an
incorrect end name if there already was one.
Leave point at the end of line.
(fn BEG-BLOCK BEG-NAME END-BLOCK END-NAME)
(defalias 'f90-block-match #[1028 "\204 \302\262\303\304\305 \"\210\3062\306 \2030 \205 \227\205# \227\232\266\202\2030 \303!\210\202P \203F \307\310#\210\311\210\312\306\311\"\210\202P \307\313\"\210\314Pc\210\205X \227\205^ \227\232\266\202\203o \211\203\275 \303!\210\202\275 \203\217 \211\204\217 \204\202 \315 \"\204\275 \307\313\"\210\314Pc\210\202\275 \203\250 \211\203\250 \307\316#\210\303!\210\317!\210\202\275 \204\275 \211\203\275 \307\320\"\210\303!\210\317\321!\210\322\323!\206\305 \324 0\207" [f90-smart-end-names f90-end-block-optional-name "program" search-forward "end" line-end-position no-match message "END %s does not match %s." nil throw "Inserting %s." " " member-ignore-case "Replacing %s with %s." replace-match "Deleting %s." "" looking-at "[ ]*!" delete-horizontal-space] 8 (#$ . 88375)])
#@69 From an end block statement, find the corresponding block and name.
(defalias 'f90-match-end #[0 "\306\307 `\310\311\211\211\211\211\211\212\312 \210\313\311w\210 \203$ ` V\203$ \202% e\314\315`\"8\262?\205T \316\317!\203A \320\306!\320\321!D\202Q \316\322\n\323Q!\205Q \320\306!\320\314!D\211\262)\205\356\211@\262\211A@\262\212\312 \210 \324V\203\217\325 eU\204\217\326\n\311\327#\210\312 \210\313\311w\210 \203\216 ` V\203\216 \202\217 e\314\315`\"8\262\204e \203\250 ` V\203\250 \202\251 e\330\315`\"8\262\204e \316\331!\203\304 \320\314!\320\321!D\206q\212\316\332!\205?\320\314!\320\321!\333`\306\324#\211\203\335 \211b\210\334\311w\210\316\335!\204:\212\312 \210\316\336!\203\370 \337y\324U\204\353 \311\210 \203 ` V\203 \202\ne\330\315`\"8\262\203\"\340\341\325 \"\210\341\311x\210\202\373 \334\311x\210h\342U)\205=\343 \210\344\311w\210\316\335!\205=D\266\203)\206q\212\316\345!\205k\320\314!\320\321!\333`\306\324#\211\203\\\211b\210\334\311w\210\316\346!\205iD\266\203)\206q\316\347!\203\320\314!\320\321!D\206q\212\316\350!\205\237\324\225b\205\237\316\351!?\205\237\316\352!\206\237\353\354\355 \310#)\203\253\356\320\306!D\202\346\316\357!\203\315\320\306!\212\324\225b\210\316\360!\204\305\316\361!\205\310\320\324!)D\202\346\316\362!\203\333\320\306!\311D\202\346\316\363!\203\351\320\306!\311D\206q\316\364!\203\366\320\306!C\206q\316\365!\203 \320\314!\320\321!\366\230\203\212\334\311w\210\316\367!)?\205D\266\202\206q\316\370!\203-\320\306!\320\321!D\202f\316\371!\204C\316\372!\203C\320\306!\320\321!D\202f\316\373!\203S\320\306!\320\321!D\202f\316\374!\204i\316\375!\203i\320\306!\320\321!D\206q\325 eU\205q\376\211\262\203 S\262\n\202e \316\322\nP!\203e T\262\n\202e \324V\203\236\377\201@ !\202\355 \203\254\201A \325 \355 #\210\f\201B =\203\323` W\203\315\377\201C \201D \325 \355 {#\210\202\323\201E
!\210@\262A@\262b\210\312 \210\201F $))\207" [case-fold-search f90-cache-position f90-blocks-re f90-auto-keyword-case f90-smart-end blink-matching-delay 1 window-start t nil beginning-of-line " 0-9" 3 parse-partial-sexp looking-at "end[ ]*\\(interface\\)[ ]*\\(\\(?:assignment\\|operator\\|read\\|write\\)[ ]*([^)\n]*)\\)" match-string 2 "end[ ]*" "?\\([ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?\\_>" 0 line-beginning-position re-search-backward move 4 "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(do\\)\\_>" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(if\\)\\_>" scan-lists " " "then\\_>" "[ ]*\\([!#]\\|$\\)" -1 search-backward "!" 38 f90-next-statement " 0-9&" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(where\\|forall\\)\\_>" "\\(!\\|$\\)" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(select\\)[ ]*\\(case\\|type\\)[ ]*(" "\\_<type\\_>[ ]*" "\\(is\\_>\\|(\\)" "\\(\\(?:\\sw\\|\\s_\\)+\\)" re-search-forward "[ ]*::[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)" line-end-position "type" "\\_<\\(interface\\)\\_>[ ]*" "\\(operator\\|assignment\\|read\\|write\\)[ ]*([^)\n]*)" "\\(?:\\sw\\|\\s_\\)+" "\\(enum\\|block[ ]*data\\)\\_>" "abstract[ ]*\\(interface\\)\\_>" "\\_<\\(associate\\)[ ]*(" "\\(\\(\\(?:\\sw\\|\\s_\\)+\\)[ ]*:\\)?[ ]*\\(critical\\|block\\)\\_>" "block" "data\\_>" "\\(program\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "module[ ]*\\(procedure\\|function\\|subroutine\\)\\_>" "\\(module\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "\\(submodule\\)[ ]*([^)\n]+)[ ]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>" "end[ ]*\\(function\\|procedure\\|subroutine\\)" "[^!'\"&\n]*\\(?:module[ ]*\\)?\\(function\\|subroutine\\)[ ]+\\(\\(?:\\sw\\|\\s_\\)+\\)" ("program" nil) message "No matching beginning." f90-change-keywords blink "Matches %s: %s" what-line sit-for f90-block-match] 18 (#$ . 89793) nil])
#@70 Insert a complete end statement matching beginning of present block.
(defalias 'f90-insert-end #[0 "\206 \301\302c\210\303 )\207" [f90-smart-end blink "end" f90-indent-new-line] 1 (#$ . 93550) "*"])
#@110 Typing \=`\[help-command] or \=`? lists all the F90 abbrevs.
Any other key combination is executed normally.
(defalias 'f90-abbrev-start #[0 "\302\303!\210\205 \304\305 \306\307\310#\210\306\311 !\310#\210\211\262!\207" [abbrev-mode help-char self-insert-command 1 set-transient-map make-sparse-keymap define-key [63] f90-abbrev-help vector] 6 (#$ . 93759) "*"])
#@49 List the currently defined abbrevs in F90 mode.
(defalias 'f90-abbrev-help #[0 "\300\301!\210\302\303 !\210\300\304!\207" [message "Listing abbrev table..." display-buffer f90-prepare-abbrev-list-buffer "Listing abbrev table...done"] 2 (#$ . 94133) nil])
#@53 Create a buffer listing the F90 mode abbreviations.
(defalias 'f90-prepare-abbrev-list-buffer #[0 "r\300\301!q\210\302 \210\303\304\305\"\210eb\210\306\307!\210\310 \210)\300\301!\207" [get-buffer-create "*Abbrevs*" erase-buffer insert-abbrev-table-description f90-mode-abbrev-table t set-buffer-modified-p nil edit-abbrevs-mode] 3 (#$ . 94394)])
#@40 Upcase all F90 keywords in the buffer.
(defalias 'f90-upcase-keywords #[0 "\300\301!\207" [f90-change-keywords upcase-word] 2 (#$ . 94747) "*"])
#@44 Capitalize all F90 keywords in the buffer.
(defalias 'f90-capitalize-keywords #[0 "\300\301!\207" [f90-change-keywords capitalize-word] 2 (#$ . 94898) "*"])
#@42 Downcase all F90 keywords in the buffer.
(defalias 'f90-downcase-keywords #[0 "\300\301!\207" [f90-change-keywords downcase-word] 2 (#$ . 95061) "*"])
#@54 Upcase all F90 keywords in the region.
(fn BEG END)
(defalias 'f90-upcase-region-keywords #[514 "\300\301#\207" [f90-change-keywords upcase-word] 6 (#$ . 95218) "*r"])
#@58 Capitalize all F90 keywords in the region.
(fn BEG END)
(defalias 'f90-capitalize-region-keywords #[514 "\300\301#\207" [f90-change-keywords capitalize-word] 6 (#$ . 95395) "*r"])
#@56 Downcase all F90 keywords in the region.
(fn BEG END)
(defalias 'f90-downcase-region-keywords #[514 "\300\301#\207" [f90-change-keywords downcase-word] 6 (#$ . 95584) "*r"])
#@189 Change the case of F90 keywords in the region (if specified) or buffer.
CHANGE-WORD should be one of `upcase-word', `downcase-word', `capitalize-word'.
(fn CHANGE-WORD &optional BEG END)
(defalias 'f90-change-keywords #[769 "\212\206 e\262\211\206
d\262\304\305 \305\n\305 \306\260 e\307 C\310\211\211b\210\311\312\313\314\315!\316\"\317$\216\320\321#\205\203 \322`\"\262\3238\2042 \3248\2042 \212\325 \210\326\310w\210\327\330!)\2042 `\262\212\331\332!\210`)\262\211{\262\333!\210{\230\2042 \321\240\210\2022 )\266\206)\207" [f90-keywords-re f90-procedures-re f90-hpf-keywords-re f90-operators-re "\\(" "\\|" "\\)" buffer-modified-p nil make-byte-code 0 "\300\242\206 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 re-search-forward t parse-partial-sexp 3 4 beginning-of-line " 0-9" looking-at "#" backward-word-strictly 1 -1] 15 (#$ . 95768)])
#@67 Function to use for `add-log-current-defun-function' in F90 mode.
(defalias 'f90-current-defun #[0 "\212\300 A@)\207" [f90-beginning-of-subprogram] 1 (#$ . 96669)])
#@239 Make the backslash character (\) be non-special in the current buffer.
With optional argument ALL, change the default for all present
and future F90 buffers. F90 mode normally treats backslash as an
escape character.
(fn &optional ALL)
(defalias 'f90-backslash-not-special #[256 "\300\301!\204\n \302\303!\210\304z\304\232\205 \211\204 \305\306\307 !!\210\310\304\311\"\207" [derived-mode-p f90-mode user-error "This function should only be used in F90 buffers" 92 set-syntax-table copy-syntax-table syntax-table modify-syntax-entry "."] 4 (#$ . 96841)])
(provide 'f90)
Zerion Mini Shell 1.0