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

Comparing JSON-XS/XS.xs (file contents):
Revision 1.104 by root, Tue Jan 19 00:31:13 2010 UTC vs.
Revision 1.113 by root, Thu Aug 11 21:37:41 2011 UTC

 #define INIT_SIZE   32 // initial scalar size to be allocated
 #define INDENT_STEP 3  // spaces per indentation level
 #define SHORT_STRING_LEN 16384 // special-case strings of up to this size
+#define DECODE_WANTS_OCTETS(json) ((json)->flags & F_UTF8)
 #define SB do {
 #define SE } while (0)
 #if __GNUC__ >= 3
 # define expect(expr,value)         __builtin_expect ((expr), (value))
 /////////////////////////////////////////////////////////////////////////////
 // fp hell
 // scan a group of digits, and a trailing exponent
 static void
-json_atof_scan1 (const char *s, NV *accum, int *expo, int postdp)
+json_atof_scan1 (const char *s, NV *accum, int *expo, int postdp, int maxdepth)
 {
   UV  uaccum = 0;
   int eaccum = 0;
+  // if we recurse too deep, skip all remaining digits
+  // to avoid a stack overflow attack
+  if (expect_false (--maxdepth <= 0))
+    while (((U8)*s - '0') < 10)
+      ++s;
   for (;;)
     {
       U8 dig = (U8)*s - '0';
       if (expect_false (dig >= 10))
         {
           if (dig == (U8)((U8)'.' - (U8)'0'))
             {
               ++s;
-              json_atof_scan1 (s, accum, expo, 1);
+              json_atof_scan1 (s, accum, expo, 1, maxdepth);
             }
           else if ((dig | ' ') == 'e' - '0')
             {
               int exp2 = 0;
               int neg  = 0;
       // if we have too many digits, then recurse for more
       // we actually do this for rather few digits
       if (uaccum >= (UV_MAX - 9) / 10)
         {
           if (postdp) *expo -= eaccum;
-          json_atof_scan1 (s, accum, expo, postdp);
+          json_atof_scan1 (s, accum, expo, postdp, maxdepth);
           if (postdp) *expo += eaccum;
           break;
         }
     }
+  // this relies greatly on the quality of the pow ()
+  // implementation of the platform, but a good
+  // implementation is hard to beat.
+  // (IEEE 754 conformant ones are required to be exact)
   if (postdp) *expo -= eaccum;
-  *accum += uaccum * pow (10., *expo);
+  *accum += uaccum * Perl_pow (10., *expo);
   *expo += eaccum;
 }
 static NV
 json_atof (const char *s)
     {
       ++s;
       neg = 1;
     }
+  // a recursion depth of ten gives us >>500 bits
-  json_atof_scan1 (s, &accum, &expo, 0);
+  json_atof_scan1 (s, &accum, &expo, 0, 10);
   return neg ? -accum : accum;
 }
 /////////////////////////////////////////////////////////////////////////////
 // encoder
     encode_rv (enc, SvRV (sv));
   else if (!SvOK (sv) || enc->json.flags & F_ALLOW_UNKNOWN)
     encode_str (enc, "null", 4, 0);
   else
     croak ("encountered perl type (%s,0x%x) that JSON cannot handle, you might want to report this",
-           SvPV_nolen (sv), SvFLAGS (sv));
+           SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));
 }
 static SV *
 encode_json (SV *scalar, JSON *json)
 {
               dSP;
               int count;
               ENTER; SAVETMPS; PUSHMARK (SP);
               XPUSHs (HeVAL (he));
+              sv_2mortal (sv);
               PUTBACK; count = call_sv (HeVAL (cb), G_ARRAY); SPAGAIN;
               if (count == 1)
                 {
                   sv = newSVsv (POPs);
                   FREETMPS; LEAVE;
                   return sv;
                 }
+              SvREFCNT_inc (sv);
               FREETMPS; LEAVE;
             }
         }
       if (dec->json.cb_object)
 {
   dec_t dec;
   SV *sv;
   /* work around bugs in 5.10 where manipulating magic values
-   * will perl ignore the magic in subsequent accesses
+   * will perl ignore the magic in subsequent accesses.
+   * also make a copy of non-PV values, to get them into a clean
+   * state (SvPV should do that, but it's buggy, see below).
    */
   /*SvGETMAGIC (string);*/
-  if (SvMAGICAL (string))
+  if (SvMAGICAL (string) || !SvPOK (string))
     string = sv_2mortal (newSVsv (string));
   SvUPGRADE (string, SVt_PV);
   /* work around a bug in perl 5.10, which causes SvCUR to fail an
     if (offset > json->max_size && json->max_size)
       croak ("attempted decode of JSON text of %lu bytes size, but max_size is set to %lu",
              (unsigned long)SvCUR (string), (unsigned long)json->max_size);
   }
-  if (json->flags & F_UTF8)
+  if (DECODE_WANTS_OCTETS (json))
     sv_utf8_downgrade (string, 0);
   else
     sv_utf8_upgrade (string);
   SvGROW (string, SvCUR (string) + 1); // should basically be a NOP
       pv_uni_display (uni, dec.cur, dec.end - dec.cur, 20, UNI_DISPLAY_QQ);
       LEAVE;
       croak ("%s, at character offset %d (before \"%s\")",
              dec.err,
-             ptr_to_index (string, dec.cur),
+             (int)ptr_to_index (string, dec.cur),
              dec.cur != dec.end ? SvPV_nolen (uni) : "(end of string)");
     }
   sv = sv_2mortal (sv);
 	PPCODE:
 {
 	if (!self->incr_text)
           self->incr_text = newSVpvn ("", 0);
+        /* if utf8-ness doesn't match the decoder, need to upgrade/downgrade */
+        if (!DECODE_WANTS_OCTETS (self) == !SvUTF8 (self->incr_text))
+          if (DECODE_WANTS_OCTETS (self))
+            {
+              if (self->incr_pos)
+                self->incr_pos = utf8_length ((U8 *)SvPVX (self->incr_text),
+                                              (U8 *)SvPVX (self->incr_text) + self->incr_pos);
+              sv_utf8_downgrade (self->incr_text, 0);
+            }
+          else
+            {
+              sv_utf8_upgrade (self->incr_text);
+              if (self->incr_pos)
+                self->incr_pos = utf8_hop ((U8 *)SvPVX (self->incr_text), self->incr_pos)
+                                 - (U8 *)SvPVX (self->incr_text);
+            }
         // append data, if any
         if (jsonstr)
           {
+            /* make sure both strings have same encoding */
+            if (SvUTF8 (jsonstr) != SvUTF8 (self->incr_text))
-            if (SvUTF8 (jsonstr))
+              if (SvUTF8 (jsonstr))
+                sv_utf8_downgrade (jsonstr, 0);
-              {
+              else
-                if (!SvUTF8 (self->incr_text))
-                  {
-                    /* utf-8-ness differs, need to upgrade */
-                    sv_utf8_upgrade (self->incr_text);
-                    if (self->incr_pos)
-                      self->incr_pos = utf8_hop ((U8 *)SvPVX (self->incr_text), self->incr_pos)
-                                       - (U8 *)SvPVX (self->incr_text);
-                  }
-              }
-            else if (SvUTF8 (self->incr_text))
-              sv_utf8_upgrade (jsonstr);
+                sv_utf8_upgrade (jsonstr);
+            /* and then just blindly append */
             {
               STRLEN len;
               const char *str = SvPV (jsonstr, len);
               STRLEN cur = SvCUR (self->incr_text);
                   if (self->incr_pos > self->max_size && self->max_size)
                     croak ("attempted decode of JSON text of %lu bytes size, but max_size is set to %lu",
                            (unsigned long)self->incr_pos, (unsigned long)self->max_size);
                   if (!INCR_DONE (self))
+                    {
+                      // as an optimisation, do not accumulate white space in the incr buffer
+                      if (self->incr_mode == INCR_M_WS && self->incr_pos)
+                        {
+                          self->incr_pos = 0;
+                          SvCUR_set (self->incr_text, 0);
+                        }
-                    break;
+                      break;
+                    }
                 }
               XPUSHs (decode_json (self->incr_text, self, &offset));
               self->incr_pos -= offset - SvPVX (self->incr_text);

Diff Legend

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

Comparing JSON-XS/XS.xs (file contents): Revision 1.104 by root, Tue Jan 19 00:31:13 2010 UTC vs. Revision 1.113 by root, Thu Aug 11 21:37:41 2011 UTC

Diff Legend

Comparing JSON-XS/XS.xs (file contents):
Revision 1.104 by root, Tue Jan 19 00:31:13 2010 UTC vs.
Revision 1.113 by root, Thu Aug 11 21:37:41 2011 UTC