[ViewVC] Diff of: cvs/JSON-XS/XS.xs

Comparing JSON-XS/XS.xs (file contents):
Revision 1.60 by root, Mon Aug 13 16:19:13 2007 UTC vs.
Revision 1.63 by root, Mon Aug 27 01:49:01 2007 UTC

 #define F_SPACE_AFTER    0x00000040UL
 #define F_ALLOW_NONREF   0x00000100UL
 #define F_SHRINK         0x00000200UL
 #define F_ALLOW_BLESSED  0x00000400UL
 #define F_CONV_BLESSED   0x00000800UL
+#define F_RELAXED        0x00001000UL
 #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
   --enc->indent;
   encode_indent (enc); encode_ch (enc, ']');
 }
 static void
-encode_he (enc_t *enc, HE *he)
+encode_hk (enc_t *enc, HE *he)
 {
   encode_ch (enc, '"');
   if (HeKLEN (he) == HEf_SVKEY)
     {
   encode_ch (enc, '"');
   if (enc->json.flags & F_SPACE_BEFORE) encode_space (enc);
   encode_ch (enc, ':');
   if (enc->json.flags & F_SPACE_AFTER ) encode_space (enc);
-  encode_sv (enc, HeVAL (he));
 }
 // compare hash entries, used when all keys are bytestrings
 static int
 he_cmp_fast (const void *a_, const void *b_)
   HE *b = *(HE **)b_;
   STRLEN la = HeKLEN (a);
   STRLEN lb = HeKLEN (b);
-  if (!(cmp = memcmp (HeKEY (a), HeKEY (b), la < lb ? la : lb)))
+  if (!(cmp = memcmp (HeKEY (b), HeKEY (a), lb < la ? lb : la)))
-    cmp = la - lb;
+    cmp = lb - la;
   return cmp;
 }
 // compare hash entries, used when some keys are sv's or utf-x
 static int
 he_cmp_slow (const void *a, const void *b)
 {
-  return sv_cmp (HeSVKEY_force (*(HE **)a), HeSVKEY_force (*(HE **)b));
+  return sv_cmp (HeSVKEY_force (*(HE **)b), HeSVKEY_force (*(HE **)a));
 }
 static void
 encode_hv (enc_t *enc, HV *hv)
 {
+  HE *he;
-  int count, i;
+  int count;
   if (enc->indent >= enc->maxdepth)
     croak ("data structure too deep (hit recursion limit)");
   encode_ch (enc, '{'); encode_nl (enc); ++enc->indent;
-  if ((count = hv_iterinit (hv)))
-    {
-      // for canonical output we have to sort by keys first
+  // for canonical output we have to sort by keys first
-      // actually, this is mostly due to the stupid so-called
+  // actually, this is mostly due to the stupid so-called
-      // security workaround added somewhere in 5.8.x.
+  // security workaround added somewhere in 5.8.x.
-      // that randomises hash orderings
+  // that randomises hash orderings
-      if (enc->json.flags & F_CANONICAL)
+  if (enc->json.flags & F_CANONICAL)
+    {
+      int count = hv_iterinit (hv);
+      if (SvMAGICAL (hv))
         {
+          // need to count by iterating. could improve by dynamically building the vector below
+          // but I don't care for the speed of this special case.
+          // note also that we will run into undefined behaviour when the two iterations
+          // do not result in the same count, something I might care for in some later release.
+          count = 0;
+          while (hv_iternext (hv))
+            ++count;
+          hv_iterinit (hv);
+        }
+      if (count)
+        {
-          int fast = 1;
+          int i, 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
               FREETMPS;
               LEAVE;
             }
-          for (i = 0; i < count; ++i)
+          while (count--)
             {
               encode_indent (enc);
+              he = hes [count];
-              encode_he (enc, hes [i]);
+              encode_hk (enc, he);
+              encode_sv (enc, expect_false (SvMAGICAL (hv)) ? hv_iterval (hv, he) : HeVAL (he));
-              if (i < count - 1)
+              if (count)
                 encode_comma (enc);
             }
-          encode_nl (enc);
         }
+    }
-      else
+  else
-        {
+    {
+      if (hv_iterinit (hv) || SvMAGICAL (hv))
-          HE *he = hv_iternext (hv);
+        if ((he = hv_iternext (hv)))
           for (;;)
             {
               encode_indent (enc);
-              encode_he (enc, he);
+              encode_hk (enc, he);
+              encode_sv (enc, expect_false (SvMAGICAL (hv)) ? hv_iterval (hv, he) : HeVAL (he));
               if (!(he = hv_iternext (hv)))
                 break;
               encode_comma (enc);
             }
+    }
-          encode_nl (enc);
+  encode_nl (enc);
-        }
-    }
   --enc->indent; encode_indent (enc); encode_ch (enc, '}');
 }
 // encode objects, arrays and special \0=false and \1=true values.
       if (ch > 0x20
           || (ch != 0x20 && ch != 0x0a && ch != 0x0d && ch != 0x09))
         break;
