sereal 0.0.2

data/ext/sereal/encode.c

@@ -0,0 +1,269 @@
+#include "sereal.h"
+#include "buffer.h"
+#include "encode.h"
+#include "snappy/csnappy_compress.c"
+
+#define W_SIZE 32
+#if T_FIXNUM > W_SIZE
+	#define W_SIZE T_FIXNUM
+#elif T_BIGNUM > W_SIZE
+	#define W_SIZE T_BIGNUM
+#elif T_FLOAT > W_SIZE
+	#define W_SIZE T_FLOAT
+#elif T_OBJECT > W_SIZE
+	#define W_SIZE T_OBJECT
+#elif T_REGEXP > W_SIZE
+	#define W_SIZE T_REGEXP
+#elif T_STRING > W_SIZE
+	#define W_SIZE T_STRING
+#elif T_ARRAY > W_SIZE
+	#define W_SIZE T_ARRAY
+#elif T_HASH > W_SIZE
+	#define W_SIZE T_HASH
+#elif T_SYMBOL > W_SIZE
+	#define W_SIZE T_SYMBOL
+#elif T_TRUE > W_SIZE
+	#define W_SIZE T_TRUE
+#elif T_FALSE > W_SIZE
+	#define W_SIZE T_FALSE
+#elif T_NIL > W_SIZE
+	#define W_SIZE T_NIL
+#endif
+
+/* function pointer array */
+void (*WRITER[W_SIZE])(sereal_t *,VALUE);
+
+static void rb_object_to_sereal(sereal_t *s, VALUE object);
+static void s_append_varint(sereal_t *s,u64 n);
+static void s_append_hdr_with_varint(sereal_t *s,u8 hdr, u64 n);
+static void s_append_zigzag(sereal_t *s,u64 n);
+static void s_append_string(sereal_t *s,u8 *string, u32 len,u8 is_utf8);
+static void s_append_rb_string(sereal_t *s, VALUE object);
+static void s_append_array(sereal_t *s, VALUE object);
+static void s_append_hash(sereal_t *s, VALUE object);
+static void s_append_symbol(sereal_t *s, VALUE object);
+static void s_append_object(sereal_t *s, VALUE object);
+static void s_append_regexp(sereal_t *s, VALUE object);
+static void s_append_integer(sereal_t *s, VALUE object);
+static void s_append_double(sereal_t *s, VALUE object);
+static void s_append_true(sereal_t *s, VALUE object);
+static void s_append_false(sereal_t *s, VALUE object);
+static void s_append_nil(sereal_t *s, VALUE object);
+static void s_default_writer(sereal_t *s, VALUE object);
+
+void s_init_writers(void) {
+        u32 i;
+        for (i = 0; i < sizeof(WRITER)/sizeof(WRITER[0]); i++) 
+                WRITER[i] = s_default_writer;
+        WRITER[T_FIXNUM] = s_append_integer;
+        WRITER[T_BIGNUM] = s_append_integer;
+        WRITER[T_FLOAT]  = s_append_double;
+        WRITER[T_OBJECT] = s_append_object;
+        WRITER[T_REGEXP] = s_append_regexp;
+        WRITER[T_STRING] = s_append_rb_string;
+        WRITER[T_ARRAY]  = s_append_array;
+        WRITER[T_HASH]   = s_append_hash;
+        WRITER[T_SYMBOL] = s_append_symbol;
+        WRITER[T_TRUE]   = s_append_true;
+        WRITER[T_FALSE]  = s_append_false;
+        WRITER[T_NIL]    = s_append_nil;
+}
+
+static void s_default_writer(sereal_t *s, VALUE object) {
+        rb_raise(rb_eTypeError, "invalid type for input %s",rb_obj_classname(object));
+}
+
+
+static inline void s_append_varint(sereal_t *s,u64 n) {
+        while (n >= 0x80) {
+                s_append_u8(s,((n & 0x7f) | 0x80));
+                n >>= 7; 
+        }
+        s_append_u8(s,n);
+}
+
+static inline void s_append_hdr_with_varint(sereal_t *s,u8 hdr, u64 n) {
+        s_append_u8(s,hdr);
+        s_append_varint(s,n);
+}
+
+static inline void s_append_zigzag(sereal_t *s,u64 n) {
+        s_append_hdr_with_varint(s,SRL_HDR_ZIGZAG,
+                                 (n << 1) ^ (n >> (sizeof(long) * 8 - 1)));
+}
+
+static inline void s_append_string(sereal_t *s,u8 *string, u32 len,u8 is_utf8) {
+        if (is_utf8) {
+                s_append_hdr_with_varint(s,SRL_HDR_STR_UTF8,len);
+        } else {
+                if (len < SRL_MASK_SHORT_BINARY_LEN) {
+                        s_append_u8(s,SRL_HDR_SHORT_BINARY_LOW | (u8)len);
+                } else {
+                        s_append_hdr_with_varint(s,SRL_HDR_BINARY,len); 
+                }
+        }
+        s_append(s,string,len);
+}
+
+static void s_append_rb_string(sereal_t *s, VALUE object) {
+        s_append_string(s,RSTRING_PTR(object),
+                        RSTRING_LEN(object),
+                        (is_ascii_string(object) ? FALSE : TRUE));
+}
+
+#define REF_THRESH(thresh,low,high)                     \
+do {                                                    \
+        if (len < (thresh))                             \
+                s_append_u8(s, low | (u8) len);         \
+        else                                            \
+                s_append_hdr_with_varint(s,high,len);   \
+} while(0);
+static void s_append_array(sereal_t *s, VALUE object) {
+        u32 i,len = RARRAY_LEN(object);
+        REF_THRESH(SRL_MASK_ARRAYREF_COUNT,SRL_HDR_ARRAYREF,SRL_HDR_ARRAY);
+        
+        for (i = 0; i < len; i++)
+                rb_object_to_sereal(s,rb_ary_entry(object,i));
+}
+
+
+int s_hash_foreach(VALUE key, VALUE value, VALUE sereal_t_object) {
+        if (key == Qundef)
+                return ST_CONTINUE;
+        rb_object_to_sereal((sereal_t *) sereal_t_object,key);
+        rb_object_to_sereal((sereal_t *) sereal_t_object,value);
+        return ST_CONTINUE;
+}
+static void s_append_hash(sereal_t *s, VALUE object) {
+        u32 len = RHASH_SIZE(object);
+        REF_THRESH(SRL_MASK_HASHREF_COUNT,SRL_HDR_HASHREF,SRL_HDR_HASH);
+        rb_hash_foreach(object, s_hash_foreach, (VALUE) s);
+}
+#undef REF_THRESH
+
+/* 
+	convert symbols to strings
+*/
+static void s_append_symbol(sereal_t *s, VALUE object) {
+	VALUE string = rb_sym_to_s(object);
+	s_append_rb_string(s,string);
+}
+
+/*
+	call object.to_srl and serialize the result
+*/
+static void s_append_object(sereal_t *s, VALUE object) {
+	rb_object_to_sereal(s,rb_funcall(object,rb_intern("to_srl"),0));
+}
+
+
+// <PATTERN-STR-TAG> <MODIFIERS-STR-TAG>
+static void s_append_regexp(sereal_t *s, VALUE object) {
+        s_append_u8(s,SRL_HDR_REGEXP);
+        rb_encoding *enc = rb_enc_get(object);
+	VALUE pattern;
+#ifndef RREGEXP_SRC_PTR
+	VALUE string = RREGEXP_SRC(object);
+	pattern = rb_enc_str_new(RSTRING_PTR(string),RSTRING_LEN(string),enc);
+#else
+        pattern = rb_enc_str_new(RREGEXP_SRC_PTR(object),RREGEXP_SRC_LEN(object), enc);
+#endif
+        s_append_rb_string(s,pattern);
+
+        int flags = rb_reg_options(object);
+        VALUE f = rb_str_new("",0);
+        if (flags & IGNORECASE) 
+                rb_str_cat(f,"i",1);
+        if (flags & EXTENDED)
+                rb_str_cat(f,"x",1);
+        if (flags & MULTILINE)
+                rb_str_cat(f,"m",1);
+        s_append_rb_string(s,f);
+}
+
+
+static void s_append_integer(sereal_t *s, VALUE object) {
+        long long v = FIXNUM_P(object) ? FIX2LONG(object) : rb_num2ll(object);
+        if (v >= 0) {
+                if (v < 16) 
+                        s_append_u8(s,SRL_HDR_POS_LOW | (u8) v);
+                else {
+                        if (!FIXNUM_P(object))
+                                s_append_hdr_with_varint(s,SRL_HDR_VARINT,NUM2ULL(object));
+                        else
+                                s_append_hdr_with_varint(s,SRL_HDR_VARINT,v);
+                }
+        } else {
+                if (v > -17)
+                        s_append_u8(s,SRL_HDR_NEG_LOW | ((u8) v + 32));
+                else
+                        s_append_zigzag(s,v);                        
+        }
+}
+static void s_append_double(sereal_t *s, VALUE object) {
+        double d = NUM2DBL(object);
+        s_append_u8(s,SRL_HDR_DOUBLE);
+        s_append(s,&d,sizeof(d));
+}
+static void s_append_true(sereal_t *s, VALUE object) {
+        s_append_u8(s,SRL_HDR_TRUE);
+}
+static void s_append_false(sereal_t *s, VALUE object) {
+        s_append_u8(s,SRL_HDR_FALSE);
+}
+static void s_append_nil(sereal_t *s, VALUE object) {
+        s_append_u8(s,SRL_HDR_UNDEF);
+}
+
+/* writer function pointers */
+static void rb_object_to_sereal(sereal_t *s, VALUE object) {
+        S_RECURSE_INC(s);
+        (*WRITER[TYPE(object)])(s,object);
+        S_RECURSE_DEC(s);
+}
+
+VALUE method_sereal_encode(VALUE self, VALUE args) {
+        sereal_t *s = s_create();
+        u32 argc = RARRAY_LEN(args);
+        if (argc < 1)
+                rb_raise(rb_eArgError,"need at least 1 argument (object)");
+        VALUE payload = rb_ary_shift(args);
+        VALUE compress = Qfalse;
+        if (argc == 2) 
+                compress = rb_ary_shift(args);
+        int do_compress = (compress == Qtrue ? TRUE : FALSE);
+
+        // setup header
+        s_append_u32(s,SRL_MAGIC_STRING_LILIPUTIAN);
+        s_append_u8(s,SRL_PROTOCOL_VERSION | (do_compress ? SRL_PROTOCOL_ENCODING_SNAPPY : SRL_PROTOCOL_ENCODING_RAW));
+        s_append_u8(s,0x0);
+        u32 s_header_len = s->pos;
+        
+        // serialize
+        rb_object_to_sereal(s,payload);
+
+        // compress
+        if (do_compress) {
+                u32 s_body_len = s->size - s_header_len;
+                u32 compressed_len = csnappy_max_compressed_length(s_body_len);
+
+                u8 *working_buf = alloc_or_raise(CSNAPPY_WORKMEM_BYTES);
+                u8 *compressed = alloc_or_raise(compressed_len + s_header_len);
+
+                COPY(s_get_p_at_pos(s,0,0),compressed,s_header_len);
+                
+                csnappy_compress(s_get_p_at_pos(s,s_header_len,1), 
+                                 s_body_len,
+                                 (compressed + s_header_len),
+                                 &compressed_len,
+                                 working_buf, 
+                                 CSNAPPY_WORKMEM_BYTES_POWER_OF_TWO);
+                free(s->data);
+                s->data = compressed;
+                s->size = compressed_len + s_header_len;
+        }
+
+        VALUE result = rb_str_new(s->data,s->size);
+        s_destroy(s);
+        return result;
+}

