home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #30 / NN_1992_30.iso / spool / alt / lucidem / help / 795 < prev    next >
Encoding:
Text File  |  1992-12-14  |  15.9 KB  |  411 lines
  1. x-gateway: rodan.UU.NET from help-lucid-emacs to alt.lucid-emacs.help; Mon, 14 Dec 1992 09:55:44 EST
  2. Date: Mon, 14 Dec 1992 09:51:47 EST
  3. From: ex594bw@pts.mot.com (Bob Weiner)
  4. Message-ID: <9212141451.AA01671@mars.pts.mot.com>
  5. Subject: Re: Filling without removing tabs from 1st line of a paragraph.
  6. Reply-To: bob_weiner@pts.mot.com
  7. Newsgroups: alt.lucid-emacs.help
  8. Path: sparky!uunet!wendy-fate.uu.net!help-lucid-emacs
  9. Sender: help-lucid-emacs-request@lucid.com
  10. Lines: 399
  11.  
  12. > In article <1gao29INNiek@transfer.stratus.com> wayne@sw.stratus.com (Wayne Newberry) writes:
  13. > 
  14. >    I currently turn on auto-fill and I'd prefer to have
  15. >    Lucid Emacs fill using only spaces, rather than a 
  16. >    combination of tabs and spaces.  Is there any way to
  17. >    make this happen?
  18. > 
  19. > 
  20. > I have almost the exact opposite problem.  I have paragraphs that look
  21. > like:
  22. > 
  23. > 14 Dec 92 1.23 me    Some text that goes on for multiple lines, with each
  24. >             continuation line starting with 3 tabs.  The first
  25. >             line of the paragraph has one tab to make the text
  26. >             line up with the continuation lines.
  27. > 
  28. > In emacs 18.58, I could set the fill-prefix to be three tabs and then use
  29. > M-q to fill such a paragraph and it would preserve the tab in the first
  30. > line of the paragraph.  Lucid Emacs 19.3, however, turns that tab into a
  31. > single space, destroying the format.
  32. >             
  33. > 14 Dec 92 1.23 me Some text that goes on for multiple lines, with each
  34. >             continuation line starting with 3 tabs.  The first
  35. >             line of the paragraph has one tab to make the text
  36. >             line up with the continuation lines.
  37. > 
  38. > Is this a bug or a (mis)feature?  Is there a variable I can change to get
  39. > the old functionality back?
  40.  
  41. Use the following "par-align.el" package which is expected to be a part of
  42. GNU Emacs V19; it will solve your problem and works under Lucid or regular
  43. GNU Emacs.  I've used it for years as my exclusive paragraph and region fill
  44. code, so if you like, you can bind it to {M-q}.  I use {M-j} myself for ease
  45. of typing.
  46.  
  47. ;;!emacs
  48. ;;
  49. ;; FILE:         par-align.el
  50. ;; SUMMARY:      Improved paragraph fill, left-align and justify functions
  51. ;; USAGE:        GNU Emacs Lisp Library
  52. ;;
  53. ;; AUTHOR:       Bob Weiner, Applied Research, Motorola, Inc.
  54. ;; E-MAIL:       weiner@mot.com
  55. ;; ORIG-DATE:    14-Apr-89
  56. ;; LAST-MOD:      2-Nov-92 at 11:13:54 by Bob Weiner
  57. ;;
  58. ;; Copyright (C) 1989, 1992    Free Software Foundation, Inc.
  59. ;; Available for use and distribution under the same terms as GNU Emacs.
  60. ;;
  61. ;; This file is not yet part of GNU Emacs.
  62. ;;
  63. ;; MODS:
  64. ;;
  65. ;;   18-Dec-90  (bw)  Added support for TeX and LaTeX modes.
  66. ;;   15-Sep-92  (bw)  Added support for mail and news edit modes.
  67. ;;                    Fixed so only one undo-boundary per fill operation.
  68. ;;   02-Nov-92  (bw)  Fixed so last line of last buffer paragraph is filled
  69. ;;                    properly if doesn't have a trailing newline.
  70. ;;
  71. ;; END-MODS.
  72. ;;
  73. ;; DESCRIPTION:  
  74. ;;
  75. ;;   This package allows GNU Emacs paragraph commands to deal more
  76. ;;   reasonably with indented text and embedded comments.  It lets you
  77. ;;   realign and set the fill prefix on one line of a paragraph, e.g. the
  78. ;;   first, and then have all the other lines match up when you fill the
  79. ;;   paragraph.
  80. ;;   
  81. ;;   An auto-justify minor mode similar to auto-fill from jka@hpfcso.HP.COM
  82. ;;   (Jay Adams) is also included.  Use the 'auto-justify-mode' command to
  83. ;;   toggle it on and off.
  84. ;;
  85. ;;
  86. ;;   I think the 'fill-paragraph-and-align' command eliminates the need for
  87. ;;   Kyle Jones, 'C Comment Edit' package.  Additionally, there is no need
  88. ;;   to edit in a special buffer.
  89. ;;   
  90. ;;   If you set the fill-prefix to some value, then set it to nil (set it at
  91. ;;   the beginning of a line) and then fill the paragraph, the old
  92. ;;   fill-prefix will be stripped off and the paragraph will be filled
  93. ;;   properly with no prefix.  Then just add the new fill-prefix, if any,
  94. ;;   that you want and refill again.
  95. ;;   
  96. ;;   If you have ever tried to fill Emacs Lisp documentation strings or
  97. ;;   embedded comments, you know that all you get is an ugly mess.  You end
  98. ;;   up having to fill after putting blank lines at the beginning and end.
  99. ;;   Now you can fill properly without making any inline changes.  The fill
  100. ;;   routines do not fill the first line of documentation strings since it is
  101. ;;   used by the apropos commands and may intentionally be short.
  102. ;;   
  103. ;;   The fill and movement commands also recognize multiple paragraphs
  104. ;;   within a single comment stretch, just like the ones you see in this
  105. ;;   description text.  Just remember to set the fill prefix properly, just
  106. ;;   as you normally would for the fill-paragraph command.
  107. ;;   
  108. ;;   When filling a region, fill-prefix-prev (old fill prefix) can be
  109. ;;   replaced by fill-prefix throughout the entire region before each
  110. ;;   paragraph is filled.  Simply call the 'fill-region-and-align-all'
  111. ;;   command.
  112. ;;   
  113. ;;   Always fill with point before some of the text to be filled.  If you
  114. ;;   try to fill when point is on a line following all of the text to be
  115. ;;   filled, the next paragraph may be filled by mistake, e.g. when filling
  116. ;;   with point near the end of a comment string.
  117. ;;
  118. ;;   C comments of the form (with any number of '*' chars):
  119. ;;   /*
  120. ;;    * <text>
  121. ;;    * <text>
  122. ;;    */
  123. ;;   are filled well.
  124. ;;
  125. ;;   Multiple line C comments of the form:
  126. ;;   /*        */
  127. ;;   /*        */
  128. ;;   are not filled well, so don't use them.  If you have some already, you
  129. ;;   can convert them to the kind above with the
  130. ;;   'c-comment-make-prefix-only' command found in this package.
  131. ;;
  132. ;;   Comments in UNIX shell scripts of the form (with any number of '#' chars):
  133. ;;   #
  134. ;;   # <text>
  135. ;;   # <text>
  136. ;;   #
  137. ;;   are filled well if the first line of the file begins with a pattern that
  138. ;;   matches the regular expression "^#!/bin/[ck]?sh" as shell scripts should.
  139. ;;
  140. ;;   Fortran comments of the form:
  141. ;;   C
  142. ;;   C <text>
  143. ;;   C <text>
  144. ;;   C
  145. ;;   are filled well.
  146. ;;
  147. ;;   The commands bound immediately below do all of this work.
  148. ;;
  149. ;; DESCRIP-END.
  150.  
  151.  
  152. ;; Suggested key bindings
  153. ;;
  154. (global-set-key "\M-j" 'fill-paragraph-and-align)
  155. (global-set-key "\C-x\C-j" 'fill-region-and-align-all)
  156. (define-key text-mode-map "\C-x\C-j" 'fill-region-and-align)
  157. (define-key indented-text-mode-map "\C-x\C-j" 'fill-region-and-align)
  158. (if (fboundp 'outline-level)
  159.     nil
  160.   (load "outline")
  161.   (provide 'outline))
  162. (define-key outline-mode-map "\C-x\C-j" 'fill-region-and-align)
  163.  
  164. ;; The next two functions are suitable as replacements for the standard
  165. ;; paragraph movement commands if you want them to recognize paragraph
  166. ;; boundaries the way the fill functions below do.
  167. ;;
  168. ;; Suggested key bindings
  169. ;;
  170. ;;(global-set-key "\M-n" 'forward-para)
  171. ;;(global-set-key "\M-p" 'backward-para)
  172.  
  173. (defun forward-para (&optional arg)
  174.   "Move forward to end of paragraph.  With ARG, do it arg times.
  175. A line which  paragraph-start  matches either separates paragraphs,
  176. if  paragraph-separate  matches it also, or is the first line of a paragraph.
  177. A paragraph end is the beginning of a line which is not part of the paragraph
  178. to which the end of the previous line belongs, or the end of the buffer."
  179.   (interactive "p")
  180.   (paragraph-filter 'forward-paragraph arg))
  181.  
  182. (defun backward-para (&optional arg)
  183.   "Move backward to start of paragraph.  With ARG, do it arg times.
  184. A paragraph start is the beginning of a line which is a first-line-of-paragraph
  185. or which is ordinary text and follows a paragraph-separating line, except
  186. if the first real line of a paragraph is preceded by a blank line,
  187. the paragraph starts at that blank line.
  188. See forward-paragraph for more information."
  189.   (interactive "p")
  190.   (or arg (setq arg 1))
  191.   (paragraph-filter 'forward-paragraph (- arg)))
  192.  
  193.  
  194. (defconst fill-prefix-prev nil
  195.   "Previous string inserted at front of new line during filling, or nil for none.
  196. Setting this variable automatically makes it local to the current buffer.")
  197. (make-variable-buffer-local 'fill-prefix-prev)
  198.  
  199. ;; Redefine this function so that it sets 'fill-prefix-prev' also.
  200. (defun set-fill-prefix ()
  201.   "Set the fill-prefix to the current line up to point.
  202. Also sets fill-prefix-prev to previous value of fill-prefix.
  203. Filling expects lines to start with the fill prefix and reinserts the fill
  204. prefix in each resulting line."
  205.   (interactive)
  206.   (setq fill-prefix-prev fill-prefix
  207.     fill-prefix (buffer-substring
  208.               (save-excursion (beginning-of-line) (point))
  209.               (point)))
  210.   (if (equal fill-prefix-prev "")
  211.       (setq fill-prefix-prev nil))
  212.   (if (equal fill-prefix "")
  213.       (setq fill-prefix nil))
  214.   (if fill-prefix
  215.       (message "fill-prefix: \"%s\"" fill-prefix)
  216.     (message "fill-prefix cancelled")))
  217.  
  218. (defun fill-paragraph-and-align (justify-flag)
  219.   "Fill current paragraph.  Prefix arg JUSTIFY-FLAG means justify as well.
  220. Does not alter fill prefix on first line of paragraph.  Any whitespace
  221. separated version of the fill-prefix, or fill-prefix-prev when fill-prefix is
  222. nil, at the beginning of lines is deleted before the fill is performed.  This
  223. aligns all lines in a paragraph properly after the fill-prefix is changed.
  224. Works well within text, singly delimited C comments, Lisp comments and
  225. documentation strings, and Fortran comments."
  226.   (interactive "P")
  227.   (paragraph-filter 'fill-para-align justify-flag))
  228.  
  229. (defun fill-region-and-align-all (justify-flag)
  230.   "Fill each line in region.  Prefix arg JUSTIFY-FLAG means justify as well.
  231. Replace any whitespace separated version of fill-prefix-prev with fill-prefix
  232. in all lines of region.  This aligns all lines throughout the region properly
  233. after the fill-prefix is changed.  Works well within text, singly delimited C
  234. comments, UNIX shell scripts, Lisp comments and documentation strings, and
  235. Fortran comments.
  236. See also documentation for fill-region-and-align."
  237.   (interactive "P")
  238.   (paragraph-filter 'fill-region-align justify-flag t))
  239.  
  240. (defun fill-region-and-align (justify-flag &optional align-all)
  241.   "Fill each line in region.  Prefix arg JUSTIFY-FLAG means justify as well.
  242. Optional ALIGN-ALL non-nil means replace fill-prefix-prev with fill-prefix in
  243. all lines of region, otherwise, does not alter prefix in paragraph separator
  244. lines and first lines of paragraphs.
  245. Any whitespace separated version of fill-prefix, or fill-prefix-prev when
  246. fill-prefix is nil, at the beginning of appropriate lines is removed before the
  247. fill is performed.  This aligns all lines in a paragraph properly after the
  248. fill-prefix is changed.  Works well within text, singly delimited C comments,
  249. UNIX shell scripts, Lisp comments and documentation strings, and Fortran comments."
  250.   (interactive "P")
  251.   (paragraph-filter 'fill-region-align justify-flag align-all))
  252.  
  253. (defun paragraph-filter (func arg1 &optional arg2)
  254.   ;;                      LISP          C/C++        Fortran        Eiffel
  255.   ;;                      --------------------------------------------------
  256.   ;; comment-start        ";"           "/*\\|//"    nil (^[Cc*])   "--"     
  257.   ;; comment-start-skip   ";+ *"        "/\\*+ *"    "![ \t]*"      "--+[ \t]*"
  258.   ;; comment-end          "" ([^J^L])   " */\\|$"    "" (^J)        "" (^J)
  259.   ;;
  260.   (let* ((*C* (memq major-mode '(c-mode c++-mode)))
  261.      (*lsp*  (memq major-mode
  262.                '(emacs-lisp-mode lisp-interaction-mode scheme-mode
  263.              lisp-mode)))
  264.      (*mail* (memq major-mode '(mail-mode rmail-edit-mode
  265.                     news-reply-mode)))
  266.      (*txt*  (memq major-mode
  267.                '(text-mode indented-text-mode texinfo-mode
  268.              para-mode LaTeX-mode latex-mode TeX-mode 
  269.              tex-mode scribe-mode outline-mode picture-mode)))
  270.      (extra-para-sep
  271.        (concat "^"
  272.            ;; Don't change the '?' in the following lines to a '+', it
  273.            ;; will break certain fill boundary conditions.
  274.            (if (eq major-mode 'fortran-mode) "[cC*]?")
  275.            "[ \t]*\\("
  276.            (cond ((and (< (point-min) 2) (> (point-max) 10)
  277.                    (string-match "^#!/bin/[ck]?sh"
  278.                        (buffer-substring 1 11)))
  279.               "#*")
  280.              ;; Don't change the '?' in the following lines to a
  281.              ;; '+', it will break certain fill boundary
  282.              ;; conditions.
  283.              (comment-start-skip
  284.                (concat "\\(" comment-start-skip "\\)?")))
  285.            (if *C* "\\|\*+/?\\|//.*")
  286.            (if *mail* "\\|^[!$%&|<> \t]+")
  287.            "\\)[ \t]*$"
  288.            (if *lsp* "\\|^[ \t]*\\([[(]\\|\"\\)")
  289.            ;; For Interleaf TPS, texinfo and Scribe markup documents
  290.            (if *txt* "\\|^[@\\<]")
  291.            ))
  292.      (paragraph-separate
  293.        (concat paragraph-separate "\\|" extra-para-sep))
  294.      (paragraph-start
  295.        (concat paragraph-start "\\|" extra-para-sep)))
  296.     (if arg2
  297.     (funcall func arg1 arg2)
  298.       (funcall func arg1))))
  299.  
  300. (defun fill-region-align (justify-flag &optional align-all)
  301.   (if align-all
  302.       (replace-fill-str fill-prefix-prev fill-prefix))
  303.   (save-excursion
  304.     (let ((end (max (point) (mark))))
  305.       (goto-char (min (point) (mark)))
  306.       (while (and (not (eobp)) (< (point) end))
  307.     (fill-para-align justify-flag align-all)
  308.     (forward-paragraph)
  309.     ;; Forward to real paragraph end if not in lisp mode
  310.     (or *lsp* (re-search-forward (concat "\\'\\|" paragraph-separate)))))))
  311.  
  312. (defun fill-para-align (justify-flag &optional leave-prefix)
  313.   (save-excursion
  314.     (end-of-line)
  315.     ;; Backward to para begin
  316.     (re-search-backward (concat "\\`\\|" paragraph-separate))
  317.     (forward-line (if (looking-at extra-para-sep) 2 1))
  318.     (let ((region-start (point)))
  319.       (forward-line -1)
  320.       (let ((from (point)))
  321.     (forward-paragraph)
  322.     ;; Forward to real paragraph end if not in lisp mode
  323.     (or *lsp* (re-search-forward (concat "\\'\\|" paragraph-separate)))
  324.     (or (= (point) (point-max)) (beginning-of-line))
  325.     (or leave-prefix
  326.         (replace-fill-str
  327.           (or fill-prefix fill-prefix-prev)
  328.           "" nil region-start (point)))
  329.     (fill-region-as-paragraph from (point) justify-flag)))))
  330.  
  331. (defun replace-fill-str (fill-str-prev fill-str &optional suffix start end)
  332.   "Replace whitespace separated FILL-STR-PREV with FILL-STR.
  333. Optional SUFFIX non-nil means replace at ends of lines, default is beginnings.
  334. Optional arguments START and END specify the replace region, default is the
  335. current region."
  336.   (if fill-str-prev
  337.       (progn (if (not start) (setq start (min (point) (mark))))
  338.          (if (not end)   (setq end   (max (point) (mark))))
  339.          (if (not fill-str) (setq fill-str ""))
  340.          (save-excursion
  341.            (save-restriction
  342.          (narrow-to-region start end)
  343.          (goto-char (point-min))
  344.          (let ((prefix
  345.              (concat
  346.                (if suffix nil "^")
  347.                "[ \t]*"
  348.                (regexp-quote
  349.                  ;; Get non-whitespace separated fill-str-prev
  350.                  (substring
  351.                    fill-str-prev
  352.                    (or (string-match "[^ \t]" fill-str-prev) 0)
  353.                    (if (string-match
  354.                      "[ \t]*\\(.*[^ \t]\\)[ \t]*$"
  355.                      fill-str-prev)
  356.                    (match-end 1))))
  357.                "[ \t]*"
  358.                (if suffix "$"))))
  359.            (while (re-search-forward prefix nil t)
  360.              (replace-match fill-str nil t))))))))
  361.  
  362. (defun c-comment-make-prefix-only ()
  363.   "Make multiply-delimited C comments in region singly delimited.
  364. Converts comments of form:
  365. /*  <text>  */      to    /*
  366. /*  <text>  */             * <text>
  367.                            * <text>
  368.                            */"
  369.   (interactive)
  370.   (replace-fill-str "/*" " * ")
  371.   (replace-fill-str "*/" "" t)
  372.   (save-excursion
  373.     (goto-char (min (point) (mark)))
  374.     (insert "/*\n"))
  375.   (save-excursion
  376.     (goto-char (max (point) (mark)))
  377.     (insert (if (bolp) " */\n" "\n */"))))
  378.  
  379. ;;; Auto-justify minor mode
  380. ;;
  381. ;; From: jka@hpfcso.HP.COM (Jay Adams)
  382. ;; Newsgroups: comp.emacs
  383. ;; Subject:  auto-justify
  384. ;; Date: 7 Sep 89 01:30:18 GMT
  385. ;; Organization: Hewlett-Packard, Fort Collins, CO, USA
  386.  
  387. (defvar auto-justify-mode '()
  388.   "Non-nil if auto-justifying minor mode is on.")
  389.  
  390. (or (assoc 'auto-justify-mode minor-mode-alist)
  391.     (setq minor-mode-alist
  392.           (cons '(auto-justify-mode " Justify")
  393.                 minor-mode-alist)))
  394.            
  395. (defun auto-justify-mode ()
  396.   "Toggle auto-justify minor mode."
  397.   (interactive)
  398.   (if (eq auto-fill-hook 'do-auto-fill-justify)
  399.       (setq auto-fill-hook 'do-auto-fill auto-justify-mode nil)
  400.     (setq auto-fill-hook 'do-auto-fill-justify
  401.           auto-justify-mode t)))
  402.  
  403. (defun do-auto-fill-justify ()
  404.   "Same as do-auto-fill but justifies current line."
  405.   (do-auto-fill)
  406.   (save-excursion
  407.     (forward-line -1)
  408.     (justify-current-line)))
  409.  
  410. (provide 'par-align)
  411.