shithub: sl

Info  •  Files  •  Log  •  Branches

rename char-* and str-char to rune-* and str-rune to avoid confusion with C definition of 'char' vs 'rune'

--- a/boot/sl.boot

+++ b/boot/sl.boot

@@ -128,9 +128,9 @@

 xnum?  #.atom? atom?  #.= =  #.num? num?  #.* *)))

             caaaar #fn("n10<<<<:" #() caaaar) caaadr

             #fn("n10T<<:" #() caaadr) caaar #fn("n10<<<:" #() caaar) caadar

-10=T<:" #() caaddr) caadr

-            #fn("n10T<:" #() caadr) caar #fn("n10<<:" #() caar) cadaar

-            #fn("n10<<T:" #() cadaar) cadadr #fn("n10TT:" #() cadadr) cadar

+10=T<:" #() caaddr) caadr

+            #fn("n10T<:" #() caadr) caar #fn("n10<<:" #() caar) cadaar

+            #fn("n10<<T:" #() cadaar) cadadr #fn("n10TT:" #() cadadr) cadar

 #fn("n10=T:" #() caddr) call-with-values

             #fn("n205086B3@0A86<C90186=}2:18661:" #() #(#3=(*values*))) capture-var! #fn("n20r3G70186E5387;JG042186510r322861e152p4:" #(index-of

   #fn(length) #fn(nconc)) capture-var!)

@@ -393,7 +393,9 @@

 h)) ref-s16-LE)

             ref-s32-LE #fn("n2202101EMGE522101KMGr8522101r2MGr@522101r3MGrH52g461:" #(#fn(s32)

                                                                                       #fn(ash)) ref-s32-LE)

-11q5386;3F042286052;3:042386062:" #(#fn(get) *properties* #fn(has?)

+11q5386;3F042286052;3:042386062:" #(#fn(get) *properties* #fn(has?)

+                                                                  #fn(del!)) remprop)

+            repl #fn("n0IIb4b5208421_5142085228485>2_51485<5047360:" #(#0#

 )

             repl #fn("n0IIb4b5208421_5142085228485>2_51485<5047360:" #(#0#

                                                                        #fn("n07050421725142324{257651S;3Z04778451788551360q@=079855147:5047;85w<61:" #(*prompt*

@@ -406,7 +408,7 @@

 " #(reverse-) reverse) reverse! #fn("n170q062:" #(reverse!-) reverse!)

             reverse!- #fn("n2I1B3B041=101?04N4?1@\x1d/40:" #() reverse!-) reverse-

             #fn("n21J400:701<0P1=62:" #(reverse-) reverse-) self-evaluating? #fn("n120051S;3Z040H;36040RS;JK0421051;3A040R;3:04022051Q:" #(#fn(gensym?)

-n(gensym?)

+n(gensym?)

             set-syntax! #fn("n220710163:" #(#fn(put!)

                                             *syntax-environment*) set-syntax!)

@@ -413,8 +415,8 @@

  unquote length>) splice-form?)

             str-join #fn("n20J5020:215022860<5242324861>20=524258661:" #("" #fn(buffer)

                                                                          #fn(io-write)

-                                                #fn("n120AF52420A062:" #(#fn(io-write)))

-                                                                         #fn(io->str)) str-join)

+                                                #fn("n120AF52420A062:" #(#fn(io-write)))

+                                                                         #fn(io->str)) str-join)

 r-lpad #fn("n3207182122051~52062:" #(#fn(str) str-rep #fn(str-length)) str-lpad)

             str-map #fn("n2205021151EI8887L23O0422860231885251524748851?8@\f/^14758661:" #(#fn(buffer)

   #fn(str-length) #fn(io-putc) #fn(str-char) 1+ ios->str) str-map)

--- a/src/str.c

+++ b/src/str.c

@@ -231,7 +231,7 @@

 	return ns;

 }

-BUILTIN("str-char", str_char)

+BUILTIN("str-rune", str_rune)

 {

 	argcount(nargs, 2);

 	char *s = tostr(args[0]);

@@ -246,7 +246,7 @@

 	return mk_rune(r);

 }

-BUILTIN("char-upcase", char_upcase)