data/ext/sereal/encode.h

@@ -0,0 +1 @@
+void s_init_writers(void);

data/ext/sereal/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+have_func("rb_intern_str", ["ruby.h"])
+have_func("rb_sym_to_s", ["ruby.h"])
+
+extension_name = 'sereal'
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/sereal/proto.h

@@ -0,0 +1,73 @@
+#define SRL_MAGIC_STRING                "=srl"          /* Magic string for header. Every packet starts with this */
+#define SRL_MAGIC_STRING_LILIPUTIAN     0x6c72733d      /* SRL_MAGIC_STRING as a little endian integer */
+
+#define SRL_PROTOCOL_VERSION            ( 1 )           /* this is the first. for some reason we did not use 0 */
+#define SRL_PROTOCOL_VERSION_BITS       ( 4 )           /* how many bits we use for the version, the rest go to the encoding */
+#define SRL_PROTOCOL_VERSION_MASK       ( ( 1 << SRL_PROTOCOL_VERSION_BITS ) - 1 )
+
+#define SRL_PROTOCOL_ENCODING_MASK      ( ~SRL_PROTOCOL_VERSION_MASK )
+#define SRL_PROTOCOL_ENCODING_RAW       ( 0 << SRL_PROTOCOL_VERSION_BITS )
+#define SRL_PROTOCOL_ENCODING_SNAPPY    ( 1 << SRL_PROTOCOL_VERSION_BITS )
+
+#define SRL_HDR_POS             ((char)0)       /* small positive integer - value in low 4 bits (identity) */
+#define SRL_HDR_POS_LOW         ((char)0)       /* small positive integer - value in low 4 bits (identity) */
+#define SRL_HDR_POS_HIGH        ((char)15)      /* small positive integer - value in low 4 bits (identity) */
+
+#define SRL_HDR_NEG             ((char)16)      /* small negative integer - value in low 4 bits (k+32) */
+#define SRL_HDR_NEG_LOW         ((char)16)      /* small negative integer - value in low 4 bits (k+32) */
+#define SRL_HDR_NEG_HIGH        ((char)31)      /* small negative integer - value in low 4 bits (k+32) */
+
+#define SRL_HDR_VARINT          ((char)32)      /* <VARINT> - Varint variable length integer */
+#define SRL_HDR_ZIGZAG          ((char)33)      /* <ZIGZAG-VARINT> - Zigzag variable length integer */
+#define SRL_HDR_FLOAT           ((char)34)      /* <IEEE-FLOAT> */
+#define SRL_HDR_DOUBLE          ((char)35)      /* <IEEE-DOUBLE> */
+#define SRL_HDR_LONG_DOUBLE     ((char)36)      /* <IEEE-LONG-DOUBLE> */
+#define SRL_HDR_UNDEF           ((char)37)      /* None - Perl undef */
+#define SRL_HDR_BINARY          ((char)38)      /* <LEN-VARINT> <BYTES> - binary/(latin1) string */
+#define SRL_HDR_STR_UTF8        ((char)39)      /* <LEN-VARINT> <UTF8> - utf8 string */
+
+#define SRL_HDR_REFN            ((char)40)      /* <ITEM-TAG>    - ref to next item */
+#define SRL_HDR_REFP            ((char)41)      /* <OFFSET-VARINT> - ref to previous item stored at offset */
+#define SRL_HDR_HASH            ((char)42)      /* <COUNT-VARINT> [<KEY-TAG> <ITEM-TAG> ...] - count followed by key/value pairs */
+#define SRL_HDR_ARRAY           ((char)43)      /* <COUNT-VARINT> [<ITEM-TAG> ...] - count followed by items */
+#define SRL_HDR_OBJECT          ((char)44)      /* <STR-TAG> <ITEM-TAG> - class, object-item */
+#define SRL_HDR_OBJECTV         ((char)45)      /* <OFFSET-VARINT> <ITEM-TAG> - offset of previously used classname tag - object-item */
+#define SRL_HDR_ALIAS           ((char)46)      /* <OFFSET-VARINT> - alias to item defined at offset */
+#define SRL_HDR_COPY            ((char)47)      /* <OFFSET-VARINT> - copy of item defined at offset */
+
+#define SRL_HDR_WEAKEN          ((char)48)      /* <REF-TAG> - Weaken the following reference */
+#define SRL_HDR_REGEXP          ((char)49)      /* <PATTERN-STR-TAG> <MODIFIERS-STR-TAG>*/
+
+/* Note: Can do reserved check with a range now, but as we start using
+ *       them, might have to explicit == check later. */
+#define SRL_HDR_RESERVED        ((char)50)      /* reserved */
+#define SRL_HDR_RESERVED_LOW    ((char)50)
+#define SRL_HDR_RESERVED_HIGH   ((char)57)
+
+#define SRL_HDR_FALSE           ((char)58)      /* false (PL_sv_no)  */
+#define SRL_HDR_TRUE            ((char)59)      /* true  (PL_sv_yes) */
+
+#define SRL_HDR_MANY            ((char)60)      /* <LEN-VARINT> <TYPE-BYTE> <TAG-DATA> - repeated tag (not done yet, will be implemented in version 2) */
+#define SRL_HDR_PACKET_START    ((char)61)      /* (first byte of magic string in header) */
+
+
+#define SRL_HDR_EXTEND          ((char)62)      /* <BYTE> - for additional tags */
+#define SRL_HDR_PAD             ((char)63)      /* (ignored tag, skip to next byte) */
+#define SRL_HDR_ARRAYREF        ((char)64)      /* [<ITEM-TAG> ...] - count of items in low 4 bits (ARRAY must be refcnt=1)*/
+#define SRL_MASK_ARRAYREF_COUNT ((char)15)      /* mask to get low bits from tag */
+#define SRL_HDR_ARRAYREF_LOW    ((char)64)
+#define SRL_HDR_ARRAYREF_HIGH   ((char)79)
+
+
+#define SRL_HDR_HASHREF         ((char)80)      /* [<KEY-TAG> <ITEM-TAG> ...] - count in low 4 bits, key/value pairs (HASH must be refcnt=1)*/
+#define SRL_MASK_HASHREF_COUNT  ((char)15)      /* mask to get low bits from tag */
+#define SRL_HDR_HASHREF_LOW     ((char)80)
+#define SRL_HDR_HASHREF_HIGH    ((char)95)
+
+#define SRL_HDR_SHORT_BINARY    ((char)96)      /* <BYTES> - binary/latin1 string, length encoded in low 5 bits of tag */
+#define SRL_HDR_SHORT_BINARY_LOW       ((char)96)
+#define SRL_HDR_SHORT_BINARY_HIGH      ((char)127)
+#define SRL_MASK_SHORT_BINARY_LEN      ((char)31)      /* mask to get length of SRL_HDR_SHORT_BINARY type tags */
+
+#define SRL_HDR_TRACK_FLAG      ((char)128)         /* if this bit is set track the item */
+

