--- JSON-XS/XS.xs	2007/04/06 21:17:09	1.26
+++ JSON-XS/XS.xs	2007/06/06 14:52:49	1.35
@@ -12,13 +12,14 @@
 #endif
 
 #define F_ASCII        0x00000001UL
-#define F_UTF8         0x00000002UL
-#define F_INDENT       0x00000004UL
-#define F_CANONICAL    0x00000008UL
-#define F_SPACE_BEFORE 0x00000010UL
-#define F_SPACE_AFTER  0x00000020UL
-#define F_ALLOW_NONREF 0x00000080UL
-#define F_SHRINK       0x00000100UL
+#define F_LATIN1       0x00000002UL
+#define F_UTF8         0x00000004UL
+#define F_INDENT       0x00000008UL
+#define F_CANONICAL    0x00000010UL
+#define F_SPACE_BEFORE 0x00000020UL
+#define F_SPACE_AFTER  0x00000040UL
+#define F_ALLOW_NONREF 0x00000100UL
+#define F_SHRINK       0x00000200UL
 #define F_MAXDEPTH     0xf8000000UL
 #define S_MAXDEPTH     27
 
@@ -33,12 +34,22 @@
 #define INIT_SIZE   32 // initial scalar size to be allocated
 #define INDENT_STEP 3  // spaces per indentation level
 
-#define UTF8_MAX_LEN      11 // for perls UTF-X: max. number of octets per character
 #define SHORT_STRING_LEN 512 // special-case strings of up to this size
 
 #define SB do {
 #define SE } while (0)
 
+#if __GNUC__ >= 3
+# define expect(expr,value)         __builtin_expect ((expr),(value))
+# define inline                     inline
+#else
+# define expect(expr,value)         (expr)
+# define inline                     static
+#endif
+
+#define expect_false(expr) expect ((expr) != 0, 0)
+#define expect_true(expr)  expect ((expr) != 0, 1)
+
 static HV *json_stash; // JSON::XS::
 
 /////////////////////////////////////////////////////////////////////////////
@@ -72,10 +83,10 @@
 // we special-case "safe" characters from U+80 .. U+7FF,
 // but use the very good perl function to parse anything else.
 // note that we never call this function for a ascii codepoints
