--- JSON-XS/XS.xs	2007/06/25 04:08:17	1.44
+++ JSON-XS/XS.xs	2007/07/10 16:22:31	1.54
@@ -27,11 +27,15 @@
 #define F_ALLOW_NONREF   0x00000100UL
 #define F_SHRINK         0x00000200UL
 #define F_ALLOW_BLESSED  0x00000400UL
-#define F_CONV_BLESSED   0x00000800UL // NYI
+#define F_CONV_BLESSED   0x00000800UL
 #define F_MAXDEPTH       0xf8000000UL
 #define S_MAXDEPTH       27
+#define F_MAXSIZE        0x01f00000UL
+#define S_MAXSIZE        20
+#define F_HOOK           0x00080000UL // some hooks exist, so slow-path processing
 
 #define DEC_DEPTH(flags) (1UL << ((flags & F_MAXDEPTH) >> S_MAXDEPTH))
+#define DEC_SIZE(flags)  (1UL << ((flags & F_MAXSIZE ) >> S_MAXSIZE ))
 
 #define F_PRETTY    F_INDENT | F_SPACE_BEFORE | F_SPACE_AFTER
 #define F_DEFAULT   (9UL << S_MAXDEPTH)
@@ -58,19 +62,16 @@
 static HV *json_stash, *json_boolean_stash; // JSON::XS::
 static SV *json_true, *json_false;
 
+typedef struct {
+  U32 flags;
+  SV *cb_object;
+  HV *cb_sk_object;
+} JSON;
+
 /////////////////////////////////////////////////////////////////////////////
 // utility functions
 
-static UV *
-SvJSON (SV *sv)
-{
-  if (!(SvROK (sv) && SvOBJECT (SvRV (sv)) && SvSTASH (SvRV (sv)) == json_stash))
-    croak ("object is not of type JSON::XS");
-
-  return &SvUVX (SvRV (sv));
-}
-
-static void
+inline void
 shrink (SV *sv)
 {
   sv_utf8_downgrade (sv, 1);
@@ -115,7 +116,7 @@
   char *cur;  // SvPVX (sv) + current output position
   char *end;  // SvEND (sv)
   SV *sv;     // result scalar
-  U32 flags;   // F_*
+  JSON json;
   U32 indent; // indentation level
   U32 maxdepth; // max. indentation/recursion level
 } enc_t;
