From a7d108593c8372b8f3ce1928d15804c19ef0fc19 Mon Sep 17 00:00:00 2001 From: jacob1 Date: Sun, 14 Aug 2016 18:23:45 -0400 Subject: [PATCH] convert spaces in BSON lib to tabs --- src/bson/BSON.cpp | 1308 ++++++++++++++++++++++----------------------- src/bson/BSON.h | 342 ++++++------ 2 files changed, 825 insertions(+), 825 deletions(-) diff --git a/src/bson/BSON.cpp b/src/bson/BSON.cpp index 7fd11c8396..45f689721d 100644 --- a/src/bson/BSON.cpp +++ b/src/bson/BSON.cpp @@ -48,248 +48,248 @@ static int ( *oid_inc_func )( void ) = NULL; ------------------------------ */ bson *bson_empty( bson *obj ) { - static char data[] = "\005\0\0\0\0"; - bson_init_data( obj, data ); - obj->finished = 1; - obj->err = 0; - obj->stackPos = 0; - return obj; + static char data[] = "\005\0\0\0\0"; + bson_init_data( obj, data ); + obj->finished = 1; + obj->err = 0; + obj->stackPos = 0; + return obj; } int bson_copy( bson *out, const bson *in ) { - if ( !out ) return BSON_ERROR; - if ( !in->finished ) return BSON_ERROR; - bson_init_size( out, bson_size( in ) ); - memcpy( out->data, in->data, bson_size( in ) ); - out->finished = 1; + if ( !out ) return BSON_ERROR; + if ( !in->finished ) return BSON_ERROR; + bson_init_size( out, bson_size( in ) ); + memcpy( out->data, in->data, bson_size( in ) ); + out->finished = 1; - return BSON_OK; + return BSON_OK; } int bson_init_data( bson *b, char *data ) { - b->data = data; + b->data = data; b->dataSize = INT_MAX; // no overflow detection for bson_iterator_next - return BSON_OK; + return BSON_OK; } int bson_init_data_size( bson *b, char *data, int size ) { - b->data = data; + b->data = data; b->dataSize = size; // used for overflow detection for bson_iterator_next - return BSON_OK; + return BSON_OK; } int bson_init_finished_data( bson *b, char *data ) { - bson_init_data( b, data ); - b->stackPos = 0; - b->finished = 1; - return BSON_OK; + bson_init_data( b, data ); + b->stackPos = 0; + b->finished = 1; + return BSON_OK; } static void _bson_reset( bson *b ) { - b->finished = 0; - b->stackPos = 0; - b->err = 0; - b->errstr = NULL; + b->finished = 0; + b->stackPos = 0; + b->err = 0; + b->errstr = NULL; } int bson_size( const bson *b ) { - int i; - if ( ! b || ! b->data ) - return 0; - bson_little_endian32( &i, b->data ); - return i; + int i; + if ( ! b || ! b->data ) + return 0; + bson_little_endian32( &i, b->data ); + return i; } const char *bson_data( bson *b ) { - return (const char *)b->data; + return (const char *)b->data; } static char hexbyte( char hex ) { - switch ( hex ) { - case '0': - return 0x0; - case '1': - return 0x1; - case '2': - return 0x2; - case '3': - return 0x3; - case '4': - return 0x4; - case '5': - return 0x5; - case '6': - return 0x6; - case '7': - return 0x7; - case '8': - return 0x8; - case '9': - return 0x9; - case 'a': - case 'A': - return 0xa; - case 'b': - case 'B': - return 0xb; - case 'c': - case 'C': - return 0xc; - case 'd': - case 'D': - return 0xd; - case 'e': - case 'E': - return 0xe; - case 'f': - case 'F': - return 0xf; - default: - return 0x0; /* something smarter? */ - } + switch ( hex ) { + case '0': + return 0x0; + case '1': + return 0x1; + case '2': + return 0x2; + case '3': + return 0x3; + case '4': + return 0x4; + case '5': + return 0x5; + case '6': + return 0x6; + case '7': + return 0x7; + case '8': + return 0x8; + case '9': + return 0x9; + case 'a': + case 'A': + return 0xa; + case 'b': + case 'B': + return 0xb; + case 'c': + case 'C': + return 0xc; + case 'd': + case 'D': + return 0xd; + case 'e': + case 'E': + return 0xe; + case 'f': + case 'F': + return 0xf; + default: + return 0x0; /* something smarter? */ + } } void bson_oid_from_string( bson_oid_t *oid, const char *str ) { - int i; - for ( i=0; i<12; i++ ) { - oid->bytes[i] = ( hexbyte( str[2*i] ) << 4 ) | hexbyte( str[2*i + 1] ); - } + int i; + for ( i=0; i<12; i++ ) { + oid->bytes[i] = ( hexbyte( str[2*i] ) << 4 ) | hexbyte( str[2*i + 1] ); + } } void bson_oid_to_string( const bson_oid_t *oid, char *str ) { - static const char hex[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}; - int i; - for ( i=0; i<12; i++ ) { - str[2*i] = hex[( oid->bytes[i] & 0xf0 ) >> 4]; - str[2*i + 1] = hex[ oid->bytes[i] & 0x0f ]; - } - str[24] = '\0'; + static const char hex[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}; + int i; + for ( i=0; i<12; i++ ) { + str[2*i] = hex[( oid->bytes[i] & 0xf0 ) >> 4]; + str[2*i + 1] = hex[ oid->bytes[i] & 0x0f ]; + } + str[24] = '\0'; } void bson_set_oid_fuzz( int ( *func )( void ) ) { - oid_fuzz_func = func; + oid_fuzz_func = func; } void bson_set_oid_inc( int ( *func )( void ) ) { - oid_inc_func = func; + oid_inc_func = func; } void bson_oid_gen( bson_oid_t *oid ) { - static int incr = 0; - static int fuzz = 0; - int i; - int t = time( NULL ); - - if( oid_inc_func ) - i = oid_inc_func(); - else - i = incr++; - - if ( !fuzz ) { - if ( oid_fuzz_func ) - fuzz = oid_fuzz_func(); - else { - srand( t ); - fuzz = rand(); - } - } - - bson_big_endian32( &oid->ints[0], &t ); - oid->ints[1] = fuzz; - bson_big_endian32( &oid->ints[2], &i ); + static int incr = 0; + static int fuzz = 0; + int i; + int t = time( NULL ); + + if( oid_inc_func ) + i = oid_inc_func(); + else + i = incr++; + + if ( !fuzz ) { + if ( oid_fuzz_func ) + fuzz = oid_fuzz_func(); + else { + srand( t ); + fuzz = rand(); + } + } + + bson_big_endian32( &oid->ints[0], &t ); + oid->ints[1] = fuzz; + bson_big_endian32( &oid->ints[2], &i ); } time_t bson_oid_generated_time( bson_oid_t *oid ) { - time_t out; - bson_big_endian32( &out, &oid->ints[0] ); + time_t out; + bson_big_endian32( &out, &oid->ints[0] ); - return out; + return out; } void bson_print( bson *b ) { - bson_print_raw( b->data , 0 ); + bson_print_raw( b->data , 0 ); } void bson_print_raw( const char *data , int depth ) { - bson_iterator i; - const char *key; - int temp; - bson_timestamp_t ts; - char oidhex[25]; - bson scope; - bson_iterator_from_buffer( &i, data ); - - while ( bson_iterator_next( &i ) ) { - bson_type t = bson_iterator_type( &i ); - if ( t == 0 ) - break; - key = bson_iterator_key( &i ); - - for ( temp=0; temp<=depth; temp++ ) - bson_printf( "\t" ); - bson_printf( "%s : %d \t " , key , t ); - switch ( t ) { - case BSON_DOUBLE: - bson_printf( "%f" , bson_iterator_double( &i ) ); - break; - case BSON_STRING: - bson_printf( "%s" , bson_iterator_string( &i ) ); - break; - case BSON_SYMBOL: - bson_printf( "SYMBOL: %s" , bson_iterator_string( &i ) ); - break; - case BSON_OID: - bson_oid_to_string( bson_iterator_oid( &i ), oidhex ); - bson_printf( "%s" , oidhex ); - break; - case BSON_BOOL: - bson_printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" ); - break; - case BSON_DATE: - bson_printf( "%ld" , ( long int )bson_iterator_date( &i ) ); - break; - case BSON_BINDATA: - bson_printf( "BSON_BINDATA" ); - break; - case BSON_UNDEFINED: - bson_printf( "BSON_UNDEFINED" ); - break; - case BSON_NULL: - bson_printf( "BSON_NULL" ); - break; - case BSON_REGEX: - bson_printf( "BSON_REGEX: %s", bson_iterator_regex( &i ) ); - break; - case BSON_CODE: - bson_printf( "BSON_CODE: %s", bson_iterator_code( &i ) ); - break; - case BSON_CODEWSCOPE: - bson_printf( "BSON_CODE_W_SCOPE: %s", bson_iterator_code( &i ) ); - bson_init( &scope ); - bson_iterator_code_scope( &i, &scope ); - bson_printf( "\n\t SCOPE: " ); - bson_print( &scope ); - break; - case BSON_INT: - bson_printf( "%d" , bson_iterator_int( &i ) ); - break; - case BSON_LONG: - bson_printf( "%lld" , ( uint64_t )bson_iterator_long( &i ) ); - break; - case BSON_TIMESTAMP: - ts = bson_iterator_timestamp( &i ); - bson_printf( "i: %d, t: %d", ts.i, ts.t ); - break; - case BSON_OBJECT: - case BSON_ARRAY: - bson_printf( "\n" ); - bson_print_raw( bson_iterator_value( &i ) , depth + 1 ); - break; - default: - bson_errprintf( "can't print type : %d\n" , t ); - } - bson_printf( "\n" ); - } + bson_iterator i; + const char *key; + int temp; + bson_timestamp_t ts; + char oidhex[25]; + bson scope; + bson_iterator_from_buffer( &i, data ); + + while ( bson_iterator_next( &i ) ) { + bson_type t = bson_iterator_type( &i ); + if ( t == 0 ) + break; + key = bson_iterator_key( &i ); + + for ( temp=0; temp<=depth; temp++ ) + bson_printf( "\t" ); + bson_printf( "%s : %d \t " , key , t ); + switch ( t ) { + case BSON_DOUBLE: + bson_printf( "%f" , bson_iterator_double( &i ) ); + break; + case BSON_STRING: + bson_printf( "%s" , bson_iterator_string( &i ) ); + break; + case BSON_SYMBOL: + bson_printf( "SYMBOL: %s" , bson_iterator_string( &i ) ); + break; + case BSON_OID: + bson_oid_to_string( bson_iterator_oid( &i ), oidhex ); + bson_printf( "%s" , oidhex ); + break; + case BSON_BOOL: + bson_printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" ); + break; + case BSON_DATE: + bson_printf( "%ld" , ( long int )bson_iterator_date( &i ) ); + break; + case BSON_BINDATA: + bson_printf( "BSON_BINDATA" ); + break; + case BSON_UNDEFINED: + bson_printf( "BSON_UNDEFINED" ); + break; + case BSON_NULL: + bson_printf( "BSON_NULL" ); + break; + case BSON_REGEX: + bson_printf( "BSON_REGEX: %s", bson_iterator_regex( &i ) ); + break; + case BSON_CODE: + bson_printf( "BSON_CODE: %s", bson_iterator_code( &i ) ); + break; + case BSON_CODEWSCOPE: + bson_printf( "BSON_CODE_W_SCOPE: %s", bson_iterator_code( &i ) ); + bson_init( &scope ); + bson_iterator_code_scope( &i, &scope ); + bson_printf( "\n\t SCOPE: " ); + bson_print( &scope ); + break; + case BSON_INT: + bson_printf( "%d" , bson_iterator_int( &i ) ); + break; + case BSON_LONG: + bson_printf( "%lld" , ( uint64_t )bson_iterator_long( &i ) ); + break; + case BSON_TIMESTAMP: + ts = bson_iterator_timestamp( &i ); + bson_printf( "i: %d, t: %d", ts.i, ts.t ); + break; + case BSON_OBJECT: + case BSON_ARRAY: + bson_printf( "\n" ); + bson_print_raw( bson_iterator_value( &i ) , depth + 1 ); + break; + default: + bson_errprintf( "can't print type : %d\n" , t ); + } + bson_printf( "\n" ); + } } /* ---------------------------- @@ -297,282 +297,282 @@ void bson_print_raw( const char *data , int depth ) { ------------------------------ */ void bson_iterator_init( bson_iterator *i, const bson *b ) { - i->cur = b->data + 4; - i->first = 1; + i->cur = b->data + 4; + i->first = 1; i->last = b->data + b->dataSize; } void bson_iterator_from_buffer( bson_iterator *i, const char *buffer ) { - i->cur = buffer + 4; - i->first = 1; + i->cur = buffer + 4; + i->first = 1; i->last = NULL; } bson_type bson_find( bson_iterator *it, const bson *obj, const char *name ) { - bson_iterator_init( it, (bson *)obj ); - while( bson_iterator_next( it ) ) { - if ( strcmp( name, bson_iterator_key( it ) ) == 0 ) - break; - } - return bson_iterator_type( it ); + bson_iterator_init( it, (bson *)obj ); + while( bson_iterator_next( it ) ) { + if ( strcmp( name, bson_iterator_key( it ) ) == 0 ) + break; + } + return bson_iterator_type( it ); } bson_bool_t bson_iterator_more( const bson_iterator *i ) { if (i->last && i->cur >= i->last) return BSON_EOO; - return *( i->cur ); + return *( i->cur ); } bson_type bson_iterator_next( bson_iterator *i ) { - int ds; - - if ( i->first ) { - i->first = 0; - return ( bson_type )( *i->cur ); - } - - switch ( bson_iterator_type( i ) ) { - case BSON_EOO: - return BSON_EOO; /* don't advance */ - case BSON_UNDEFINED: - case BSON_NULL: - ds = 0; - break; - case BSON_BOOL: - ds = 1; - break; - case BSON_INT: - ds = 4; - break; - case BSON_LONG: - case BSON_DOUBLE: - case BSON_TIMESTAMP: - case BSON_DATE: - ds = 8; - break; - case BSON_OID: - ds = 12; - break; - case BSON_STRING: - case BSON_SYMBOL: - case BSON_CODE: - ds = 4 + bson_iterator_int_raw( i ); - break; - case BSON_BINDATA: - ds = 5 + bson_iterator_int_raw( i ); - break; - case BSON_OBJECT: - case BSON_ARRAY: - case BSON_CODEWSCOPE: - ds = bson_iterator_int_raw( i ); - break; - case BSON_DBREF: - ds = 4+12 + bson_iterator_int_raw( i ); - break; - case BSON_REGEX: { - const char *s = bson_iterator_value( i ); - const char *p = s; - p += strlen( p )+1; - p += strlen( p )+1; - ds = p-s; - break; - } - - default: { - char msg[] = "unknown type: 000000000000"; - bson_numstr( msg+14, ( unsigned )( i->cur[0] ) ); - bson_fatal_msg( 0, msg ); - return (bson_type)0; - } - } - - i->cur += 1 + strlen( i->cur + 1 ) + 1 + ds; + int ds; + + if ( i->first ) { + i->first = 0; + return ( bson_type )( *i->cur ); + } + + switch ( bson_iterator_type( i ) ) { + case BSON_EOO: + return BSON_EOO; /* don't advance */ + case BSON_UNDEFINED: + case BSON_NULL: + ds = 0; + break; + case BSON_BOOL: + ds = 1; + break; + case BSON_INT: + ds = 4; + break; + case BSON_LONG: + case BSON_DOUBLE: + case BSON_TIMESTAMP: + case BSON_DATE: + ds = 8; + break; + case BSON_OID: + ds = 12; + break; + case BSON_STRING: + case BSON_SYMBOL: + case BSON_CODE: + ds = 4 + bson_iterator_int_raw( i ); + break; + case BSON_BINDATA: + ds = 5 + bson_iterator_int_raw( i ); + break; + case BSON_OBJECT: + case BSON_ARRAY: + case BSON_CODEWSCOPE: + ds = bson_iterator_int_raw( i ); + break; + case BSON_DBREF: + ds = 4+12 + bson_iterator_int_raw( i ); + break; + case BSON_REGEX: { + const char *s = bson_iterator_value( i ); + const char *p = s; + p += strlen( p )+1; + p += strlen( p )+1; + ds = p-s; + break; + } + + default: { + char msg[] = "unknown type: 000000000000"; + bson_numstr( msg+14, ( unsigned )( i->cur[0] ) ); + bson_fatal_msg( 0, msg ); + return (bson_type)0; + } + } + + i->cur += 1 + strlen( i->cur + 1 ) + 1 + ds; if (i->last && i->cur >= i->last) return BSON_EOO; - return ( bson_type )( *i->cur ); + return ( bson_type )( *i->cur ); } bson_type bson_iterator_type( const bson_iterator *i ) { - return ( bson_type )i->cur[0]; + return ( bson_type )i->cur[0]; } const char *bson_iterator_key( const bson_iterator *i ) { - return i->cur + 1; + return i->cur + 1; } const char *bson_iterator_value( const bson_iterator *i ) { - const char *t = i->cur + 1; - t += strlen( t ) + 1; - return t; + const char *t = i->cur + 1; + t += strlen( t ) + 1; + return t; } /* types */ int bson_iterator_int_raw( const bson_iterator *i ) { - int out; - bson_little_endian32( &out, bson_iterator_value( i ) ); - return out; + int out; + bson_little_endian32( &out, bson_iterator_value( i ) ); + return out; } double bson_iterator_double_raw( const bson_iterator *i ) { - double out; - bson_little_endian64( &out, bson_iterator_value( i ) ); - return out; + double out; + bson_little_endian64( &out, bson_iterator_value( i ) ); + return out; } int64_t bson_iterator_long_raw( const bson_iterator *i ) { - int64_t out; - bson_little_endian64( &out, bson_iterator_value( i ) ); - return out; + int64_t out; + bson_little_endian64( &out, bson_iterator_value( i ) ); + return out; } bson_bool_t bson_iterator_bool_raw( const bson_iterator *i ) { - return bson_iterator_value( i )[0]; + return bson_iterator_value( i )[0]; } bson_oid_t *bson_iterator_oid( const bson_iterator *i ) { - return ( bson_oid_t * )bson_iterator_value( i ); + return ( bson_oid_t * )bson_iterator_value( i ); } int bson_iterator_int( const bson_iterator *i ) { - switch ( bson_iterator_type( i ) ) { - case BSON_INT: - return bson_iterator_int_raw( i ); - case BSON_LONG: - return bson_iterator_long_raw( i ); - case BSON_DOUBLE: - return bson_iterator_double_raw( i ); - default: - return 0; - } + switch ( bson_iterator_type( i ) ) { + case BSON_INT: + return bson_iterator_int_raw( i ); + case BSON_LONG: + return bson_iterator_long_raw( i ); + case BSON_DOUBLE: + return bson_iterator_double_raw( i ); + default: + return 0; + } } double bson_iterator_double( const bson_iterator *i ) { - switch ( bson_iterator_type( i ) ) { - case BSON_INT: - return bson_iterator_int_raw( i ); - case BSON_LONG: - return bson_iterator_long_raw( i ); - case BSON_DOUBLE: - return bson_iterator_double_raw( i ); - default: - return 0; - } + switch ( bson_iterator_type( i ) ) { + case BSON_INT: + return bson_iterator_int_raw( i ); + case BSON_LONG: + return bson_iterator_long_raw( i ); + case BSON_DOUBLE: + return bson_iterator_double_raw( i ); + default: + return 0; + } } int64_t bson_iterator_long( const bson_iterator *i ) { - switch ( bson_iterator_type( i ) ) { - case BSON_INT: - return bson_iterator_int_raw( i ); - case BSON_LONG: - return bson_iterator_long_raw( i ); - case BSON_DOUBLE: - return bson_iterator_double_raw( i ); - default: - return 0; - } + switch ( bson_iterator_type( i ) ) { + case BSON_INT: + return bson_iterator_int_raw( i ); + case BSON_LONG: + return bson_iterator_long_raw( i ); + case BSON_DOUBLE: + return bson_iterator_double_raw( i ); + default: + return 0; + } } bson_timestamp_t bson_iterator_timestamp( const bson_iterator *i ) { - bson_timestamp_t ts; - bson_little_endian32( &( ts.i ), bson_iterator_value( i ) ); - bson_little_endian32( &( ts.t ), bson_iterator_value( i ) + 4 ); - return ts; + bson_timestamp_t ts; + bson_little_endian32( &( ts.i ), bson_iterator_value( i ) ); + bson_little_endian32( &( ts.t ), bson_iterator_value( i ) + 4 ); + return ts; } bson_bool_t bson_iterator_bool( const bson_iterator *i ) { - switch ( bson_iterator_type( i ) ) { - case BSON_BOOL: - return bson_iterator_bool_raw( i ); - case BSON_INT: - return bson_iterator_int_raw( i ) != 0; - case BSON_LONG: - return bson_iterator_long_raw( i ) != 0; - case BSON_DOUBLE: - return bson_iterator_double_raw( i ) != 0; - case BSON_EOO: - case BSON_NULL: - return 0; - default: - return 1; - } + switch ( bson_iterator_type( i ) ) { + case BSON_BOOL: + return bson_iterator_bool_raw( i ); + case BSON_INT: + return bson_iterator_int_raw( i ) != 0; + case BSON_LONG: + return bson_iterator_long_raw( i ) != 0; + case BSON_DOUBLE: + return bson_iterator_double_raw( i ) != 0; + case BSON_EOO: + case BSON_NULL: + return 0; + default: + return 1; + } } const char *bson_iterator_string( const bson_iterator *i ) { - return bson_iterator_value( i ) + 4; + return bson_iterator_value( i ) + 4; } int bson_iterator_string_len( const bson_iterator *i ) { - return bson_iterator_int_raw( i ); + return bson_iterator_int_raw( i ); } const char *bson_iterator_code( const bson_iterator *i ) { - switch ( bson_iterator_type( i ) ) { - case BSON_STRING: - case BSON_CODE: - return bson_iterator_value( i ) + 4; - case BSON_CODEWSCOPE: - return bson_iterator_value( i ) + 8; - default: - return NULL; - } + switch ( bson_iterator_type( i ) ) { + case BSON_STRING: + case BSON_CODE: + return bson_iterator_value( i ) + 4; + case BSON_CODEWSCOPE: + return bson_iterator_value( i ) + 8; + default: + return NULL; + } } void bson_iterator_code_scope( const bson_iterator *i, bson *scope ) { - if ( bson_iterator_type( i ) == BSON_CODEWSCOPE ) { - int code_len; - bson_little_endian32( &code_len, bson_iterator_value( i )+4 ); - bson_init_data( scope, (char*)((void *)(bson_iterator_value(i)+8+code_len ))); - _bson_reset( scope ); - scope->finished = 1; - } else { - bson_empty( scope ); - } + if ( bson_iterator_type( i ) == BSON_CODEWSCOPE ) { + int code_len; + bson_little_endian32( &code_len, bson_iterator_value( i )+4 ); + bson_init_data( scope, (char*)((void *)(bson_iterator_value(i)+8+code_len ))); + _bson_reset( scope ); + scope->finished = 1; + } else { + bson_empty( scope ); + } } bson_date_t bson_iterator_date( const bson_iterator *i ) { - return bson_iterator_long_raw( i ); + return bson_iterator_long_raw( i ); } time_t bson_iterator_time_t( const bson_iterator *i ) { - return bson_iterator_date( i ) / 1000; + return bson_iterator_date( i ) / 1000; } int bson_iterator_bin_len( const bson_iterator *i ) { - return ( bson_iterator_bin_type( i ) == BSON_BIN_BINARY_OLD ) - ? bson_iterator_int_raw( i ) - 4 - : bson_iterator_int_raw( i ); + return ( bson_iterator_bin_type( i ) == BSON_BIN_BINARY_OLD ) + ? bson_iterator_int_raw( i ) - 4 + : bson_iterator_int_raw( i ); } char bson_iterator_bin_type( const bson_iterator *i ) { - return bson_iterator_value( i )[4]; + return bson_iterator_value( i )[4]; } const char *bson_iterator_bin_data( const bson_iterator *i ) { - return ( bson_iterator_bin_type( i ) == BSON_BIN_BINARY_OLD ) - ? bson_iterator_value( i ) + 9 - : bson_iterator_value( i ) + 5; + return ( bson_iterator_bin_type( i ) == BSON_BIN_BINARY_OLD ) + ? bson_iterator_value( i ) + 9 + : bson_iterator_value( i ) + 5; } const char *bson_iterator_regex( const bson_iterator *i ) { - return bson_iterator_value( i ); + return bson_iterator_value( i ); } const char *bson_iterator_regex_opts( const bson_iterator *i ) { - const char *p = bson_iterator_value( i ); - return p + strlen( p ) + 1; + const char *p = bson_iterator_value( i ); + return p + strlen( p ) + 1; } void bson_iterator_subobject( const bson_iterator *i, bson *sub ) { - bson_init_data( sub, ( char * )bson_iterator_value( i ) ); - _bson_reset( sub ); - sub->finished = 1; + bson_init_data( sub, ( char * )bson_iterator_value( i ) ); + _bson_reset( sub ); + sub->finished = 1; } void bson_iterator_subiterator( const bson_iterator *i, bson_iterator *sub ) { - bson_iterator_from_buffer( sub, bson_iterator_value( i ) ); + bson_iterator_from_buffer( sub, bson_iterator_value( i ) ); } /* ---------------------------- @@ -580,117 +580,117 @@ void bson_iterator_subiterator( const bson_iterator *i, bson_iterator *sub ) { ------------------------------ */ static void _bson_init_size( bson *b, int size ) { - if( size == 0 ) - b->data = NULL; - else - b->data = ( char * )bson_malloc( size ); - b->dataSize = size; - b->cur = b->data + 4; - _bson_reset( b ); + if( size == 0 ) + b->data = NULL; + else + b->data = ( char * )bson_malloc( size ); + b->dataSize = size; + b->cur = b->data + 4; + _bson_reset( b ); } void bson_init( bson *b ) { - _bson_init_size( b, initialBufferSize ); + _bson_init_size( b, initialBufferSize ); } void bson_init_size( bson *b, int size ) { - _bson_init_size( b, size ); + _bson_init_size( b, size ); } static void bson_append_byte( bson *b, char c ) { - b->cur[0] = c; - b->cur++; + b->cur[0] = c; + b->cur++; } static void bson_append( bson *b, const void *data, int len ) { - memcpy( b->cur , data , len ); - b->cur += len; + memcpy( b->cur , data , len ); + b->cur += len; } static void bson_append32( bson *b, const void *data ) { - bson_little_endian32( b->cur, data ); - b->cur += 4; + bson_little_endian32( b->cur, data ); + b->cur += 4; } static void bson_append64( bson *b, const void *data ) { - bson_little_endian64( b->cur, data ); - b->cur += 8; + bson_little_endian64( b->cur, data ); + b->cur += 8; } int bson_ensure_space( bson *b, const int bytesNeeded ) { - int pos = b->cur - b->data; - char *orig = b->data; - int new_size; + int pos = b->cur - b->data; + char *orig = b->data; + int new_size; - if ( pos + bytesNeeded <= b->dataSize ) - return BSON_OK; + if ( pos + bytesNeeded <= b->dataSize ) + return BSON_OK; - new_size = 1.5 * ( b->dataSize + bytesNeeded ); + new_size = 1.5 * ( b->dataSize + bytesNeeded ); - if( new_size < b->dataSize ) { - if( ( b->dataSize + bytesNeeded ) < INT_MAX ) - new_size = INT_MAX; - else { - b->err = BSON_SIZE_OVERFLOW; - return BSON_ERROR; - } - } + if( new_size < b->dataSize ) { + if( ( b->dataSize + bytesNeeded ) < INT_MAX ) + new_size = INT_MAX; + else { + b->err = BSON_SIZE_OVERFLOW; + return BSON_ERROR; + } + } - b->data = (char*)bson_realloc( b->data, new_size ); - if ( !b->data ) - bson_fatal_msg( !!b->data, "realloc() failed" ); + b->data = (char*)bson_realloc( b->data, new_size ); + if ( !b->data ) + bson_fatal_msg( !!b->data, "realloc() failed" ); - b->dataSize = new_size; - b->cur += b->data - orig; + b->dataSize = new_size; + b->cur += b->data - orig; - return BSON_OK; + return BSON_OK; } int bson_finish( bson *b ) { - int i; + int i; - if( b->err & BSON_NOT_UTF8 ) - return BSON_ERROR; + if( b->err & BSON_NOT_UTF8 ) + return BSON_ERROR; - if ( ! b->finished ) { - if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR; - bson_append_byte( b, 0 ); - i = b->cur - b->data; - bson_little_endian32( b->data, &i ); - b->finished = 1; - } + if ( ! b->finished ) { + if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR; + bson_append_byte( b, 0 ); + i = b->cur - b->data; + bson_little_endian32( b->data, &i ); + b->finished = 1; + } - return BSON_OK; + return BSON_OK; } void bson_destroy( bson *b ) { - bson_free( b->data ); - b->err = 0; - b->data = 0; - b->cur = 0; - b->finished = 1; + bson_free( b->data ); + b->err = 0; + b->data = 0; + b->cur = 0; + b->finished = 1; } static int bson_append_estart( bson *b, int type, const char *name, const int dataSize ) { - const int len = strlen( name ) + 1; + const int len = strlen( name ) + 1; - if ( b->finished ) { - b->err |= BSON_ALREADY_FINISHED; - return BSON_ERROR; - } + if ( b->finished ) { + b->err |= BSON_ALREADY_FINISHED; + return BSON_ERROR; + } - if ( bson_ensure_space( b, 1 + len + dataSize ) == BSON_ERROR ) { - return BSON_ERROR; - } + if ( bson_ensure_space( b, 1 + len + dataSize ) == BSON_ERROR ) { + return BSON_ERROR; + } - if( bson_check_field_name( b, ( const char * )name, len - 1 ) == BSON_ERROR ) { - bson_builder_error( b ); - return BSON_ERROR; - } + if( bson_check_field_name( b, ( const char * )name, len - 1 ) == BSON_ERROR ) { + bson_builder_error( b ); + return BSON_ERROR; + } - bson_append_byte( b, ( char )type ); - bson_append( b, name, len ); - return BSON_OK; + bson_append_byte( b, ( char )type ); + bson_append( b, name, len ); + return BSON_OK; } /* ---------------------------- @@ -698,221 +698,221 @@ static int bson_append_estart( bson *b, int type, const char *name, const int da ------------------------------ */ int bson_append_int( bson *b, const char *name, const int i ) { - if ( bson_append_estart( b, BSON_INT, name, 4 ) == BSON_ERROR ) - return BSON_ERROR; - bson_append32( b , &i ); - return BSON_OK; + if ( bson_append_estart( b, BSON_INT, name, 4 ) == BSON_ERROR ) + return BSON_ERROR; + bson_append32( b , &i ); + return BSON_OK; } int bson_append_long( bson *b, const char *name, const int64_t i ) { - if ( bson_append_estart( b , BSON_LONG, name, 8 ) == BSON_ERROR ) - return BSON_ERROR; - bson_append64( b , &i ); - return BSON_OK; + if ( bson_append_estart( b , BSON_LONG, name, 8 ) == BSON_ERROR ) + return BSON_ERROR; + bson_append64( b , &i ); + return BSON_OK; } int bson_append_double( bson *b, const char *name, const double d ) { - if ( bson_append_estart( b, BSON_DOUBLE, name, 8 ) == BSON_ERROR ) - return BSON_ERROR; - bson_append64( b , &d ); - return BSON_OK; + if ( bson_append_estart( b, BSON_DOUBLE, name, 8 ) == BSON_ERROR ) + return BSON_ERROR; + bson_append64( b , &d ); + return BSON_OK; } int bson_append_bool( bson *b, const char *name, const bson_bool_t i ) { - if ( bson_append_estart( b, BSON_BOOL, name, 1 ) == BSON_ERROR ) - return BSON_ERROR; - bson_append_byte( b , i != 0 ); - return BSON_OK; + if ( bson_append_estart( b, BSON_BOOL, name, 1 ) == BSON_ERROR ) + return BSON_ERROR; + bson_append_byte( b , i != 0 ); + return BSON_OK; } int bson_append_null( bson *b, const char *name ) { - if ( bson_append_estart( b , BSON_NULL, name, 0 ) == BSON_ERROR ) - return BSON_ERROR; - return BSON_OK; + if ( bson_append_estart( b , BSON_NULL, name, 0 ) == BSON_ERROR ) + return BSON_ERROR; + return BSON_OK; } int bson_append_undefined( bson *b, const char *name ) { - if ( bson_append_estart( b, BSON_UNDEFINED, name, 0 ) == BSON_ERROR ) - return BSON_ERROR; - return BSON_OK; + if ( bson_append_estart( b, BSON_UNDEFINED, name, 0 ) == BSON_ERROR ) + return BSON_ERROR; + return BSON_OK; } static int bson_append_string_base( bson *b, const char *name, - const char *value, int len, bson_type type ) { + const char *value, int len, bson_type type ) { - int sl = len + 1; - if ( bson_check_string( b, ( const char * )value, sl - 1 ) == BSON_ERROR ) - return BSON_ERROR; - if ( bson_append_estart( b, type, name, 4 + sl ) == BSON_ERROR ) { - return BSON_ERROR; - } - bson_append32( b , &sl ); - bson_append( b , value , sl - 1 ); - bson_append( b , "\0" , 1 ); - return BSON_OK; + int sl = len + 1; + if ( bson_check_string( b, ( const char * )value, sl - 1 ) == BSON_ERROR ) + return BSON_ERROR; + if ( bson_append_estart( b, type, name, 4 + sl ) == BSON_ERROR ) { + return BSON_ERROR; + } + bson_append32( b , &sl ); + bson_append( b , value , sl - 1 ); + bson_append( b , "\0" , 1 ); + return BSON_OK; } int bson_append_string( bson *b, const char *name, const char *value ) { - return bson_append_string_base( b, name, value, strlen ( value ), BSON_STRING ); + return bson_append_string_base( b, name, value, strlen ( value ), BSON_STRING ); } int bson_append_symbol( bson *b, const char *name, const char *value ) { - return bson_append_string_base( b, name, value, strlen ( value ), BSON_SYMBOL ); + return bson_append_string_base( b, name, value, strlen ( value ), BSON_SYMBOL ); } int bson_append_code( bson *b, const char *name, const char *value ) { - return bson_append_string_base( b, name, value, strlen ( value ), BSON_CODE ); + return bson_append_string_base( b, name, value, strlen ( value ), BSON_CODE ); } int bson_append_string_n( bson *b, const char *name, const char *value, int len ) { - return bson_append_string_base( b, name, value, len, BSON_STRING ); + return bson_append_string_base( b, name, value, len, BSON_STRING ); } int bson_append_symbol_n( bson *b, const char *name, const char *value, int len ) { - return bson_append_string_base( b, name, value, len, BSON_SYMBOL ); + return bson_append_string_base( b, name, value, len, BSON_SYMBOL ); } int bson_append_code_n( bson *b, const char *name, const char *value, int len ) { - return bson_append_string_base( b, name, value, len, BSON_CODE ); + return bson_append_string_base( b, name, value, len, BSON_CODE ); } int bson_append_code_w_scope_n( bson *b, const char *name, - const char *code, int len, const bson *scope ) { + const char *code, int len, const bson *scope ) { - int sl = len + 1; - int size = 4 + 4 + sl + bson_size( scope ); - if ( bson_append_estart( b, BSON_CODEWSCOPE, name, size ) == BSON_ERROR ) - return BSON_ERROR; - bson_append32( b, &size ); - bson_append32( b, &sl ); - bson_append( b, code, sl ); - bson_append( b, scope->data, bson_size( scope ) ); - return BSON_OK; + int sl = len + 1; + int size = 4 + 4 + sl + bson_size( scope ); + if ( bson_append_estart( b, BSON_CODEWSCOPE, name, size ) == BSON_ERROR ) + return BSON_ERROR; + bson_append32( b, &size ); + bson_append32( b, &sl ); + bson_append( b, code, sl ); + bson_append( b, scope->data, bson_size( scope ) ); + return BSON_OK; } int bson_append_code_w_scope( bson *b, const char *name, const char *code, const bson *scope ) { - return bson_append_code_w_scope_n( b, name, code, strlen ( code ), scope ); + return bson_append_code_w_scope_n( b, name, code, strlen ( code ), scope ); } int bson_append_binary( bson *b, const char *name, char type, const char *str, int len ) { - if ( type == BSON_BIN_BINARY_OLD ) { - int subtwolen = len + 4; - if ( bson_append_estart( b, BSON_BINDATA, name, 4+1+4+len ) == BSON_ERROR ) - return BSON_ERROR; - bson_append32( b, &subtwolen ); - bson_append_byte( b, type ); - bson_append32( b, &len ); - bson_append( b, str, len ); - } else { - if ( bson_append_estart( b, BSON_BINDATA, name, 4+1+len ) == BSON_ERROR ) - return BSON_ERROR; - bson_append32( b, &len ); - bson_append_byte( b, type ); - bson_append( b, str, len ); - } - return BSON_OK; + if ( type == BSON_BIN_BINARY_OLD ) { + int subtwolen = len + 4; + if ( bson_append_estart( b, BSON_BINDATA, name, 4+1+4+len ) == BSON_ERROR ) + return BSON_ERROR; + bson_append32( b, &subtwolen ); + bson_append_byte( b, type ); + bson_append32( b, &len ); + bson_append( b, str, len ); + } else { + if ( bson_append_estart( b, BSON_BINDATA, name, 4+1+len ) == BSON_ERROR ) + return BSON_ERROR; + bson_append32( b, &len ); + bson_append_byte( b, type ); + bson_append( b, str, len ); + } + return BSON_OK; } int bson_append_oid( bson *b, const char *name, const bson_oid_t *oid ) { - if ( bson_append_estart( b, BSON_OID, name, 12 ) == BSON_ERROR ) - return BSON_ERROR; - bson_append( b , oid , 12 ); - return BSON_OK; + if ( bson_append_estart( b, BSON_OID, name, 12 ) == BSON_ERROR ) + return BSON_ERROR; + bson_append( b , oid , 12 ); + return BSON_OK; } int bson_append_new_oid( bson *b, const char *name ) { - bson_oid_t oid; - bson_oid_gen( &oid ); - return bson_append_oid( b, name, &oid ); + bson_oid_t oid; + bson_oid_gen( &oid ); + return bson_append_oid( b, name, &oid ); } int bson_append_regex( bson *b, const char *name, const char *pattern, const char *opts ) { - const int plen = strlen( pattern )+1; - const int olen = strlen( opts )+1; - if ( bson_append_estart( b, BSON_REGEX, name, plen + olen ) == BSON_ERROR ) - return BSON_ERROR; - if ( bson_check_string( b, pattern, plen - 1 ) == BSON_ERROR ) - return BSON_ERROR; - bson_append( b , pattern , plen ); - bson_append( b , opts , olen ); - return BSON_OK; + const int plen = strlen( pattern )+1; + const int olen = strlen( opts )+1; + if ( bson_append_estart( b, BSON_REGEX, name, plen + olen ) == BSON_ERROR ) + return BSON_ERROR; + if ( bson_check_string( b, pattern, plen - 1 ) == BSON_ERROR ) + return BSON_ERROR; + bson_append( b , pattern , plen ); + bson_append( b , opts , olen ); + return BSON_OK; } int bson_append_bson( bson *b, const char *name, const bson *bson ) { - if ( bson_append_estart( b, BSON_OBJECT, name, bson_size( bson ) ) == BSON_ERROR ) - return BSON_ERROR; - bson_append( b , bson->data , bson_size( bson ) ); - return BSON_OK; + if ( bson_append_estart( b, BSON_OBJECT, name, bson_size( bson ) ) == BSON_ERROR ) + return BSON_ERROR; + bson_append( b , bson->data , bson_size( bson ) ); + return BSON_OK; } int bson_append_element( bson *b, const char *name_or_null, const bson_iterator *elem ) { - bson_iterator next = *elem; - int size; + bson_iterator next = *elem; + int size; - bson_iterator_next( &next ); - size = next.cur - elem->cur; + bson_iterator_next( &next ); + size = next.cur - elem->cur; - if ( name_or_null == NULL ) { - if( bson_ensure_space( b, size ) == BSON_ERROR ) - return BSON_ERROR; - bson_append( b, elem->cur, size ); - } else { - int data_size = size - 2 - strlen( bson_iterator_key( elem ) ); - bson_append_estart( b, elem->cur[0], name_or_null, data_size ); - bson_append( b, bson_iterator_value( elem ), data_size ); - } + if ( name_or_null == NULL ) { + if( bson_ensure_space( b, size ) == BSON_ERROR ) + return BSON_ERROR; + bson_append( b, elem->cur, size ); + } else { + int data_size = size - 2 - strlen( bson_iterator_key( elem ) ); + bson_append_estart( b, elem->cur[0], name_or_null, data_size ); + bson_append( b, bson_iterator_value( elem ), data_size ); + } - return BSON_OK; + return BSON_OK; } int bson_append_timestamp( bson *b, const char *name, bson_timestamp_t *ts ) { - if ( bson_append_estart( b, BSON_TIMESTAMP, name, 8 ) == BSON_ERROR ) return BSON_ERROR; + if ( bson_append_estart( b, BSON_TIMESTAMP, name, 8 ) == BSON_ERROR ) return BSON_ERROR; - bson_append32( b , &( ts->i ) ); - bson_append32( b , &( ts->t ) ); + bson_append32( b , &( ts->i ) ); + bson_append32( b , &( ts->t ) ); - return BSON_OK; + return BSON_OK; } int bson_append_date( bson *b, const char *name, bson_date_t millis ) { - if ( bson_append_estart( b, BSON_DATE, name, 8 ) == BSON_ERROR ) return BSON_ERROR; - bson_append64( b , &millis ); - return BSON_OK; + if ( bson_append_estart( b, BSON_DATE, name, 8 ) == BSON_ERROR ) return BSON_ERROR; + bson_append64( b , &millis ); + return BSON_OK; } int bson_append_time_t( bson *b, const char *name, time_t secs ) { - return bson_append_date( b, name, ( bson_date_t )secs * 1000 ); + return bson_append_date( b, name, ( bson_date_t )secs * 1000 ); } int bson_append_start_object( bson *b, const char *name ) { - if ( bson_append_estart( b, BSON_OBJECT, name, 5 ) == BSON_ERROR ) return BSON_ERROR; - b->stack[ b->stackPos++ ] = b->cur - b->data; - bson_append32( b , &zero ); - return BSON_OK; + if ( bson_append_estart( b, BSON_OBJECT, name, 5 ) == BSON_ERROR ) return BSON_ERROR; + b->stack[ b->stackPos++ ] = b->cur - b->data; + bson_append32( b , &zero ); + return BSON_OK; } int bson_append_start_array( bson *b, const char *name ) { - if ( bson_append_estart( b, BSON_ARRAY, name, 5 ) == BSON_ERROR ) return BSON_ERROR; - b->stack[ b->stackPos++ ] = b->cur - b->data; - bson_append32( b , &zero ); - return BSON_OK; + if ( bson_append_estart( b, BSON_ARRAY, name, 5 ) == BSON_ERROR ) return BSON_ERROR; + b->stack[ b->stackPos++ ] = b->cur - b->data; + bson_append32( b , &zero ); + return BSON_OK; } int bson_append_finish_object( bson *b ) { - char *start; - int i; - if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR; - bson_append_byte( b , 0 ); + char *start; + int i; + if ( bson_ensure_space( b, 1 ) == BSON_ERROR ) return BSON_ERROR; + bson_append_byte( b , 0 ); - start = b->data + b->stack[ --b->stackPos ]; - i = b->cur - start; - bson_little_endian32( start, &i ); + start = b->data + b->stack[ --b->stackPos ]; + i = b->cur - start; + bson_little_endian32( start, &i ); - return BSON_OK; + return BSON_OK; } int bson_append_finish_array( bson *b ) { - return bson_append_finish_object( b ); + return bson_append_finish_object( b ); } @@ -921,33 +921,33 @@ int bson_append_finish_array( bson *b ) { static bson_err_handler err_handler = NULL; bson_err_handler set_bson_err_handler( bson_err_handler func ) { - bson_err_handler old = err_handler; - err_handler = func; - return old; + bson_err_handler old = err_handler; + err_handler = func; + return old; } void *bson_malloc( int size ) { - void *p; - p = bson_malloc_func( size ); - bson_fatal_msg( !!p, "malloc() failed" ); - return p; + void *p; + p = bson_malloc_func( size ); + bson_fatal_msg( !!p, "malloc() failed" ); + return p; } void *bson_realloc( void *ptr, int size ) { - void *p; - p = bson_realloc_func( ptr, size ); - bson_fatal_msg( !!p, "realloc() failed" ); - return p; + void *p; + p = bson_realloc_func( ptr, size ); + bson_fatal_msg( !!p, "realloc() failed" ); + return p; } int _bson_errprintf( const char *format, ... ) { - va_list ap; - int ret; - va_start( ap, format ); - ret = vfprintf( stderr, format, ap ); - va_end( ap ); + va_list ap; + int ret; + va_start( ap, format ); + ret = vfprintf( stderr, format, ap ); + va_end( ap ); - return ret; + return ret; } /** @@ -957,34 +957,34 @@ int _bson_errprintf( const char *format, ... ) { * @param */ void bson_builder_error( bson *b ) { - if( err_handler ) - err_handler( "BSON error." ); + if( err_handler ) + err_handler( "BSON error." ); } void bson_fatal( int ok ) { - bson_fatal_msg( ok, "" ); + bson_fatal_msg( ok, "" ); } void bson_fatal_msg( int ok , const char *msg ) { - if ( ok ) - return; + if ( ok ) + return; - if ( err_handler ) { - err_handler( msg ); - } + if ( err_handler ) { + err_handler( msg ); + } - bson_errprintf( "error: %s\n" , msg ); - exit( -5 ); + bson_errprintf( "error: %s\n" , msg ); + exit( -5 ); } /* Efficiently copy an integer to a string. */ void bson_numstr( char *str, int i ) { - if( i < 1000 ) - memcpy( str, bson_numstrs[i], 4 ); - else - bson_sprintf( str,"%d", i ); + if( i < 1000 ) + memcpy( str, bson_numstrs[i], 4 ); + else + bson_sprintf( str,"%d", i ); } /* encoding.c */ @@ -1032,14 +1032,14 @@ void bson_numstr( char *str, int i ) { * get the number of trailing bytes that are supposed to follow it. */ static const char trailingBytesForUTF8[256] = { - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 }; /* --------------------------------------------------------------------- */ @@ -1055,81 +1055,81 @@ static const char trailingBytesForUTF8[256] = { * definition of UTF-8 goes up to 4-byte sequences. */ static int isLegalUTF8( const unsigned char *source, int length ) { - unsigned char a; - const unsigned char *srcptr = source + length; - switch ( length ) { - default: - return 0; - /* Everything else falls through when "true"... */ - case 4: - if ( ( a = ( *--srcptr ) ) < 0x80 || a > 0xBF ) return 0; - case 3: - if ( ( a = ( *--srcptr ) ) < 0x80 || a > 0xBF ) return 0; - case 2: - if ( ( a = ( *--srcptr ) ) > 0xBF ) return 0; - switch ( *source ) { - /* no fall-through in this inner switch */ - case 0xE0: - if ( a < 0xA0 ) return 0; - break; - case 0xF0: - if ( a < 0x90 ) return 0; - break; - case 0xF4: - if ( a > 0x8F ) return 0; - break; - default: - if ( a < 0x80 ) return 0; - } - case 1: - if ( *source >= 0x80 && *source < 0xC2 ) return 0; - if ( *source > 0xF4 ) return 0; - } - return 1; + unsigned char a; + const unsigned char *srcptr = source + length; + switch ( length ) { + default: + return 0; + /* Everything else falls through when "true"... */ + case 4: + if ( ( a = ( *--srcptr ) ) < 0x80 || a > 0xBF ) return 0; + case 3: + if ( ( a = ( *--srcptr ) ) < 0x80 || a > 0xBF ) return 0; + case 2: + if ( ( a = ( *--srcptr ) ) > 0xBF ) return 0; + switch ( *source ) { + /* no fall-through in this inner switch */ + case 0xE0: + if ( a < 0xA0 ) return 0; + break; + case 0xF0: + if ( a < 0x90 ) return 0; + break; + case 0xF4: + if ( a > 0x8F ) return 0; + break; + default: + if ( a < 0x80 ) return 0; + } + case 1: + if ( *source >= 0x80 && *source < 0xC2 ) return 0; + if ( *source > 0xF4 ) return 0; + } + return 1; } static int bson_validate_string( bson *b, const unsigned char *string, const int length, const char check_utf8, const char check_dot, const char check_dollar ) { - int position = 0; - int sequence_length = 1; + int position = 0; + int sequence_length = 1; - if( check_dollar && string[0] == '$' ) { - b->err |= BSON_FIELD_INIT_DOLLAR; - } + if( check_dollar && string[0] == '$' ) { + b->err |= BSON_FIELD_INIT_DOLLAR; + } - while ( position < length ) { - if ( check_dot && *( string + position ) == '.' ) { - b->err |= BSON_FIELD_HAS_DOT; - } + while ( position < length ) { + if ( check_dot && *( string + position ) == '.' ) { + b->err |= BSON_FIELD_HAS_DOT; + } - if ( check_utf8 ) { - sequence_length = trailingBytesForUTF8[*( string + position )] + 1; - if ( ( position + sequence_length ) > length ) { - b->err |= BSON_NOT_UTF8; - return BSON_ERROR; - } - if ( !isLegalUTF8( string + position, sequence_length ) ) { - b->err |= BSON_NOT_UTF8; - return BSON_ERROR; - } - } - position += sequence_length; - } + if ( check_utf8 ) { + sequence_length = trailingBytesForUTF8[*( string + position )] + 1; + if ( ( position + sequence_length ) > length ) { + b->err |= BSON_NOT_UTF8; + return BSON_ERROR; + } + if ( !isLegalUTF8( string + position, sequence_length ) ) { + b->err |= BSON_NOT_UTF8; + return BSON_ERROR; + } + } + position += sequence_length; + } - return BSON_OK; + return BSON_OK; } int bson_check_string( bson *b, const char *string, const int length ) { - return bson_validate_string( b, ( const unsigned char * )string, length, 1, 0, 0 ); + return bson_validate_string( b, ( const unsigned char * )string, length, 1, 0, 0 ); } int bson_check_field_name( bson *b, const char *string, const int length ) { - return bson_validate_string( b, ( const unsigned char * )string, length, 1, 1, 1 ); + return bson_validate_string( b, ( const unsigned char * )string, length, 1, 1, 1 ); } diff --git a/src/bson/BSON.h b/src/bson/BSON.h index 92d43f2c61..94e8792fe5 100644 --- a/src/bson/BSON.h +++ b/src/bson/BSON.h @@ -41,191 +41,191 @@ typedef unsigned long long int uint64_t; #define BSON_ERROR -1 static const char bson_numstrs[1000][4] = { - "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", - "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", - "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", - "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", - "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", - "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", - "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", - "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", - "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", - "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", - - "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", - "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", - "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", - "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", - "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", - "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", - "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", - "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", - "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", - "190", "191", "192", "193", "194", "195", "196", "197", "198", "199", - - "200", "201", "202", "203", "204", "205", "206", "207", "208", "209", - "210", "211", "212", "213", "214", "215", "216", "217", "218", "219", - "220", "221", "222", "223", "224", "225", "226", "227", "228", "229", - "230", "231", "232", "233", "234", "235", "236", "237", "238", "239", - "240", "241", "242", "243", "244", "245", "246", "247", "248", "249", - "250", "251", "252", "253", "254", "255", "256", "257", "258", "259", - "260", "261", "262", "263", "264", "265", "266", "267", "268", "269", - "270", "271", "272", "273", "274", "275", "276", "277", "278", "279", - "280", "281", "282", "283", "284", "285", "286", "287", "288", "289", - "290", "291", "292", "293", "294", "295", "296", "297", "298", "299", - - "300", "301", "302", "303", "304", "305", "306", "307", "308", "309", - "310", "311", "312", "313", "314", "315", "316", "317", "318", "319", - "320", "321", "322", "323", "324", "325", "326", "327", "328", "329", - "330", "331", "332", "333", "334", "335", "336", "337", "338", "339", - "340", "341", "342", "343", "344", "345", "346", "347", "348", "349", - "350", "351", "352", "353", "354", "355", "356", "357", "358", "359", - "360", "361", "362", "363", "364", "365", "366", "367", "368", "369", - "370", "371", "372", "373", "374", "375", "376", "377", "378", "379", - "380", "381", "382", "383", "384", "385", "386", "387", "388", "389", - "390", "391", "392", "393", "394", "395", "396", "397", "398", "399", - - "400", "401", "402", "403", "404", "405", "406", "407", "408", "409", - "410", "411", "412", "413", "414", "415", "416", "417", "418", "419", - "420", "421", "422", "423", "424", "425", "426", "427", "428", "429", - "430", "431", "432", "433", "434", "435", "436", "437", "438", "439", - "440", "441", "442", "443", "444", "445", "446", "447", "448", "449", - "450", "451", "452", "453", "454", "455", "456", "457", "458", "459", - "460", "461", "462", "463", "464", "465", "466", "467", "468", "469", - "470", "471", "472", "473", "474", "475", "476", "477", "478", "479", - "480", "481", "482", "483", "484", "485", "486", "487", "488", "489", - "490", "491", "492", "493", "494", "495", "496", "497", "498", "499", - - "500", "501", "502", "503", "504", "505", "506", "507", "508", "509", - "510", "511", "512", "513", "514", "515", "516", "517", "518", "519", - "520", "521", "522", "523", "524", "525", "526", "527", "528", "529", - "530", "531", "532", "533", "534", "535", "536", "537", "538", "539", - "540", "541", "542", "543", "544", "545", "546", "547", "548", "549", - "550", "551", "552", "553", "554", "555", "556", "557", "558", "559", - "560", "561", "562", "563", "564", "565", "566", "567", "568", "569", - "570", "571", "572", "573", "574", "575", "576", "577", "578", "579", - "580", "581", "582", "583", "584", "585", "586", "587", "588", "589", - "590", "591", "592", "593", "594", "595", "596", "597", "598", "599", - - "600", "601", "602", "603", "604", "605", "606", "607", "608", "609", - "610", "611", "612", "613", "614", "615", "616", "617", "618", "619", - "620", "621", "622", "623", "624", "625", "626", "627", "628", "629", - "630", "631", "632", "633", "634", "635", "636", "637", "638", "639", - "640", "641", "642", "643", "644", "645", "646", "647", "648", "649", - "650", "651", "652", "653", "654", "655", "656", "657", "658", "659", - "660", "661", "662", "663", "664", "665", "666", "667", "668", "669", - "670", "671", "672", "673", "674", "675", "676", "677", "678", "679", - "680", "681", "682", "683", "684", "685", "686", "687", "688", "689", - "690", "691", "692", "693", "694", "695", "696", "697", "698", "699", - - "700", "701", "702", "703", "704", "705", "706", "707", "708", "709", - "710", "711", "712", "713", "714", "715", "716", "717", "718", "719", - "720", "721", "722", "723", "724", "725", "726", "727", "728", "729", - "730", "731", "732", "733", "734", "735", "736", "737", "738", "739", - "740", "741", "742", "743", "744", "745", "746", "747", "748", "749", - "750", "751", "752", "753", "754", "755", "756", "757", "758", "759", - "760", "761", "762", "763", "764", "765", "766", "767", "768", "769", - "770", "771", "772", "773", "774", "775", "776", "777", "778", "779", - "780", "781", "782", "783", "784", "785", "786", "787", "788", "789", - "790", "791", "792", "793", "794", "795", "796", "797", "798", "799", - - "800", "801", "802", "803", "804", "805", "806", "807", "808", "809", - "810", "811", "812", "813", "814", "815", "816", "817", "818", "819", - "820", "821", "822", "823", "824", "825", "826", "827", "828", "829", - "830", "831", "832", "833", "834", "835", "836", "837", "838", "839", - "840", "841", "842", "843", "844", "845", "846", "847", "848", "849", - "850", "851", "852", "853", "854", "855", "856", "857", "858", "859", - "860", "861", "862", "863", "864", "865", "866", "867", "868", "869", - "870", "871", "872", "873", "874", "875", "876", "877", "878", "879", - "880", "881", "882", "883", "884", "885", "886", "887", "888", "889", - "890", "891", "892", "893", "894", "895", "896", "897", "898", "899", - - "900", "901", "902", "903", "904", "905", "906", "907", "908", "909", - "910", "911", "912", "913", "914", "915", "916", "917", "918", "919", - "920", "921", "922", "923", "924", "925", "926", "927", "928", "929", - "930", "931", "932", "933", "934", "935", "936", "937", "938", "939", - "940", "941", "942", "943", "944", "945", "946", "947", "948", "949", - "950", "951", "952", "953", "954", "955", "956", "957", "958", "959", - "960", "961", "962", "963", "964", "965", "966", "967", "968", "969", - "970", "971", "972", "973", "974", "975", "976", "977", "978", "979", - "980", "981", "982", "983", "984", "985", "986", "987", "988", "989", - "990", "991", "992", "993", "994", "995", "996", "997", "998", "999", + "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", + "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", + "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", + "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", + "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", + "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", + "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", + "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", + "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", + "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", + + "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", + "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", + "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", + "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", + "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", + "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", + "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", + "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", + "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", + "190", "191", "192", "193", "194", "195", "196", "197", "198", "199", + + "200", "201", "202", "203", "204", "205", "206", "207", "208", "209", + "210", "211", "212", "213", "214", "215", "216", "217", "218", "219", + "220", "221", "222", "223", "224", "225", "226", "227", "228", "229", + "230", "231", "232", "233", "234", "235", "236", "237", "238", "239", + "240", "241", "242", "243", "244", "245", "246", "247", "248", "249", + "250", "251", "252", "253", "254", "255", "256", "257", "258", "259", + "260", "261", "262", "263", "264", "265", "266", "267", "268", "269", + "270", "271", "272", "273", "274", "275", "276", "277", "278", "279", + "280", "281", "282", "283", "284", "285", "286", "287", "288", "289", + "290", "291", "292", "293", "294", "295", "296", "297", "298", "299", + + "300", "301", "302", "303", "304", "305", "306", "307", "308", "309", + "310", "311", "312", "313", "314", "315", "316", "317", "318", "319", + "320", "321", "322", "323", "324", "325", "326", "327", "328", "329", + "330", "331", "332", "333", "334", "335", "336", "337", "338", "339", + "340", "341", "342", "343", "344", "345", "346", "347", "348", "349", + "350", "351", "352", "353", "354", "355", "356", "357", "358", "359", + "360", "361", "362", "363", "364", "365", "366", "367", "368", "369", + "370", "371", "372", "373", "374", "375", "376", "377", "378", "379", + "380", "381", "382", "383", "384", "385", "386", "387", "388", "389", + "390", "391", "392", "393", "394", "395", "396", "397", "398", "399", + + "400", "401", "402", "403", "404", "405", "406", "407", "408", "409", + "410", "411", "412", "413", "414", "415", "416", "417", "418", "419", + "420", "421", "422", "423", "424", "425", "426", "427", "428", "429", + "430", "431", "432", "433", "434", "435", "436", "437", "438", "439", + "440", "441", "442", "443", "444", "445", "446", "447", "448", "449", + "450", "451", "452", "453", "454", "455", "456", "457", "458", "459", + "460", "461", "462", "463", "464", "465", "466", "467", "468", "469", + "470", "471", "472", "473", "474", "475", "476", "477", "478", "479", + "480", "481", "482", "483", "484", "485", "486", "487", "488", "489", + "490", "491", "492", "493", "494", "495", "496", "497", "498", "499", + + "500", "501", "502", "503", "504", "505", "506", "507", "508", "509", + "510", "511", "512", "513", "514", "515", "516", "517", "518", "519", + "520", "521", "522", "523", "524", "525", "526", "527", "528", "529", + "530", "531", "532", "533", "534", "535", "536", "537", "538", "539", + "540", "541", "542", "543", "544", "545", "546", "547", "548", "549", + "550", "551", "552", "553", "554", "555", "556", "557", "558", "559", + "560", "561", "562", "563", "564", "565", "566", "567", "568", "569", + "570", "571", "572", "573", "574", "575", "576", "577", "578", "579", + "580", "581", "582", "583", "584", "585", "586", "587", "588", "589", + "590", "591", "592", "593", "594", "595", "596", "597", "598", "599", + + "600", "601", "602", "603", "604", "605", "606", "607", "608", "609", + "610", "611", "612", "613", "614", "615", "616", "617", "618", "619", + "620", "621", "622", "623", "624", "625", "626", "627", "628", "629", + "630", "631", "632", "633", "634", "635", "636", "637", "638", "639", + "640", "641", "642", "643", "644", "645", "646", "647", "648", "649", + "650", "651", "652", "653", "654", "655", "656", "657", "658", "659", + "660", "661", "662", "663", "664", "665", "666", "667", "668", "669", + "670", "671", "672", "673", "674", "675", "676", "677", "678", "679", + "680", "681", "682", "683", "684", "685", "686", "687", "688", "689", + "690", "691", "692", "693", "694", "695", "696", "697", "698", "699", + + "700", "701", "702", "703", "704", "705", "706", "707", "708", "709", + "710", "711", "712", "713", "714", "715", "716", "717", "718", "719", + "720", "721", "722", "723", "724", "725", "726", "727", "728", "729", + "730", "731", "732", "733", "734", "735", "736", "737", "738", "739", + "740", "741", "742", "743", "744", "745", "746", "747", "748", "749", + "750", "751", "752", "753", "754", "755", "756", "757", "758", "759", + "760", "761", "762", "763", "764", "765", "766", "767", "768", "769", + "770", "771", "772", "773", "774", "775", "776", "777", "778", "779", + "780", "781", "782", "783", "784", "785", "786", "787", "788", "789", + "790", "791", "792", "793", "794", "795", "796", "797", "798", "799", + + "800", "801", "802", "803", "804", "805", "806", "807", "808", "809", + "810", "811", "812", "813", "814", "815", "816", "817", "818", "819", + "820", "821", "822", "823", "824", "825", "826", "827", "828", "829", + "830", "831", "832", "833", "834", "835", "836", "837", "838", "839", + "840", "841", "842", "843", "844", "845", "846", "847", "848", "849", + "850", "851", "852", "853", "854", "855", "856", "857", "858", "859", + "860", "861", "862", "863", "864", "865", "866", "867", "868", "869", + "870", "871", "872", "873", "874", "875", "876", "877", "878", "879", + "880", "881", "882", "883", "884", "885", "886", "887", "888", "889", + "890", "891", "892", "893", "894", "895", "896", "897", "898", "899", + + "900", "901", "902", "903", "904", "905", "906", "907", "908", "909", + "910", "911", "912", "913", "914", "915", "916", "917", "918", "919", + "920", "921", "922", "923", "924", "925", "926", "927", "928", "929", + "930", "931", "932", "933", "934", "935", "936", "937", "938", "939", + "940", "941", "942", "943", "944", "945", "946", "947", "948", "949", + "950", "951", "952", "953", "954", "955", "956", "957", "958", "959", + "960", "961", "962", "963", "964", "965", "966", "967", "968", "969", + "970", "971", "972", "973", "974", "975", "976", "977", "978", "979", + "980", "981", "982", "983", "984", "985", "986", "987", "988", "989", + "990", "991", "992", "993", "994", "995", "996", "997", "998", "999", }; enum bson_error_t { - BSON_SIZE_OVERFLOW = 1 /**< Trying to create a BSON object larger than INT_MAX. */ + BSON_SIZE_OVERFLOW = 1 /**< Trying to create a BSON object larger than INT_MAX. */ }; enum bson_validity_t { - BSON_VALID = 0, /**< BSON is valid and UTF-8 compliant. */ - BSON_NOT_UTF8 = ( 1<<1 ), /**< A key or a string is not valid UTF-8. */ - BSON_FIELD_HAS_DOT = ( 1<<2 ), /**< Warning: key contains '.' character. */ - BSON_FIELD_INIT_DOLLAR = ( 1<<3 ), /**< Warning: key starts with '$' character. */ - BSON_ALREADY_FINISHED = ( 1<<4 ) /**< Trying to modify a finished BSON object. */ + BSON_VALID = 0, /**< BSON is valid and UTF-8 compliant. */ + BSON_NOT_UTF8 = ( 1<<1 ), /**< A key or a string is not valid UTF-8. */ + BSON_FIELD_HAS_DOT = ( 1<<2 ), /**< Warning: key contains '.' character. */ + BSON_FIELD_INIT_DOLLAR = ( 1<<3 ), /**< Warning: key starts with '$' character. */ + BSON_ALREADY_FINISHED = ( 1<<4 ) /**< Trying to modify a finished BSON object. */ }; enum bson_binary_subtype_t { - BSON_BIN_BINARY = 0, - BSON_BIN_FUNC = 1, - BSON_BIN_BINARY_OLD = 2, - BSON_BIN_UUID = 3, - BSON_BIN_MD5 = 5, - BSON_BIN_USER = 128 + BSON_BIN_BINARY = 0, + BSON_BIN_FUNC = 1, + BSON_BIN_BINARY_OLD = 2, + BSON_BIN_UUID = 3, + BSON_BIN_MD5 = 5, + BSON_BIN_USER = 128 }; typedef enum { - BSON_EOO = 0, - BSON_DOUBLE = 1, - BSON_STRING = 2, - BSON_OBJECT = 3, - BSON_ARRAY = 4, - BSON_BINDATA = 5, - BSON_UNDEFINED = 6, - BSON_OID = 7, - BSON_BOOL = 8, - BSON_DATE = 9, - BSON_NULL = 10, - BSON_REGEX = 11, - BSON_DBREF = 12, /**< Deprecated. */ - BSON_CODE = 13, - BSON_SYMBOL = 14, - BSON_CODEWSCOPE = 15, - BSON_INT = 16, - BSON_TIMESTAMP = 17, - BSON_LONG = 18 + BSON_EOO = 0, + BSON_DOUBLE = 1, + BSON_STRING = 2, + BSON_OBJECT = 3, + BSON_ARRAY = 4, + BSON_BINDATA = 5, + BSON_UNDEFINED = 6, + BSON_OID = 7, + BSON_BOOL = 8, + BSON_DATE = 9, + BSON_NULL = 10, + BSON_REGEX = 11, + BSON_DBREF = 12, /**< Deprecated. */ + BSON_CODE = 13, + BSON_SYMBOL = 14, + BSON_CODEWSCOPE = 15, + BSON_INT = 16, + BSON_TIMESTAMP = 17, + BSON_LONG = 18 } bson_type; typedef int bson_bool_t; typedef struct { - const char *cur; - bson_bool_t first; + const char *cur; + bson_bool_t first; const char *last; } bson_iterator; typedef struct { - char *data; - char *cur; - int dataSize; - bson_bool_t finished; - int stack[32]; - int stackPos; - int err; /**< Bitfield representing errors or warnings on this buffer */ - char *errstr; /**< A string representation of the most recent error or warning. */ + char *data; + char *cur; + int dataSize; + bson_bool_t finished; + int stack[32]; + int stackPos; + int err; /**< Bitfield representing errors or warnings on this buffer */ + char *errstr; /**< A string representation of the most recent error or warning. */ } bson; #pragma pack(1) typedef union { - char bytes[12]; - int ints[3]; + char bytes[12]; + int ints[3]; } bson_oid_t; #pragma pack() typedef int64_t bson_date_t; /* milliseconds since epoch UTC */ typedef struct { - int i; /* increment */ - int t; /* time in seconds */ + int i; /* increment */ + int t; /* time in seconds */ } bson_timestamp_t; /* ---------------------------- @@ -1193,27 +1193,27 @@ bson_bool_t bson_check_string( bson *b, const char *string, //#endif static TPT_INLINE void bson_swap_endian64( void *outp, const void *inp ) { - const char *in = ( const char * )inp; - char *out = ( char * )outp; - - out[0] = in[7]; - out[1] = in[6]; - out[2] = in[5]; - out[3] = in[4]; - out[4] = in[3]; - out[5] = in[2]; - out[6] = in[1]; - out[7] = in[0]; + const char *in = ( const char * )inp; + char *out = ( char * )outp; + + out[0] = in[7]; + out[1] = in[6]; + out[2] = in[5]; + out[3] = in[4]; + out[4] = in[3]; + out[5] = in[2]; + out[6] = in[1]; + out[7] = in[0]; } static TPT_INLINE void bson_swap_endian32( void *outp, const void *inp ) { - const char *in = ( const char * )inp; - char *out = ( char * )outp; + const char *in = ( const char * )inp; + char *out = ( char * )outp; - out[0] = in[3]; - out[1] = in[2]; - out[2] = in[1]; - out[3] = in[0]; + out[0] = in[3]; + out[1] = in[2]; + out[2] = in[1]; + out[3] = in[0]; } #endif