pg 1.0.0 → 1.5.9

data/ext/pg_coder.c

@@ -26,53 +26,111 @@ pg_coder_allocate( VALUE klass )
 void
 pg_coder_init_encoder( VALUE self )
 {
-	t_pg_coder *this = DATA_PTR( self );
+	t_pg_coder *this = RTYPEDDATA_DATA( self );
 	VALUE klass = rb_class_of(self);
 	if( rb_const_defined( klass, s_id_CFUNC ) ){
 		VALUE cfunc = rb_const_get( klass, s_id_CFUNC );
-		this->enc_func = DATA_PTR(cfunc);
+		this->enc_func = RTYPEDDATA_DATA(cfunc);
 	} else {
 		this->enc_func = NULL;
 	}
 	this->dec_func = NULL;
-	this->coder_obj = self;
+	RB_OBJ_WRITE(self, &this->coder_obj, self);
 	this->oid = 0;
 	this->format = 0;
+	this->flags = 0;
 	rb_iv_set( self, "@name", Qnil );
 }
 
 void
 pg_coder_init_decoder( VALUE self )
 {
-	t_pg_coder *this = DATA_PTR( self );
+	t_pg_coder *this = RTYPEDDATA_DATA( self );
 	VALUE klass = rb_class_of(self);
 	this->enc_func = NULL;
 	if( rb_const_defined( klass, s_id_CFUNC ) ){
 		VALUE cfunc = rb_const_get( klass, s_id_CFUNC );
-		this->dec_func = DATA_PTR(cfunc);
+		this->dec_func = RTYPEDDATA_DATA(cfunc);
 	} else {
 		this->dec_func = NULL;
 	}
-	this->coder_obj = self;
+	RB_OBJ_WRITE(self, &this->coder_obj, self);
 	this->oid = 0;
 	this->format = 0;
+	this->flags = 0;
 	rb_iv_set( self, "@name", Qnil );
 }
 
+static size_t
+pg_coder_memsize(const void *_this)
+{
+	const t_pg_coder *this = (const t_pg_coder *)_this;
+	return sizeof(*this);
+}
+
+static size_t
+pg_composite_coder_memsize(const void *_this)
+{
+	const t_pg_composite_coder *this = (const t_pg_composite_coder *)_this;
+	return sizeof(*this);
+}
+
+void
+pg_coder_compact(void *_this)
+{
+	t_pg_coder *this = (t_pg_coder *)_this;
+	pg_gc_location(this->coder_obj);
+}
+
+static void
+pg_composite_coder_compact(void *_this)
+{
+	t_pg_composite_coder *this = (t_pg_composite_coder *)_this;
+	pg_coder_compact(&this->comp);
+}
+
+const rb_data_type_t pg_coder_type = {
+	"PG::Coder",
+	{
+		(RUBY_DATA_FUNC) NULL,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_coder_memsize,
+		pg_compact_callback(pg_coder_compact),
+	},
+	0,
+	0,
+	// IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+	// macro to update VALUE references, as to trigger write barriers.
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
 static VALUE
 pg_simple_encoder_allocate( VALUE klass )
 {
 	t_pg_coder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_coder, NULL, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_coder, &pg_coder_type, this );
 	pg_coder_init_encoder( self );
 	return self;
 }
 
+static const rb_data_type_t pg_composite_coder_type = {
+	"PG::CompositeCoder",
+	{
+		(RUBY_DATA_FUNC) NULL,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_composite_coder_memsize,
+		pg_compact_callback(pg_composite_coder_compact),
+	},
+	&pg_coder_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
 static VALUE
 pg_composite_encoder_allocate( VALUE klass )
 {
 	t_pg_composite_coder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_composite_coder, NULL, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_composite_coder, &pg_composite_coder_type, this );
 	pg_coder_init_encoder( self );
 	this->elem = NULL;
 	this->needs_quotation = 1;
@@ -85,7 +143,7 @@ static VALUE
 pg_simple_decoder_allocate( VALUE klass )
 {
 	t_pg_coder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_coder, NULL, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_coder, &pg_coder_type, this );
 	pg_coder_init_decoder( self );
 	return self;
 }
