string-ci* oddity

string-ci* oddity

[Bill Schottstaedt]

Why do both Guile and Gauche give this result in string-ci<?
(and the other string-ci functions similarly):

guile> (char-ci<? #\a #\_)
#t
guile> (string-ci<? "a" "_")
#f

gosh> (char-ci<? #\a #\_)
#t
gosh> (string-ci<? "a" "_")
#f

The odd chars are ASCII 91 to 96:

guile> (string-ci<? "a" "[")
#f
guile> (char-ci<? #\a #\[)
#t

Re: string-ci* oddity

[Thien-Thi Nguyen]

() "Bill Schottstaedt" <bil@ccrma.Stanford.EDU>
() Fri, 19 Dec 2008 06:55:21 -0800

   Why do both Guile and Gauche give this result in string-ci<?
   (and the other string-ci functions similarly):

   The odd chars are ASCII 91 to 96:

ASCII 91-96 lie between the two ranges A-Z and a-z.
One procedure smashes case up and the other down.
Smashing happens unconditionally.

(define (my-char-ci<? p q)
  (< (down p)) (down q))

Another more complicated (but arguably more correct) approach
would be to determine if one/both of the args are not smashable,
and entirely avoid smashing in that case.  Something like:

(define (smashable? c)
  (or (<= #\a c #\z) (<= #\A c #\Z)))

(define (my-char-ci<? p q)
  (if (and (smashable? p) (smashable? q))
      (< (down p) (down q))
      (< p q)))

Pseudoscheme (numeric operators don't actually take chars),
but you get the idea.

thi

Re: string-ci* oddity

[Thien-Thi Nguyen]

FYI, below is the code that all ci comparison
funcs will be using in the next Guile 1.4.x release.

This means, for example:
(char-ci<? #\a #\_) => #f.

thi


___________________________________________________________________
// libguile/chars.c

#define ISLOWER(c)  (islower (c) ? (1 + c - 'a') : 0)
#define ISUPPER(c)  (isupper (c) ? (1 + c - 'A') : 0)

static int
ccmp_ci (int x, int y)
{
  int lx, ux = 0, ly, uy = 0, rv;

  rv = ((! ((lx = ISLOWER (x)) || (ux = ISUPPER (x))))
        ||
        (! ((ly = ISLOWER (y)) || (uy = ISUPPER (y)))))
    /* One or both do not satisfy `isalpha'; subtract directly.  */
    ? (x - y)
    /* Both satisfy `isalpha'; subtract in one domain or another.  */
    : (lx
       ? (lx - (ly
                ? ly
                : uy))
       : (ux - (uy
                ? uy
                : ly)));
  return !rv
    ? 0
    : (GOOD (rv)
       ?  1
       : -1);
}