rsalz@uunet.UU.NET (Rich Salz) (10/06/87)
Submitted-by: "Mark A. Ardis" <maa@sei.cmu.edu> Posting-number: Volume 11, Issue 92 Archive-name: templates/part02 #! /bin/sh # This is a shell archive, meaning: # 1. Remove everything above the #! /bin/sh line. # 2. Save the resulting text in a file. # 3. Execute the file with /bin/sh (not csh) to create: # template.el # tplvars.el export PATH; PATH=/bin:/usr/bin:$PATH echo shar: "extracting 'template.el'" '(26969 characters)' if test -f 'template.el' then echo shar: "will not over-write existing file 'template.el'" else sed 's/^X//' << \SHAR_EOF > 'template.el' X;;; template.el -- generate and manipulate templates X;;; Copyright (C) 1987 Mark A. Ardis. X X(require 'tplvars) X(require 'menu) X(require 'symbol) X(require 'tplhelper) X(require 'tplparse) X(require 'tplreplace) X(require 'tplscan) X X(provide 'template) X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X;;; All global variables are in "tplvars". X;;; All non-interactive helper functions are in "tplhelper" or "tplscan". X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun template-mode () X "Toggle template-mode, a minor mode for manipulation of text via templates. X Calls 'template-mode-hook' if it is defined." X (interactive) X ; Local Variables X (let (file-name) X ; Body X (setq template-mode (not template-mode)) X (set-buffer-modified-p (buffer-modified-p)) X (if template-mode X (progn X (setq file-name (buffer-name)) X (setq sym-completion-buffer (concat "id-" file-name)) X (if tpl-save-identifier-file X (find-file-noselect sym-completion-buffer) X ; else X (get-buffer-create sym-completion-buffer) X ) ; if X (bury-buffer sym-completion-buffer) X (tpl-initialize-scan) X (tpl-build-template-list) X (tpl-make-keymap) X (and (boundp 'template-mode-hook) X template-mode-hook X (funcall template-mode-hook)) X ) ; progn X ; else X (progn X (setq tpl-local-template-list nil) X (tpl-undo-keymap) X ) ; progn X ) ; if X ) ; let X ) ; defun template-mode X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun compile-templates (template-file) X "Compile the templates in TEMPLATE-FILE into a Lisp structure." X (interactive "Fcompile-templates: Template file? ") X ; Local Variables X (let (file-list file-name file X found root-name object-file) X ; Body X (setq root-name (file-name-nondirectory template-file)) X (if (and (> (length root-name) 4) X (equal (substring root-name -4) ".tpl")) X (setq root-name (substring root-name 0 -4)) X ) ; if X (setq object-file (concat (file-name-directory template-file) X root-name "tpl.el")) X (setq file-list tpl-local-template-list) X (setq found nil) X (while (and file-list (not found)) X (setq file (car file-list)) X (setq file-list (cdr file-list)) X (setq file-name (nth 0 file)) X (if (equal file-name root-name) X (setq found t) X ) ; if (equal file-name root-name) X ) ; while file-list X (if found X (progn X (save-window-excursion X (set-buffer tpl-work-buffer) X (erase-buffer) X (message "Compiling templates into a lisp form...") X (insert "(setq template-list '") X (insert (prin1-to-string file)) X (insert ")") X (newline) X (write-region (point-min) (point-max) object-file) X (byte-compile-file object-file) X (delete-file object-file) X ) ; save-window-excursion X (bury-buffer tpl-work-buffer) X ) ; progn X ; else X (progn X (error "Cannot find " template-file) X ) ; progn X ) ; if found X ; return X object-file X ) ; let X ) ; defun compile-templates X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun delete-placeholder () X "Delete the placeholder at point." X (interactive) X ; Local Variables X (let (start) X ; Body X (if (looking-at tpl-pattern-placeholder) X (progn X (setq start (point)) X (re-search-forward tpl-pattern-placeholder) X (delete-region start (point)) X ) ; progn X ; else X (error "No placholder here!") X ) ; if (looking-at tpl-pattern-placeholder) X ) ; let X ) ; defun delete-placeholder X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun describe-template-mode () X "Describe template-mode and its keybindings." X (interactive) X ; Local Variables X (let (orig-buffer) X ; Body X (setq orig-buffer (buffer-name)) X (pop-to-buffer (get-buffer-create "*Help*")) X (erase-buffer) X (insert "Template-mode is a minor mode for manipulating regions of text\n") X (insert "called `templates'. Templates have some of the attributes of\n") X (insert "productions in a context-free grammar. They also have some of\n") X (insert "the attributes of rectangular pictures. ") X (insert "For more information try:\n\n") X (insert " C-h b (describe-bindings) Shows all of the new bindings.\n") X (insert " C-h i (info) A user manual is available via `info'.\n") X (goto-char (point-min)) X (pop-to-buffer orig-buffer) X ) ; let X ) ; defun describe-template-mode X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun expand-placeholder () X "Expand the placeholder at point---interactive version." X (interactive) X ; Local Variables X (let (start stop) X ; Body X (if (looking-at tpl-pattern-placeholder) X (progn X (setq start (point)) X (setq tpl-destination-needed t) X (tpl-expand-placeholder nil) X (setq stop (point)) X (if (not tpl-destination-needed) X (progn X (goto-char (marker-position tpl-destination-marker)) X (set-marker tpl-destination-marker nil) X ) ; progn X ; else X (progn X (setq tpl-destination-needed nil) X (goto-char start) X (if (re-search-forward tpl-pattern-placeholder stop stop) X (re-search-backward tpl-pattern-placeholder) X ) ; if X ) ; progn X ) ; if (not tpl-destination-needed) X ) ; progn X ; else X (error "expand-placeholder: No placeholder at point!") X ) ; if X ) ; let X ) ; defun expand-placeholder X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun expand-placeholders-in-region (start stop) X "Expand each placeholder in the region between START and STOP." X (interactive "r") X ; Local Variables X (let (stop-marker save) X ; Body X (goto-char start) X (setq stop-marker (make-marker)) X (set-marker stop-marker stop) X ; (The check for out-of-bounds is X ; needed for a placeholder at X ; the end of the region.) X (while (and (< (point) (marker-position stop-marker)) X (re-search-forward X tpl-pattern-placeholder (marker-position stop-marker) t)) X (re-search-backward tpl-pattern-placeholder) X (if (looking-at tpl-begin-optional) X (if (or (equal t tpl-keep-optional-placeholders) X (and tpl-keep-optional-placeholders X (tpl-y-or-n-p "Keep optional placeholder? "))) X (progn X (delete-char (length tpl-begin-optional)) X (insert-before-markers tpl-begin-placeholder) X (re-search-backward tpl-begin-placeholder) X (if (or (< tpl-expansion-depth tpl-ask-expansion-depth) X (tpl-y-or-n-p "Expand? ")) X (progn X (setq tpl-expansion-depth (1+ tpl-expansion-depth)) X (unwind-protect X (tpl-expand-placeholder (marker-position stop-marker)) X (setq tpl-expansion-depth (1- tpl-expansion-depth)) X ) ; unwind-protect X ) ; progn X ; else X (progn X (re-search-forward tpl-pattern-placeholder) X ) ; progn X ) ; if (tpl-y-or-n-p "Expand? ") X ) ; progn X ; else X (progn X (setq save (point)) X (re-search-forward tpl-pattern-placeholder) X (delete-region save (point)) X (if (tpl-blank-line) X (delete-indentation) X ) ; if X ) ; progn X ) ; if (tpl-y-or-n-p "Keep optional placeholder? ") X ; else X (if (or (< tpl-expansion-depth tpl-ask-expansion-depth) X (tpl-y-or-n-p "Expand? ")) X (progn X (setq tpl-expansion-depth (1+ tpl-expansion-depth)) X (unwind-protect X (tpl-expand-placeholder (marker-position stop-marker)) X (setq tpl-expansion-depth (1- tpl-expansion-depth)) X ) ; unwind-protect X ) ; progn X ; else X (progn X (re-search-forward tpl-pattern-placeholder) X ) ; progn X ) ; if (tpl-y-or-n-p "Expand? ") X ) ; if (looking-at tpl-begin-optional) X ) ; while (re-search-forward...) X (if (< (point) (marker-position stop-marker)) X (goto-char (marker-position stop-marker)) X ) ; if X (set-marker stop-marker nil) X ) ; let X ) ; defun expand-placeholders-in-region X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun generate-any-template () X "Generate any template, by using the special all-templates-template." X (interactive) X ; Local Variables X (let () X ; Body X (if (or tpl-all-templates-template-invalid X (not (tpl-find-template tpl-all-templates-name))) X (if (y-or-n-p "Cannot find all-templates-template. Rebuild? ") X (progn X (tpl-make-all-templates-template) X (tpl-generate tpl-all-templates-name) X ) ; progn X ; else X (error "Aborted.") X ) ; if (y-or-n-p ...) X ; else X (tpl-generate tpl-all-templates-name) X ) ; if X ) ; let X ) ; defun generate-any-template X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun generate-template () X "Complete template name and call tpl-generate." X (interactive) X ; Local Variables X (let (name name-list) X ; Body X ; Build completion list X (setq name-list (tpl-make-completion-list)) X ; Query for name and generate X (setq name X (completing-read "generate-template: Name of template? " X name-list nil t nil)) X (tpl-generate name) X ) ; let X ) ; defun generate-template X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun load-tpl-buffer (&optional buffer) X "Load all of the templates (in the optional BUFFER). X Defaults to 'tpl-new-template-buffer." X (interactive) X ; Local Variables X (let (root-name new-list) X ; Body X (if (not buffer) X (setq buffer X (read-buffer "load-tpl-buffer: Template buffer? " X tpl-new-template-buffer t)) X ) ; if (not buffer) X (setq new-list (tpl-make-template-list buffer t)) X (setq tpl-local-template-list (append (list new-list) tpl-local-template-list)) X (if tpl-rebuild-all-templates-template X (tpl-make-all-templates-template) X ; else X (setq tpl-all-templates-template-invalid t) X ) ; if X (if (interactive-p) X (if (y-or-n-p "Rebuild global template list with these new templates? ") X (progn X (setq mode-nm (read-string "Mode name for global template list? ")) X (tpl-rebuild-global-template-list mode-nm new-list) X ) ; progn X ) ; if (y-or-n-p ...) X ) ; if (interactive-p) X ) ; let X ) ; defun load-tpl-buffer X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun load-tpl-file (&optional file) X "Load all of the templates (in the optional FILE). X Uses file name completion in the current directory, and X defaults to 'tpl-new-template-buffer." X (interactive) X ; Local Variables X (let (root-name new-list) X ; Body X (if (not file) X (setq file X (expand-file-name (read-file-name X (concat "load-tpl-file: Template file? (" X tpl-new-template-buffer ") ") X nil tpl-new-template-buffer))) X ) ; if (not file) X (setq root-name (tpl-root-of-file-name (file-name-nondirectory file))) X (setq new-list (tpl-make-template-list file)) X (setq tpl-local-template-list (append (list new-list) tpl-local-template-list)) X (if tpl-rebuild-all-templates-template X (tpl-make-all-templates-template) X ; else X (setq tpl-all-templates-template-invalid t) X ) ; if X (if (interactive-p) X (if (y-or-n-p "Rebuild global template list with these new templates? ") X (progn X (setq mode-nm (read-string "Mode name for global template list? ")) X (tpl-rebuild-global-template-list mode-nm new-list) X ) ; progn X ) ; if (y-or-n-p ...) X ) ; if (interactive-p) X ) ; let X ) ; defun load-tpl-file X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun load-tpl-library (file &optional mode-nm) X "Find FILE and add all of the templates in it to the template list. X (Uses the 'tpl-load-path value to find the file.) Optional second X argument MODE-NM is used to rebuild the global template list." X (interactive "sload-tpl-library: File name? ") X ; Local Variables X (let (found head-template-list tail-template-list template-file file-name X root-name template-list new-list) X ; Body X (setq root-name (tpl-root-of-file-name (file-name-nondirectory file))) X ; Look for file in existing list X (setq found nil) X (setq head-template-list nil) X (setq tail-template-list tpl-local-template-list) X (while (and tail-template-list (not found)) X (setq template-file (car tail-template-list)) X (setq tail-template-list (cdr tail-template-list)) X (setq file-name (nth 0 template-file)) X (if (equal file-name root-name) X (setq found t) X ; else X (setq head-template-list X (append head-template-list (list template-file))) X ) ; if (equal file-name file) X ) ; while (and tail-template-list (not found)) X ; If found, query about replacing X (if (and found X (not (y-or-n-p "File already loaded. Replace? "))) X (error "File already loaded. Aborted.") X ) ; if X (setq tpl-local-template-list (append head-template-list tail-template-list)) X ; Find template file X (setq file (tpl-find-template-file root-name)) X (if (and (> (length file) 4) X (equal (substring file -4) ".elc")) X (progn X (load file) X (setq new-list template-list) X ) ; progn X ; else X (progn X (setq new-list (tpl-make-template-list file)) X ) ; progn X ) ; if compiled X (setq tpl-local-template-list X (append (list new-list) X tpl-local-template-list)) X (if tpl-rebuild-all-templates-template X (tpl-make-all-templates-template) X ; else X (setq tpl-all-templates-template-invalid t) X ) ; if X (if (interactive-p) X (if (y-or-n-p "Rebuild global template list with these new templates? ") X (progn X (setq mode-nm X (read-minibuffer "Mode name for global template list? ")) X (tpl-rebuild-global-template-list mode-nm new-list) X ) ; progn X ) ; if X ; else X (tpl-rebuild-global-template-list mode-nm new-list) X ) ; if X ) ; let X ) ; defun load-tpl-library X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun next-placeholder () X "Search forward for the next placeholder." X (interactive) X ; Local Variables X (let (count) X ; Body X (if (looking-at tpl-pattern-placeholder) X (setq count 2) X ; else X (setq count 1) X ) ; if (looking-at tpl-pattern-placeholder) X (re-search-forward tpl-pattern-placeholder (point-max) nil count) X (re-search-backward tpl-pattern-placeholder) X ) ; let X ) ; defun next-placeholder X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun previous-placeholder () X "Search backward for the previous placeholder." X (interactive) X ; Local Variables X (let () X ; Body X (re-search-backward tpl-pattern-placeholder) X ) ; let X ) ; defun previous-placeholder X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun query-replace-groups (start stop) X "Replace some lines after point, beginning with a line that X matches START, and ending before a line that matches STOP, with X temporary placeholders. As each match is found, the user X must type a character saying what to do with it. For directions, X type \\[help-command] at that time." X (interactive "squery-replace-groups starting with: \nsquery-replace-groups starting with %s ending with: ") X ; Local Variables X (let () X ; Body X (setq tpl-end-group (concat "^" stop)) X (perform-replace-tpl X (concat "^" start) X "placeholder" t nil nil X 're-search-forward 'tpl-find-end-of-group 'tpl-replace-group X 'tpl-find-next-group) X ) ; let X ) ; defun query-replace-groups X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun query-replace-lines (string) X "Replace some lines after point matching leading STRING with X temporary placeholders. As each match is found, the user X must type a character saying what to do with it. For directions, X type \\[help-command] at that time." X (interactive "squery-replace-lines with leading pattern: ") X ; Local Variables X (let () X ; Body X (perform-replace-tpl X (concat "^" string) X "placeholder" t nil nil X 're-search-forward 'beginning-of-line 'tpl-replace-line) X ) ; let X ) ; defun query-replace-lines X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun region-to-tpl (start stop &optional name file parse) X "Create a template with the text between START and STOP. X Optionally, call it NAME and put the template in FILE. X Optional fifth argument PARSE specifies whether the template X should be parsed: if t parse, if nil do not parse, if neither X t nor nil ask about parsing." X (interactive "r") X ; Local Variables X (let (string column text-file template table parse name-place X suggestion begin-body) X ; Body X (if (not file) X (setq file X (expand-file-name (read-file-name X (concat "Template file? (" X tpl-new-template-buffer ") ") X nil tpl-new-template-buffer))) X ) ; if (not file) X (if (and parse (not (equal parse t))) X (setq parse (y-or-n-p "region-to-tpl: Parse the template? ")) X ) ; if X (setq string (buffer-substring start stop)) X (goto-char start) X (setq column (current-column)) X (goto-char stop) X (setq text-file (buffer-file-name)) X (if (not (equal file text-file)) X (progn X (find-file-other-window file) X (goto-char (point-min)) X (open-line 1) X (insert tpl-begin-template-definition " ") X (setq name-place (point)) X (insert " ") X (if parse X (insert tpl-sequence-type) X (insert tpl-string-type) X ) ; if parse X (beginning-of-line nil) X (delete-char 1) ; Remove regexp anchor X (setq name-place (1- name-place)) X (end-of-line nil) X (newline) X (insert tpl-begin-template-body) X (newline) X (beginning-of-line 0) X (delete-char 1) ; Remove regexp anchor X (beginning-of-line 2) X ; Insert body of template X (setq begin-body (point)) X (insert string) X (newline) X ; Fix indentation X (indent-rigidly begin-body (point) (- 0 column)) X (insert tpl-end-template-body) X (newline) X (beginning-of-line 0) X (delete-char 1) ; Remove regexp anchor X (goto-char name-place) X (if (not name) X (if tpl-get-placeholder-name-in-context X (progn X (if tpl-form-placeholder-name-from-context X (setq suggestion tpl-formed-placeholder-name) X ; else X (progn X (setq suggestion tpl-next-placeholder-name) X (tpl-increment-next-placeholder-name) X ) ; progn X ) ; if tpl-form-placeholder-name-from-context X (insert suggestion) X (if tpl-query-flag X (progn X (search-backward suggestion) X (setq name X (sym-read-string "Placeholder name? " X suggestion)) X (if (equal (length name) 0) X (progn X (setq name suggestion) X ) ; progn X ) ; if X ) ; progn X ; else X (setq name suggestion) X ) ; if tpl-query-flag X ) ; progn X ; else X (progn X (setq name (tpl-get-placeholder-name)) X (insert name) X ) ; progn X ) ; if tpl-get-placeholder-name-in-context X ; else X (insert name) X ) ; if (not-name) X ) ; progn X ; else X (error "Cannot reuse this file for templates!") X ) ; if (not (equal file text-file)) X ; return X name X ) ; let X ) ; defun region-to-tpl X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun replace-line-with-placeholder (count &optional name file parse) X "Replace the line containing point with a placeholder. X Prefix argument COUNT gives number of lines X (ending with current line). Optional second argument NAME is used X for placeholder name. Optional third argument FILE is used for X file to store template. Optional fourth argument PARSE X specifies whether template should be parsed. (See 'region-to-tpl X for interpretation.)" X (interactive "p") X ; Local Variables X (let (start) X ; Body X (if (interactive-p) X (progn X (setq parse "ask") X (setq file "new.tpl") X ) ; progn X ) ; if X (setq count (1- count)) X (forward-line (* count -1)) X (setq start (point)) X (forward-line count) X (end-of-line nil) X (replace-region-with-placeholder start (point) name file parse) X ) ; let X ) ; defun replace-line-with-placeholder X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun replace-region-with-placeholder (start stop &optional name file parse) X "Replace the region between START and STOP with a placeholder. X Optionally, call it NAME and put the template in FILE. X Optional fifth argument PARSE specifies whether template X should be parsed. (See 'region-to-tpl for interpretation.)" X (interactive "r") X ; Local Variables X (let (start-marker stop-marker) X ; Body X (if (interactive-p) X (progn X (setq parse "ask") X (setq file "new.tpl") X ) ; progn X ) ; if X (if (> (- stop start) 0) X (progn X (save-window-excursion X (setq start-marker (make-marker)) X (set-marker start-marker start) X (setq stop-marker (make-marker)) X (set-marker stop-marker stop) X (setq name (region-to-tpl start stop name file parse)) X (if tpl-auto-save-new-templates X (save-buffer) X ) ; if tpl-auto-save-new-templates X ) ; save-window-excursion X (delete-region (marker-position start-marker) X (marker-position stop-marker)) X (unwind-protect X (if tpl-auto-load-new-templates X (load-tpl-buffer (buffer-name (get-file-buffer file))) X ) ; if X (goto-char (marker-position start-marker)) X (set-marker start-marker nil) X (set-marker stop-marker nil) X (insert-before-markers X tpl-begin-placeholder name tpl-end-placeholder)) X ) ; progn X ; else X (insert-before-markers X tpl-begin-placeholder name tpl-end-placeholder) X ) ; if (> (- stop start) 0) X ) ; let X ) ; defun replace-region-with-placeholder X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun rewrap-template-around-point () X "Unwrap FIRST template around point and wrap with SECOND. X Template names are prompted for with completing-read. X A side effect of this function is to push-mark at the beginning of the X enclosed region." X (interactive) X ; Local Variables X (let (name-list first second) X ; Body X ; Build completion list X (setq name-list (tpl-make-completion-list)) X ; Query for name to unwrap X (setq first X (completing-read "rewrap-template: Name of enclosing template? " X name-list nil t nil)) X ; Query for name to wrap X (setq second X (completing-read "rewrap-template: Name of new template? " X name-list nil t nil)) X (tpl-unwrap-template first t) X (tpl-wrap-template (mark) (point) second) X ) ; let X ) ; defun rewrap-template-around-point X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun tpl-recompile-templates (template-dir) X "Compile a standard list of templates in TEMPLATE-DIR." X (interactive "Dtpl-recompile-templates: Template directory? ") X ; Local Variables X (let (prefix) X ; Body X (autoload 'awk-mode "awk") X (autoload 'bib-mode "bib") X (autoload 'pascal-mode "pascal") X (setq prefix template-dir) X (if (not (equal (substring prefix -1) "/")) X (setq prefix (concat prefix "/")) X ) ; if X (if (not template-mode) X (template-mode) X ) ; if X (compile-templates (concat prefix "generic.tpl")) X (awk-mode) X (template-mode) X (compile-templates (concat prefix "awk.tpl")) X (bib-mode) X (template-mode) X (compile-templates (concat prefix "bib.tpl")) X (c-mode) X (template-mode) X (compile-templates (concat prefix "c.tpl")) X (emacs-lisp-mode) X (template-mode) X (compile-templates (concat prefix "elisp.tpl")) X (latex-mode) X (template-mode) X (compile-templates (concat prefix "latex.tpl")) X (pascal-mode) X (template-mode) X (compile-templates (concat prefix "pascal.tpl")) X (scribe-mode) X (template-mode) X (compile-templates (concat prefix "scribe.tpl")) X (texinfo-mode) X (template-mode) X (compile-templates (concat prefix "texinfo.tpl")) X ) ; let X) ; defun tpl-recompile-templates X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun unwrap-template-around-point (arg) X "Complete template name and call tpl-unwrap-template. Prefix argument X ARG non-nil causes the mark to be set at the beginning of the resulting X region." X (interactive "P") X ; Local Variables X (let (name name-list) X ; Body X ; Build completion list X (setq name-list (tpl-make-completion-list)) X ; Query for name and unwrap X (setq name X (completing-read "unwrap-template-around-point: Name of template? " X name-list nil t nil)) X (tpl-unwrap-template name arg) X ) ; let X ) ; defun unwrap-template-around-point X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun wrap-template-around-line (count) X "Replace COUNT lines including point with TEMPLATE, X reinserting the replaced line at the destination placeholder. X Prefix argument indicates number of lines to wrap. X Second argument, TEMPLATE, is read with completing-read." X (interactive "p") X ; Local Variables X (let (start) X ; Body X (setq count (1- count)) X (forward-line (* count -1)) X (beginning-of-line nil) X (setq start (point)) X (forward-line count) X (end-of-line nil) X (wrap-template-around-region start (point)) X ) ; let X ) ; defun wrap-template-around-line X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun wrap-template-around-region (start stop) X "Replace the region between START and STOP with TEMPLATE, X reinserting the replaced region at the destination placeholder. X The region is indented rigidly at its insertion column. X The third argument, TEMPLATE, is read with completing-read." X (interactive "r") X ; Local Variables X (let (name-list template) X ; Body X (setq name-list (tpl-make-completion-list)) X (setq template (completing-read "wrap-template: Name of template? " X name-list nil t nil)) X (tpl-wrap-template start stop template) X ) ; let X ) ; defun wrap-template-around-region X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(defun wrap-template-around-word (count) X "Replace COUNT words before point with TEMPLATE, X reinserting the replaced word at the destination placeholder. X Prefix argument indicates number of words to wrap. X Second argument, TEMPLATE, is read with completing-read." X (interactive "p") X ; Local Variables X (let (start) X ; Body X (forward-word (* count -1)) X (setq start (point)) X (forward-word count) X (wrap-template-around-region start (point)) X ) ; let X ) ; defun wrap-template-around-word X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X(tpl-initialize-modes) X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X;;; end of template.el SHAR_EOF if test 26969 -ne "`wc -c < 'template.el'`" then echo shar: "error transmitting 'template.el'" '(should have been 26969 characters)' fi fi echo shar: "extracting 'tplvars.el'" '(11467 characters)' if test -f 'tplvars.el' then echo shar: "will not over-write existing file 'tplvars.el'" else sed 's/^X//' << \SHAR_EOF > 'tplvars.el' X;;; tplvars.el -- Variables for template-mode. X;;; Copyright (C) 1987 Mark A. Ardis. X X(provide 'tplvars) X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X;;; User Options X X(defvar tpl-ask-expansion-depth 1 X "*Depth of recursive placeholder expansions at which to start asking X whether to expand. Possible values are: X -1 delete all placeholders X 0 don't expand or delete placeholders---leave them alone X 1 ask about expansion at level 1 X n ask about expansion at level n of expanding X Defaults to 1, which means always ask." X) ; tpl-ask-expansion-depth X X(defvar tpl-auto-load-new-templates nil X "*If non-nil load new templates after creating them with X 'replace-wtih-placeholder. Otherwise, loading must be done X by invoking 'load-tpl-file. Defaults to nil." X) ; tpl-auto-load-new-templates X X(defvar tpl-auto-save-new-templates nil X "*If non-nil save new templates after creating them with X 'replace-wtih-placeholder. Otherwise, saving must be done X by invoking 'save-buffer. Defaults to nil." X) ; tpl-auto-save-new-templates X X(defvar tpl-auto-template-alist nil X "*Global Alist of major modes and their associated template files. X Initialized by 'tpl-initialize-modes'." X) ; tpl-auto-template-alist X X(defvar tpl-begin-placeholder "<" X "*Regular expression for beginning of placeholder." X) ; tpl-begin-placeholder X X(defvar tpl-begin-template-body "^:begin" X "*Regular expression for beginning of template body." X) ; tpl-begin-template-body X(make-variable-buffer-local 'tpl-begin-template-body) X(setq-default tpl-begin-template-body "^:begin") X X(defvar tpl-begin-template-definition "^Template" X "*Regular expression for beginning of template definition." X) ; tpl-begin-template-definition X(make-variable-buffer-local 'tpl-begin-template-definition) X(setq-default tpl-begin-template-definition "^Template") X X(defvar tpl-destination-symbol "POINT" X "*Special symbol used as placeholder as location for point X after expanding a template." X) ; tpl-destination-symbol X X(defvar tpl-display-begin ">>" X "*Delimiter marking beginning of a selected placeholder." X) ; tpl-display-begin X X(defvar tpl-display-end "<<" X "*Delimiter marking end of a selected placeholder." X) ; tpl-display-end X X(defvar tpl-end-placeholder ">" X "*Regular expression for end of placeholder." X) ; tpl-end-placeholder X X(defvar tpl-end-template-body "^:end" X "*Regular expression for end of template body." X) ; tpl-end-template-body X(make-variable-buffer-local 'tpl-end-template-body) X(setq-default tpl-end-template-body "^:end") X X(defvar tpl-fill-while-unscanning nil X "*If non-nil, use whatever fill mode is in effect while unscanning X (inserting) templates. Defaults to nil, which ensures that template X formats are not disturbed by context." X) ; tpl-fill-while-unscanning X X(defvar tpl-form-placeholder-name-from-context nil X "*Option to generate placeholder names by looking for the first symbol X after point. Defaults to nil, which means use temporary names instead." X) ; tpl-form-placeholder-name-from-context X X(defvar tpl-function-type "Function" X "*Name of function-type template type." X) ; tpl-function-type X X(defvar tpl-get-placeholder-name-in-context t X "*If non-nil allow the user to type in the placeholder name within X the context of the template definition. Otherwise, use temporary X names. Defaults to t." X) ; tpl-get-placeholder-name-in-context X X(defvar tpl-include-prefix-in-groups t X "*Option to include the prefix string (used to find the beginning of X a group) in the group." X) ; tpl-include-prefix-in-groups X X(defvar tpl-indentation-size 2 X "*Size of indentation units in columns." X) ; tpl-indentation-size X(make-variable-buffer-local 'tpl-indentation-size) X(setq-default tpl-indentation-size 2) X X(defvar tpl-keep-optional-placeholders "ask" X "*Option to determine processing of optional placeholders in template-mode. X If t, then always keep them. If nil, then always delete them. If neither X t nor nil, then always ask." X) ; tpl-keep-optional-placeholders X X(defvar tpl-lexical-type "Lexical" X "*Name of lexical-type template type." X) ; tpl-lexical-type X X(defvar tpl-literal-whitespace nil X "*If non-nil leave leading whitespace in templates as-is. X Otherwise, calculate relative indentation units (see X 'tpl-indentation-size' variable). Defaults to nil." X) ; tpl-literal-whitespace X X(defvar tpl-load-path (list nil "/faculty/ardis/Gnu/Template/Templates") X "*List of directories to search for template files to load. X Each element is a string (directory name) or nil (try default directory). X Use 'template-mode-load-hook to change this value." X) ; tpl-load-path X X(defvar tpl-new-template-buffer "new.tpl" X "*Buffer containing new templates." X) ; tpl-new-template-buffer X X(defvar tpl-next-placeholder-number 1 X "*Counter used to generate unique temporary placeholder names." X) ; tpl-next-placeholder-number X X(defvar tpl-pattern-optional "#" X "*Regular expression for all optional placeholders." X) ; tpl-pattern-optional X X(defvar tpl-pattern-other "." X "*Regular expression for all other tokens." X) ; tpl-pattern-other X X(defvar tpl-pattern-placeholder nil X "*Regular expression for placeholder." X) ; tpl-pattern-placeholder X X(defvar tpl-pattern-punctuation "\\s.+" X "*Regular expression for at least one punctuation character." X) ; tpl-pattern-punctuation X X(defvar tpl-pattern-string ".*" X "*Regular expression for any string." X) ; tpl-pattern-string X X(defvar tpl-pattern-symbol "\\(\\sw\\|\\s_\\)+" X "*Regular expression for at least one symbol character." X) ; tpl-pattern-symbol X X(defvar tpl-pattern-whitespace "[ ]+" X "*Regular expression for at least one whitespace character." X) ; tpl-pattern-whitespace X X(defvar tpl-pattern-word "\\sw+" X "*Regular expression for at least one word character." X) ; tpl-pattern-word X X(defvar tpl-rebuild-all-templates-template nil X "*If non-nil rebuild the list of all templates after invoking X template-mode and after loading new templates. Otherwise, do not X (improves performance of starting up). Defaults to nil." X) ; tpl-rebuild-all-templates-template X X(defvar tpl-repetition-type "Repetition" X "*Name of repetition-type template type." X) ; tpl-repetition-type X X(defvar tpl-save-identifier-file nil X "*Option to save identifier table in a separate file. Defaults X to nil, which means save only in a buffer." X) ; tpl-save-identifier-file X X(defvar tpl-selection-type "Selection" X "*Name of selection-type template type." X) ; tpl-selection-type X X(defvar tpl-sep-placeholder ":" X "*Regular expression for placeholder body separator." X) ; tpl-sep-placeholder X X(defvar tpl-sequence-type "Sequence" X "*Name of sequence-type template type." X) ; tpl-sequence-type X X(defvar tpl-string-type "String" X "*Name of string-type template type." X) ; tpl-string-type X X(defvar tpl-temporary-placeholder-name "TEMP" X "*Root of temporary placeholder names." X) ; tpl-temporary-placeholder-name X X(defvar tpl-verify-end-of-group nil X "*Option to verify (by positioning point) the end of each group X of lines in 'query-replace-groups." X) ; tpl-verify-end-of-group X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X;;; Global Variables X X(defvar lex-patterns nil X "A list of regular expressions to be used in recognizing tokens." X) ; lex-patterns X X(defvar string-patterns nil X "A list of string patterns to be used in recognizing tokens." X) ; string-patterns X X(defvar template-mode nil X "Minor mode symbol." X) ; template-mode X(make-variable-buffer-local 'template-mode) X X(defvar template-mode-map nil X "Keymap for template-mode." X) ; template-mode-map X X(defvar tpl-all-templates-file "ALLTEMPLATES" X "Name of dummy template file for all-templates-template." X) ; tpl-all-templates-name X X(defvar tpl-all-templates-name "ALLTEMPLATES" X "Name of special template that is a selection of all other templates." X) ; tpl-all-templates-name X X(defvar tpl-all-templates-template-invalid t X "Flag to indicate validity of all-templates-template." X) ; tpl-all-templates-template-invalid X X(defvar tpl-begin-optional nil X "Regular expression for beginning of optional placeholder." X) ; tpl-begin-optional X X(defvar tpl-buffer X "Current template buffer." X) ; tpl-buffer X X(defvar tpl-comment-level 100 X "Special value indicating alignment on comment column." X) ; tpl-comment-level X X(defvar tpl-destination-marker (make-marker) X "Location (a marker) to leave point after expanding placeholder." X) ; tpl-destination-marker X(make-variable-buffer-local 'tpl-destination-marker) X(setq-default tpl-destination-marker (make-marker)) X X(defvar tpl-destination-needed nil X "Boolean flag used to signal whether a destination for point (after X expanding a placeholder) has been found yet." X) ; tpl-destination-needed X X(defvar tpl-destination-placeholder nil X "Special placeholder used to place point after expanding a template." X) ; tpl-destination-placeholder X X(defvar tpl-end-group nil X "Global variable to hold pattern for end of group." X) ; tpl-end-group X X(defvar tpl-expansion-depth 1 X "Current depth of recursive calls to expand placeholders. X Compared to tpl-ask-expansion-depth." X) ; tpl-expansion-depth X(make-variable-buffer-local 'tpl-expansion-depth) X(setq-default tpl-expansion-depth 1) X X(defvar tpl-formed-placeholder-name nil X "Value formed by searching for next symbol after point." X) ; tpl-formed-placeholder-name X X(defvar tpl-global-template-list nil X "Global Alist of major modes and their associated templates." X) ; tpl-global-template-list X X(defvar tpl-indentation-type 'indentation X "Type of indentation terminals." X) ; tpl-indentation-type X X(defvar tpl-local-template-list nil X "List of all templates and their tree values." X) ; tpl-local-template-list X(make-variable-buffer-local 'tpl-local-template-list) X X(defvar tpl-menu-buffer "Menu" X "Buffer used for making selections of templates." X) ; tpl-menu-buffer X X(defvar tpl-newline-token nil X "Token indicating presence of a newline." X) ; tpl-newline-token X X(defvar tpl-newline-type 'newline X "Type of newline terminals." X) ; tpl-newline-type X X(defvar tpl-next-placeholder-name (concat tpl-temporary-placeholder-name X tpl-next-placeholder-number) X "Next unique name for temporary placeholder." X) ; tpl-next-placeholder-number X X(defvar tpl-optional-type 'optional X "Type of optional placeholders." X) ; tpl-optional-type X X(defvar tpl-other-type 'other X "Type of other terminals." X) ; tpl-other-type X X(defvar tpl-placeholder-type 'placeholder X "Type of all placeholders." X) ; tpl-placeholder-type X X(defvar tpl-punctuation-type 'punctuation X "Type of punctuation terminals." X) ; tpl-punctuation-type X X(defvar tpl-query-flag t X "If non-nil query about placeholder names." X) ; tpl-query-flag X X(defvar tpl-saved-map nil X "Local keymap to restore when turning off template-mode." X) ; tpl-saved-map X(make-variable-buffer-local 'tpl-saved-map) X X(defvar tpl-terminal-type 'terminal X "Type of all literal strings." X) ; tpl-terminal-type X X(defvar tpl-textlong-buffer "Textlong" X "Buffer used for creating textlong values." X) ; tpl-textlong-buffer X X(defvar tpl-whitespace-type 'whitespace X "Type of whitespace terminals." X) ; tpl-whitespace-type X X(defvar tpl-word-type 'word X "Type of word terminals." X) ; tpl-word-type X X(defvar tpl-work-buffer "Work" X "Buffer used for constructing temporary objects." X) ; tpl-work-buffer X X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ X X;;; end of tplvars.el SHAR_EOF if test 11467 -ne "`wc -c < 'tplvars.el'`" then echo shar: "error transmitting 'tplvars.el'" '(should have been 11467 characters)' fi fi exit 0 # End of shell archive