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

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.4 by root, Sat Oct 26 21:06:37 2013 UTC vs.
Revision 1.8 by root, Sun Oct 27 10:12:01 2013 UTC

…		…
9	#include <limits.h>	9	#include <limits.h>
10	#include <float.h>	10	#include <float.h>
11		11
12	#include "ecb.h"	12	#include "ecb.h"
13		13
		14	// known tags, rfc7049
		15	enum cbor_tag
		16	{
		17	CBOR_TAG_DATETIME = 0, // rfc4287, utf-8
		18	CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any
		19	CBOR_TAG_POS_BIGNUM = 2, // byte string
		20	CBOR_TAG_NEG_BIGNUM = 3, // byte string
		21	CBOR_TAG_DECIMAL = 4, // decimal fraction, array
		22	CBOR_TAG_BIGFLOAT = 5, // array
		23
		24	CBOR_TAG_CONV_B64U = 21, // base64url, any
		25	CBOR_TAG_CONV_B64 = 22, // base64, any
		26	CBOR_TAG_CONV_HEX = 23, // base16, any
		27	CBOR_TAG_CBOR = 24, // embedded cbor, byte string
		28
		29	CBOR_TAG_URI = 32, // URI rfc3986, utf-8
		30	CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8
		31	CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8
		32	CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8
		33	CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
		34
		35	CBOR_TAG_MAGIC = 55799
		36	};
		37
