github-migration/mongo-ruby-driver
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Get rid of "implicit conversion 64-bit 32-bit" warnings

Browse Source 
This resolves "warning: implicit conversion shortens 64-bit value into a 32-bit value"
The problem is String/Array length is a long (so 64 bits on some platforms instead of 32) and the extension use int
There are 2 solutions:
* use long everywhere (but waste of memory, and hard to do)
* cast into ints (but potential lost of data)
I did the second, because all these cases are about String/Array lengths,
and it is very unlikely to have a String/Array of more than 2 billions elements (that would mean at least 2GB in memory).

The last cast might need to be reviewed (htonl((int)time(NULL))) because htonl want a 32-bit int, but time(NULL) will overflow with the year 2038 problem.
This commit is contained in:
eregon 2010-12-30 22:30:00 +01:00 committed by Kyle Banker
parent 70bbb6f1fc
commit 3ab2acbf4f
1 changed files with 15 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
ext/cbson/cbson.c
View File

@ -104,13 +104,13 @@ static int max_bson_size;
/* MUST call TO_UTF8 before calling write_utf8. */ /* MUST call TO_UTF8 before calling write_utf8. */
#define TO_UTF8(string) rb_str_export_to_enc((string), rb_utf8_encoding()) #define TO_UTF8(string) rb_str_export_to_enc((string), rb_utf8_encoding())
static void write_utf8(buffer_t buffer, VALUE string, char check_null) { static void write_utf8(buffer_t buffer, VALUE string, char check_null) {
result_t status = check_string(RSTRING_PTR(string), RSTRING_LEN(string), result_t status = check_string(RSTRING_PTR(string), RSTRING_LENINT(string),
0, check_null); 0, check_null);
if (status == HAS_NULL) { if (status == HAS_NULL) {
buffer_free(buffer); buffer_free(buffer);
rb_raise(InvalidDocument, "Key names / regex patterns must not contain the NULL byte"); rb_raise(InvalidDocument, "Key names / regex patterns must not contain the NULL byte");
} }
SAFE_WRITE(buffer, RSTRING_PTR(string), RSTRING_LEN(string)); SAFE_WRITE(buffer, RSTRING_PTR(string), RSTRING_LENINT(string));
} }
#else #else
#define STR_NEW(p,n) rb_str_new((p), (n)) #define STR_NEW(p,n) rb_str_new((p), (n))
@ -257,7 +257,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
} else { } else {
int int_value; int int_value;
write_name_and_type(buffer, key, 0x10); write_name_and_type(buffer, key, 0x10);
int_value = ll_value; int_value = (int)ll_value;
SAFE_WRITE(buffer, (char*)&int_value, 4); SAFE_WRITE(buffer, (char*)&int_value, 4);
} }
break; break;
@ -307,7 +307,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c"); rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c");
} }
items = RARRAY_LEN(value); items = RARRAY_LENINT(value);
for(i = 0; i < items; i++) { for(i = 0; i < items; i++) {
char* name; char* name;
VALUE key; VALUE key;
@ -328,7 +328,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
int length; int length;
write_name_and_type(buffer, key, 0x02); write_name_and_type(buffer, key, 0x02);
value = TO_UTF8(value); value = TO_UTF8(value);
length = RSTRING_LEN(value) + 1; length = RSTRING_LENINT(value) + 1;
SAFE_WRITE(buffer, (char*)&length, 4); SAFE_WRITE(buffer, (char*)&length, 4);
write_utf8(buffer, value, 0); write_utf8(buffer, value, 0);
SAFE_WRITE(buffer, &zero, 1); SAFE_WRITE(buffer, &zero, 1);
@ -337,7 +337,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
case T_SYMBOL: case T_SYMBOL:
{ {
const char* str_value = rb_id2name(SYM2ID(value)); const char* str_value = rb_id2name(SYM2ID(value));
int length = strlen(str_value) + 1; int length = (int)strlen(str_value) + 1;
write_name_and_type(buffer, key, 0x0E); write_name_and_type(buffer, key, 0x0E);
SAFE_WRITE(buffer, (char*)&length, 4); SAFE_WRITE(buffer, (char*)&length, 4);
SAFE_WRITE(buffer, str_value, length); SAFE_WRITE(buffer, str_value, length);
@ -352,7 +352,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
const char subtype = strcmp(cls, "ByteBuffer") ? const char subtype = strcmp(cls, "ByteBuffer") ?
(const char)FIX2INT(rb_funcall(value, rb_intern("subtype"), 0)) : 2; (const char)FIX2INT(rb_funcall(value, rb_intern("subtype"), 0)) : 2;
VALUE string_data = rb_funcall(value, rb_intern("to_s"), 0); VALUE string_data = rb_funcall(value, rb_intern("to_s"), 0);
int length = RSTRING_LEN(string_data); int length = RSTRING_LENINT(string_data);
write_name_and_type(buffer, key, 0x05); write_name_and_type(buffer, key, 0x05);
if (subtype == 2) { if (subtype == 2) {
const int other_length = length + 4; const int other_length = length + 4;
@ -413,7 +413,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
} }
code_str = rb_funcall(value, rb_intern("code"), 0); code_str = rb_funcall(value, rb_intern("code"), 0);
length = RSTRING_LEN(code_str) + 1; length = RSTRING_LENINT(code_str) + 1;
SAFE_WRITE(buffer, (char*)&length, 4); SAFE_WRITE(buffer, (char*)&length, 4);
SAFE_WRITE(buffer, RSTRING_PTR(code_str), length - 1); SAFE_WRITE(buffer, RSTRING_PTR(code_str), length - 1);
SAFE_WRITE(buffer, &zero, 1); SAFE_WRITE(buffer, &zero, 1);
@ -493,7 +493,7 @@ static int write_element(VALUE key, VALUE value, VALUE extra, int allow_id) {
if (TYPE(has_extra) == T_TRUE) { if (TYPE(has_extra) == T_TRUE) {
VALUE extra = rb_funcall(value, rb_intern("extra_options_str"), 0); VALUE extra = rb_funcall(value, rb_intern("extra_options_str"), 0);
buffer_position old_position = buffer_get_position(buffer); buffer_position old_position = buffer_get_position(buffer);
SAFE_WRITE(buffer, RSTRING_PTR(extra), RSTRING_LEN(extra)); SAFE_WRITE(buffer, RSTRING_PTR(extra), RSTRING_LENINT(extra));
qsort(buffer_get_buffer(buffer) + old_position, RSTRING_LEN(extra), sizeof(char), cmp_char); qsort(buffer_get_buffer(buffer) + old_position, RSTRING_LEN(extra), sizeof(char), cmp_char);
} }
SAFE_WRITE(buffer, &zero, 1); SAFE_WRITE(buffer, &zero, 1);
@ -667,7 +667,7 @@ static VALUE get_value(const char* buffer, int* position, int type) {
value = rb_ary_new(); value = rb_ary_new();
while (*position < end) { while (*position < end) {
int type = (int)buffer[(*position)++]; int type = (int)buffer[(*position)++];
int key_size = strlen(buffer + *position); int key_size = (int)strlen(buffer + *position);
VALUE to_append; VALUE to_append;
*position += key_size + 1; // just skip the key, they're in order. *position += key_size + 1; // just skip the key, they're in order.
@ -731,13 +731,13 @@ static VALUE get_value(const char* buffer, int* position, int type) {
} }
case 11: case 11:
{ {
int pattern_length = strlen(buffer + *position); int pattern_length = (int)strlen(buffer + *position);
VALUE pattern = STR_NEW(buffer + *position, pattern_length); VALUE pattern = STR_NEW(buffer + *position, pattern_length);
int flags_length, flags = 0, i = 0; int flags_length, flags = 0, i = 0;
VALUE argv[3]; VALUE argv[3];
*position += pattern_length + 1; *position += pattern_length + 1;
flags_length = strlen(buffer + *position); flags_length = (int)strlen(buffer + *position);
for (i = 0; i < flags_length; i++) { for (i = 0; i < flags_length; i++) {
char flag = buffer[*position + i]; char flag = buffer[*position + i];
if (flag == 'i') { if (flag == 'i') {
@ -847,7 +847,7 @@ static VALUE elements_to_hash(const char* buffer, int max) {
int position = 0; int position = 0;
while (position < max) { while (position < max) {
int type = (int)buffer[position++]; int type = (int)buffer[position++];
int name_length = strlen(buffer + position); int name_length = (int)strlen(buffer + position);
VALUE name = STR_NEW(buffer + position, name_length); VALUE name = STR_NEW(buffer + position, name_length);
VALUE value; VALUE value;
position += name_length + 1; position += name_length + 1;
@ -859,7 +859,7 @@ static VALUE elements_to_hash(const char* buffer, int max) {
static VALUE method_deserialize(VALUE self, VALUE bson) { static VALUE method_deserialize(VALUE self, VALUE bson) {
const char* buffer = RSTRING_PTR(bson); const char* buffer = RSTRING_PTR(bson);
int remaining = RSTRING_LEN(bson); int remaining = RSTRING_LENINT(bson);
// NOTE we just swallow the size and end byte here // NOTE we just swallow the size and end byte here
buffer += 4; buffer += 4;
@ -876,7 +876,7 @@ static VALUE objectid_generate(VALUE self)
unsigned short pid; unsigned short pid;
int i; int i;
t = htonl(time(NULL)); t = htonl((int)time(NULL));
MEMCPY(&oid_bytes, &t, unsigned char, 4); MEMCPY(&oid_bytes, &t, unsigned char, 4);
MEMCPY(&oid_bytes[4], hostname_digest, unsigned char, 3); MEMCPY(&oid_bytes[4], hostname_digest, unsigned char, 3);