1 ;;; dcl-mode.el --- major mode for editing DCL command files
3 ;; Copyright (C) 1997, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 ;; Free Software Foundation, Inc.
6 ;; Author: Odd Gripenstam <gripenstamol@decus.se>
7 ;; Maintainer: Odd Gripenstam <gripenstamol@decus.se>
8 ;; Keywords: DCL editing major-mode languages
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software: you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation, either version 3 of the License, or
15 ;; (at your option) any later version.
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
27 ;; DCL mode is a package for editing DCL command files. It helps you
28 ;; indent lines, add leading `$' and trailing `-', move around in the
29 ;; code and insert lexical functions.
31 ;; Type `C-h m' when you are editing a .COM file to get more
32 ;; information about this mode.
34 ;; To use templates you will need a version of tempo.el that is at
35 ;; least later than the buggy 1.1.1, which was included with my versions of
36 ;; Emacs. I used version 1.2.4.
37 ;; The latest tempo.el distribution can be fetched from
38 ;; ftp.lysator.liu.se in the directory /pub/emacs.
39 ;; I recommend setting (setq tempo-interactive t). This will make
40 ;; tempo prompt you for values to put in the blank spots in the templates.
42 ;; There is limited support for imenu. The limitation is that you need
43 ;; a version of imenu.el that uses imenu-generic-expression. I found
44 ;; the version I use in Emacs 19.30. (It was *so* much easier to hook
45 ;; into that version than the one in 19.27...)
47 ;; Any feedback will be welcomed. If you write functions for
48 ;; dcl-calc-command-indent-function or dcl-calc-cont-indent-function,
49 ;; please send them to the maintainer.
52 ;; Ideas for improvement:
53 ;; * Better font-lock support.
54 ;; * Change meaning of `left margin' when dcl-tab-always-indent is nil.
55 ;; Consider the following line (`_' is the cursor):
57 ;; Pressing tab with the cursor at the underline now inserts a tab.
58 ;; This should be part of the left margin and pressing tab should indent
60 ;; * Make M-LFD work properly with comments in all cases. Now it only
61 ;; works on comment-only lines. But what is "properly"? New rules for
62 ;; indenting comments?
63 ;; * Even smarter indentation of continuation lines.
64 ;; * A delete-indentation function (M-^) that joins continued lines,
65 ;; including lines with end line comments?
67 ;; * `indent list' commands: C-M-q, C-u TAB. What is a list in DCL? One
68 ;; complete command line? A block? A subroutine?
74 ;;; *** Customization *****************************************************
77 ;; First, font lock. This is a minimal approach, please improve!
79 (defvar dcl-font-lock-keywords
80 '(("\\<\\(if\\|then\\|else\\|endif\\)\\>"
81 1 font-lock-keyword-face
)
83 0 font-lock-builtin-face
)
84 ("[.]\\(eq\\|not\\|or\\|and\\|lt\\|gt\\|le\\|ge\\|eqs\\|nes\\)[.]"
85 0 font-lock-builtin-face
))
86 "Font lock keyword specification for DCL mode.
87 Presently this includes some syntax, .OP.erators, and \"f$\" lexicals.")
89 (defvar dcl-font-lock-defaults
90 '(dcl-font-lock-keywords nil
)
91 "Font lock specification for DCL mode.")
97 "Major mode for editing DCL command files."
98 :link
'(custom-group-link :tag
"Font Lock Faces group" font-lock-faces
)
101 (defcustom dcl-basic-offset
4
102 "*Number of columns to indent a block in DCL.
103 A block is the commands between THEN-ELSE-ENDIF and between the commands
104 dcl-block-begin-regexp and dcl-block-end-regexp.
106 The meaning of this variable may be changed if
107 dcl-calc-command-indent-function is set to a function."
112 (defcustom dcl-continuation-offset
6
113 "*Number of columns to indent a continuation line in DCL.
114 A continuation line is a line that follows a line ending with `-'.
116 The meaning of this variable may be changed if
117 dcl-calc-cont-indent-function is set to a function."
122 (defcustom dcl-margin-offset
8
123 "*Indentation for the first command line in DCL.
124 The first command line in a file or after a SUBROUTINE statement is indented
125 this much. Other command lines are indented the same number of columns as
126 the preceding command line.
127 A command line is a line that starts with `$'."
132 (defcustom dcl-margin-label-offset
2
133 "*Number of columns to indent a margin label in DCL.
134 A margin label is a label that doesn't begin or end a block, i.e. it
135 doesn't match dcl-block-begin-regexp or dcl-block-end-regexp."
140 (defcustom dcl-comment-line-regexp
"^\\$!"
141 "*Regexp describing the start of a comment line in DCL.
142 Comment lines are not indented."
147 (defcustom dcl-block-begin-regexp
"loop[0-9]*:"
148 "*Regexp describing a command that begins an indented block in DCL.
149 Set to nil to only indent at THEN-ELSE-ENDIF."
154 (defcustom dcl-block-end-regexp
"endloop[0-9]*:"
155 "*Regexp describing a command that ends an indented block in DCL.
156 Set to nil to only indent at THEN-ELSE-ENDIF."
161 (defcustom dcl-calc-command-indent-function nil
162 "*Function to calculate indentation for a command line in DCL.
163 If this variable is non-nil it is called as a function:
165 \(func INDENT-TYPE CUR-INDENT EXTRA-INDENT LAST-POINT THIS-POINT)
167 The function must return the number of columns to indent the current line or
168 nil to get the default indentation.
170 INDENT-TYPE is a symbol indicating what kind of indentation should be done.
171 It can have the following values:
172 indent the lines indentation should be increased, e.g. after THEN.
173 outdent the lines indentation should be decreased, e.g a line with ENDIF.
174 first-line indentation for the first line in a buffer or SUBROUTINE.
175 CUR-INDENT is the indentation of the preceding command line.
176 EXTRA-INDENT is the default change in indentation for this line
177 \(a negative number for 'outdent).
178 LAST-POINT is the buffer position of the first significant word on the
179 previous line or nil if the current line is the first line.
180 THIS-POINT is the buffer position of the first significant word on the
183 If this variable is nil, the indentation is calculated as
184 CUR-INDENT + EXTRA-INDENT.
186 This package includes two functions suitable for this:
187 dcl-calc-command-indent-multiple
188 dcl-calc-command-indent-hang"
189 :type
'(choice (const nil
) function
)
193 (defcustom dcl-calc-cont-indent-function
'dcl-calc-cont-indent-relative
194 "*Function to calculate indentation for a continuation line.
195 If this variable is non-nil it is called as a function:
197 \(func CUR-INDENT EXTRA-INDENT)
199 The function must return the number of columns to indent the current line or
200 nil to get the default indentation.
202 If this variable is nil, the indentation is calculated as
203 CUR-INDENT + EXTRA-INDENT.
205 This package includes one function suitable for this:
206 dcl-calc-cont-indent-relative"
211 (defcustom dcl-tab-always-indent t
212 "*Controls the operation of the TAB key in DCL mode.
213 If t, pressing TAB always indents the current line.
214 If nil, pressing TAB indents the current line if point is at the left margin.
215 Data lines (i.e. lines not part of a command line or continuation line) are
221 (defcustom dcl-electric-characters t
222 "*Non-nil means reindent immediately when a label, ELSE or ENDIF is inserted."
227 (defcustom dcl-tempo-comma
", "
228 "*Text to insert when a comma is needed in a template, in DCL mode."
232 (defcustom dcl-tempo-left-paren
"("
233 "*Text to insert when a left parenthesis is needed in a template in DCL."
238 (defcustom dcl-tempo-right-paren
")"
239 "*Text to insert when a right parenthesis is needed in a template in DCL."
243 ; I couldn't decide what looked best, so I'll let you decide...
244 ; Remember, you can also customize this with imenu-submenu-name-format.
245 (defcustom dcl-imenu-label-labels
"Labels"
246 "*Imenu menu title for sub-listing with label names."
249 (defcustom dcl-imenu-label-goto
"GOTO"
250 "*Imenu menu title for sub-listing with GOTO statements."
253 (defcustom dcl-imenu-label-gosub
"GOSUB"
254 "*Imenu menu title for sub-listing with GOSUB statements."
257 (defcustom dcl-imenu-label-call
"CALL"
258 "*Imenu menu title for sub-listing with CALL statements."
262 (defcustom dcl-imenu-generic-expression
263 `((nil "^\\$[ \t]*\\([A-Za-z0-9_\$]+\\):[ \t]+SUBROUTINE\\b" 1)
264 (,dcl-imenu-label-labels
265 "^\\$[ \t]*\\([A-Za-z0-9_\$]+\\):\\([ \t]\\|$\\)" 1)
266 (,dcl-imenu-label-goto
"\\s-GOTO[ \t]+\\([A-Za-z0-9_\$]+\\)" 1)
267 (,dcl-imenu-label-gosub
"\\s-GOSUB[ \t]+\\([A-Za-z0-9_\$]+\\)" 1)
268 (,dcl-imenu-label-call
"\\s-CALL[ \t]+\\([A-Za-z0-9_\$]+\\)" 1))
269 "*Default imenu generic expression for DCL.
271 The default includes SUBROUTINE labels in the main listing and
272 sub-listings for other labels, CALL, GOTO and GOSUB statements.
273 See `imenu-generic-expression' for details."
274 :type
'(repeat (sexp :tag
"Imenu Expression"))
278 (defcustom dcl-mode-hook nil
279 "*Hook called by `dcl-mode'."
284 ;;; *** Global variables ****************************************************
287 (defvar dcl-mode-syntax-table nil
288 "Syntax table used in DCL-buffers.")
289 (unless dcl-mode-syntax-table
290 (setq dcl-mode-syntax-table
(make-syntax-table))
291 (modify-syntax-entry ?
! "<" dcl-mode-syntax-table
) ; comment start
292 (modify-syntax-entry ?
\n ">" dcl-mode-syntax-table
) ; comment end
293 (modify-syntax-entry ?
< "(>" dcl-mode-syntax-table
) ; < and ...
294 (modify-syntax-entry ?
> ")<" dcl-mode-syntax-table
) ; > is a matching pair
295 (modify-syntax-entry ?
\\ "_" dcl-mode-syntax-table
) ; not an escape
299 (defvar dcl-mode-map
()
300 "Keymap used in DCL-mode buffers.")
303 (setq dcl-mode-map
(make-sparse-keymap))
304 (define-key dcl-mode-map
"\e\n" 'dcl-split-line
)
305 (define-key dcl-mode-map
"\e\t" 'tempo-complete-tag
)
306 (define-key dcl-mode-map
"\e^" 'dcl-delete-indentation
)
307 (define-key dcl-mode-map
"\em" 'dcl-back-to-indentation
)
308 (define-key dcl-mode-map
"\ee" 'dcl-forward-command
)
309 (define-key dcl-mode-map
"\ea" 'dcl-backward-command
)
310 (define-key dcl-mode-map
"\e\C-q" 'dcl-indent-command
)
311 (define-key dcl-mode-map
"\t" 'dcl-tab
)
312 (define-key dcl-mode-map
":" 'dcl-electric-character
)
313 (define-key dcl-mode-map
"F" 'dcl-electric-character
)
314 (define-key dcl-mode-map
"f" 'dcl-electric-character
)
315 (define-key dcl-mode-map
"E" 'dcl-electric-character
)
316 (define-key dcl-mode-map
"e" 'dcl-electric-character
)
317 (define-key dcl-mode-map
"\C-c\C-o" 'dcl-set-option
)
318 (define-key dcl-mode-map
"\C-c\C-f" 'tempo-forward-mark
)
319 (define-key dcl-mode-map
"\C-c\C-b" 'tempo-backward-mark
)
321 (define-key dcl-mode-map
[menu-bar
] (make-sparse-keymap))
322 (define-key dcl-mode-map
[menu-bar dcl
]
323 (cons "DCL" (make-sparse-keymap "DCL")))
325 ;; Define these in bottom-up order
326 (define-key dcl-mode-map
[menu-bar dcl tempo-backward-mark
]
327 '("Previous template mark" . tempo-backward-mark
))
328 (define-key dcl-mode-map
[menu-bar dcl tempo-forward-mark
]
329 '("Next template mark" . tempo-forward-mark
))
330 (define-key dcl-mode-map
[menu-bar dcl tempo-complete-tag
]
331 '("Complete template tag" . tempo-complete-tag
))
332 (define-key dcl-mode-map
[menu-bar dcl dcl-separator-tempo
]
334 (define-key dcl-mode-map
[menu-bar dcl dcl-save-all-options
]
335 '("Save all options" . dcl-save-all-options
))
336 (define-key dcl-mode-map
[menu-bar dcl dcl-save-nondefault-options
]
337 '("Save changed options" . dcl-save-nondefault-options
))
338 (define-key dcl-mode-map
[menu-bar dcl dcl-set-option
]
339 '("Set option" . dcl-set-option
))
340 (define-key dcl-mode-map
[menu-bar dcl dcl-separator-option
]
342 (define-key dcl-mode-map
[menu-bar dcl dcl-delete-indentation
]
343 '("Delete indentation" . dcl-delete-indentation
))
344 (define-key dcl-mode-map
[menu-bar dcl dcl-split-line
]
345 '("Split line" . dcl-split-line
))
346 (define-key dcl-mode-map
[menu-bar dcl dcl-indent-command
]
347 '("Indent command" . dcl-indent-command
))
348 (define-key dcl-mode-map
[menu-bar dcl dcl-tab
]
349 '("Indent line/insert tab" . dcl-tab
))
350 (define-key dcl-mode-map
[menu-bar dcl dcl-back-to-indentation
]
351 '("Back to indentation" . dcl-back-to-indentation
))
352 (define-key dcl-mode-map
[menu-bar dcl dcl-forward-command
]
353 '("End of statement" . dcl-forward-command
))
354 (define-key dcl-mode-map
[menu-bar dcl dcl-backward-command
]
355 '("Beginning of statement" . dcl-backward-command
))
356 ;; imenu is only supported for versions with imenu-generic-expression
357 (if (boundp 'imenu-generic-expression
)
359 (define-key dcl-mode-map
[menu-bar dcl dcl-separator-movement
]
361 (define-key dcl-mode-map
[menu-bar dcl imenu
]
362 '("Buffer index menu" . imenu
))))
367 "\\([ \t]*-[ \t]*\\(!.*\\)*\n\\)*[ \t]*"
368 "Regular expression describing white space in a DCL command line.
369 White space is any number of continued lines with only space,tab,endcomment
370 followed by space or tab."
375 (defcustom dcl-label-r
376 "[a-zA-Z0-9_\$]*:\\([ \t!]\\|$\\)"
377 "Regular expression describing a label.
378 A label is a name followed by a colon followed by white-space or end-of-line."
384 "^\\$\\(.*-[ \t]*\\(!.*\\)*\n\\)*[^!\"\n]*\\(\".*\\(\"\".*\\)*\"\\)*[^!\"\n]*"
385 "Regular expression describing a DCL command line up to a trailing comment.
386 A line starting with $, optionally followed by continuation lines,
387 followed by the end of the command line.
388 A continuation line is any characters followed by `-',
389 optionally followed by a comment, followed by a newline."
394 (defcustom dcl-command-regexp
395 "^\\$\\(.*-[ \t]*\\(!.*\\)*\n\\)*.*\\(\".*\\(\"\".*\\)*\"\\)*"
396 "Regular expression describing a DCL command line.
397 A line starting with $, optionally followed by continuation lines,
398 followed by the end of the command line.
399 A continuation line is any characters followed by `-',
400 optionally followed by a comment, followed by a newline."
405 (defcustom dcl-electric-reindent-regexps
406 (list "endif" "else" dcl-label-r
)
407 "*Regexps that can trigger an electric reindent.
408 A list of regexps that will trigger a reindent if the last letter
409 is defined as dcl-electric-character.
411 E.g.: if this list contains `endif', the key `f' is defined as
412 dcl-electric-character and the you have just typed the `f' in
413 `endif', the line will be reindented."
414 :type
'(repeat regexp
)
418 (defvar dcl-option-alist
419 '((dcl-basic-offset dcl-option-value-basic
)
420 (dcl-continuation-offset curval
)
421 (dcl-margin-offset dcl-option-value-margin-offset
)
422 (dcl-margin-label-offset dcl-option-value-offset
)
423 (dcl-comment-line-regexp dcl-option-value-comment-line
)
424 (dcl-block-begin-regexp curval
)
425 (dcl-block-end-regexp curval
)
426 (dcl-tab-always-indent toggle
)
427 (dcl-electric-characters toggle
)
428 (dcl-electric-reindent-regexps curval
)
429 (dcl-tempo-comma curval
)
430 (dcl-tempo-left-paren curval
)
431 (dcl-tempo-right-paren curval
)
432 (dcl-calc-command-indent-function curval
)
433 (dcl-calc-cont-indent-function curval
)
434 (comment-start curval
)
435 (comment-start-skip curval
)
437 "Options and default values for dcl-set-option.
439 An alist with option variables and functions or keywords to get a
440 default value for the option.
443 curval the current value
444 toggle the opposite of the current value (for t/nil)")
447 (defvar dcl-option-history
448 (mapcar (lambda (option-assoc)
449 (format "%s" (car option-assoc
)))
451 "The history list for dcl-set-option.
452 Preloaded with all known option names from dcl-option-alist")
455 ;; Must be defined after dcl-cmd-r
456 ;; This version is more correct but much slower than the one
457 ;; above. This version won't find GOTOs in comments or text strings.
458 ;(defvar dcl-imenu-generic-expression
460 ; ((nil "^\\$[ \t]*\\([A-Za-z0-9_\$]+\\):[ \t]+SUBROUTINE\\b" 1)
461 ; ("Labels" "^\\$[ \t]*\\([A-Za-z0-9_\$]+\\):\\([ \t]\\|$\\)" 1)
462 ; ("GOTO" (, (concat dcl-cmd-r "GOTO[ \t]+\\([A-Za-z0-9_\$]+\\)")) 5)
463 ; ("GOSUB" (, (concat dcl-cmd-r
464 ; "GOSUB[ \t]+\\([A-Za-z0-9_\$]+\\)")) 5)
465 ; ("CALL" (, (concat dcl-cmd-r "CALL[ \t]+\\([A-Za-z0-9_\$]+\\)")) 5)))
466 ; "*Default imenu generic expression for DCL.
468 ;The default includes SUBROUTINE labels in the main listing and
469 ;sub-listings for other labels, CALL, GOTO and GOSUB statements.
470 ;See `imenu-generic-expression' in a recent (e.g. Emacs 19.30) imenu.el
474 ;;; *** Mode initialization *************************************************
479 "Major mode for editing DCL-files.
481 This mode indents command lines in blocks. (A block is commands between
482 THEN-ELSE-ENDIF and between lines matching dcl-block-begin-regexp and
483 dcl-block-end-regexp.)
485 Labels are indented to a fixed position unless they begin or end a block.
486 Whole-line comments (matching dcl-comment-line-regexp) are not indented.
487 Data lines are not indented.
492 Commands not usually bound to keys:
494 \\[dcl-save-nondefault-options]\t\tSave changed options
495 \\[dcl-save-all-options]\t\tSave all options
496 \\[dcl-save-option]\t\t\tSave any option
497 \\[dcl-save-mode]\t\t\tSave buffer mode
499 Variables controlling indentation style and extra features:
502 Extra indentation within blocks.
504 dcl-continuation-offset
505 Extra indentation for continued lines.
508 Indentation for the first command line in a file or SUBROUTINE.
510 dcl-margin-label-offset
511 Indentation for a label.
513 dcl-comment-line-regexp
514 Lines matching this regexp will not be indented.
516 dcl-block-begin-regexp
518 Regexps that match command lines that begin and end, respectively,
519 a block of commmand lines that will be given extra indentation.
520 Command lines between THEN-ELSE-ENDIF are always indented; these variables
521 make it possible to define other places to indent.
522 Set to nil to disable this feature.
524 dcl-calc-command-indent-function
525 Can be set to a function that customizes indentation for command lines.
526 Two such functions are included in the package:
527 dcl-calc-command-indent-multiple
528 dcl-calc-command-indent-hang
530 dcl-calc-cont-indent-function
531 Can be set to a function that customizes indentation for continued lines.
532 One such function is included in the package:
533 dcl-calc-cont-indent-relative (set by default)
535 dcl-tab-always-indent
536 If t, pressing TAB always indents the current line.
537 If nil, pressing TAB indents the current line if point is at the left
540 dcl-electric-characters
541 Non-nil causes lines to be indented at once when a label, ELSE or ENDIF is
544 dcl-electric-reindent-regexps
545 Use this variable and function dcl-electric-character to customize
546 which words trigger electric indentation.
550 dcl-tempo-right-paren
551 These variables control the look of expanded templates.
553 dcl-imenu-generic-expression
554 Default value for imenu-generic-expression. The default includes
555 SUBROUTINE labels in the main listing and sub-listings for
556 other labels, CALL, GOTO and GOSUB statements.
558 dcl-imenu-label-labels
560 dcl-imenu-label-gosub
562 Change the text that is used as sub-listing labels in imenu.
564 Loading this package calls the value of the variable
565 `dcl-mode-load-hook' with no args, if that value is non-nil.
566 Turning on DCL mode calls the value of the variable `dcl-mode-hook'
567 with no args, if that value is non-nil.
570 The following example uses the default values for all variables:
572 $! This is a comment line that is not indented (it matches
573 $! dcl-comment-line-regexp)
574 $! Next follows the first command line. It is indented dcl-margin-offset.
576 $ ! Other comments are indented like command lines.
577 $ ! A margin label indented dcl-margin-label-offset:
581 $ ! Lines between THEN-ELSE and ELSE-ENDIF are
582 $ ! indented dcl-basic-offset
583 $ loop1: ! This matches dcl-block-begin-regexp...
584 $ ! ...so this line is indented dcl-basic-offset
585 $ text = \"This \" + - ! is a continued line
586 \"lined up with the command line\"
588 Data lines are not indented at all.
589 $ endloop1: ! This matches dcl-block-end-regexp
594 There is some minimal font-lock support (see vars
595 `dcl-font-lock-defaults' and `dcl-font-lock-keywords')."
597 (kill-all-local-variables)
598 (set-syntax-table dcl-mode-syntax-table
)
600 (make-local-variable 'indent-line-function
)
601 (setq indent-line-function
'dcl-indent-line
)
603 (make-local-variable 'comment-start
)
604 (setq comment-start
"!")
606 (make-local-variable 'comment-end
)
607 (setq comment-end
"")
609 (make-local-variable 'comment-multi-line
)
610 (setq comment-multi-line nil
)
612 ;; This used to be "^\\$[ \t]*![ \t]*" which looks more correct.
613 ;; The drawback was that you couldn't make empty comment lines by pressing
614 ;; C-M-j repeatedly - only the first line became a comment line.
615 ;; This version has the drawback that the "$" can be anywhere in the line,
616 ;; and something inappropriate might be interpreted as a comment.
617 (make-local-variable 'comment-start-skip
)
618 (setq comment-start-skip
"\\$[ \t]*![ \t]*")
620 (if (boundp 'imenu-generic-expression
)
621 (progn (setq imenu-generic-expression dcl-imenu-generic-expression
)
622 (setq imenu-case-fold-search t
)))
623 (setq imenu-create-index-function
'dcl-imenu-create-index-function
)
625 (make-local-variable 'dcl-comment-line-regexp
)
626 (make-local-variable 'dcl-block-begin-regexp
)
627 (make-local-variable 'dcl-block-end-regexp
)
628 (make-local-variable 'dcl-basic-offset
)
629 (make-local-variable 'dcl-continuation-offset
)
630 (make-local-variable 'dcl-margin-label-offset
)
631 (make-local-variable 'dcl-margin-offset
)
632 (make-local-variable 'dcl-tab-always-indent
)
633 (make-local-variable 'dcl-electric-characters
)
634 (make-local-variable 'dcl-calc-command-indent-function
)
635 (make-local-variable 'dcl-calc-cont-indent-function
)
636 (make-local-variable 'dcl-electric-reindent-regexps
)
639 (make-local-variable 'font-lock-defaults
)
640 (setq font-lock-defaults dcl-font-lock-defaults
)
642 (setq major-mode
'dcl-mode
)
643 (setq mode-name
"DCL")
644 (use-local-map dcl-mode-map
)
645 (tempo-use-tag-list 'dcl-tempo-tags
)
646 (run-mode-hooks 'dcl-mode-hook
))
649 ;;; *** Movement commands ***************************************************
652 ;;;-------------------------------------------------------------------------
653 (defun dcl-beginning-of-statement ()
654 "Go to the beginning of the preceding or current command line."
656 (re-search-backward dcl-command-regexp nil t
))
659 ;;;-------------------------------------------------------------------------
660 (defun dcl-end-of-statement ()
661 "Go to the end of the next or current command line."
663 (if (or (dcl-end-of-command-p)
664 (dcl-beginning-of-command-p)
665 (not (dcl-command-p)))
667 (dcl-beginning-of-statement))
668 (re-search-forward dcl-command-regexp nil t
))
671 ;;;-------------------------------------------------------------------------
672 (defun dcl-beginning-of-command ()
673 "Move point to beginning of current command."
675 (let ((type (dcl-get-line-type)))
676 (if (and (eq type
'$
)
678 () ; already in the correct position
679 (dcl-beginning-of-statement))))
682 ;;;-------------------------------------------------------------------------
683 (defun dcl-end-of-command ()
684 "Move point to end of current command or next command if not on a command."
686 (let ((type (dcl-get-line-type))
691 (dcl-beginning-of-command)
692 (dcl-end-of-statement))
693 (dcl-end-of-statement))))
696 ;;;-------------------------------------------------------------------------
697 (defun dcl-backward-command (&optional incl-comment-commands
)
698 "Move backward to a command.
699 Move point to the preceding command line that is not a comment line,
700 a command line with only a comment, only contains a `$' or only
703 Returns point of the found command line or nil if not able to move."
705 (let ((start (point))
708 ;; Find first non-empty command line
710 ;; back up one statement and look at the command
711 (if (dcl-beginning-of-statement)
713 ((and dcl-block-begin-regexp
; might be nil
714 (looking-at (concat "^\\$" dcl-ws-r
715 dcl-block-begin-regexp
)))
716 (setq done t retval
(point)))
717 ((and dcl-block-end-regexp
; might be nil
718 (looking-at (concat "^\\$" dcl-ws-r
719 dcl-block-end-regexp
)))
720 (setq done t retval
(point)))
721 ((looking-at dcl-comment-line-regexp
)
722 t
) ; comment line, one more loop
723 ((and (not incl-comment-commands
)
724 (looking-at "\\$[ \t]*!"))
725 t
) ; comment only command, loop...
726 ((looking-at "^\\$[ \t]*$")
727 t
) ; empty line, one more loop
729 (concat "^\\$" dcl-ws-r dcl-label-r dcl-ws-r
"$")))
730 (setq done t
) ; not a label-only line, exit the loop
731 (setq retval
(point))))
732 ;; We couldn't go further back, and we haven't found a command yet.
733 ;; Return to the start positionn
740 ;;;-------------------------------------------------------------------------
741 (defun dcl-forward-command (&optional incl-comment-commands
)
742 "Move forward to a command.
743 Move point to the end of the next command line that is not a comment line,
744 a command line with only a comment, only contains a `$' or only
747 Returns point of the found command line or nil if not able to move."
749 (let ((start (point))
752 ;; Find first non-empty command line
754 ;; go forward one statement and look at the command
755 (if (dcl-end-of-statement)
757 (dcl-beginning-of-statement)
759 ((and dcl-block-begin-regexp
; might be nil
760 (looking-at (concat "^\\$" dcl-ws-r
761 dcl-block-begin-regexp
)))
763 (setq retval
(point)))
764 ((and dcl-block-end-regexp
; might be nil
765 (looking-at (concat "^\\$" dcl-ws-r
766 dcl-block-end-regexp
)))
768 (setq retval
(point)))
769 ((looking-at dcl-comment-line-regexp
)
770 t
) ; comment line, one more loop
771 ((and (not incl-comment-commands
)
772 (looking-at "\\$[ \t]*!"))
773 t
) ; comment only command, loop...
774 ((looking-at "^\\$[ \t]*$")
775 t
) ; empty line, one more loop
777 (concat "^\\$" dcl-ws-r dcl-label-r dcl-ws-r
"$")))
778 (setq done t
) ; not a label-only line, exit the loop
779 (setq retval
(point)))))
780 ;; We couldn't go further back, and we haven't found a command yet.
781 ;; Return to the start positionn
788 ;;;-------------------------------------------------------------------------
789 (defun dcl-back-to-indentation ()
790 "Move point to the first non-whitespace character on this line.
791 Leading $ and labels counts as whitespace in this case.
792 If this is a comment line then move to the first non-whitespace character
795 Typing \\[dcl-back-to-indentation] several times in a row will move point to other
796 `interesting' points closer to the left margin, and then back to the
797 rightmost point again.
799 E.g. on the following line, point would go to the positions indicated
800 by the numbers in order 1-2-3-1-... :
805 (if (eq last-command
'dcl-back-to-indentation
)
806 (dcl-back-to-indentation-1 (point))
807 (dcl-back-to-indentation-1)))
808 (defun dcl-back-to-indentation-1 (&optional limit
)
809 "Helper function for dcl-back-to-indentation"
811 ;; "Indentation points" that we will travel to
824 (let* ((default-limit (save-excursion (end-of-line) (1+ (point))))
825 (limit (or limit default-limit
))
826 (last-good-point (point))
829 (back-to-indentation)
831 ;; If we already were at the outermost indentation point then we
832 ;; start searching for the innermost point again.
833 (if (= (point) opoint
)
834 (setq limit default-limit
))
836 (if (< (point) limit
)
837 (setq last-good-point
(point)))
840 ;; Special treatment for comment lines. We are trying to allow
841 ;; things like "$ !*" as comment lines.
842 ((looking-at dcl-comment-line-regexp
)
843 (re-search-forward (concat dcl-comment-line-regexp
"[ \t]*") limit t
)
844 (if (< (point) limit
)
845 (setq last-good-point
(point))))
847 ;; Normal command line
848 ((looking-at "^\\$[ \t]*")
849 ;; Move over leading "$" and blanks
850 (re-search-forward "^\\$[ \t]*" limit t
)
851 (if (< (point) limit
)
852 (setq last-good-point
(point)))
854 ;; Move over a label (if it isn't a block begin/end)
855 ;; We must treat block begin/end labels as commands because
856 ;; dcl-set-option relies on it.
857 (if (and (looking-at dcl-label-r
)
858 (not (or (and dcl-block-begin-regexp
859 (looking-at dcl-block-begin-regexp
))
860 (and dcl-block-end-regexp
861 (looking-at dcl-block-end-regexp
)))))
862 (re-search-forward (concat dcl-label-r
"[ \t]*") limit t
))
863 (if (< (point) limit
)
864 (setq last-good-point
(point)))
866 ;; Move over the beginning of a comment
867 (if (looking-at "![ \t]*")
868 (re-search-forward "![ \t]*" limit t
))
869 (if (< (point) limit
)
870 (setq last-good-point
(point)))))
871 (goto-char last-good-point
)))
874 ;;; *** Support for indentation *********************************************
877 (defun dcl-get-line-type ()
878 "Determine the type of the current line.
879 Returns one of the following symbols:
880 $ for a complete command line or the beginning of a command line.
881 - for a continuation line
882 $! for a comment line
884 empty-data for an empty line following a data line
885 empty-$ for an empty line following a command line"
887 ;; Check if it's a comment line.
888 ;; A comment line starts with $!
891 (if (looking-at dcl-comment-line-regexp
)
893 ;; Check if it's a command line.
894 ;; A command line starts with $
897 (if (looking-at "^\\$")
899 ;; Check if it's a continuation line
902 ;; If we're at the beginning of the buffer it can't be a continuation
905 (let ((opoint (point)))
906 (dcl-beginning-of-statement)
907 (re-search-forward dcl-command-regexp opoint t
)
908 (if (>= (point) opoint
)
910 ;; Empty lines might be different things
912 (if (and (bolp) (eolp))
916 (let ((type (dcl-get-line-type)))
918 ((or (equal type
'$
) (equal type
'$
!) (equal type
'-
))
922 ;; Anything else must be a data line
927 ;;;-------------------------------------------------------------------------
928 (defun dcl-indentation-point ()
929 "Return point of first non-`whitespace' on this line."
931 (dcl-back-to-indentation)
935 ;;;---------------------------------------------------------------------------
936 (defun dcl-show-line-type ()
937 "Test dcl-get-line-type."
939 (let ((type (dcl-get-line-type)))
942 (message "command line"))
946 (message "comment line"))
948 (message "continuation line"))
951 ((equal type
'empty-data
)
952 (message "empty-data"))
953 ((equal type
'empty-$
)
960 ;;; *** Perform indentation *************************************************
963 ;;;---------------------------------------------------------------------------
964 (defun dcl-calc-command-indent-multiple
965 (indent-type cur-indent extra-indent last-point this-point
)
966 "Indent lines to a multiple of dcl-basic-offset.
968 Set dcl-calc-command-indent-function to this function to customize
969 indentation of command lines.
971 Command lines that need to be indented beyond the left margin are
972 always indented to a column that is a multiple of dcl-basic-offset, as
973 if tab stops were set at 4, 8, 12, etc.
975 This supports a formatting style like this (dcl-margin offset = 2,
976 dcl-basic-offset = 4):
984 ;; calculate indentation if it's an interesting indent-type,
985 ;; otherwise return nil to get the default indentation
988 ((equal indent-type
'indent
)
989 (setq indent
(- cur-indent
(% cur-indent dcl-basic-offset
)))
990 (setq indent
(+ indent extra-indent
))))))
993 ;;;---------------------------------------------------------------------------
994 ;; Some people actually writes likes this. To each his own...
995 (defun dcl-calc-command-indent-hang
996 (indent-type cur-indent extra-indent last-point this-point
)
997 "Indent lines as default, but indent THEN, ELSE and ENDIF extra.
999 Set dcl-calc-command-indent-function to this function to customize
1000 indentation of command lines.
1002 This function supports a formatting style like this:
1010 If you use this function you will probably want to add \"then\" to
1011 dcl-electric-reindent-regexps and define the key \"n\" as
1012 dcl-electric-character.
1014 (let ((case-fold-search t
))
1017 ;; No indentation, this word is `then': +2
1018 ;; last word was endif: -2
1021 (goto-char this-point
)
1022 (if (looking-at "\\bthen\\b")
1023 (+ cur-indent extra-indent
2)))
1025 (goto-char last-point
)
1026 (if (looking-at "\\bendif\\b")
1027 (- (+ cur-indent extra-indent
) 2)))))
1028 ;; Indentation, last word was `then' or `else': -2
1029 ((equal indent-type
'indent
)
1030 (goto-char last-point
)
1032 ((looking-at "\\bthen\\b")
1033 (- (+ cur-indent extra-indent
) 2))
1034 ((looking-at "\\belse\\b")
1035 (- (+ cur-indent extra-indent
) 2))))
1036 ;; Outdent, this word is `endif' or `else': + 2
1037 ((equal indent-type
'outdent
)
1038 (goto-char this-point
)
1040 ((looking-at "\\bendif\\b")
1041 (+ cur-indent extra-indent
2))
1042 ((looking-at "\\belse\\b")
1043 (+ cur-indent extra-indent
2))))))))
1046 ;;;---------------------------------------------------------------------------
1047 (defun dcl-calc-command-indent ()
1048 "Calculate how much the current line shall be indented.
1049 The line is known to be a command line.
1051 Find the indentation of the preceding line and analyze its contents to
1052 see if the current lines should be indented.
1053 Analyze the current line to see if it should be `outdented'.
1055 Calculate the indentation of the current line, either with the default
1056 method or by calling dcl-calc-command-indent-function if it is
1059 If the current line should be outdented, calculate its indentation,
1060 either with the default method or by calling
1061 dcl-calc-command-indent-function if it is non-nil.
1064 Rules for default indentation:
1066 If it is the first line in the buffer, indent dcl-margin-offset.
1068 Go to the previous command line with a command on it.
1069 Find out how much it is indented (cur-indent).
1070 Look at the first word on the line to see if the indentation should be
1071 adjusted. Skip margin-label, continuations and comments while looking for
1072 the first word. Save this buffer position as `last-point'.
1073 If the first word after a label is SUBROUTINE, set extra-indent to
1076 First word extra-indent
1077 THEN +dcl-basic-offset
1078 ELSE +dcl-basic-offset
1079 block-begin +dcl-basic-offset
1081 Then return to the current line and look at the first word to see if the
1082 indentation should be adjusted again. Save this buffer position as
1085 First word extra-indent
1086 ELSE -dcl-basic-offset
1087 ENDIF -dcl-basic-offset
1088 block-end -dcl-basic-offset
1091 If dcl-calc-command-indent-function is nil or returns nil set
1092 cur-indent to cur-indent+extra-indent.
1094 If an extra adjustment is necessary and if
1095 dcl-calc-command-indent-function is nil or returns nil set cur-indent
1096 to cur-indent+extra-indent.
1098 See also documentation for dcl-calc-command-indent-function.
1099 The indent-type classification could probably be expanded upon.
1104 (let ((is-block nil
)
1105 (case-fold-search t
)
1108 indent-type last-point this-point extra-indent2 cur-indent2
1110 (if (bobp) ; first line in buffer
1111 (setq cur-indent
0 extra-indent dcl-margin-offset
1112 indent-type
'first-line
1113 this-point
(dcl-indentation-point))
1116 ;; Find first non-empty command line
1118 ;; back up one statement and look at the command
1119 (if (dcl-beginning-of-statement)
1121 ((and dcl-block-begin-regexp
; might be nil
1122 (looking-at (concat "^\\$" dcl-ws-r
1123 dcl-block-begin-regexp
)))
1124 (setq done t
) (setq is-block t
))
1125 ((and dcl-block-end-regexp
; might be nil
1126 (looking-at (concat "^\\$" dcl-ws-r
1127 dcl-block-end-regexp
)))
1128 (setq done t
) (setq is-block t
))
1129 ((looking-at dcl-comment-line-regexp
)
1130 t
) ; comment line, one more loop
1131 ((looking-at "^\\$[ \t]*$")
1132 t
) ; empty line, one more loop
1134 (concat "^\\$" dcl-ws-r dcl-label-r dcl-ws-r
"$")))
1135 (setq done t
))) ; not a label-only line, exit the loop
1136 ;; We couldn't go further back, so this must have been the
1138 (setq cur-indent dcl-margin-offset
1139 last-point
(dcl-indentation-point))
1141 ;; Examine the line to get current indentation and possibly a
1142 ;; reason to indent.
1145 ((looking-at (concat "^\\$[ \t]*" dcl-label-r dcl-ws-r
1146 "\\(subroutine\\b\\)"))
1147 (setq cur-indent dcl-margin-offset
1148 last-point
(1+ (match-beginning 1))))
1150 ;; Find out how much this line is indented.
1151 ;; Look at comment, continuation character, command but not label
1152 ;; unless it's a block.
1154 (re-search-forward "^\\$[ \t]*")
1155 (re-search-forward (concat "^\\$[ \t]*\\(" dcl-label-r
1157 (setq cur-indent
(current-column))
1158 ;; Look for a reason to indent: Find first word on this line
1159 (re-search-forward dcl-ws-r
)
1160 (setq last-point
(point))
1162 ((looking-at "\\bthen\\b")
1163 (setq extra-indent dcl-basic-offset indent-type
'indent
))
1164 ((looking-at "\\belse\\b")
1165 (setq extra-indent dcl-basic-offset indent-type
'indent
))
1166 ((and dcl-block-begin-regexp
; might be nil
1167 (looking-at dcl-block-begin-regexp
))
1168 (setq extra-indent dcl-basic-offset indent-type
'indent
))
1170 (setq extra-indent2
0)
1171 ;; We're back at the beginning of the original line.
1172 ;; Look for a reason to outdent: Find first word on this line
1173 (re-search-forward (concat "^\\$" dcl-ws-r
))
1174 (setq this-point
(dcl-indentation-point))
1176 ((looking-at "\\belse\\b")
1177 (setq extra-indent2
(- dcl-basic-offset
) indent-type2
'outdent
))
1178 ((looking-at "\\bendif\\b")
1179 (setq extra-indent2
(- dcl-basic-offset
) indent-type2
'outdent
))
1180 ((and dcl-block-end-regexp
; might be nil
1181 (looking-at dcl-block-end-regexp
))
1182 (setq extra-indent2
(- dcl-basic-offset
) indent-type2
'outdent
))
1183 ((looking-at (concat dcl-label-r dcl-ws-r
"\\(subroutine\\b\\)"))
1184 (setq cur-indent2
0 extra-indent2 dcl-margin-offset
1185 indent-type2
'first-line
1186 this-point
(1+ (match-beginning 1)))))
1189 (or (and dcl-calc-command-indent-function
1190 (funcall dcl-calc-command-indent-function
1191 indent-type cur-indent extra-indent
1192 last-point this-point
))
1193 (+ cur-indent extra-indent
)))
1194 ;; Calculate outdent
1197 (or cur-indent2
(setq cur-indent2 cur-indent
))
1199 (or (and dcl-calc-command-indent-function
1200 (funcall dcl-calc-command-indent-function
1201 indent-type2 cur-indent2 extra-indent2
1202 last-point this-point
))
1203 (+ cur-indent2 extra-indent2
)))))
1208 ;;;---------------------------------------------------------------------------
1209 (defun dcl-calc-cont-indent-relative (cur-indent extra-indent
)
1210 "Indent continuation lines to align with words on previous line.
1212 Indent continuation lines to a position relative to preceding
1213 significant command line elements.
1215 Set `dcl-calc-cont-indent-function' to this function to customize
1216 indentation of continuation lines.
1218 Indented lines will align with either:
1220 * the second word on the command line
1223 * the word after an assignment
1226 * the third word if it's a qualifier
1227 $ set terminal/width=80 -
1229 * the innermost nonclosed parenthesis
1230 $ if ((a.eq.b .and. -
1231 d.eq.c .or. f$function(xxxx, -
1234 (let ((case-fold-search t
)
1237 (dcl-beginning-of-statement)
1238 (let ((end (save-excursion (forward-line 1) (point))))
1239 ;; Move over blanks and label
1240 (if (re-search-forward (concat "^\\$[ \t]*\\(" dcl-label-r
1241 "\\)*[ \t]*") end t
)
1243 ;; Move over the first word (might be `@filespec')
1244 (if (> (skip-chars-forward "@:[]<>$\\-a-zA-Z0-9_.;" end
) 0)
1245 (let (was-assignment)
1246 (skip-chars-forward " \t" end
)
1247 ;; skip over assignment if there is one
1248 (if (looking-at ":?==?")
1250 (setq was-assignment t
)
1251 (skip-chars-forward " \t:=" end
)))
1252 ;; This could be the position to indent to
1253 (setq indent
(current-column))
1255 ;; Move to the next word unless we have seen an
1256 ;; assignment. If it starts with `/' it's a
1257 ;; qualifier and we will indent to that position
1258 (if (and (not was-assignment
)
1259 (> (skip-chars-forward "a-zA-Z0-9_" end
) 0))
1261 (skip-chars-forward " \t" end
)
1262 (if (= (char-after (point)) ?
/)
1263 (setq indent
(current-column)))))
1265 ;; Now check if there are any parenthesis to adjust to.
1266 ;; If there is, we will indent to the position after the last non-closed
1267 ;; opening parenthesis.
1270 (let* ((start (save-excursion (dcl-beginning-of-statement) (point)))
1271 (parse-sexp-ignore-comments t
) ; for parse-partial
1272 (par-pos (nth 1 (parse-partial-sexp start
(point)))))
1273 (if par-pos
; is nil if no parenthesis was found
1274 (setq indent
(save-excursion
1276 (1+ (current-column)))))))
1280 ;;;---------------------------------------------------------------------------
1281 (defun dcl-calc-continuation-indent ()
1282 "Calculate how much the current line shall be indented.
1283 The line is known to be a continuation line.
1285 Go to the previous command line.
1286 Find out how much it is indented."
1287 ;; This was copied without much thought from dcl-calc-command-indent, so
1288 ;; it's a bit clumsy.
1293 ;; Huh? a continuation line first in the buffer??
1295 (let ((is-block nil
)
1298 ;; Find first non-empty command line
1301 (if (dcl-beginning-of-statement)
1303 ((and dcl-block-begin-regexp
1304 (looking-at (concat "^\\$" dcl-ws-r
1305 dcl-block-begin-regexp
)))
1306 (setq done t
) (setq is-block t
))
1307 ((and dcl-block-end-regexp
1308 (looking-at (concat "^\\$" dcl-ws-r
1309 dcl-block-end-regexp
)))
1310 (setq done t
) (setq is-block t
))
1311 ((looking-at dcl-comment-line-regexp
)
1313 ((looking-at "^\\$[ \t]*$")
1316 (concat "^\\$" dcl-ws-r dcl-label-r dcl-ws-r
"$")))
1318 ;; This must have been the first line.
1319 (setq indent dcl-margin-offset
)
1323 ;; Find out how much this line is indented.
1324 ;; Look at comment, continuation character, command but not label
1325 ;; unless it's a block.
1327 (re-search-forward "^\\$[ \t]*")
1328 (re-search-forward (concat "^\\$[ \t]*\\(" dcl-label-r
1330 (setq indent
(current-column))
1332 ;; We're back at the beginning of the original line.
1333 (or (and dcl-calc-cont-indent-function
1334 (funcall dcl-calc-cont-indent-function indent
1335 dcl-continuation-offset
))
1336 (+ indent dcl-continuation-offset
))
1340 ;;;---------------------------------------------------------------------------
1341 (defun dcl-indent-command-line ()
1342 "Indent a line known to be a command line."
1343 (let ((indent (dcl-calc-command-indent))
1344 (pos (- (point-max) (point))))
1347 (re-search-forward "^\\$[ \t]*")
1348 ;; Indent any margin-label if the offset is set
1349 ;; (Don't look at block labels)
1350 (if (and dcl-margin-label-offset
1351 (looking-at dcl-label-r
)
1352 (not (and dcl-block-begin-regexp
1353 (looking-at dcl-block-begin-regexp
)))
1354 (not (and dcl-block-end-regexp
1355 (looking-at dcl-block-end-regexp
))))
1357 (dcl-indent-to dcl-margin-label-offset
)
1358 (re-search-forward dcl-label-r
)))
1359 (dcl-indent-to indent
1)
1362 (if (> (- (point-max) pos
) (point))
1363 (goto-char (- (point-max) pos
)))
1367 ;;;-------------------------------------------------------------------------
1368 (defun dcl-indent-continuation-line ()
1369 "Indent a line known to be a continuation line.
1371 Notice that no special treatment is made for labels. They have to be
1372 on the first part on a command line to be taken into consideration."
1373 (let ((indent (dcl-calc-continuation-indent)))
1376 (re-search-forward "^[ \t]*")
1377 (dcl-indent-to indent
))
1378 (skip-chars-forward " \t")))
1381 ;;;---------------------------------------------------------------------------
1382 (defun dcl-delete-chars (chars)
1383 "Delete all characters in the set CHARS around point."
1384 (skip-chars-backward chars
)
1385 (delete-region (point) (progn (skip-chars-forward chars
) (point))))
1388 ;;;---------------------------------------------------------------------------
1389 (defun dcl-indent-line ()
1390 "The DCL version of `indent-line-function'.
1391 Adjusts indentation on the current line. Data lines are not indented."
1392 (let ((type (dcl-get-line-type)))
1395 (dcl-indent-command-line))
1397 (message "Unknown line type!"))
1399 ((equal type
'data
))
1400 ((equal type
'empty-data
))
1402 (dcl-indent-continuation-line))
1403 ((equal type
'empty-$
)
1405 (dcl-indent-command-line))
1407 (message "dcl-indent-line: unknown type"))
1411 ;;;-------------------------------------------------------------------------
1412 (defun dcl-indent-command ()
1413 "Indents the complete command line that point is on.
1414 This includes continuation lines."
1416 (let ((type (dcl-get-line-type)))
1417 (if (or (equal type
'$
)
1419 (equal type
'empty-$
))
1421 (indent-region (progn (or (looking-at "^\\$")
1422 (dcl-beginning-of-statement))
1424 (progn (dcl-end-of-statement) (point))
1428 ;;;-------------------------------------------------------------------------
1430 "Insert tab in data lines or indent code.
1431 If `dcl-tab-always-indent' is t, code lines are always indented.
1432 If nil, indent the current line only if point is at the left margin or in
1433 the lines indentation; otherwise insert a tab."
1435 (let ((type (dcl-get-line-type))
1436 (start-point (point)))
1438 ;; Data line : always insert tab
1439 ((or (equal type
'data
) (equal type
'empty-data
))
1441 ;; Indent only at start of line
1442 ((not dcl-tab-always-indent
) ; nil
1443 (let ((search-end-point
1446 (re-search-forward "^\\$?[ \t]*" start-point t
))))
1448 (and search-end-point
1449 (>= search-end-point start-point
)))
1451 (tab-to-tab-stop))))
1453 ((eq dcl-tab-always-indent t
) ; t
1458 ;;;-------------------------------------------------------------------------
1459 (defun dcl-electric-character (arg)
1460 "Inserts a character and indents if necessary.
1461 Insert a character if the user gave a numeric argument or the flag
1462 `dcl-electric-characters' is not set. If an argument was given,
1463 insert that many characters.
1465 The line is only reindented if the word just typed matches any of the
1466 regexps in `dcl-electric-reindent-regexps'."
1468 (if (or arg
(not dcl-electric-characters
))
1470 (self-insert-command (prefix-numeric-value arg
))
1471 (self-insert-command 1))
1472 ;; Insert the character and indent
1473 (self-insert-command 1)
1474 (let ((case-fold-search t
))
1475 ;; There must be a better way than (memq t ...).
1476 ;; (apply 'or ...) didn't work
1477 (if (memq t
(mapcar 'dcl-was-looking-at dcl-electric-reindent-regexps
))
1478 (dcl-indent-line)))))
1481 ;;;-------------------------------------------------------------------------
1482 (defun dcl-indent-to (col &optional minimum
)
1483 "Like indent-to, but only indents if indentation would change"
1485 (let (cur-indent collapsed indent
)
1487 (skip-chars-forward " \t")
1488 (setq cur-indent
(current-column))
1489 (skip-chars-backward " \t")
1490 (setq collapsed
(current-column)))
1491 (setq indent
(max col
(+ collapsed
(or minimum
0))))
1492 (if (/= indent cur-indent
)
1494 (dcl-delete-chars " \t")
1495 (indent-to col minimum
)))))
1498 ;;;-------------------------------------------------------------------------
1499 (defun dcl-split-line ()
1500 "Break line at point and insert text to keep the syntax valid.
1502 Inserts continuation marks and splits character strings."
1503 ;; Still don't know what to do with comments at the end of a command line.
1506 (type (dcl-get-line-type)))
1508 ((or (equal type
'$
) (equal type
'-
))
1509 (let ((info (parse-partial-sexp
1510 (save-excursion (dcl-beginning-of-statement) (point))
1512 ;; handle some special cases
1514 ((nth 3 info
) ; in text constant
1515 (insert "\" + -\n\"")
1516 (indent-according-to-mode)
1518 ((not (nth 4 info
)) ; not in comment
1521 (= (char-after (point)) ?
\")
1522 (= (char-after (1- (point))) ?
\"))
1523 (progn ; a " "" " situation
1525 (insert "\" + -\n\"")
1527 (indent-according-to-mode)
1529 ((and (dcl-was-looking-at "[ \t]*-[ \t]*") ; after cont mark
1530 (looking-at "[ \t]*\\(!.*\\)?$"))
1531 ;; Do default below. This might considered wrong if we're
1532 ;; after a subtraction: $ x = 3 - <M-LFD>
1535 (delete-horizontal-space)
1537 (insert "\n") (indent-according-to-mode)
1540 ;; use the normal function for other cases
1541 (if (not done
) ; normal M-LFD action
1542 (indent-new-comment-line))))
1545 ;;;-------------------------------------------------------------------------
1546 (defun dcl-delete-indentation (&optional arg
)
1547 "Join this line to previous like delete-indentation.
1548 Also remove the continuation mark if easily detected."
1550 (delete-indentation arg
)
1551 (let ((type (dcl-get-line-type)))
1552 (if (and (member type
'($ - empty-$
))
1554 (= (char-before) ?-
))
1557 (fixup-whitespace)))))
1560 ;;; *** Set options *********************************************************
1563 ;;;-------------------------------------------------------------------------
1564 (defun dcl-option-value-basic (option-assoc)
1565 "Guess a value for basic-offset."
1567 (dcl-beginning-of-command)
1568 (let* (;; current lines indentation
1569 (this-indent (save-excursion
1570 (dcl-back-to-indentation)
1572 ;; previous lines indentation
1573 (prev-indent (save-excursion
1574 (if (dcl-backward-command)
1576 (dcl-back-to-indentation)
1577 (current-column)))))
1578 (next-indent (save-excursion
1579 (dcl-end-of-command)
1580 (if (dcl-forward-command)
1582 (dcl-beginning-of-command)
1583 (dcl-back-to-indentation)
1584 (current-column)))))
1585 (diff (if prev-indent
1586 (abs (- this-indent prev-indent
)))))
1592 (/= (- this-indent next-indent
) 0))
1593 (abs (- this-indent next-indent
)))
1595 dcl-basic-offset
)))))
1598 ;;;-------------------------------------------------------------------------
1599 (defun dcl-option-value-offset (option-assoc)
1600 "Guess a value for an offset.
1601 Find the column of the first non-blank character on the line.
1602 Returns the column offset."
1605 (re-search-forward "^$[ \t]*" nil t
)
1609 ;;;-------------------------------------------------------------------------
1610 (defun dcl-option-value-margin-offset (option-assoc)
1611 "Guess a value for margin offset.
1612 Find the column of the first non-blank character on the line, not
1614 Returns a number as a string."
1617 (dcl-back-to-indentation)
1621 ;;;-------------------------------------------------------------------------
1622 (defun dcl-option-value-comment-line (option-assoc)
1623 "Guess a value for `dcl-comment-line-regexp'.
1624 Must return a string."
1625 ;; Should we set comment-start and comment-start-skip as well?
1626 ;; If someone wants `$!&' as a comment line, C-M-j won't work well if
1628 ;; This must be done after the user has given the real value in
1634 ;; We could search for "^\\$.*!+[^ \t]*", but, as noted above, we
1635 ;; can't handle that case very good, so there is no point in
1637 (if (looking-at "^\\$[^!\n]*!")
1638 (let ((regexp (buffer-substring (match-beginning 0) (match-end 0))))
1639 (concat "^" (regexp-quote regexp
)))
1640 dcl-comment-line-regexp
))))
1643 ;;;-------------------------------------------------------------------------
1644 (defun dcl-guess-option-value (option)
1645 "Guess what value the user would like to give the symbol option."
1646 (let* ((option-assoc (assoc option dcl-option-alist
))
1647 (option (car option-assoc
))
1648 (action (car (cdr option-assoc
)))
1651 (funcall action option-assoc
))
1652 ((eq action
'toggle
)
1653 (not (eval option
)))
1654 ((eq action
'curval
)
1655 (cond ((or (stringp (symbol-value option
))
1656 (numberp (symbol-value option
)))
1657 (format "%S" (symbol-value option
)))
1659 (format "'%S" (symbol-value option
))))))))
1660 ;; format the value as a string if not already done
1663 (format "%S" value
))))
1666 ;;;-------------------------------------------------------------------------
1667 (defun dcl-guess-option ()
1668 "Guess what option the user wants to set by looking around in the code.
1669 Returns the name of the option variable as a string."
1670 (let ((case-fold-search t
))
1673 ((eq (dcl-get-line-type) '-
)
1674 "dcl-calc-cont-indent-function")
1678 (looking-at "^\\$[ \t]*!"))
1679 "dcl-comment-line-regexp")
1680 ;; Margin offset: subroutine statement or first line in buffer
1681 ;; Test this before label indentation to detect a subroutine
1684 (or (looking-at (concat "^\\$[ \t]*" dcl-label-r dcl-ws-r
1687 (not (dcl-backward-command t
)))))
1688 "dcl-margin-offset")
1689 ;; Margin offset: on command line after subroutine statement
1692 (and (eq (dcl-get-line-type) '$
)
1693 (dcl-backward-command)
1694 (looking-at (concat "^\\$[ \t]*" dcl-label-r dcl-ws-r
1696 "dcl-margin-offset")
1697 ;; Label indentation
1700 (and (looking-at (concat "^\\$[ \t]*" dcl-label-r
))
1701 (not (and dcl-block-begin-regexp
1702 (looking-at (concat "^\\$[ \t]*"
1703 dcl-block-begin-regexp
))))
1704 (not (and dcl-block-end-regexp
1705 (looking-at (concat "^\\$[ \t]*"
1706 dcl-block-end-regexp
))))))
1707 "dcl-margin-label-offset")
1709 ((and (eq (dcl-get-line-type) '$
) ; beginning of command
1712 (let* ((this-indent (save-excursion
1713 (dcl-back-to-indentation)
1715 (prev-indent (save-excursion
1716 (if (dcl-backward-command)
1718 (dcl-back-to-indentation)
1719 (current-column)))))
1720 (next-indent (save-excursion
1721 (dcl-end-of-command)
1722 (if (dcl-forward-command)
1724 (dcl-beginning-of-command)
1725 (dcl-back-to-indentation)
1726 (current-column))))))
1727 (or (and prev-indent
; last cmd is indented differently
1728 (/= (- this-indent prev-indent
) 0))
1730 (/= (- this-indent next-indent
) 0))))))
1737 ;;;-------------------------------------------------------------------------
1738 (defun dcl-set-option (option-sym option-value
)
1739 "Set a value for one of the dcl customization variables.
1740 The function tries to guess which variable should be set and to what value.
1741 All variable names are available as completions and in the history list."
1744 (intern (completing-read
1745 "Set DCL option: " ; prompt
1746 (mapcar (function ; alist of valid values
1747 (lambda (option-assoc)
1748 (cons (format "%s" (car option-assoc
)) nil
)))
1751 t
; only value from the list OK
1752 (dcl-guess-option) ; initial (default) value
1753 'dcl-option-history
))) ; history list
1756 (format "Set DCL option %s to: " option-sym
)
1757 (dcl-guess-option-value option-sym
))))
1758 (list option-sym option-value
)))
1759 ;; Should make a sanity check on the symbol/value pair.
1760 ;; `set' instead of `setq' because we want option-sym to be evaluated.
1761 (set option-sym option-value
))
1764 ;;; *** Save options ********************************************************
1767 ;;;-------------------------------------------------------------------------
1768 (defun dcl-save-local-variable (var &optional def-prefix def-suffix
)
1769 "Save a variable in a `Local Variables' list.
1770 Set or update the value of VAR in the current buffers
1771 `Local Variables:' list."
1772 ;; Look for "Local variables:" line in last page.
1774 (goto-char (point-max))
1775 (search-backward "\n\^L" (max (- (point-max) 3000) (point-min)) 'move
)
1776 (if (let ((case-fold-search t
))
1777 (search-forward "Local Variables:" nil t
))
1779 prefix prefixlen suffix beg
1780 prefix-string suffix-string
)
1781 ;; The prefix is what comes before "local variables:" in its line.
1782 ;; The suffix is what comes after "local variables:" in its line.
1783 (skip-chars-forward " \t")
1785 (setq suffix-string
(buffer-substring (point)
1786 (progn (end-of-line) (point)))))
1787 (goto-char (match-beginning 0))
1790 (buffer-substring (point)
1791 (progn (beginning-of-line) (point)))))
1793 (if prefix-string
(setq prefixlen
(length prefix-string
)
1794 prefix
(regexp-quote prefix-string
)))
1795 (if suffix-string
(setq suffix
(concat (regexp-quote suffix-string
)
1798 ;; Look at next local variable spec.
1799 (if selective-display
(re-search-forward "[\n\C-m]")
1801 ;; Skip the prefix, if any.
1803 (if (looking-at prefix
)
1804 (forward-char prefixlen
)
1805 (error "Local variables entry is missing the prefix")))
1806 ;; Find the variable name; strip whitespace.
1807 (skip-chars-forward " \t")
1809 (skip-chars-forward "^:\n")
1810 (if (eolp) (error "Missing colon in local variables entry"))
1811 (skip-chars-backward " \t")
1812 (let* ((str (buffer-substring beg
(point)))
1813 (found-var (read str
))
1815 ;; Setting variable named "end" means end of list.
1816 (if (string-equal (downcase str
) "end")
1818 ;; Not found. Insert a new entry before this line
1821 (insert (concat prefix-string
(symbol-name var
) ": "
1822 (prin1-to-string (eval var
)) " "
1823 suffix-string
"\n")))
1824 ;; Is it the variable we are looking for?
1825 (if (eq var found-var
)
1827 ;; Found it: delete the variable value and insert the
1830 (skip-chars-forward "^:")
1832 (delete-region (point) (progn (read (current-buffer))
1835 (prin1 (eval var
) (current-buffer))
1836 (skip-chars-backward "\n")
1837 (skip-chars-forward " \t")
1838 (or (if suffix
(looking-at suffix
) (eolp))
1840 "Local variables entry is terminated incorrectly")))
1842 ;; Did not find "Local variables:"
1843 (goto-char (point-max))
1846 ;; If def- parameter not set, use comment- if set. In that case, make
1847 ;; sure there is a space in a suitable position
1853 (if (or (equal comment-start
"")
1854 (string-match "[ \t]$" comment-start
))
1856 (concat comment-start
" ")))))
1862 (if (or (equal comment-end
"")
1863 (string-match "^[ \t]" comment-end
))
1865 (concat " " comment-end
))))))
1866 (insert (concat def-prefix
"Local variables:" def-suffix
"\n"))
1867 (insert (concat def-prefix
(symbol-name var
) ": "
1868 (prin1-to-string (eval var
)) def-suffix
"\n"))
1869 (insert (concat def-prefix
"end:" def-suffix
)))
1873 ;;;-------------------------------------------------------------------------
1874 (defun dcl-save-all-options ()
1875 "Save all dcl-mode options for this buffer.
1876 Saves or updates all dcl-mode related options in a `Local Variables:'
1877 section at the end of the current buffer."
1879 (mapcar (lambda (option-assoc)
1880 (let* ((option (car option-assoc
)))
1881 (dcl-save-local-variable option
"$! ")))
1885 ;;;-------------------------------------------------------------------------
1886 (defun dcl-save-nondefault-options ()
1887 "Save changed DCL mode options for this buffer.
1888 Saves or updates all DCL mode related options that don't have their
1889 default values in a `Local Variables:' section at the end of the
1892 No entries are removed from the `Local Variables:' section. This means
1893 that if a variable is given a non-default value in the section and
1894 later is manually reset to its default value, the variable's entry will
1895 still be present in the `Local Variables:' section with its old value."
1897 (mapcar (lambda (option-assoc)
1898 (let* ((option (car option-assoc
))
1899 (option-name (symbol-name option
)))
1900 (if (and (string-equal "dcl-"
1901 (substring option-name
0 4))
1902 (not (equal (default-value option
) (eval option
))))
1903 (dcl-save-local-variable option
"$! "))))
1907 ;;;-------------------------------------------------------------------------
1908 (defun dcl-save-option (option)
1909 "Save a DCL mode option for this buffer.
1910 Saves or updates an option in a `Local Variables:'
1911 section at the end of the current buffer."
1913 (let ((option (intern (completing-read "Option: " obarray
))))
1915 (dcl-save-local-variable option
))
1918 ;;;-------------------------------------------------------------------------
1919 (defun dcl-save-mode ()
1920 "Save the current mode for this buffer.
1921 Save the current mode in a `Local Variables:'
1922 section at the end of the current buffer."
1924 (let ((mode (prin1-to-string major-mode
)))
1925 (if (string-match "-mode$" mode
)
1926 (let ((mode (intern (substring mode
0 (match-beginning 0)))))
1927 (dcl-save-option 'mode
))
1928 (message "Strange mode: %s" mode
))))
1931 ;;; *** Templates ***********************************************************
1932 ;; tempo seems to be the only suitable package among those included in
1933 ;; standard Emacs. I would have liked something closer to the functionality
1934 ;; of LSE templates...
1936 (defvar dcl-tempo-tags nil
1937 "Tempo tags for DCL mode.")
1939 (tempo-define-template "dcl-f$context"
1940 '("f$context" dcl-tempo-left-paren
1941 (p "context-type: ") dcl-tempo-comma
1942 (p "context-symbol: ") dcl-tempo-comma
1943 (p "selection-item: ") dcl-tempo-comma
1944 (p "selection-value: ") dcl-tempo-comma
1945 (p "value-qualifier: ") dcl-tempo-right-paren
)
1946 "f$context" "" 'dcl-tempo-tags
)
1948 (tempo-define-template "dcl-f$csid"
1949 '("f$csid" dcl-tempo-left-paren
1950 (p "context-symbol: ") dcl-tempo-right-paren
)
1951 "f$csid" "" 'dcl-tempo-tags
)
1953 (tempo-define-template "dcl-f$cvsi"
1954 '("f$cvsi" dcl-tempo-left-paren
1955 (p "start-bit: ") dcl-tempo-comma
1956 (p "number-of-bits: ") dcl-tempo-comma
1957 (p "string: ") dcl-tempo-right-paren
)
1958 "f$cvsi" "" 'dcl-tempo-tags
)
1960 (tempo-define-template "dcl-f$cvtime"
1961 '("f$cvtime" dcl-tempo-left-paren
1962 (p "[input_time]: ") dcl-tempo-comma
1963 (p "[output_time_format]: ") dcl-tempo-comma
1964 (p "[output_field]: ") dcl-tempo-right-paren
)
1965 "f$cvtime" "" 'dcl-tempo-tags
)
1967 (tempo-define-template "dcl-f$cvui"
1968 '("f$cvui" dcl-tempo-left-paren
1969 (p "start-bit: ") dcl-tempo-comma
1970 (p "number-of-bits: ") dcl-tempo-comma
1971 (p "string") dcl-tempo-right-paren
)
1972 "f$cvui" "" 'dcl-tempo-tags
)
1974 (tempo-define-template "dcl-f$device"
1975 '("f$device" dcl-tempo-left-paren
1976 (p "[search_devnam]: ") dcl-tempo-comma
1977 (p "[devclass]: ") dcl-tempo-comma
1978 (p "[devtype]: ") dcl-tempo-comma
1979 (p "[stream-id]: ") dcl-tempo-right-paren
)
1980 "f$device" "" 'dcl-tempo-tags
)
1982 (tempo-define-template "dcl-f$directory"
1983 '("f$directory" dcl-tempo-left-paren
1984 dcl-tempo-right-paren
)
1985 "f$directory" "" 'dcl-tempo-tags
)
1987 (tempo-define-template "dcl-f$edit"
1988 '("f$edit" dcl-tempo-left-paren
1989 (p "string: ") dcl-tempo-comma
1990 (p "edit-list: ") dcl-tempo-right-paren
)
1991 "f$edit" "" 'dcl-tempo-tags
)
1993 (tempo-define-template "dcl-f$element"
1994 '("f$element" dcl-tempo-left-paren
1995 (p "element-number: ") dcl-tempo-comma
1996 (p "delimiter: ") dcl-tempo-comma
1997 (p "string: ") dcl-tempo-right-paren
)
1998 "f$element" "" 'dcl-tempo-tags
)
2000 (tempo-define-template "dcl-f$environment"
2001 '("f$environment" dcl-tempo-left-paren
2002 (p "item: ") dcl-tempo-right-paren
)
2003 "f$environment" "" 'dcl-tempo-tags
)
2005 (tempo-define-template "dcl-f$extract"
2006 '("f$extract" dcl-tempo-left-paren
2007 (p "start: ") dcl-tempo-comma
2008 (p "length: ") dcl-tempo-comma
2009 (p "string: ") dcl-tempo-right-paren
)
2010 "f$extract" "" 'dcl-tempo-tags
)
2012 (tempo-define-template "dcl-f$fao"
2013 '("f$fao" dcl-tempo-left-paren
2014 (p "control-string: ") dcl-tempo-comma
2015 ("argument[,...]: ") dcl-tempo-right-paren
)
2016 "f$fao" "" 'dcl-tempo-tags
)
2018 (tempo-define-template "dcl-f$file_attributes"
2019 '("f$file_attributes" dcl-tempo-left-paren
2020 (p "filespec: ") dcl-tempo-comma
2021 (p "item: ") dcl-tempo-right-paren
)
2022 "f$file_attributes" "" 'dcl-tempo-tags
)
2024 (tempo-define-template "dcl-f$getdvi"
2025 '("f$getdvi" dcl-tempo-left-paren
2026 (p "device-name: ") dcl-tempo-comma
2027 (p "item: ") dcl-tempo-right-paren
)
2028 "f$getdvi" "" 'dcl-tempo-tags
)
2030 (tempo-define-template "dcl-f$getjpi"
2031 '("f$getjpi" dcl-tempo-left-paren
2032 (p "pid: ") dcl-tempo-comma
2033 (p "item: ") dcl-tempo-right-paren
)
2034 "f$getjpi" "" 'dcl-tempo-tags
)
2036 (tempo-define-template "dcl-f$getqui"
2037 '("f$getqui" dcl-tempo-left-paren
2038 (p "function: ") dcl-tempo-comma
2039 (p "[item]: ") dcl-tempo-comma
2040 (p "[object-id]: ") dcl-tempo-comma
2041 (p "[flags]: ") dcl-tempo-right-paren
)
2042 "f$getqui" "" 'dcl-tempo-tags
)
2044 (tempo-define-template "dcl-f$getsyi"
2045 '("f$getsyi" dcl-tempo-left-paren
2046 (p "item: ") dcl-tempo-comma
2047 (p "[node-name]: ") dcl-tempo-comma
2048 (p "[cluster-id]: ") dcl-tempo-right-paren
)
2049 "f$getsyi" "" 'dcl-tempo-tags
)
2051 (tempo-define-template "dcl-f$identifier"
2052 '("f$identifier" dcl-tempo-left-paren
2053 (p "identifier: ") dcl-tempo-comma
2054 (p "conversion-type: ") dcl-tempo-right-paren
)
2055 "f$identifier" "" 'dcl-tempo-tags
)
2057 (tempo-define-template "dcl-f$integer"
2058 '("f$integer" dcl-tempo-left-paren
2059 (p "expression: ") dcl-tempo-right-paren
)
2060 "f$integer" "" 'dcl-tempo-tags
)
2062 (tempo-define-template "dcl-f$length"
2063 '("f$length" dcl-tempo-left-paren
2064 (p "string: ") dcl-tempo-right-paren
)
2065 "f$length" "" 'dcl-tempo-tags
)
2067 (tempo-define-template "dcl-f$locate"
2068 '("f$locate" dcl-tempo-left-paren
2069 (p "substring: ") dcl-tempo-comma
2070 (p "string: ") dcl-tempo-right-paren
)
2071 "f$locate" "" 'dcl-tempo-tags
)
2073 (tempo-define-template "dcl-f$message"
2074 '("f$message" dcl-tempo-left-paren
2075 (p "status-code: ") dcl-tempo-right-paren
)
2076 "f$message" "" 'dcl-tempo-tags
)
2078 (tempo-define-template "dcl-f$mode"
2079 '("f$mode" dcl-tempo-left-paren dcl-tempo-right-paren
)
2080 "f$mode" "" 'dcl-tempo-tags
)
2082 (tempo-define-template "dcl-f$parse"
2083 '("f$parse" dcl-tempo-left-paren
2084 (p "filespec: ") dcl-tempo-comma
2085 (p "[default-spec]: ") dcl-tempo-comma
2086 (p "[related-spec]: ") dcl-tempo-comma
2087 (p "[field]: ") dcl-tempo-comma
2088 (p "[parse-type]: ") dcl-tempo-right-paren
)
2089 "f$parse" "" 'dcl-tempo-tags
)
2091 (tempo-define-template "dcl-f$pid"
2092 '("f$pid" dcl-tempo-left-paren
2093 (p "context-symbol: ") dcl-tempo-right-paren
)
2094 "f$pid" "" 'dcl-tempo-tags
)
2096 (tempo-define-template "dcl-f$privilege"
2097 '("f$privilege" dcl-tempo-left-paren
2098 (p "priv-states: ") dcl-tempo-right-paren
)
2099 "f$privilege" "" 'dcl-tempo-tags
)
2101 (tempo-define-template "dcl-f$process"
2103 "f$process" "" 'dcl-tempo-tags
)
2105 (tempo-define-template "dcl-f$search"
2106 '("f$search" dcl-tempo-left-paren
2107 (p "filespec: ") dcl-tempo-comma
2108 (p "[stream-id]: ") dcl-tempo-right-paren
)
2109 "f$search" "" 'dcl-tempo-tags
)
2111 (tempo-define-template "dcl-f$setprv"
2112 '("f$setprv" dcl-tempo-left-paren
2113 (p "priv-states: ") dcl-tempo-right-paren
)
2114 "f$setprv" "" 'dcl-tempo-tags
)
2116 (tempo-define-template "dcl-f$string"
2117 '("f$string" dcl-tempo-left-paren
2118 (p "expression: ") dcl-tempo-right-paren
)
2119 "f$string" "" 'dcl-tempo-tags
)
2121 (tempo-define-template "dcl-f$time"
2122 '("f$time" dcl-tempo-left-paren dcl-tempo-right-paren
)
2123 "f$time" "" 'dcl-tempo-tags
)
2125 (tempo-define-template "dcl-f$trnlnm"
2126 '("f$trnlnm" dcl-tempo-left-paren
2127 (p "logical-name: ") dcl-tempo-comma
2128 (p "[table]: ") dcl-tempo-comma
2129 (p "[index]: ") dcl-tempo-comma
2130 (p "[mode]: ") dcl-tempo-comma
2131 (p "[case]: ") dcl-tempo-comma
2132 (p "[item]: ") dcl-tempo-right-paren
)
2133 "f$trnlnm" "" 'dcl-tempo-tags
)
2135 (tempo-define-template "dcl-f$type"
2136 '("f$type" dcl-tempo-left-paren
2137 (p "symbol-name: ") dcl-tempo-right-paren
)
2138 "f$type" "" 'dcl-tempo-tags
)
2140 (tempo-define-template "dcl-f$user"
2141 '("f$user" dcl-tempo-left-paren dcl-tempo-right-paren
)
2142 "f$user" "" 'dcl-tempo-tags
)
2144 (tempo-define-template "dcl-f$verify"
2145 '("f$verify" dcl-tempo-left-paren
2146 (p "[procedure-value]: ") dcl-tempo-comma
2147 (p "[image-value]: ") dcl-tempo-right-paren
)
2148 "f$verify" "" 'dcl-tempo-tags
)
2153 ;;; *** Unsorted stuff *****************************************************
2156 ;;;-------------------------------------------------------------------------
2157 (defun dcl-beginning-of-command-p ()
2158 "Return t if point is at the beginning of a command.
2159 Otherwise return nil."
2161 (eq (dcl-get-line-type) '$
)))
2164 ;;;-------------------------------------------------------------------------
2165 (defun dcl-end-of-command-p ()
2166 "Check if point is at the end of a command.
2167 Return t if point is at the end of a command, either the end of an
2168 only line or at the end of the last continuation line.
2169 Otherwise return nil."
2170 ;; Must be at end-of-line on a command line or a continuation line
2171 (let ((type (dcl-get-line-type)))
2175 ;; Next line must not be a continuation line
2178 (not (eq (dcl-get-line-type) '-
))))))
2181 ;;;-------------------------------------------------------------------------
2182 (defun dcl-command-p ()
2183 "Check if point is on a command line.
2184 Return t if point is on a command line or a continuation line,
2185 otherwise return nil."
2186 (let ((type (dcl-get-line-type)))
2191 ;;;-------------------------------------------------------------------------
2192 (defun dcl-was-looking-at (regexp)
2194 (let ((start (point))
2195 (found (re-search-backward regexp
0 t
)))
2198 (equal start
(match-end 0))))))
2200 (declare-function imenu-default-create-index-function
"imenu" ())
2202 ;;;-------------------------------------------------------------------------
2203 (defun dcl-imenu-create-index-function ()
2204 "Jacket routine to make imenu searches non case sensitive."
2205 (let ((case-fold-search t
))
2206 (imenu-default-create-index-function)))
2210 ;;; *** Epilogue ************************************************************
2215 (run-hooks 'dcl-mode-load-hook
) ; for your customizations
2217 ;; arch-tag: e00d421b-f26c-483e-a8bd-af412ea7764a
2218 ;;; dcl-mode.el ends here