Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

minor: astyle

  • Loading branch information...
commit 70bc545d62b2d07ae7070b0a6f0442703639b8a0 1 parent 720a83e
@banker banker authored
View
4 .astylerc
@@ -0,0 +1,4 @@
+--style=java
+--pad-paren-in
+--pad-paren-in
+--align-pointer=name
View
728 src/bson.c
@@ -30,108 +30,125 @@ const int initialBufferSize = 128;
static const int zero = 0;
/* Custom standard function pointers. */
-static void *(*malloc_func)( size_t ) = NULL;
-static void *(*realloc_func)( void *, size_t ) = NULL;
-static void (*free_func)( void * ) = NULL;
-static int (*printf_func)( const char *, va_list ) = NULL;
-static int (*fprintf_func)( FILE*, const char *, va_list ) = NULL;
-static int (*sprintf_func)( char *, const char *, va_list ) = NULL;
-static int (*oid_fuzz_func)( void ) = NULL;
-static int (*oid_inc_func)( void ) = NULL;
+static void *( *malloc_func )( size_t ) = NULL;
+static void *( *realloc_func )( void *, size_t ) = NULL;
+static void ( *free_func )( void * ) = NULL;
+static int ( *printf_func )( const char *, va_list ) = NULL;
+static int ( *fprintf_func )( FILE *, const char *, va_list ) = NULL;
+static int ( *sprintf_func )( char *, const char *, va_list ) = NULL;
+static int ( *oid_fuzz_func )( void ) = NULL;
+static int ( *oid_inc_func )( void ) = NULL;
/* ----------------------------
READING
------------------------------ */
-bson *bson_empty(bson * obj){
- static char * data = "\005\0\0\0\0";
- bson_init_data(obj, data);
+bson *bson_empty( bson *obj ) {
+ static char *data = "\005\0\0\0\0";
+ bson_init_data( obj, data );
return obj;
}
void bson_copy_basic( bson *out, const bson *in ) {
- if (!out) return;
+ if ( !out ) return;
bson_init_size( out, bson_size( in ) );
- memcpy(out->data, in->data, bson_size(in));
+ memcpy( out->data, in->data, bson_size( in ) );
}
-void bson_copy(bson* out, const bson* in) {
+void bson_copy( bson *out, const bson *in ) {
int i;
- if (!out) return;
+ if ( !out ) return;
bson_copy_basic( out, in );
out->cur = in->cur;
out->dataSize = in->dataSize;
out->finished = in->finished;
out->stackPos = in->stackPos;
- for(i=0; i<out->stackPos; i++)
- out->stack[i] = in->stack[i];
+ for( i=0; i<out->stackPos; i++ )
+ out->stack[i] = in->stack[i];
out->err = in->err;
}
-int bson_init_data( bson * b, char * data ){
+int bson_init_data( bson *b, char *data ) {
b->data = data;
return BSON_OK;
}
-int bson_size(const bson * b ){
+int bson_size( const bson *b ) {
int i;
if ( ! b || ! b->data )
return 0;
- bson_little_endian32(&i, b->data);
+ bson_little_endian32( &i, b->data );
return i;
}
-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? */
+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? */
}
}
-void bson_oid_from_string(bson_oid_t* oid, const char* str){
+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]);
+ 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){
+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];
+ 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) ) {
+void bson_set_oid_fuzz( int ( *func )( void ) ) {
oid_fuzz_func = func;
}
-void bson_set_oid_inc( int (*func)(void) ) {
+void bson_set_oid_inc( int ( *func )( void ) ) {
oid_inc_func = func;
}
@@ -139,47 +156,47 @@ void bson_oid_gen( bson_oid_t *oid ) {
static int incr = 0;
static int fuzz = 0;
int i;
- int t = time(NULL);
+ int t = time( NULL );
if( oid_inc_func )
i = oid_inc_func();
else
i = incr++;
- if (!fuzz) {
+ if ( !fuzz ) {
if ( oid_fuzz_func )
fuzz = oid_fuzz_func();
else {
- srand(t);
+ srand( t );
fuzz = rand();
}
}
- bson_big_endian32(&oid->ints[0], &t);
+ bson_big_endian32( &oid->ints[0], &t );
oid->ints[1] = fuzz;
- bson_big_endian32(&oid->ints[2], &i);
+ bson_big_endian32( &oid->ints[2], &i );
}
-time_t bson_oid_generated_time(bson_oid_t* oid){
+time_t bson_oid_generated_time( bson_oid_t *oid ) {
time_t out;
- bson_big_endian32(&out, &oid->ints[0]);
+ bson_big_endian32( &out, &oid->ints[0] );
return out;
}
-void bson_print( bson * b ){
+void bson_print( bson *b ) {
bson_print_raw( b->data , 0 );
}
-void bson_print_raw( const char * data , int depth ){
+void bson_print_raw( const char *data , int depth ) {
bson_iterator i;
- const char * key;
+ const char *key;
int temp;
bson_timestamp_t ts;
char oidhex[25];
bson scope;
bson_iterator_init( &i , data );
- while ( bson_iterator_next( &i ) ){
+ while ( bson_iterator_next( &i ) ) {
bson_type t = bson_iterator_type( &i );
if ( t == 0 )
break;
@@ -188,30 +205,57 @@ void bson_print_raw( const char * data , int depth ){
for ( temp=0; temp<=depth; temp++ )
printf( "\t" );
bson_printf( "%s : %d \t " , key , t );
- switch ( t ){
- case BSON_DOUBLE: printf( "%f" , bson_iterator_double( &i ) ); break;
- case BSON_STRING: printf( "%s" , bson_iterator_string( &i ) ); break;
- case BSON_SYMBOL: printf( "SYMBOL: %s" , bson_iterator_string( &i ) ); break;
- case BSON_OID: bson_oid_to_string(bson_iterator_oid(&i), oidhex); printf( "%s" , oidhex ); break;
- case BSON_BOOL: printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" ); break;
- case BSON_DATE: printf( "%ld" , (long int)bson_iterator_date( &i ) ); break;
- case BSON_BINDATA: printf( "BSON_BINDATA" ); break;
- case BSON_UNDEFINED: printf( "BSON_UNDEFINED" ); break;
- case BSON_NULL: printf( "BSON_NULL" ); break;
- case BSON_REGEX: printf( "BSON_REGEX: %s", bson_iterator_regex( &i ) ); break;
- case BSON_CODE: printf( "BSON_CODE: %s", bson_iterator_code( &i ) ); break;
+ switch ( t ) {
+ case BSON_DOUBLE:
+ printf( "%f" , bson_iterator_double( &i ) );
+ break;
+ case BSON_STRING:
+ printf( "%s" , bson_iterator_string( &i ) );
+ break;
+ case BSON_SYMBOL:
+ printf( "SYMBOL: %s" , bson_iterator_string( &i ) );
+ break;
+ case BSON_OID:
+ bson_oid_to_string( bson_iterator_oid( &i ), oidhex );
+ printf( "%s" , oidhex );
+ break;
+ case BSON_BOOL:
+ printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" );
+ break;
+ case BSON_DATE:
+ printf( "%ld" , ( long int )bson_iterator_date( &i ) );
+ break;
+ case BSON_BINDATA:
+ printf( "BSON_BINDATA" );
+ break;
+ case BSON_UNDEFINED:
+ printf( "BSON_UNDEFINED" );
+ break;
+ case BSON_NULL:
+ printf( "BSON_NULL" );
+ break;
+ case BSON_REGEX:
+ printf( "BSON_REGEX: %s", bson_iterator_regex( &i ) );
+ break;
+ case BSON_CODE:
+ printf( "BSON_CODE: %s", bson_iterator_code( &i ) );
+ break;
case BSON_CODEWSCOPE:
printf( "BSON_CODE_W_SCOPE: %s", bson_iterator_code( &i ) );
bson_init( &scope );
bson_iterator_code_scope( &i, &scope );
- printf("\n\t SCOPE: ");
+ printf( "\n\t SCOPE: " );
bson_print( &scope );
break;
- case BSON_INT: printf( "%d" , bson_iterator_int( &i ) ); break;
- case BSON_LONG: printf( "%ld" , bson_iterator_long( &i ) ); break;
+ case BSON_INT:
+ printf( "%d" , bson_iterator_int( &i ) );
+ break;
+ case BSON_LONG:
+ printf( "%ld" , bson_iterator_long( &i ) );
+ break;
case BSON_TIMESTAMP:
ts = bson_iterator_timestamp( &i );
- printf("i: %d, t: %d", ts.i, ts.t);
+ printf( "i: %d, t: %d", ts.i, ts.t );
break;
case BSON_OBJECT:
case BSON_ARRAY:
@@ -229,221 +273,259 @@ void bson_print_raw( const char * data , int depth ){
ITERATOR
------------------------------ */
-void bson_iterator_init( bson_iterator * i , const char * bson ){
+void bson_iterator_init( bson_iterator *i , const char *bson ) {
i->cur = bson + 4;
i->first = 1;
}
-bson_type bson_find(bson_iterator* it, const bson* obj, const char* name){
- bson_iterator_init(it, obj->data);
- while(bson_iterator_next(it)){
- if (strcmp(name, bson_iterator_key(it)) == 0)
+bson_type bson_find( bson_iterator *it, const bson *obj, const char *name ) {
+ bson_iterator_init( it, obj->data );
+ while( bson_iterator_next( it ) ) {
+ if ( strcmp( name, bson_iterator_key( it ) ) == 0 )
break;
}
- return bson_iterator_type(it);
+ return bson_iterator_type( it );
}
-bson_bool_t bson_iterator_more( const bson_iterator * i ){
- return *(i->cur);
+bson_bool_t bson_iterator_more( const bson_iterator *i ) {
+ return *( i->cur );
}
-bson_type bson_iterator_next( bson_iterator * i ){
+bson_type bson_iterator_next( bson_iterator *i ) {
int ds;
- if ( i->first ){
+ if ( i->first ) {
i->first = 0;
- return (bson_type)(*i->cur);
+ return ( bson_type )( *i->cur );
}
- switch ( bson_iterator_type(i) ){
- case BSON_EOO: return BSON_EOO; /* don't advance */
+ 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_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_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_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;
- }
+ 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 0;
- }
+ default: {
+ char msg[] = "unknown type: 000000000000";
+ bson_numstr( msg+14, ( unsigned )( i->cur[0] ) );
+ bson_fatal_msg( 0, msg );
+ return 0;
}
-
+ }
+
i->cur += 1 + strlen( i->cur + 1 ) + 1 + ds;
- 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];
+bson_type bson_iterator_type( const bson_iterator *i ) {
+ return ( bson_type )i->cur[0];
}
-const char * bson_iterator_key( const bson_iterator * i ){
+const char *bson_iterator_key( const bson_iterator *i ) {
return i->cur + 1;
}
-const char * bson_iterator_value( const bson_iterator * i ){
- const char * t = i->cur + 1;
+const char *bson_iterator_value( const bson_iterator *i ) {
+ const char *t = i->cur + 1;
t += strlen( t ) + 1;
return t;
}
/* types */
-int bson_iterator_int_raw( const bson_iterator * i ){
+int bson_iterator_int_raw( const bson_iterator *i ) {
int out;
- bson_little_endian32(&out, bson_iterator_value( i ));
+ bson_little_endian32( &out, bson_iterator_value( i ) );
return out;
}
-double bson_iterator_double_raw( const bson_iterator * i ){
+double bson_iterator_double_raw( const bson_iterator *i ) {
double out;
- bson_little_endian64(&out, bson_iterator_value( i ));
+ bson_little_endian64( &out, bson_iterator_value( i ) );
return out;
}
-int64_t bson_iterator_long_raw( const bson_iterator * i ){
+int64_t bson_iterator_long_raw( const bson_iterator *i ) {
int64_t out;
- bson_little_endian64(&out, bson_iterator_value( i ));
+ bson_little_endian64( &out, bson_iterator_value( i ) );
return out;
}
-bson_bool_t bson_iterator_bool_raw( const bson_iterator * i ){
+bson_bool_t bson_iterator_bool_raw( const bson_iterator *i ) {
return bson_iterator_value( i )[0];
}
-bson_oid_t * bson_iterator_oid( const bson_iterator * i ){
- return (bson_oid_t*)bson_iterator_value(i);
+bson_oid_t *bson_iterator_oid( const bson_iterator *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;
+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;
}
}
-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;
+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;
}
}
-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;
+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;
}
}
-bson_timestamp_t bson_iterator_timestamp( const bson_iterator * i){
+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);
+ 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;
+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;
}
}
-const char * bson_iterator_string( const bson_iterator * i ){
+const char *bson_iterator_string( const bson_iterator *i ) {
return bson_iterator_value( i ) + 4;
}
-int bson_iterator_string_len( const bson_iterator * i ){
+int bson_iterator_string_len( const bson_iterator *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;
+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;
}
}
-void bson_iterator_code_scope(const bson_iterator * i, bson * scope){
- if (bson_iterator_type(i) == BSON_CODEWSCOPE){
+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, (void*)(bson_iterator_value(i)+8+code_len));
- }else{
- bson_empty(scope);
+ bson_little_endian32( &code_len, bson_iterator_value( i )+4 );
+ bson_init_data( scope, ( void * )( bson_iterator_value( i )+8+code_len ) );
+ } else {
+ bson_empty( scope );
}
}
-bson_date_t bson_iterator_date(const bson_iterator * i){
- return bson_iterator_long_raw(i);
+bson_date_t bson_iterator_date( const bson_iterator *i ) {
+ return bson_iterator_long_raw( i );
}
-time_t bson_iterator_time_t(const bson_iterator * i){
- return bson_iterator_date(i) / 1000;
+time_t bson_iterator_time_t( const bson_iterator *i ) {
+ 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 );
+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 );
}
-char bson_iterator_bin_type( const bson_iterator * i ){
- return bson_iterator_value(i)[4];
+char bson_iterator_bin_type( const bson_iterator *i ) {
+ 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;
+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;
}
-const char * bson_iterator_regex( const bson_iterator * i ){
+const char *bson_iterator_regex( const bson_iterator *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 *bson_iterator_regex_opts( const bson_iterator *i ) {
+ 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));
+void bson_iterator_subobject( const bson_iterator *i, bson *sub ) {
+ bson_init_data( sub, ( char * )bson_iterator_value( i ) );
}
-void bson_iterator_subiterator(const bson_iterator * i, bson_iterator * sub){
- bson_iterator_init(sub, bson_iterator_value(i));
+void bson_iterator_subiterator( const bson_iterator *i, bson_iterator *sub ) {
+ bson_iterator_init( sub, bson_iterator_value( i ) );
}
/* ----------------------------
@@ -454,7 +536,7 @@ static void _bson_init_size( bson *b, int size ) {
if( size == 0 )
b->data = NULL;
else
- b->data = (char*)bson_malloc( size );
+ b->data = ( char * )bson_malloc( size );
b->dataSize = size;
b->cur = b->data + 4;
b->finished = 0;
@@ -471,40 +553,40 @@ void bson_init_size( bson *b, int size ) {
_bson_init_size( b, size );
}
-void bson_append_byte( bson * b, char c ){
+void bson_append_byte( bson *b, char c ) {
b->cur[0] = c;
b->cur++;
}
-void bson_append( bson * b, const void * data, int len ){
+void bson_append( bson *b, const void *data, int len ) {
memcpy( b->cur , data , len );
b->cur += len;
}
-void bson_append32(bson * b, const void * data){
- bson_little_endian32(b->cur, data);
+void bson_append32( bson *b, const void *data ) {
+ bson_little_endian32( b->cur, data );
b->cur += 4;
}
-void bson_append64(bson * b, const void * data){
- bson_little_endian64(b->cur, data);
+void bson_append64( bson *b, const void *data ) {
+ bson_little_endian64( b->cur, data );
b->cur += 8;
}
-int bson_ensure_space( bson * b, const int bytesNeeded ){
+int bson_ensure_space( bson *b, const int bytesNeeded ) {
int pos = b->cur - b->data;
- char * orig = b->data;
+ char *orig = b->data;
int new_size;
- if (b->finished) {
+ if ( b->finished ) {
b->err = BSON_OBJECT_FINISHED;
return BSON_ERROR;
}
- if (pos + bytesNeeded <= b->dataSize)
+ 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 )
@@ -515,9 +597,9 @@ int bson_ensure_space( bson * b, const int bytesNeeded ){
}
}
- b->data = realloc(b->data, new_size);
- if (!b->data)
- bson_fatal_msg(!!b->data, "realloc() failed");
+ b->data = realloc( b->data, new_size );
+ if ( !b->data )
+ bson_fatal_msg( !!b->data, "realloc() failed" );
b->dataSize = new_size;
b->cur += b->data - orig;
@@ -532,20 +614,20 @@ int bson_ensure_space( bson * b, const int bytesNeeded ){
* This buffer is then deallocated by calling
* bson_destroy().
*/
-int bson_finish( bson * b ){
+int bson_finish( bson *b ) {
int i;
- if ( ! b->finished ){
+ 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);
+ bson_little_endian32( b->data, &i );
b->finished = 1;
}
return BSON_OK;
}
-void bson_destroy( bson * b ){
+void bson_destroy( bson *b ) {
bson_free( b->data );
b->err = 0;
b->data = 0;
@@ -553,18 +635,18 @@ void bson_destroy( bson * b ){
b->finished = 1;
}
-static int bson_append_estart( bson * b, int type, const char * name, const int dataSize ){
- const int len = strlen(name) + 1;
+static int bson_append_estart( bson *b, int type, const char *name, const int dataSize ) {
+ const int len = strlen( name ) + 1;
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 ) {
+ 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_byte( b, ( char )type );
bson_append( b, name, len );
return BSON_OK;
}
@@ -573,138 +655,138 @@ static int bson_append_estart( bson * b, int type, const char * name, const int
BUILDING TYPES
------------------------------ */
-int bson_append_int( bson * b, const char * name, const int i ) {
+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;
}
-int bson_append_long( bson * b, const char * name, const int64_t i ) {
+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;
}
-int bson_append_double( bson * b, const char * name, const double d ) {
+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;
}
-int bson_append_bool( bson * b, const char * name, const bson_bool_t i ) {
+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;
}
-int bson_append_null( bson * b, const char * name ) {
+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;
}
-int bson_append_undefined( bson * b, const char * name ) {
+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;
}
-int bson_append_string_base( bson * b, const char * name,
- const char * value, int len, bson_type type) {
+int bson_append_string_base( bson *b, const char *name,
+ const char *value, int len, bson_type type ) {
int sl = len + 1;
- if ( bson_check_string( b, (const char *)value, sl - 1 ) == BSON_ERROR )
+ 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_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);
+int bson_append_string( bson *b, const char *name, const char *value ) {
+ 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);
+int bson_append_symbol( bson *b, const char *name, const char *value ) {
+ 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);
+int bson_append_code( bson *b, const char *name, const char *value ) {
+ 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);
+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 );
}
-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);
+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 );
}
-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);
+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 );
}
-int bson_append_code_w_scope_n( bson * b, const char * name,
- const char * code, int len, const bson * scope) {
+int bson_append_code_w_scope_n( bson *b, const char *name,
+ 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 )
+ 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));
+ 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){
+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 );
}
-int bson_append_binary( bson * b, const char * name, char type, const char * str, int len ){
- if ( type == BSON_BIN_BINARY_OLD ){
+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);
+ 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);
+ 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 ){
+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;
}
-int bson_append_new_oid( bson * b, const char * name ){
+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_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;
+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 )
@@ -714,116 +796,116 @@ int bson_append_regex( bson * b, const char * name, const char * pattern, const
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 )
+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) );
+ 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){
+int bson_append_element( bson *b, const char *name_or_null, const bson_iterator *elem ) {
bson_iterator next = *elem;
int size;
- bson_iterator_next(&next);
+ bson_iterator_next( &next );
size = next.cur - elem->cur;
- if (name_or_null == NULL){
- if( bson_ensure_space(b, size) == BSON_ERROR )
+ 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);
+ 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;
}
-int bson_append_timestamp( bson * b, const char * name, bson_timestamp_t * ts ){
+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;
- bson_append32( b , &(ts->i) );
- bson_append32( b , &(ts->t) );
+ bson_append32( b , &( ts->i ) );
+ bson_append32( b , &( ts->t ) );
return BSON_OK;
}
-int bson_append_date( bson * b, const char * name, bson_date_t millis ) {
+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;
}
-int bson_append_time_t( bson * b, const char * name, time_t secs) {
- return bson_append_date(b, name, (bson_date_t)secs * 1000);
+int bson_append_time_t( bson *b, const char *name, time_t secs ) {
+ return bson_append_date( b, name, ( bson_date_t )secs * 1000 );
}
-int bson_append_start_object( bson * b, const char * name ) {
+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;
}
-int bson_append_start_array( bson * b, const char * name ) {
+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;
}
-int bson_append_finish_object( bson * b ){
- char * start;
+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 );
start = b->data + b->stack[ --b->stackPos ];
i = b->cur - start;
- bson_little_endian32(start, &i);
+ bson_little_endian32( start, &i );
return BSON_OK;
}
static bson_err_handler err_handler = NULL;
-bson_err_handler set_bson_err_handler(bson_err_handler func){
+bson_err_handler set_bson_err_handler( bson_err_handler func ) {
bson_err_handler old = err_handler;
err_handler = func;
return old;
}
-void bson_set_malloc( void *(*func)( size_t ) ) {
+void bson_set_malloc( void *( *func )( size_t ) ) {
malloc_func = func;
}
-void *bson_malloc(int size) {
+void *bson_malloc( int size ) {
void *p;
- if( malloc_func)
- p = malloc_func(size);
+ if( malloc_func )
+ p = malloc_func( size );
else
- p = malloc(size);
- bson_fatal_msg(!!p, "malloc() failed");
+ p = malloc( size );
+ bson_fatal_msg( !!p, "malloc() failed" );
return p;
}
-void bson_set_realloc( void *(*func)( void *, size_t ) ) {
+void bson_set_realloc( void *( *func )( void *, size_t ) ) {
realloc_func = func;
}
-void* bson_realloc(void* ptr, int size){
+void *bson_realloc( void *ptr, int size ) {
void *p;
if( realloc_func )
- p = realloc_func(ptr, size);
+ p = realloc_func( ptr, size );
else
- p = realloc(ptr, size);
- bson_fatal_msg(!!p, "realloc() failed");
+ p = realloc( ptr, size );
+ bson_fatal_msg( !!p, "realloc() failed" );
return p;
}
-void bson_set_free( void (*func)( void * ) ) {
+void bson_set_free( void ( *func )( void * ) ) {
free_func = func;
}
@@ -834,7 +916,7 @@ void bson_free( void *ptr ) {
free( ptr );
}
-void bson_set_printf( int (*func)( const char *, va_list ) ) {
+void bson_set_printf( int ( *func )( const char *, va_list ) ) {
printf_func = func;
}
@@ -851,7 +933,7 @@ int bson_printf( const char *format, ... ) {
return ret;
}
-void bson_set_fprintf( int (*func)( FILE*, const char *, va_list ) ) {
+void bson_set_fprintf( int ( *func )( FILE *, const char *, va_list ) ) {
fprintf_func = func;
}
@@ -868,11 +950,11 @@ int bson_fprintf( FILE *fp, const char *format, ... ) {
return ret;
}
-void bson_set_sprintf( int (*func)( char *, const char *, va_list ) ) {
+void bson_set_sprintf( int ( *func )( char *, const char *, va_list ) ) {
sprintf_func = func;
}
-int bson_sprintf( char* s, const char *format, ... ) {
+int bson_sprintf( char *s, const char *format, ... ) {
va_list ap;
int ret;
va_start( ap, format );
@@ -891,32 +973,32 @@ int bson_sprintf( char* s, const char *format, ... ) {
*
* @param
*/
-void bson_builder_error( bson* b ) {
+void bson_builder_error( bson *b ) {
if( err_handler )
- err_handler( "BSON error." );
+ err_handler( "BSON error." );
}
-void bson_fatal( int ok ){
- bson_fatal_msg(ok, "");
+void bson_fatal( int ok ) {
+ bson_fatal_msg( ok, "" );
}
-void bson_fatal_msg( int ok , const char* msg){
- if (ok)
+void bson_fatal_msg( int ok , const char *msg ) {
+ if ( ok )
return;
- if (err_handler){
- err_handler(msg);
+ if ( err_handler ) {
+ err_handler( msg );
}
bson_fprintf( stderr , "error: %s\n" , msg );
- exit(-5);
+ exit( -5 );
}
extern const char bson_numstrs[1000][4];
-void bson_numstr(char* str, int i){
- if(i < 1000)
- memcpy(str, bson_numstrs[i], 4);
+void bson_numstr( char *str, int i ) {
+ if( i < 1000 )
+ memcpy( str, bson_numstrs[i], 4 );
else
- bson_sprintf(str,"%d", i);
+ bson_sprintf( str,"%d", i );
}
View
234 src/bson.h
@@ -40,9 +40,9 @@ enum bson_error_t {
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_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. */
};
enum bson_binary_subtype_t {
@@ -79,23 +79,23 @@ typedef enum {
typedef int bson_bool_t;
typedef struct {
- const char * cur;
+ const char *cur;
bson_bool_t first;
} bson_iterator;
typedef struct {
- char * data;
- char * cur;
+ 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 *errstr; /**< A string representation of the most recent error or warning. */
} bson;
#pragma pack(1)
-typedef union{
+typedef union {
char bytes[12];
int ints[3];
} bson_oid_t;
@@ -104,8 +104,8 @@ typedef union{
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;
/* ----------------------------
@@ -119,21 +119,21 @@ typedef struct {
*
* @return the size.
*/
-int bson_size(const bson * b );
+int bson_size( const bson *b );
/**
* Destroy a BSON object.
*
* @param b the object to destroy.
*/
-void bson_destroy( bson * b );
+void bson_destroy( bson *b );
/**
* Print a string representation of a BSON object.
*
* @param b the BSON object to print.
*/
-void bson_print( bson * b );
+void bson_print( bson *b );
/**
* Print a string representation of a BSON object.
@@ -141,7 +141,7 @@ void bson_print( bson * b );
* @param bson the raw data to print.
* @param depth the depth to recurse the object.x
*/
-void bson_print_raw( const char * bson , int depth );
+void bson_print_raw( const char *bson , int depth );
/* advances iterator to named field */
/* returns BSON_EOO (which is false) if field not found */
@@ -154,7 +154,7 @@ void bson_print_raw( const char * bson , int depth );
*
* @return the type of the found object, bson_eoo if it is not found.
*/
-bson_type bson_find(bson_iterator* it, const bson* obj, const char* name);
+bson_type bson_find( bson_iterator *it, const bson *obj, const char *name );
/**
* Initialize a bson_iterator.
@@ -162,7 +162,7 @@ bson_type bson_find(bson_iterator* it, const bson* obj, const char* name);
* @param i the bson_iterator to initialize.
* @param bson the BSON object to associate with the iterator.
*/
-void bson_iterator_init( bson_iterator * i , const char * bson );
+void bson_iterator_init( bson_iterator *i , const char *bson );
/* more returns true for eoo. best to loop with bson_iterator_next(&it) */
/**
@@ -172,7 +172,7 @@ void bson_iterator_init( bson_iterator * i , const char * bson );
*
* @return returns true if there is more data.
*/
-bson_bool_t bson_iterator_more( const bson_iterator * i );
+bson_bool_t bson_iterator_more( const bson_iterator *i );
/**
* Point the iterator at the next BSON object.
@@ -181,7 +181,7 @@ bson_bool_t bson_iterator_more( const bson_iterator * i );
*
* @return the type of the next BSON object.
*/
-bson_type bson_iterator_next( bson_iterator * i );
+bson_type bson_iterator_next( bson_iterator *i );
/**
* Get the type of the BSON object currently pointed to by the iterator.
@@ -190,7 +190,7 @@ bson_type bson_iterator_next( bson_iterator * i );
*
* @return the type of the current BSON object.
*/
-bson_type bson_iterator_type( const bson_iterator * i );
+bson_type bson_iterator_type( const bson_iterator *i );
/**
* Get the key of the BSON object currently pointed to by the iterator.
@@ -199,7 +199,7 @@ bson_type bson_iterator_type( const bson_iterator * i );
*
* @return the key of the current BSON object.
*/
-const char * bson_iterator_key( const bson_iterator * i );
+const char *bson_iterator_key( const bson_iterator *i );
/**
* Get the value of the BSON object currently pointed to by the iterator.
@@ -208,7 +208,7 @@ const char * bson_iterator_key( const bson_iterator * i );
*
* @return the value of the current BSON object.
*/
-const char * bson_iterator_value( const bson_iterator * i );
+const char *bson_iterator_value( const bson_iterator *i );
/* these convert to the right type (return 0 if non-numeric) */
/**
@@ -219,7 +219,7 @@ const char * bson_iterator_value( const bson_iterator * i );
*
* @return the value of the current BSON object.
*/
-double bson_iterator_double( const bson_iterator * i );
+double bson_iterator_double( const bson_iterator *i );
/**
* Get the int value of the BSON object currently pointed to by the iterator.
@@ -228,7 +228,7 @@ double bson_iterator_double( const bson_iterator * i );
*
* @return the value of the current BSON object.
*/
-int bson_iterator_int( const bson_iterator * i );
+int bson_iterator_int( const bson_iterator *i );
/**
* Get the long value of the BSON object currently pointed to by the iterator.
@@ -237,7 +237,7 @@ int bson_iterator_int( const bson_iterator * i );
*
* @return the value of the current BSON object.
*/
-int64_t bson_iterator_long( const bson_iterator * i );
+int64_t bson_iterator_long( const bson_iterator *i );
/* return the bson timestamp as a whole or in parts */
/**
@@ -248,7 +248,7 @@ int64_t bson_iterator_long( const bson_iterator * i );
*
* @return the value of the current BSON object.
*/
-bson_timestamp_t bson_iterator_timestamp( const bson_iterator * i );
+bson_timestamp_t bson_iterator_timestamp( const bson_iterator *i );
/**
* Get the boolean value of the BSON object currently pointed to by
@@ -260,7 +260,7 @@ bson_timestamp_t bson_iterator_timestamp( const bson_iterator * i );
*/
/* false: boolean false, 0 in any type, or null */
/* true: anything else (even empty strings and objects) */
-bson_bool_t bson_iterator_bool( const bson_iterator * i );
+bson_bool_t bson_iterator_bool( const bson_iterator *i );
/**
* Get the double value of the BSON object currently pointed to by the
@@ -271,7 +271,7 @@ bson_bool_t bson_iterator_bool( const bson_iterator * i );
* @return the value of the current BSON object.
*/
/* these assume you are using the right type */
-double bson_iterator_double_raw( const bson_iterator * i );
+double bson_iterator_double_raw( const bson_iterator *i );
/**
* Get the int value of the BSON object currently pointed to by the
@@ -281,7 +281,7 @@ double bson_iterator_double_raw( const bson_iterator * i );
*
* @return the value of the current BSON object.
*/
-int bson_iterator_int_raw( const bson_iterator * i );
+int bson_iterator_int_raw( const bson_iterator *i );
/**
* Get the long value of the BSON object currently pointed to by the
@@ -291,7 +291,7 @@ int bson_iterator_int_raw( const bson_iterator * i );
*
* @return the value of the current BSON object.
*/
-int64_t bson_iterator_long_raw( const bson_iterator * i );
+int64_t bson_iterator_long_raw( const bson_iterator *i );
/**
* Get the bson_bool_t value of the BSON object currently pointed to by the
@@ -301,17 +301,17 @@ int64_t bson_iterator_long_raw( const bson_iterator * i );
*
* @return the value of the current BSON object.
*/
-bson_bool_t bson_iterator_bool_raw( const bson_iterator * i );
+bson_bool_t bson_iterator_bool_raw( const bson_iterator *i );
/**
* Get the bson_oid_t value of the BSON object currently pointed to by the
- * iterator.
+ * iterator.
*
* @param i the bson_iterator
*
* @return the value of the current BSON object.
*/
-bson_oid_t* bson_iterator_oid( const bson_iterator * i );
+bson_oid_t *bson_iterator_oid( const bson_iterator *i );
/**
* Get the string value of the BSON object currently pointed to by the
@@ -322,21 +322,21 @@ bson_oid_t* bson_iterator_oid( const bson_iterator * i );
* @return the value of the current BSON object.
*/
/* these can also be used with bson_code and bson_symbol*/
-const char * bson_iterator_string( const bson_iterator * i );
+const char *bson_iterator_string( const bson_iterator *i );
/**
* Get the string length of the BSON object currently pointed to by the
- * iterator.
+ * iterator.
*
* @param i the bson_iterator
*
* @return the length of the current BSON object.
*/
-int bson_iterator_string_len( const bson_iterator * i );
+int bson_iterator_string_len( const bson_iterator *i );
/**
* Get the code value of the BSON object currently pointed to by the
- * iterator. Works with bson_code, bson_codewscope, and BSON_STRING
+ * iterator. Works with bson_code, bson_codewscope, and BSON_STRING
* returns NULL for everything else.
*
* @param i the bson_iterator
@@ -345,97 +345,97 @@ int bson_iterator_string_len( const bson_iterator * i );
*/
/* works with bson_code, bson_codewscope, and BSON_STRING */
/* returns NULL for everything else */
-const char * bson_iterator_code(const bson_iterator * i);
+const char *bson_iterator_code( const bson_iterator *i );
/**
- * Calls bson_empty on scope if not a bson_codewscope
+ * Calls bson_empty on scope if not a bson_codewscope
*
* @param i the bson_iterator.
* @param scope the bson scope.
*/
/* calls bson_empty on scope if not a bson_codewscope */
-void bson_iterator_code_scope(const bson_iterator * i, bson * scope);
+void bson_iterator_code_scope( const bson_iterator *i, bson *scope );
/**
* Get the date value of the BSON object currently pointed to by the
- * iterator.
+ * iterator.
*
* @param i the bson_iterator
*
* @return the date value of the current BSON object.
*/
/* both of these only work with bson_date */
-bson_date_t bson_iterator_date(const bson_iterator * i);
+bson_date_t bson_iterator_date( const bson_iterator *i );
/**
* Get the time value of the BSON object currently pointed to by the
- * iterator.
+ * iterator.
*
* @param i the bson_iterator
*
* @return the time value of the current BSON object.
*/
-time_t bson_iterator_time_t(const bson_iterator * i);
+time_t bson_iterator_time_t( const bson_iterator *i );
/**
* Get the length of the BSON binary object currently pointed to by the
- * iterator.
+ * iterator.
*
* @param i the bson_iterator
*
* @return the length of the current BSON binary object.
*/
-int bson_iterator_bin_len( const bson_iterator * i );
+int bson_iterator_bin_len( const bson_iterator *i );
/**
* Get the type of the BSON binary object currently pointed to by the
- * iterator.
+ * iterator.
*
* @param i the bson_iterator
*
* @return the type of the current BSON binary object.
*/
-char bson_iterator_bin_type( const bson_iterator * i );
+char bson_iterator_bin_type( const bson_iterator *i );
/**
* Get the value of the BSON binary object currently pointed to by the
- * iterator.
+ * iterator.
*
* @param i the bson_iterator
*
* @return the value of the current BSON binary object.
*/
-const char * bson_iterator_bin_data( const bson_iterator * i );
+const char *bson_iterator_bin_data( const bson_iterator *i );
/**
* Get the value of the BSON regex object currently pointed to by the
- * iterator.
+ * iterator.
*
* @param i the bson_iterator
*
* @return the value of the current BSON regex object.
*/
-const char * bson_iterator_regex( const bson_iterator * i );
+const char *bson_iterator_regex( const bson_iterator *i );
/**
* Get the options of the BSON regex object currently pointed to by the
- * iterator.
+ * iterator.
*
* @param i the bson_iterator.
*
* @return the options of the current BSON regex object.
*/
-const char * bson_iterator_regex_opts( const bson_iterator * i );
+const char *bson_iterator_regex_opts( const bson_iterator *i );
/* these work with BSON_OBJECT and BSON_ARRAY */
/**
* Get the BSON subobject currently pointed to by the
- * iterator.
+ * iterator.
*
* @param i the bson_iterator.
* @param sub the BSON subobject destination.
*/
-void bson_iterator_subobject(const bson_iterator * i, bson * sub);
+void bson_iterator_subobject( const bson_iterator *i, bson *sub );
/**
* Get a bson_iterator that on the BSON subobject.
@@ -443,16 +443,16 @@ void bson_iterator_subobject(const bson_iterator * i, bson * sub);
* @param i the bson_iterator.
* @param sub the iterator to point at the BSON subobject.
*/
-void bson_iterator_subiterator(const bson_iterator * i, bson_iterator * sub);
+void bson_iterator_subiterator( const bson_iterator *i, bson_iterator *sub );
/* str must be at least 24 hex chars + null byte */
/**
- * Create a bson_oid_t from a string.
+ * Create a bson_oid_t from a string.
*
* @param oid the bson_oid_t destination.
* @param str a null terminated string comprised of at least 24 hex chars.
*/
-void bson_oid_from_string(bson_oid_t* oid, const char* str);
+void bson_oid_from_string( bson_oid_t *oid, const char *str );
/**
* Create a string representation of the bson_oid_t.
@@ -460,14 +460,14 @@ void bson_oid_from_string(bson_oid_t* oid, const char* str);
* @param oid the bson_oid_t source.
* @param str the string representation destination.
*/
-void bson_oid_to_string(const bson_oid_t* oid, char* str);
+void bson_oid_to_string( const bson_oid_t *oid, char *str );
/**
* Create a bson_oid object.
*
* @param oid the destination for the newly created bson_oid_t.
*/
-void bson_oid_gen(bson_oid_t* oid);
+void bson_oid_gen( bson_oid_t *oid );
/**
* Set a function to be used to generate the second four bytes
@@ -475,7 +475,7 @@ void bson_oid_gen(bson_oid_t* oid);
*
* @param func a pointer to a function that returns an int.
*/
-void bson_set_oid_fuzz( int (*func)(void) );
+void bson_set_oid_fuzz( int ( *func )( void ) );
/**
* Set a function to be used to generate the incrementing part
@@ -484,14 +484,14 @@ void bson_set_oid_fuzz( int (*func)(void) );
*
* @param func a pointer to a function that returns an int.
*/
-void bson_set_oid_inc( int (*func)(void) );
+void bson_set_oid_inc( int ( *func )( void ) );
/**
* Get the time a bson_oid_t was created.
*
* @param oid the bson_oid_t.
*/
-time_t bson_oid_generated_time(bson_oid_t* oid); /* Gives the time the OID was created */
+time_t bson_oid_generated_time( bson_oid_t *oid ); /* Gives the time the OID was created */
/* ----------------------------
BUILDING
@@ -505,7 +505,7 @@ time_t bson_oid_generated_time(bson_oid_t* oid); /* Gives the time the OID was c
* @note When finished, you must pass the bson object to
* bson_destroy( ).
*/
-void bson_init( bson* b );
+void bson_init( bson *b );
/**
* Initialize a BSON object, and point its data
@@ -516,20 +516,20 @@ void bson_init( bson* b );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_init_data( bson * b , char * data );
+int bson_init_data( bson *b , char *data );
void bson_init_size( bson *b, int size );
/**
* Grow a bson object.
- *
+ *
* @param b the bson to grow.
* @param bytesNeeded the additional number of bytes needed.
*
* @return BSON_OK or BSON_ERROR with the bson error object set.
* Exits if allocation fails.
*/
-int bson_ensure_space( bson * b, const int bytesNeeded );
+int bson_ensure_space( bson *b, const int bytesNeeded );
/**
* Finalize a bson object.
@@ -539,15 +539,15 @@ int bson_ensure_space( bson * b, const int bytesNeeded );
* @return the standard error code. To deallocate memory,
* call bson_destroy on the bson object.
*/
-int bson_finish( bson * b );
+int bson_finish( bson *b );
-/**
+/**
* Destroy a bson object.
*
* @param b the bson object to destroy.
*
*/
-void bson_destroy( bson * b );
+void bson_destroy( bson *b );
/**
* Returns a pointer to a static empty BSON object.
@@ -557,7 +557,7 @@ void bson_destroy( bson * b );
* @return the empty initialized BSON object.
*/
/* returns pointer to static empty bson object */
-bson * bson_empty(bson * obj);
+bson *bson_empty( bson *obj );
/**
* Copy BSON data only from one object to another.
@@ -573,7 +573,7 @@ void bson_copy_basic( bson *out, const bson *in );
* @param out the copy destination BSON object.
* @param in the copy source BSON object.
*/
-void bson_copy(bson* out, const bson* in); /* puts data in new buffer. NOOP if out==NULL */
+void bson_copy( bson *out, const bson *in ); /* puts data in new buffer. NOOP if out==NULL */
/**
* Append a previously created bson_oid_t to a bson object.
@@ -584,7 +584,7 @@ void bson_copy(bson* out, const bson* in); /* puts data in new buffer. NOOP if o
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_oid( bson * b, const char * name, const bson_oid_t* oid );
+int bson_append_oid( bson *b, const char *name, const bson_oid_t *oid );
/**
* Append a bson_oid_t to a bson.
@@ -594,7 +594,7 @@ int bson_append_oid( bson * b, const char * name, const bson_oid_t* oid );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_new_oid( bson * b, const char * name );
+int bson_append_new_oid( bson *b, const char *name );
/**
* Append an int to a bson.
@@ -605,7 +605,7 @@ int bson_append_new_oid( bson * b, const char * name );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_int( bson * b, const char * name, const int i );
+int bson_append_int( bson *b, const char *name, const int i );
/**
* Append an long to a bson.
@@ -616,7 +616,7 @@ int bson_append_int( bson * b, const char * name, const int i );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_long( bson * b, const char * name, const int64_t i );
+int bson_append_long( bson *b, const char *name, const int64_t i );
/**
* Append an double to a bson.
@@ -627,7 +627,7 @@ int bson_append_long( bson * b, const char * name, const int64_t i );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_double( bson * b, const char * name, const double d );
+int bson_append_double( bson *b, const char *name, const double d );
/**
* Append a string to a bson.
@@ -638,7 +638,7 @@ int bson_append_double( bson * b, const char * name, const double d );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_string( bson * b, const char * name, const char * str );
+int bson_append_string( bson *b, const char *name, const char *str );
/**
* Append len bytes of a string to a bson.
@@ -647,10 +647,10 @@ int bson_append_string( bson * b, const char * name, const char * str );
* @param name the key for the string.
* @param str the string to append.
* @param len the number of bytes from str to append.
- *
+ *
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_string_n( bson * b, const char * name, const char * str, int len);
+int bson_append_string_n( bson *b, const char *name, const char *str, int len );
/**
* Append a symbol to a bson.
@@ -658,10 +658,10 @@ int bson_append_string_n( bson * b, const char * name, const char * str, int len
* @param b the bson to append to.
* @param name the key for the symbol.
* @param str the symbol to append.
- *
+ *
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_symbol( bson * b, const char * name, const char * str );
+int bson_append_symbol( bson *b, const char *name, const char *str );
/**
* Append len bytes of a symbol to a bson.
@@ -670,10 +670,10 @@ int bson_append_symbol( bson * b, const char * name, const char * str );
* @param name the key for the symbol.
* @param str the symbol to append.
* @param len the number of bytes from str to append.
- *
+ *
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_symbol_n( bson * b, const char * name, const char * str, int len );
+int bson_append_symbol_n( bson *b, const char *name, const char *str, int len );
/**
* Append code to a bson.
@@ -682,10 +682,10 @@ int bson_append_symbol_n( bson * b, const char * name, const char * str, int len
* @param name the key for the code.
* @param str the code to append.
* @param len the number of bytes from str to append.
- *
+ *
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_code( bson * b, const char * name, const char * str );
+int bson_append_code( bson *b, const char *name, const char *str );
/**
* Append len bytes of code to a bson.
@@ -694,10 +694,10 @@ int bson_append_code( bson * b, const char * name, const char * str );
* @param name the key for the code.
* @param str the code to append.
* @param len the number of bytes from str to append.
- *
+ *
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_code_n( bson * b, const char * name, const char * str, int len );
+int bson_append_code_n( bson *b, const char *name, const char *str, int len );
/**
* Append code to a bson with scope.
@@ -706,10 +706,10 @@ int bson_append_code_n( bson * b, const char * name, const char * str, int len )
* @param name the key for the code.
* @param str the string to append.
* @param scope a BSON object containing the scope.
- *
+ *
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_code_w_scope( bson * b, const char * name, const char * code, const bson * scope);
+int bson_append_code_w_scope( bson *b, const char *name, const char *code, const bson *scope );
/**
* Append len bytes of code to a bson with scope.
@@ -719,10 +719,10 @@ int bson_append_code_w_scope( bson * b, const char * name, const char * code, co
* @param str the string to append.
* @param len the number of bytes from str to append.
* @param scope a BSON object containing the scope.
- *
+ *
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_code_w_scope_n( bson * b, const char * name, const char * code, int size, const bson * scope);
+int bson_append_code_w_scope_n( bson *b, const char *name, const char *code, int size, const bson *scope );
/**
* Append binary data to a bson.
@@ -735,7 +735,7 @@ int bson_append_code_w_scope_n( bson * b, const char * name, const char * code,
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_binary( bson * b, const char * name, char type, const char * str, int len );
+int bson_append_binary( bson *b, const char *name, char type, const char *str, int len );
/**
* Append a bson_bool_t to a bson.
@@ -746,7 +746,7 @@ int bson_append_binary( bson * b, const char * name, char type, const char * str
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_bool( bson * b, const char * name, const bson_bool_t v );
+int bson_append_bool( bson *b, const char *name, const bson_bool_t v );
/**
* Append a null value to a bson.
@@ -756,7 +756,7 @@ int bson_append_bool( bson * b, const char * name, const bson_bool_t v );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_null( bson * b, const char * name );
+int bson_append_null( bson *b, const char *name );
/**
* Append an undefined value to a bson.
@@ -766,7 +766,7 @@ int bson_append_null( bson * b, const char * name );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_undefined( bson * b, const char * name );
+int bson_append_undefined( bson *b, const char *name );
/**
* Append a regex value to a bson.
@@ -778,7 +778,7 @@ int bson_append_undefined( bson * b, const char * name );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_regex( bson * b, const char * name, const char * pattern, const char * opts );
+int bson_append_regex( bson *b, const char *name, const char *pattern, const char *opts );
/**
* Append bson data to a bson.
@@ -789,7 +789,7 @@ int bson_append_regex( bson * b, const char * name, const char * pattern, const
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_bson( bson * b, const char * name, const bson* bson);
+int bson_append_bson( bson *b, const char *name, const bson *bson );
/**
* Append a BSON element to a bson from the current point of an iterator.
@@ -800,7 +800,7 @@ int bson_append_bson( bson * b, const char * name, const bson* bson);
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_element( bson * b, const char * name_or_null, const bson_iterator* elem);
+int bson_append_element( bson *b, const char *name_or_null, const bson_iterator *elem );
/**
* Append a bson_timestamp_t value to a bson.
@@ -811,7 +811,7 @@ int bson_append_element( bson * b, const char * name_or_null, const bson_iterato
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_timestamp( bson * b, const char * name, bson_timestamp_t * ts );
+int bson_append_timestamp( bson *b, const char *name, bson_timestamp_t *ts );
/* these both append a bson_date */
/**
@@ -823,7 +823,7 @@ int bson_append_timestamp( bson * b, const char * name, bson_timestamp_t * ts );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_date(bson * b, const char * name, bson_date_t millis);
+int bson_append_date( bson *b, const char *name, bson_date_t millis );
/**
* Append a time_t value to a bson.
@@ -834,7 +834,7 @@ int bson_append_date(bson * b, const char * name, bson_date_t millis);
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_time_t(bson * b, const char * name, time_t secs);
+int bson_append_time_t( bson *b, const char *name, time_t secs );
/**
* Start appending a new object to a bson.
@@ -844,7 +844,7 @@ int bson_append_time_t(bson * b, const char * name, time_t secs);
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_start_object( bson * b, const char * name );
+int bson_append_start_object( bson *b, const char *name );
/**
* Start appending a new array to a bson.
@@ -854,7 +854,7 @@ int bson_append_start_object( bson * b, const char * name );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_start_array( bson * b, const char * name );
+int bson_append_start_array( bson *b, const char *name );
/**
* Finish appending a new object or array to a bson.
@@ -863,20 +863,20 @@ int bson_append_start_array( bson * b, const char * name );
*
* @return BSON_OK or BSON_ERROR.
*/
-int bson_append_finish_object( bson * b );
+int bson_append_finish_object( bson *b );
-void bson_numstr(char* str, int i);
+void bson_numstr( char *str, int i );
-void bson_incnumstr(char* str);
+void bson_incnumstr( char *str );
/* Error handling and stadard library function over-riding. */
/* -------------------------------------------------------- */
/* bson_err_handlers shouldn't return!!! */
-typedef void(*bson_err_handler)(const char* errmsg);
+typedef void( *bson_err_handler )( const char *errmsg );
/* Set an alternative to the standard malloc(). */
-void bson_set_malloc( void *(*func)( size_t ) );
+void bson_set_malloc( void *( *func )( size_t ) );
/**
* Allocates memory and checks return value, exiting fatally if malloc() fails.
@@ -890,7 +890,7 @@ void bson_set_malloc( void *(*func)( size_t ) );
void *bson_malloc( int size );
/* Set an alternative to the standard realloc(). */
-void bson_set_realloc( void *(*func)( void *, size_t ) );
+void bson_set_realloc( void *( *func )( void *, size_t ) );
/**
* Changes the size of allocated memory and checks return value,
@@ -906,7 +906,7 @@ void bson_set_realloc( void *(*func)( void *, size_t ) );
void *bson_realloc( void *ptr, int size );
/* Set an alternative to the standard free(). */
-void bson_set_free( void (*func)( void * ) );
+void bson_set_free( void ( *func )( void * ) );
/**
* Release memory allocated by malloc or realloc.
@@ -916,7 +916,7 @@ void bson_set_free( void (*func)( void * ) );
void bson_free( void *ptr );
/* Set an alternative to the standard printf(). */
-void bson_set_printf( int (*func)( const char *, va_list ) );
+void bson_set_printf( int ( *func )( const char *, va_list ) );
/**
* Use this instead of printf.
@@ -924,7 +924,7 @@ void bson_set_printf( int (*func)( const char *, va_list ) );
int bson_printf( const char *format, ... );
/* Set an alternative to the standard fprintf(). */
-void bson_set_fprintf( int (*func)( FILE *, const char *, va_list ) );
+void bson_set_fprintf( int ( *func )( FILE *, const char *, va_list ) );
/**
* Use this instead of fprintf.
@@ -932,7 +932,7 @@ void bson_set_fprintf( int (*func)( FILE *, const char *, va_list ) );
int bson_fprintf( FILE *fp, const char *format, ... );
/* Set an alternative to the standard sprintf(). */
-void bson_set_sprintf( int (*func)( char *, const char *, va_list ) );
+void bson_set_sprintf( int ( *func )( char *, const char *, va_list ) );
/**
* Use this instead of sprintf.
@@ -946,7 +946,7 @@ int bson_sprintf( char *s, const char *format, ... );
*
* @return the old error handling function, or NULL.
*/
-bson_err_handler set_bson_err_handler(bson_err_handler func);
+bson_err_handler set_bson_err_handler( bson_err_handler func );
/* does nothing if ok != 0 */
/**
@@ -962,14 +962,14 @@ void bson_fatal( int ok );
* @param ok exits if ok is equal to 0.
* @param msg prints to stderr before exiting.
*/
-void bson_fatal_msg( int ok, const char* msg );
+void bson_fatal_msg( int ok, const char *msg );
/**
* Invoke the error handler, but do not exit.
*
* @param b the buffer object.
*/
-void bson_builder_error( bson* b );
+void bson_builder_error( bson *b );
MONGO_EXTERN_C_END
#endif
View
70 src/encoding.c
@@ -67,31 +67,43 @@ static const char trailingBytesForUTF8[256] = {
* If presented with a length > 4, this returns 0. The Unicode
* definition of UTF-8 goes up to 4-byte sequences.
*/
-static int isLegalUTF8(const unsigned char* source, int length) {
+static int isLegalUTF8( const unsigned char *source, int length ) {
unsigned char a;
- const unsigned char* srcptr = source + length;
- switch (length) {
- default: return 0;
+ 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) {
+ 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 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;
+ 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) {
+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;
@@ -100,18 +112,18 @@ static int bson_validate_string( bson* b, const unsigned char* string,
b->err |= BSON_FIELD_INIT_DOLLAR;
}
- while (position < length) {
- if (check_dot && *(string + position) == '.') {
+ 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) {
+ if ( check_utf8 ) {
+ sequence_length = trailingBytesForUTF8[*( string + position )] + 1;
+ if