data/ext/sereal/sereal.c

@@ -0,0 +1,12 @@
+#include "sereal.h"
+#include "encode.h"
+
+VALUE Sereal = Qnil;
+void Init_sereal();
+void Init_sereal() {
+        Sereal = rb_define_class("Sereal", rb_cObject);
+        rb_define_singleton_method(Sereal, "encode", method_sereal_encode, -2);
+        rb_define_singleton_method(Sereal, "decode", method_sereal_decode, -2);
+        s_init_writers();
+}
+

data/ext/sereal/sereal.h

@@ -0,0 +1,73 @@
+#ifndef _MAIN_H
+#define _MAIN_H
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/st.h>
+#include <string.h>     /* memcpy,memset */
+#include "proto.h"
+
+typedef unsigned long long      u64;
+typedef unsigned int            u32;
+typedef unsigned short          u16;
+typedef unsigned char           u8;
+typedef struct _sereal          sereal_t;
+typedef struct _track_entry     track_t;
+
+#define TRUE 1
+#define FALSE 0
+#define MAX_RECURSION_DEPTH 100
+#define COPY(src,dst,len) memcpy((dst),(src),len)
+#define ZERO(src,len) memset((src),0,len)
+
+#define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
+#define THRESH(x,min,max) ((x) >= (min) && (x) <= (max))
+
+#define IS_SHORT_BINARY(t) THRESH(t,SRL_HDR_SHORT_BINARY_LOW,SRL_HDR_SHORT_BINARY_HIGH)
+#define IS_ARRAYREF(t) THRESH(t,SRL_HDR_ARRAYREF_LOW,SRL_HDR_ARRAYREF_HIGH)
+#define IS_HASHREF(t) THRESH(t,SRL_HDR_HASHREF_LOW,SRL_HDR_HASHREF_HIGH)
+#define IS_STRING(t) ((t) == SRL_HDR_STR_UTF8 || (t) == SRL_HDR_BINARY || IS_SHORT_BINARY((t)))
+
+#define SRL_HDR_SYM SRL_HDR_RESERVED_LOW
+#define SRL_HDR_RB_OBJ (SRL_HDR_RESERVED_LOW+1)
+#define _D(fmt,arg...) fprintf(stderr,"%s(): " fmt "\n",__func__,##arg)
+
+#ifdef ONIGURUMA_H
+	#define IGNORECASE ONIG_OPTION_IGNORECASE
+	#define MULTILINE ONIG_OPTION_MULTILINE
+	#define EXTENDED ONIG_OPTION_EXTEND
+#else
+	#define IGNORECASE RE_OPTION_IGNORECASE
+	#define MULTILINE RE_OPTION_MULTILINE
+	#define EXTENDED RE_OPTION_EXTENDED
+#endif
+#define FLAG_SAFE 1
+struct _sereal {
+        u8 *data;
+        u32 size;
+        u32 pos;
+        u32 rsize;
+        u32 level;
+        u8 flags;
+};
+
+VALUE method_sereal_encode(VALUE self, VALUE args);
+VALUE method_sereal_decode(VALUE self, VALUE payload);
+
+#define S_RECURSE_INC(s)                                          \
+do {                                                              \
+        if((s)->level++ > MAX_RECURSION_DEPTH)                    \
+                rb_raise(rb_eArgError,                            \
+                         "max recursion depth reached: %d",       \
+                         MAX_RECURSION_DEPTH);                    \
+} while(0);
+
+#define S_RECURSE_DEC(s) ((s)->level--)
+
+#ifndef HAVE_RB_INTERN_STR
+#define rb_intern_str(string) SYM2ID(rb_str_intern(string))
+#endif
+#ifndef HAVE_RB_SYM_TO_S
+#define rb_sym_to_s(object) rb_funcall(object,rb_intern("to_s"),0)
+#endif
+
+#endif

