Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

bcon.c from C Driver for MongoDB #14

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

bcon.c from C Driver for MongoDB #14

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
372 changes: 372 additions & 0 deletions bcon.c
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,372 @@
/* bcon.c */

/* Copyright 2009-2012 10gen Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <assert.h>
#include "bcon.h"

#ifndef NOT_REACHED
#define NOT_REACHED 0
#endif

#define ARRAY_INDEX_BUFFER_SIZE 9

const char *bcon_errstr[] = {
"OK",
"ERROR",
"bcon document or nesting incomplete",
"bson finish error"
};

bcon_error_t bson_append_bcon_array(bson *b, const bcon *bc);

/* should be static, but it used by test files */
bcon_token_t bcon_token(char *s);

bcon_token_t bcon_token(char *s) {
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The function is too complicated

bcon_token( char * s) now has cyclomatic complexity of 21.
Corresponding modifications started here.
Split your routines to keep cyclomatic complexity below 10 to improve their maintainability.

This comment was generated with the following checker: high_cyclomatic_complexity

if (s == 0) return Token_EOD;
switch (s[0]) {
case ':': if (s[1] != '\0' && s[2] != '\0' && s[3] != '\0' && s[4] == '\0' &&
s[3] == ':' && (s[1] == '_' || s[1] == 'P' || s[1] == 'R'))
return Token_Typespec; break;
case '{': if (s[1] == '\0') return Token_OpenBrace; break;
case '}': if (s[1] == '\0') return Token_CloseBrace; break;
case '[': if (s[1] == '\0') return Token_OpenBracket; break;
case ']': if (s[1] == '\0') return Token_CloseBracket; break;
case '.': if (s[1] == '\0') return Token_End; break;
}
return Token_Default;
}

static bcon_error_t bson_bcon_key_value(bson *b, const char *key, const char *typespec, const bcon bci) {
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The function is too long

bson_bcon_key_value( bson * b , const char * key , const char * typespec , const bcon bci) now spans 88 lines.
Corresponding modifications started here.
Keep your functions' length within 50 lines to improve readability.

This comment was generated with the following checker: long_method

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The function is too complicated

bson_bcon_key_value( bson * b , const char * key , const char * typespec , const bcon bci) now has cyclomatic complexity of 43.
Corresponding modifications started here.
Split your routines to keep cyclomatic complexity below 10 to improve their maintainability.

This comment was generated with the following checker: high_cyclomatic_complexity

bcon_error_t ret = BCON_OK;
bson_oid_t oid;
char ptype = typespec ? typespec[1] : '_';
char utype = typespec ? typespec[2] : '_';
switch (ptype) {
case '_': /* kv(b, key, utype, bci) */
switch (utype) {
case '_': /* fall through */
case 's': bson_append_string( b, key, bci.s ); break; /* common case */
case 'f': bson_append_double( b, key, bci.f ); break;
case 'D':
bson_append_start_object( b, key );
ret = bson_append_bcon( b, bci.D );
bson_append_finish_object( b );
break;
case 'A':
bson_append_start_array( b, key );
ret = bson_append_bcon_array( b, bci.A );
bson_append_finish_array( b );
break;
case 'o': if (*bci.o == '\0') bson_oid_gen( &oid ); else bson_oid_from_string( &oid, bci.o ); bson_append_oid( b, key, &oid ); break;
case 'b': bson_append_bool( b, key, bci.b ); break;
case 't': bson_append_time_t( b, key, bci.t ); break;
case 'v': bson_append_null( b, key ); break; /* void */
case 'x': bson_append_symbol( b, key, bci.x ); break;
case 'i': bson_append_int( b, key, bci.i ); break;
case 'l': bson_append_long( b, key, bci.l ); break;
default: printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED); break;
}
break;
case 'R': /* krv(b, key, utype, bci) */
switch (utype) {
case 'f': bson_append_double( b, key, *bci.Rf ); break;
case 's': bson_append_string( b, key, bci.Rs ); break;
case 'D':
bson_append_start_object( b, key );
ret = bson_append_bcon( b, bci.RD );
bson_append_finish_object( b );
break;
case 'A':
bson_append_start_array( b, key );
ret = bson_append_bcon_array( b, bci.RA );
bson_append_finish_array( b );
break;
case 'o': if (*bci.o == '\0') bson_oid_gen( &oid ); else bson_oid_from_string( &oid, bci.o ); bson_append_oid( b, key, &oid ); break;
case 'b': bson_append_bool( b, key, *bci.Rb ); break;
case 't': bson_append_time_t( b, key, *bci.Rt ); break;
case 'x': bson_append_symbol( b, key, bci.Rx ); break;
case 'i': bson_append_int( b, key, *bci.Ri ); break;
case 'l': bson_append_long( b, key, *bci.Rl ); break;
default: printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED); break;
}
break;
case 'P': /* kpv(b, key, utype, bci) */
if (*bci.Pv != 0) {
switch (utype) {
case 'f': bson_append_double( b, key, **bci.Pf ); break;
case 's': bson_append_string( b, key, *bci.Ps ); break;
case 'D':
bson_append_start_object( b, key );
ret = bson_append_bcon( b, *bci.PD );
bson_append_finish_object( b );
break;
case 'A':
bson_append_start_array( b, key );
ret = bson_append_bcon_array( b, *bci.PA );
bson_append_finish_array( b );
break;
case 'o': if (**bci.Po == '\0') bson_oid_gen( &oid );
else bson_oid_from_string( &oid, *bci.Po );
bson_append_oid( b, key, &oid );
break;
case 'b': bson_append_bool( b, key, **bci.Pb ); break;
case 't': bson_append_time_t( b, key, **bci.Pt ); break;
case 'x': if (*bci.Px != 0) bson_append_symbol( b, key, *bci.Px ); break;
case 'i': bson_append_int( b, key, **bci.Pi ); break;
case 'l': bson_append_long( b, key, **bci.Pl ); break;
default: printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED); break;
}
}
break;
default:
printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED);
break;
}
return ret;
}

