1;;; sort.el --- commands to sort text in an Emacs buffer 2 3;; Copyright (C) 1986, 1987, 1994, 1995, 2001, 2002, 2003, 4;; 2004, 2005, 2006, 2007 Free Software Foundation, Inc. 5 6;; Author: Howie Kaye 7;; Maintainer: FSF 8;; Keywords: unix 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;; This package provides the sorting facilities documented in the Emacs 30;; user's manual. 31 32;;; Code: 33 34(defgroup sort nil 35 "Commands to sort text in an Emacs buffer." 36 :group 'data) 37 38(defcustom sort-fold-case nil 39 "*Non-nil if the buffer sort functions should ignore case." 40 :group 'sort 41 :type 'boolean) 42 43;;;###autoload 44(defun sort-subr (reverse nextrecfun endrecfun 45 &optional startkeyfun endkeyfun predicate) 46 "General text sorting routine to divide buffer into records and sort them. 47 48We divide the accessible portion of the buffer into disjoint pieces 49called sort records. A portion of each sort record (perhaps all of 50it) is designated as the sort key. The records are rearranged in the 51buffer in order by their sort keys. The records may or may not be 52contiguous. 53 54Usually the records are rearranged in order of ascending sort key. 55If REVERSE is non-nil, they are rearranged in order of descending sort key. 56The variable `sort-fold-case' determines whether alphabetic case affects 57the sort order. 58 59The next four arguments are functions to be called to move point 60across a sort record. They will be called many times from within sort-subr. 61 62NEXTRECFUN is called with point at the end of the previous record. 63It moves point to the start of the next record. 64It should move point to the end of the buffer if there are no more records. 65The first record is assumed to start at the position of point when sort-subr 66is called. 67 68ENDRECFUN is called with point within the record. 69It should move point to the end of the record. 70 71STARTKEYFUN moves from the start of the record to the start of the key. 72It may return either a non-nil value to be used as the key, or 73else the key is the substring between the values of point after 74STARTKEYFUN and ENDKEYFUN are called. If STARTKEYFUN is nil, the key 75starts at the beginning of the record. 76 77ENDKEYFUN moves from the start of the sort key to the end of the sort key. 78ENDKEYFUN may be nil if STARTKEYFUN returns a value or if it would be the 79same as ENDRECFUN. 80 81PREDICATE is the function to use to compare keys. If keys are numbers, 82it defaults to `<', otherwise it defaults to `string<'." 83 ;; Heuristically try to avoid messages if sorting a small amt of text. 84 (let ((messages (> (- (point-max) (point-min)) 50000))) 85 (save-excursion 86 (if messages (message "Finding sort keys...")) 87 (let* ((sort-lists (sort-build-lists nextrecfun endrecfun 88 startkeyfun endkeyfun)) 89 (old (reverse sort-lists)) 90 (case-fold-search sort-fold-case)) 91 (if (null sort-lists) 92 () 93 (or reverse (setq sort-lists (nreverse sort-lists))) 94 (if messages (message "Sorting records...")) 95 (setq sort-lists 96 (sort sort-lists 97 (cond (predicate 98 `(lambda (a b) (,predicate (car a) (car b)))) 99 ((numberp (car (car sort-lists))) 100 'car-less-than-car) 101 ((consp (car (car sort-lists))) 102 (lambda (a b) 103 (> 0 (compare-buffer-substrings 104 nil (car (car a)) (cdr (car a)) 105 nil (car (car b)) (cdr (car b)))))) 106 (t 107 (lambda (a b) (string< (car a) (car b))))))) 108 (if reverse (setq sort-lists (nreverse sort-lists))) 109 (if messages (message "Reordering buffer...")) 110 (sort-reorder-buffer sort-lists old))) 111 (if messages (message "Reordering buffer... Done")))) 112 nil) 113 114;; Parse buffer into records using the arguments as Lisp expressions; 115;; return a list of records. Each record looks like (KEY STARTPOS . ENDPOS) 116;; where KEY is the sort key (a number or string), 117;; and STARTPOS and ENDPOS are the bounds of this record in the buffer. 118 119;; The records appear in the list lastmost first! 120 121(defun sort-build-lists (nextrecfun endrecfun startkeyfun endkeyfun) 122 (let ((sort-lists ()) 123 (start-rec nil) 124 done key) 125 ;; Loop over sort records. 126 ;(goto-char (point-min)) -- it is the caller's responsibility to 127 ;arrange this if necessary 128 (while (not (eobp)) 129 (setq start-rec (point)) ;save record start 130 (setq done nil) 131 ;; Get key value, or move to start of key. 132 (setq key (catch 'key 133 (or (and startkeyfun (funcall startkeyfun)) 134 ;; If key was not returned as value, 135 ;; move to end of key and get key from the buffer. 136 (let ((start (point))) 137 (funcall (or endkeyfun 138 (prog1 endrecfun (setq done t)))) 139 (cons start (point)))))) 140 ;; Move to end of this record (start of next one, or end of buffer). 141 (cond ((prog1 done (setq done nil))) 142 (endrecfun (funcall endrecfun)) 143 (nextrecfun (funcall nextrecfun) (setq done t))) 144 (if key (push 145 ;; consing optimization in case in which key is same as record. 146 (if (and (consp key) 147 (equal (car key) start-rec) 148 (equal (cdr key) (point))) 149 (cons key key) 150 (cons key (cons start-rec (point)))) 151 sort-lists)) 152 (and (not done) nextrecfun (funcall nextrecfun))) 153 sort-lists)) 154 155(defun sort-reorder-buffer (sort-lists old) 156 (let ((last (point-min)) 157 (min (point-min)) (max (point-max)) 158 (old-buffer (current-buffer)) 159 temp-buffer) 160 (with-temp-buffer 161 ;; Record the temporary buffer. 162 (setq temp-buffer (current-buffer)) 163 164 ;; Copy the sorted text into the temporary buffer. 165 (while sort-lists 166 (goto-char (point-max)) 167 (insert-buffer-substring old-buffer 168 last 169 (nth 1 (car old))) 170 (goto-char (point-max)) 171 (insert-buffer-substring old-buffer 172 (nth 1 (car sort-lists)) 173 (cdr (cdr (car sort-lists)))) 174 (setq last (cdr (cdr (car old))) 175 sort-lists (cdr sort-lists) 176 old (cdr old))) 177 (goto-char (point-max)) 178 (insert-buffer-substring old-buffer last max) 179 180 ;; Copy the reordered text from the temporary buffer 181 ;; to the buffer we sorted (OLD-BUFFER). 182 (set-buffer old-buffer) 183 (let ((inhibit-quit t)) 184 ;; Make sure insertions done for reordering 185 ;; saves any markers at the end of the sorted region, 186 ;; by leaving the last character of the region. 187 (delete-region min (1- max)) 188 ;; Now replace the one remaining old character with the sorted text. 189 (goto-char (point-min)) 190 (insert-buffer-substring temp-buffer) 191 (delete-region max (1+ max)))))) 192 193;;;###autoload 194(defun sort-lines (reverse beg end) 195 "Sort lines in region alphabetically; argument means descending order. 196Called from a program, there are three arguments: 197REVERSE (non-nil means reverse order), BEG and END (region to sort). 198The variable `sort-fold-case' determines whether alphabetic case affects 199the sort order." 200 (interactive "P\nr") 201 (save-excursion 202 (save-restriction 203 (narrow-to-region beg end) 204 (goto-char (point-min)) 205 (let ;; To make `end-of-line' and etc. to ignore fields. 206 ((inhibit-field-text-motion t)) 207 (sort-subr reverse 'forward-line 'end-of-line))))) 208 209;;;###autoload 210(defun sort-paragraphs (reverse beg end) 211 "Sort paragraphs in region alphabetically; argument means descending order. 212Called from a program, there are three arguments: 213REVERSE (non-nil means reverse order), BEG and END (region to sort). 214The variable `sort-fold-case' determines whether alphabetic case affects 215the sort order." 216 (interactive "P\nr") 217 (save-excursion 218 (save-restriction 219 (narrow-to-region beg end) 220 (goto-char (point-min)) 221 (sort-subr reverse 222 (function 223 (lambda () 224 (while (and (not (eobp)) (looking-at paragraph-separate)) 225 (forward-line 1)))) 226 'forward-paragraph)))) 227 228;;;###autoload 229(defun sort-pages (reverse beg end) 230 "Sort pages in region alphabetically; argument means descending order. 231Called from a program, there are three arguments: 232REVERSE (non-nil means reverse order), BEG and END (region to sort). 233The variable `sort-fold-case' determines whether alphabetic case affects 234the sort order." 235 (interactive "P\nr") 236 (save-excursion 237 (save-restriction 238 (narrow-to-region beg end) 239 (goto-char (point-min)) 240 (sort-subr reverse 241 (function (lambda () (skip-chars-forward "\n"))) 242 'forward-page)))) 243 244(defvar sort-fields-syntax-table nil) 245(if sort-fields-syntax-table nil 246 (let ((table (make-syntax-table)) 247 (i 0)) 248 (while (< i 256) 249 (modify-syntax-entry i "w" table) 250 (setq i (1+ i))) 251 (modify-syntax-entry ?\s " " table) 252 (modify-syntax-entry ?\t " " table) 253 (modify-syntax-entry ?\n " " table) 254 (modify-syntax-entry ?\. "_" table) ; for floating pt. numbers. -wsr 255 (setq sort-fields-syntax-table table))) 256 257(defcustom sort-numeric-base 10 258 "*The default base used by `sort-numeric-fields'." 259 :group 'sort 260 :type 'integer) 261 262;;;###autoload 263(defun sort-numeric-fields (field beg end) 264 "Sort lines in region numerically by the ARGth field of each line. 265Fields are separated by whitespace and numbered from 1 up. 266Specified field must contain a number in each line of the region, 267which may begin with \"0x\" or \"0\" for hexadecimal and octal values. 268Otherwise, the number is interpreted according to sort-numeric-base. 269With a negative arg, sorts by the ARGth field counted from the right. 270Called from a program, there are three arguments: 271FIELD, BEG and END. BEG and END specify region to sort." 272 (interactive "p\nr") 273 (let ;; To make `end-of-line' and etc. to ignore fields. 274 ((inhibit-field-text-motion t)) 275 (sort-fields-1 field beg end 276 (lambda () 277 (sort-skip-fields field) 278 (let* ((case-fold-search t) 279 (base 280 (if (looking-at "\\(0x\\)[0-9a-f]\\|\\(0\\)[0-7]") 281 (cond ((match-beginning 1) 282 (goto-char (match-end 1)) 283 16) 284 ((match-beginning 2) 285 (goto-char (match-end 2)) 286 8) 287 (t nil))))) 288 (string-to-number (buffer-substring (point) 289 (save-excursion 290 (forward-sexp 1) 291 (point))) 292 (or base sort-numeric-base)))) 293 nil))) 294 295;;;;;###autoload 296;;(defun sort-float-fields (field beg end) 297;; "Sort lines in region numerically by the ARGth field of each line. 298;;Fields are separated by whitespace and numbered from 1 up. Specified field 299;;must contain a floating point number in each line of the region. With a 300;;negative arg, sorts by the ARGth field counted from the right. Called from a 301;;program, there are three arguments: FIELD, BEG and END. BEG and END specify 302;;region to sort." 303;; (interactive "p\nr") 304;; (sort-fields-1 field beg end 305;; (function (lambda () 306;; (sort-skip-fields field) 307;; (string-to-number 308;; (buffer-substring 309;; (point) 310;; (save-excursion 311;; (re-search-forward 312;; "[+-]?[0-9]*\.?[0-9]*\\([eE][+-]?[0-9]+\\)?") 313;; (point)))))) 314;; nil)) 315 316;;;###autoload 317(defun sort-fields (field beg end) 318 "Sort lines in region lexicographically by the ARGth field of each line. 319Fields are separated by whitespace and numbered from 1 up. 320With a negative arg, sorts by the ARGth field counted from the right. 321Called from a program, there are three arguments: 322FIELD, BEG and END. BEG and END specify region to sort. 323The variable `sort-fold-case' determines whether alphabetic case affects 324the sort order." 325 (interactive "p\nr") 326 (let ;; To make `end-of-line' and etc. to ignore fields. 327 ((inhibit-field-text-motion t)) 328 (sort-fields-1 field beg end 329 (function (lambda () 330 (sort-skip-fields field) 331 nil)) 332 (function (lambda () (skip-chars-forward "^ \t\n")))))) 333 334(defun sort-fields-1 (field beg end startkeyfun endkeyfun) 335 (let ((tbl (syntax-table))) 336 (if (zerop field) (setq field 1)) 337 (unwind-protect 338 (save-excursion 339 (save-restriction 340 (narrow-to-region beg end) 341 (goto-char (point-min)) 342 (set-syntax-table sort-fields-syntax-table) 343 (sort-subr nil 344 'forward-line 'end-of-line 345 startkeyfun endkeyfun))) 346 (set-syntax-table tbl)))) 347 348;; Position at the beginning of field N on the current line, 349;; assuming point is initially at the beginning of the line. 350(defun sort-skip-fields (n) 351 (if (> n 0) 352 ;; Skip across N - 1 fields. 353 (let ((i (1- n))) 354 (while (> i 0) 355 (skip-chars-forward " \t") 356 (skip-chars-forward "^ \t\n") 357 (setq i (1- i))) 358 (skip-chars-forward " \t") 359 (if (eolp) 360 (error "Line has too few fields: %s" 361 (buffer-substring 362 (save-excursion (beginning-of-line) (point)) 363 (save-excursion (end-of-line) (point)))))) 364 (end-of-line) 365 ;; Skip back across - N - 1 fields. 366 (let ((i (1- (- n)))) 367 (while (> i 0) 368 (skip-chars-backward " \t") 369 (skip-chars-backward "^ \t\n") 370 (setq i (1- i))) 371 (skip-chars-backward " \t")) 372 (if (bolp) 373 (error "Line has too few fields: %s" 374 (buffer-substring 375 (save-excursion (beginning-of-line) (point)) 376 (save-excursion (end-of-line) (point))))) 377 ;; Position at the front of the field 378 ;; even if moving backwards. 379 (skip-chars-backward "^ \t\n"))) 380 381(defvar sort-regexp-fields-regexp) 382(defvar sort-regexp-record-end) 383 384;; Move to the beginning of the next match for record-regexp, 385;; and set sort-regexp-record-end to the end of that match. 386;; If the next match is empty and does not advance point, 387;; skip one character and try again. 388(defun sort-regexp-fields-next-record () 389 (let ((oldpos (point))) 390 (and (re-search-forward sort-regexp-fields-regexp nil 'move) 391 (setq sort-regexp-record-end (match-end 0)) 392 (if (= sort-regexp-record-end oldpos) 393 (progn 394 (forward-char 1) 395 (re-search-forward sort-regexp-fields-regexp nil 'move) 396 (setq sort-regexp-record-end (match-end 0))) 397 t) 398 (goto-char (match-beginning 0))))) 399 400;;;###autoload 401(defun sort-regexp-fields (reverse record-regexp key-regexp beg end) 402 "Sort the region lexicographically as specified by RECORD-REGEXP and KEY. 403RECORD-REGEXP specifies the textual units which should be sorted. 404 For example, to sort lines RECORD-REGEXP would be \"^.*$\" 405KEY specifies the part of each record (ie each match for RECORD-REGEXP) 406 is to be used for sorting. 407 If it is \"\\\\digit\" then the digit'th \"\\\\(...\\\\)\" match field from 408 RECORD-REGEXP is used. 409 If it is \"\\\\&\" then the whole record is used. 410 Otherwise, it is a regular-expression for which to search within the record. 411If a match for KEY is not found within a record then that record is ignored. 412 413With a negative prefix arg sorts in reverse order. 414 415The variable `sort-fold-case' determines whether alphabetic case affects 416the sort order. 417 418For example: to sort lines in the region by the first word on each line 419 starting with the letter \"f\", 420 RECORD-REGEXP would be \"^.*$\" and KEY would be \"\\\\=\\<f\\\\w*\\\\>\"" 421 ;; using negative prefix arg to mean "reverse" is now inconsistent with 422 ;; other sort-.*fields functions but then again this was before, since it 423 ;; didn't use the magnitude of the arg to specify anything. 424 (interactive "P\nsRegexp specifying records to sort: 425sRegexp specifying key within record: \nr") 426 (cond ((or (equal key-regexp "") (equal key-regexp "\\&")) 427 (setq key-regexp 0)) 428 ((string-match "\\`\\\\[1-9]\\'" key-regexp) 429 (setq key-regexp (- (aref key-regexp 1) ?0)))) 430 (save-excursion 431 (save-restriction 432 (narrow-to-region beg end) 433 (goto-char (point-min)) 434 (let (sort-regexp-record-end 435 (sort-regexp-fields-regexp record-regexp)) 436 (re-search-forward sort-regexp-fields-regexp nil t) 437 (setq sort-regexp-record-end (point)) 438 (goto-char (match-beginning 0)) 439 (sort-subr reverse 440 'sort-regexp-fields-next-record 441 (function (lambda () 442 (goto-char sort-regexp-record-end))) 443 (function (lambda () 444 (let ((n 0)) 445 (cond ((numberp key-regexp) 446 (setq n key-regexp)) 447 ((re-search-forward 448 key-regexp sort-regexp-record-end t) 449 (setq n 0)) 450 (t (throw 'key nil))) 451 (condition-case () 452 (cons (match-beginning n) 453 (match-end n)) 454 ;; if there was no such register 455 (error (throw 'key nil))))))))))) 456 457 458(defvar sort-columns-subprocess t) 459 460;;;###autoload 461(defun sort-columns (reverse &optional beg end) 462 "Sort lines in region alphabetically by a certain range of columns. 463For the purpose of this command, the region BEG...END includes 464the entire line that point is in and the entire line the mark is in. 465The column positions of point and mark bound the range of columns to sort on. 466A prefix argument means sort into REVERSE order. 467The variable `sort-fold-case' determines whether alphabetic case affects 468the sort order. 469 470Note that `sort-columns' rejects text that contains tabs, 471because tabs could be split across the specified columns 472and it doesn't know how to handle that. Also, when possible, 473it uses the `sort' utility program, which doesn't understand tabs. 474Use \\[untabify] to convert tabs to spaces before sorting." 475 (interactive "P\nr") 476 (save-excursion 477 (let ;; To make `end-of-line' and etc. to ignore fields. 478 ((inhibit-field-text-motion t) 479 beg1 end1 col-beg1 col-end1 col-start col-end) 480 (goto-char (min beg end)) 481 (setq col-beg1 (current-column)) 482 (beginning-of-line) 483 (setq beg1 (point)) 484 (goto-char (max beg end)) 485 (setq col-end1 (current-column)) 486 (forward-line) 487 (setq end1 (point)) 488 (setq col-start (min col-beg1 col-end1)) 489 (setq col-end (max col-beg1 col-end1)) 490 (if (search-backward "\t" beg1 t) 491 (error "sort-columns does not work with tabs -- use M-x untabify")) 492 (if (not (or (memq system-type '(vax-vms windows-nt)) 493 (let ((pos beg1) plist fontified) 494 (catch 'found 495 (while (< pos end1) 496 (setq plist (text-properties-at pos)) 497 (setq fontified (plist-get plist 'fontified)) 498 (while (consp plist) 499 (unless (or (eq (car plist) 'fontified) 500 (and (eq (car plist) 'face) 501 fontified)) 502 (throw 'found t)) 503 (setq plist (cddr plist))) 504 (setq pos (next-property-change pos nil end1))))))) 505 ;; Use the sort utility if we can; it is 4 times as fast. 506 ;; Do not use it if there are any non-font-lock properties 507 ;; in the region, since the sort utility would lose the 508 ;; properties. Tabs are used as field separator; on NetBSD, 509 ;; sort complains if "\n" is used as field separator. 510 (let ((sort-args (list (if reverse "-rt\t" "-t\t") 511 (format "-k1.%d,1.%d" 512 (1+ col-start) 513 (1+ col-end))))) 514 (when sort-fold-case 515 (push "-f" sort-args)) 516 (apply #'call-process-region beg1 end1 "sort" t t nil sort-args)) 517 ;; On VMS and ms-windows, use Emacs's own facilities. 518 (save-excursion 519 (save-restriction 520 (narrow-to-region beg1 end1) 521 (goto-char beg1) 522 (sort-subr reverse 'forward-line 'end-of-line 523 #'(lambda () (move-to-column col-start) nil) 524 #'(lambda () (move-to-column col-end) nil)))))))) 525 526;;;###autoload 527(defun reverse-region (beg end) 528 "Reverse the order of lines in a region. 529From a program takes two point or marker arguments, BEG and END." 530 (interactive "r") 531 (if (> beg end) 532 (let (mid) (setq mid end end beg beg mid))) 533 (save-excursion 534 ;; put beg at the start of a line and end and the end of one -- 535 ;; the largest possible region which fits this criteria 536 (goto-char beg) 537 (or (bolp) (forward-line 1)) 538 (setq beg (point)) 539 (goto-char end) 540 ;; the test for bolp is for those times when end is on an empty line; 541 ;; it is probably not the case that the line should be included in the 542 ;; reversal; it isn't difficult to add it afterward. 543 (or (and (eolp) (not (bolp))) (progn (forward-line -1) (end-of-line))) 544 (setq end (point-marker)) 545 ;; the real work. this thing cranks through memory on large regions. 546 (let (ll (do t)) 547 (while do 548 (goto-char beg) 549 (setq ll (cons (buffer-substring (point) (progn (end-of-line) (point))) 550 ll)) 551 (setq do (/= (point) end)) 552 (delete-region beg (if do (1+ (point)) (point)))) 553 (while (cdr ll) 554 (insert (car ll) "\n") 555 (setq ll (cdr ll))) 556 (insert (car ll))))) 557 558(provide 'sort) 559 560;;; arch-tag: fbac12be-2a7b-4c8a-9665-264d61f70bd9 561;;; sort.el ends here 562