14	#define F_SHRINK 0x00000200UL	38	#define F_SHRINK 0x00000200UL
15	#define F_ALLOW_UNKNOWN 0x00002000UL	39	#define F_ALLOW_UNKNOWN 0x00002000UL
16		40
17	#define INIT_SIZE 32 // initial scalar size to be allocated	41	#define INIT_SIZE 32 // initial scalar size to be allocated
18		42
19	#define SB do {	43	#define SB do {
20	#define SE } while (0)	44	#define SE } while (0)
21
22	#if __GNUC__ >= 3
23	# define expect(expr,value) __builtin_expect ((expr), (value))
24	# define INLINE static inline
25	#else
26	# define expect(expr,value) (expr)
27	# define INLINE static
28	#endif
29
30	#define expect_false(expr) expect ((expr) != 0, 0)
31	#define expect_true(expr) expect ((expr) != 0, 1)
32		45
33	#define IN_RANGE_INC(type,val,beg,end) \	46	#define IN_RANGE_INC(type,val,beg,end) \
34	((unsigned type)((unsigned type)(val) - (unsigned type)(beg)) \	47	((unsigned type)((unsigned type)(val) - (unsigned type)(beg)) \
35	<= (unsigned type)((unsigned type)(end) - (unsigned type)(beg)))	48	<= (unsigned type)((unsigned type)(end) - (unsigned type)(beg)))
36		49
…		…
42	#else	55	#else
43	# define CBOR_SLOW 0	56	# define CBOR_SLOW 0
44	# define CBOR_STASH cbor_stash	57	# define CBOR_STASH cbor_stash
45	#endif	58	#endif
46		59
47	static HV cbor_stash, cbor_boolean_stash; // CBOR::XS::	60	static HV cbor_stash, cbor_boolean_stash, *cbor_tagged_stash; // CBOR::XS::
48	static SV cbor_true, cbor_false;	61	static SV cbor_true, cbor_false;
49		62
50	typedef struct {	63	typedef struct {
51	U32 flags;	64	U32 flags;
52	U32 max_depth;	65	U32 max_depth;
53	STRLEN max_size;	66	STRLEN max_size;
54
55	SV *cb_object;
56	HV *cb_sk_object;
57	} CBOR;	67	} CBOR;
58		68
59	INLINE void	69	ecb_inline void
60	cbor_init (CBOR *cbor)	70	cbor_init (CBOR *cbor)
61	{	71	{
62	Zero (cbor, 1, CBOR);	72	Zero (cbor, 1, CBOR);
63	cbor->max_depth = 512;	73	cbor->max_depth = 512;
64	}	74	}
65		75
66	/////////////////////////////////////////////////////////////////////////////	76	/////////////////////////////////////////////////////////////////////////////
67	// utility functions	77	// utility functions
68		78
69	INLINE SV *	79	ecb_inline SV *
70	get_bool (const char *name)	80	get_bool (const char *name)
71	{	81	{
72	SV *sv = get_sv (name, 1);	82	SV *sv = get_sv (name, 1);
73		83
74	SvREADONLY_on (sv);	84	SvREADONLY_on (sv);
75	SvREADONLY_on (SvRV (sv));	85	SvREADONLY_on (SvRV (sv));
76		86
77	return sv;	87	return sv;
78	}	88	}
79		89
80	INLINE void	90	ecb_inline void
81	shrink (SV *sv)	91	shrink (SV *sv)
82	{	92	{
83	sv_utf8_downgrade (sv, 1);	93	sv_utf8_downgrade (sv, 1);
84		94
85	if (SvLEN (sv) > SvCUR (sv) + 1)	95	if (SvLEN (sv) > SvCUR (sv) + 1)
…		…
108	SV *sv; // result scalar	118	SV *sv; // result scalar
109	CBOR cbor;	119	CBOR cbor;
110	U32 depth; // recursion level	120	U32 depth; // recursion level
111	} enc_t;	121	} enc_t;
112		122
113	INLINE void	123	ecb_inline void
114	need (enc_t *enc, STRLEN len)	124	need (enc_t *enc, STRLEN len)
115	{	125	{
116	if (expect_false (enc->cur + len >= enc->end))	126	if (ecb_expect_false (enc->cur + len >= enc->end))
117	{	127	{
118	STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);	128	STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);
119	SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);	129	SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);
120	enc->cur = SvPVX (enc->sv) + cur;	130	enc->cur = SvPVX (enc->sv) + cur;
121	enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;	131	enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;
122	}	132	}
123	}	133	}
124		134
125	INLINE void	135	ecb_inline void
126	encode_ch (enc_t *enc, char ch)	136	encode_ch (enc_t *enc, char ch)
127	{	137	{
128	need (enc, 1);	138	need (enc, 1);
129	*enc->cur++ = ch;	139	*enc->cur++ = ch;
130	}	140	}
…		…
224	if (HeKLEN (he) == HEf_SVKEY)	234	if (HeKLEN (he) == HEf_SVKEY)
225	encode_sv (enc, HeSVKEY (he));	235	encode_sv (enc, HeSVKEY (he));
226	else	236	else
227	encode_str (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));	237	encode_str (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));
228		238
229	encode_sv (enc, expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));	239	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
230	}	240	}
231		241
232	if (mg)	242	if (mg)
233	encode_ch (enc, 0xe0 \| 31);	243	encode_ch (enc, 0xe0 \| 31);
234		244
…		…
242	svtype svt;	252	svtype svt;
243		253
244	SvGETMAGIC (sv);	254	SvGETMAGIC (sv);
245	svt = SvTYPE (sv);	255	svt = SvTYPE (sv);
246		256
247	if (expect_false (SvOBJECT (sv)))	257	if (ecb_expect_false (SvOBJECT (sv)))
248	{	258	{
249	HV *stash = !CBOR_SLOW \|\| cbor_boolean_stash	259	HV *boolean_stash = !CBOR_SLOW \|\| cbor_boolean_stash
250	? cbor_boolean_stash	260	? cbor_boolean_stash
251	: gv_stashpv ("CBOR::XS::Boolean", 1);	261	: gv_stashpv ("CBOR::XS::Boolean", 1);
		262	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash
		263	? cbor_tagged_stash
		264	: gv_stashpv ("CBOR::XS::Tagged" , 1);
252		265
253	if (SvSTASH (sv) == stash)	266	if (SvSTASH (sv) == boolean_stash)
254	encode_ch (enc, SvIV (sv) ? 0xe0 \| 21 : 0xe0 \| 20);	267	encode_ch (enc, SvIV (sv) ? 0xe0 \| 21 : 0xe0 \| 20);
		268	else if (SvSTASH (sv) == tagged_stash)
		269	{
		270	if (svt != SVt_PVAV)
		271	croak ("encountered CBOR::XS::Tagged object that isn't an array");
		272
		273	encode_uint (enc, 0xc0, SvUV (av_fetch ((AV )sv, 0, 1)));
		274	encode_sv (enc, av_fetch ((AV )sv, 1, 1));
		275	}
255	else	276	else
256	{	277	{
257	#if 0 //TODO	278	// we re-bless the reference to get overload and other niceties right
258	if (enc->cbor.flags & F_CONV_BLESSED)	279	GV *to_cbor = gv_fetchmethod_autoload (SvSTASH (sv), "TO_CBOR", 0);
		280
		281	if (to_cbor)
259	{	282	{
260	// we re-bless the reference to get overload and other niceties right
261	GV *to_cbor = gv_fetchmethod_autoload (SvSTASH (sv), "TO_CBOR", 0);
262
263	if (to_cbor)
264	{
265	dSP;	283	dSP;
266		284
267	ENTER; SAVETMPS; PUSHMARK (SP);	285	ENTER; SAVETMPS; PUSHMARK (SP);
268	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), SvSTASH (sv)));	286	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), SvSTASH (sv)));
269		287
270	// calling with G_SCALAR ensures that we always get a 1 return value	288	// calling with G_SCALAR ensures that we always get a 1 return value
271	PUTBACK;	289	PUTBACK;
272	call_sv ((SV *)GvCV (to_cbor), G_SCALAR);	290	call_sv ((SV *)GvCV (to_cbor), G_SCALAR);
273	SPAGAIN;	291	SPAGAIN;
274		292
275	// catch this surprisingly common error	293	// catch this surprisingly common error
276	if (SvROK (TOPs) && SvRV (TOPs) == sv)	294	if (SvROK (TOPs) && SvRV (TOPs) == sv)
277	croak ("%s::TO_CBOR method returned same object as was passed instead of a new one", HvNAME (SvSTASH (sv)));	295	croak ("%s::TO_CBOR method returned same object as was passed instead of a new one", HvNAME (SvSTASH (sv)));
278		296
279	sv = POPs;	297	sv = POPs;
280	PUTBACK;	298	PUTBACK;
281		299
282	encode_sv (enc, sv);	300	encode_sv (enc, sv);
283		301
284	FREETMPS; LEAVE;	302	FREETMPS; LEAVE;
285	}
286	else if (enc->cbor.flags & F_ALLOW_BLESSED)
287	encode_str (enc, "null", 4, 0);
288	else
289	croak ("encountered object '%s', but neither allow_blessed enabled nor TO_CBOR method available on it",
290	SvPV_nolen (sv_2mortal (newRV_inc (sv))));
291	}	303	}
292	else if (enc->cbor.flags & F_ALLOW_BLESSED)
293	encode_str (enc, "null", 4, 0);
294	else	304	else
295	croak ("encountered object '%s', but neither allow_blessed nor convert_blessed settings are enabled",	305	croak ("encountered object '%s', but no TO_CBOR method available on it",
296	SvPV_nolen (sv_2mortal (newRV_inc (sv))));	306	SvPV_nolen (sv_2mortal (newRV_inc (sv))));
297	#endif
298	}	307	}
299	}	308	}
300	else if (svt == SVt_PVHV)	309	else if (svt == SVt_PVHV)
301	encode_hv (enc, (HV *)sv);	310	encode_hv (enc, (HV *)sv);
302	else if (svt == SVt_PVAV)	311	else if (svt == SVt_PVAV)
…		…
328	{	337	{
329	double nv = SvNVX (sv);	338	double nv = SvNVX (sv);
330		339
331	need (enc, 9);	340	need (enc, 9);
332		341
333	if (expect_false (nv == (U32)nv))	342	if (ecb_expect_false (nv == (U32)nv))
334	encode_uint (enc, 0x00, (U32)nv);	343	encode_uint (enc, 0x00, (U32)nv);
335	//TODO: maybe I32?	344	//TODO: maybe I32?
336	else if (expect_false (nv == (float)nv))	345	else if (ecb_expect_false (nv == (float)nv))
337	{	346	{
338	uint32_t fp = ecb_float_to_binary32 (nv);	347	uint32_t fp = ecb_float_to_binary32 (nv);
339		348
340	*enc->cur++ = 0xe0 \| 26;	349	*enc->cur++ = 0xe0 \| 26;
341		350
…		…
429	U32 maxdepth; // recursion depth limit	438	U32 maxdepth; // recursion depth limit
430	} dec_t;	439	} dec_t;
431		440
432	#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE	441	#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE
433		442
434	#define WANT(len) if (expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data");	443	#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data")
435		444
436	#define DEC_INC_DEPTH if (++dec->depth > dec->cbor.max_depth) ERR (ERR_NESTING_EXCEEDED)	445	#define DEC_INC_DEPTH if (++dec->depth > dec->cbor.max_depth) ERR (ERR_NESTING_EXCEEDED)
437	#define DEC_DEC_DEPTH --dec->depth	446	#define DEC_DEC_DEPTH --dec->depth
438		447
439	static UV	448	static UV
…		…
571	}	580	}
572		581
573	DEC_DEC_DEPTH;	582	DEC_DEC_DEPTH;
574	return newRV_noinc ((SV *)hv);	583	return newRV_noinc ((SV *)hv);
575		584
576	#if 0
577	SV *sv;
578	HV *hv = newHV ();
579
580	DEC_INC_DEPTH;
581	decode_ws (dec);
582
583	for (;;)
584	{
585	// heuristic: assume that
586	// a) decode_str + hv_store_ent are abysmally slow.
587	// b) most hash keys are short, simple ascii text.
588	// => try to "fast-match" such strings to avoid
589	// the overhead of decode_str + hv_store_ent.
590	{
591	SV *value;
592	char *p = dec->cur;
593	char *e = p + 24; // only try up to 24 bytes
594
595	for (;;)
596	{
597	// the >= 0x80 is false on most architectures
598	if (p == e \|\| p < 0x20 \|\| p >= 0x80 \|\| *p == '\\')
599	{
600	// slow path, back up and use decode_str
601	SV *key = decode_str (dec);
602	if (!key)
603	goto fail;
604
605	decode_ws (dec); EXPECT_CH (':');
606
607	decode_ws (dec);
608	value = decode_sv (dec);
609	if (!value)
610	{
611	SvREFCNT_dec (key);
612	goto fail;
613	}
614
615	hv_store_ent (hv, key, value, 0);
616	SvREFCNT_dec (key);
617
618	break;
619	}
620	else if (*p == '"')
621	{
622	// fast path, got a simple key
623	char *key = dec->cur;
624	int len = p - key;
625	dec->cur = p + 1;
626
627	decode_ws (dec); EXPECT_CH (':');
628
629	decode_ws (dec);
630	value = decode_sv (dec);
631	if (!value)
632	goto fail;
633
634	hv_store (hv, key, len, value, 0);
635
636	break;
637	}
638
639	++p;
640	}
641	}
642
643	decode_ws (dec);
644
645	if (*dec->cur == '}')
646	{
647	++dec->cur;
648	break;
649	}
650
651	if (*dec->cur != ',')
652	ERR (", or } expected while parsing object/hash");
653
654	++dec->cur;
655
656	decode_ws (dec);
657
658	if (*dec->cur == '}' && dec->cbor.flags & F_RELAXED)
659	{
660	++dec->cur;
661	break;
662	}
663	}
664
665	DEC_DEC_DEPTH;
666	sv = newRV_noinc ((SV *)hv);
667
668	// check filter callbacks
669	if (dec->cbor.flags & F_HOOK)
670	{
671	if (dec->cbor.cb_sk_object && HvKEYS (hv) == 1)
672	{
673	HE cb, he;
674
675	hv_iterinit (hv);
676	he = hv_iternext (hv);
677	hv_iterinit (hv);
678
679	// the next line creates a mortal sv each time its called.
680	// might want to optimise this for common cases.
681	cb = hv_fetch_ent (dec->cbor.cb_sk_object, hv_iterkeysv (he), 0, 0);
682
683	if (cb)
684	{
685	dSP;
686	int count;
687
688	ENTER; SAVETMPS; PUSHMARK (SP);
689	XPUSHs (HeVAL (he));
690	sv_2mortal (sv);
691
692	PUTBACK; count = call_sv (HeVAL (cb), G_ARRAY); SPAGAIN;
693
694	if (count == 1)
695	{
696	sv = newSVsv (POPs);
697	FREETMPS; LEAVE;
698	return sv;
699	}
700
701	SvREFCNT_inc (sv);
702	FREETMPS; LEAVE;
703	}
704	}
705
706	if (dec->cbor.cb_object)
707	{
708	dSP;
709	int count;
710
711	ENTER; SAVETMPS; PUSHMARK (SP);
712	XPUSHs (sv_2mortal (sv));
713
714	PUTBACK; count = call_sv (dec->cbor.cb_object, G_ARRAY); SPAGAIN;
715
716	if (count == 1)
717	{
718	sv = newSVsv (POPs);
719	FREETMPS; LEAVE;
720	return sv;
721	}
722
723	SvREFCNT_inc (sv);
724	FREETMPS; LEAVE;
725	}
726	}
727
728	return sv;
729	#endif
730
731	fail:	585	fail:
732	SvREFCNT_dec (hv);	586	SvREFCNT_dec (hv);
733	DEC_DEC_DEPTH;	587	DEC_DEC_DEPTH;
734	return &PL_sv_undef;	588	return &PL_sv_undef;
735	}	589	}
736		590
737	static SV *	591	static SV *
738	decode_str (dec_t *dec, int utf8)	592	decode_str (dec_t *dec, int utf8)
739	{	593	{
740	SV *sv;	594	SV *sv = 0;
741		595
742	if ((*dec->cur & 31) == 31)	596	if ((*dec->cur & 31) == 31)
743	{	597	{
744	++dec->cur;	598	++dec->cur;
745		599
…		…
754	{	608	{
755	++dec->cur;	609	++dec->cur;
756	break;	610	break;
757	}	611	}
758		612
759	SV *sv2 = decode_sv (dec);
760	sv_catsv (sv, sv2);	613	sv_catsv (sv, decode_sv (dec));
761	}	614	}
762	}	615	}
763	else	616	else
764	{	617	{
765	STRLEN len = decode_uint (dec);	618	STRLEN len = decode_uint (dec);
…		…
773	SvUTF8_on (sv);	626	SvUTF8_on (sv);
774		627
775	return sv;	628	return sv;
776		629
777	fail:	630	fail:
		631	SvREFCNT_dec (sv);
778	return &PL_sv_undef;	632	return &PL_sv_undef;
779	}	633	}
780		634
781	static SV *	635	static SV *
782	decode_tagged (dec_t *dec)	636	decode_tagged (dec_t *dec)
783	{	637	{
784	UV tag = decode_uint (dec);	638	UV tag = decode_uint (dec);
785	SV *sv = decode_sv (dec);	639	SV *sv = decode_sv (dec);
786		640
787	if (tag == 55799) // 2.4.5 Self-Describe CBOR	641	if (tag == CBOR_TAG_MAGIC) // 2.4.5 Self-Describe CBOR
788	return sv;	642	return sv;
789		643
790	AV *av = newAV ();	644	AV *av = newAV ();
791	av_push (av, newSVuv (tag));	645	av_push (av, newSVuv (tag));
792	av_push (av, sv);	646	av_push (av, sv);
793	return newRV_noinc ((SV *)av);	647
		648	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash
		649	? cbor_tagged_stash
		650	: gv_stashpv ("CBOR::XS::Tagged" , 1);
		651
		652	return sv_bless (newRV_noinc ((SV *)av), tagged_stash);
794	}	653	}
795		654
796	static SV *	655	static SV *
797	decode_sv (dec_t *dec)	656	decode_sv (dec_t *dec)
798	{	657	{
799	WANT (1);	658	WANT (1);
800		659
801	switch (*dec->cur >> 5)	660	switch (*dec->cur >> 5)
802	{	661	{
803	case 0: // unsigned int	662	case 0: // unsigned int
804	//TODO: 64 bit values on 3 2bit perls
805	return newSVuv (decode_uint (dec));	663	return newSVuv (decode_uint (dec));
806	case 1: // negative int	664	case 1: // negative int
807	return newSViv (-1 - (IV)decode_uint (dec));	665	return newSViv (-1 - (IV)decode_uint (dec));
808	case 2: // octet string	666	case 2: // octet string
809	return decode_str (dec, 0);	667	return decode_str (dec, 0);
…		…
873	ERR ("corrupted CBOR data (reserved/unassigned major 7 value)");	731	ERR ("corrupted CBOR data (reserved/unassigned major 7 value)");
874	}	732	}
875		733
876	break;	734	break;
877	}	735	}
878	#if 0
879	switch (*dec->cur)
880	{
881	//case '"': ++dec->cur; return decode_str (dec);
882	case '[': ++dec->cur; return decode_av (dec);
883	case '{': ++dec->cur; return decode_hv (dec);
884
885	case '-':
886	case '0': case '1': case '2': case '3': case '4':
887	case '5': case '6': case '7': case '8': case '9':
888	//TODO return decode_num (dec);
889
890	case 't':
891	if (dec->end - dec->cur >= 4 && !memcmp (dec->cur, "true", 4))
892	{
893	dec->cur += 4;
894	#if CBOR_SLOW
895	cbor_true = get_bool ("CBOR::XS::true");
896	#endif
897	return newSVsv (cbor_true);
898	}
899	else
900	ERR ("'true' expected");
901
902	break;
903
904	case 'f':
905	if (dec->end - dec->cur >= 5 && !memcmp (dec->cur, "false", 5))
906	{
907	dec->cur += 5;
908	#if CBOR_SLOW
909	cbor_false = get_bool ("CBOR::XS::false");
910	#endif
911	return newSVsv (cbor_false);
912	}
913	else
914	ERR ("'false' expected");
915
916	break;
917
918	case 'n':
919	if (dec->end - dec->cur >= 4 && !memcmp (dec->cur, "null", 4))
920	{
921	dec->cur += 4;
922	return newSVsv (&PL_sv_undef);
923	}
924	else
925	ERR ("'null' expected");
926
927	break;
928
929	default:
930	ERR ("malformed CBOR string, neither array, object, number, string or atom");
931	break;
932	}
933	#endif
934		736
935	fail:	737	fail:
936	return &PL_sv_undef;	738	return &PL_sv_undef;
937	}	739	}
938		740
…		…
981	dec.cur = (U8 *)SvPVX (string);	783	dec.cur = (U8 *)SvPVX (string);
982	dec.end = (U8 *)SvEND (string);	784	dec.end = (U8 *)SvEND (string);
983	dec.err = 0;	785	dec.err = 0;
984	dec.depth = 0;	786	dec.depth = 0;
985		787
986	if (dec.cbor.cb_object \|\| dec.cbor.cb_sk_object)
987	;//TODO dec.cbor.flags \|= F_HOOK;
988
989	sv = decode_sv (&dec);	788	sv = decode_sv (&dec);
990		789
991	if (offset_return)	790	if (offset_return)
992	*offset_return = dec.cur;	791	*offset_return = dec.cur;
993		792
…		…
1013		812
1014	BOOT:	813	BOOT:
1015	{	814	{
1016	cbor_stash = gv_stashpv ("CBOR::XS" , 1);	815	cbor_stash = gv_stashpv ("CBOR::XS" , 1);
1017	cbor_boolean_stash = gv_stashpv ("CBOR::XS::Boolean", 1);	816	cbor_boolean_stash = gv_stashpv ("CBOR::XS::Boolean", 1);
		817	cbor_tagged_stash = gv_stashpv ("CBOR::XS::Tagged" , 1);
1018		818
1019	cbor_true = get_bool ("CBOR::XS::true");	819	cbor_true = get_bool ("CBOR::XS::true");
1020	cbor_false = get_bool ("CBOR::XS::false");	820	cbor_false = get_bool ("CBOR::XS::false");
1021	}	821	}
1022		822
…		…
1024		824
1025	void CLONE (...)	825	void CLONE (...)
1026	CODE:	826	CODE:
1027	cbor_stash = 0;	827	cbor_stash = 0;
1028	cbor_boolean_stash = 0;	828	cbor_boolean_stash = 0;
		829	cbor_tagged_stash = 0;