-static UV
+inline UV
 decode_utf8 (unsigned char *s, STRLEN len, STRLEN *clen)
 {
-  if (s[0] > 0xdf || s[0] < 0xc2)
+  if (expect_false (s[0] > 0xdf || s[0] < 0xc2))
     return utf8n_to_uvuni (s, len, clen, UTF8_CHECK_ONLY);
   else if (len > 1 && s[1] >= 0x80 && s[1] <= 0xbf)
     {
@@ -103,19 +114,19 @@
   U32 maxdepth; // max. indentation/recursion level
 } enc_t;
 
-static void
+inline void
 need (enc_t *enc, STRLEN len)
 {
-  if (enc->cur + len >= enc->end)
+  if (expect_false (enc->cur + len >= enc->end))
     {
       STRLEN cur = enc->cur - SvPVX (enc->sv);
       SvGROW (enc->sv, cur + len + 1);
       enc->cur = SvPVX (enc->sv) + cur;
-      enc->end = SvPVX (enc->sv) + SvLEN (enc->sv);
+      enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;
     }
 }
 
-static void
+inline void
 encode_ch (enc_t *enc, char ch)
 {
   need (enc, 1);
@@ -133,15 +144,15 @@
     {
       unsigned char ch = *(unsigned char *)str;
 
-      if (ch >= 0x20 && ch < 0x80) // most common case
+      if (expect_true (ch >= 0x20 && ch < 0x80)) // most common case
         {
-          if (ch == '"') // but with slow exceptions
+          if (expect_false (ch == '"')) // but with slow exceptions
             {
               need (enc, len += 1);
               *enc->cur++ = '\\';
               *enc->cur++ = '"';
             }
-          else if (ch == '\\')
+          else if (expect_false (ch == '\\'))
             {
               need (enc, len += 1);
               *enc->cur++ = '\\';
@@ -183,7 +194,7 @@
                   if (uch > 0x10FFFFUL)
                     croak ("out of range codepoint (0x%lx) encountered, unrepresentable in JSON", (unsigned long)uch);
 
-                  if (uch < 0x80 || enc->flags & F_ASCII)
+                  if (uch < 0x80 || enc->flags & F_ASCII || (enc->flags & F_LATIN1 && uch > 0xFF))
                     {
                       if (uch > 0xFFFFUL)
                         {
@@ -207,6 +218,11 @@
 
                       str += clen;
                     }
+                  else if (enc->flags & F_LATIN1)
+                    {
+                      *enc->cur++ = uch;
+                      str += clen;
+                    }
                   else if (is_utf8)
                     {
                       need (enc, len += clen);
@@ -218,7 +234,7 @@
                     }
                   else
                     {
-                      need (enc, len += UTF8_MAX_LEN - 1); // never more than 11 bytes needed
+                      need (enc, len += UTF8_MAXBYTES - 1); // never more than 11 bytes needed
                       enc->cur = uvuni_to_utf8_flags (enc->cur, uch, 0);
                       ++str;
                     }
@@ -230,7 +246,7 @@
     }
 }
 
-static void
+inline void
 encode_indent (enc_t *enc)
 {
   if (enc->flags & F_INDENT)
@@ -243,14 +259,14 @@
     }
 }
 
-static void
+inline void
 encode_space (enc_t *enc)
 {
   need (enc, 1);
   encode_ch (enc, ' ');
 }
 
-static void
+inline void
 encode_nl (enc_t *enc)
 {
   if (enc->flags & F_INDENT)
@@ -260,7 +276,7 @@
     }
 }
 
-static void
+inline void
 encode_comma (enc_t *enc)
 {
   encode_ch (enc, ',');
@@ -369,8 +385,13 @@
       // that randomises hash orderings
       if (enc->flags & F_CANONICAL)
         {
-          HE *he, *hes [count]; // if your compiler dies here, you need to enable C99 mode
           int fast = 1;
+          HE *he;
+#if defined(__BORLANDC__) || defined(_MSC_VER)
+          HE **hes = _alloca (count * sizeof (HE));
+#else
+          HE *hes [count]; // if your compiler dies here, you need to enable C99 mode
+#endif
 
           i = 0;
           while ((he = hv_iternext (hv)))
@@ -484,11 +505,38 @@
     }
   else if (SvIOKp (sv))
     {
-      need (enc, 64);
-      enc->cur += 
-         SvIsUV(sv)
-            ? snprintf (enc->cur, 64, "%"UVuf, (UV)SvUVX (sv))
-            : snprintf (enc->cur, 64, "%"IVdf, (IV)SvIVX (sv));
+      // we assume we can always read an IV as a UV
+      if (SvUV (sv) & ~(UV)0x7fff)
+        {
+          need (enc, 32);
+          enc->cur += 
+             SvIsUV(sv)
+                ? snprintf (enc->cur, 32, "%"UVuf, (UV)SvUVX (sv))
+                : snprintf (enc->cur, 32, "%"IVdf, (IV)SvIVX (sv));
+        }
+      else
+        {
+          // optimise the "small number case"
+          // code will likely be branchless and use only a single multiplication
+          I32 i = SvIV (sv);
+          U32 u;
+
+          need (enc, 6);
+
+          *enc->cur = '-'; enc->cur += i < 0 ? 1 : 0;
+          u = i < 0 ? -i : i;
+
+          // convert to 4.28 fixed-point representation
+          u = u * ((0xfffffff + 10000) / 10000); // 10**5, 5 fractional digits
+
+          char digit, nz = 0;
+
+          digit = u >> 28; *enc->cur = digit + '0'; nz |= digit; enc->cur += nz ? 1 : 0; u = (u & 0xfffffff) * 5;
+          digit = u >> 27; *enc->cur = digit + '0'; nz |= digit; enc->cur += nz ? 1 : 0; u = (u & 0x7ffffff) * 5;
+          digit = u >> 26; *enc->cur = digit + '0'; nz |= digit; enc->cur += nz ? 1 : 0; u = (u & 0x3ffffff) * 5;
+          digit = u >> 25; *enc->cur = digit + '0'; nz |= digit; enc->cur += nz ? 1 : 0; u = (u & 0x1ffffff) * 5;
+          digit = u >> 24; *enc->cur = digit + '0'; nz |= digit; enc->cur += 1;
+        }
     }
   else if (SvROK (sv))
     encode_rv (enc, SvRV (sv));
@@ -517,10 +565,11 @@
   SvPOK_only (enc.sv);
   encode_sv (&enc, scalar);
 
-  if (!(flags & (F_ASCII | F_UTF8)))
-    SvUTF8_on (enc.sv);
-
   SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv));
+  *SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings
+
+  if (!(flags & (F_ASCII | F_LATIN1 | F_UTF8)))
+    SvUTF8_on (enc.sv);
 
   if (enc.flags & F_SHRINK)
     shrink (enc.sv);
@@ -542,7 +591,7 @@
   U32 maxdepth; // recursion depth limit
 } dec_t;
 