@@ -94,7 +152,7 @@ static VALUE
 pg_composite_decoder_allocate( VALUE klass )
 {
 	t_pg_composite_coder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_composite_coder, NULL, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_composite_coder, &pg_composite_coder_type, this );
 	pg_coder_init_decoder( self );
 	this->elem = NULL;
 	this->needs_quotation = 1;
@@ -121,7 +179,7 @@ pg_coder_encode(int argc, VALUE *argv, VALUE self)
 	VALUE value;
 	int len, len2;
 	int enc_idx;
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 
 	if(argc < 1 || argc > 2){
 		rb_raise(rb_eArgError, "wrong number of arguments (%i for 1..2)", argc);
@@ -143,7 +201,6 @@ pg_coder_encode(int argc, VALUE *argv, VALUE self)
 
 	if( len == -1 ){
 		/* The intermediate value is a String that can be used directly. */
-		OBJ_INFECT(intermediate, value);
 		return intermediate;
 	}
 
@@ -155,7 +212,6 @@ pg_coder_encode(int argc, VALUE *argv, VALUE self)
 			rb_obj_classname( self ), len, len2 );
 	}
 	rb_str_set_len( res, len2 );
-	OBJ_INFECT(res, value);
 
 	RB_GC_GUARD(intermediate);
 
@@ -180,7 +236,7 @@ pg_coder_decode(int argc, VALUE *argv, VALUE self)
 	int tuple = -1;
 	int field = -1;
 	VALUE res;
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 
 	if(argc < 1 || argc > 3){
 		rb_raise(rb_eArgError, "wrong number of arguments (%i for 1..3)", argc);
@@ -192,13 +248,16 @@ pg_coder_decode(int argc, VALUE *argv, VALUE self)
 	if( NIL_P(argv[0]) )
 		return Qnil;
 
-	val = StringValuePtr(argv[0]);
+	if( this->format == 0 ){
+		val = StringValueCStr(argv[0]);
+	}else{
+		val = StringValuePtr(argv[0]);
+	}
 	if( !this->dec_func ){
 		rb_raise(rb_eRuntimeError, "no decoder function defined");
 	}
 
-	res = this->dec_func(this, val, RSTRING_LEN(argv[0]), tuple, field, ENCODING_GET(argv[0]));
-	OBJ_INFECT(res, argv[0]);
+	res = this->dec_func(this, val, RSTRING_LENINT(argv[0]), tuple, field, ENCODING_GET(argv[0]));
 
 	return res;
 }
@@ -215,7 +274,8 @@ pg_coder_decode(int argc, VALUE *argv, VALUE self)
 static VALUE
 pg_coder_oid_set(VALUE self, VALUE oid)
 {
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
+	rb_check_frozen(self);
 	this->oid = NUM2UINT(oid);
 	return oid;
 }
@@ -230,7 +290,7 @@ pg_coder_oid_set(VALUE self, VALUE oid)
 static VALUE
 pg_coder_oid_get(VALUE self)
 {
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 	return UINT2NUM(this->oid);
 }
 
@@ -246,7 +306,8 @@ pg_coder_oid_get(VALUE self)
 static VALUE
 pg_coder_format_set(VALUE self, VALUE format)
 {
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
+	rb_check_frozen(self);
 	this->format = NUM2INT(format);
 	return format;
 }
@@ -261,10 +322,41 @@ pg_coder_format_set(VALUE self, VALUE format)
 static VALUE
 pg_coder_format_get(VALUE self)
 {
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 	return INT2NUM(this->format);
 }
 
