;;; esope.el : quelques ajouts et modifications à fortran.el ;;; pour faire un Esope mode ;;; Stephane Gounand ;;; Version 0.0.0 (10 Octobre 1997) ;;; Usage: ;; This file (esope.el) should reside in you home directory ;; or in your load-path. ;; For example, uncomment and add in your Emacs configuration file (~/.emacs) : ;; (add-to-list 'load-path "/u2/gounand/emacs") ;; if esope.el resides in /u2/gounand/emacs/ ;; Then, uncomment the three following lines and put them in your ;; Emacs configuration file (~/.emacs) : ;; (setq auto-mode-alist (cons '("\\.eso\\'" . esope-mode) auto-mode-alist)) ;; (setq auto-mode-alist (cons '("\\.INC\\'" . esope-mode) auto-mode-alist)) ;; (autoload 'esope-mode "esope" "Esope mode" t nil) ;;; Todo: ;; * utiliser derived-mode plutot que de recopier fortran.el ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; fortran.el --- Fortran mode for GNU Emacs ;; Copyright (c) 1986, 1993, 1994, 1995, 1997 Free Software Foundation, Inc. ;; Author: Michael D. Prange ;; Maintainer: bug-fortran-mode@erl.mit.edu (Steve Gildea and others) ;; Version 1.30.6 (July 27, 1995) ;; Keywords: languages ;; This file is part of GNU Emacs. ;; GNU Emacs is free software; you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by ;; the Free Software Foundation; either version 2, or (at your option) ;; any later version. ;; GNU Emacs is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; GNU General Public License for more details. ;; You should have received a copy of the GNU General Public License ;; along with GNU Emacs; see the file COPYING. If not, write to the ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, ;; Boston, MA 02111-1307, USA. ;;; Commentary: ;; Fortran mode has been upgraded and is now maintained by Stephen A. Wood ;; (saw@cebaf.gov). It now will use either fixed format continuation line ;; markers (character in 6th column), or tab format continuation line style ;; (digit after a TAB character.) A auto-fill mode has been added to ;; automatically wrap fortran lines that get too long. ;; We acknowledge many contributions and valuable suggestions by ;; Lawrence R. Dodd, Ralf Fassel, Ralph Finch, Stephen Gildea, ;; Dr. Anil Gokhale, Ulrich Mueller, Mark Neale, Eric Prestemon, ;; Gary Sabot and Richard Stallman. ;; This file may be used with GNU Emacs version 18.xx if the following ;; variable and function substitutions are made. ;; Replace: ;; frame-width with screen-width ;; auto-fill-function with auto-fill-hook ;; comment-indent-function with comment-indent-hook ;; (setq unread-command-events (list c)) with (setq unread-command-char c) ;; Bugs to bug-fortran-mode@erl.mit.edu ;;; Code: (defconst esope-mode-version "version 0.0.0") (defgroup esope nil "Esope mode for Emacs" :group 'languages) (defgroup esope-indent nil "Indentation variables in Esope mode" :prefix "esope-" :group 'esope) (defgroup esope-comment nil "Comment-handling variables in Esope mode" :prefix "esope-" :group 'esope) ;;;###autoload (defcustom esope-tab-mode-default nil "*Default tabbing/carriage control style for empty files in Esope mode. A value of t specifies tab-digit style of continuation control. A value of nil specifies that continuation lines are marked with a character in column 6." :type 'boolean :group 'esope-indent) ;; Buffer local, used to display mode line. (defcustom esope-tab-mode-string nil "String to appear in mode line when TAB format mode is on." :type '(choice (const nil) string) :group 'esope-indent) (defcustom esope-do-indent 3 "*Extra indentation applied to DO blocks." :type 'integer :group 'esope-indent) (defcustom esope-if-indent 3 "*Extra indentation applied to IF blocks." :type 'integer :group 'esope-indent) (defcustom esope-structure-indent 3 "*Extra indentation applied to STRUCTURE, UNION, MAP and INTERFACE blocks." :type 'integer :group 'esope-indent) (defcustom esope-continuation-indent 5 "*Extra indentation applied to Esope continuation lines." :type 'integer :group 'esope-indent) (defcustom esope-comment-indent-style 'fixed "*nil forces comment lines not to be touched, 'fixed makes fixed comment indentation to `esope-comment-line-extra-indent' columns beyond `esope-minimum-statement-indent-fixed' (for `indent-tabs-mode' of nil) or `esope-minimum-statement-indent-tab' (for `indent-tabs-mode' of t), and 'relative indents to current Esope indentation plus `esope-comment-line-extra-indent'." :type '(radio (const nil) (const fixed) (const relative)) :group 'esope-indent) (defcustom esope-comment-line-extra-indent 0 "*Amount of extra indentation for text within full-line comments." :type 'integer :group 'esope-indent :group 'esope-comment) (defcustom comment-line-start nil "*Delimiter inserted to start new full-line comment." :type '(choice string (const nil)) :group 'esope-comment) (defcustom comment-line-start-skip nil "*Regexp to match the start of a full-line comment." :type '(choice string (const nil)) :group 'esope-comment) (defcustom esope-minimum-statement-indent-fixed 6 "*Minimum statement indentation for fixed format continuation style." :type 'integer :group 'esope-indent) (defcustom esope-minimum-statement-indent-tab (max tab-width 6) "*Minimum statement indentation for TAB format continuation style." :type 'integer :group 'esope-indent) ;; Note that this is documented in the v18 manuals as being a string ;; of length one rather than a single character. ;; The code in this file accepts either format for compatibility. (defcustom esope-comment-indent-char " " "*Single-character string inserted for Esope comment indentation. Normally a space." :type 'string :group 'esope-comment) (defcustom esope-line-number-indent 1 "*Maximum indentation for Esope line numbers. 5 means right-justify them within their five-column field." :type 'integer :group 'esope-indent) (defcustom esope-check-all-num-for-matching-do nil "*Non-nil causes all numbered lines to be treated as possible DO loop ends." :type 'boolean :group 'esope) (defcustom esope-blink-matching-if t "*Non-nil causes \\[esope-indent-line] on ENDIF statement to blink on matching IF. Also, from an ENDDO statement blink on matching DO [WHILE] statement." :type 'boolean :group 'esope) (defcustom esope-continuation-string "$" "*Single-character string used for Esope continuation lines. In fixed format continuation style, this character is inserted in column 6 by \\[esope-split-line] to begin a continuation line. Also, if \\[esope-indent-line] finds this at the beginning of a line, it will convert the line into a continuation line of the appropriate style. Normally $." :type 'string :group 'esope) (defcustom esope-comment-region "C" "*String inserted by \\[esope-comment-region]\ at start of each line in region." :type 'string :group 'esope-comment) (defcustom esope-electric-line-number t "*Non-nil causes line number digits to be moved to the correct column as\ typed." :type 'boolean :group 'esope) (defcustom esope-startup-message t "*Non-nil displays a startup message when Esope mode is first called." :type 'boolean :group 'esope) (defvar esope-column-ruler-fixed "0 4 6 10 20 30 40 50 60 70\n\ \[ ]|{ | | | | | | | | \ \| | | | |}\n" "*String displayed above current line by \\[esope-column-ruler]. This variable used in fixed format mode.") (defvar esope-column-ruler-tab "0 810 20 30 40 50 60 70\n\ \[ ]| { | | | | | | | | \ \| | | | |}\n" "*String displayed above current line by \\[esope-column-ruler]. This variable used in TAB format mode.") (defconst bug-esope-mode "bug-fortran-mode@erl.mit.edu" "Address of mailing list for Esope mode bugs.") (defvar esope-mode-syntax-table nil "Syntax table in use in Esope mode buffers.") (defvar esope-analyze-depth 100 "Number of lines to scan to determine whether to use fixed or TAB format\ style.") (defcustom esope-break-before-delimiters t "*Non-nil causes `esope-fill' to break lines before delimiters." :type 'boolean :group 'esope) (if esope-mode-syntax-table () (setq esope-mode-syntax-table (make-syntax-table)) (modify-syntax-entry ?\; "w" esope-mode-syntax-table) (modify-syntax-entry ?\r " " esope-mode-syntax-table) (modify-syntax-entry ?+ "." esope-mode-syntax-table) (modify-syntax-entry ?- "." esope-mode-syntax-table) (modify-syntax-entry ?= "." esope-mode-syntax-table) (modify-syntax-entry ?* "." esope-mode-syntax-table) (modify-syntax-entry ?/ "." esope-mode-syntax-table) (modify-syntax-entry ?\' "\"" esope-mode-syntax-table) (modify-syntax-entry ?\" "\"" esope-mode-syntax-table) (modify-syntax-entry ?\\ "/" esope-mode-syntax-table) (modify-syntax-entry ?. "w" esope-mode-syntax-table) (modify-syntax-entry ?_ "w" esope-mode-syntax-table) (modify-syntax-entry ?\! "<" esope-mode-syntax-table) (modify-syntax-entry ?\n ">" esope-mode-syntax-table)) ;; Comments are real pain in Esope because there is no way to represent the ;; standard comment syntax in an Emacs syntax table (we can for VAX-style). ;; Therefore an unmatched quote in a standard comment will throw fontification ;; off on the wrong track. So we do syntactic fontification with regexps. ;; Regexps done by simon@gnu with help from Ulrik Dickow and ;; probably others Si's forgotten about (sorry). (defconst esope-font-lock-keywords-1 nil "Subdued level highlighting for Esope mode.") (defconst esope-font-lock-keywords-2 nil "Medium level highlighting for Esope mode.") (defconst esope-font-lock-keywords-3 nil "Gaudy level highlighting for Esope mode.") (let ((comment-chars "c!*") (esope-type-types ; (make-regexp ; (let ((simple-types '("character" "byte" "integer" "logical" ; "none" "real" "complex" ; "double[ \t]*precision" "double[ \t]*complex")) ;;;;; Modified **** ; (structured-types '("structure" "union" "map" "segment")) ; (other-types '("record" "dimension" "parameter" "common" "save" ; "external" "intrinsic" "data" "equivalence"))) ;;;;; Modified **** ; (append ; (mapcar (lambda (x) (concat "implicit[ \t]*" x)) simple-types) ; simple-types ; (mapcar (lambda (x) (concat "end[ \t]*" x)) structured-types) ; structured-types ; other-types))) (concat "byte\\|c\\(haracter\\|om\\(mon\\|plex\\)\\)\\|" "d\\(ata\\|imension\\|ouble" "[ \t]*\\(complex\\|precision\\)\\)\\|" "e\\(nd[ \t]*\\(map\\|segment\\|structure\\|union\\)\\|" "quivalence\\|xternal\\)\\|" "i\\(mplicit[ \t]*\\(byte\\|" "c\\(haracter\\|omplex\\)\\|" "double[ \t]*\\(complex\\|precision\\)\\|" "integer\\|logical\\|none\\|real\\)\\|" "nt\\(eger\\|rinsic\\)\\)\\|" "logical\\|map\\|none\\|parameter\\|re\\(al\\|cord\\)\\|" "s\\(ave\\|egment\\|tructure\\)\\|union")) (esope-keywords ; ("continue" "format" "end" "enddo" "if" "then" "else" "endif" ; "elseif" "while" "inquire" "stop" "return" "include" "open" ; "close" "read" "write" "format" "print") (concat "c\\(lose\\|ontinue\\)\\|" "e\\(lse\\(\\|if\\)\\|nd\\(\\|do\\|if\\)\\)\\|format\\|" "i\\(f\\|n\\(clude\\|quire\\)\\)\\|open\\|print\\|" "re\\(ad\\|turn\\)\\|stop\\|then\\|w\\(hile\\|rite\\)")) (esope-logicals ; ("and" "or" "not" "lt" "le" "eq" "ge" "gt" "ne" "true" "false") "and\\|eq\\|false\\|g[et]\\|l[et]\\|n\\(e\\|ot\\)\\|or\\|true")) (setq esope-font-lock-keywords-1 (list ;; ;; Fontify syntactically (assuming strings cannot be quoted or span lines). (cons (concat "^[" comment-chars "].*") 'font-lock-comment-face) '(esope-match-!-comment . font-lock-comment-face) (list (concat "^[^" comment-chars "\t\n]" (make-string 71 ?.) "\\(.*\\)") '(1 font-lock-comment-face)) '("'[^'\n]*'?" . font-lock-string-face) ;; ;; Program, subroutine and function declarations, plus calls. (list (concat "\\<\\(block[ \t]*data\\|call\\|entry\\|function\\|" "program\\|subroutine\\)\\>[ \t]*\\(\\sw+\\)?") '(1 font-lock-keyword-face) '(2 font-lock-function-name-face nil t)) ;; ;; Ajouts ESOPE ;; ; (list (concat "\\<\\(inc" (list (concat "\\(^-inc" "\\)\\>[ \t]*\\(\\sw+\\)?") '(1 font-lock-builtin-face) '(2 font-lock-string-face nil t)) (list (concat "\\<\\(pointeur\\|segact\\|segdes\\|" "segini\\|segsup\\)\\>[ \t]*\\(\\sw+\\)?") '(1 font-lock-builtin-face) '(2 font-lock-variable-name-face nil t)) (list (concat "\\<\\(segadj\\|" "segprt\\)\\>[ \t]*\\(\\sw+\\)?") '(1 font-lock-warning-face) '(2 font-lock-variable-name-face nil t)) )) (setq esope-font-lock-keywords-2 (append esope-font-lock-keywords-1 (list ;; ;; Fontify all type specifiers (must be first; see below). (cons (concat "\\<\\(" esope-type-types "\\)\\>") 'font-lock-type-face) ;; ;; Fontify all builtin keywords (except logical, do and goto; see below). (concat "\\<\\(" esope-keywords "\\)\\>") ;; ;; Fontify all builtin operators. (concat "\\.\\(" esope-logicals "\\)\\.") ;; ;; Fontify do/goto keywords and targets, and goto tags. (list "\\<\\(do\\|go *to\\)\\>[ \t]*\\([0-9]+\\)?" '(1 font-lock-keyword-face) '(2 font-lock-reference-face nil t)) (cons "^ *\\([0-9]+\\)" 'font-lock-reference-face)))) (setq esope-font-lock-keywords-3 (append ;; ;; The list `esope-font-lock-keywords-1'. esope-font-lock-keywords-1 ;; ;; Fontify all type specifiers plus their declared items. (list (list (concat "\\<\\(" esope-type-types "\\)\\>[ \t(/]*\\(*\\)?") ;; Fontify the type specifier. '(1 font-lock-type-face) ;; Fontify each declaration item (or just the /.../ block name). '(font-lock-match-c-style-declaration-item-and-skip-to-next ;; Start after any *(...) expression. (and (match-beginning 15) (forward-sexp 1)) ;; No need to clean up. nil ;; Fontify as a variable name, functions are fontified elsewhere. (1 font-lock-variable-name-face nil t)))) ;; ;; Things extra to `esope-font-lock-keywords-3' (must be done first). (list ;; ;; Fontify goto-like `err=label'/`end=label' in read/write statements. '(", *\\(e\\(nd\\|rr\\)\\)\\> *\\(= *\\([0-9]+\\)\\)?" (1 font-lock-keyword-face) (4 font-lock-reference-face nil t)) ;; ;; Highlight standard continuation character and in a TAB-formatted line. '("^ \\([^ 0]\\)" 1 font-lock-string-face) '("^\t\\([1-9]\\)" 1 font-lock-string-face)) ;; ;; The list `esope-font-lock-keywords-2' less that for types (see above). (cdr (nthcdr (length esope-font-lock-keywords-1) esope-font-lock-keywords-2)))) ) (defvar esope-font-lock-keywords esope-font-lock-keywords-1 "Default expressions to highlight in Esope mode.") (defvar esope-mode-map () "Keymap used in Esope mode.") (if esope-mode-map () (setq esope-mode-map (make-sparse-keymap)) (define-key esope-mode-map ";" 'esope-abbrev-start) (define-key esope-mode-map "\C-c;" 'esope-comment-region) (define-key esope-mode-map "\e\C-a" 'beginning-of-esope-subprogram) (define-key esope-mode-map "\e\C-e" 'end-of-esope-subprogram) (define-key esope-mode-map "\e;" 'esope-indent-comment) (define-key esope-mode-map "\e\C-h" 'mark-esope-subprogram) (define-key esope-mode-map "\e\n" 'esope-split-line) (define-key esope-mode-map "\n" 'esope-indent-new-line) (define-key esope-mode-map "\e\C-q" 'esope-indent-subprogram) (define-key esope-mode-map "\C-c\C-w" 'esope-window-create-momentarily) (define-key esope-mode-map "\C-c\C-r" 'esope-column-ruler) (define-key esope-mode-map "\C-c\C-p" 'esope-previous-statement) (define-key esope-mode-map "\C-c\C-n" 'esope-next-statement) (define-key esope-mode-map "\t" 'esope-indent-line) (define-key esope-mode-map "0" 'esope-electric-line-number) (define-key esope-mode-map "1" 'esope-electric-line-number) (define-key esope-mode-map "2" 'esope-electric-line-number) (define-key esope-mode-map "3" 'esope-electric-line-number) (define-key esope-mode-map "4" 'esope-electric-line-number) (define-key esope-mode-map "5" 'esope-electric-line-number) (define-key esope-mode-map "6" 'esope-electric-line-number) (define-key esope-mode-map "7" 'esope-electric-line-number) (define-key esope-mode-map "8" 'esope-electric-line-number) (define-key esope-mode-map "9" 'esope-electric-line-number)) (defvar esope-mode-abbrev-table nil) (if esope-mode-abbrev-table () (let ((ac abbrevs-changed)) (define-abbrev-table 'esope-mode-abbrev-table ()) (define-abbrev esope-mode-abbrev-table ";a" ".and." nil) ; (define-abbrev esope-mode-abbrev-table ";au" "automatic" nil) ; (define-abbrev esope-mode-abbrev-table ";b" "byte" nil) ; (define-abbrev esope-mode-abbrev-table ";bd" "block data" nil) (define-abbrev esope-mode-abbrev-table ";ch" "character" nil) (define-abbrev esope-mode-abbrev-table ";c4" "character*4" nil) (define-abbrev esope-mode-abbrev-table ";c8" "character*8" nil) ; (define-abbrev esope-mode-abbrev-table ";cl" "close" nil) (define-abbrev esope-mode-abbrev-table ";c" "continue" nil) (define-abbrev esope-mode-abbrev-table ";co" "continue" nil) ; (define-abbrev esope-mode-abbrev-table ";cm" "common" nil) ; (define-abbrev esope-mode-abbrev-table ";cx" "complex" nil) ; (define-abbrev esope-mode-abbrev-table ";df" "define" nil) ; (define-abbrev esope-mode-abbrev-table ";di" "dimension" nil) ; (define-abbrev esope-mode-abbrev-table ";do" "double" nil) ; (define-abbrev esope-mode-abbrev-table ";dc" "double complex" nil) ; (define-abbrev esope-mode-abbrev-table ";dp" "double precision" nil) ; (define-abbrev esope-mode-abbrev-table ";dw" "do while" nil) (define-abbrev esope-mode-abbrev-table ";e" "else" nil) (define-abbrev esope-mode-abbrev-table ";ed" "enddo" nil) (define-abbrev esope-mode-abbrev-table ";el" "elseif" nil) (define-abbrev esope-mode-abbrev-table ";en" "endif" nil) ; (define-abbrev esope-mode-abbrev-table ";eq" "equivalence" nil) ; (define-abbrev esope-mode-abbrev-table ";ew" "endwhere" nil) (define-abbrev esope-mode-abbrev-table ";ex" "external" nil) ; (define-abbrev esope-mode-abbrev-table ";ey" "entry" nil) (define-abbrev esope-mode-abbrev-table ";f" "format" nil) (define-abbrev esope-mode-abbrev-table ";fa" ".false." nil) (define-abbrev esope-mode-abbrev-table ";fu" "function" nil) (define-abbrev esope-mode-abbrev-table ";g" "goto" nil) (define-abbrev esope-mode-abbrev-table ";i9" "if (iret.ne.0) GOTO 9999" nil) (define-abbrev esope-mode-abbrev-table ";if" "" 'esope-skeleton-if-endif) (define-abbrev esope-mode-abbrev-table ";ife" "" 'esope-skeleton-if-else-endif) (define-abbrev esope-mode-abbrev-table ";im" "implicit" nil) ; (define-abbrev esope-mode-abbrev-table ";ib" "implicit byte" nil) ; (define-abbrev esope-mode-abbrev-table ";ic" "implicit complex" nil) ; (define-abbrev esope-mode-abbrev-table ";ich" "implicit character" nil) ; (define-abbrev esope-mode-abbrev-table ";ii" "implicit integer" nil) ; (define-abbrev esope-mode-abbrev-table ";il" "implicit logical" nil) (define-abbrev esope-mode-abbrev-table ";ir" "implicit real" nil) (define-abbrev esope-mode-abbrev-table ";i8" "implicit real*8 (a-h,o-z)" nil) (define-abbrev esope-mode-abbrev-table ";inc" "-INC" nil) (define-abbrev esope-mode-abbrev-table ";in" "integer" nil) (define-abbrev esope-mode-abbrev-table ";intr" "intrinsic" nil) (define-abbrev esope-mode-abbrev-table ";l" "logical" nil) ; (define-abbrev esope-mode-abbrev-table ";n" "namelist" nil) (define-abbrev esope-mode-abbrev-table ";n" ".not." nil) ; (define-abbrev esope-mode-abbrev-table ";o" "open" nil) ; was ;op (define-abbrev esope-mode-abbrev-table ";o" ".or." nil) ; was ;op (define-abbrev esope-mode-abbrev-table ";p" "parameter" nil) (define-abbrev esope-mode-abbrev-table ";pa" "parameter" nil) (define-abbrev esope-mode-abbrev-table ";pr" "program" nil) (define-abbrev esope-mode-abbrev-table ";ps" "pause" nil) ; (define-abbrev esope-mode-abbrev-table ";p" "print" nil) ; (define-abbrev esope-mode-abbrev-table ";rc" "record" nil) (define-abbrev esope-mode-abbrev-table ";re" "real" nil) (define-abbrev esope-mode-abbrev-table ";r8" "real*8" nil) ; (define-abbrev esope-mode-abbrev-table ";r" "read" nil) (define-abbrev esope-mode-abbrev-table ";r" "return" nil) (define-abbrev esope-mode-abbrev-table ";rt" "return" nil) ; (define-abbrev esope-mode-abbrev-table ";rw" "rewind" nil) ; (define-abbrev esope-mode-abbrev-table ";s" "stop" nil) ;; (define-abbrev esope-mode-abbrev-table ";sa" "save" nil) (define-abbrev esope-mode-abbrev-table ";sa" "segact" nil) (define-abbrev esope-mode-abbrev-table ";sd" "segdes" nil) (define-abbrev esope-mode-abbrev-table ";sj" "segadj" nil) (define-abbrev esope-mode-abbrev-table ";si" "segini" nil) (define-abbrev esope-mode-abbrev-table ";ss" "segsup" nil) ; (define-abbrev esope-mode-abbrev-table ";st" "structure" nil) ; (define-abbrev esope-mode-abbrev-table ";sc" "static" nil) (define-abbrev esope-mode-abbrev-table ";su" "subroutine" nil) (define-abbrev esope-mode-abbrev-table ";tr" ".true." nil) ; (define-abbrev esope-mode-abbrev-table ";ty" "type" nil) ; (define-abbrev esope-mode-abbrev-table ";vo" "volatile" nil) (define-abbrev esope-mode-abbrev-table ";w" "write" nil) (define-abbrev esope-mode-abbrev-table ";wi" "write(ioimp,*)" nil) ; (define-abbrev esope-mode-abbrev-table ";wh" "where" nil) (setq abbrevs-changed ac))) ; (define-skeleton esope-skeleton-if-endif "Insert an if - endif region" nil >"IF (" _ ") THEN"\n -3"ENDIF") (define-skeleton esope-skeleton-if-else-endif "Insert an if - else - endif region" nil >"IF (" _ ") THEN"\n -3"ELSE" \n -3"ENDIF") (setq skeleton-end-hook nil) ;;;###autoload (defun esope-mode () "Major mode for editing Esope code. \\[esope-indent-line] indents the current Esope line correctly. DO statements must not share a common CONTINUE. Type ;? or ;\\[help-command] to display a list of built-in\ abbrevs for Esope keywords. Key definitions: \\{esope-mode-map} Variables controlling indentation style and extra features: comment-start Normally nil in Esope mode. If you want to use comments starting with `!', set this to the string \"!\". esope-do-indent Extra indentation within do blocks. (default 3) esope-if-indent Extra indentation within if blocks. (default 3) esope-structure-indent Extra indentation within structure, union, map and interface blocks. (default 3) esope-continuation-indent Extra indentation applied to continuation statements. (default 5) esope-comment-line-extra-indent Amount of extra indentation for text within full-line comments. (default 0) esope-comment-indent-style nil means don't change indentation of text in full-line comments, fixed means indent that text at `esope-comment-line-extra-indent' beyond the value of `esope-minimum-statement-indent-fixed' (for fixed format continuation style) or `esope-minimum-statement-indent-tab' (for TAB format continuation style). relative means indent at `esope-comment-line-extra-indent' beyond the indentation for a line of code. (default 'fixed) esope-comment-indent-char Single-character string to be inserted instead of space for full-line comment indentation. (default \" \") esope-minimum-statement-indent-fixed Minimum indentation for Esope statements in fixed format mode. (def.6) esope-minimum-statement-indent-tab Minimum indentation for Esope statements in TAB format mode. (default 9) esope-line-number-indent Maximum indentation for line numbers. A line number will get less than this much indentation if necessary to avoid reaching column 5. (default 1) esope-check-all-num-for-matching-do Non-nil causes all numbered lines to be treated as possible \"continue\" statements. (default nil) esope-blink-matching-if Non-nil causes \\[esope-indent-line] on an ENDIF statement to blink on matching IF. Also, from an ENDDO statement, blink on matching DO [WHILE] statement. (default t) esope-continuation-string Single-character string to be inserted in column 5 of a continuation line. (default \"$\") esope-comment-region String inserted by \\[esope-comment-region] at start of each line in region. (default \"C\") esope-electric-line-number Non-nil causes line number digits to be moved to the correct column as typed. (default t) esope-break-before-delimiters Non-nil causes `esope-fill' breaks lines before delimiters. (default t) esope-startup-message Set to nil to inhibit message first time Esope mode is used. Turning on Esope mode calls the value of the variable `esope-mode-hook' with no args, if that value is non-nil." (interactive) (kill-all-local-variables) (if esope-startup-message (message "Emacs Esope mode %s. Bugs to %s" esope-mode-version bug-esope-mode)) (setq esope-startup-message nil) (setq local-abbrev-table esope-mode-abbrev-table) (set-syntax-table esope-mode-syntax-table) ;; Font Lock mode support. (make-local-variable 'font-lock-defaults) (setq font-lock-defaults '((esope-font-lock-keywords esope-font-lock-keywords-1 esope-font-lock-keywords-2 esope-font-lock-keywords-3) t t ((?/ . "$/")))) (make-local-variable 'esope-break-before-delimiters) (setq esope-break-before-delimiters t) (make-local-variable 'indent-line-function) (setq indent-line-function 'esope-indent-line) (make-local-variable 'comment-indent-function) (setq comment-indent-function 'esope-comment-hook) (make-local-variable 'comment-line-start-skip) ;;; Modif pour ne pas toucher aux lignes de commentaires ;;; lors de l'indentation automatique (en particulier pour ;;; la première ligne (version du .eso) (setq comment-line-start-skip "^[Cc*#].*\\|^-inc.*") ;;; "^[Cc*]\\(\\([^ \t\n]\\)\\2\\2*\\)?[ \t]*\\|^#.*\\|^-inc.*") (make-local-variable 'comment-line-start) (setq comment-line-start "C") (make-local-variable 'comment-start-skip) (setq comment-start-skip "![ \t]*") (make-local-variable 'comment-start) (setq comment-start nil) (make-local-variable 'require-final-newline) (setq require-final-newline t) (make-local-variable 'abbrev-all-caps) (setq abbrev-all-caps t) (make-local-variable 'indent-tabs-mode) (setq indent-tabs-mode nil) ;;;(setq abbrev-mode t) ; ?? (abbrev-mode 1) instead?? (setq fill-column 72) ; Already local? (use-local-map esope-mode-map) (setq mode-name "Esope") (setq major-mode 'esope-mode) ;;;(make-local-variable 'esope-tab-mode) (make-local-variable 'esope-comment-line-extra-indent) (make-local-variable 'esope-minimum-statement-indent-fixed) (make-local-variable 'esope-minimum-statement-indent-tab) (make-local-variable 'esope-column-ruler-fixed) (make-local-variable 'esope-column-ruler-tab) (make-local-variable 'esope-tab-mode-string) (setq esope-tab-mode-string " TAB-format") (setq indent-tabs-mode (esope-analyze-file-format)) (run-hooks 'esope-mode-hook)) (defun esope-comment-hook () (save-excursion (skip-chars-backward " \t") (max (+ 1 (current-column)) comment-column))) (defun esope-indent-comment () "Align or create comment on current line. Existing comments of all types are recognized and aligned. If the line has no comment, a side-by-side comment is inserted and aligned if the value of comment-start is not nil. Otherwise, a separate-line comment is inserted, on this line or on a new line inserted before this line if this line is not blank." (interactive) (beginning-of-line) ;; Recognize existing comments of either kind. (cond ((looking-at comment-line-start-skip) (esope-indent-line)) ((esope-find-comment-start-skip) ; catches any inline comment and ; leaves point after comment-start-skip (if comment-start-skip (progn (goto-char (match-beginning 0)) (if (not (= (current-column) (esope-comment-hook))) (progn (delete-horizontal-space) (indent-to (esope-comment-hook))))) (end-of-line))) ; otherwise goto end of line or sth else? ;; No existing comment. ;; If side-by-side comments are defined, insert one, ;; unless line is now blank. ((and comment-start (not (looking-at "^[ \t]*$"))) (end-of-line) (delete-horizontal-space) (indent-to (esope-comment-hook)) (insert comment-start)) ;; Else insert separate-line comment, making a new line if nec. (t (if (looking-at "^[ \t]*$") (delete-horizontal-space) (beginning-of-line) (insert "\n") (forward-char -1)) (insert comment-line-start) (insert-char (if (stringp esope-comment-indent-char) (aref esope-comment-indent-char 0) esope-comment-indent-char) (- (calculate-esope-indent) (current-column)))))) (defun esope-comment-region (beg-region end-region arg) "Comments every line in the region. Puts esope-comment-region at the beginning of every line in the region. BEG-REGION and END-REGION are args which specify the region boundaries. With non-nil ARG, uncomments the region." (interactive "*r\nP") (let ((end-region-mark (make-marker)) (save-point (point-marker))) (set-marker end-region-mark end-region) (goto-char beg-region) (beginning-of-line) (if (not arg) ;comment the region (progn (insert esope-comment-region) (while (and (= (forward-line 1) 0) (< (point) end-region-mark)) (insert esope-comment-region))) (let ((com (regexp-quote esope-comment-region))) ;uncomment the region (if (looking-at com) (delete-region (point) (match-end 0))) (while (and (= (forward-line 1) 0) (< (point) end-region-mark)) (if (looking-at com) (delete-region (point) (match-end 0)))))) (goto-char save-point) (set-marker end-region-mark nil) (set-marker save-point nil))) (defun esope-abbrev-start () "Typing ;\\[help-command] or ;? lists all the Esope abbrevs. Any other key combination is executed normally." (interactive) (let (c) (insert last-command-char) (if (or (eq (setq c (read-event)) ??) ;insert char if not equal to `?' (eq c help-char)) (esope-abbrev-help) (setq unread-command-events (list c))))) (defun esope-abbrev-help () "List the currently defined abbrevs in Esope mode." (interactive) (message "Listing abbrev table...") (display-buffer (esope-prepare-abbrev-list-buffer)) (message "Listing abbrev table...done")) (defun esope-prepare-abbrev-list-buffer () (save-excursion (set-buffer (get-buffer-create "*Abbrevs*")) (erase-buffer) (insert-abbrev-table-description 'esope-mode-abbrev-table t) (goto-char (point-min)) (set-buffer-modified-p nil) (edit-abbrevs-mode)) (get-buffer-create "*Abbrevs*")) (defun esope-column-ruler () "Inserts a column ruler momentarily above current line, till next keystroke. The ruler is defined by the value of `esope-column-ruler-fixed' when in fixed format mode, and `esope-column-ruler-tab' when in TAB format mode. The key typed is executed unless it is SPC." (interactive) (momentary-string-display (if indent-tabs-mode esope-column-ruler-tab esope-column-ruler-fixed) (save-excursion (beginning-of-line) (if (eq (window-start (selected-window)) (window-point (selected-window))) (progn (forward-line) (point)) (point))) nil "Type SPC or any command to erase ruler.")) (defun esope-window-create () "Makes the window 72 columns wide. See also `esope-window-create-momentarily'." (interactive) (condition-case error (progn (let ((window-min-width 2)) (if (< (window-width) (frame-width)) (enlarge-window-horizontally (- (frame-width) (window-width) 1))) (split-window-horizontally 73) (other-window 1) (switch-to-buffer " esope-window-extra" t) (select-window (previous-window)))) (error (message "No room for Esope window.") 'error))) (defun esope-window-create-momentarily (&optional arg) "Momentarily makes the window 72 columns wide. Optional ARG non-nil and non-unity disables the momentary feature. See also `esope-window-create'." (interactive "p") (if (or (not arg) (= arg 1)) (save-window-excursion (if (not (equal (esope-window-create) 'error)) (progn (message "Type SPC to continue editing.") (let ((char (read-event))) (or (equal char (string-to-char " ")) (setq unread-command-events (list char))))))) (esope-window-create))) (defun esope-split-line () "Break line at point and insert continuation marker and alignment." (interactive) (delete-horizontal-space) (if (save-excursion (beginning-of-line) (looking-at comment-line-start-skip)) (insert "\n" comment-line-start " ") (if indent-tabs-mode (progn (insert "\n\t") (insert-char (esope-numerical-continuation-char) 1)) (insert "\n " esope-continuation-string)));Space after \n important (esope-indent-line)) ;when the cont string is C, c or *. (defun esope-numerical-continuation-char () "Return a digit for tab-digit style of continuation lines. If, previous line is a tab-digit continuation line, returns that digit plus one. Otherwise return 1. Zero not allowed." (save-excursion (forward-line -1) (if (looking-at "\t[1-9]") (+ ?1 (% (- (char-after (+ (point) 1)) ?0) 9)) ?1))) (defun delete-horizontal-regexp (chars) "Delete all characters in CHARS around point. CHARS is like the inside of a [...] in a regular expression except that ] is never special and \ quotes ^, - or \." (interactive "*s") (skip-chars-backward chars) (delete-region (point) (progn (skip-chars-forward chars) (point)))) (defun esope-electric-line-number (arg) "Self insert, but if part of a Esope line number indent it automatically. Auto-indent does not happen if a numeric arg is used." (interactive "P") (if (or arg (not esope-electric-line-number)) (if arg (self-insert-command (prefix-numeric-value arg)) (self-insert-command 1)) (if (or (and (= 5 (current-column)) (save-excursion (beginning-of-line) (looking-at " ")));In col 5 with only spaces to left. (and (= (if indent-tabs-mode esope-minimum-statement-indent-tab esope-minimum-statement-indent-fixed) (current-column)) (save-excursion (beginning-of-line) (looking-at "\t"));In col 8 with a single tab to the left. (not (or (eq last-command 'esope-indent-line) (eq last-command 'esope-indent-new-line)))) (save-excursion (re-search-backward "[^ \t0-9]" (save-excursion (beginning-of-line) (point)) t)) ;not a line number (looking-at "[0-9]") ;within a line number ) (self-insert-command (prefix-numeric-value arg)) (skip-chars-backward " \t") (insert last-command-char) (esope-indent-line)))) (defun beginning-of-esope-subprogram () "Moves point to the beginning of the current Esope subprogram." (interactive) (let ((case-fold-search t)) (beginning-of-line -1) (re-search-backward "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]" nil 'move) ; Ligne suivante modifiée : but : ne pas indenter la première ligne du .eso ! ; (if (looking-at "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]") ; (forward-line 1)))) (forward-line 1))) (defun end-of-esope-subprogram () "Moves point to the end of the current Esope subprogram." (interactive) (let ((case-fold-search t)) (beginning-of-line 2) (re-search-forward "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]" nil 'move) (goto-char (match-beginning 0)) (forward-line 1))) (defun mark-esope-subprogram () "Put mark at end of Esope subprogram, point at beginning. The marks are pushed." (interactive) (end-of-esope-subprogram) (push-mark (point)) (beginning-of-esope-subprogram)) (defun esope-previous-statement () "Moves point to beginning of the previous Esope statement. Returns `first-statement' if that statement is the first non-comment Esope statement in the file, and nil otherwise." (interactive) (let (not-first-statement continue-test) (beginning-of-line) (setq continue-test (and (not (looking-at comment-line-start-skip)) (or (looking-at (concat "[ \t]*" (regexp-quote esope-continuation-string))) (or (looking-at " [^ 0\n]") (looking-at "\t[1-9]"))))) (while (and (setq not-first-statement (= (forward-line -1) 0)) (or (looking-at comment-line-start-skip) (looking-at "[ \t]*$") (looking-at " [^ 0\n]") (looking-at "\t[1-9]") (looking-at (concat "[ \t]*" comment-start-skip))))) (cond ((and continue-test (not not-first-statement)) (message "Incomplete continuation statement.")) (continue-test (esope-previous-statement)) ((not not-first-statement) 'first-statement)))) (defun esope-next-statement () "Moves point to beginning of the next Esope statement. Returns `last-statement' if that statement is the last non-comment Esope statement in the file, and nil otherwise." (interactive) (let (not-last-statement) (beginning-of-line) (while (and (setq not-last-statement (and (= (forward-line 1) 0) (not (eobp)))) (or (looking-at comment-line-start-skip) (looking-at "[ \t]*$") (looking-at " [^ 0\n]") (looking-at "\t[1-9]") (looking-at (concat "[ \t]*" comment-start-skip))))) (if (not not-last-statement) 'last-statement))) (defun esope-blink-matching-if () ;; From a Esope ENDIF statement, blink the matching IF statement. (let ((top-of-window (window-start)) matching-if (endif-point (point)) message) (if (save-excursion (beginning-of-line) (skip-chars-forward " \t0-9") (looking-at "end[ \t]*if\\b")) (progn (if (not (setq matching-if (esope-beginning-if))) (setq message "No matching if.") (if (< matching-if top-of-window) (save-excursion (goto-char matching-if) (beginning-of-line) (setq message (concat "Matches " (buffer-substring (point) (progn (end-of-line) (point)))))))) (if message (message "%s" message) (goto-char matching-if) (sit-for 1) (goto-char endif-point)))))) (defun esope-blink-matching-do () ;; From a Esope ENDDO statement, blink on the matching DO or DO WHILE ;; statement. This is basically copied from esope-blink-matching-if. (let ((top-of-window (window-start)) matching-do (enddo-point (point)) message) (if (save-excursion (beginning-of-line) (skip-chars-forward " \t0-9") (looking-at "end[ \t]*do\\b")) (progn (if (not (setq matching-do (esope-beginning-do))) (setq message "No matching do.") (if (< matching-do top-of-window) (save-excursion (goto-char matching-do) (beginning-of-line) (setq message (concat "Matches " (buffer-substring (point) (progn (end-of-line) (point)))))))) (if message (message "%s" message) (goto-char matching-do) (sit-for 1) (goto-char enddo-point)))))) (defun esope-mark-do () "Put mark at end of Esope DO [WHILE]-ENDDO construct, point at beginning. The marks are pushed." (interactive) (let (enddo-point do-point) (if (setq enddo-point (esope-end-do)) (if (not (setq do-point (esope-beginning-do))) (message "No matching do.") ;; Set mark, move point. (goto-char enddo-point) (push-mark) (goto-char do-point))))) (defun esope-end-do () ;; Search forward for first unmatched ENDDO. Return point or nil. (if (save-excursion (beginning-of-line) (skip-chars-forward " \t0-9") (looking-at "end[ \t]*do\\b")) ;; Sitting on one. (match-beginning 0) ;; Search for one. (save-excursion (let ((count 1)) (while (and (not (= count 0)) (not (eq (esope-next-statement) 'last-statement)) ;; Keep local to subprogram (not (looking-at "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]"))) (skip-chars-forward " \t0-9") (cond ((looking-at "end[ \t]*do\\b") (setq count (- count 1))) ((looking-at "do[ \t]+[^0-9]") (setq count (+ count 1))))) (and (= count 0) ;; All pairs accounted for. (point)))))) (defun esope-beginning-do () ;; Search backwards for first unmatched DO [WHILE]. Return point or nil. (if (save-excursion (beginning-of-line) (skip-chars-forward " \t0-9") (looking-at "do[ \t]+")) ;; Sitting on one. (match-beginning 0) ;; Search for one. (save-excursion (let ((count 1)) (while (and (not (= count 0)) (not (eq (esope-previous-statement) 'first-statement)) ;; Keep local to subprogram (not (looking-at "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]"))) (skip-chars-forward " \t0-9") (cond ((looking-at "do[ \t]+[^0-9]") (setq count (- count 1))) ((looking-at "end[ \t]*do\\b") (setq count (+ count 1))))) (and (= count 0) ;; All pairs accounted for. (point)))))) (defun esope-mark-if () "Put mark at end of Esope IF-ENDIF construct, point at beginning. The marks are pushed." (interactive) (let (endif-point if-point) (if (setq endif-point (esope-end-if)) (if (not (setq if-point (esope-beginning-if))) (message "No matching if.") ;; Set mark, move point. (goto-char endif-point) (push-mark) (goto-char if-point))))) (defun esope-end-if () ;; Search forwards for first unmatched ENDIF. Return point or nil. (if (save-excursion (beginning-of-line) (skip-chars-forward " \t0-9") (looking-at "end[ \t]*if\\b")) ;; Sitting on one. (match-beginning 0) ;; Search for one. The point has been already been moved to first ;; letter on line but this should not cause troubles. (save-excursion (let ((count 1)) (while (and (not (= count 0)) (not (eq (esope-next-statement) 'last-statement)) ;; Keep local to subprogram. (not (looking-at "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]"))) (skip-chars-forward " \t0-9") (cond ((looking-at "end[ \t]*if\\b") (setq count (- count 1))) ((looking-at "if[ \t]*(") (save-excursion (if (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]") (let (then-test) ; Multi-line if-then. (while (and (= (forward-line 1) 0) ;; Search forward for then. (or (looking-at " [^ 0\n]") (looking-at "\t[1-9]")) (not (setq then-test (looking-at ".*then\\b[ \t]*[^ \t(=a-z0-9]"))))) then-test)) (setq count (+ count 1))))))) (and (= count 0) ;; All pairs accounted for. (point)))))) (defun esope-beginning-if () ;; Search backwards for first unmatched IF-THEN. Return point or nil. (if (save-excursion ;; May be sitting on multi-line if-then statement, first move to ;; beginning of current statement. Note: `esope-previous-statement' ;; moves to previous statement *unless* current statement is first ;; one. Only move forward if not first-statement. (if (not (eq (esope-previous-statement) 'first-statement)) (esope-next-statement)) (skip-chars-forward " \t0-9") (and (looking-at "if[ \t]*(") (save-match-data (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]") ;; Multi-line if-then. (let (then-test) (while (and (= (forward-line 1) 0) ;; Search forward for then. (or (looking-at " [^ 0\n]") (looking-at "\t[1-9]")) (not (setq then-test (looking-at ".*then\\b[ \t]*[^ \t(=a-z0-9]"))))) then-test))))) ;; Sitting on one. (match-beginning 0) ;; Search for one. (save-excursion (let ((count 1)) (while (and (not (= count 0)) (not (eq (esope-previous-statement) 'first-statement)) ;; Keep local to subprogram. (not (looking-at "^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]"))) (skip-chars-forward " \t0-9") (cond ((looking-at "if[ \t]*(") (save-excursion (if (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t(=a-z0-9]") (let (then-test) ; Multi-line if-then. (while (and (= (forward-line 1) 0) ;; Search forward for then. (or (looking-at " [^ 0\n]") (looking-at "\t[1-9]")) (not (setq then-test (looking-at ".*then\\b[ \t]*[^ \t(=a-z0-9]"))))) then-test)) (setq count (- count 1))))) ((looking-at "end[ \t]*if\\b") (setq count (+ count 1))))) (and (= count 0) ;; All pairs accounted for. (point)))))) (defun esope-indent-line () "Indents current Esope line based on its contents and on previous lines." (interactive) (let ((cfi (calculate-esope-indent))) (save-excursion (beginning-of-line) (if (or (not (= cfi (esope-current-line-indentation))) (and (re-search-forward "^[ \t]*[0-9]+" (+ (point) 4) t) (not (esope-line-number-indented-correctly-p)))) (esope-indent-to-column cfi) (beginning-of-line) (if (and (not (looking-at comment-line-start-skip)) (esope-find-comment-start-skip)) (esope-indent-comment)))) ;; Never leave point in left margin. (if (< (current-column) cfi) (move-to-column cfi)) (if (and auto-fill-function (> (save-excursion (end-of-line) (current-column)) fill-column)) (save-excursion (end-of-line) (esope-fill))) (if esope-blink-matching-if (progn (esope-blink-matching-if) (esope-blink-matching-do))))) (defun esope-indent-new-line () "Reindent the current Esope line, insert a newline and indent the newline. An abbrev before point is expanded if `abbrev-mode' is non-nil." (interactive) (if abbrev-mode (expand-abbrev)) (save-excursion (beginning-of-line) (skip-chars-forward " \t") (if (or (looking-at "[0-9]") ;Reindent only where it is most (looking-at "end") ;likely to be necessary (looking-at "else") (looking-at (regexp-quote esope-continuation-string))) (esope-indent-line))) (newline) (esope-indent-line)) (defun esope-indent-subprogram () "Properly indents the Esope subprogram which contains point." (interactive) (save-excursion (mark-esope-subprogram) (message "Indenting subprogram...") (indent-region (point) (mark) nil)) (message "Indenting subprogram...done.")) (defun calculate-esope-indent () "Calculates the Esope indent column based on previous lines." (let (icol first-statement (case-fold-search t) (esope-minimum-statement-indent (if indent-tabs-mode esope-minimum-statement-indent-tab esope-minimum-statement-indent-fixed))) (save-excursion (setq first-statement (esope-previous-statement)) (if first-statement (setq icol esope-minimum-statement-indent) (progn (if (= (point) (point-min)) (setq icol esope-minimum-statement-indent) (setq icol (esope-current-line-indentation))) (skip-chars-forward " \t0-9") (cond ((looking-at "if[ \t]*(") (if (or (looking-at ".*)[ \t]*then\\b[ \t]*[^ \t_$(=a-z0-9]") (let (then-test) ;multi-line if-then (while (and (= (forward-line 1) 0) ;;search forward for then (or (looking-at " [^ 0\n]") (looking-at "\t[1-9]")) (not (setq then-test (looking-at ".*then\\b[ \t]\ *[^ \t_$(=a-z0-9]"))))) then-test)) (setq icol (+ icol esope-if-indent)))) ((looking-at "\\(else\\|elseif\\)\\b") (setq icol (+ icol esope-if-indent))) ((looking-at "select[ \t]*case[ \t](.*)\\b") (setq icol (+ icol esope-if-indent))) ((looking-at "case[ \t]*(.*)[ \t]*\n") (setq icol (+ icol esope-if-indent))) ((looking-at "case[ \t]*default\\b") (setq icol (+ icol esope-if-indent))) ((looking-at "\\(otherwise\\|else[ \t]*where\\)\\b") (setq icol (+ icol esope-if-indent))) ((looking-at "where[ \t]*(.*)[ \t]*\n") (setq icol (+ icol esope-if-indent))) ((looking-at "do\\b") (setq icol (+ icol esope-do-indent))) ((looking-at "\\(structure\\|union\\|map\\|interface\\)\\b[ \t]*[^ \t=(a-z]") (setq icol (+ icol esope-structure-indent))) ((looking-at "end\\b[ \t]*[^ \t=(a-z]") ;; Previous END resets indent to minimum (setq icol esope-minimum-statement-indent)))))) (save-excursion (beginning-of-line) (cond ((looking-at "[ \t]*$")) ((looking-at comment-line-start-skip) (cond ((eq esope-comment-indent-style 'relative) (setq icol (+ icol esope-comment-line-extra-indent))) ((eq esope-comment-indent-style 'fixed) (setq icol (+ esope-minimum-statement-indent esope-comment-line-extra-indent)))) (setq esope-minimum-statement-indent 0)) ((or (looking-at (concat "[ \t]*" (regexp-quote esope-continuation-string))) (looking-at " [^ 0\n]") (looking-at "\t[1-9]")) (setq icol (+ icol esope-continuation-indent))) ((looking-at "[ \t]*#") ; Check for cpp directive. (setq esope-minimum-statement-indent 0 icol 0)) (first-statement) ((and esope-check-all-num-for-matching-do (looking-at "[ \t]*[0-9]+") (esope-check-for-matching-do)) (setq icol (- icol esope-do-indent))) (t (skip-chars-forward " \t0-9") (cond ((looking-at "end[ \t]*if\\b") (setq icol (- icol esope-if-indent))) ((looking-at "\\(else\\|elseif\\)\\b") (setq icol (- icol esope-if-indent))) ((looking-at "case[ \t]*(.*)[ \t]*\n") (setq icol (- icol esope-if-indent))) ((looking-at "case[ \t]*default\\b") (setq icol (- icol esope-if-indent))) ((looking-at "\\(otherwise\\|else[ \t]*where\\)\\b") (setq icol (- icol esope-if-indent))) ((looking-at "end[ \t]*where\\b") (setq icol (- icol esope-if-indent))) ((and (looking-at "continue\\b") (esope-check-for-matching-do)) (setq icol (- icol esope-do-indent))) ((looking-at "end[ \t]*do\\b") (setq icol (- icol esope-do-indent))) ((looking-at "end[ \t]*\ \\(structure\\|union\\|map\\|interface\\)\\b[ \t]*[^ \t=(a-z]") (setq icol (- icol esope-structure-indent))) ((looking-at "end[ \t]*select\\b[ \t]*[^ \t=(a-z]") (setq icol (- icol esope-if-indent))) ((and (looking-at "end\\b[ \t]*[^ \t=(a-z]") (not (= icol esope-minimum-statement-indent))) (message "Warning: `end' not in column %d. Probably\ an unclosed block." esope-minimum-statement-indent)))))) (max esope-minimum-statement-indent icol))) (defun esope-current-line-indentation () "Indentation of current line, ignoring Esope line number or continuation. This is the column position of the first non-whitespace character aside from the line number and/or column 5/8 line-continuation character. For comment lines, returns indentation of the first non-indentation text within the comment." (save-excursion (beginning-of-line) (cond ((looking-at comment-line-start-skip) (goto-char (match-end 0)) (skip-chars-forward (if (stringp esope-comment-indent-char) esope-comment-indent-char (char-to-string esope-comment-indent-char)))) ((or (looking-at " [^ 0\n]") (looking-at "\t[1-9]")) (goto-char (match-end 0))) (t ;; Move past line number. (skip-chars-forward "[ \t0-9]");From Uli )) ;; Move past whitespace. (skip-chars-forward " \t") (current-column))) (defun esope-indent-to-column (col) "Indents current line with spaces to column COL. notes: 1) A non-zero/non-blank character in column 5 indicates a continuation line, and this continuation character is retained on indentation; 2) If `esope-continuation-string' is the first non-whitespace character, this is a continuation line; 3) A non-continuation line which has a number as the first non-whitespace character is a numbered line. 4) A TAB followed by a digit indicates a continuation line." (save-excursion (beginning-of-line) (if (looking-at comment-line-start-skip) (if esope-comment-indent-style (let ((char (if (stringp esope-comment-indent-char) (aref esope-comment-indent-char 0) esope-comment-indent-char))) (goto-char (match-end 0)) (delete-horizontal-regexp (concat " \t" (char-to-string char))) (insert-char char (- col (current-column))))) (if (looking-at "\t[1-9]") (if indent-tabs-mode (goto-char (match-end 0)) (delete-char 2) (insert " ") (insert esope-continuation-string)) (if (looking-at " [^ 0\n]") (if indent-tabs-mode (progn (delete-char 6) (insert "\t") (insert-char (esope-numerical-continuation-char) 1)) (forward-char 6)) (delete-horizontal-space) ;; Put line number in columns 0-4 ;; or put continuation character in column 5. (cond ((eobp)) ((looking-at (regexp-quote esope-continuation-string)) (if indent-tabs-mode (progn (indent-to (if indent-tabs-mode esope-minimum-statement-indent-tab esope-minimum-statement-indent-fixed)) (delete-char 1) (insert-char (esope-numerical-continuation-char) 1)) (indent-to 5) (forward-char 1))) ((looking-at "[0-9]+") (let ((extra-space (- 5 (- (match-end 0) (point))))) (if (< extra-space 0) (message "Warning: line number exceeds 5-digit limit.") (indent-to (min esope-line-number-indent extra-space)))) (skip-chars-forward "0-9"))))) ;; Point is now after any continuation character or line number. ;; Put body of statement where specified. (delete-horizontal-space) (indent-to col) ;; Indent any comment following code on the same line. (if (and comment-start-skip (esope-find-comment-start-skip)) (progn (goto-char (match-beginning 0)) (if (not (= (current-column) (esope-comment-hook))) (progn (delete-horizontal-space) (indent-to (esope-comment-hook))))))))) (defun esope-line-number-indented-correctly-p () "Return t if current line's line number is correctly indented. Do not call if there is no line number." (save-excursion (beginning-of-line) (skip-chars-forward " \t") (and (<= (current-column) esope-line-number-indent) (or (= (current-column) esope-line-number-indent) (progn (skip-chars-forward "0-9") (= (current-column) 5)))))) (defun esope-check-for-matching-do () "When called from a numbered statement, returns t if matching DO is found. Otherwise return a nil." (let (charnum (case-fold-search t)) (save-excursion (beginning-of-line) (if (looking-at "[ \t]*[0-9]+") (progn (skip-chars-forward " \t") (skip-chars-forward "0") ;skip past leading zeros (setq charnum (buffer-substring (point) (progn (skip-chars-forward "0-9") (point)))) (beginning-of-line) (and (re-search-backward (concat "\\(^[ \t0-9]*end\\b[ \t]*[^ \t=(a-z]\\)\\|" "\\(^[ \t0-9]*do[ \t]*0*" charnum "\\b\\)\\|" "\\(^[ \t]*0*" charnum "\\b\\)") nil t) (looking-at (concat "^[ \t0-9]*do[ \t]*0*" charnum)))))))) (defun esope-find-comment-start-skip () "Move to past `comment-start-skip' found on current line. Return t if `comment-start-skip' found, nil if not." ;;; In order to move point only if comment-start-skip is found, ;;; this one uses a lot of save-excursions. Note that re-search-forward ;;; moves point even if comment-start-skip is inside a string-constant. ;;; Some code expects certain values for match-beginning and end (interactive) (if (save-excursion (re-search-forward comment-start-skip (save-excursion (end-of-line) (point)) t)) (let ((save-match-beginning (match-beginning 0)) (save-match-end (match-end 0))) (if (esope-is-in-string-p (match-beginning 0)) (save-excursion (goto-char save-match-end) (esope-find-comment-start-skip)) ; recurse for rest of line (goto-char save-match-beginning) (re-search-forward comment-start-skip (save-excursion (end-of-line) (point)) t) (goto-char (match-end 0)) t)) nil)) ;;;From: simon@gnu (Simon Marshall) ;;; Find the next ! not in a string. (defun esope-match-!-comment (limit) (let (found) (while (and (setq found (search-forward "!" limit t)) (esope-is-in-string-p (point)))) (if (not found) nil ;; Cheaper than `looking-at' "!.*". (store-match-data (list (1- (point)) (progn (end-of-line) (min (point) limit)))) t))) ;; The above function is about 10% faster than the below... ;;(defun esope-match-!-comment (limit) ;; (let (found) ;; (while (and (setq found (re-search-forward "!.*" limit t)) ;; (esope-is-in-string-p (match-beginning 0)))) ;; found)) ;;;From: ralf@up3aud1.gwdg.de (Ralf Fassel) ;;; Test if TAB format continuation lines work. (defun esope-is-in-string-p (where) "Return non-nil if POS (a buffer position) is inside a Esope string, nil else." (save-excursion (goto-char where) (cond ((bolp) nil) ; bol is never inside a string ((save-excursion ; comment lines too (beginning-of-line)(looking-at comment-line-start-skip)) nil) (t (let (;; ok, serious now. Init some local vars: (parse-state '(0 nil nil nil nil nil 0)) (quoted-comment-start (if comment-start (regexp-quote comment-start))) (not-done t) parse-limit end-of-line ) ;; move to start of current statement (esope-next-statement) (esope-previous-statement) ;; now parse up to WHERE (while not-done (if (or ;; skip to next line if: ;; - comment line? (looking-at comment-line-start-skip) ;; - at end of line? (eolp) ;; - not in a string and after comment-start? (and (not (nth 3 parse-state)) comment-start (equal comment-start (char-to-string (preceding-char))))) ;; get around a bug in forward-line in versions <= 18.57 (if (or (> (forward-line 1) 0) (eobp)) (setq not-done nil)) ;; else: ;; if we are at beginning of code line, skip any ;; whitespace, labels and tab continuation markers. (if (bolp) (skip-chars-forward " \t0-9")) ;; if we are in column <= 5 now, check for continuation char (cond ((= 5 (current-column)) (forward-char 1)) ((and (< (current-column) 5) (equal esope-continuation-string (char-to-string (following-char))) (forward-char 1)))) ;; find out parse-limit from here (setq end-of-line (save-excursion (end-of-line)(point))) (setq parse-limit (min where end-of-line)) ;; parse max up to comment-start, if non-nil and in current line (if comment-start (save-excursion (if (re-search-forward quoted-comment-start end-of-line t) (setq parse-limit (min (point) parse-limit))))) ;; now parse if still in limits (if (< (point) where) (setq parse-state (parse-partial-sexp (point) parse-limit nil nil parse-state)) (setq not-done nil)) )) ;; result is (nth 3 parse-state)))))) (defun esope-auto-fill-mode (arg) "Toggle esope-auto-fill mode. With ARG, turn `esope-auto-fill' mode on iff ARG is positive. In `esope-auto-fill' mode, inserting a space at a column beyond `fill-column' automatically breaks the line at a previous space." (interactive "P") (prog1 (setq auto-fill-function (if (if (null arg) (not auto-fill-function) (> (prefix-numeric-value arg) 0)) 'esope-do-auto-fill nil)) (force-mode-line-update))) (defun esope-do-auto-fill () (if (> (current-column) fill-column) (esope-indent-line))) (defun esope-fill () (interactive) (let* ((opoint (point)) (bol (save-excursion (beginning-of-line) (point))) (eol (save-excursion (end-of-line) (point))) (bos (min eol (+ bol (esope-current-line-indentation)))) (quote (save-excursion (goto-char bol) (if (looking-at comment-line-start-skip) nil ; OK to break quotes on comment lines. (move-to-column fill-column) (cond ((esope-is-in-string-p (point)) (save-excursion (re-search-backward "[^']'[^']" bol t) (if esope-break-before-delimiters (point) (1+ (point))))) (t nil))))) ;; ;; decide where to split the line. If a position for a quoted ;; string was found above then use that, else break the line ;; before the last delimiter. ;; Delimiters are whitespace, commas, and operators. ;; Will break before a pair of *'s. ;; (fill-point (or quote (save-excursion (move-to-column (1+ fill-column)) (skip-chars-backward "^ \t\n,'+-/*=)" ;;; (if esope-break-before-delimiters ;;; "^ \t\n,'+-/*=" "^ \t\n,'+-/*=)") ) (if (<= (point) (1+ bos)) (progn (move-to-column (1+ fill-column)) ;;;what is this doing??? (if (not (re-search-forward "[\t\n,'+-/*)=]" eol t)) (goto-char bol)))) (if (bolp) (re-search-forward "[ \t]" opoint t) (forward-char -1) (if (looking-at "'") (forward-char 1) (skip-chars-backward " \t\*"))) (if esope-break-before-delimiters (point) (1+ (point)))))) ) ;; if we are in an in-line comment, don't break unless the ;; line of code is longer than it should be. Otherwise ;; break the line at the column computed above. ;; ;; Need to use esope-find-comment-start-skip to make sure that quoted !'s ;; don't prevent a break. (if (not (or (save-excursion (if (and (re-search-backward comment-start-skip bol t) (not (esope-is-in-string-p (point)))) (progn (skip-chars-backward " \t") (< (current-column) (1+ fill-column))))) (save-excursion (goto-char fill-point) (bolp)))) (if (> (save-excursion (goto-char fill-point) (current-column)) (1+ fill-column)) (progn (goto-char fill-point) (esope-break-line)) (save-excursion (if (> (save-excursion (goto-char fill-point) (current-column)) (+ (calculate-esope-indent) esope-continuation-indent)) (progn (goto-char fill-point) (esope-break-line)))))) )) (defun esope-break-line () (let ((opoint (point)) (bol (save-excursion (beginning-of-line) (point))) (eol (save-excursion (end-of-line) (point))) (comment-string nil)) (save-excursion (if (and comment-start-skip (esope-find-comment-start-skip)) (progn (re-search-backward comment-start-skip bol t) (setq comment-string (buffer-substring (point) eol)) (delete-region (point) eol)))) ;;; Forward line 1 really needs to go to next non white line (if (save-excursion (forward-line 1) (or (looking-at " [^ 0\n]") (looking-at "\t[1-9]"))) (progn (end-of-line) (delete-region (point) (match-end 0)) (delete-horizontal-space) (esope-fill)) (esope-split-line)) (if comment-string (save-excursion (goto-char bol) (end-of-line) (delete-horizontal-space) (indent-to (esope-comment-hook)) (insert comment-string))))) (defun esope-analyze-file-format () "Returns nil if fixed format is used, t if TAB formatting is used. Use `esope-tab-mode-default' if no non-comment statements are found in the file before the end or the first `esope-analyze-depth' lines." (let ((i 0)) (save-excursion (goto-char (point-min)) (setq i 0) (while (not (or (eobp) (looking-at "\t") (looking-at " ") (> i esope-analyze-depth))) (forward-line) (setq i (1+ i))) (cond ((looking-at "\t") t) ((looking-at " ") nil) (esope-tab-mode-default t) (t nil))))) (or (assq 'esope-tab-mode-string minor-mode-alist) (setq minor-mode-alist (cons '(esope-tab-mode-string (indent-tabs-mode esope-tab-mode-string)) minor-mode-alist))) (provide 'esope) ;;; esope.el ends here ;