1;;; newcomment.el --- (un)comment regions of buffers 2 3;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 4;; 2005, 2006, 2007 Free Software Foundation, Inc. 5 6;; Author: code extracted from Emacs-20's simple.el 7;; Maintainer: Stefan Monnier <monnier@iro.umontreal.ca> 8;; Keywords: comment uncomment 9 10;; This file is part of GNU Emacs. 11 12;; GNU Emacs is free software; you can redistribute it and/or modify 13;; it under the terms of the GNU General Public License as published by 14;; the Free Software Foundation; either version 2, or (at your option) 15;; any later version. 16 17;; GNU Emacs is distributed in the hope that it will be useful, 18;; but WITHOUT ANY WARRANTY; without even the implied warranty of 19;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20;; GNU General Public License for more details. 21 22;; You should have received a copy of the GNU General Public License 23;; along with GNU Emacs; see the file COPYING. If not, write to the 24;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 25;; Boston, MA 02110-1301, USA. 26 27;;; Commentary: 28 29;; A replacement for simple.el's comment-related functions. 30 31;;; Bugs: 32 33;; - boxed comments in Perl are not properly uncommented because they are 34;; uncommented one-line at a time. 35;; - nested comments in sgml-mode are not properly quoted. 36;; - single-char nestable comment-start can only do the "\\s<+" stuff 37;; if the corresponding closing marker happens to be right. 38;; - uncomment-region with a numeric argument can render multichar 39;; comment markers invalid. 40;; - comment-indent or comment-region when called inside a comment 41;; will happily break the surrounding comment. 42;; - comment-quote-nested will not (un)quote properly all nested comment 43;; markers if there are more than just comment-start and comment-end. 44;; For example, in Pascal where {...*) and (*...} are possible. 45 46;;; Todo: 47 48;; - rebox.el-style refill. 49;; - quantized steps in comment-alignment. 50;; - try to align tail comments. 51;; - check what c-comment-line-break-function has to say. 52;; - spill auto-fill of comments onto the end of the next line. 53;; - uncomment-region with a consp (for blocks) or somehow make the 54;; deletion of continuation markers less dangerous. 55;; - drop block-comment-<foo> unless it's really used. 56;; - uncomment-region on a subpart of a comment. 57;; - support gnu-style "multi-line with space in continue". 58;; - somehow allow comment-dwim to use the region even if transient-mark-mode 59;; is not turned on. 60 61;; - when auto-filling a comment, try to move the comment to the left 62;; rather than break it (if possible). 63;; - sometimes default the comment-column to the same 64;; one used on the preceding line(s). 65 66;;; Code: 67 68;;;###autoload 69(defalias 'indent-for-comment 'comment-indent) 70;;;###autoload 71(defalias 'set-comment-column 'comment-set-column) 72;;;###autoload 73(defalias 'kill-comment 'comment-kill) 74;;;###autoload 75(defalias 'indent-new-comment-line 'comment-indent-new-line) 76 77(defgroup comment nil 78 "Indenting and filling of comments." 79 :prefix "comment-" 80 :version "21.1" 81 :group 'fill) 82 83;; Autoload this to avoid warnings, since some major modes define it. 84;;;###autoload 85(defvar comment-use-syntax 'undecided 86 "Non-nil if syntax-tables can be used instead of regexps. 87Can also be `undecided' which means that a somewhat expensive test will 88be used to try to determine whether syntax-tables should be trusted 89to understand comments or not in the given buffer. 90Major modes should set this variable.") 91 92(defcustom comment-fill-column nil 93 "Column to use for `comment-indent'. If nil, use `fill-column' instead." 94 :type '(choice (const nil) integer) 95 :group 'comment) 96 97;;;###autoload 98(defcustom comment-column 32 99 "Column to indent right-margin comments to. 100Each mode establishes a different default value for this variable; you 101can set the value for a particular mode using that mode's hook. 102Comments might be indented to a value smaller than this in order 103not to go beyond `comment-fill-column'." 104 :type 'integer 105 :group 'comment) 106(make-variable-buffer-local 'comment-column) 107;;;###autoload(put 'comment-column 'safe-local-variable 'integerp) 108 109;;;###autoload 110(defvar comment-start nil 111 "*String to insert to start a new comment, or nil if no comment syntax.") 112;;;###autoload(put 'comment-start 'safe-local-variable 'string-or-null-p) 113 114;;;###autoload 115(defvar comment-start-skip nil 116 "*Regexp to match the start of a comment plus everything up to its body. 117If there are any \\(...\\) pairs, the comment delimiter text is held to begin 118at the place matched by the close of the first pair.") 119;;;###autoload(put 'comment-start-skip 'safe-local-variable 'string-or-null-p) 120 121;;;###autoload 122(defvar comment-end-skip nil 123 "Regexp to match the end of a comment plus everything up to its body.") 124;;;###autoload(put 'comment-end-skip 'safe-local-variable 'string-or-null-p) 125 126;;;###autoload 127(defvar comment-end "" 128 "*String to insert to end a new comment. 129Should be an empty string if comments are terminated by end-of-line.") 130;;;###autoload(put 'comment-end 'safe-local-variable 'string-or-null-p) 131 132;;;###autoload 133(defvar comment-indent-function 'comment-indent-default 134 "Function to compute desired indentation for a comment. 135This function is called with no args with point at the beginning of 136the comment's starting delimiter and should return either the desired 137column indentation or nil. 138If nil is returned, indentation is delegated to `indent-according-to-mode'.") 139 140;;;###autoload 141(defvar comment-insert-comment-function nil 142 "Function to insert a comment when a line doesn't contain one. 143The function has no args. 144 145Applicable at least in modes for languages like fixed-format Fortran where 146comments always start in column zero.") 147 148(defvar comment-region-function 'comment-region-default 149 "Function to comment a region. 150Its args are the same as those of `comment-region', but BEG and END are 151guaranteed to be correctly ordered. It is called within `save-excursion'. 152 153Applicable at least in modes for languages like fixed-format Fortran where 154comments always start in column zero.") 155 156(defvar uncomment-region-function 'uncomment-region-default 157 "Function to uncomment a region. 158Its args are the same as those of `uncomment-region', but BEG and END are 159guaranteed to be correctly ordered. It is called within `save-excursion'. 160 161Applicable at least in modes for languages like fixed-format Fortran where 162comments always start in column zero.") 163 164;; ?? never set 165(defvar block-comment-start nil) 166(defvar block-comment-end nil) 167 168(defvar comment-quote-nested t 169 "Non-nil if nested comments should be quoted. 170This should be locally set by each major mode if needed.") 171 172(defvar comment-continue nil 173 "Continuation string to insert for multiline comments. 174This string will be added at the beginning of each line except the very 175first one when commenting a region with a commenting style that allows 176comments to span several lines. 177It should generally have the same length as `comment-start' in order to 178preserve indentation. 179If it is nil a value will be automatically derived from `comment-start' 180by replacing its first character with a space.") 181 182(defvar comment-add 0 183 "How many more comment chars should be inserted by `comment-region'. 184This determines the default value of the numeric argument of `comment-region'. 185This should generally stay 0, except for a few modes like Lisp where 186it can be convenient to set it to 1 so that regions are commented with 187two semi-colons.") 188 189(defconst comment-styles 190 '((plain . (nil nil nil nil)) 191 (indent . (nil nil nil t)) 192 (aligned . (nil t nil t)) 193 (multi-line . (t nil nil t)) 194 (extra-line . (t nil t t)) 195 (box . (nil t t t)) 196 (box-multi . (t t t t))) 197 "Possible comment styles of the form (STYLE . (MULTI ALIGN EXTRA INDENT)). 198STYLE should be a mnemonic symbol. 199MULTI specifies that comments are allowed to span multiple lines. 200ALIGN specifies that the `comment-end' markers should be aligned. 201EXTRA specifies that an extra line should be used before and after the 202 region to comment (to put the `comment-end' and `comment-start'). 203INDENT specifies that the `comment-start' markers should not be put at the 204 left margin but at the current indentation of the region to comment.") 205 206;;;###autoload 207(defcustom comment-style 'plain 208 "Style to be used for `comment-region'. 209See `comment-styles' for a list of available styles." 210 :type (if (boundp 'comment-styles) 211 `(choice ,@(mapcar (lambda (s) `(const ,(car s))) comment-styles)) 212 'symbol) 213 :group 'comment) 214 215;;;###autoload 216(defcustom comment-padding " " 217 "Padding string that `comment-region' puts between comment chars and text. 218Can also be an integer which will be automatically turned into a string 219of the corresponding number of spaces. 220 221Extra spacing between the comment characters and the comment text 222makes the comment easier to read. Default is 1. nil means 0." 223 :type '(choice string integer (const nil)) 224 :group 'comment) 225 226;;;###autoload 227(defcustom comment-multi-line nil 228 "Non-nil means `comment-indent-new-line' continues comments. 229That is, it inserts no new terminator or starter. 230This affects `auto-fill-mode', which is the main reason to 231customize this variable. 232 233It also affects \\[indent-new-comment-line]. However, if you want this 234behavior for explicit filling, you might as well use \\[newline-and-indent]." 235 :type 'boolean 236 :group 'comment) 237 238(defcustom comment-empty-lines nil 239 "If nil, `comment-region' does not comment out empty lines. 240If t, it always comments out empty lines. 241If `eol' it only comments out empty lines if comments are 242terminated by the end of line (i.e. `comment-end' is empty)." 243 :type '(choice (const :tag "Never" nil) 244 (const :tag "Always" t) 245 (const :tag "EOl-terminated" 'eol)) 246 :group 'comment) 247 248;;;; 249;;;; Helpers 250;;;; 251 252(defun comment-string-strip (str beforep afterp) 253 "Strip STR of any leading (if BEFOREP) and/or trailing (if AFTERP) space." 254 (string-match (concat "\\`" (if beforep "\\s-*") 255 "\\(.*?\\)" (if afterp "\\s-*\n?") 256 "\\'") str) 257 (match-string 1 str)) 258 259(defun comment-string-reverse (s) 260 "Return the mirror image of string S, without any trailing space." 261 (comment-string-strip (concat (nreverse (string-to-list s))) nil t)) 262 263;;;###autoload 264(defun comment-normalize-vars (&optional noerror) 265 "Check and setup the variables needed by other commenting functions. 266Functions autoloaded from newcomment.el, being entry points, should call 267this function before any other, so the rest of the code can assume that 268the variables are properly set." 269 (unless (and (not comment-start) noerror) 270 (unless comment-start 271 (let ((cs (read-string "No comment syntax is defined. Use: "))) 272 (if (zerop (length cs)) 273 (error "No comment syntax defined") 274 (set (make-local-variable 'comment-start) cs)))) 275 ;; comment-use-syntax 276 (when (eq comment-use-syntax 'undecided) 277 (set (make-local-variable 'comment-use-syntax) 278 (let ((st (syntax-table)) 279 (cs comment-start) 280 (ce (if (string= "" comment-end) "\n" comment-end))) 281 ;; Try to skip over a comment using forward-comment 282 ;; to see if the syntax tables properly recognize it. 283 (with-temp-buffer 284 (set-syntax-table st) 285 (insert cs " hello " ce) 286 (goto-char (point-min)) 287 (and (forward-comment 1) (eobp)))))) 288 ;; comment-padding 289 (unless comment-padding (setq comment-padding 0)) 290 (when (integerp comment-padding) 291 (setq comment-padding (make-string comment-padding ? ))) 292 ;; comment markers 293 ;;(setq comment-start (comment-string-strip comment-start t nil)) 294 ;;(setq comment-end (comment-string-strip comment-end nil t)) 295 ;; comment-continue 296 (unless (or comment-continue (string= comment-end "")) 297 (set (make-local-variable 'comment-continue) 298 (concat (if (string-match "\\S-\\S-" comment-start) " " "|") 299 (substring comment-start 1))) 300 ;; Hasn't been necessary yet. 301 ;; (unless (string-match comment-start-skip comment-continue) 302 ;; (kill-local-variable 'comment-continue)) 303 ) 304 ;; comment-skip regexps 305 (unless (and comment-start-skip 306 ;; In case comment-start has changed since last time. 307 (string-match comment-start-skip comment-start)) 308 (set (make-local-variable 'comment-start-skip) 309 (concat "\\(\\(^\\|[^\\\n]\\)\\(\\\\\\\\\\)*\\)\\(\\s<+\\|" 310 (regexp-quote (comment-string-strip comment-start t t)) 311 ;; Let's not allow any \s- but only [ \t] since \n 312 ;; might be both a comment-end marker and \s-. 313 "+\\)[ \t]*"))) 314 (unless (and comment-end-skip 315 ;; In case comment-end has changed since last time. 316 (string-match comment-end-skip comment-end)) 317 (let ((ce (if (string= "" comment-end) "\n" 318 (comment-string-strip comment-end t t)))) 319 (set (make-local-variable 'comment-end-skip) 320 ;; We use [ \t] rather than \s- because we don't want to 321 ;; remove ^L in C mode when uncommenting. 322 (concat "[ \t]*\\(\\s>" (if comment-quote-nested "" "+") 323 "\\|" (regexp-quote (substring ce 0 1)) 324 (if (and comment-quote-nested (<= (length ce) 1)) "" "+") 325 (regexp-quote (substring ce 1)) 326 "\\)")))))) 327 328(defun comment-quote-re (str unp) 329 (concat (regexp-quote (substring str 0 1)) 330 "\\\\" (if unp "+" "*") 331 (regexp-quote (substring str 1)))) 332 333(defun comment-quote-nested (cs ce unp) 334 "Quote or unquote nested comments. 335If UNP is non-nil, unquote nested comment markers." 336 (setq cs (comment-string-strip cs t t)) 337 (setq ce (comment-string-strip ce t t)) 338 (when (and comment-quote-nested (> (length ce) 0)) 339 (let ((re (concat (comment-quote-re ce unp) 340 "\\|" (comment-quote-re cs unp)))) 341 (goto-char (point-min)) 342 (while (re-search-forward re nil t) 343 (goto-char (match-beginning 0)) 344 (forward-char 1) 345 (if unp (delete-char 1) (insert "\\")) 346 (when (= (length ce) 1) 347 ;; If the comment-end is a single char, adding a \ after that 348 ;; "first" char won't deactivate it, so we turn such a CE 349 ;; into !CS. I.e. for pascal, we turn } into !{ 350 (if (not unp) 351 (when (string= (match-string 0) ce) 352 (replace-match (concat "!" cs) t t)) 353 (when (and (< (point-min) (match-beginning 0)) 354 (string= (buffer-substring (1- (match-beginning 0)) 355 (1- (match-end 0))) 356 (concat "!" cs))) 357 (backward-char 2) 358 (delete-char (- (match-end 0) (match-beginning 0))) 359 (insert ce)))))))) 360 361;;;; 362;;;; Navigation 363;;;; 364 365(defvar comment-use-global-state nil 366 "Non-nil means that the global syntactic context is used. 367More specifically, it means that `syntax-ppss' is used to find out whether 368point is within a string or not. Major modes whose syntax is faithfully 369described by the syntax-tables can set this to non-nil so comment markers 370in strings will not confuse Emacs.") 371 372(defun comment-search-forward (limit &optional noerror) 373 "Find a comment start between point and LIMIT. 374Moves point to inside the comment and returns the position of the 375comment-starter. If no comment is found, moves point to LIMIT 376and raises an error or returns nil if NOERROR is non-nil." 377 (if (not comment-use-syntax) 378 (if (re-search-forward comment-start-skip limit noerror) 379 (or (match-end 1) (match-beginning 0)) 380 (goto-char limit) 381 (unless noerror (error "No comment"))) 382 (let* ((pt (point)) 383 ;; Assume (at first) that pt is outside of any string. 384 (s (parse-partial-sexp pt (or limit (point-max)) nil nil 385 (if comment-use-global-state (syntax-ppss pt)) 386 t))) 387 (when (and (nth 8 s) (nth 3 s) (not comment-use-global-state)) 388 ;; The search ended at eol inside a string. Try to see if it 389 ;; works better when we assume that pt is inside a string. 390 (setq s (parse-partial-sexp 391 pt (or limit (point-max)) nil nil 392 (list nil nil nil (nth 3 s) nil nil nil nil) 393 t))) 394 (if (or (not (and (nth 8 s) (not (nth 3 s)))) 395 ;; Make sure the comment starts after PT. 396 (< (nth 8 s) pt)) 397 (unless noerror (error "No comment")) 398 ;; We found the comment. 399 (let ((pos (point)) 400 (start (nth 8 s)) 401 (bol (line-beginning-position)) 402 (end nil)) 403 (while (and (null end) (>= (point) bol)) 404 (if (looking-at comment-start-skip) 405 (setq end (min (or limit (point-max)) (match-end 0))) 406 (backward-char))) 407 (goto-char (or end pos)) 408 start))))) 409 410(defun comment-search-backward (&optional limit noerror) 411 "Find a comment start between LIMIT and point. 412Moves point to inside the comment and returns the position of the 413comment-starter. If no comment is found, moves point to LIMIT 414and raises an error or returns nil if NOERROR is non-nil." 415 ;; FIXME: If a comment-start appears inside a comment, we may erroneously 416 ;; stop there. This can be rather bad in general, but since 417 ;; comment-search-backward is only used to find the comment-column (in 418 ;; comment-set-column) and to find the comment-start string (via 419 ;; comment-beginning) in indent-new-comment-line, it should be harmless. 420 (if (not (re-search-backward comment-start-skip limit t)) 421 (unless noerror (error "No comment")) 422 (beginning-of-line) 423 (let* ((end (match-end 0)) 424 (cs (comment-search-forward end t)) 425 (pt (point))) 426 (if (not cs) 427 (progn (beginning-of-line) 428 (comment-search-backward limit noerror)) 429 (while (progn (goto-char cs) 430 (comment-forward) 431 (and (< (point) end) 432 (setq cs (comment-search-forward end t)))) 433 (setq pt (point))) 434 (goto-char pt) 435 cs)))) 436 437(defun comment-beginning () 438 "Find the beginning of the enclosing comment. 439Returns nil if not inside a comment, else moves point and returns 440the same as `comment-search-backward'." 441 ;; HACK ATTACK! 442 ;; We should really test `in-string-p' but that can be expensive. 443 (unless (eq (get-text-property (point) 'face) 'font-lock-string-face) 444 (let ((pt (point)) 445 (cs (comment-search-backward nil t))) 446 (when cs 447 (if (save-excursion 448 (goto-char cs) 449 (and 450 ;; For modes where comment-start and comment-end are the same, 451 ;; the search above may have found a `ce' rather than a `cs'. 452 (or (if comment-end-skip (not (looking-at comment-end-skip))) 453 ;; Maybe font-lock knows that it's a `cs'? 454 (eq (get-text-property (match-end 0) 'face) 455 'font-lock-comment-face) 456 (unless (eq (get-text-property (point) 'face) 457 'font-lock-comment-face) 458 ;; Let's assume it's a `cs' if we're on the same line. 459 (>= (line-end-position) pt))) 460 ;; Make sure that PT is not past the end of the comment. 461 (if (comment-forward 1) (> (point) pt) (eobp)))) 462 cs 463 (goto-char pt) 464 nil))))) 465 466(defun comment-forward (&optional n) 467 "Skip forward over N comments. 468Just like `forward-comment' but only for positive N 469and can use regexps instead of syntax." 470 (setq n (or n 1)) 471 (if (< n 0) (error "No comment-backward") 472 (if comment-use-syntax (forward-comment n) 473 (while (> n 0) 474 (setq n 475 (if (or (forward-comment 1) 476 (and (looking-at comment-start-skip) 477 (goto-char (match-end 0)) 478 (re-search-forward comment-end-skip nil 'move))) 479 (1- n) -1))) 480 (= n 0)))) 481 482(defun comment-enter-backward () 483 "Move from the end of a comment to the end of its content. 484Point is assumed to be just at the end of a comment." 485 (if (bolp) 486 ;; comment-end = "" 487 (progn (backward-char) (skip-syntax-backward " ")) 488 (cond 489 ((save-restriction 490 (narrow-to-region (line-beginning-position) (point)) 491 (goto-char (point-min)) 492 (re-search-forward (concat comment-end-skip "\\'") nil t)) 493 (goto-char (match-beginning 0))) 494 ;; comment-end-skip not found. Maybe we're at EOB which implicitly 495 ;; closes the comment. 496 ((eobp) (skip-syntax-backward " ")) 497 (t 498 ;; else comment-end-skip was not found probably because it was not 499 ;; set right. Since \\s> should catch the single-char case, we'll 500 ;; blindly assume we're at the end of a two-char comment-end. 501 (backward-char 2) 502 (skip-chars-backward (string (char-after))) 503 (skip-syntax-backward " "))))) 504 505;;;; 506;;;; Commands 507;;;; 508 509;;;###autoload 510(defun comment-indent-default () 511 "Default for `comment-indent-function'." 512 (if (and (looking-at "\\s<\\s<\\(\\s<\\)?") 513 (or (match-end 1) (/= (current-column) (current-indentation)))) 514 0 515 (when (or (/= (current-column) (current-indentation)) 516 (and (> comment-add 0) (looking-at "\\s<\\(\\S<\\|\\'\\)"))) 517 comment-column))) 518 519;;;###autoload 520(defun comment-indent (&optional continue) 521 "Indent this line's comment to `comment-column', or insert an empty comment. 522If CONTINUE is non-nil, use the `comment-continue' markers if any." 523 (interactive "*") 524 (comment-normalize-vars) 525 (let* ((empty (save-excursion (beginning-of-line) 526 (looking-at "[ \t]*$"))) 527 (starter (or (and continue comment-continue) 528 (and empty block-comment-start) comment-start)) 529 (ender (or (and continue comment-continue "") 530 (and empty block-comment-end) comment-end))) 531 (unless starter (error "No comment syntax defined")) 532 (beginning-of-line) 533 (let* ((eolpos (line-end-position)) 534 (begpos (comment-search-forward eolpos t)) 535 cpos indent) 536 ;; An existing comment? 537 (if begpos 538 (progn 539 (if (and (not (looking-at "[\t\n ]")) 540 (looking-at comment-end-skip)) 541 ;; The comment is empty and we have skipped all its space 542 ;; and landed right before the comment-ender: 543 ;; Go back to the middle of the space. 544 (forward-char (/ (skip-chars-backward " \t") -2))) 545 (setq cpos (point-marker))) 546 ;; If none, insert one. 547 (if comment-insert-comment-function 548 (funcall comment-insert-comment-function) 549 (save-excursion 550 ;; Some `comment-indent-function's insist on not moving 551 ;; comments that are in column 0, so we first go to the 552 ;; likely target column. 553 (indent-to comment-column) 554 ;; Ensure there's a space before the comment for things 555 ;; like sh where it matters (as well as being neater). 556 (unless (memq (char-before) '(nil ?\n ?\t ?\s)) 557 (insert ?\s)) 558 (setq begpos (point)) 559 (insert starter) 560 (setq cpos (point-marker)) 561 (insert ender)))) 562 (goto-char begpos) 563 ;; Compute desired indent. 564 (setq indent (save-excursion (funcall comment-indent-function))) 565 ;; If `indent' is nil and there's code before the comment, we can't 566 ;; use `indent-according-to-mode', so we default to comment-column. 567 (unless (or indent (save-excursion (skip-chars-backward " \t") (bolp))) 568 (setq indent comment-column)) 569 (if (not indent) 570 ;; comment-indent-function refuses: delegate to line-indent. 571 (indent-according-to-mode) 572 ;; If the comment is at the left of code, adjust the indentation. 573 (unless (save-excursion (skip-chars-backward " \t") (bolp)) 574 ;; Avoid moving comments past the fill-column. 575 (let ((max (+ (current-column) 576 (- (or comment-fill-column fill-column) 577 (save-excursion (end-of-line) (current-column)))))) 578 (if (<= max indent) 579 (setq indent max) ;Don't move past the fill column. 580 ;; We can choose anywhere between indent..max. 581 ;; Let's try to align to a comment on the previous line. 582 (let ((other nil) 583 (min (max indent 584 (save-excursion (skip-chars-backward " \t") 585 (1+ (current-column)))))) 586 (save-excursion 587 (when (and (zerop (forward-line -1)) 588 (setq other (comment-search-forward 589 (line-end-position) t))) 590 (goto-char other) (setq other (current-column)))) 591 (if (and other (<= other max) (>= other min)) 592 ;; There is a comment and it's in the range: bingo. 593 (setq indent other) 594 ;; Let's try to align to a comment on the next line, then. 595 (let ((other nil)) 596 (save-excursion 597 (when (and (zerop (forward-line 1)) 598 (setq other (comment-search-forward 599 (line-end-position) t))) 600 (goto-char other) (setq other (current-column)))) 601 (if (and other (<= other max) (> other min)) 602 ;; There is a comment and it's in the range: bingo. 603 (setq indent other)))))))) 604 ;; Update INDENT to leave at least one space 605 ;; after other nonwhite text on the line. 606 (save-excursion 607 (skip-chars-backward " \t") 608 (unless (bolp) 609 (setq indent (max indent (1+ (current-column)))))) 610 ;; If that's different from comment's current position, change it. 611 (unless (= (current-column) indent) 612 (delete-region (point) (progn (skip-chars-backward " \t") (point))) 613 (indent-to indent))) 614 (goto-char cpos) 615 (set-marker cpos nil)))) 616 617;;;###autoload 618(defun comment-set-column (arg) 619 "Set the comment column based on point. 620With no ARG, set the comment column to the current column. 621With just minus as arg, kill any comment on this line. 622With any other arg, set comment column to indentation of the previous comment 623 and then align or create a comment on this line at that column." 624 (interactive "P") 625 (cond 626 ((eq arg '-) (comment-kill nil)) 627 (arg 628 (comment-normalize-vars) 629 (save-excursion 630 (beginning-of-line) 631 (comment-search-backward) 632 (beginning-of-line) 633 (goto-char (comment-search-forward (line-end-position))) 634 (setq comment-column (current-column)) 635 (message "Comment column set to %d" comment-column)) 636 (comment-indent)) 637 (t (setq comment-column (current-column)) 638 (message "Comment column set to %d" comment-column)))) 639 640;;;###autoload 641(defun comment-kill (arg) 642 "Kill the comment on this line, if any. 643With prefix ARG, kill comments on that many lines starting with this one." 644 (interactive "P") 645 (comment-normalize-vars) 646 (dotimes (_ (prefix-numeric-value arg)) 647 (save-excursion 648 (beginning-of-line) 649 (let ((cs (comment-search-forward (line-end-position) t))) 650 (when cs 651 (goto-char cs) 652 (skip-syntax-backward " ") 653 (setq cs (point)) 654 (comment-forward) 655 (kill-region cs (if (bolp) (1- (point)) (point))) 656 (indent-according-to-mode)))) 657 (if arg (forward-line 1)))) 658 659(defun comment-padright (str &optional n) 660 "Construct a string composed of STR plus `comment-padding'. 661It also adds N copies of the last non-whitespace chars of STR. 662If STR already contains padding, the corresponding amount is 663ignored from `comment-padding'. 664N defaults to 0. 665If N is `re', a regexp is returned instead, that would match 666the string for any N." 667 (setq n (or n 0)) 668 (when (and (stringp str) (not (string= "" str))) 669 ;; Separate the actual string from any leading/trailing padding 670 (string-match "\\`\\s-*\\(.*?\\)\\s-*\\'" str) 671 (let ((s (match-string 1 str)) ;actual string 672 (lpad (substring str 0 (match-beginning 1))) ;left padding 673 (rpad (concat (substring str (match-end 1)) ;original right padding 674 (substring comment-padding ;additional right padding 675 (min (- (match-end 0) (match-end 1)) 676 (length comment-padding))))) 677 ;; We can only duplicate C if the comment-end has multiple chars 678 ;; or if comments can be nested, else the comment-end `}' would 679 ;; be turned into `}}}' where only the first ends the comment 680 ;; and the rest becomes bogus junk. 681 (multi (not (and comment-quote-nested 682 ;; comment-end is a single char 683 (string-match "\\`\\s-*\\S-\\s-*\\'" comment-end))))) 684 (if (not (symbolp n)) 685 (concat lpad s (when multi (make-string n (aref str (1- (match-end 1))))) rpad) 686 ;; construct a regexp that would match anything from just S 687 ;; to any possible output of this function for any N. 688 (concat (mapconcat (lambda (c) (concat (regexp-quote (string c)) "?")) 689 lpad "") ;padding is not required 690 (regexp-quote s) 691 (when multi "+") ;the last char of S might be repeated 692 (mapconcat (lambda (c) (concat (regexp-quote (string c)) "?")) 693 rpad "")))))) ;padding is not required 694 695(defun comment-padleft (str &optional n) 696 "Construct a string composed of `comment-padding' plus STR. 697It also adds N copies of the first non-whitespace chars of STR. 698If STR already contains padding, the corresponding amount is 699ignored from `comment-padding'. 700N defaults to 0. 701If N is `re', a regexp is returned instead, that would match 702 the string for any N." 703 (setq n (or n 0)) 704 (when (and (stringp str) (not (string= "" str))) 705 ;; Only separate the left pad because we assume there is no right pad. 706 (string-match "\\`\\s-*" str) 707 (let ((s (substring str (match-end 0))) 708 (pad (concat (substring comment-padding 709 (min (- (match-end 0) (match-beginning 0)) 710 (length comment-padding))) 711 (match-string 0 str))) 712 (c (aref str (match-end 0))) ;the first non-space char of STR 713 ;; We can only duplicate C if the comment-end has multiple chars 714 ;; or if comments can be nested, else the comment-end `}' would 715 ;; be turned into `}}}' where only the first ends the comment 716 ;; and the rest becomes bogus junk. 717 (multi (not (and comment-quote-nested 718 ;; comment-end is a single char 719 (string-match "\\`\\s-*\\S-\\s-*\\'" comment-end))))) 720 (if (not (symbolp n)) 721 (concat pad (when multi (make-string n c)) s) 722 ;; Construct a regexp that would match anything from just S 723 ;; to any possible output of this function for any N. 724 ;; We match any number of leading spaces because this regexp will 725 ;; be used for uncommenting where we might want to remove 726 ;; uncomment markers with arbitrary leading space (because 727 ;; they were aligned). 728 (concat "\\s-*" 729 (if multi (concat (regexp-quote (string c)) "*")) 730 (regexp-quote s)))))) 731 732;;;###autoload 733(defun uncomment-region (beg end &optional arg) 734 "Uncomment each line in the BEG .. END region. 735The numeric prefix ARG can specify a number of chars to remove from the 736comment markers." 737 (interactive "*r\nP") 738 (comment-normalize-vars) 739 (when (> beg end) (setq beg (prog1 end (setq end beg)))) 740 ;; Bind `comment-use-global-state' to nil. While uncommenting a region 741 ;; (which works a line at a time), a comment can appear to be 742 ;; included in a mult-line string, but it is actually not. 743 (let ((comment-use-global-state nil)) 744 (save-excursion 745 (funcall uncomment-region-function beg end arg)))) 746 747(defun uncomment-region-default (beg end &optional arg) 748 "Uncomment each line in the BEG .. END region. 749The numeric prefix ARG can specify a number of chars to remove from the 750comment markers." 751 (goto-char beg) 752 (setq end (copy-marker end)) 753 (let* ((numarg (prefix-numeric-value arg)) 754 (ccs comment-continue) 755 (srei (comment-padright ccs 're)) 756 (csre (comment-padright comment-start 're)) 757 (sre (and srei (concat "^\\s-*?\\(" srei "\\)"))) 758 spt) 759 (while (and (< (point) end) 760 (setq spt (comment-search-forward end t))) 761 (let ((ipt (point)) 762 ;; Find the end of the comment. 763 (ept (progn 764 (goto-char spt) 765 (unless (or (comment-forward) 766 ;; Allow non-terminated comments. 767 (eobp)) 768 (error "Can't find the comment end")) 769 (point))) 770 (box nil) 771 (box-equal nil)) ;Whether we might be using `=' for boxes. 772 (save-restriction 773 (narrow-to-region spt ept) 774 775 ;; Remove the comment-start. 776 (goto-char ipt) 777 (skip-syntax-backward " ") 778 ;; A box-comment starts with a looong comment-start marker. 779 (when (and (or (and (= (- (point) (point-min)) 1) 780 (setq box-equal t) 781 (looking-at "=\\{7\\}") 782 (not (eq (char-before (point-max)) ?\n)) 783 (skip-chars-forward "=")) 784 (> (- (point) (point-min) (length comment-start)) 7)) 785 (> (count-lines (point-min) (point-max)) 2)) 786 (setq box t)) 787 ;; Skip the padding. Padding can come from comment-padding and/or 788 ;; from comment-start, so we first check comment-start. 789 (if (or (save-excursion (goto-char (point-min)) (looking-at csre)) 790 (looking-at (regexp-quote comment-padding))) 791 (goto-char (match-end 0))) 792 (when (and sre (looking-at (concat "\\s-*\n\\s-*" srei))) 793 (goto-char (match-end 0))) 794 (if (null arg) (delete-region (point-min) (point)) 795 (skip-syntax-backward " ") 796 (delete-char (- numarg)) 797 (unless (or (bobp) 798 (save-excursion (goto-char (point-min)) 799 (looking-at comment-start-skip))) 800 ;; If there's something left but it doesn't look like 801 ;; a comment-start any more, just remove it. 802 (delete-region (point-min) (point)))) 803 804 ;; Remove the end-comment (and leading padding and such). 805 (goto-char (point-max)) (comment-enter-backward) 806 ;; Check for special `=' used sometimes in comment-box. 807 (when (and box-equal (not (eq (char-before (point-max)) ?\n))) 808 (let ((pos (point))) 809 ;; skip `=' but only if there are at least 7. 810 (when (> (skip-chars-backward "=") -7) (goto-char pos)))) 811 (unless (looking-at "\\(\n\\|\\s-\\)*\\'") 812 (when (and (bolp) (not (bobp))) (backward-char)) 813 (if (null arg) (delete-region (point) (point-max)) 814 (skip-syntax-forward " ") 815 (delete-char numarg) 816 (unless (or (eobp) (looking-at comment-end-skip)) 817 ;; If there's something left but it doesn't look like 818 ;; a comment-end any more, just remove it. 819 (delete-region (point) (point-max))))) 820 821 ;; Unquote any nested end-comment. 822 (comment-quote-nested comment-start comment-end t) 823 824 ;; Eliminate continuation markers as well. 825 (when sre 826 (let* ((cce (comment-string-reverse (or comment-continue 827 comment-start))) 828 (erei (and box (comment-padleft cce 're))) 829 (ere (and erei (concat "\\(" erei "\\)\\s-*$")))) 830 (goto-char (point-min)) 831 (while (progn 832 (if (and ere (re-search-forward 833 ere (line-end-position) t)) 834 (replace-match "" t t nil (if (match-end 2) 2 1)) 835 (setq ere nil)) 836 (forward-line 1) 837 (re-search-forward sre (line-end-position) t)) 838 (replace-match "" t t nil (if (match-end 2) 2 1))))) 839 ;; Go to the end for the next comment. 840 (goto-char (point-max)))))) 841 (set-marker end nil)) 842 843(defun comment-make-extra-lines (cs ce ccs cce min-indent max-indent &optional block) 844 "Make the leading and trailing extra lines. 845This is used for `extra-line' style (or `box' style if BLOCK is specified)." 846 (let ((eindent 0)) 847 (if (not block) 848 ;; Try to match CS and CE's content so they align aesthetically. 849 (progn 850 (setq ce (comment-string-strip ce t t)) 851 (when (string-match "\\(.+\\).*\n\\(.*?\\)\\1" (concat ce "\n" cs)) 852 (setq eindent 853 (max (- (match-end 2) (match-beginning 2) (match-beginning 0)) 854 0)))) 855 ;; box comment 856 (let* ((width (- max-indent min-indent)) 857 (s (concat cs "a=m" cce)) 858 (e (concat ccs "a=m" ce)) 859 (c (if (string-match ".*\\S-\\S-" cs) 860 (aref cs (1- (match-end 0))) 861 (if (and (equal comment-end "") (string-match ".*\\S-" cs)) 862 (aref cs (1- (match-end 0))) ?=))) 863 (re "\\s-*a=m\\s-*") 864 (_ (string-match re s)) 865 (lcs (length cs)) 866 (fill 867 (make-string (+ width (- (match-end 0) 868 (match-beginning 0) lcs 3)) c))) 869 (setq cs (replace-match fill t t s)) 870 (when (and (not (string-match comment-start-skip cs)) 871 (string-match "a=m" s)) 872 ;; The whitespace around CS cannot be ignored: put it back. 873 (setq re "a=m") 874 (setq fill (make-string (- width lcs) c)) 875 (setq cs (replace-match fill t t s))) 876 (string-match re e) 877 (setq ce (replace-match fill t t e)))) 878 (cons (concat cs "\n" (make-string min-indent ? ) ccs) 879 (concat cce "\n" (make-string (+ min-indent eindent) ? ) ce)))) 880 881(defmacro comment-with-narrowing (beg end &rest body) 882 "Execute BODY with BEG..END narrowing. 883Space is added (and then removed) at the beginning for the text's 884indentation to be kept as it was before narrowing." 885 (declare (debug t) (indent 2)) 886 (let ((bindent (make-symbol "bindent"))) 887 `(let ((,bindent (save-excursion (goto-char ,beg) (current-column)))) 888 (save-restriction 889 (narrow-to-region ,beg ,end) 890 (goto-char (point-min)) 891 (insert (make-string ,bindent ? )) 892 (prog1 893 (progn ,@body) 894 ;; remove the bindent 895 (save-excursion 896 (goto-char (point-min)) 897 (when (looking-at " *") 898 (let ((n (min (- (match-end 0) (match-beginning 0)) ,bindent))) 899 (delete-char n) 900 (setq ,bindent (- ,bindent n)))) 901 (end-of-line) 902 (let ((e (point))) 903 (beginning-of-line) 904 (while (and (> ,bindent 0) (re-search-forward " *" e t)) 905 (let ((n (min ,bindent (- (match-end 0) (match-beginning 0) 1)))) 906 (goto-char (match-beginning 0)) 907 (delete-char n) 908 (setq ,bindent (- ,bindent n))))))))))) 909 910(defun comment-add (arg) 911 (if (and (null arg) (= (string-match "[ \t]*\\'" comment-start) 1)) 912 comment-add 913 (1- (prefix-numeric-value arg)))) 914 915(defun comment-region-internal (beg end cs ce 916 &optional ccs cce block lines indent) 917 "Comment region BEG .. END. 918CS and CE are the comment start string and comment end string, 919respectively. CCS and CCE are the comment continuation strings 920for the start and end of lines, respectively (default to CS and CE). 921BLOCK indicates that end of lines should be marked with either CCE, 922CE or CS \(if CE is empty) and that those markers should be aligned. 923LINES indicates that an extra lines will be used at the beginning 924and end of the region for CE and CS. 925INDENT indicates to put CS and CCS at the current indentation of 926the region rather than at left margin." 927 ;;(assert (< beg end)) 928 (let ((no-empty (not (or (eq comment-empty-lines t) 929 (and comment-empty-lines (zerop (length ce))))))) 930 ;; Sanitize CE and CCE. 931 (if (and (stringp ce) (string= "" ce)) (setq ce nil)) 932 (if (and (stringp cce) (string= "" cce)) (setq cce nil)) 933 ;; If CE is empty, multiline cannot be used. 934 (unless ce (setq ccs nil cce nil)) 935 ;; Should we mark empty lines as well ? 936 (if (or ccs block lines) (setq no-empty nil)) 937 ;; Make sure we have end-markers for BLOCK mode. 938 (when block (unless ce (setq ce (comment-string-reverse cs)))) 939 ;; If BLOCK is not requested, we don't need CCE. 940 (unless block (setq cce nil)) 941 ;; Continuation defaults to the same as CS and CE. 942 (unless ccs (setq ccs cs cce ce)) 943 944 (save-excursion 945 (goto-char end) 946 ;; If the end is not at the end of a line and the comment-end 947 ;; is implicit (i.e. a newline), explicitly insert a newline. 948 (unless (or ce (eolp)) (insert "\n") (indent-according-to-mode)) 949 (comment-with-narrowing beg end 950 (let ((min-indent (point-max)) 951 (max-indent 0)) 952 (goto-char (point-min)) 953 ;; Quote any nested comment marker 954 (comment-quote-nested comment-start comment-end nil) 955 956 ;; Loop over all lines to find the needed indentations. 957 (goto-char (point-min)) 958 (while 959 (progn 960 (unless (looking-at "[ \t]*$") 961 (setq min-indent (min min-indent (current-indentation)))) 962 (end-of-line) 963 (setq max-indent (max max-indent (current-column))) 964 (not (or (eobp) (progn (forward-line) nil))))) 965 966 (setq max-indent 967 (+ max-indent (max (length cs) (length ccs)) 968 ;; Inserting ccs can change max-indent by (1- tab-width) 969 ;; but only if there are TABs in the boxed text, of course. 970 (if (save-excursion (goto-char beg) 971 (search-forward "\t" end t)) 972 (1- tab-width) 0))) 973 (unless indent (setq min-indent 0)) 974 975 ;; make the leading and trailing lines if requested 976 (when lines 977 (let ((csce 978 (comment-make-extra-lines 979 cs ce ccs cce min-indent max-indent block))) 980 (setq cs (car csce)) 981 (setq ce (cdr csce)))) 982 983 (goto-char (point-min)) 984 ;; Loop over all lines from BEG to END. 985 (while 986 (progn 987 (unless (and no-empty (looking-at "[ \t]*$")) 988 (move-to-column min-indent t) 989 (insert cs) (setq cs ccs) ;switch to CCS after the first line 990 (end-of-line) 991 (if (eobp) (setq cce ce)) 992 (when cce 993 (when block (move-to-column max-indent t)) 994 (insert cce))) 995 (end-of-line) 996 (not (or (eobp) (progn (forward-line) nil)))))))))) 997 998;;;###autoload 999(defun comment-region (beg end &optional arg) 1000 "Comment or uncomment each line in the region. 1001With just \\[universal-argument] prefix arg, uncomment each line in region BEG .. END. 1002Numeric prefix ARG means use ARG comment characters. 1003If ARG is negative, delete that many comment characters instead. 1004By default, comments start at the left margin, are terminated on each line, 1005even for syntax in which newline does not end the comment and blank lines 1006do not get comments. This can be changed with `comment-style'. 1007 1008The strings used as comment starts are built from 1009`comment-start' without trailing spaces and `comment-padding'." 1010 (interactive "*r\nP") 1011 (comment-normalize-vars) 1012 (if (> beg end) (let (mid) (setq mid beg beg end end mid))) 1013 (save-excursion 1014 ;; FIXME: maybe we should call uncomment depending on ARG. 1015 (funcall comment-region-function beg end arg))) 1016 1017(defun comment-region-default (beg end &optional arg) 1018 (let* ((numarg (prefix-numeric-value arg)) 1019 (style (cdr (assoc comment-style comment-styles))) 1020 (lines (nth 2 style)) 1021 (block (nth 1 style)) 1022 (multi (nth 0 style))) 1023 ;; we use `chars' instead of `syntax' because `\n' might be 1024 ;; of end-comment syntax rather than of whitespace syntax. 1025 ;; sanitize BEG and END 1026 (goto-char beg) (skip-chars-forward " \t\n\r") (beginning-of-line) 1027 (setq beg (max beg (point))) 1028 (goto-char end) (skip-chars-backward " \t\n\r") (end-of-line) 1029 (setq end (min end (point))) 1030 (if (>= beg end) (error "Nothing to comment")) 1031 1032 ;; sanitize LINES 1033 (setq lines 1034 (and 1035 lines ;; multi 1036 (progn (goto-char beg) (beginning-of-line) 1037 (skip-syntax-forward " ") 1038 (>= (point) beg)) 1039 (progn (goto-char end) (end-of-line) (skip-syntax-backward " ") 1040 (<= (point) end)) 1041 (or block (not (string= "" comment-end))) 1042 (or block (progn (goto-char beg) (search-forward "\n" end t))))) 1043 1044 ;; don't add end-markers just because the user asked for `block' 1045 (unless (or lines (string= "" comment-end)) (setq block nil)) 1046 1047 (cond 1048 ((consp arg) (uncomment-region beg end)) 1049 ((< numarg 0) (uncomment-region beg end (- numarg))) 1050 (t 1051 (setq numarg (comment-add arg)) 1052 (comment-region-internal 1053 beg end 1054 (let ((s (comment-padright comment-start numarg))) 1055 (if (string-match comment-start-skip s) s 1056 (comment-padright comment-start))) 1057 (let ((s (comment-padleft comment-end numarg))) 1058 (and s (if (string-match comment-end-skip s) s 1059 (comment-padright comment-end)))) 1060 (if multi (comment-padright comment-continue numarg)) 1061 (if multi 1062 (comment-padleft (comment-string-reverse comment-continue) numarg)) 1063 block 1064 lines 1065 (nth 3 style)))))) 1066 1067;;;###autoload 1068(defun comment-box (beg end &optional arg) 1069 "Comment out the BEG .. END region, putting it inside a box. 1070The numeric prefix ARG specifies how many characters to add to begin- and 1071end- comment markers additionally to what `comment-add' already specifies." 1072 (interactive "*r\np") 1073 (comment-normalize-vars) 1074 (let ((comment-style (if (cadr (assoc comment-style comment-styles)) 1075 'box-multi 'box))) 1076 (comment-region beg end (+ comment-add arg)))) 1077 1078 1079;;;###autoload 1080(defun comment-or-uncomment-region (beg end &optional arg) 1081 "Call `comment-region', unless the region only consists of comments, 1082in which case call `uncomment-region'. If a prefix arg is given, it 1083is passed on to the respective function." 1084 (interactive "*r\nP") 1085 (comment-normalize-vars) 1086 (funcall (if (save-excursion ;; check for already commented region 1087 (goto-char beg) 1088 (comment-forward (point-max)) 1089 (<= end (point))) 1090 'uncomment-region 'comment-region) 1091 beg end arg)) 1092 1093;;;###autoload 1094(defun comment-dwim (arg) 1095 "Call the comment command you want (Do What I Mean). 1096If the region is active and `transient-mark-mode' is on, call 1097 `comment-region' (unless it only consists of comments, in which 1098 case it calls `uncomment-region'). 1099Else, if the current line is empty, insert a comment and indent it. 1100Else if a prefix ARG is specified, call `comment-kill'. 1101Else, call `comment-indent'. 1102You can configure `comment-style' to change the way regions are commented." 1103 (interactive "*P") 1104 (comment-normalize-vars) 1105 (if (and mark-active transient-mark-mode) 1106 (comment-or-uncomment-region (region-beginning) (region-end) arg) 1107 (if (save-excursion (beginning-of-line) (not (looking-at "\\s-*$"))) 1108 ;; FIXME: If there's no comment to kill on this line and ARG is 1109 ;; specified, calling comment-kill is not very clever. 1110 (if arg (comment-kill (and (integerp arg) arg)) (comment-indent)) 1111 (let ((add (comment-add arg))) 1112 ;; Some modes insist on keeping column 0 comment in column 0 1113 ;; so we need to move away from it before inserting the comment. 1114 (indent-according-to-mode) 1115 (insert (comment-padright comment-start add)) 1116 (save-excursion 1117 (unless (string= "" comment-end) 1118 (insert (comment-padleft comment-end add))) 1119 (indent-according-to-mode)))))) 1120 1121;;;###autoload 1122(defcustom comment-auto-fill-only-comments nil 1123 "Non-nil means to only auto-fill inside comments. 1124This has no effect in modes that do not define a comment syntax." 1125 :type 'boolean 1126 :group 'comment) 1127 1128(defun comment-valid-prefix-p (prefix compos) 1129 "Check that the adaptive-fill-prefix is consistent with the context. 1130PREFIX is the prefix (presumably guessed by `adaptive-fill-mode'). 1131COMPOS is the position of the beginning of the comment we're in, or nil 1132if we're not inside a comment." 1133 ;; This consistency checking is mostly needed to workaround the limitation 1134 ;; of auto-fill-mode whose paragraph-determination doesn't pay attention 1135 ;; to comment boundaries. 1136 (if (null compos) 1137 ;; We're not inside a comment: the prefix shouldn't match 1138 ;; a comment-starter. 1139 (not (and comment-start comment-start-skip 1140 (string-match comment-start-skip prefix))) 1141 (or 1142 ;; Accept any prefix if the current comment is not EOL-terminated. 1143 (save-excursion (goto-char compos) (comment-forward) (not (bolp))) 1144 ;; Accept any prefix that starts with the same comment-start marker 1145 ;; as the current one. 1146 (when (string-match (concat "\\`[ \t]*\\(?:" comment-start-skip "\\)") 1147 prefix) 1148 (let ((prefix-com (comment-string-strip (match-string 0 prefix) nil t))) 1149 (string-match "\\`[ \t]*" prefix-com) 1150 (let* ((prefix-space (match-string 0 prefix-com)) 1151 (prefix-indent (string-width prefix-space)) 1152 (prefix-comstart (substring prefix-com (match-end 0)))) 1153 (save-excursion 1154 (goto-char compos) 1155 ;; The comstart marker is the same. 1156 (and (looking-at (regexp-quote prefix-comstart)) 1157 ;; The indentation as well. 1158 (or (= prefix-indent 1159 (- (current-column) (current-left-margin))) 1160 ;; Check the indentation in two different ways, just 1161 ;; to try and avoid most of the potential funny cases. 1162 (equal prefix-space 1163 (buffer-substring (point) 1164 (progn (move-to-left-margin) 1165 (point))))))))))))) 1166 1167 1168;;;###autoload 1169(defun comment-indent-new-line (&optional soft) 1170 "Break line at point and indent, continuing comment if within one. 1171This indents the body of the continued comment 1172under the previous comment line. 1173 1174This command is intended for styles where you write a comment per line, 1175starting a new comment (and terminating it if necessary) on each line. 1176If you want to continue one comment across several lines, use \\[newline-and-indent]. 1177 1178If a fill column is specified, it overrides the use of the comment column 1179or comment indentation. 1180 1181The inserted newline is marked hard if variable `use-hard-newlines' is true, 1182unless optional argument SOFT is non-nil." 1183 (interactive) 1184 (comment-normalize-vars t) 1185 (let (compos comin) 1186 ;; If we are not inside a comment and we only auto-fill comments, 1187 ;; don't do anything (unless no comment syntax is defined). 1188 (unless (and comment-start 1189 comment-auto-fill-only-comments 1190 (not (interactive-p)) 1191 (not (save-excursion 1192 (prog1 (setq compos (comment-beginning)) 1193 (setq comin (point)))))) 1194 1195 ;; Now we know we should auto-fill. 1196 ;; Insert the newline before removing empty space so that markers 1197 ;; get preserved better. 1198 (if soft (insert-and-inherit ?\n) (newline 1)) 1199 (save-excursion (forward-char -1) (delete-horizontal-space)) 1200 (delete-horizontal-space) 1201 1202 (if (and fill-prefix (not adaptive-fill-mode)) 1203 ;; Blindly trust a non-adaptive fill-prefix. 1204 (progn 1205 (indent-to-left-margin) 1206 (insert-before-markers-and-inherit fill-prefix)) 1207 1208 ;; If necessary check whether we're inside a comment. 1209 (unless (or compos (null comment-start)) 1210 (save-excursion 1211 (backward-char) 1212 (setq compos (comment-beginning)) 1213 (setq comin (point)))) 1214 1215 (cond 1216 ;; If there's an adaptive prefix, use it unless we're inside 1217 ;; a comment and the prefix is not a comment starter. 1218 ((and fill-prefix 1219 (comment-valid-prefix-p fill-prefix compos)) 1220 (indent-to-left-margin) 1221 (insert-and-inherit fill-prefix)) 1222 ;; If we're not inside a comment, just try to indent. 1223 ((not compos) (indent-according-to-mode)) 1224 (t 1225 (let* ((comment-column 1226 ;; The continuation indentation should be somewhere between 1227 ;; the current line's indentation (plus 2 for good measure) 1228 ;; and the current comment's indentation, with a preference 1229 ;; for comment-column. 1230 (save-excursion 1231 ;; FIXME: use prev line's info rather than first line's. 1232 (goto-char compos) 1233 (min (current-column) (max comment-column 1234 (+ 2 (current-indentation)))))) 1235 (comstart (buffer-substring compos comin)) 1236 (normalp 1237 (string-match (regexp-quote (comment-string-strip 1238 comment-start t t)) 1239 comstart)) 1240 (comment-end 1241 (if normalp comment-end 1242 ;; The comment starter is not the normal comment-start 1243 ;; so we can't just use comment-end. 1244 (save-excursion 1245 (goto-char compos) 1246 (if (not (comment-forward)) comment-end 1247 (comment-string-strip 1248 (buffer-substring 1249 (save-excursion (comment-enter-backward) (point)) 1250 (point)) 1251 nil t))))) 1252 (comment-start comstart) 1253 (continuep (or comment-multi-line 1254 (cadr (assoc comment-style comment-styles)))) 1255 ;; Force comment-continue to be recreated from comment-start. 1256 ;; FIXME: wrong if comment-continue was set explicitly! 1257 ;; FIXME: use prev line's continuation if available. 1258 (comment-continue nil)) 1259 (if (and comment-multi-line (> (length comment-end) 0)) 1260 (indent-according-to-mode) 1261 (insert-and-inherit ?\n) 1262 (forward-char -1) 1263 (comment-indent continuep) 1264 (save-excursion 1265 (let ((pt (point))) 1266 (end-of-line) 1267 (let ((comend (buffer-substring pt (point)))) 1268 ;; The 1+ is to make sure we delete the \n inserted above. 1269 (delete-region pt (1+ (point))) 1270 (end-of-line 0) 1271 (insert comend)))))))))))) 1272 1273(provide 'newcomment) 1274 1275;; arch-tag: 01e3320a-00c8-44ea-a696-8f8e7354c858 1276;;; newcomment.el ends here 1277