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

Comparing JSON-XS/XS.xs (file contents):
Revision 1.97 by root, Fri Jul 3 09:38:30 2009 UTC vs.
Revision 1.104 by root, Tue Jan 19 00:31:13 2010 UTC

 #if defined(__BORLANDC__) || defined(_MSC_VER)
 # define snprintf _snprintf // C compilers have this in stdio.h
 #endif
 // some old perls do not have this, try to make it work, no
-// guarentees, though. if it breaks, you get to keep the pieces.
+// guarantees, though. if it breaks, you get to keep the pieces.
 #ifndef UTF8_MAXBYTES
 # define UTF8_MAXBYTES 13
 #endif
+// three extra for rounding, sign, and end of string
-#define IVUV_MAXCHARS (sizeof (UV) * CHAR_BIT * 28 / 93 + 2)
+#define IVUV_MAXCHARS (sizeof (UV) * CHAR_BIT * 28 / 93 + 3)
 #define F_ASCII          0x00000001UL
 #define F_LATIN1         0x00000002UL
 #define F_UTF8           0x00000004UL
 #define F_INDENT         0x00000008UL
 enum {
   INCR_M_WS = 0, // initial whitespace skipping, must be 0
   INCR_M_STR,    // inside string
   INCR_M_BS,     // inside backslash
+  INCR_M_C0,     // inside comment in initial whitespace sequence
+  INCR_M_C1,     // inside comment in other places
   INCR_M_JSON    // outside anything, count nesting
 };
 #define INCR_DONE(json) ((json)->incr_nest <= 0 && (json)->incr_mode == INCR_M_JSON)
   return SvUTF8 (sv)
          ? utf8_distance (offset, SvPVX (sv))
          : offset - SvPVX (sv);
 }
+/////////////////////////////////////////////////////////////////////////////
+// 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)
+{
+  UV  uaccum = 0;
+  int eaccum = 0;
+  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);
+            }
+          else if ((dig | ' ') == 'e' - '0')
+            {
+              int exp2 = 0;
+              int neg  = 0;
+              ++s;
+              if (*s == '-')
+                {
+                  ++s;
+                  neg = 1;
+                }
+              else if (*s == '+')
+                ++s;
+              while ((dig = (U8)*s - '0') < 10)
+                exp2 = exp2 * 10 + *s++ - '0';
+              *expo += neg ? -exp2 : exp2;
+            }
+          break;
+        }
+      ++s;
+      uaccum = uaccum * 10 + dig;
+      ++eaccum;
+      // 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);
+          if (postdp) *expo += eaccum;
+          break;
+        }
+    }
+  if (postdp) *expo -= eaccum;
+  *accum += uaccum * pow (10., *expo);
+  *expo += eaccum;
+}
+static NV
+json_atof (const char *s)
+{
+  NV accum = 0.;
+  int expo = 0;
+  int neg  = 0;
+  if (*s == '-')
+    {
+      ++s;
+      neg = 1;
+    }
+  json_atof_scan1 (s, &accum, &expo, 0);
+  return neg ? -accum : accum;
+}
 /////////////////////////////////////////////////////////////////////////////
 // encoder
 // structure used for encoding JSON
 typedef struct
   // for canonical output we have to sort by keys first
   // actually, this is mostly due to the stupid so-called
   // security workaround added somewhere in 5.8.x
   // that randomises hash orderings
-  if (enc->json.flags & F_CANONICAL)
+  if (enc->json.flags & F_CANONICAL && !SvRMAGICAL (hv))
     {
       int count = hv_iterinit (hv);
       if (SvMAGICAL (hv))
         {
                 : enc.json.flags & F_LATIN1 ? 0x000100UL
                                             : 0x110000UL;
   SvPOK_only (enc.sv);
   encode_sv (&enc, scalar);
+  encode_nl (&enc);
   SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv));
   *SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings
   if (!(enc.json.flags & (F_ASCII | F_LATIN1 | F_UTF8)))
           else if (expect_true (ch >= 0x20 && ch < 0x80))
             *cur++ = ch;
           else if (ch >= 0x80)
             {
               STRLEN clen;
-              UV uch;
               --dec_cur;
-              uch = decode_utf8 (dec_cur, dec->end - dec_cur, &clen);
+              decode_utf8 (dec_cur, dec->end - dec_cur, &clen);
               if (clen == (STRLEN)-1)
                 ERR ("malformed UTF-8 character in JSON string");
               do
                 *cur++ = *dec_cur++;
       }
       len -= *start == '-' ? 1 : 0;
       // does not fit into IV or UV, try NV