1029		830
1030	void new (char *klass)	831	void new (char *klass)
1031	PPCODE:	832	PPCODE:
1032	{	833	{
1033	SV *pv = NEWSV (0, sizeof (CBOR));	834	SV *pv = NEWSV (0, sizeof (CBOR));
…		…
1136	EXTEND (SP, 2);	937	EXTEND (SP, 2);
1137	PUSHs (sv);	938	PUSHs (sv);
1138	PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));	939	PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1139	}	940	}
1140		941
		942	#if 0
		943
1141	void DESTROY (CBOR *self)	944	void DESTROY (CBOR *self)
1142	CODE:	945	CODE:
1143	SvREFCNT_dec (self->cb_sk_object);	946	SvREFCNT_dec (self->cb_sk_object);
1144	SvREFCNT_dec (self->cb_object);	947	SvREFCNT_dec (self->cb_object);
1145		948
		949	#endif
		950
1146	PROTOTYPES: ENABLE	951	PROTOTYPES: ENABLE
1147		952
1148	void encode_cbor (SV *scalar)	953	void encode_cbor (SV *scalar)
1149	PPCODE:	954	PPCODE:
1150	{	955	{

Diff Legend

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

Comparing CBOR-XS/XS.xs (file contents): Revision 1.4 by root, Sat Oct 26 21:06:37 2013 UTC vs. Revision 1.8 by root, Sun Oct 27 10:12:01 2013 UTC

Diff Legend

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.4 by root, Sat Oct 26 21:06:37 2013 UTC vs.
Revision 1.8 by root, Sun Oct 27 10:12:01 2013 UTC