typedef enum bcon_state_t {
State_Element, State_DocSpecValue, State_DocValue,
State_ArraySpecValue, State_ArrayValue
} bcon_state_t;

#define DOC_STACK_SIZE 1024
#define ARRAY_INDEX_STACK_SIZE 1024

#define DOC_PUSH_STATE(return_state) ( doc_stack[doc_stack_pointer++] = (return_state) )
#define DOC_POP_STATE ( state = doc_stack[--doc_stack_pointer] )
#define ARRAY_PUSH_RESET_INDEX_STATE(return_state) ( array_index_stack[array_index_stack_pointer++] = array_index, array_index = 0, DOC_PUSH_STATE(return_state) )
#define ARRAY_POP_INDEX_STATE ( array_index = array_index_stack[--array_index_stack_pointer], DOC_POP_STATE )

#define ARRAY_KEY_STRING(l) (bson_numstr(array_index_buffer, (int)(l)), array_index_buffer)

/*
* simplified FSM to parse BCON structure, uses stacks for sub-documents and sub-arrays
*/
static bcon_error_t bson_append_bcon_with_state(bson *b, const bcon *bc, bcon_state_t start_state) {
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The function is too long

bson_append_bcon_with_state( bson * b , const bcon * bc , bcon_state_t start_state) now spans 103 lines.
Corresponding modifications started here.
Keep your functions' length within 50 lines to improve readability.

This comment was generated with the following checker: long_method

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The function is too complicated

bson_append_bcon_with_state( bson * b , const bcon * bc , bcon_state_t start_state) now has cyclomatic complexity of 20.
Corresponding modifications started here.
Split your routines to keep cyclomatic complexity below 10 to improve their maintainability.

This comment was generated with the following checker: high_cyclomatic_complexity

bcon_error_t ret = BCON_OK;
bcon_state_t state = start_state;
char *key = 0;
char *typespec = 0;
unsigned char doc_stack[DOC_STACK_SIZE];
size_t doc_stack_pointer = 0;
size_t array_index = 0;
size_t array_index_stack[ARRAY_INDEX_STACK_SIZE];
size_t array_index_stack_pointer = 0;
char array_index_buffer[ARRAY_INDEX_BUFFER_SIZE]; /* max BSON size */
int end_of_data;
const bcon *bcp;
for (end_of_data = 0, bcp = bc; ret == BCON_OK && !end_of_data; bcp++) {
bcon bci = *bcp;
char *s = bci.s;
switch (state) {
case State_Element:
switch (bcon_token(s)) {
case Token_CloseBrace:
bson_append_finish_object( b );
DOC_POP_STATE; /* state = ...; */
break;
case Token_End:
end_of_data = 1;
break;
default:
key = s;
state = State_DocSpecValue;
break;
}
break;
case State_DocSpecValue:
switch (bcon_token(s)) {
case Token_Typespec:
typespec = s;
state = State_DocValue;
break;
case Token_OpenBrace:
bson_append_start_object( b, key );
DOC_PUSH_STATE(State_Element);
state = State_Element;
break;
case Token_OpenBracket:
bson_append_start_array( b, key );
ARRAY_PUSH_RESET_INDEX_STATE(State_Element);
state = State_ArraySpecValue;
break;
case Token_End:
end_of_data = 1;
break;
default:
ret = bson_bcon_key_value(b, key, typespec, bci);
state = State_Element;
break;
}
break;
case State_DocValue:
ret = bson_bcon_key_value(b, key, typespec, bci);
state = State_Element;
typespec = 0;
break;
case State_ArraySpecValue:
switch (bcon_token(s)) {
case Token_Typespec:
typespec = s;
state = State_ArrayValue;
break;
case Token_OpenBrace:
key = ARRAY_KEY_STRING(array_index++);
bson_append_start_object( b, key );
DOC_PUSH_STATE(State_ArraySpecValue);
state = State_Element;
break;
case Token_OpenBracket:
key = ARRAY_KEY_STRING(array_index++);
bson_append_start_array( b, key );
ARRAY_PUSH_RESET_INDEX_STATE(State_ArraySpecValue);
/* state = State_ArraySpecValue; */
break;
case Token_CloseBracket:
bson_append_finish_array( b );
ARRAY_POP_INDEX_STATE; /* state = ...; */
break;
case Token_End:
end_of_data = 1;
break;
default:
key = ARRAY_KEY_STRING(array_index++);
ret = bson_bcon_key_value(b, key, typespec, bci);
/* state = State_ArraySpecValue; */
break;
}
break;
case State_ArrayValue:
key = ARRAY_KEY_STRING(array_index++);
ret = bson_bcon_key_value(b, key, typespec, bci);
state = State_ArraySpecValue;
typespec = 0;
break;
default: assert(NOT_REACHED); break;
}
}
return state == start_state ? BCON_OK : BCON_DOCUMENT_INCOMPLETE;
}

