(fill-comment, comment-column, comment-start)

(comment-start-skip, comment-end, comment-indent-function)
(block-comment-start, block-comment-end, indent-for-comment)
(set-comment-column, kill-comment, comment-padding, comment-region)
(comment-multi-line, indent-new-comment-line): Remove.

1 files changed, 0 insertions, 350 deletions

diff --git a/lisp/simple.el b/lisp/simple.el
index 69eab7d5bcb..9105231ad4f 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -35,11 +35,6 @@
   "Killing and yanking commands"
   :group 'editing)
 
-(defgroup fill-comments nil
-  "Indenting and filling of comments."
-  :prefix "comment-"
-  :group 'fill)
-
 (defgroup paren-matching nil
   "Highlight (un)matching of parens and expressions."
   :group 'matching)
@@ -2617,266 +2612,10 @@ With argument 0, interchanges line point is in with line mark is in."
     (delete-region (point) (+ (point) len1))
     (insert word2)))
 
-(defcustom comment-column 32
-  "*Column to indent right-margin comments to.
-Setting this variable automatically makes it local to the current buffer.
-Each mode establishes a different default value for this variable; you
-can set the value for a particular mode using that mode's hook."
-  :type 'integer
-  :group 'fill-comments)
-(make-variable-buffer-local 'comment-column)
-
-(defcustom comment-start nil
-  "*String to insert to start a new comment, or nil if no comment syntax."
-  :type '(choice (const :tag "None" nil)
-                 string)
-  :group 'fill-comments)
-
-(defcustom comment-start-skip nil
-  "*Regexp to match the start of a comment plus everything up to its body.
-If there are any \\(...\\) pairs, the comment delimiter text is held to begin
-at the place matched by the close of the first pair."
-  :type '(choice (const :tag "None" nil)
-                 regexp)
-  :group 'fill-comments)
-
-(defcustom comment-end ""
-  "*String to insert to end a new comment.
-Should be an empty string if comments are terminated by end-of-line."
-  :type 'string
-  :group 'fill-comments)
-
 (defvar comment-indent-hook nil
   "Obsolete variable for function to compute desired indentation for a comment.
 This function is called with no args with point at the beginning of
 the comment's starting delimiter.")
-
-(defvar comment-indent-function
-  (lambda () comment-column)
-  "Function to compute desired indentation for a comment.
-This function is called with no args with point at the beginning of
-the comment's starting delimiter.")
-
-(defcustom block-comment-start nil
-  "*String to insert to start a new comment on a line by itself.
-If nil, use `comment-start' instead.
-Note that the regular expression `comment-start-skip' should skip this string
-as well as the `comment-start' string."
-  :type '(choice (const :tag "Use comment-start" nil)
-                 string)
-  :group 'fill-comments)
-
-(defcustom block-comment-end nil
-  "*String to insert to end a new comment on a line by itself.
-Should be an empty string if comments are terminated by end-of-line.
-If nil, use `comment-end' instead."
-  :type '(choice (const :tag "Use comment-end" nil)
-                 string)
-  :group 'fill-comments)
-
-(defun indent-for-comment ()
-  "Indent this line's comment to comment column, or insert an empty comment."
-  (interactive "*")
-  (let* ((empty (save-excursion (beginning-of-line)
-                                (looking-at "[ \t]*$")))
-         (starter (or (and empty block-comment-start) comment-start))
-         (ender (or (and empty block-comment-end) comment-end)))
-    (cond
-     ((null starter)
-      (error "No comment syntax defined"))
-     ((null comment-start-skip)
-      (error "This mode doesn't define `comment-start-skip'"))
-     (t (let* ((eolpos (save-excursion (end-of-line) (point)))
-               cpos indent begpos)
-          (beginning-of-line)
-          (if (re-search-forward comment-start-skip eolpos 'move)
-              (progn (setq cpos (point-marker))
-                     ;; Find the start of the comment delimiter.
-                     ;; If there were paren-pairs in comment-start-skip,
-                     ;; position at the end of the first pair.
-                     (if (match-end 1)
-                         (goto-char (match-end 1))
-                       ;; If comment-start-skip matched a string with
-                       ;; internal whitespace (not final whitespace) then
-                       ;; the delimiter start at the end of that
-                       ;; whitespace.  Otherwise, it starts at the
-                       ;; beginning of what was matched.
-                       (skip-syntax-backward " " (match-beginning 0))
-                       (skip-syntax-backward "^ " (match-beginning 0)))))
-          (setq begpos (point))
-          ;; Compute desired indent.
-          (if (= (current-column)
-                 (setq indent (if comment-indent-hook
-                                  (funcall comment-indent-hook)
-                                (funcall comment-indent-function))))
-              (goto-char begpos)
-            ;; If that's different from current, change it.
-            (skip-chars-backward " \t")
-            (delete-region (point) begpos)
-            (indent-to indent))
-          ;; An existing comment?
-          (if cpos
-              (progn (goto-char cpos)
-                     (set-marker cpos nil))
-            ;; No, insert one.
-            (insert starter)
-            (save-excursion
-              (insert ender))))))))
-
-(defun set-comment-column (arg)
-  "Set the comment column based on point.
-With no arg, set the comment column to the current column.
-With just minus as arg, kill any comment on this line.
-With any other arg, set comment column to indentation of the previous comment
- and then align or create a comment on this line at that column."
-  (interactive "P")
-  (if (eq arg '-)
-      (kill-comment nil)
-    (if arg
-        (progn
-          (save-excursion
-            (beginning-of-line)
-            (re-search-backward comment-start-skip)
-            (beginning-of-line)
-            (re-search-forward comment-start-skip)
-            (goto-char (match-beginning 0))
-            (setq comment-column (current-column))
-            (message "Comment column set to %d" comment-column))
-          (indent-for-comment))
-      (setq comment-column (current-column))
-      (message "Comment column set to %d" comment-column))))
-
-(defun kill-comment (arg)
-  "Kill the comment on this line, if any.
-With argument, kill comments on that many lines starting with this one."
-  ;; this function loses in a lot of situations.  it incorrectly recognises
-  ;; comment delimiters sometimes (ergo, inside a string), doesn't work
-  ;; with multi-line comments, can kill extra whitespace if comment wasn't
-  ;; through end-of-line, et cetera.
-  (interactive "P")
-  (or comment-start-skip (error "No comment syntax defined"))
-  (let ((count (prefix-numeric-value arg)) endc)
-    (while (> count 0)
-      (save-excursion
-        (end-of-line)
-        (setq endc (point))
-        (beginning-of-line)
-        (and (string< "" comment-end)
-             (setq endc
-                   (progn
-                     (re-search-forward (regexp-quote comment-end) endc 'move)
-                     (skip-chars-forward " \t")
-                     (point))))
-        (beginning-of-line)
-        (if (re-search-forward comment-start-skip endc t)
-            (progn
-              (goto-char (match-beginning 0))
-              (skip-chars-backward " \t")
-              (kill-region (point) endc)
-              ;; to catch comments a line beginnings
-              (indent-according-to-mode))))
-      (if arg (forward-line 1))
-      (setq count (1- count)))))
-
-(defvar comment-padding 1
-  "Number of spaces `comment-region' puts between comment chars and text.
-
-Extra spacing between the comment characters and the comment text
-makes the comment easier to read.  Default is 1.  Nil means 0 and is
-more efficient.")
-
-(defun comment-region (beg end &optional arg)
-  "Comment or uncomment each line in the region.
-With just C-u prefix arg, uncomment each line in region.
-Numeric prefix arg ARG means use ARG comment characters.
-If ARG is negative, delete that many comment characters instead.
-Comments are terminated on each line, even for syntax in which newline does
-not end the comment.  Blank lines do not get comments.
-
-The strings used as comment starts are build from
-`comment-start' without trailing spaces and `comment-padding'."
-  ;; if someone wants it to only put a comment-start at the beginning and
-  ;; comment-end at the end then typing it, C-x C-x, closing it, C-x C-x
-  ;; is easy enough.  No option is made here for other than commenting
-  ;; every line.
-  (interactive "*r\nP")
-  (or comment-start (error "No comment syntax is defined"))
-  (if (> beg end) (let (mid) (setq mid beg beg end end mid)))
-  (save-excursion
-    (save-restriction
-      (let* ((comment-start
-              (substring comment-start 0
-                         (string-match "[ \t]*$" comment-start)))
-             (cs comment-start) (ce comment-end)
-             (cp (when comment-padding
-                   (make-string comment-padding ? )))
-             numarg)
-        (if (consp arg) (setq numarg t)
-          (setq numarg (prefix-numeric-value arg))
-          ;; For positive arg > 1, replicate the comment delims now,
-          ;; then insert the replicated strings just once.
-          (while (> numarg 1)
-            (setq cs (concat cs comment-start)
-                  ce (concat ce comment-end))
-            (setq numarg (1- numarg))))
-        ;; Loop over all lines from BEG to END.
-        (narrow-to-region beg end)
-        (goto-char beg)
-        (if (or (eq numarg t) (< numarg 0))
-            (while (not (eobp))
-              (let (found-comment)
-                ;; Delete comment start from beginning of line.
-                (if (eq numarg t)
-                    (while (looking-at (regexp-quote cs))
-                      (setq found-comment t)
-                      (delete-char (length cs)))
-                  (let ((count numarg))
-                    (while (and (> 1 (setq count (1+ count)))
-                                (looking-at (regexp-quote cs)))
-                      (setq found-comment t)
-                      (delete-char (length cs)))))
-                ;; Delete comment padding from beginning of line
-                (when (and found-comment comment-padding
-                           (looking-at (regexp-quote cp)))
-                  (delete-char comment-padding))
-                ;; Delete comment end from end of line.
-                (if (string= "" ce)
-                    nil
-                  (if (eq numarg t)
-                      (progn
-                        (end-of-line)
-                        ;; This is questionable if comment-end ends in
-                        ;; whitespace.  That is pretty brain-damaged,
-                        ;; though.
-                        (while (progn (skip-chars-backward " \t")
-                                      (and (>= (- (point) (point-min)) (length ce))
-                                           (save-excursion
-                                             (backward-char (length ce))
-                                             (looking-at (regexp-quote ce)))))
-                            (delete-char (- (length ce)))))
-                    (let ((count numarg))
-                      (while (> 1 (setq count (1+ count)))
-                        (end-of-line)
-                        ;; this is questionable if comment-end ends in whitespace
-                        ;; that is pretty brain-damaged though
-                        (skip-chars-backward " \t")
-                        (if (>= (- (point) (point-min)) (length ce))
-                            (save-excursion
-                              (backward-char (length ce))
-                              (if (looking-at (regexp-quote ce))
-                                  (delete-char (length ce)))))))))
-                (forward-line 1)))
-
-          (when comment-padding
-            (setq cs (concat cs cp)))
-          (while (not (eobp))
-            ;; Insert at beginning and at end.
-            (if (looking-at "[ \t]*$") ()
-              (insert cs)
-              (if (string= "" ce) ()
-                (end-of-line)
-                (insert ce)))
-            (search-forward "\n" nil 'move)))))))
 
 (defun backward-word (arg)
   "Move backward until encountering the end of a word.
@@ -3146,95 +2885,6 @@ Just \\[universal-argument] as argument means to use the current column."
     (message "Fill column set to %d (was %d)" arg fill-column)
     (setq fill-column arg)))
 
-(defcustom comment-multi-line nil
-  "*Non-nil means \\[indent-new-comment-line] should continue same comment
-on new line, with no new terminator or starter.
-This is obsolete because you might as well use \\[newline-and-indent]."
-  :type 'boolean
-  :group 'fill-comments)
-
-(defun indent-new-comment-line (&optional soft)
-  "Break line at point and indent, continuing comment if within one.
-This indents the body of the continued comment
-under the previous comment line.
-
-This command is intended for styles where you write a comment per line,
-starting a new comment (and terminating it if necessary) on each line.
-If you want to continue one comment across several lines, use \\[newline-and-indent].
-
-If a fill column is specified, it overrides the use of the comment column
-or comment indentation.
-
-The inserted newline is marked hard if `use-hard-newlines' is true,
-unless optional argument SOFT is non-nil."
-  (interactive)
-  (let (comcol comstart)
-    (skip-chars-backward " \t")
-    (delete-region (point)
-                   (progn (skip-chars-forward " \t")
-                          (point)))
-    (if soft (insert-and-inherit ?\n) (newline 1))
-    (if fill-prefix
-        (progn
-          (indent-to-left-margin)
-          (insert-and-inherit fill-prefix))
-      (if (not comment-multi-line)
-          (save-excursion
-            (if (and comment-start-skip
-                     (let ((opoint (1- (point)))
-                           inside)
-                       (forward-line -1)
-                       ;; Determine (more or less) whether
-                       ;; target position is inside a comment.
-                       (while (and (re-search-forward comment-start-skip opoint t)
-                                   (not (setq inside (or (equal comment-end "")
-                                                         (not (search-forward comment-end opoint t)))))))
-                       inside))
-                ;; The old line has a comment and point was inside the comment.
-                ;; Set WIN to the pos of the comment-start.
-                ;; But if the comment is empty, look at preceding lines
-                ;; to find one that has a nonempty comment.
-
-                ;; If comment-start-skip contains a \(...\) pair,
-                ;; the real comment delimiter starts at the end of that pair.
-                (let ((win (or (match-end 1) (match-beginning 0))))
-                  (while (and (eolp) (not (bobp))
-                              (let (opoint)
-                                (beginning-of-line)
-                                (setq opoint (point))
-                                (forward-line -1)
-                                (re-search-forward comment-start-skip opoint t)))
-                    (setq win (or (match-end 1) (match-beginning 0))))
-                  ;; Indent this line like what we found.
-                  (goto-char win)
-                  (setq comcol (current-column))
-                  (setq comstart
-                        (buffer-substring (point) (match-end 0)))))))
-      (if comcol
-          (let ((comment-column comcol)
-                (comment-start comstart)
-                (comment-end comment-end))
-            (and comment-end (not (equal comment-end ""))
-  ;            (if (not comment-multi-line)
-                     (progn
-                       (forward-char -1)
-                       (insert comment-end)
-                       (forward-char 1))
-  ;              (setq comment-column (+ comment-column (length comment-start))
-  ;                    comment-start "")
-  ;                )
-                 )
-            (if (not (eolp))
-                (setq comment-end ""))
-            (insert-and-inherit ?\n)
-            (forward-char -1)
-            (indent-for-comment)
-            (save-excursion
-              ;; Make sure we delete the newline inserted above.
-              (end-of-line)
-              (delete-char 1)))
-        (indent-according-to-mode)))))
-
 (defun set-selective-display (arg)
   "Set `selective-display' to ARG; clear it if no arg.
 When the value of `selective-display' is a number > 0,