emacs: lisp/progmodes/dcl-mode.el comparison

comparison lisp/progmodes/dcl-mode.el @ 49598:0d8b17d428b5

Trailing whitepace deleted.

author	Juanma Barranquero <lekktu@gmail.com>
date	Tue, 04 Feb 2003 13:24:35 +0000
parents	5a5a4566e9f7
children	534fbe8d6c4b d7ddb3e565de

comparison

equal deleted inserted replaced

-:e88404e8f2cf
+:0d8b17d428b5
 ;; indent lines, add leading `$' and trailing `-', move around in the
 ;; code and insert lexical functions.
 ;;
 ;; Type `C-h m' when you are editing a .COM file to get more
 ;; information about this mode.
 ;;
 ;; To use templates you will need a version of tempo.el that is at
 ;; least later than the buggy 1.1.1, which was included with my versions of
 ;; Emacs.  I used version 1.2.4.
 ;; The latest tempo.el distribution can be fetched from
 ;; ftp.lysator.liu.se in the directory /pub/emacs.
 ;; I recommend setting (setq tempo-interactive t).  This will make
 ;; tempo prompt you for values to put in the blank spots in the templates.
 ;;
 ;; the version I use in Emacs 19.30.  (It was *so* much easier to hook
 ;; into that version than the one in 19.27...)
 ;;
 ;; Any feedback will be welcomed.  If you write functions for
 ;; dcl-calc-command-indent-function or dcl-calc-cont-indent-function,
 ;; please send them to the maintainer.
 ;;
 ;;
 ;; Ideas for improvement:
 ;; * Change meaning of `left margin' when dcl-tab-always-indent is nil.
 ;;   Consider the following line (`_' is the cursor):
 ;;     $ label: _ command
 :group 'dcl)
 (defcustom dcl-margin-offset 8
 "*Indentation for the first command line in DCL.
 The first command line in a file or after a SUBROUTINE statement is indented
 this much.  Other command lines are indented the same number of columns as
 the preceding command line.
 A command line is a line that starts with `$'."
 :type 'integer
 :group 'dcl)
 :group 'dcl)
 (defcustom dcl-calc-command-indent-function nil
 "*Function to calculate indentation for a command line in DCL.
 If this variable is non-nil it is called as a function:
 \(func INDENT-TYPE CUR-INDENT EXTRA-INDENT LAST-POINT THIS-POINT)
 The function must return the number of columns to indent the current line or
 nil to get the default indentation.
 INDENT-TYPE is a symbol indicating what kind of indentation should be done.
 It can have the following values:
 indent      the lines indentation should be increased, e.g. after THEN.
 outdent     the lines indentation should be decreased, e.g a line with ENDIF.
 first-line  indentation for the first line in a buffer or SUBROUTINE.
 CUR-INDENT is the indentation of the preceding command line.
 EXTRA-INDENT is the default change in indentation for this line
 \(a negative number for 'outdent).
 LAST-POINT is the buffer position of the first significant word on the
 previous line or nil if the current line is the first line.
 THIS-POINT is the buffer position of the first significant word on the
 current line.
 If this variable is nil, the indentation is calculated as
 CUR-INDENT + EXTRA-INDENT.
 This package includes two functions suitable for this:
 dcl-calc-command-indent-multiple
 dcl-calc-command-indent-hang"
 :group 'dcl)
 (defcustom dcl-calc-cont-indent-function 'dcl-calc-cont-indent-relative
 "*Function to calculate indentation for a continuation line.
 If this variable is non-nil it is called as a function:
 \(func CUR-INDENT EXTRA-INDENT)
 The function must return the number of columns to indent the current line or
 nil to get the default indentation.
 If this variable is nil, the indentation is calculated as
 CUR-INDENT + EXTRA-INDENT.
 This package includes one function suitable for this:
 dcl-calc-cont-indent-relative"
 :type 'function
 (defcustom dcl-tab-always-indent t
 "*Controls the operation of the TAB key in DCL mode.
 If t, pressing TAB always indents the current line.
 If nil, pressing TAB indents the current line if point is at the left margin.
 Data lines (i.e. lines not part of a command line or continuation line) are
 never indented."
 :type 'boolean
 :group 'dcl)
 (,dcl-imenu-label-gosub "\\s-GOSUB[ \t]+\\([A-Za-z0-9_\$]+\\)" 1)
 (,dcl-imenu-label-call "\\s-CALL[ \t]+\\([A-Za-z0-9_\$]+\\)" 1))
 "*Default imenu generic expression for DCL.
 The default includes SUBROUTINE labels in the main listing and
 sub-listings for other labels, CALL, GOTO and GOSUB statements.
 See `imenu-generic-expression' for details."
 :type '(repeat (sexp :tag "Imenu Expression"))
 :group 'dcl)
 (setq dcl-mode-syntax-table (make-syntax-table))
 (modify-syntax-entry ?!  "<" dcl-mode-syntax-table) ; comment start
 (modify-syntax-entry ?\n ">" dcl-mode-syntax-table) ; comment end
 (modify-syntax-entry ?< "(>" dcl-mode-syntax-table) ; < and ...
 (modify-syntax-entry ?> ")<" dcl-mode-syntax-table) ; > is a matching pair
 )
 (defvar dcl-mode-map ()
 "Keymap used in DCL-mode buffers.")
 (if dcl-mode-map
 A label is a name followed by a colon followed by white-space or end-of-line."
 :type 'regexp
 :group 'dcl)
 (defcustom dcl-cmd-r
 "^\\$\\(.*-[ \t]*\\(!.*\\)*\n\\)*[^!\"\n]*\\(\".*\\(\"\".*\\)*\"\\)*[^!\"\n]*"
 "Regular expression describing a DCL command line up to a trailing comment.
 A line starting with $, optionally followed by continuation lines,
 followed by the end of the command line.
 A continuation line is any characters followed by `-',
 optionally followed by a comment, followed by a newline."
 :type 'regexp
 :group 'dcl)
 (defcustom dcl-command-regexp
 "^\\$\\(.*-[ \t]*\\(!.*\\)*\n\\)*.*\\(\".*\\(\"\".*\\)*\"\\)*"
 "Regular expression describing a DCL command line.
 A line starting with $, optionally followed by continuation lines,
 followed by the end of the command line.
 A continuation line is any characters followed by `-',
 `endif', the line will be reindented."
 :type '(repeat regexp)
 :group 'dcl)
 (defvar dcl-option-alist
 '((dcl-basic-offset dcl-option-value-basic)
 (dcl-continuation-offset curval)
 (dcl-margin-offset dcl-option-value-margin-offset)
 (dcl-margin-label-offset dcl-option-value-offset)
 (dcl-comment-line-regexp dcl-option-value-comment-line)
 (dcl-block-begin-regexp curval)
 (dcl-block-end-regexp curval)
 (dcl-tab-always-indent toggle)
 (dcl-electric-characters toggle)
 (dcl-electric-reindent-regexps curval)
 (dcl-tempo-comma curval)
 (dcl-tempo-left-paren curval)
 (dcl-tempo-right-paren curval)
 (dcl-calc-command-indent-function curval)
 (dcl-calc-cont-indent-function curval)
 (comment-start curval)
 (comment-start-skip curval)
 )
 The keywords are:
 curval       the current value
 toggle       the opposite of the current value (for t/nil)")
 (defvar dcl-option-history
 (mapcar (lambda (option-assoc)
 	    (format "%s" (car option-assoc)))
 	  dcl-option-alist)
 "The history list for dcl-set-option.
 Preloaded with all known option names from dcl-option-alist")
 ;			"GOSUB[ \t]+\\([A-Za-z0-9_\$]+\\)")) 5)
 ;    ("CALL" (, (concat dcl-cmd-r "CALL[ \t]+\\([A-Za-z0-9_\$]+\\)")) 5)))
 ;  "*Default imenu generic expression for DCL.
 ;The default includes SUBROUTINE labels in the main listing and
 ;sub-listings for other labels, CALL, GOTO and GOSUB statements.
 ;See `imenu-generic-expression' in a recent (e.g. Emacs 19.30) imenu.el
 ;for details.")
 ;;; *** Mode initialization *************************************************
 This mode indents command lines in blocks.  (A block is commands between
 THEN-ELSE-ENDIF and between lines matching dcl-block-begin-regexp and
 dcl-block-end-regexp.)
 Labels are indented to a fixed position unless they begin or end a block.
 Whole-line comments (matching dcl-comment-line-regexp) are not indented.
 Data lines are not indented.
 Key bindings:
 \\{dcl-mode-map}
 dcl-margin-label-offset
 Indentation for a label.
 dcl-comment-line-regexp
 Lines matching this regexp will not be indented.
 dcl-block-begin-regexp
 dcl-block-end-regexp
 Regexps that match command lines that begin and end, respectively,
 a block of commmand lines that will be given extra indentation.
 One such function is included in the package:
 	dcl-calc-cont-indent-relative    (set by default)
 dcl-tab-always-indent
 If t, pressing TAB always indents the current line.
 If nil, pressing TAB indents the current line if point is at the left
 margin.
 dcl-electric-characters
 Non-nil causes lines to be indented at once when a label, ELSE or ENDIF is
 typed.
 dcl-electric-reindent-regexps
 Use this variable and function dcl-electric-character to customize
 These variables control the look of expanded templates.
 dcl-imenu-generic-expression
 Default value for imenu-generic-expression.  The default includes
 SUBROUTINE labels in the main listing and sub-listings for
 other labels, CALL, GOTO and GOSUB statements.
 dcl-imenu-label-labels
 dcl-imenu-label-goto
 dcl-imenu-label-gosub
 dcl-imenu-label-call
 Change the text that is used as sub-listing labels in imenu.
 Loading this package calls the value of the variable
 `dcl-mode-load-hook' with no args, if that value is non-nil.
 Turning on DCL mode calls the value of the variable `dcl-mode-hook'
 with no args, if that value is non-nil.
 The following example uses the default values for all variables:
 $! This is a comment line that is not indented (it matches
 $! dcl-comment-line-regexp)
 $! Next follows the first command line.  It is indented dcl-margin-offset.
 $       i = 1
 $       ! Other comments are indented like command lines.
 $       ! A margin label indented dcl-margin-label-offset:
 $ label:
 $       if i.eq.1
 $       then
 $           ! Lines between THEN-ELSE and ELSE-ENDIF are
 $           ! indented dcl-basic-offset
 $           loop1: ! This matches dcl-block-begin-regexp...
 $               ! ...so this line is indented dcl-basic-offset
 $               text = \"This \" + - ! is a continued line
 \"lined up with the command line\"
 $               type sys$input
 Data lines are not indented at all.
 $           endloop1: ! This matches dcl-block-end-regexp
 $       endif
 $
 "
 (interactive)
 (make-local-variable 'comment-end)
 (setq comment-end "")
 (make-local-variable 'comment-multi-line)
 (setq comment-multi-line nil)
 ;; This used to be "^\\$[ \t]*![ \t]*" which looks more correct.
 ;; The drawback was that you couldn't make empty comment lines by pressing
 ;; C-M-j repeatedly - only the first line became a comment line.
 ;; This version has the drawback that the "$" can be anywhere in the line,
 ;; and something inappropriate might be interpreted as a comment.
 (make-local-variable 'dcl-tab-always-indent)
 (make-local-variable 'dcl-electric-characters)
 (make-local-variable 'dcl-calc-command-indent-function)
 (make-local-variable 'dcl-calc-cont-indent-function)
 (make-local-variable 'dcl-electric-reindent-regexps)
 (setq major-mode 'dcl-mode)
 (setq mode-name "DCL")
 (use-local-map dcl-mode-map)
 (tempo-use-tag-list 'dcl-tempo-tags)
 (run-hooks 'dcl-mode-hook))
 ;;;-------------------------------------------------------------------------
 (defun dcl-backward-command (&optional incl-comment-commands)
 "Move backward to a command.
 Move point to the preceding command line that is not a comment line,
 a command line with only a comment, only contains a `$' or only
 contains a label.
 Returns point of the found command line or nil if not able to move."
 (interactive)
 (let ((start (point))
 	done
 ;;;-------------------------------------------------------------------------
 (defun dcl-forward-command (&optional incl-comment-commands)
 "Move forward to a command.
 Move point to the end of the next command line that is not a comment line,
 a command line with only a comment, only contains a `$' or only
 contains a label.
 Returns point of the found command line or nil if not able to move."
 (interactive)
 (let ((start (point))
 	done
 "Move point to the first non-whitespace character on this line.
 Leading $ and labels counts as whitespace in this case.
 If this is a comment line then move to the first non-whitespace character
 in the comment.
 Typing \\[dcl-back-to-indentation] several times in a row will move point to other
 `interesting' points closer to the left margin, and then back to the
 rightmost point again.
 E.g. on the following line, point would go to the positions indicated
 by the numbers in order 1-2-3-1-... :
 $ label: command
 ;;  4  3   2  1
 ;;
 ;;  $  !  text
 ;;  3  2  1
 ;;
 ;;  $  l:  command  !
 ;;  3  2   1
 ;;
 ;;  text
 ;;  1
 (if (< (point) limit)
 	(setq last-good-point (point)))
 (cond
 ;; Special treatment for comment lines.  We are trying to allow
 ;; things like "$ !*" as comment lines.
 ((looking-at dcl-comment-line-regexp)
 (re-search-forward (concat dcl-comment-line-regexp "[ \t]*") limit t)
 (if (< (point) limit)
 	  (setq last-good-point (point))))
 "Return point of first non-`whitespace' on this line."
 (save-excursion
 (dcl-back-to-indentation)
 (point)))
 ;;;---------------------------------------------------------------------------
 (defun dcl-show-line-type ()
 "Test dcl-get-line-type."
 (interactive)
 (let ((type (dcl-get-line-type)))
 $   endif
 $ xxx
 If you use this function you will probably want to add \"then\" to
 dcl-electric-reindent-regexps and define the key \"n\" as
 dcl-electric-character.
 "
 (let ((case-fold-search t))
 (save-excursion
 (cond
 ;; No indentation, this word is `then': +2
 	(cond
 	 ((looking-at "\\bthen\\b")
 	  (- (+ cur-indent extra-indent) 2))
 	 ((looking-at "\\belse\\b")
 	  (- (+ cur-indent extra-indent) 2))))
 ;; Outdent, this word is `endif' or `else': + 2
 ((equal indent-type 'outdent)
 	(goto-char this-point)
 	(cond
 	 ((looking-at "\\bendif\\b")
 	  (+ cur-indent extra-indent 2))
 method or by calling dcl-calc-command-indent-function if it is
 non-nil.
 If the current line should be outdented, calculate its indentation,
 either with the default method or by calling
 dcl-calc-command-indent-function if it is non-nil.
 Rules for default indentation:
 If it is the first line in the buffer, indent dcl-margin-offset.
 Go to the previous command line with a command on it.
 Find out how much it is indented (cur-indent).
 Look at the first word on the line to see if the indentation should be
 adjusted.  Skip margin-label, continuations and comments while looking for
 the first word.  Save this buffer position as `last-point'.
 If the first word after a label is SUBROUTINE, set extra-indent to
 dcl-margin-offset.
 First word  extra-indent
 THEN        +dcl-basic-offset
 ELSE        +dcl-basic-offset
 block-begin +dcl-basic-offset
 Then return to the current line and look at the first word to see if the
 indentation should be adjusted again.  Save this buffer position as
 `this-point'.
 First word  extra-indent
 ELSE        -dcl-basic-offset
 ENDIF       -dcl-basic-offset
 block-end   -dcl-basic-offset
 If dcl-calc-command-indent-function is nil or returns nil set
 cur-indent to cur-indent+extra-indent.
 If an extra adjustment is necessary and if
 dcl-calc-command-indent-function is nil or returns nil set cur-indent
 to cur-indent+extra-indent.
 See also documentation for dcl-calc-command-indent-function.
 The indent-type classification could probably be expanded upon.
 "
 ()
 (concat "^\\$" dcl-ws-r dcl-label-r dcl-ws-r "$")))
 (setq done t))) ; not a label-only line, exit the loop
 ;; We couldn't go further back, so this must have been the
 		;; first line.
 (setq cur-indent dcl-margin-offset
 		      last-point (dcl-indentation-point))
 (setq done t)))
 	    ;; Examine the line to get current indentation and possibly a
 	    ;; reason to indent.
 (cond
 (cur-indent)
 $ if ((a.eq.b .and. -
 d.eq.c .or. f$function(xxxx, -
 yyy)))
 "
 (let ((case-fold-search t)
 	indent)
 (save-excursion
 (dcl-beginning-of-statement)
 (let ((end (save-excursion (forward-line 1) (point))))
 	;; Move over blanks and label
 	(if (re-search-forward (concat "^\\$[ \t]*\\(" dcl-label-r
 			(progn
 			  (setq was-assignment t)
 			  (skip-chars-forward " \t:=" end)))
 		    ;; This could be the position to indent to
 		    (setq indent (current-column))
 		    ;; Move to the next word unless we have seen an
 		    ;; assignment.  If it starts with `/' it's a
 		    ;; qualifier and we will indent to that position
 		    (if (and (not was-assignment)
 			     (> (skip-chars-forward "a-zA-Z0-9_" end) 0))
 (progn
 (dcl-indent-to dcl-margin-label-offset)
 (re-search-forward dcl-label-r)))
 (dcl-indent-to indent 1)
 )
 ;;
 (if (> (- (point-max) pos) (point))
 (goto-char (- (point-max) pos)))
 ))
 (insert "$" )
 (dcl-indent-command-line))
 (t
 (message "dcl-indent-line: unknown type"))
 )))
 ;;;-------------------------------------------------------------------------
 (defun dcl-indent-command ()
 "Indents the complete command line that point is on.
 This includes continuation lines."
 (interactive "*")
 (let ((type (dcl-get-line-type))
 (start-point (point)))
 (cond
 ;; Data line : always insert tab
 ((or (equal type 'data) (equal type 'empty-data))
 (tab-to-tab-stop))
 ;; Indent only at start of line
 ((not dcl-tab-always-indent)       ; nil
 (let ((search-end-point
 (save-excursion
 (beginning-of-line)
 (re-search-forward "^\\$?[ \t]*" start-point t))))
 ;;;-------------------------------------------------------------------------
 (defun dcl-electric-character (arg)
 "Inserts a character and indents if necessary.
 Insert a character if the user gave a numeric argument or the flag
 `dcl-electric-characters' is not set.  If an argument was given,
 insert that many characters.
 The line is only reindented if the word just typed matches any of the
 regexps in `dcl-electric-reindent-regexps'."
 (self-insert-command 1))
 ;; Insert the character and indent
 (self-insert-command 1)
 (let ((case-fold-search t))
 ;; There must be a better way than (memq t ...).
 ;; (apply 'or ...) didn't work
 (if (memq t (mapcar 'dcl-was-looking-at dcl-electric-reindent-regexps))
 (dcl-indent-line)))))
 ;;;-------------------------------------------------------------------------
 (setq indent (max col (+ collapsed (or minimum 0))))
 (if (/= indent cur-indent)
 	(progn
 	  (dcl-delete-chars " \t")
 	  (indent-to col minimum)))))
 ;;;-------------------------------------------------------------------------
 (defun dcl-split-line ()
 "Break line at point and insert text to keep the syntax valid.
 	 ))))
 ;; use the normal function for other cases
 (if (not done)			; normal M-LFD action
 	(indent-new-comment-line))))
 ;;;-------------------------------------------------------------------------
 (defun dcl-delete-indentation (&optional arg)
 "Join this line to previous like delete-indentation.
 Also remove the continuation mark if easily detected."
 (interactive "*P")
 ;;;-------------------------------------------------------------------------
 (defun dcl-option-value-margin-offset (option-assoc)
 "Guess a value for margin offset.
 Find the column of the first non-blank character on the line, not
 counting labels.
 Returns a number as a string."
 (save-excursion
 (beginning-of-line)
 (dcl-back-to-indentation)
 (current-column)))
 ;; suggesting it.
 (if (looking-at "^\\$[^!\n]*!")
 	 (let ((regexp (buffer-substring (match-beginning 0) (match-end 0))))
 	   (concat "^" (regexp-quote regexp)))
 dcl-comment-line-regexp))))
 ;;;-------------------------------------------------------------------------
 (defun dcl-guess-option-value (option)
 "Guess what value the user would like to give the symbol option."
 (let* ((option-assoc (assoc option dcl-option-alist))
 	       (or (and prev-indent	; last cmd is indented differently
 			(/= (- this-indent prev-indent) 0))
 		   (and next-indent
 			(/= (- this-indent next-indent) 0))))))
 "dcl-basic-offset")
 ;; No more guesses.
 (t
 ""))))
 ;;;-------------------------------------------------------------------------
 ;;;-------------------------------------------------------------------------
 (defun dcl-save-local-variable (var &optional def-prefix def-suffix)
 "Save a variable in a `Local Variables' list.
 Set or update the value of VAR in the current buffers
 `Local Variables:' list."
 ;; Look for "Local variables:" line in last page.
 (save-excursion
 (goto-char (point-max))
 (search-backward "\n\^L" (max (- (point-max) 3000) (point-min)) 'move)
 (if (let ((case-fold-search t))
 	      (if (string-equal (downcase str) "end")
 		  (progn
 		    ;; Not found.  Insert a new entry before this line
 		    (setq continue nil)
 		    (beginning-of-line)
 		    (insert (concat prefix-string (symbol-name var) ": "
 				    (prin1-to-string (eval var)) " "
 				    suffix-string "\n")))
 		;; Is it the variable we are looking for?
 		(if (eq var found-var)
 		    (progn
 		(if (or (equal comment-end "")
 			(string-match "^[ \t]" comment-end))
 		    comment-end
 		  (concat " " comment-end))))))
 	(insert (concat def-prefix "Local variables:" def-suffix "\n"))
 	(insert (concat def-prefix (symbol-name var) ": "
 			(prin1-to-string (eval var)) def-suffix "\n"))
 	(insert (concat def-prefix "end:" def-suffix)))
 )))
 (require 'tempo)
 (defvar dcl-tempo-tags nil
 "Tempo tags for DCL mode.")
 (tempo-define-template "dcl-f$context"
 		       '("f$context" dcl-tempo-left-paren
 			 (p "context-type: ") dcl-tempo-comma
 			 (p "context-symbol: ") dcl-tempo-comma
 			 (p "selection-item: ") dcl-tempo-comma
 			 (p "selection-value: ") dcl-tempo-comma
 			 (p "value-qualifier: ") dcl-tempo-right-paren)
 		       "f$context" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$csid"
 		       '("f$csid" dcl-tempo-left-paren
 			 (p "context-symbol: ") dcl-tempo-right-paren)
 		       "f$csid" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$cvsi"
 		       '("f$cvsi" dcl-tempo-left-paren
 			 (p "start-bit: ") dcl-tempo-comma
 			 (p "number-of-bits: ") dcl-tempo-comma
 			 (p "string: ") dcl-tempo-right-paren)
 		       "f$cvsi" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$cvtime"
 		       '("f$cvtime" dcl-tempo-left-paren
 			 (p "[input_time]: ") dcl-tempo-comma
 			 (p "[output_time_format]: ") dcl-tempo-comma
 			 (p "[output_field]: ") dcl-tempo-right-paren)
 		       "f$cvtime" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$cvui"
 		       '("f$cvui" dcl-tempo-left-paren
 			 (p "start-bit: ") dcl-tempo-comma
 			 (p "number-of-bits: ") dcl-tempo-comma
 			 (p "string") dcl-tempo-right-paren)
 		       "f$cvui" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$device"
 		       '("f$device" dcl-tempo-left-paren
 			 (p "[search_devnam]: ") dcl-tempo-comma
 			 (p "[devclass]: ") dcl-tempo-comma
 			 (p "[devtype]: ") dcl-tempo-comma
 			 (p "[stream-id]: ") dcl-tempo-right-paren)
 		       "f$device" "" 'dcl-tempo-tags)
 		       '("f$directory" dcl-tempo-left-paren
 			 dcl-tempo-right-paren)
 		       "f$directory" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$edit"
 		       '("f$edit" dcl-tempo-left-paren
 			 (p "string: ") dcl-tempo-comma
 			 (p "edit-list: ") dcl-tempo-right-paren)
 		       "f$edit" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$element"
 		       '("f$element" dcl-tempo-left-paren
 			 (p "element-number: ") dcl-tempo-comma
 			 (p "delimiter: ") dcl-tempo-comma
 			 (p "string: ") dcl-tempo-right-paren)
 		       "f$element" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$environment"
 		       '("f$environment" dcl-tempo-left-paren
 			 (p "item: ") dcl-tempo-right-paren)
 		       "f$environment" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$extract"
 		       '("f$extract" dcl-tempo-left-paren
 			 (p "start: ") dcl-tempo-comma
 			 (p "length: ") dcl-tempo-comma
 			 (p "string: ") dcl-tempo-right-paren)
 		       "f$extract" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$fao"
 		       '("f$fao" dcl-tempo-left-paren
 			 (p "control-string: ") dcl-tempo-comma
 			 ("argument[,...]: ") dcl-tempo-right-paren)
 		       "f$fao" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$file_attributes"
 		       '("f$file_attributes" dcl-tempo-left-paren
 			 (p "filespec: ") dcl-tempo-comma
 			 (p "item: ") dcl-tempo-right-paren)
 		       "f$file_attributes" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$getdvi"
 		       '("f$getdvi" dcl-tempo-left-paren
 			 (p "device-name: ") dcl-tempo-comma
 			 (p "item: ") dcl-tempo-right-paren)
 		       "f$getdvi" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$getjpi"
 		       '("f$getjpi" dcl-tempo-left-paren
 			 (p "pid: ") dcl-tempo-comma
 			 (p "item: ") dcl-tempo-right-paren )
 		       "f$getjpi" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$getqui"
 		       '("f$getqui" dcl-tempo-left-paren
 			 (p "function: ") dcl-tempo-comma
 			 (p "[item]: ") dcl-tempo-comma
 			 (p "[object-id]: ") dcl-tempo-comma
 			 (p "[flags]: ") dcl-tempo-right-paren)
 		       "f$getqui" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$getsyi"
 		       '("f$getsyi" dcl-tempo-left-paren
 			 (p "item: ") dcl-tempo-comma
 			 (p "[node-name]: ") dcl-tempo-comma
 			 (p "[cluster-id]: ") dcl-tempo-right-paren)
 		       "f$getsyi" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$identifier"
 		       '("f$identifier" dcl-tempo-left-paren
 			 (p "identifier: ") dcl-tempo-comma
 			 (p "conversion-type: ") dcl-tempo-right-paren)
 		       "f$identifier" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$integer"
 		       '("f$integer" dcl-tempo-left-paren
 			 (p "expression: ") dcl-tempo-right-paren)
 		       "f$integer" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$length"
 		       '("f$length" dcl-tempo-left-paren
 			 (p "string: ") dcl-tempo-right-paren )
 		       "f$length" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$locate"
 		       '("f$locate" dcl-tempo-left-paren
 			 (p "substring: ") dcl-tempo-comma
 			 (p "string: ") dcl-tempo-right-paren)
 		       "f$locate" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$message"
 		       '("f$message" dcl-tempo-left-paren
 			 (p "status-code: ") dcl-tempo-right-paren )
 		       "f$message" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$mode"
 		       '("f$mode" dcl-tempo-left-paren dcl-tempo-right-paren)
 		       "f$mode" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$parse"
 		       '("f$parse" dcl-tempo-left-paren
 			 (p "filespec: ") dcl-tempo-comma
 			 (p "[default-spec]: ") dcl-tempo-comma
 			 (p "[related-spec]: ") dcl-tempo-comma
 			 (p "[field]: ") dcl-tempo-comma
 			 (p "[parse-type]: ") dcl-tempo-right-paren)
 		       "f$parse" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$pid"
 		       '("f$pid" dcl-tempo-left-paren
 			 (p "context-symbol: ") dcl-tempo-right-paren)
 		       "f$pid" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$privilege"
 		       '("f$privilege" dcl-tempo-left-paren
 			 (p "priv-states: ") dcl-tempo-right-paren)
 		       "f$privilege" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$process"
 		       '("f$process()")
 		       "f$process" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$search"
 		       '("f$search" dcl-tempo-left-paren
 			 (p "filespec: ") dcl-tempo-comma
 			 (p "[stream-id]: ") dcl-tempo-right-paren)
 		       "f$search" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$setprv"
 		       '("f$setprv" dcl-tempo-left-paren
 			 (p "priv-states: ") dcl-tempo-right-paren)
 		       "f$setprv" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$string"
 		       '("f$string" dcl-tempo-left-paren
 			 (p "expression: ") dcl-tempo-right-paren)
 		       "f$string" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$time"
 		       '("f$time" dcl-tempo-left-paren dcl-tempo-right-paren)
 		       "f$time" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$trnlnm"
 		       '("f$trnlnm" dcl-tempo-left-paren
 			 (p "logical-name: ") dcl-tempo-comma
 			 (p "[table]: ") dcl-tempo-comma
 			 (p "[index]: ") dcl-tempo-comma
 			 (p "[mode]: ") dcl-tempo-comma
 			 (p "[case]: ") dcl-tempo-comma
 			 (p "[item]: ") dcl-tempo-right-paren)
 		       "f$trnlnm" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$type"
 		       '("f$type" dcl-tempo-left-paren
 			 (p "symbol-name: ") dcl-tempo-right-paren)
 		       "f$type" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$user"
 		       '("f$user" dcl-tempo-left-paren dcl-tempo-right-paren)
 		       "f$user" "" 'dcl-tempo-tags)
 (tempo-define-template "dcl-f$verify"
 		       '("f$verify" dcl-tempo-left-paren
 			 (p "[procedure-value]: ") dcl-tempo-comma
 			 (p "[image-value]: ") dcl-tempo-right-paren)
 		       "f$verify" "" 'dcl-tempo-tags)
 (found (re-search-backward regexp 0 t)))
 (if (not found)
 ()
 (equal start (match-end 0))))))
 ;;;-------------------------------------------------------------------------
 (defun dcl-imenu-create-index-function ()
 "Jacket routine to make imenu searches non case sensitive."
 (let ((case-fold-search t))
 (imenu-default-create-index-function)))

Mercurial > emacs

comparison lisp/progmodes/dcl-mode.el @ 49598:0d8b17d428b5