-static void
+inline void
 decode_ws (dec_t *dec)
 {
   for (;;)
@@ -578,10 +627,10 @@
   signed char d1, d2, d3, d4;
   unsigned char *cur = (unsigned char *)dec->cur;
 
-  d1 = decode_hexdigit [cur [0]]; if (d1 < 0) ERR ("four hexadecimal digits expected");
-  d2 = decode_hexdigit [cur [1]]; if (d2 < 0) ERR ("four hexadecimal digits expected");
-  d3 = decode_hexdigit [cur [2]]; if (d3 < 0) ERR ("four hexadecimal digits expected");
-  d4 = decode_hexdigit [cur [3]]; if (d4 < 0) ERR ("four hexadecimal digits expected");
+  d1 = decode_hexdigit [cur [0]]; if (expect_false (d1 < 0)) ERR ("four hexadecimal digits expected");
+  d2 = decode_hexdigit [cur [1]]; if (expect_false (d2 < 0)) ERR ("four hexadecimal digits expected");
+  d3 = decode_hexdigit [cur [2]]; if (expect_false (d3 < 0)) ERR ("four hexadecimal digits expected");
+  d4 = decode_hexdigit [cur [3]]; if (expect_false (d4 < 0)) ERR ("four hexadecimal digits expected");
 
   dec->cur += 4;
 
@@ -602,19 +651,19 @@
 
   do
     {
-      char buf [SHORT_STRING_LEN + UTF8_MAX_LEN];
+      char buf [SHORT_STRING_LEN + UTF8_MAXBYTES];
       char *cur = buf;
 
       do
         {
           unsigned char ch = *(unsigned char *)dec->cur++;
 
-          if (ch == '"')
+          if (expect_false (ch == '"'))
             {
               --dec->cur;
               break;
             }
-          else if (ch == '\\')
+          else if (expect_false (ch == '\\'))
             {
               switch (*dec->cur)
                 {
@@ -674,7 +723,7 @@
                     ERR ("illegal backslash escape sequence in string");
                 }
             }
-          else if (ch >= 0x20 && ch <= 0x7f)
+          else if (expect_true (ch >= 0x20 && ch <= 0x7f))
             *cur++ = ch;
           else if (ch >= 0x80)
             {
@@ -803,16 +852,36 @@
 
   if (!is_nv)
     {
-      UV uv;
-      int numtype = grok_number (start, dec->cur - start, &uv);
-      if (numtype & IS_NUMBER_IN_UV)
-        if (numtype & IS_NUMBER_NEG)
+      // special case the rather common 1..4-digit-int case, assumes 32 bit ints or so
+      if (*start == '-')
+        switch (dec->cur - start)
           {
-            if (uv < (UV)IV_MIN)
-              return newSViv (-(IV)uv);
+            case 2: return newSViv (-(                                                      start [1] - '0'       ));
+            case 3: return newSViv (-(                                     start [1] * 10 + start [2] - '0' *   11));
+            case 4: return newSViv (-(                   start [1] * 100 + start [2] * 10 + start [3] - '0' *  111));
+            case 5: return newSViv (-(start [1] * 1000 + start [2] * 100 + start [3] * 10 + start [4] - '0' * 1111));
           }
-        else
-          return newSVuv (uv);
+      else
+        switch (dec->cur - start)
+          {
+            case 1: return newSViv (                                                        start [0] - '0'       );
+            case 2: return newSViv (                                       start [0] * 10 + start [1] - '0' *   11);
+            case 3: return newSViv (                     start [0] * 100 + start [1] * 10 + start [2] - '0' *  111);
+            case 4: return newSViv (  start [0] * 1000 + start [1] * 100 + start [2] * 10 + start [3] - '0' * 1111);
+          }
+
+      {
+        UV uv;
+        int numtype = grok_number (start, dec->cur - start, &uv);
+        if (numtype & IS_NUMBER_IN_UV)
+          if (numtype & IS_NUMBER_NEG)
+            {
+              if (uv < (UV)IV_MIN)
+                return newSViv (-(IV)uv);
+            }
+          else
+            return newSVuv (uv);
+      }
     }
 
   return newSVnv (Atof (start));
@@ -979,11 +1048,13 @@
 }
 
 static SV *
-decode_json (SV *string, U32 flags)
+decode_json (SV *string, U32 flags, UV *offset_return)
 {
   dec_t dec;
+  UV offset;
   SV *sv;
 
+  SvGETMAGIC (string);
   SvUPGRADE (string, SVt_PV);
 
   if (flags & F_UTF8)
@@ -1000,14 +1071,34 @@
   dec.depth    = 0;
   dec.maxdepth = DEC_DEPTH (dec.flags);
 
-  *dec.end = 0; // this should basically be a nop, too, but make sure its there
+  *dec.end = 0; // this should basically be a nop, too, but make sure it's there
   sv = decode_sv (&dec);
 
+  if (!(offset_return || !sv))
+    {
+      // check for trailing garbage
+      decode_ws (&dec);
+
+      if (*dec.cur)
+        {
+          dec.err = "garbage after JSON object";
+          SvREFCNT_dec (sv);
+          sv = 0;
+        }
+    }
+
+  if (offset_return || !sv)
+    {
+      offset = dec.flags & F_UTF8
+               ? dec.cur - SvPVX (string)
+               : utf8_distance (dec.cur, SvPVX (string));
+
+      if (offset_return)
+        *offset_return = offset;
+    }
+
   if (!sv)
     {
-      IV offset = dec.flags & F_UTF8
-                  ? dec.cur - SvPVX (string)
-                  : utf8_distance (dec.cur, SvPVX (string));
       SV *uni = sv_newmortal ();
 
       // horrible hack to silence warning inside pv_uni_display
@@ -1065,6 +1156,7 @@
 SV *ascii (SV *self, int enable = 1)
 	ALIAS:
         ascii        = F_ASCII
+        latin1       = F_LATIN1
         utf8         = F_UTF8
         indent       = F_INDENT
         canonical    = F_CANONICAL
@@ -1110,7 +1202,16 @@
 
 void decode (SV *self, SV *jsonstr)
 	PPCODE:
-        XPUSHs (decode_json (jsonstr, *SvJSON (self)));
+        XPUSHs (decode_json (jsonstr, *SvJSON (self), 0));
+
+void decode_prefix (SV *self, SV *jsonstr)
+	PPCODE:
+{
+  	UV offset;
+        EXTEND (SP, 2);
+        PUSHs (decode_json (jsonstr, *SvJSON (self), &offset));
+        PUSHs (sv_2mortal (newSVuv (offset)));
+}
 
 PROTOTYPES: ENABLE
 
@@ -1124,5 +1225,5 @@
 	ALIAS:
         jsonToObj = 0
 	PPCODE:
-        XPUSHs (decode_json (jsonstr, F_DEFAULT | F_UTF8));
+        XPUSHs (decode_json (jsonstr, F_DEFAULT | F_UTF8, 0));