Function: ls-lisp-version-lessp

ls-lisp-version-lessp is a byte-compiled function defined in ls-lisp.el.gz.

Signature

(ls-lisp-version-lessp S1 S2)

Documentation

Return t if versioned string S1 should sort before versioned string S2.

Case is significant if ls-lisp-ignore-case is nil. This is the same as string-lessp (with the exception of case insensitivity), but sequences of digits are compared numerically, as a whole, in the same manner as the strverscmp function available in some standard C libraries does.

Source Code

;; Defined in /usr/src/emacs/lisp/ls-lisp.el.gz
(defun ls-lisp-version-lessp (s1 s2)
  "Return t if versioned string S1 should sort before versioned string S2.

Case is significant if `ls-lisp-ignore-case' is nil.
This is the same as `string-lessp' (with the exception of case
insensitivity), but sequences of digits are compared numerically,
as a whole, in the same manner as the `strverscmp' function available
in some standard C libraries does."
  (let ((i1 0)
	(i2 0)
	(len1 (length s1))
	(len2 (length s2))
	(val 0)
	ni1 ni2 e1 e2 found-2-numbers-p)
    (while (and (< i1 len1) (< i2 len2) (zerop val))
      (unless found-2-numbers-p
	(setq ni1 (string-match "[0-9]+" s1 i1)
	      e1 (match-end 0))
	(setq ni2 (string-match "[0-9]+" s2 i2)
	      e2 (match-end 0)))
      (cond
       ((and ni1 ni2)
	(cond
	 ((and (> ni1 i1) (> ni2 i2))
	  ;; Compare non-numerical part as strings.
	  (setq val (compare-strings s1 i1 ni1 s2 i2 ni2 ls-lisp-ignore-case)
		i1 ni1
		i2 ni2
		found-2-numbers-p t))
	 ((and (= ni1 i1) (= ni2 i2))
	  (setq found-2-numbers-p nil)
	  ;; Compare numerical parts as integral and/or fractional parts.
	  (let* ((sub1 (substring s1 ni1 e1))
		 (sub2 (substring s2 ni2 e2))
		 ;; "Fraction" is a numerical sequence with leading zeros.
		 (fr1 (string-match "\\`0+" sub1))
		 (efr1 (match-end 0))
		 (fr2 (string-match "\\`0+" sub2))
		 (efr2 (match-end 0)))
	    (cond
             ;; Two fractions: the longer one is less than the other,
             ;; but only if the "common prefix" is all-zeroes,
             ;; otherwise fall back on numerical comparison.
	     ((and fr1 fr2)
	      (if (or (and (< efr1 (- e1 ni1)) (< efr2 (- e2 ni2))
			   (not (eq (aref sub1 efr1) (aref sub2 efr2))))
		      (= efr1 (- e1 ni1)) (=  efr2 (- e2 ni2)))
		  (setq val (- val (- (length sub1) (length sub2))))))
	     (fr1		; a fraction is always less than an integral
	      (setq val (- 0 ni1 1)))   ; make sure val is non-zero
	     (fr2
	      (setq val (1+ ni2))))     ; make sure val is non-zero
	    (if (zerop val)	; fall back on numerical comparison
		(setq val (- (string-to-number sub1)
			     (string-to-number sub2))))
	    (setq i1 e1
		  i2 e2)))
	 (t
	  (setq val (compare-strings s1 i1 nil s2 i2 nil ls-lisp-ignore-case)
		i1 len1
		i2 len2))))
       (t (setq val (compare-strings s1 i1 nil s2 i2 nil ls-lisp-ignore-case)
		i1 len1
		i2 len2)))
      (and (eq val t) (setq val 0)))
    (if (zerop val)
	(setq val (- len1 len2)))
    (< val 0)))