-      if ((sizeof (NV) == sizeof (double) && DBL_DIG >= len)
+      if (len <= NV_DIG)
-          #if defined (LDBL_DIG)
-          || (sizeof (NV) == sizeof (long double) && LDBL_DIG >= len)
-          #endif
-         )
         // fits into NV without loss of precision
-        return newSVnv (Atof (start));
+        return newSVnv (json_atof (start));
       // everything else fails, convert it to a string
       return newSVpvn (start, dec->cur - start);
     }
   // loss of precision here
-  return newSVnv (Atof (start));
+  return newSVnv (json_atof (start));
 fail:
   return 0;
 }
 static void
 incr_parse (JSON *self)
 {
   const char *p = SvPVX (self->incr_text) + self->incr_pos;
+  // the state machine here is a bit convoluted and could be simplified a lot
+  // but this would make it slower, so...
   for (;;)
     {
       //printf ("loop pod %d *p<%c><%s>, mode %d nest %d\n", p - SvPVX (self->incr_text), *p, p, self->incr_mode, self->incr_nest);//D
       switch (self->incr_mode)
         {
-          // only used for intiial whitespace skipping
+          // only used for initial whitespace skipping
           case INCR_M_WS:
             for (;;)
               {
                 if (*p > 0x20)
                   {
+                    if (*p == '#')
+                      {
+                        self->incr_mode = INCR_M_C0;
+                        goto incr_m_c;
+                      }
+                    else
+                      {
-                    self->incr_mode = INCR_M_JSON;
+                        self->incr_mode = INCR_M_JSON;
-                    goto incr_m_json;
+                        goto incr_m_json;
+                      }
                   }
                 else if (!*p)
                   goto interrupt;
                 ++p;
               goto interrupt;
             ++p;
             self->incr_mode = INCR_M_STR;
             goto incr_m_str;
+          // inside #-style comments
+          case INCR_M_C0:
+          case INCR_M_C1:
+          incr_m_c:
+            for (;;)
+              {
+                if (*p == '\n')
+                  {
+                    self->incr_mode = self->incr_mode == INCR_M_C0 ? INCR_M_WS : INCR_M_JSON;
+                    break;
+                  }
+                else if (!*p)
+                  goto interrupt;
+                ++p;
+              }
+            break;
           // inside a string
           case INCR_M_STR:
           incr_m_str:
             for (;;)
                     case ']':
                     case '}':
                       if (--self->incr_nest <= 0)
                         goto interrupt;
+                      break;
+                    case '#':
+                      self->incr_mode = INCR_M_C1;
+                      goto incr_m_c;
                   }
               }
         }
       modechange:
         ;
     }
 interrupt:
   self->incr_pos = p - SvPVX (self->incr_text);
+  //printf ("interrupt<%.*s>\n", self->incr_pos, SvPVX(self->incr_text));//D
   //printf ("return pos %d mode %d nest %d\n", self->incr_pos, self->incr_mode, self->incr_nest);//D
 }
 /////////////////////////////////////////////////////////////////////////////
 // XS interface functions
 	json_stash         = gv_stashpv ("JSON::XS"         , 1);
 	json_boolean_stash = gv_stashpv ("JSON::XS::Boolean", 1);
         json_true  = get_bool ("JSON::XS::true");
         json_false = get_bool ("JSON::XS::false");
+        CvNODEBUG_on (get_cv ("JSON::XS::incr_text", 0)); /* the debugger completely breaks lvalue subs */
 }
 PROTOTYPES: DISABLE
 void CLONE (...)
         json_init (&json);
         json.flags |= ix;
         XPUSHs (decode_json (jsonstr, &json, 0));
 }

Diff Legend

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

Comparing JSON-XS/XS.xs (file contents): Revision 1.97 by root, Fri Jul 3 09:38:30 2009 UTC vs. Revision 1.104 by root, Tue Jan 19 00:31:13 2010 UTC

Diff Legend

Comparing JSON-XS/XS.xs (file contents):
Revision 1.97 by root, Fri Jul 3 09:38:30 2009 UTC vs.
Revision 1.104 by root, Tue Jan 19 00:31:13 2010 UTC