--- JSON-XS/XS.xs	2008/03/19 04:08:22	1.72
+++ JSON-XS/XS.xs	2008/03/19 15:37:54	1.75
@@ -6,6 +6,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <limits.h>
 #include <float.h>
 
 #if defined(__BORLANDC__) || defined(_MSC_VER)
@@ -18,6 +19,8 @@
 # define UTF8_MAXBYTES 13
 #endif
 
+#define IVUV_MAXCHARS (sizeof (UV) * CHAR_BIT * 28 / 93 + 2)
+
 #define F_ASCII          0x00000001UL
 #define F_LATIN1         0x00000002UL
 #define F_UTF8           0x00000004UL
@@ -125,13 +128,20 @@
 INLINE unsigned char *
 encode_utf8 (unsigned char *s, UV ch)
 {
-  if (ch <= 0x7FF)
-    {
-      *s++ = (ch >>   6) | 0xc0;
-      *s++ = (ch & 0x3f) | 0x80;
-    }
-  else
-    s = uvuni_to_utf8_flags (s, ch, 0);
+  if      (expect_false (ch < 0x000080))
+    *s++ = ch;
+  else if (expect_true  (ch < 0x000800))
+    *s++ = 0xc0 | ( ch >>  6),
+    *s++ = 0x80 | ( ch        & 0x3f);
+  else if (              ch < 0x010000)
+    *s++ = 0xe0 | ( ch >> 12),
+    *s++ = 0x80 | ((ch >>  6) & 0x3f),
+    *s++ = 0x80 | ( ch        & 0x3f);
+  else if (              ch < 0x110000)
+    *s++ = 0xf0 | ( ch >> 18),
+    *s++ = 0x80 | ((ch >> 12) & 0x3f),
+    *s++ = 0x80 | ((ch >>  6) & 0x3f),
+    *s++ = 0x80 | ( ch        & 0x3f);
 
   return s;
 }
@@ -229,9 +239,9 @@
 
                   if (uch < 0x80/*0x20*/ || uch >= enc->limit)
                     {
-                      if (uch > 0xFFFFUL)
+                      if (uch >= 0x10000UL)
                         {
-                          if (uch > 0x10FFFFUL)
+                          if (uch >= 0x110000UL)
                             croak ("out of range codepoint (0x%lx) encountered, unrepresentable in JSON", (unsigned long)uch);
 
                           need (enc, len += 11);
@@ -640,21 +650,16 @@
     }
   else if (SvIOKp (sv))
     {
-      // we assume we can always read an IV as a UV
-      if (SvUV (sv) & ~(UV)0x7fff)
-        {
-          // large integer, use the (rather slow) snprintf way.
-          need (enc, sizeof (UV) * 3);
-          enc->cur += 
-             SvIsUV(sv)
-                ? snprintf (enc->cur, sizeof (UV) * 3, "%"UVuf, (UV)SvUVX (sv))
-                : snprintf (enc->cur, sizeof (UV) * 3, "%"IVdf, (IV)SvIVX (sv));
-        }
-      else
+      // we assume we can always read an IV as a UV and vice versa
+      // we assume two's complement
+      // we assume no aliasing issues in the union
+      if (SvIsUV (sv) ? SvUVX (sv) <= 59000
+                      : SvIVX (sv) <= 59000 && SvIVX (sv) >= -59000)
         {
           // optimise the "small number case"
           // code will likely be branchless and use only a single multiplication
-          I32 i = SvIV (sv);
+          // works for numbers up to 59074
+          I32 i = SvIVX (sv);
           U32 u;
           char digit, nz = 0;
 
@@ -670,13 +675,22 @@
           // and multiplying by 5 while moving the decimal point one to the right,
           // resulting in a net multiplication by 10.
           // we always write the digit to memory but conditionally increment
-          // the pointer, to ease the usage of conditional move instructions.
-          digit = u >> 28; *enc->cur = digit + '0'; enc->cur += (nz = nz || digit); u = (u & 0xfffffff) * 5;
-          digit = u >> 27; *enc->cur = digit + '0'; enc->cur += (nz = nz || digit); u = (u & 0x7ffffff) * 5;
-          digit = u >> 26; *enc->cur = digit + '0'; enc->cur += (nz = nz || digit); u = (u & 0x3ffffff) * 5;
-          digit = u >> 25; *enc->cur = digit + '0'; enc->cur += (nz = nz || digit); u = (u & 0x1ffffff) * 5;
+          // the pointer, to enable the use of conditional move instructions.
+          digit = u >> 28; *enc->cur = digit + '0'; enc->cur += (nz = nz || digit); u = (u & 0xfffffffUL) * 5;
+          digit = u >> 27; *enc->cur = digit + '0'; enc->cur += (nz = nz || digit); u = (u & 0x7ffffffUL) * 5;
+          digit = u >> 26; *enc->cur = digit + '0'; enc->cur += (nz = nz || digit); u = (u & 0x3ffffffUL) * 5;
+          digit = u >> 25; *enc->cur = digit + '0'; enc->cur += (nz = nz || digit); u = (u & 0x1ffffffUL) * 5;
           digit = u >> 24; *enc->cur = digit + '0'; enc->cur += 1; // correctly generate '0'
         }
+      else
+        {
+          // large integer, use the (rather slow) snprintf way.
+          need (enc, IVUV_MAXCHARS);
+          enc->cur += 
+             SvIsUV(sv)
+                ? snprintf (enc->cur, IVUV_MAXCHARS, "%"UVuf, (UV)SvUVX (sv))
+                : snprintf (enc->cur, IVUV_MAXCHARS, "%"IVdf, (IV)SvIVX (sv));
+        }
     }
   else if (SvROK (sv))
     encode_rv (enc, SvRV (sv));
@@ -703,7 +717,7 @@
   enc.maxdepth  = DEC_DEPTH (enc.json.flags);
   enc.limit     = enc.json.flags & F_ASCII  ? 0x000080UL
                 : enc.json.flags & F_LATIN1 ? 0x000100UL
-                                            : 0x10FFFFUL;
+                                            : 0x110000UL;
 
   SvPOK_only (enc.sv);
   encode_sv (&enc, scalar);
@@ -891,7 +905,7 @@
                     ERR ("illegal backslash escape sequence in string");
                 }
             }
-          else if (expect_true (ch >= 0x20 && ch <= 0x7f))
+          else if (expect_true (ch >= 0x20 && ch < 0x80))
             *cur++ = ch;
           else if (ch >= 0x80)
             {
@@ -1300,12 +1314,12 @@
 decode_sv (dec_t *dec)
 {
   // the beauty of JSON: you need exactly one character lookahead
-  // to parse anything.
+  // to parse everything.
   switch (*dec->cur)
     {
       case '"': ++dec->cur; return decode_str (dec); 
-      case '[': ++dec->cur; return decode_av (dec); 
-      case '{': ++dec->cur; return decode_hv (dec);
+      case '[': ++dec->cur; return decode_av  (dec); 
+      case '{': ++dec->cur; return decode_hv  (dec);
 
       case '-':
       case '0': case '1': case '2': case '3': case '4':