bcon_error_t bson_append_bcon(bson *b, const bcon *bc) {
return bson_append_bcon_with_state(b, bc, State_Element);
}

bcon_error_t bson_append_bcon_array(bson *b, const bcon *bc) {
return bson_append_bcon_with_state(b, bc, State_ArraySpecValue);
}

/**
* Generate BSON from BCON
* @param b a BSON object
* @param bc a BCON object
* match with bson_destroy
*/
bcon_error_t bson_from_bcon(bson *b, const bcon *bc) {
bcon_error_t ret = BSON_OK;
bson_init( b );
ret = bson_append_bcon_with_state( b, bc, State_Element );
if (ret != BCON_OK) return ret;
ret = bson_finish( b );
return ( ret == BSON_OK ? BCON_OK : BCON_BSON_ERROR );
}

void bcon_print(const bcon *bc) { /* prints internal representation, not JSON */
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The function is too long

bcon_print( const bcon * bc) now spans 79 lines.
Corresponding modifications started here.
Keep your functions' length within 50 lines to improve readability.

This comment was generated with the following checker: long_method

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The function is too complicated

bcon_print( const bcon * bc) now has cyclomatic complexity of 66.
Corresponding modifications started here.
Split your routines to keep cyclomatic complexity below 10 to improve their maintainability.

This comment was generated with the following checker: high_cyclomatic_complexity

char *typespec = 0;
const char *delim = "";
int end_of_data;
bcon *bcp;
putchar('{');
for (end_of_data = 0, bcp = (bcon*)bc; !end_of_data; bcp++) {
bcon bci = *bcp;
char *typespec_next = 0;
if (typespec) {
switch (typespec[1]) {
case '_':
switch (typespec[2]) {
case 'f': printf("%s%f", delim, bci.f); break;
case 's': printf("%s\"%s\"", delim, bci.s); break;
case 'D': printf("%sPD(0x%lx,..)", delim, (unsigned long)bci.D); break;
case 'A': printf("%sPA(0x%lx,....)", delim, (unsigned long)bci.A); break;
case 'o': printf("%s\"%s\"", delim, bci.o); break;
case 'b': printf("%s%d", delim, bci.b); break;
case 't': printf("%s%ld", delim, (long)bci.t); break;
case 'v': printf("%s\"%s\"", delim, bci.v); break;
case 'x': printf("%s\"%s\"", delim, bci.x); break;
case 'i': printf("%s%d", delim, bci.i); break;
case 'l': printf("%s%ld", delim, bci.l); break;
default: printf("\ntypespec:\"%s\"\n", typespec); assert(NOT_REACHED); break;
}
break;
case 'R':
switch (typespec[2]) {
case 'f': printf("%sRf(0x%lx,%f)", delim, (unsigned long)bci.Rf, *bci.Rf); break;
case 's': printf("%sRs(0x%lx,\"%s\")", delim, (unsigned long)bci.Rs, bci.Rs); break;
case 'D': printf("%sRD(0x%lx,..)", delim, (unsigned long)bci.RD); break;
case 'A': printf("%sRA(0x%lx,....)", delim, (unsigned long)bci.RA); break;
case 'o': printf("%sRo(0x%lx,\"%s\")", delim, (unsigned long)bci.Ro, bci.Ro); break;
case 'b': printf("%sRb(0x%lx,%d)", delim, (unsigned long)bci.Rb, *bci.Rb); break;
case 't': printf("%sRt(0x%lx,%ld)", delim, (unsigned long)bci.Rt, (long)*bci.Rt); break;
case 'x': printf("%sRx(0x%lx,\"%s\")", delim, (unsigned long)bci.Rx, bci.Rx); break;
case 'i': printf("%sRi(0x%lx,%d)", delim, (unsigned long)bci.Ri, *bci.Ri); break;
case 'l': printf("%sRl(0x%lx,%ld)", delim, (unsigned long)bci.Rl, *bci.Rl); break;
default: printf("\ntypespec:\"%s\"\n", typespec); assert(NOT_REACHED); break;
}
break;
case 'P':
switch (typespec[2]) {
case 'f': printf("%sPf(0x%lx,0x%lx,%f)", delim, (unsigned long)bci.Pf, (unsigned long)(bci.Pf ? *bci.Pf : 0), bci.Pf && *bci.Pf ? **bci.Pf : 0.0); break;
case 's': printf("%sPs(0x%lx,0x%lx,\"%s\")", delim, (unsigned long)bci.Ps, (unsigned long)(bci.Ps ? *bci.Ps : 0), bci.Ps && *bci.Ps ? *bci.Ps : ""); break;
case 'D': printf("%sPD(0x%lx,0x%lx,..)", delim, (unsigned long)bci.PD, (unsigned long)(bci.PD ? *bci.PD : 0)); break;
case 'A': printf("%sPA(0x%lx,0x%lx,....)", delim, (unsigned long)bci.PA, (unsigned long)(bci.PA ? *bci.PA : 0)); break;
case 'o': printf("%sPo(0x%lx,0x%lx,\"%s\")", delim, (unsigned long)bci.Po, (unsigned long)(bci.Po ? *bci.Po : 0), bci.Po && *bci.Po ? *bci.Po : ""); break;
case 'b': printf("%sPb(0x%lx,0x%lx,%d)", delim, (unsigned long)bci.Pb, (unsigned long)(bci.Pb ? *bci.Pb : 0), bci.Pb && *bci.Pb ? **bci.Pb : 0); break;
case 't': printf("%sPt(0x%lx,0x%lx,%ld)", delim, (unsigned long)bci.Pt, (unsigned long)(bci.Pt ? *bci.Pt : 0), bci.Pt && *bci.Pt ? (long)**bci.Pt : 0); break;
case 'x': printf("%sPx(0x%lx,0x%lx,\"%s\")", delim, (unsigned long)bci.Px, (unsigned long)(bci.Px ? *bci.Px : 0), bci.Px && *bci.Px ? *bci.Px : ""); break;
case 'i': printf("%sPi(0x%lx,0x%lx,%d)", delim, (unsigned long)bci.Pi, (unsigned long)(bci.Pi ? *bci.Pi : 0), bci.Pi && *bci.Pi ? **bci.Pi : 0); break;
case 'l': printf("%sPl(0x%lx,0x%lx,%ld)", delim, (unsigned long)bci.Pl, (unsigned long)(bci.Pl ? *bci.Pl : 0), bci.Pl && *bci.Pl ? **bci.Pl : 0); break;

default: printf("\ntypespec:\"%s\"\n", typespec); assert(NOT_REACHED); break;
}
break;
default:
printf("\ntypespec:\"%s\"\n", typespec); assert(NOT_REACHED);
break;
}
}
else {
char *s = bci.s;
switch (s[0]) {
case '.':
end_of_data = (s[1] == '\0');
break;
case ':':
typespec_next = bcon_token(s) == Token_Typespec ? s : 0;
break;
}
printf("%s\"%s\"", delim, s);
}
typespec = typespec_next;
delim = ",";
}
putchar('}');
}