use radix literals

[factor.git] / core / io / encodings / utf8 / utf8.factor

diff --git a/core/io/encodings/utf8/utf8.factor b/core/io/encodings/utf8/utf8.factor
index c78a86c072703a3815aa9dea10eeff6ac7813fac..c01ee89e9eb65b5369b85fb6b95223a003aa7ec8 100644 (file)
--- a/core/io/encodings/utf8/utf8.factor
+++ b/core/io/encodings/utf8/utf8.factor
@@ -12,30 +12,41 @@ SINGLETON: utf8
 <PRIVATE 
 
 : starts-2? ( char -- ? )
-    dup [ -6 shift BIN: 10 number= ] when ; inline
+    dup [ -6 shift 0b10 number= ] when ; inline
 
 : append-nums ( stream byte -- stream char )
     over stream-read1 dup starts-2?
-    [ swap 6 shift swap BIN: 111111 bitand bitor ]
+    [ [ 6 shift ] dip 0b111111 bitand bitor ]
     [ 2drop replacement-char ] if ; inline
 
+: minimum-code-point ( char minimum -- char )
+    over > [ drop replacement-char ] when ; inline
+
+: maximum-code-point ( char maximum -- char )
+    over < [ drop replacement-char ] when ; inline
+
 : double ( stream byte -- stream char )
-    BIN: 11111 bitand append-nums ; inline
+    0b11111 bitand append-nums
+    0x80 minimum-code-point ; inline
 
 : triple ( stream byte -- stream char )
-    BIN: 1111 bitand append-nums append-nums ; inline
+    0b1111 bitand append-nums append-nums
+    0x800 minimum-code-point ; inline
 
 : quadruple ( stream byte -- stream char )
-    BIN: 111 bitand append-nums append-nums append-nums ; inline
+    0b111 bitand append-nums append-nums append-nums
+    0x10000 minimum-code-point
+    0x10FFFF maximum-code-point ; inline
 
 : begin-utf8 ( stream byte -- stream char )
-    {
-        { [ dup -7 shift zero? ] [ ] }
-        { [ dup -5 shift BIN: 110 = ] [ double ] }
-        { [ dup -4 shift BIN: 1110 = ] [ triple ] }
-        { [ dup -3 shift BIN: 11110 = ] [ quadruple ] }
-        [ drop replacement-char ]
-    } cond ; inline
+    dup 127 > [
+        {
+            { [ dup -5 shift 0b110 = ] [ double ] }
+            { [ dup -4 shift 0b1110 = ] [ triple ] }
+            { [ dup -3 shift 0b11110 = ] [ quadruple ] }
+            [ drop replacement-char ]
+        } cond
+    ] when ; inline
 
 : decode-utf8 ( stream -- char/f )
     dup stream-read1 dup [ begin-utf8 ] when nip ; inline
@@ -46,27 +57,28 @@ M: utf8 decode-char
 ! Encoding UTF-8
 
 : encoded ( stream char -- )
-    BIN: 111111 bitand BIN: 10000000 bitor swap stream-write1 ; inline
+    0b111111 bitand 0b10000000 bitor swap stream-write1 ; inline
 
 : char>utf8 ( char stream -- )
-    swap {
-        { [ dup -7 shift zero? ] [ swap stream-write1 ] }
-        { [ dup -11 shift zero? ] [
-            2dup -6 shift BIN: 11000000 bitor swap stream-write1
-            encoded
-        ] }
-        { [ dup -16 shift zero? ] [
-            2dup -12 shift BIN: 11100000 bitor swap stream-write1
-            2dup -6 shift encoded
-            encoded
-        ] }
-        [
-            2dup -18 shift BIN: 11110000 bitor swap stream-write1
-            2dup -12 shift encoded
-            2dup -6 shift encoded
-            encoded
-        ]
-    } cond ; inline
+    over 127 <= [ stream-write1 ] [
+        swap {
+            { [ dup -11 shift zero? ] [
+                2dup -6 shift 0b11000000 bitor swap stream-write1
+                encoded
+            ] }
+            { [ dup -16 shift zero? ] [
+                2dup -12 shift 0b11100000 bitor swap stream-write1
+                2dup -6 shift encoded
+                encoded
+            ] }
+            [
+                2dup -18 shift 0b11110000 bitor swap stream-write1
+                2dup -12 shift encoded
+                2dup -6 shift encoded
+                encoded
+            ]
+        } cond
+    ] if ; inline
 
 M: utf8 encode-char
     drop char>utf8 ;