+BUILTIN("rune-upcase", rune_upcase)

 {

 	argcount(nargs, 1);

 	sl_cprim *cp = ptr(args[0]);

@@ -255,7 +255,7 @@

 	return mk_rune(toupperrune(*(Rune*)cp_data(cp)));

 }

-BUILTIN("char-downcase", char_downcase)

+BUILTIN("rune-downcase", rune_downcase)

 {

 	argcount(nargs, 1);

 	sl_cprim *cp = ptr(args[0]);

@@ -264,7 +264,7 @@

 	return mk_rune(tolowerrune(*(Rune*)cp_data(cp)));

 }

-BUILTIN("char-titlecase", char_titlecase)

+BUILTIN("rune-titlecase", rune_titlecase)

 {

 	argcount(nargs, 1);

 	sl_cprim *cp = ptr(args[0]);

@@ -274,7 +274,7 @@

 }

 sl_purefn

-BUILTIN("char-alphabetic?", char_alphabeticp)

+BUILTIN("rune-alphabetic?", rune_alphabeticp)

 {

 	argcount(nargs, 1);

 	sl_cprim *cp = ptr(args[0]);

@@ -284,7 +284,7 @@

 }

 sl_purefn

-BUILTIN("char-lower-case?", char_lower_casep)

+BUILTIN("rune-lower-case?", rune_lower_casep)

 {

 	argcount(nargs, 1);

 	sl_cprim *cp = ptr(args[0]);

@@ -294,7 +294,7 @@

 }

 sl_purefn

-BUILTIN("char-upper-case?", char_upper_casep)

+BUILTIN("rune-upper-case?", rune_upper_casep)

 {

 	argcount(nargs, 1);

 	sl_cprim *cp = ptr(args[0]);

@@ -304,7 +304,7 @@

 }

 sl_purefn

-BUILTIN("char-title-case?", char_title_casep)

+BUILTIN("rune-title-case?", rune_title_casep)

 {

 	argcount(nargs, 1);

 	sl_cprim *cp = ptr(args[0]);

@@ -314,7 +314,7 @@

 }

 sl_purefn

-BUILTIN("char-numeric?", char_numericp)

+BUILTIN("rune-numeric?", rune_numericp)

 {

 	argcount(nargs, 1);

 	sl_cprim *cp = ptr(args[0]);

@@ -324,7 +324,7 @@

 }

 sl_purefn

-BUILTIN("char-whitespace?", char_whitespacep)

+BUILTIN("rune-whitespace?", rune_whitespacep)

 {

 	argcount(nargs, 1);

 	sl_cprim *cp = ptr(args[0]);

--- a/src/system.lsp

+++ b/src/system.lsp

@@ -312,7 +312,7 @@

              xs)

       x0))

