#!+sb-doc
"The argument must be a character object; UPPER-CASE-P returns T if the
argument is an upper-case character, NIL otherwise."
- (< (ucd-value-0 char) 4))
+ (< (ucd-value-0 char) 5))
(defun lower-case-p (char)
#!+sb-doc
"The argument must be a character object; LOWER-CASE-P returns T if the
argument is a lower-case character, NIL otherwise."
- (< 3 (ucd-value-0 char) 8))
+ (< 4 (ucd-value-0 char) 9))
(defun both-case-p (char)
#!+sb-doc
"The argument must be a character object. BOTH-CASE-P returns T if the
argument is an alphabetic character and if the character exists in both upper
and lower case. For ASCII, this is the same as ALPHA-CHAR-P."
- (< (ucd-value-0 char) 8))
+ (< (ucd-value-0 char) 9))
(defun digit-char-p (char &optional (radix 10.))
#!+sb-doc
(defmacro equal-char-code (character)
(let ((ch (gensym)))
`(let ((,ch ,character))
- (if (< (ucd-value-0 ,ch) 4)
+ (if (< (ucd-value-0 ,ch) 5)
(ucd-value-1 ,ch)
(char-code ,ch)))))
#!+sb-doc
"Return CHAR converted to upper-case if that is possible. Don't convert
lowercase eszet (U+DF)."
- (if (< 3 (ucd-value-0 char) 8)
+ (if (< 4 (ucd-value-0 char) 9)
(code-char (ucd-value-1 char))
char))
(defun char-downcase (char)
#!+sb-doc
"Return CHAR converted to lower-case if that is possible."
- (if (< (ucd-value-0 char) 4)
+ (if (< (ucd-value-0 char) 5)
(code-char (ucd-value-1 char))
char))
(with-test (:name (:case-insensitive-char-comparisons :eacute))
(assert (char-equal (code-char 201) (code-char 233))))
-(with-test (:name (:case-insensitive-char-comparisons :exhaustive)
- :fails-on :sb-unicode)
+(with-test (:name (:case-insensitive-char-comparisons :exhaustive))
(dotimes (i char-code-limit)
(let* ((char (code-char i))
(down (char-downcase char))
(setf (gethash list *misc-hash*)
(incf *misc-index*))))))
+(defun gc-index-sort-key (gc-index)
+ (or (cdr (assoc gc-index '((1 . 2) (2 . 1)))) gc-index))
+
(defun compare-misc-entry (left right)
(destructuring-bind (left-gc-index left-bidi-index left-ccc-index
left-decimal-digit left-digit left-bidi-mirrored
right
(or (and left-cl-both-case-p (not right-cl-both-case-p))
(and (or left-cl-both-case-p (not right-cl-both-case-p))
- (or (< left-gc-index right-gc-index)
+ (or (< (gc-index-sort-key left-gc-index)
+ (gc-index-sort-key right-gc-index))
(and (= left-gc-index right-gc-index)
(or (< left-decomposition-info right-decomposition-info)
(and (= left-decomposition-info right-decomposition-info)
(parse-integer simple-titlecase :radix 16)))
(cl-both-case-p
(not (null (or (and (= gc-index 0) lower-index)
- (and (= gc-index 1) upper-index)))))
+ (and (= gc-index 1) upper-index)
+ ;; deal with prosgegrammeni / titlecase
+ (and (= gc-index 2)
+ (typep code-point '(integer #x1000 #x1fff))
+ lower-index)))))
(decomposition-info 0))
(declare (ignore digit-index))
(when (and (not cl-both-case-p)