{quick,merge}sort -> sort

svn: r2569

original commit: 16f01a1109691d2fa4844b9411410f4794cf0dc1

collects/parser-tools/private-lex/deriv.ss

@@ -239,19 +239,19 @@
         (cond
           ((and (null? old-states) (null? new-states))
            (make-dfa (get-state-number) (state-index start)
-                     (mergesort (filter (lambda (x) (cdr x))
+                     (sort (filter (lambda (x) (cdr x))
-                                        (map (lambda (state)
+                                   (map (lambda (state)
-					       (cons (state-index state) (get-final (state-spec state))))
+                                          (cons (state-index state) (get-final (state-spec state))))
-					     all-states))
+                                        all-states))
-                                (lambda (a b) (< (car a) (car b))))
+                           (lambda (a b) (< (car a) (car b))))
-                     (mergesort (hash-table-map transitions
+                     (sort (hash-table-map transitions
-                                                (lambda (state trans)
+                                           (lambda (state trans)
-                                                  (cons (state-index state)
+                                             (cons (state-index state)
-                                                        (map (lambda (t)
+                                                   (map (lambda (t)
-                                                               (cons (car t)
+                                                          (cons (car t)
-                                                                     (state-index (cdr t))))
+                                                                (state-index (cdr t))))
-                                                             trans))))
+                                                        trans))))
-                                (lambda (a b) (< (car a) (car b))))))
+                           (lambda (a b) (< (car a) (car b))))))
           ((null? old-states)
            (loop new-states null all-states (compute-chars new-states)))
           ((null? cs)
@@ -336,4 +336,4 @@
                                        (repetition 1 +inf.0 "1")))))))
   (define t14 (build-test-dfa `((complement "1"))))
 |#
-  )
+  )

collects/parser-tools/private-lex/front.ss

@@ -31,7 +31,7 @@
         (let* ((from-state (car trans))
                (all-chars/to (cdr trans))
                (flat-all-chars/to
-                (mergesort
+                (sort
                  (apply append
                    (map (lambda (chars/to)
                           (let ((char-ranges (loc:integer-set-contents (car chars/to)))

collects/parser-tools/private-lex/util.ss

@@ -85,7 +85,7 @@
   ;; Sorts l according to index and removes the entries with duplicate
   ;; indexes.
   (define (do-simple-equiv l index)
-    (let ((ordered (mergesort l (lambda (a b) (< (index a) (index b))))))
+    (let ((ordered (sort l (lambda (a b) (< (index a) (index b))))))
       (remove-dups ordered index null)))
 
   (test-block ()

collects/parser-tools/private-yacc/lr0.ss

@@ -28,7 +28,7 @@
                 (non-term-index (trans-key-gs b)))))))
   
   (define (trans-key-list-remove-dups tkl)
-    (let loop ((sorted (quicksort tkl trans-key<?)))
+    (let loop ((sorted (sort tkl trans-key<?)))
       (cond
         ((null? sorted) null)
         ((null? (cdr sorted)) sorted)
@@ -39,9 +39,8 @@
                      (kernel-index (trans-key-st (cadr sorted)))))
              (loop (cdr sorted))
              (cons (car sorted) (loop (cdr sorted))))))))
-             
+
-      
+
-           
   ;; build-transition-table : int (listof (cons/c trans-key X) ->
   ;;                          (vectorof (symbol X hashtable))
   (define (build-transition-table num-states assoc)
@@ -279,7 +278,7 @@
 		      (let* ((gs (car i))
 			     (items (cadr i))
 			     (new #f)
-			     (new-kernel (quicksort
+			     (new-kernel (sort
 					  (filter (lambda (x) x)
 						  (map move-dot-right items))
 					  item<?))
@@ -370,4 +369,4 @@
      (car (q-f q))
      (set-q-f! q (cdr (q-f q)))))
 
-)
+)

collects/parser-tools/yacc-to-scheme.ss

@@ -124,8 +124,8 @@
 		      (let ((t (get-token-grammar i)))
 			t)))))
           `(begin
-             (define-tokens t ,(quicksort (hash-table-map terms (lambda (k v) k)) symbol<?))
+             (define-tokens t ,(sort (hash-table-map terms (lambda (k v) k)) symbol<?))
-             (define-empty-tokens et ,(quicksort (hash-table-map eterms (lambda (k v) k)) symbol<?))
+             (define-empty-tokens et ,(sort (hash-table-map eterms (lambda (k v) k)) symbol<?))
              (parser
               (start ___)
               (end ___)