-(def (char? x)

+(def (rune? x)

   (eq? (typeof x) 'rune))

 (def (arr? x)

@@ -869,13 +869,13 @@

   (str-sub s n))

 (def (str-trim s at-start at-end)

-  (def (trim-start s chars i L)

-    (if (and (< i L) (str-find chars (str-char s i)))

-        (trim-start s chars (1+ i) L)

+  (def (trim-start s runes i L)

+    (if (and (< i L) (str-find runes (str-rune s i)))

+        (trim-start s runes (1+ i) L)

         i))

-  (def (trim-end s chars i)

-    (if (and (> i 0) (str-find chars (str-char s (1- i))))

-        (trim-end s chars (1- i))

+  (def (trim-end s runes i)

+    (if (and (> i 0) (str-find runes (str-rune s (1- i))))

+        (trim-end s runes (1- i))

         i))

   (let ((L (str-length s)))

     (str-sub s

@@ -887,7 +887,7 @@

         (n (str-length s)))

     (let ((i 0))

       (while (< i n)

-         (io-putc b (f (str-char s i)))

+         (io-putc b (f (str-rune s i)))

          (set! i (1+ i))))

     (ios->str b)))

--- a/test/unittest.lsp

+++ b/test/unittest.lsp

@@ -558,53 +558,53 @@

 (assert (equal? (list s2) (str-split s2 "X" :trim T)))

 (assert (equal? (list s2) (str-split s2 "X")))

-(assert (equal? #\а (str-char s 10)))

-(assert (equal? #\nul (str-char s 6)))

-(assert-fail (str-char s 11))

+(assert (equal? #\а (str-rune s 10)))

+(assert (equal? #\nul (str-rune s 6)))

+(assert-fail (str-rune s 11))

-(assert (equal? #\W (char-upcase #\w)))

-(assert (equal? #\П (char-upcase #\п)))

-(assert (equal? #\nul (char-upcase #\nul)))

+(assert (equal? #\W (rune-upcase #\w)))

+(assert (equal? #\П (rune-upcase #\п)))

+(assert (equal? #\nul (rune-upcase #\nul)))

-(assert (char-upper-case? #\W))

-(assert (char-upper-case? #\П))

-(assert (not (char-upper-case? #\nul)))

-(assert (not (char-upper-case? #\w)))

-(assert (not (char-upper-case? #\п)))

-(assert (not (char-upper-case? #\nul)))

+(assert (rune-upper-case? #\W))

+(assert (rune-upper-case? #\П))

+(assert (not (rune-upper-case? #\nul)))

+(assert (not (rune-upper-case? #\w)))

+(assert (not (rune-upper-case? #\п)))

+(assert (not (rune-upper-case? #\nul)))

-(assert (equal? #\w (char-downcase #\W)))

-(assert (equal? #\п (char-downcase #\П)))

-(assert (equal? #\nul (char-downcase #\nul)))

+(assert (equal? #\w (rune-downcase #\W)))

+(assert (equal? #\п (rune-downcase #\П)))

+(assert (equal? #\nul (rune-downcase #\nul)))

-(assert (char-lower-case? #\w))

-(assert (char-lower-case? #\п))

-(assert (not (char-lower-case? #\nul)))

-(assert (not (char-lower-case? #\W)))

-(assert (not (char-lower-case? #\П)))

-(assert (not (char-lower-case? #\nul)))

+(assert (rune-lower-case? #\w))

+(assert (rune-lower-case? #\п))

+(assert (not (rune-lower-case? #\nul)))

+(assert (not (rune-lower-case? #\W)))

+(assert (not (rune-lower-case? #\П)))

+(assert (not (rune-lower-case? #\nul)))

-(assert (char-numeric? #\0))

-(assert (char-numeric? #\9))

-(assert (not (char-numeric? #\⁰)))

-(assert (not (char-numeric? #\q)))

+(assert (rune-numeric? #\0))

+(assert (rune-numeric? #\9))

+(assert (not (rune-numeric? #\⁰)))

+(assert (not (rune-numeric? #\q)))

-(assert (char-whitespace? #\space))

-(assert (char-whitespace? #\tab))

-(assert (char-whitespace? #\vtab))

-(assert (char-whitespace? #\newline))

-(assert (char-whitespace? #\x00a0))

-(assert (char-whitespace? #\x3000))

-(assert (not (char-whitespace? #\x200b)))

+(assert (rune-whitespace? #\space))

+(assert (rune-whitespace? #\tab))

+(assert (rune-whitespace? #\vtab))

+(assert (rune-whitespace? #\newline))

+(assert (rune-whitespace? #\x00a0))

+(assert (rune-whitespace? #\x3000))

+(assert (not (rune-whitespace? #\x200b)))

-(assert (char-alphabetic? #\q))

-(assert (char-alphabetic? #\й))

-(assert (not (char-alphabetic? #\⁰)))

-(assert (not (char-alphabetic? #\0)))

+(assert (rune-alphabetic? #\q))

+(assert (rune-alphabetic? #\й))

+(assert (not (rune-alphabetic? #\⁰)))

+(assert (not (rune-alphabetic? #\0)))

-(assert (not (char-title-case? #\DŽ)))

-(assert (equal? #\Dž (char-titlecase #\DŽ)))

-(assert (char-title-case? #\Dž))

+(assert (not (rune-title-case? #\DŽ)))

+(assert (equal? #\Dž (rune-titlecase #\DŽ)))

+(assert (rune-title-case? #\Dž))

 (def s "hello й goodbye")

 (assert (= 6 (str-find s #\й)))