+/*
+ * call-seq:
+ *    coder.flags = Integer
+ *
+ * Set coder specific bitwise OR-ed flags.
+ * See the particular en- or decoder description for available flags.
+ *
+ * The default is +0+.
+ */
+static VALUE
+pg_coder_flags_set(VALUE self, VALUE flags)
+{
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
+	rb_check_frozen(self);
+	this->flags = NUM2INT(flags);
+	return flags;
+}
+
+/*
+ * call-seq:
+ *    coder.flags -> Integer
+ *
+ * Get current bitwise OR-ed coder flags.
+ */
+static VALUE
+pg_coder_flags_get(VALUE self)
+{
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
+	return INT2NUM(this->flags);
+}
+
 /*
  * call-seq:
  *    coder.needs_quotation = Boolean
@@ -278,7 +370,8 @@ pg_coder_format_get(VALUE self)
 static VALUE
 pg_coder_needs_quotation_set(VALUE self, VALUE needs_quotation)
 {
-	t_pg_composite_coder *this = DATA_PTR(self);
+	t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
+	rb_check_frozen(self);
 	this->needs_quotation = RTEST(needs_quotation);
 	return needs_quotation;
 }
@@ -293,7 +386,7 @@ pg_coder_needs_quotation_set(VALUE self, VALUE needs_quotation)
 static VALUE
 pg_coder_needs_quotation_get(VALUE self)
 {
-	t_pg_composite_coder *this = DATA_PTR(self);
+	t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
 	return this->needs_quotation ? Qtrue : Qfalse;
 }
 
@@ -308,7 +401,8 @@ pg_coder_needs_quotation_get(VALUE self)
 static VALUE
 pg_coder_delimiter_set(VALUE self, VALUE delimiter)
 {
-	t_pg_composite_coder *this = DATA_PTR(self);
+	t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
+	rb_check_frozen(self);
 	StringValue(delimiter);
 	if(RSTRING_LEN(delimiter) != 1)
 		rb_raise( rb_eArgError, "delimiter size must be one byte");
@@ -325,7 +419,7 @@ pg_coder_delimiter_set(VALUE self, VALUE delimiter)
 static VALUE
 pg_coder_delimiter_get(VALUE self)
 {
-	t_pg_composite_coder *this = DATA_PTR(self);
+	t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
 	return rb_str_new(&this->delimiter, 1);
 }
 
@@ -341,12 +435,13 @@ pg_coder_delimiter_get(VALUE self)
 static VALUE
 pg_coder_elements_type_set(VALUE self, VALUE elem_type)
 {
-	t_pg_composite_coder *this = DATA_PTR( self );
+	t_pg_composite_coder *this = RTYPEDDATA_DATA( self );
 
+	rb_check_frozen(self);
 	if ( NIL_P(elem_type) ){
 		this->elem = NULL;
 	} else if ( rb_obj_is_kind_of(elem_type, rb_cPG_Coder) ){
-		this->elem = DATA_PTR( elem_type );
+		this->elem = RTYPEDDATA_DATA( elem_type );
 	} else {
 		rb_raise( rb_eTypeError, "wrong elements type %s (expected some kind of PG::Coder)",
 				rb_obj_classname( elem_type ) );
@@ -356,17 +451,35 @@ pg_coder_elements_type_set(VALUE self, VALUE elem_type)
 	return elem_type;
 }
 
-void
+static const rb_data_type_t pg_coder_cfunc_type = {
+	"PG::Coder::CFUNC",
+	{
+		(RUBY_DATA_FUNC)NULL,
+		(RUBY_DATA_FUNC)NULL,
+		(size_t (*)(const void *))NULL,
+	},
+	0,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+VALUE
 pg_define_coder( const char *name, void *func, VALUE base_klass, VALUE nsp )
 {
-	VALUE cfunc_obj = Data_Wrap_Struct( rb_cObject, NULL, NULL, func );
+	VALUE cfunc_obj = TypedData_Wrap_Struct( rb_cObject, &pg_coder_cfunc_type, func );
 	VALUE coder_klass = rb_define_class_under( nsp, name, base_klass );
 	if( nsp==rb_mPG_BinaryEncoder || nsp==rb_mPG_BinaryDecoder )
 		rb_include_module( coder_klass, rb_mPG_BinaryFormatting );
 
-	rb_define_const( coder_klass, "CFUNC", cfunc_obj );
+	if( nsp==rb_mPG_BinaryEncoder || nsp==rb_mPG_TextEncoder )
+		rb_define_method( coder_klass, "encode", pg_coder_encode, -1 );
+	if( nsp==rb_mPG_BinaryDecoder || nsp==rb_mPG_TextDecoder )
+		rb_define_method( coder_klass, "decode", pg_coder_decode, -1 );
+
+	rb_define_const( coder_klass, "CFUNC", rb_obj_freeze(cfunc_obj) );
 
 	RB_GC_GUARD(cfunc_obj);
+	return coder_klass;
 }
 
 
@@ -403,14 +516,14 @@ pg_coder_enc_func(t_pg_coder *this)
 }
 
 static VALUE
-pg_text_dec_in_ruby(t_pg_coder *this, char *val, int len, int tuple, int field, int enc_idx)
+pg_text_dec_in_ruby(t_pg_coder *this, const char *val, int len, int tuple, int field, int enc_idx)
 {
 	VALUE string = pg_text_dec_string(this, val, len, tuple, field, enc_idx);
 	return rb_funcall( this->coder_obj, s_id_decode, 3, string, INT2NUM(tuple), INT2NUM(field) );
 }
 
 static VALUE
-pg_bin_dec_in_ruby(t_pg_coder *this, char *val, int len, int tuple, int field, int enc_idx)
+pg_bin_dec_in_ruby(t_pg_coder *this, const char *val, int len, int tuple, int field, int enc_idx)
 {
 	VALUE string = pg_bin_dec_bytea(this, val, len, tuple, field, enc_idx);
 	return rb_funcall( this->coder_obj, s_id_decode, 3, string, INT2NUM(tuple), INT2NUM(field) );
@@ -433,7 +546,7 @@ pg_coder_dec_func(t_pg_coder *this, int binary)
 
 
 void
-init_pg_coder()
+init_pg_coder(void)
 {
 	s_id_encode = rb_intern("encode");
 	s_id_decode = rb_intern("decode");
@@ -457,14 +570,25 @@ init_pg_coder()
 	rb_define_method( rb_cPG_Coder, "oid", pg_coder_oid_get, 0 );
 	rb_define_method( rb_cPG_Coder, "format=", pg_coder_format_set, 1 );
 	rb_define_method( rb_cPG_Coder, "format", pg_coder_format_get, 0 );
+	rb_define_method( rb_cPG_Coder, "flags=", pg_coder_flags_set, 1 );
+	rb_define_method( rb_cPG_Coder, "flags", pg_coder_flags_get, 0 );
+
+	/* define flags to be used with PG::Coder#flags= */
+	rb_define_const( rb_cPG_Coder, "TIMESTAMP_DB_UTC", INT2NUM(PG_CODER_TIMESTAMP_DB_UTC));
+	rb_define_const( rb_cPG_Coder, "TIMESTAMP_DB_LOCAL", INT2NUM(PG_CODER_TIMESTAMP_DB_LOCAL));
+	rb_define_const( rb_cPG_Coder, "TIMESTAMP_APP_UTC", INT2NUM(PG_CODER_TIMESTAMP_APP_UTC));
+	rb_define_const( rb_cPG_Coder, "TIMESTAMP_APP_LOCAL", INT2NUM(PG_CODER_TIMESTAMP_APP_LOCAL));
+	rb_define_const( rb_cPG_Coder, "FORMAT_ERROR_MASK", INT2NUM(PG_CODER_FORMAT_ERROR_MASK));
+	rb_define_const( rb_cPG_Coder, "FORMAT_ERROR_TO_RAISE", INT2NUM(PG_CODER_FORMAT_ERROR_TO_RAISE));
+	rb_define_const( rb_cPG_Coder, "FORMAT_ERROR_TO_STRING", INT2NUM(PG_CODER_FORMAT_ERROR_TO_STRING));
+	rb_define_const( rb_cPG_Coder, "FORMAT_ERROR_TO_PARTIAL", INT2NUM(PG_CODER_FORMAT_ERROR_TO_PARTIAL));
+
 	/*
 	 * Name of the coder or the corresponding data type.
 	 *
 	 * This accessor is only used in PG::Coder#inspect .
 	 */
 	rb_define_attr(   rb_cPG_Coder, "name", 1, 1 );
-	rb_define_method( rb_cPG_Coder, "encode", pg_coder_encode, -1 );
-	rb_define_method( rb_cPG_Coder, "decode", pg_coder_decode, -1 );
 
 	/* Document-class: PG::SimpleCoder < PG::Coder */
 	rb_cPG_SimpleCoder = rb_define_class_under( rb_mPG, "SimpleCoder", rb_cPG_Coder );