data/ext/sereal/snappy/csnappy.h

@@ -0,0 +1,129 @@
+#ifndef __CSNAPPY_H__
+#define __CSNAPPY_H__
+/*
+File modified for the Linux Kernel by
+Zeev Tarantov <zeev.tarantov@gmail.com>
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CSNAPPY_VERSION	4
+
+#define CSNAPPY_WORKMEM_BYTES_POWER_OF_TWO 15
+#define CSNAPPY_WORKMEM_BYTES (1 << CSNAPPY_WORKMEM_BYTES_POWER_OF_TWO)
+
+#ifndef __GNUC__
+#define __attribute__(x) /*NOTHING*/
+#endif
+
+/*
+ * Returns the maximal size of the compressed representation of
+ * input data that is "source_len" bytes in length;
+ */
+uint32_t
+csnappy_max_compressed_length(uint32_t source_len) __attribute__((const));
+
+/*
+ * Flat array compression that does not emit the "uncompressed length"
+ * prefix. Compresses "input" array to the "output" array.
+ *
+ * REQUIRES: "input" is at most 32KiB long.
+ * REQUIRES: "output" points to an array of memory that is at least
+ * "csnappy_max_compressed_length(input_length)" in size.
+ * REQUIRES: working_memory has (1 << workmem_bytes_power_of_two) bytes.
+ * REQUIRES: 9 <= workmem_bytes_power_of_two <= 15.
+ *
+ * Returns an "end" pointer into "output" buffer.
+ * "end - output" is the compressed size of "input".
+ */
+char*
+csnappy_compress_fragment(
+	const char *input,
+	const uint32_t input_length,
+	char *output,
+	void *working_memory,
+	const int workmem_bytes_power_of_two);
+
+/*
+ * REQUIRES: "compressed" must point to an area of memory that is at
+ * least "csnappy_max_compressed_length(input_length)" bytes in length.
+ * REQUIRES: working_memory has (1 << workmem_bytes_power_of_two) bytes.
+ * REQUIRES: 9 <= workmem_bytes_power_of_two <= 15.
+ *
+ * Takes the data stored in "input[0..input_length-1]" and stores
+ * it in the array pointed to by "compressed".
+ *
+ * "*out_compressed_length" is set to the length of the compressed output.
+ */
+void
+csnappy_compress(
+	const char *input,
+	uint32_t input_length,
+	char *compressed,
+	uint32_t *out_compressed_length,
+	void *working_memory,
+	const int workmem_bytes_power_of_two);
+
+/*
+ * Reads header of compressed data to get stored length of uncompressed data.
+ * REQUIRES: start points to compressed data.
+ * REQUIRES: n is length of available compressed data.
+ *
+ * Returns SNAPPY_E_HEADER_BAD on error.
+ * Returns number of bytes read from input on success.
+ * Stores decoded length into *result.
+ */
+int
+csnappy_get_uncompressed_length(
+	const char *start,
+	uint32_t n,
+	uint32_t *result);
+
+/*
+ * Safely decompresses all data from array "src" of length "src_len" containing
+ * entire compressed stream (with header) into array "dst" of size "dst_len".
+ * REQUIRES: dst_len is at least csnappy_get_uncompressed_length(...).
+ *
+ * Iff successful, returns CSNAPPY_E_OK.
+ * If recorded length in header is greater than dst_len, returns
+ *  CSNAPPY_E_OUTPUT_INSUF.
+ * If compressed data is malformed, does not write more than dst_len into dst.
+ */
+int
+csnappy_decompress(
+	const char *src,
+	uint32_t src_len,
+	char *dst,
+	uint32_t dst_len);
+
+/*
+ * Safely decompresses stream src_len bytes long read from src to dst.
+ * Amount of available space at dst must be provided in *dst_len by caller.
+ * If compressed stream needs more space, it will not overflow and return
+ *  CSNAPPY_E_OUTPUT_OVERRUN.
+ * On success, sets *dst_len to actal number of bytes decompressed.
+ * Iff successful, returns CSNAPPY_E_OK.
+ */
+int
+csnappy_decompress_noheader(
+	const char *src,
+	uint32_t src_len,
+	char *dst,
+	uint32_t *dst_len);
+
+/*
+ * Return values (< 0 = Error)
+ */
+#define CSNAPPY_E_OK			0
+#define CSNAPPY_E_HEADER_BAD		(-1)
+#define CSNAPPY_E_OUTPUT_INSUF		(-2)
+#define CSNAPPY_E_OUTPUT_OVERRUN	(-3)
+#define CSNAPPY_E_INPUT_NOT_CONSUMED	(-4)
+#define CSNAPPY_E_DATA_MALFORMED	(-5)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif