ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/JSON-XS/XS.xs
(Generate patch)

Comparing JSON-XS/XS.xs (file contents):
Revision 1.40 by root, Tue Jun 12 01:27:02 2007 UTC vs.
Revision 1.46 by root, Mon Jun 25 22:11:39 2007 UTC

… …
9 9
10#if defined(__BORLANDC__) || defined(_MSC_VER) 10#if defined(__BORLANDC__) || defined(_MSC_VER)
11# define snprintf _snprintf // C compilers have this in stdio.h 11# define snprintf _snprintf // C compilers have this in stdio.h
12#endif 12#endif
13 13
14// some old perls do not have this, try to make it work, no
15// guarentees, though. if it breaks, you get to keep the pieces.
16#ifndef UTF8_MAXBYTES
17# define UTF8_MAXBYTES 13
18#endif
19
14#define F_ASCII 0x00000001UL 20#define F_ASCII 0x00000001UL
15#define F_LATIN1 0x00000002UL 21#define F_LATIN1 0x00000002UL
16#define F_UTF8 0x00000004UL 22#define F_UTF8 0x00000004UL
17#define F_INDENT 0x00000008UL 23#define F_INDENT 0x00000008UL
18#define F_CANONICAL 0x00000010UL 24#define F_CANONICAL 0x00000010UL
19#define F_SPACE_BEFORE 0x00000020UL 25#define F_SPACE_BEFORE 0x00000020UL
20#define F_SPACE_AFTER 0x00000040UL 26#define F_SPACE_AFTER 0x00000040UL
21#define F_ALLOW_NONREF 0x00000100UL 27#define F_ALLOW_NONREF 0x00000100UL
22#define F_SHRINK 0x00000200UL 28#define F_SHRINK 0x00000200UL
29#define F_ALLOW_BLESSED 0x00000400UL
30#define F_CONV_BLESSED 0x00000800UL // NYI
23#define F_MAXDEPTH 0xf8000000UL 31#define F_MAXDEPTH 0xf8000000UL
24#define S_MAXDEPTH 27 32#define S_MAXDEPTH 27
33#define F_MAXSIZE 0x01f00000UL
34#define S_MAXSIZE 20
25 35
26#define DEC_DEPTH(flags) (1UL << ((flags & F_MAXDEPTH) >> S_MAXDEPTH)) 36#define DEC_DEPTH(flags) (1UL << ((flags & F_MAXDEPTH) >> S_MAXDEPTH))
27 37#define DEC_SIZE(flags) (1UL << ((flags & F_MAXSIZE ) >> S_MAXSIZE ))
28// F_SELFCONVERT? <=> to_json/toJson
29// F_BLESSED? <=> { $__class__$ => }
30 38
31#define F_PRETTY F_INDENT | F_SPACE_BEFORE | F_SPACE_AFTER 39#define F_PRETTY F_INDENT | F_SPACE_BEFORE | F_SPACE_AFTER
32#define F_DEFAULT (9UL << S_MAXDEPTH) 40#define F_DEFAULT (9UL << S_MAXDEPTH)
33 41
34#define INIT_SIZE 32 // initial scalar size to be allocated 42#define INIT_SIZE 32 // initial scalar size to be allocated
… …
48#endif 56#endif
49 57
50#define expect_false(expr) expect ((expr) != 0, 0) 58#define expect_false(expr) expect ((expr) != 0, 0)
51#define expect_true(expr) expect ((expr) != 0, 1) 59#define expect_true(expr) expect ((expr) != 0, 1)
52 60
53static HV *json_stash; // JSON::XS:: 61static HV *json_stash, *json_boolean_stash; // JSON::XS::
62static SV *json_true, *json_false;
54 63
55///////////////////////////////////////////////////////////////////////////// 64/////////////////////////////////////////////////////////////////////////////
56// utility functions 65// utility functions
57 66
58static UV * 67static UV *
… …
462 svtype svt; 471 svtype svt;
463 472
464 SvGETMAGIC (sv); 473 SvGETMAGIC (sv);
465 svt = SvTYPE (sv); 474 svt = SvTYPE (sv);
466 475
476 if (expect_false (SvOBJECT (sv)))
477 {
478 if (SvSTASH (sv) == json_boolean_stash)
479 {
480 if (SvIV (sv) == 0)
481 encode_str (enc, "false", 5, 0);
482 else
483 encode_str (enc, "true", 4, 0);
484 }
485 else
486 {
487#if 0
488 if (0 && sv_derived_from (rv, "JSON::Literal"))
489 {
490 // not yet
491 }
492#endif
493 if (enc->flags & F_CONV_BLESSED)
494 {
495 // we re-bless the reference to get overload and other niceties right
496 GV *to_json = gv_fetchmethod_autoload (SvSTASH (sv), "TO_JSON", 1);
497
498 if (to_json)
499 {
500 dSP;
501 ENTER;
502 SAVETMPS;
503 PUSHMARK (SP);
504 XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), SvSTASH (sv)));
505
506 // calling with G_SCALAR ensures that we always get a 1 reutrn value
507 // check anyways.
508 PUTBACK;
509 assert (1 == call_sv ((SV *)GvCV (to_json), G_SCALAR));
510 SPAGAIN;
511
512 encode_sv (enc, POPs);
513
514 FREETMPS;
515 LEAVE;
516 }
517 else if (enc->flags & F_ALLOW_BLESSED)
518 encode_str (enc, "null", 4, 0);
519 else
520 croak ("encountered object '%s', but neither allow_blessed enabled nor TO_JSON method available on it",
521 SvPV_nolen (sv_2mortal (newRV_inc (sv))));
522 }
523 else if (enc->flags & F_ALLOW_BLESSED)
524 encode_str (enc, "null", 4, 0);
525 else
526 croak ("encountered object '%s', but neither allow_blessed nor convert_blessed settings are enabled",
527 SvPV_nolen (sv_2mortal (newRV_inc (sv))));
528 }
529 }
467 if (svt == SVt_PVHV) 530 else if (svt == SVt_PVHV)
468 encode_hv (enc, (HV *)sv); 531 encode_hv (enc, (HV *)sv);
469 else if (svt == SVt_PVAV) 532 else if (svt == SVt_PVAV)
470 encode_av (enc, (AV *)sv); 533 encode_av (enc, (AV *)sv);
471 else if (svt < SVt_PVAV) 534 else if (svt < SVt_PVAV)
472 { 535 {
… …
960 if (*dec->cur == '}') 1023 if (*dec->cur == '}')
961 ++dec->cur; 1024 ++dec->cur;
962 else 1025 else
963 for (;;) 1026 for (;;)
964 { 1027 {
965 SV *key, *value;
966
967 decode_ws (dec); EXPECT_CH ('"'); 1028 decode_ws (dec); EXPECT_CH ('"');
968 1029
969 key = decode_str (dec); 1030 // heuristic: assume that
970 if (!key) 1031 // a) decode_str + hv_store_ent are abysmally slow
971 goto fail; 1032 // b) most hash keys are short, simple ascii text
1033 // so try to "fast-match" such strings to avoid
1034 // the overhead of hv_store_ent.
1035 {
1036 SV *value;
1037 char *p = dec->cur;
1038 char *e = p + 24; // only try up to 24 bytes
972 1039
973 decode_ws (dec); EXPECT_CH (':'); 1040 for (;;)
974
975 value = decode_sv (dec);
976 if (!value)
977 { 1041 {
1042 if (p == e || *p < 0x20 || *p >= 0x80 || *p == '\\')
1043 {
1044 // slow path, back up and use decode_str
1045 SV *key = decode_str (dec);
1046 if (!key)
1047 goto fail;
1048
1049 decode_ws (dec); EXPECT_CH (':');
1050
1051 value = decode_sv (dec);
1052 if (!value)
1053 {
1054 SvREFCNT_dec (key);
1055 goto fail;
1056 }
1057
1058 hv_store_ent (hv, key, value, 0);
978 SvREFCNT_dec (key); 1059 SvREFCNT_dec (key);
1060
1061 break;
1062 }
1063 else if (*p == '"')
1064 {
1065 // fast path, got a simple key
1066 char *key = dec->cur;
1067 int len = p - key;
1068 dec->cur = p + 1;
1069
1070 decode_ws (dec); EXPECT_CH (':');
1071
1072 value = decode_sv (dec);
1073 if (!value)
979 goto fail; 1074 goto fail;
1075
1076 hv_store (hv, key, len, value, 0);
1077
1078 break;
1079 }
1080
1081 ++p;
980 } 1082 }
981 1083 }
982 hv_store_ent (hv, key, value, 0);
983 SvREFCNT_dec (key);
984 1084
985 decode_ws (dec); 1085 decode_ws (dec);
986 1086
987 if (*dec->cur == '}') 1087 if (*dec->cur == '}')
988 { 1088 {
… …
1025 1125
1026 case 't': 1126 case 't':
1027 if (dec->end - dec->cur >= 4 && !memcmp (dec->cur, "true", 4)) 1127 if (dec->end - dec->cur >= 4 && !memcmp (dec->cur, "true", 4))
1028 { 1128 {
1029 dec->cur += 4; 1129 dec->cur += 4;
1030 return newSViv (1); 1130 return SvREFCNT_inc (json_true);
1031 } 1131 }
1032 else 1132 else
1033 ERR ("'true' expected"); 1133 ERR ("'true' expected");
1034 1134
1035 break; 1135 break;
1036 1136
1037 case 'f': 1137 case 'f':
1038 if (dec->end - dec->cur >= 5 && !memcmp (dec->cur, "false", 5)) 1138 if (dec->end - dec->cur >= 5 && !memcmp (dec->cur, "false", 5))
1039 { 1139 {
1040 dec->cur += 5; 1140 dec->cur += 5;
1041 return newSViv (0); 1141 return SvREFCNT_inc (json_false);
1042 } 1142 }
1043 else 1143 else
1044 ERR ("'false' expected"); 1144 ERR ("'false' expected");
1045 1145
1046 break; 1146 break;
… …
1073 SV *sv; 1173 SV *sv;
1074 1174
1075 SvGETMAGIC (string); 1175 SvGETMAGIC (string);
1076 SvUPGRADE (string, SVt_PV); 1176 SvUPGRADE (string, SVt_PV);
1077 1177
1178 if (flags & F_MAXSIZE && SvCUR (string) > DEC_SIZE (flags))
1179 croak ("attempted decode of JSON text of %lu bytes size, but max_size is set to %lu",
1180 (unsigned long)SvCUR (string), (unsigned long)DEC_SIZE (flags));
1181
1078 if (flags & F_UTF8) 1182 if (flags & F_UTF8)
1079 sv_utf8_downgrade (string, 0); 1183 sv_utf8_downgrade (string, 0);
1080 else 1184 else
1081 sv_utf8_upgrade (string); 1185 sv_utf8_upgrade (string);
1082 1186
… …
1156 i >= '0' && i <= '9' ? i - '0' 1260 i >= '0' && i <= '9' ? i - '0'
1157 : i >= 'a' && i <= 'f' ? i - 'a' + 10 1261 : i >= 'a' && i <= 'f' ? i - 'a' + 10
1158 : i >= 'A' && i <= 'F' ? i - 'A' + 10 1262 : i >= 'A' && i <= 'F' ? i - 'A' + 10
1159 : -1; 1263 : -1;
1160 1264
1161 json_stash = gv_stashpv ("JSON::XS", 1); 1265 json_stash = gv_stashpv ("JSON::XS" , 1);
1266 json_boolean_stash = gv_stashpv ("JSON::XS::Boolean", 1);
1267
1268 json_true = get_sv ("JSON::XS::true" , 1); SvREADONLY_on (json_true );
1269 json_false = get_sv ("JSON::XS::false", 1); SvREADONLY_on (json_false);
1162} 1270}
1163 1271
1164PROTOTYPES: DISABLE 1272PROTOTYPES: DISABLE
1165 1273
1166SV *new (char *dummy) 1274SV *new (char *dummy)
… …
1169 OUTPUT: 1277 OUTPUT:
1170 RETVAL 1278 RETVAL
1171 1279
1172SV *ascii (SV *self, int enable = 1) 1280SV *ascii (SV *self, int enable = 1)
1173 ALIAS: 1281 ALIAS:
1174 ascii = F_ASCII 1282 ascii = F_ASCII
1175 latin1 = F_LATIN1 1283 latin1 = F_LATIN1
1176 utf8 = F_UTF8 1284 utf8 = F_UTF8
1177 indent = F_INDENT 1285 indent = F_INDENT
1178 canonical = F_CANONICAL 1286 canonical = F_CANONICAL
1179 space_before = F_SPACE_BEFORE 1287 space_before = F_SPACE_BEFORE
1180 space_after = F_SPACE_AFTER 1288 space_after = F_SPACE_AFTER
1181 pretty = F_PRETTY 1289 pretty = F_PRETTY
1182 allow_nonref = F_ALLOW_NONREF 1290 allow_nonref = F_ALLOW_NONREF
1183 shrink = F_SHRINK 1291 shrink = F_SHRINK
1292 allow_blessed = F_ALLOW_BLESSED
1293 convert_blessed = F_CONV_BLESSED
1184 CODE: 1294 CODE:
1185{ 1295{
1186 UV *uv = SvJSON (self); 1296 UV *uv = SvJSON (self);
1187 if (enable) 1297 if (enable)
1188 *uv |= ix; 1298 *uv |= ix;
… …
1210 RETVAL = newSVsv (self); 1320 RETVAL = newSVsv (self);
1211} 1321}
1212 OUTPUT: 1322 OUTPUT:
1213 RETVAL 1323 RETVAL
1214 1324
1325SV *max_size (SV *self, UV max_size = 0)
1326 CODE:
1327{
1328 UV *uv = SvJSON (self);
1329 UV log2 = 0;
1330
1331 if (max_size > 0x80000000UL) max_size = 0x80000000UL;
1332 if (max_size == 1) max_size = 2;
1333
1334 while ((1UL << log2) < max_size)
1335 ++log2;
1336
1337 *uv = *uv & ~F_MAXSIZE | (log2 << S_MAXSIZE);
1338
1339 RETVAL = newSVsv (self);
1340}
1341 OUTPUT:
1342 RETVAL
1343
1215void encode (SV *self, SV *scalar) 1344void encode (SV *self, SV *scalar)
1216 PPCODE: 1345 PPCODE:
1217 XPUSHs (encode_json (scalar, *SvJSON (self))); 1346 XPUSHs (encode_json (scalar, *SvJSON (self)));
1218 1347
1219void decode (SV *self, SV *jsonstr) 1348void decode (SV *self, SV *jsonstr)

Diff Legend

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