@@ -199,7 +200,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 || (enc->flags & F_LATIN1 && uch > 0xFF))
+                  if (uch < 0x80 || enc->json.flags & F_ASCII || (enc->json.flags & F_LATIN1 && uch > 0xFF))
                     {
                       if (uch > 0xFFFFUL)
                         {
@@ -223,7 +224,7 @@
 
                       str += clen;
                     }
-                  else if (enc->flags & F_LATIN1)
+                  else if (enc->json.flags & F_LATIN1)
                     {
                       *enc->cur++ = uch;
                       str += clen;
@@ -254,7 +255,7 @@
 inline void
 encode_indent (enc_t *enc)
 {
-  if (enc->flags & F_INDENT)
+  if (enc->json.flags & F_INDENT)
     {
       int spaces = enc->indent * INDENT_STEP;
 
@@ -274,7 +275,7 @@
 inline void
 encode_nl (enc_t *enc)
 {
-  if (enc->flags & F_INDENT)
+  if (enc->json.flags & F_INDENT)
     {
       need (enc, 1);
       encode_ch (enc, '\n');
@@ -286,9 +287,9 @@
 {
   encode_ch (enc, ',');
 
-  if (enc->flags & F_INDENT)
+  if (enc->json.flags & F_INDENT)
     encode_nl (enc);
-  else if (enc->flags & F_SPACE_AFTER)
+  else if (enc->json.flags & F_SPACE_AFTER)
     encode_space (enc);
 }
 
@@ -341,9 +342,9 @@
 
   encode_ch (enc, '"');
 
-  if (enc->flags & F_SPACE_BEFORE) encode_space (enc);
+  if (enc->json.flags & F_SPACE_BEFORE) encode_space (enc);
   encode_ch (enc, ':');
-  if (enc->flags & F_SPACE_AFTER ) encode_space (enc);
+  if (enc->json.flags & F_SPACE_AFTER ) encode_space (enc);
   encode_sv (enc, HeVAL (he));
 }
 
@@ -388,7 +389,7 @@
       // actually, this is mostly due to the stupid so-called
       // security workaround added somewhere in 5.8.x.
       // that randomises hash orderings
-      if (enc->flags & F_CANONICAL)
+      if (enc->json.flags & F_CANONICAL)
         {
           int fast = 1;
           HE *he;
@@ -474,10 +475,10 @@
     {
       if (SvSTASH (sv) == json_boolean_stash)
         {
-          if (SvIV (sv) == 0)
-            encode_str (enc, "false", 5, 0);
-          else
+          if (SvIV (sv))
             encode_str (enc, "true", 4, 0);
+          else
+            encode_str (enc, "false", 5, 0);
         }
       else
         {
@@ -487,37 +488,42 @@
               // not yet
             }
 #endif
-          if (enc->flags & F_CONV_BLESSED)
+          if (enc->json.flags & F_CONV_BLESSED)
             {
               // we re-bless the reference to get overload and other niceties right
-              GV *to_json = gv_fetchmethod_autoload (SvSTASH (sv), "TO_JSON", 1);
+              GV *to_json = gv_fetchmethod_autoload (SvSTASH (sv), "TO_JSON", 0);
 
               if (to_json)
                 {
+                  int count;
                   dSP;
-                  ENTER;
-                  SAVETMPS;
-                  PUSHMARK (SP);
+
+                  ENTER; SAVETMPS; PUSHMARK (SP);
                   XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), SvSTASH (sv)));
 
-                  // calling with G_SCALAR ensures that we always get a 1 reutrn value
-                  // check anyways.
+                  // calling with G_SCALAR ensures that we always get a 1 return value
                   PUTBACK;
-                  assert (1 == call_sv ((SV *)GvCV (to_json), G_SCALAR));
+                  call_sv ((SV *)GvCV (to_json), G_SCALAR);
                   SPAGAIN;
 
-                  encode_sv (enc, POPs);
+                  // catch this surprisingly common error
+                  if (SvROK (TOPs) && SvRV (TOPs) == sv)
+                    croak ("%s::TO_JSON method returned same object as was passed instead of a new one", HvNAME (SvSTASH (sv)));
+
+                  sv = POPs;
+                  PUTBACK;
+
+                  encode_sv (enc, sv);
 
-                  FREETMPS;
-                  LEAVE;
+                  FREETMPS; LEAVE;
                 }
-              else if (enc->flags & F_ALLOW_BLESSED)
+              else if (enc->json.flags & F_ALLOW_BLESSED)
                 encode_str (enc, "null", 4, 0);
               else
                 croak ("encountered object '%s', but neither allow_blessed enabled nor TO_JSON method available on it",
                        SvPV_nolen (sv_2mortal (newRV_inc (sv))));
             }
-          else if (enc->flags & F_ALLOW_BLESSED)
+          else if (enc->json.flags & F_ALLOW_BLESSED)
             encode_str (enc, "null", 4, 0);
           else
             croak ("encountered object '%s', but neither allow_blessed nor convert_blessed settings are enabled",
@@ -530,10 +536,13 @@
     encode_av (enc, (AV *)sv);
   else if (svt < SVt_PVAV)
     {
-      if (SvNIOK (sv) && SvIV (sv) == 0)
-        encode_str (enc, "false", 5, 0);
-      else if (SvNIOK (sv) && SvIV (sv) == 1)
+      STRLEN len = 0;
+      char *pv = svt ? SvPV (sv, len) : 0;
+
+      if (len == 1 && *pv == '1')
         encode_str (enc, "true", 4, 0);
+      else if (len == 1 && *pv == '0')
+        encode_str (enc, "false", 5, 0);
       else
         croak ("cannot encode reference to scalar '%s' unless the scalar is 0 or 1",
                SvPV_nolen (sv_2mortal (newRV_inc (sv))));
@@ -613,19 +622,19 @@
 }
 
 static SV *
-encode_json (SV *scalar, U32 flags)
+encode_json (SV *scalar, JSON *json)
 {
   enc_t enc;
 
-  if (!(flags & F_ALLOW_NONREF) && !SvROK (scalar))
+  if (!(json->flags & F_ALLOW_NONREF) && !SvROK (scalar))
     croak ("hash- or arrayref expected (not a simple scalar, use allow_nonref to allow this)");
 
-  enc.flags     = flags;
+  enc.json      = *json;
   enc.sv        = sv_2mortal (NEWSV (0, INIT_SIZE));
   enc.cur       = SvPVX (enc.sv);
   enc.end       = SvEND (enc.sv);
   enc.indent    = 0;
-  enc.maxdepth  = DEC_DEPTH (flags);
+  enc.maxdepth  = DEC_DEPTH (enc.json.flags);
 
   SvPOK_only (enc.sv);
   encode_sv (&enc, scalar);
@@ -633,10 +642,10 @@
   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)))
+  if (!(enc.json.flags & (F_ASCII | F_LATIN1 | F_UTF8)))
     SvUTF8_on (enc.sv);
 
-  if (enc.flags & F_SHRINK)
+  if (enc.json.flags & F_SHRINK)
     shrink (enc.sv);
 
   return enc.sv;
@@ -651,7 +660,7 @@
   char *cur; // current parser pointer
   char *end; // end of input string
   const char *err; // parse error, if != 0
-  U32 flags;  // F_*
+  JSON json;
   U32 depth; // recursion depth
   U32 maxdepth; // recursion depth limit
 } dec_t;
@@ -1012,6 +1021,7 @@
 static SV *
 decode_hv (dec_t *dec)
 {
+  SV *sv;
   HV *hv = newHV ();
 
   DEC_INC_DEPTH;
@@ -1022,25 +1032,63 @@
   else
     for (;;)
       {
-        SV *key, *value;
-
         decode_ws (dec); EXPECT_CH ('"');
 
-        key = decode_str (dec);
-        if (!key)
-          goto fail;
+        // heuristic: assume that
+        // a) decode_str + hv_store_ent are abysmally slow.
+        // b) most hash keys are short, simple ascii text.
+        // => try to "fast-match" such strings to avoid
+        // the overhead of decode_str + hv_store_ent.
+        {
+          SV *value;
+          char *p = dec->cur;
+          char *e = p + 24; // only try up to 24 bytes
 
-        decode_ws (dec); EXPECT_CH (':');
+          for (;;)
+            {
+              // the >= 0x80 is true on most architectures
+              if (p == e || *p < 0x20 || *p >= 0x80 || *p == '\\')
+                {
+                  // slow path, back up and use decode_str
+                  SV *key = decode_str (dec);
+                  if (!key)
+                    goto fail;
 
-        value = decode_sv (dec);
-        if (!value)
-          {
-            SvREFCNT_dec (key);
-            goto fail;
-          }
+                  decode_ws (dec); EXPECT_CH (':');
 
-        hv_store_ent (hv, key, value, 0);
-        SvREFCNT_dec (key);
+                  value = decode_sv (dec);
+                  if (!value)
+                    {
+                      SvREFCNT_dec (key);
+                      goto fail;
+                    }
+
+                  hv_store_ent (hv, key, value, 0);
+                  SvREFCNT_dec (key);
+
+                  break;
+                }
+              else if (*p == '"')
+                {
+                  // fast path, got a simple key
+                  char *key = dec->cur;
+                  int len = p - key;
+                  dec->cur = p + 1;
+
+                  decode_ws (dec); EXPECT_CH (':');
+
+                  value = decode_sv (dec);
+                  if (!value)
+                    goto fail;
+
+                  hv_store (hv, key, len, value, 0);
+
+                  break;
+                }
+
+              ++p;
+            }
+        }
 
         decode_ws (dec);
 
@@ -1057,7 +1105,67 @@
       }
 
   DEC_DEC_DEPTH;
-  return newRV_noinc ((SV *)hv);
+  sv = newRV_noinc ((SV *)hv);
+
+  // check filter callbacks
+  if (dec->json.flags & F_HOOK)
+    {
+      if (dec->json.cb_sk_object && HvKEYS (hv) == 1)
+        {
+          HE *cb, *he;
+
+          hv_iterinit (hv);
+          he = hv_iternext (hv);
+          hv_iterinit (hv);
+
+          // the next line creates a mortal sv each time its called.
+          // might want to optimise this for common cases.
+          cb = hv_fetch_ent (dec->json.cb_sk_object, hv_iterkeysv (he), 0, 0);
+
+          if (cb)
+            {
+              dSP;
+              int count;
+
+              ENTER; SAVETMPS; PUSHMARK (SP);
+              XPUSHs (HeVAL (he));
+
+              PUTBACK; count = call_sv (HeVAL (cb), G_ARRAY); SPAGAIN;
+
+              if (count == 1)
+                {
+                  sv = newSVsv (POPs);
+                  FREETMPS; LEAVE;
+                  return sv;
+                }
+
+              FREETMPS; LEAVE;
+            }
+        }
+
+      if (dec->json.cb_object)
+        {
+          dSP;
+          int count;
+
+          ENTER; SAVETMPS; PUSHMARK (SP);
+          XPUSHs (sv_2mortal (sv));
+
+          PUTBACK; count = call_sv (dec->json.cb_object, G_ARRAY); SPAGAIN;
+
+          if (count == 1)
+            {
+              sv = newSVsv (POPs);
+              FREETMPS; LEAVE;
+              return sv;
+            }
+
+          SvREFCNT_inc (sv);
+          FREETMPS; LEAVE;
+        }
+    }
+
+  return sv;
 
 fail:
   SvREFCNT_dec (hv);
@@ -1126,7 +1234,7 @@
 }
 
 static SV *
-decode_json (SV *string, U32 flags, UV *offset_return)
+decode_json (SV *string, JSON *json, UV *offset_return)
 {
   dec_t dec;
   UV offset;
@@ -1135,19 +1243,26 @@
   SvGETMAGIC (string);
   SvUPGRADE (string, SVt_PV);
 
-  if (flags & F_UTF8)
+  if (json->flags & F_MAXSIZE && SvCUR (string) > DEC_SIZE (json->flags))
+    croak ("attempted decode of JSON text of %lu bytes size, but max_size is set to %lu",
+           (unsigned long)SvCUR (string), (unsigned long)DEC_SIZE (json->flags));
+
+  if (json->flags & F_UTF8)
     sv_utf8_downgrade (string, 0);
   else
     sv_utf8_upgrade (string);
 
   SvGROW (string, SvCUR (string) + 1); // should basically be a NOP
 
-  dec.flags    = flags;
+  dec.json     = *json;
   dec.cur      = SvPVX (string);
   dec.end      = SvEND (string);
   dec.err      = 0;
   dec.depth    = 0;
-  dec.maxdepth = DEC_DEPTH (dec.flags);
+  dec.maxdepth = DEC_DEPTH (dec.json.flags);
+
+  if (dec.json.cb_object || dec.json.cb_sk_object)
+    dec.json.flags |= F_HOOK;
 
   *dec.end = 0; // this should basically be a nop, too, but make sure it's there
   sv = decode_sv (&dec);
@@ -1167,7 +1282,7 @@
 
   if (offset_return || !sv)
     {
-      offset = dec.flags & F_UTF8
+      offset = dec.json.flags & F_UTF8
                ? dec.cur - SvPVX (string)
                : utf8_distance (dec.cur, SvPVX (string));
 
@@ -1196,7 +1311,7 @@
 
   sv = sv_2mortal (sv);
 
-  if (!(dec.flags & F_ALLOW_NONREF) && !SvROK (sv))
+  if (!(dec.json.flags & F_ALLOW_NONREF) && !SvROK (sv))
     croak ("JSON text must be an object or array (but found number, string, true, false or null, use allow_nonref to allow this)");
 
   return sv;
@@ -1227,13 +1342,17 @@
 
 PROTOTYPES: DISABLE
 
-SV *new (char *dummy)
-	CODE:
-        RETVAL = sv_bless (newRV_noinc (newSVuv (F_DEFAULT)), json_stash);
-	OUTPUT:
-        RETVAL
+void new (char *klass)
+	PPCODE:
+{
+  	SV *pv = NEWSV (0, sizeof (JSON));
+        SvPOK_only (pv);
+        Zero (SvPVX (pv), 1, JSON);
+        ((JSON *)SvPVX (pv))->flags = F_DEFAULT;
+        XPUSHs (sv_2mortal (sv_bless (newRV_noinc (pv), json_stash)));
+}
 
-SV *ascii (SV *self, int enable = 1)
+void ascii (JSON *self, int enable = 1)
 	ALIAS:
         ascii           = F_ASCII
         latin1          = F_LATIN1
@@ -1247,23 +1366,19 @@
         shrink          = F_SHRINK
         allow_blessed   = F_ALLOW_BLESSED
         convert_blessed = F_CONV_BLESSED
-	CODE:
+	PPCODE:
 {
-  	UV *uv = SvJSON (self);
         if (enable)
-          *uv |=  ix;
+          self->flags |=  ix;
         else
-          *uv &= ~ix;
+          self->flags &= ~ix;
 
-        RETVAL = newSVsv (self);
+        XPUSHs (ST (0));
 }
-	OUTPUT:
-        RETVAL
 
-SV *max_depth (SV *self, UV max_depth = 0x80000000UL)
-	CODE:
+void max_depth (JSON *self, UV max_depth = 0x80000000UL)
+	PPCODE:
 {
-  	UV *uv = SvJSON (self);
         UV log2 = 0;
 
         if (max_depth > 0x80000000UL) max_depth = 0x80000000UL;
@@ -1271,41 +1386,93 @@
         while ((1UL << log2) < max_depth)
           ++log2;
 
-        *uv = *uv & ~F_MAXDEPTH | (log2 << S_MAXDEPTH);
+        self->flags = self->flags & ~F_MAXDEPTH | (log2 << S_MAXDEPTH);
+
+        XPUSHs (ST (0));
+}
+
+void max_size (JSON *self, UV max_size = 0)
+	PPCODE:
+{
+        UV log2 = 0;
+
+        if (max_size > 0x80000000UL) max_size = 0x80000000UL;
+        if (max_size == 1)           max_size = 2;
+
+        while ((1UL << log2) < max_size)
+          ++log2;
+
+        self->flags = self->flags & ~F_MAXSIZE | (log2 << S_MAXSIZE);
+
+        XPUSHs (ST (0));
+}
+
+void filter_json_object (JSON *self, SV *cb = &PL_sv_undef)
+	PPCODE:
+{
+        SvREFCNT_dec (self->cb_object);
+        self->cb_object = SvOK (cb) ? newSVsv (cb) : 0;
+
+        XPUSHs (ST (0));
+}
+
+void filter_json_single_key_object (JSON *self, SV *key, SV *cb = &PL_sv_undef)
+	PPCODE:
+{
+  	if (!self->cb_sk_object)
+          self->cb_sk_object = newHV ();
+
+        if (SvOK (cb))
+          hv_store_ent (self->cb_sk_object, key, newSVsv (cb), 0);
+        else
+          {
+            hv_delete_ent (self->cb_sk_object, key, G_DISCARD, 0);
 
-        RETVAL = newSVsv (self);
+            if (!HvKEYS (self->cb_sk_object))
+              {
+                SvREFCNT_dec (self->cb_sk_object);
+                self->cb_sk_object = 0;
+              }
+          }
+
+        XPUSHs (ST (0));
 }
-	OUTPUT:
-        RETVAL
 
-void encode (SV *self, SV *scalar)
+void encode (JSON *self, SV *scalar)
 	PPCODE:
-        XPUSHs (encode_json (scalar, *SvJSON (self)));
+        XPUSHs (encode_json (scalar, self));
 
-void decode (SV *self, SV *jsonstr)
+void decode (JSON *self, SV *jsonstr)
 	PPCODE:
-        XPUSHs (decode_json (jsonstr, *SvJSON (self), 0));
+        XPUSHs (decode_json (jsonstr, self, 0));
 
-void decode_prefix (SV *self, SV *jsonstr)
+void decode_prefix (JSON *self, SV *jsonstr)
 	PPCODE:
 {
   	UV offset;
         EXTEND (SP, 2);
-        PUSHs (decode_json (jsonstr, *SvJSON (self), &offset));
+        PUSHs (decode_json (jsonstr, self, &offset));
         PUSHs (sv_2mortal (newSVuv (offset)));
 }
 
+void DESTROY (JSON *self)
+	CODE:
+        SvREFCNT_dec (self->cb_sk_object);
+        SvREFCNT_dec (self->cb_object);
+
 PROTOTYPES: ENABLE
 
 void to_json (SV *scalar)
-	ALIAS:
-        objToJson = 0
 	PPCODE:
-        XPUSHs (encode_json (scalar, F_DEFAULT | F_UTF8));
+{
+        JSON json = { F_DEFAULT | F_UTF8 };
+        XPUSHs (encode_json (scalar, &json));
+}
 
 void from_json (SV *jsonstr)
-	ALIAS:
-        jsonToObj = 0
 	PPCODE:
-        XPUSHs (decode_json (jsonstr, F_DEFAULT | F_UTF8, 0));
+{
+        JSON json = { F_DEFAULT | F_UTF8 };
+        XPUSHs (decode_json (jsonstr, &json, 0));
+}