+      if (ch == '#' && dec->json.flags & F_RELAXED)
+        ++dec->cur;
       ++dec->cur;
     }
 }
 #define ERR(reason) SB dec->err = reason; goto fail; SE
         if (*dec->cur != ',')
           ERR (", or ] expected while parsing array");
         ++dec->cur;
+        decode_ws (dec);
+        if (*dec->cur == ']' && dec->json.flags & F_RELAXED)
+          {
+            ++dec->cur;
+            break;
+          }
       }
   DEC_DEC_DEPTH;
   return newRV_noinc ((SV *)av);
   if (*dec->cur == '}')
     ++dec->cur;
   else
     for (;;)
       {
-        decode_ws (dec); EXPECT_CH ('"');
+        EXPECT_CH ('"');
         // 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
                   if (!key)
                     goto fail;
                   decode_ws (dec); EXPECT_CH (':');
+                  decode_ws (dec);
                   value = decode_sv (dec);
                   if (!value)
                     {
                       SvREFCNT_dec (key);
                       goto fail;
                   int len = p - key;
                   dec->cur = p + 1;
                   decode_ws (dec); EXPECT_CH (':');
+                  decode_ws (dec);
                   value = decode_sv (dec);
                   if (!value)
                     goto fail;
                   hv_store (hv, key, len, value, 0);
         if (*dec->cur != ',')
           ERR (", or } expected while parsing object/hash");
         ++dec->cur;
+        decode_ws (dec);
+        if (*dec->cur == '}' && dec->json.flags & F_RELAXED)
+          {
+            ++dec->cur;
+            break;
+          }
       }
   DEC_DEC_DEPTH;
   sv = newRV_noinc ((SV *)hv);
 }
 static SV *
 decode_sv (dec_t *dec)
 {
-  decode_ws (dec);
   // the beauty of JSON: you need exactly one character lookahead
   // to parse anything.
   switch (*dec->cur)
     {
       case '"': ++dec->cur; return decode_str (dec);
   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
+  decode_ws (&dec);
   sv = decode_sv (&dec);
   if (!(offset_return || !sv))
     {
       // check for trailing garbage
         pretty          = F_PRETTY
         allow_nonref    = F_ALLOW_NONREF
         shrink          = F_SHRINK
         allow_blessed   = F_ALLOW_BLESSED
         convert_blessed = F_CONV_BLESSED
+        relaxed         = F_RELAXED
 	PPCODE:
 {
         if (enable)
           self->flags |=  ix;
         else

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing JSON-XS/XS.xs (file contents): Revision 1.60 by root, Mon Aug 13 16:19:13 2007 UTC vs. Revision 1.63 by root, Mon Aug 27 01:49:01 2007 UTC

Diff Legend

Comparing JSON-XS/XS.xs (file contents):
Revision 1.60 by root, Mon Aug 13 16:19:13 2007 UTC vs.
Revision 1.63 by root, Mon Aug 27 01:49:01 2007 UTC