id stringlengths 21 132 | codebase stringclasses 57
values | c_file stringlengths 3 108 | function stringlengths 3 74 | sloc stringclasses 134
values | c_code stringlengths 25 52.1k | c_constructs dict |
|---|---|---|---|---|---|---|
transcoder-set#MIDDLE_OF_THREE_USING_MINIMUM_COMPARISONS_1_prep#main.c | transcoder-set | MIDDLE_OF_THREE_USING_MINIMUM_COMPARISONS_1.c | main | 16 | int main(void) {
int n_success = 0;
int param0[] = {43,76,57,10,59,92,49,16,33,66};
int param1[] = {24,54,5,13,47,14,62,95,41,63};
int param2[] = {7,66,40,4,56,50,65,12,90,46};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i],param2[i]) == f_gold(param0[i],param1[i],param2[i]))
{
n_success+=1;
}
break;
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
}
| {
"array_type": 3,
"break_continue_statement": 1,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#CIRCLE_LATTICE_POINTS_prep#len.c | transcoder-set | CIRCLE_LATTICE_POINTS.c | len | 1 | int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
libosip2-5.3.1#osip_authentication_info_prep#osip_message_set_authentication_info.c | libosip2-5.3.1 | osip_authentication_info.c | osip_message_set_authentication_info | 19 | int osip_message_set_authentication_info(osip_message_t *sip, const char *hvalue) {
osip_authentication_info_t *authentication_info;
int i;
if (hvalue == ((void *)0) || hvalue[0] == '\0')
return 0;
if (sip == ((void *)0))
return -2;
i = osip_authentication_info_init(&authentication_info);
if (i != 0)
return i;
i = osip_authentication_info_parse(authentication_info, hvalue);
if (i != 0) {
osip_authentication_info_free(authentication_info);
return i;
}
sip->message_property = 2;
osip_list_add(&sip->authentication_infos, authentication_info, -1);
return 0;
}
| {
"array_type": 1,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 4,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 5,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 2,
"union_type": 0,
"while_loop": 0
} |
robotfindskitten#robotfindskitten_prep#draw.c | robotfindskitten | robotfindskitten.c | draw | 1 | void draw(screen_object o) { full_draw(o,0); }
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
json.h#allow_global_object_prep#json_get_key_size.c | json.h | allow_global_object.c | json_get_key_size | 31 | int json_get_key_size(struct json_parse_state_s *state) {
const size_t flags_bitset = state->flags_bitset;
if (json_parse_flags_allow_unquoted_keys & flags_bitset) {
size_t offset = state->offset;
const size_t size = state->size;
const char *const src = state->src;
size_t data_size = state->data_size;
if ('"' == src[offset]) {
return json_get_string_size(state, 1);
} else if ((json_parse_flags_allow_single_quoted_strings & flags_bitset) &&
('\'' == src[offset])) {
return json_get_string_size(state, 1);
} else {
while ((offset < size) && is_valid_unquoted_key_char(src[offset])) {
offset++;
data_size++;
}
data_size++;
if (json_parse_flags_allow_location_information & flags_bitset) {
state->dom_size += sizeof(struct json_string_ex_s);
} else {
state->dom_size += sizeof(struct json_string_s);
}
state->offset = offset;
state->data_size = data_size;
return 0;
}
} else {
return json_get_string_size(state, 1);
}
}
| {
"array_type": 1,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 4,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 4,
"struct_type": 1,
"switch_statement": 0,
"type_casting": 2,
"union_type": 0,
"while_loop": 1
} |
gawk-5.2.2#profile_prep#pp_string_fp.c | gawk-5.2.2 | profile.c | pp_string_fp | 18 | void
pp_string_fp(Func_print print_func, FILE *fp, const char *in_str,
size_t len, int delim, _Bool breaklines)
{
char *s = pp_string(in_str, len, delim);
int count;
size_t slen;
const char *str = (const char *) s;
slen = strlen(str);
for (count = 0; slen > 0; slen--, str++) {
print_func(fp, "%c", *str);
if (++count >= 70 && breaklines) {
print_func(fp, "%c\n%c", delim, delim);
count = 0;
}
}
pma_free(s);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 2,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#COUNT_DISTINCT_NON_NEGATIVE_PAIRS_X_Y_SATISFY_INEQUALITY_XX_YY_N_2_1_prep#f_gold.c | transcoder-set | COUNT_DISTINCT_NON_NEGATIVE_PAIRS_X_Y_SATISFY_INEQUALITY_XX_YY_N_2_1.c | f_gold | 12 | int f_gold ( int n ) {
int x = 0, yCount, res = 0;
for ( yCount = 0;
yCount * yCount < n;
yCount ++ );
while ( yCount != 0 ) {
res += yCount;
x ++;
while ( yCount != 0 && ( x * x + ( yCount - 1 ) * ( yCount - 1 ) >= n ) ) yCount --;
}
return res;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 2
} |
transcoder-set#SMALLEST_OF_THREE_INTEGERS_WITHOUT_COMPARISON_OPERATORS_prep#f_filled.c | transcoder-set | SMALLEST_OF_THREE_INTEGERS_WITHOUT_COMPARISON_OPERATORS.c | f_filled | 1 | int f_filled ( int x, int y, int z ) {}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
nettle-3.9.1#ecc-gostdsa-verify_prep#nettle_ecc_gostdsa_verify_itch.c | nettle-3.9.1 | ecc-gostdsa-verify.c | nettle_ecc_gostdsa_verify_itch | 5 | mp_size_t
nettle_ecc_gostdsa_verify_itch (const struct ecc_curve *ecc)
{
return 5*ecc->p.size + (((3 << 4) + 8) * (ecc->p.size));
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 1,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
gprolog-1.5.0#atom_prep#Pl_Find_Next_Atom.c | gprolog-1.5.0 | atom.c | Pl_Find_Next_Atom | 10 | int
Pl_Find_Next_Atom(int last_atom)
{
while ((PlULong) ++last_atom < pl_max_atom)
{
if (pl_atom_tbl[last_atom].name)
return last_atom;
}
return -1;
}
| {
"array_type": 1,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 2,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 1
} |
heman#mat4_prep#kmMat4ExtractPlane.c | heman | mat4.c | kmMat4ExtractPlane | 52 | kmPlane* kmMat4ExtractPlane(kmPlane* pOut, const kmMat4* pIn, const unsigned int plane)
{
float t = 1.0f;
switch(plane) {
case 1:
pOut->a = pIn->mat[3] - pIn->mat[0];
pOut->b = pIn->mat[7] - pIn->mat[4];
pOut->c = pIn->mat[11] - pIn->mat[8];
pOut->d = pIn->mat[15] - pIn->mat[12];
break;
case 0:
pOut->a = pIn->mat[3] + pIn->mat[0];
pOut->b = pIn->mat[7] + pIn->mat[4];
pOut->c = pIn->mat[11] + pIn->mat[8];
pOut->d = pIn->mat[15] + pIn->mat[12];
break;
case 2:
pOut->a = pIn->mat[3] + pIn->mat[1];
pOut->b = pIn->mat[7] + pIn->mat[5];
pOut->c = pIn->mat[11] + pIn->mat[9];
pOut->d = pIn->mat[15] + pIn->mat[13];
break;
case 3:
pOut->a = pIn->mat[3] - pIn->mat[1];
pOut->b = pIn->mat[7] - pIn->mat[5];
pOut->c = pIn->mat[11] - pIn->mat[9];
pOut->d = pIn->mat[15] - pIn->mat[13];
break;
case 5:
pOut->a = pIn->mat[3] - pIn->mat[2];
pOut->b = pIn->mat[7] - pIn->mat[6];
pOut->c = pIn->mat[11] - pIn->mat[10];
pOut->d = pIn->mat[15] - pIn->mat[14];
break;
case 4:
pOut->a = pIn->mat[3] + pIn->mat[2];
pOut->b = pIn->mat[7] + pIn->mat[6];
pOut->c = pIn->mat[11] + pIn->mat[10];
pOut->d = pIn->mat[15] + pIn->mat[14];
break;
default:
((void) sizeof ((0 && "Invalid plane index") ? 1 : 0), __extension__ ({ if (0 && "Invalid plane index") ; else __assert_fail ("0 && \"Invalid plane index\"", "/home/melih/storage/Transpiler/Dataset/projects/codebases_v2/heman/kazmath/mat4.c", 779, __extension__ __PRETTY_FUNCTION__); }));
}
t = sqrtf(pOut->a * pOut->a +
pOut->b * pOut->b +
pOut->c * pOut->c);
pOut->a /= t;
pOut->b /= t;
pOut->c /= t;
pOut->d /= t;
return pOut;
}
| {
"array_type": 1,
"break_continue_statement": 6,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 1,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
patch-2.7.6#pch_prep#pch_rename.c | patch-2.7.6 | pch.c | pch_rename | 4 | _Bool pch_rename (void)
{
return p_rename[OLD] && p_rename[NEW];
}
| {
"array_type": 1,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
libxml2#xmlsave_prep#xmlSaveToFd.c | libxml2 | xmlsave.c | xmlSaveToFd | 13 | xmlSaveCtxtPtr
xmlSaveToFd(int fd, const char *encoding, int options)
{
xmlSaveCtxtPtr ret;
ret = xmlNewSaveCtxt(encoding, options);
if (ret == ((void *)0)) return(((void *)0));
ret->buf = xmlOutputBufferCreateFd(fd, ret->handler);
if (ret->buf == ((void *)0)) {
xmlFreeSaveCtxt(ret);
return(((void *)0));
}
return(ret);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 2,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 3,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 3,
"union_type": 0,
"while_loop": 0
} |
nano-7.2#global_prep#backwards_void.c | nano-7.2 | global.c | backwards_void | 1 | void backwards_void(void) {;}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#MAXIMUM_POSSIBLE_DIFFERENCE_TWO_SUBSETS_ARRAY_1_prep#len.c | transcoder-set | MAXIMUM_POSSIBLE_DIFFERENCE_TWO_SUBSETS_ARRAY_1.c | len | 1 | int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#HYPERCUBE_GRAPH_prep#main.c | transcoder-set | HYPERCUBE_GRAPH.c | main | 14 | int main(void) {
int n_success = 0;
int param0[] = {72,28,45,41,94,97,97,36,91,84};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
break;
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
}
| {
"array_type": 1,
"break_continue_statement": 1,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
gprolog-1.5.0#g_var_inl_c_prep#Pl_Blt_G_Link.c | gprolog-1.5.0 | g_var_inl_c.c | Pl_Blt_G_Link | 7 | void
Pl_Blt_G_Link(WamWord x, WamWord y)
{
Pl_Set_C_Bip_Name("g_link", 2);
G_Assign(x, y, 1, 0);
Pl_Unset_C_Bip_Name();
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
optipng-0.7.8#compress_prep#compress.c | optipng-0.7.8 | compress.c | compress | 4 | int compress(Bytef *dest, uLongf *destLen, const Bytef *source,
uLong sourceLen) {
return compress2(dest, destLen, source, sourceLen, (-1));
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
bc-1.07.1#scan_prep#yypop_buffer_state.c | bc-1.07.1 | scan.c | yypop_buffer_state | 13 | void yypop_buffer_state (void)
{
if (!( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : ((void *)0)))
return;
yy_delete_buffer(( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : ((void *)0)) );
(yy_buffer_stack)[(yy_buffer_stack_top)] = ((void *)0);
if ((yy_buffer_stack_top) > 0)
--(yy_buffer_stack_top);
if (( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : ((void *)0))) {
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
}
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 3,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 5,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#FINDING_POWER_PRIME_NUMBER_P_N_prep#f_gold.c | transcoder-set | FINDING_POWER_PRIME_NUMBER_P_N.c | f_gold | 9 | int f_gold ( int n, int p ) {
int ans = 0;
int temp = p;
while ( temp <= n ) {
ans += n / temp;
temp = temp * p;
}
return ans;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 1
} |
gprolog-1.5.0#const_io_c_prep#Pl_Display_To_String.c | gprolog-1.5.0 | const_io_c.c | Pl_Display_To_String | 7 | char *
Pl_Display_To_String(WamWord term_word)
{
char *ret_str;
{ int stm; WamWord stm_word; char *str; stm = Pl_Add_Str_Stream(((void *)0), 1); stm_word = Pl_Make_Stream_Tagged_Word(stm); { Pl_Display_2(stm_word, term_word); } str = Pl_Term_Write_Str_Stream(stm); { ret_str = Pl_Strdup_Check(str, "const_io_c.c", 186); } Pl_Delete_Str_Stream(stm); };
return ret_str;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 2,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
dap-3.10#machdep_prep#dap_putdouble.c | dap-3.10 | machdep.c | dap_putdouble | 50 | void dap_putdouble(DFILE *dfp)
{
unsigned int ix[2];
unsigned int sign;
unsigned int e;
char dstr[13];
int d;
d = 0;
ix[0] = *(((unsigned int *) &dap_double) + dap_dbllow);
ix[1] = *(((unsigned int *) &dap_double) + dap_dblhigh);
if (!(ix[0] & 0x7fffffff) && !ix[1])
{
dstr[d++] = 'A';
for (e = 0; e < 11; e++)
dstr[d++] = '!';
}
else
{
sign = ((ix[1] >> 20) & 0x800);
e =((ix[1] >> 20) & 0x7ff);
if (!e)
{
dstr[d++] = 'A';
for (e = 0; e < 11; e++)
dstr[d++] = '!';
}
else if (e == 0x7ff)
{
for (e = 0; e < 12; e++)
dstr[d++] = 'a';
}
else
{
if (sign)
{
e = 0x800 - e;
ix[1] = ((~ix[1]) & 0xfffff);
ix[0] = (~ix[0]);
}
else
e += 0x800;
d += putnd(e, 2, dstr + d);
d += putnd(ix[1], 4, dstr + d);
d += putnd(ix[0], 6, dstr + d);
}
}
dstr[d] = '\0';
for (d = 0; dstr[d]; d++)
dap_putc(dstr[d], dfp);
}
| {
"array_type": 2,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 4,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 4,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
wget-1.21.4#css__prep#yy_delete_buffer.c | wget-1.21.4 | css_.c | yy_delete_buffer | 10 | void yy_delete_buffer (YY_BUFFER_STATE b )
{
if ( ! b )
return;
if ( b == ( (yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : ((void *)0)) )
(yy_buffer_stack)[(yy_buffer_stack_top)] = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
yyfree( (void *) b->yy_ch_buf );
yyfree( (void *) b );
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 3,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 3,
"union_type": 0,
"while_loop": 0
} |
optipng-0.7.8#pngerror_prep#png_app_error.c | optipng-0.7.8 | pngerror.c | png_app_error | 8 | void
png_app_error(png_const_structrp png_ptr, png_const_charp error_message)
{
if ((png_ptr->flags & 0x400000U) != 0)
png_warning(png_ptr, error_message);
else
png_error(png_ptr, error_message);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
tar-1.34#malloca_prep#freea.c | tar-1.34 | malloca.c | freea | 13 | void
freea (void *p)
{
if ((uintptr_t) p & (sa_alignment_max - 1))
{
abort ();
}
if ((uintptr_t) p & sa_alignment_max)
{
void *mem = (char *) p - ((small_t *) p)[-1];
free (mem);
}
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 2,
"memory_management": 1,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
tmux#proc_prep#proc_toggle_log.c | tmux | proc.c | proc_toggle_log | 5 | void
proc_toggle_log(struct tmuxproc *tp)
{
log_toggle(tp->name);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 1,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
nettle-3.9.1#output_prep#sexp_put_char.c | nettle-3.9.1 | output.c | sexp_put_char | 25 | void
sexp_put_char(struct sexp_output *output, uint8_t c)
{
if (output->coding)
{
char encoded[2];
unsigned done;
unsigned i;
done = output->coding->encode_update(&output->base64, encoded,
1, &c);
((void) sizeof ((done <= sizeof(encoded)) ? 1 : 0), __extension__ ({ if (done <= sizeof(encoded)) ; else __assert_fail ("done <= sizeof(encoded)", "output.c", 124, __extension__ __PRETTY_FUNCTION__); }));
for (i = 0; i<done; i++)
{
if (output->line_width
&& output->pos >= output->line_width
&& output->pos >= (output->coding_indent + 10))
sexp_put_newline(output, output->coding_indent);
sexp_put_raw_char(output, encoded[i]);
}
}
else if (output->hash)
output->hash->update(output->ctx, 1, &c);
else
sexp_put_raw_char(output, c);
}
| {
"array_type": 1,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 4,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 1,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
gprolog-1.5.0#error_supp_prep#Pl_Err_Evaluation.c | gprolog-1.5.0 | error_supp.c | Pl_Err_Evaluation | 7 | void
Pl_Err_Evaluation(int pl_atom_error)
{
Update_Cur_From_C_Bip();
(pl_reg_bank[0]) = (((PlLong) (pl_atom_error) << 3) + ((PlULong)0x3));
Pl_Execute_A_Continuation(X1_24706C5F6572725F6576616C756174696F6E__a1);
}
| {
"array_type": 1,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
wget-1.21.4#iri_prep#idn_decode.c | wget-1.21.4 | iri.c | idn_decode | 5 | char *
idn_decode (const char *host)
{
return xstrdup(host);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
libxml2#libxml2-py_prep#libxml_xmlNodeSetContentLen.c | libxml2 | libxml2-py.c | libxml_xmlNodeSetContentLen | 15 | PyObject *
libxml_xmlNodeSetContentLen(PyObject *self __attribute__ ((__unused__)), PyObject *args) {
PyObject *py_retval;
int c_retval;
xmlNodePtr cur;
PyObject *pyobj_cur;
xmlChar * content;
int len;
if (!_PyArg_ParseTuple_SizeT(args, (char *)"Ozi:xmlNodeSetContentLen", &pyobj_cur, &content, &len))
return(((void *)0));
cur = (xmlNodePtr) (((pyobj_cur) == (&_Py_NoneStruct)) ? ((void *)0) : (((PyxmlNode_Object *)(pyobj_cur))->obj));
c_retval = xmlNodeSetContentLen(cur, content, len);
py_retval = libxml_intWrap((int) c_retval);
return(py_retval);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 2,
"return_statement": 2,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 4,
"union_type": 0,
"while_loop": 0
} |
tmux#imsg-buffer_prep#ibuf_size.c | tmux | imsg-buffer.c | ibuf_size | 5 | size_t
ibuf_size(struct ibuf *buf)
{
return (buf->wpos);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 1,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#MAXIMUM_SUM_SUBARRAY_REMOVING_ONE_ELEMENT_prep#max.c | transcoder-set | MAXIMUM_SUM_SUBARRAY_REMOVING_ONE_ELEMENT.c | max | 1 | int max(int x, int y) { return (x > y)? x: y; }
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
tulipindicators-0.9.1#tiamalgamation_prep#ti_cosh.c | tulipindicators-0.9.1 | tiamalgamation.c | ti_cosh | 1 | int ti_cosh(int size, double const *const *inputs, double const *options, double *const *outputs) { const double *in1 = inputs[0]; (void)options; double *output = outputs[0]; int i; for (i = 0; i < size; ++i) { output[i] = (cosh(in1[i])); } return 0; }
| {
"array_type": 4,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 3,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#FINDING_POWER_PRIME_NUMBER_P_N_prep#sort.c | transcoder-set | FINDING_POWER_PRIME_NUMBER_P_N.c | sort | 1 | void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
gprolog-1.5.0#control_c_prep#Pl_Between_Alt_0.c | gprolog-1.5.0 | control_c.c | Pl_Between_Alt_0 | 17 | void
Pl_Between_Alt_0(void)
{
PlLong l, u;
WamWord i_word;
Pl_Update_Choice_Point((CodePtr) X1_246265747765656E5F616C74__a0, 0);
l = (*(WamWord *) &(B[-9 - (0)]));
u = (*(WamWord *) &(B[-9 - (1)]));
i_word = (*(WamWord *) &(B[-9 - (2)]));
if (l == u)
(B = ((*(WamWord **) &(B[-5]))), (((WamWordP *) pl_reg_bank)[256 +0]) = (*(WamWord **) &(B[-6])));
else
{
(*(WamWord *) &(B[-9 - (0)])) = l + 1;
}
Pl_Get_Integer(l, i_word);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
json.h#allow_inf_and_nan_prep#json_extract_get_array_size.c | json.h | allow_inf_and_nan.c | json_extract_get_array_size | 17 | struct json_extract_result_s
json_extract_get_array_size(const struct json_array_s *const array) {
struct json_extract_result_s result;
size_t i;
const struct json_array_element_s *element = array->start;
result.dom_size = sizeof(struct json_array_s) +
(sizeof(struct json_array_element_s) * array->length);
result.data_size = 0;
for (i = 0; i < array->length; i++) {
const struct json_extract_result_s value_result =
json_extract_get_value_size(element->value);
result.dom_size += value_result.dom_size;
result.data_size += value_result.data_size;
element = element->next;
}
return result;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 1,
"struct_type": 2,
"switch_statement": 0,
"type_casting": 2,
"union_type": 0,
"while_loop": 0
} |
bc-1.07.1#number_prep#bc_new_num.c | bc-1.07.1 | number.c | bc_new_num | 21 | bc_num
bc_new_num (int length, int scale)
{
bc_num temp;
if (_bc_Free_list != ((void *)0)) {
temp = _bc_Free_list;
_bc_Free_list = temp->n_next;
} else {
temp = (bc_num) malloc (sizeof(bc_struct));
if (temp == ((void *)0)) out_of_memory ();
}
temp->n_sign = PLUS;
temp->n_len = length;
temp->n_scale = scale;
temp->n_refs = 1;
temp->n_ptr = (char *) malloc (length+scale);
if (temp->n_ptr == ((void *)0)) out_of_memory();
temp->n_value = temp->n_ptr;
memset (temp->n_ptr, 0, length+scale);
return temp;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 3,
"memory_management": 2,
"memory_operation": 1,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 4,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#DOUBLE_FACTORIAL_1_prep#cmpfunc.c | transcoder-set | DOUBLE_FACTORIAL_1.c | cmpfunc | 1 | int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
tar-1.34#regex_prep#rpl_regerror.c | tar-1.34 | regex.c | rpl_regerror | 23 | size_t
rpl_regerror (int errcode, const regex_t *__restrict preg, char *__restrict errbuf,
size_t errbuf_size)
{
const char *msg;
size_t msg_size;
int nerrcodes = sizeof __re_error_msgid_idx / sizeof __re_error_msgid_idx[0];
if (__builtin_expect ((errcode < 0 || errcode >= nerrcodes), 0))
abort ();
msg = gettext (__re_error_msgid + __re_error_msgid_idx[errcode]);
msg_size = strlen (msg) + 1;
if (__builtin_expect ((errbuf_size != 0), 1))
{
size_t cpy_size = msg_size;
if (__builtin_expect ((msg_size > errbuf_size), 0))
{
cpy_size = errbuf_size - 1;
errbuf[cpy_size] = '\0';
}
memcpy (errbuf, msg, cpy_size);
}
return msg_size;
}
| {
"array_type": 2,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 3,
"memory_management": 0,
"memory_operation": 1,
"pointer_type": 1,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
tmux#environ_prep#environ_RB_FIND.c | tmux | environ.c | environ_RB_FIND | 1 | struct environ_entry * environ_RB_FIND(struct environ *head, struct environ_entry *elm) { struct environ_entry *tmp = (head)->rbh_root; int comp; while (tmp) { comp = environ_cmp(elm, tmp); if (comp < 0) tmp = (tmp)->entry.rbe_left; else if (comp > 0) tmp = (tmp)->entry.rbe_right; else return (tmp); } return (((void *)0)); }
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 1,
"struct_type": 1,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 1
} |
binn-3.0#binn_prep#binn_object_str.c | binn-3.0 | binn.c | binn_object_str | 5 | char * binn_object_str(void *obj, const char *key) {
char *value;
binn_object_get(obj, key, 0xA0, &value, ((void *)0));
return value;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
cflow-1.7#posix_prep#posix_output_handler.c | cflow-1.7 | posix.c | posix_output_handler | 27 | int
posix_output_handler(cflow_output_command cmd,
FILE *outfile, int line,
void *data, void *handler_data)
{
switch (cmd) {
case cflow_output_init:
if (emacs_option)
error(3, 0,
gettext("--format=posix is not compatible with --emacs"));
brief_listing = print_line_numbers = omit_symbol_names_option = 1;
break;
case cflow_output_begin:
case cflow_output_end:
case cflow_output_separator:
break;
case cflow_output_newline:
fprintf(outfile, "\n");
break;
case cflow_output_text:
fprintf(outfile, "%s", (char*) data);
break;
case cflow_output_symbol:
return print_symbol(outfile, line, data);
}
return 0;
}
| {
"array_type": 0,
"break_continue_statement": 4,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 2,
"struct_type": 0,
"switch_statement": 1,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
optipng-0.7.8#pnmin_prep#pnm_fget_values.c | optipng-0.7.8 | pnmin.c | pnm_fget_values | 115 | int pnm_fget_values(const pnm_struct *pnm_ptr,
unsigned int *sample_values,
unsigned int num_rows,
FILE *stream)
{
unsigned int format = pnm_ptr->format;
unsigned int depth = pnm_ptr->depth;
unsigned int width = pnm_ptr->width;
unsigned int maxval = pnm_ptr->maxval;
size_t row_length = (size_t)depth * (size_t)width;
size_t num_samples = num_rows * row_length;
int ch, ch8;
int ch16, ch24;
int mask;
size_t i, j;
switch (format)
{
case PNM_P1:
for (i = 0; i < num_samples; ++i)
{
do
{
ch = pnm_fget_char(stream);
} while (((ch) == ' ' || (ch) == '\t' || (ch) == '\n' || (ch) == '\r'));
if (ch != '0' && ch != '1')
{
ungetc(ch, stream);
break;
}
sample_values[i] = (ch == '0') ? 1 : 0;
}
break;
case PNM_P2:
case PNM_P3:
for (i = 0; i < num_samples; ++i)
{
if (pnm_fscan_uint(stream, &sample_values[i]) != 1)
break;
}
break;
case PNM_P4:
for (i = j = 0; i < num_samples; )
{
ch = getc(stream);
if (ch == (-1))
break;
for (mask = 0x80; mask != 0; mask >>= 1)
{
sample_values[i++] = (ch & mask) ? 0 : 1;
if (++j == row_length)
{
j = 0;
break;
}
}
}
break;
case PNM_P5:
case PNM_P6:
case PNM_P7:
if (maxval <= 0xffU)
{
for (i = 0; i < num_samples; ++i)
{
ch = getc(stream);
if (ch == (-1))
break;
sample_values[i] = (unsigned int)ch;
}
}
else if (maxval <= 0xffffU)
{
for (i = 0; i < num_samples; ++i)
{
ch8 = getc(stream);
ch = getc(stream);
if (ch == (-1))
break;
sample_values[i] = ((unsigned int)ch8 << 8) + (unsigned int)ch;
}
}
else if (maxval <= 0xffffffffU)
{
ch24 = 0;
for (i = 0; i < num_samples; ++i)
{
if (maxval > 0xffffffU)
ch24 = getc(stream);
ch16 = getc(stream);
ch8 = getc(stream);
ch = getc(stream);
if (ch == (-1))
break;
sample_values[i] =
((unsigned int)ch24 << 24) + ((unsigned int)ch16 << 16) +
((unsigned int)ch8 << 8) + ((unsigned int)ch);
}
}
else
{
(*__errno_location ()) = 22;
return 0;
}
break;
default:
(*__errno_location ()) = 22;
return 0;
}
if (i < num_samples)
{
memset(sample_values + i, 0, (num_samples - i) * sizeof(unsigned int));
return -1;
}
return 1;
}
| {
"array_type": 1,
"break_continue_statement": 11,
"enum_type": 0,
"for_loop": 7,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 12,
"memory_management": 0,
"memory_operation": 1,
"pointer_type": 0,
"return_statement": 4,
"struct_type": 0,
"switch_statement": 1,
"type_casting": 1,
"union_type": 0,
"while_loop": 1
} |
optipng-0.7.8#png_prep#png_reset_zstream.c | optipng-0.7.8 | png.c | png_reset_zstream | 7 | int
png_reset_zstream(png_structrp png_ptr)
{
if (png_ptr == ((void *)0))
return (-2);
return (inflateReset(&png_ptr->zstream));
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 2,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#GCD_ELEMENTS_GIVEN_RANGE_prep#main.c | transcoder-set | GCD_ELEMENTS_GIVEN_RANGE.c | main | 15 | int main(void) {
int n_success = 0;
int param0[] = {57,22,17,74,93,56,5,5,9,98};
int param1[] = {57,22,17,74,22,54,33,68,75,21};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
break;
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
}
| {
"array_type": 2,
"break_continue_statement": 1,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
bc-1.07.1#util_prep#insert_id_rec.c | bc-1.07.1 | util.c | insert_id_rec | 111 | int insert_id_rec (id_rec **root, id_rec *new_id)
{
id_rec *A, *B;
if (*root == ((void *)0))
{
*root = new_id;
new_id->left = ((void *)0);
new_id->right = ((void *)0);
new_id->balance = 0;
return (1);
}
if (strcmp (new_id->id, (*root)->id) < 0)
{
if (insert_id_rec (&((*root)->left), new_id))
{
(*root)->balance --;
switch ((*root)->balance)
{
case 0:
return (0);
case -1:
return (1);
case -2:
A = *root;
B = (*root)->left;
if (B->balance <= 0)
{
A->left = B->right;
B->right = A;
*root = B;
A->balance = 0;
B->balance = 0;
}
else
{
*root = B->right;
B->right = (*root)->left;
A->left = (*root)->right;
(*root)->left = B;
(*root)->right = A;
switch ((*root)->balance)
{
case -1:
A->balance = 1;
B->balance = 0;
break;
case 0:
A->balance = 0;
B->balance = 0;
break;
case 1:
A->balance = 0;
B->balance = -1;
break;
}
(*root)->balance = 0;
}
}
}
}
else
{
if (insert_id_rec (&((*root)->right), new_id))
{
(*root)->balance ++;
switch ((*root)->balance)
{
case 0:
return (0);
case 1:
return (1);
case 2:
A = *root;
B = (*root)->right;
if (B->balance >= 0)
{
A->right = B->left;
B->left = A;
*root = B;
A->balance = 0;
B->balance = 0;
}
else
{
*root = B->left;
B->left = (*root)->right;
A->right = (*root)->left;
(*root)->left = A;
(*root)->right = B;
switch ((*root)->balance)
{
case -1:
A->balance = 0;
B->balance = 1;
break;
case 0:
A->balance = 0;
B->balance = 0;
break;
case 1:
A->balance = -1;
B->balance = 0;
break;
}
(*root)->balance = 0;
}
}
}
}
return (0);
}
| {
"array_type": 0,
"break_continue_statement": 6,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 6,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 2,
"return_statement": 6,
"struct_type": 0,
"switch_statement": 4,
"type_casting": 3,
"union_type": 0,
"while_loop": 0
} |
wget-1.21.4#ftp-basic_prep#ftp_rest.c | wget-1.21.4 | ftp-basic.c | ftp_rest | 25 | uerr_t
ftp_rest (int csock, wgint offset)
{
char *request, *respline;
int nwritten;
uerr_t err;
request = ftp_request ("REST", number_to_static_string (offset));
nwritten = fd_write (csock, request, strlen (request), -1);
if (nwritten < 0)
{
do { free ((void *) (request)); request = ((void *)0); } while (0);
return WRITEFAILED;
}
do { free ((void *) (request)); request = ((void *)0); } while (0);
err = ftp_response (csock, &respline);
if (err != FTPOK)
return err;
if (*respline != '3')
{
do { free ((void *) (respline)); respline = ((void *)0); } while (0);
return FTPRESTFAIL;
}
do { free ((void *) (respline)); respline = ((void *)0); } while (0);
return FTPOK;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 3,
"memory_management": 4,
"memory_operation": 0,
"pointer_type": 2,
"return_statement": 4,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 4,
"union_type": 0,
"while_loop": 4
} |
less-633#optfunc_prep#set_tabs.c | less-633 | optfunc.c | set_tabs | 27 | void set_tabs(char *s, int len)
{
int i;
char *es = s + len;
for (i = 1; i < 128; )
{
int n = 0;
int v = 0;
while (s < es && *s == ' ')
s++;
for (; s < es && *s >= '0' && *s <= '9'; s++)
{
v |= help_ckd_mul(&n, n, 10, sizeof *(&n), ((1 ? 0 : *(&n)) - 1 < 0));
v |= help_ckd_add(&n, n, *s - '0', sizeof *(&n), ((1 ? 0 : *(&n)) - 1 < 0));
}
if (!v && n > tabstops[i-1])
tabstops[i++] = n;
while (s < es && *s == ' ')
s++;
if (s == es || *s++ != ',')
break;
}
if (i < 2)
return;
ntabstops = i;
tabdefault = tabstops[ntabstops-1] - tabstops[ntabstops-2];
}
| {
"array_type": 0,
"break_continue_statement": 1,
"enum_type": 0,
"for_loop": 2,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 3,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 2
} |
transcoder-set#MAXIMUM_SUM_IARRI_AMONG_ROTATIONS_GIVEN_ARRAY_prep#main.c | transcoder-set | MAXIMUM_SUM_IARRI_AMONG_ROTATIONS_GIVEN_ARRAY.c | main | 25 | int main(void) {
int n_success = 0;
int param0_0[] = {11,12,16,26,29,40,54,59,65,70,71,73,78,81,87,87,88,90,95,97};
int param0_1[] = {-46,-32,54,96,-72,-58,-36,-44,26,-2,-68,42,90,26,-92,-96,88,-42,-18,46,-70,24,0,24,34,34,-52,50,94,-60,64,58};
int param0_2[] = {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};
int param0_3[] = {48,2,79,98,28,17,41,47,61,76,82,5,74,4,80,51,22,45,91,75,91,93,42,45,69,98,76,74,83,17,30,88,53,25,35,19,26};
int param0_4[] = {-88,-84,-82,-74,-44,-34,-32,-20,-20,-14,6,6,10,12,16,24,32,34,38,46,54,54,56,60,82,88,90,94,98};
int param0_5[] = {0,1,1,1,1,0,1,1,1,1,1,1,1};
int param0_6[] = {10,14,14,14,19,20,22,26,35,36,40,53,54,55,55,57,57,67,72,72,77,78,83,84,95,96};
int param0_7[] = {-80,18,-76,48,-52,-38,52,-82,40,-44,-90,86,-86,-36,-32,-2,56,-12,-88,14,-16,8,52,24,46,56,84,-36,84,-60,72,-46,32,-16,-20,68,-86,-62,58,8,78,-52,22,-28,-22,-42,12,-48};
int param0_8[] = {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1};
int param0_9[] = {20,94,36,2,50,62,84,50,66,75,1,18,41,48,72,61,86,22,54,6,71,46,92,68,59,51,89,31,58,78,82,84};
int *param0[10] = {param0_0,param0_1,param0_2,param0_3,param0_4,param0_5,param0_6,param0_7,param0_8,param0_9};
int param1[] = {11,22,33,20,24,7,16,30,14,25};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i],param1[i]) == f_gold(param0[i],param1[i]))
{
n_success+=1;
}
break;
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
}
| {
"array_type": 2,
"break_continue_statement": 1,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
libxml2#libxml2-py_prep#libxml_xmlGetDocEntity.c | libxml2 | libxml2-py.c | libxml_xmlGetDocEntity | 14 | PyObject *
libxml_xmlGetDocEntity(PyObject *self __attribute__ ((__unused__)), PyObject *args) {
PyObject *py_retval;
xmlEntityPtr c_retval;
xmlDoc * doc;
PyObject *pyobj_doc;
xmlChar * name;
if (!_PyArg_ParseTuple_SizeT(args, (char *)"Oz:xmlGetDocEntity", &pyobj_doc, &name))
return(((void *)0));
doc = (xmlDoc *) (((pyobj_doc) == (&_Py_NoneStruct)) ? ((void *)0) : (((PyxmlNode_Object *)(pyobj_doc))->obj));
c_retval = xmlGetDocEntity(doc, name);
py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
return(py_retval);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 2,
"return_statement": 2,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 3,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#PROGRAM_CIRCUMFERENCE_PARALLELOGRAM_prep#f_filled.c | transcoder-set | PROGRAM_CIRCUMFERENCE_PARALLELOGRAM.c | f_filled | 1 | float f_filled ( float a, float b ) {}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
tulipindicators-0.9.1#di_prep#ti_di.c | tulipindicators-0.9.1 | di.c | ti_di | 40 | int ti_di(int size, double const *const *inputs, double const *options, double *const *outputs) {
const double *high = inputs[0];
const double *low = inputs[1];
const double *close = inputs[2];
const int period = (int)options[0];
double *plus_di = outputs[0];
double *minus_di = outputs[1];
if (period < 1) return 1;
if (size <= ti_di_start(options)) return 0;
const double per = ((double)period-1) / ((double)period);
double atr = 0;
double dmup = 0;
double dmdown = 0;
int i;
for (i = 1; i < period; ++i) {
double truerange;
do{ const double l = low[i]; const double h = high[i]; const double c = close[i-1]; const double ych = fabs(h - c); const double ycl = fabs(l - c); double v = h - l; if (ych > v) v = ych; if (ycl > v) v = ycl; truerange = v;}while(0);
atr += truerange;
double dp, dm;
do { dp = high[i] - high[i-1]; dm = low[i-1] - low[i]; if (dp < 0) dp = 0; else if (dp > dm) dm = 0; if (dm < 0) dm = 0; else if (dm > dp) dp = 0;} while (0);
dmup += dp;
dmdown += dm;
}
*plus_di++ = 100.0 * dmup / atr;
*minus_di++ = 100.0 * dmdown / atr;
for (i = period; i < size; ++i) {
double truerange;
do{ const double l = low[i]; const double h = high[i]; const double c = close[i-1]; const double ych = fabs(h - c); const double ycl = fabs(l - c); double v = h - l; if (ych > v) v = ych; if (ycl > v) v = ycl; truerange = v;}while(0);
atr = atr * per + truerange;
double dp, dm;
do { dp = high[i] - high[i-1]; dm = low[i-1] - low[i]; if (dp < 0) dp = 0; else if (dp > dm) dm = 0; if (dm < 0) dm = 0; else if (dm > dp) dp = 0;} while (0);
dmup = dmup * per + dp;
dmdown = dmdown * per + dm;
*plus_di++ = 100.0 * dmup / atr;
*minus_di++ = 100.0 * dmdown / atr;
}
((void) sizeof ((plus_di - outputs[0] == size - ti_di_start(options)) ? 1 : 0), __extension__ ({ if (plus_di - outputs[0] == size - ti_di_start(options)) ; else __assert_fail ("plus_di - outputs[0] == size - ti_di_start(options)", "indicators/di.c", 88, __extension__ __PRETTY_FUNCTION__); }));
((void) sizeof ((minus_di - outputs[1] == size - ti_di_start(options)) ? 1 : 0), __extension__ ({ if (minus_di - outputs[1] == size - ti_di_start(options)) ; else __assert_fail ("minus_di - outputs[1] == size - ti_di_start(options)", "indicators/di.c", 89, __extension__ __PRETTY_FUNCTION__); }));
return 0;
}
| {
"array_type": 5,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 2,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 8,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 5,
"return_statement": 3,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 4,
"union_type": 0,
"while_loop": 4
} |
libxml2#xmlunicode_prep#xmlUCSIsSpacingModifierLetters.c | libxml2 | xmlunicode.c | xmlUCSIsSpacingModifierLetters | 4 | int
xmlUCSIsSpacingModifierLetters(int code) {
return(((code >= 0x02B0) && (code <= 0x02FF)));
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
json.h#allow_equals_in_object_prep#json_get_string_size.c | json.h | allow_equals_in_object.c | json_get_string_size | 126 | int json_get_string_size(struct json_parse_state_s *state, size_t is_key) {
size_t offset = state->offset;
const size_t size = state->size;
size_t data_size = 0;
const char *const src = state->src;
const int is_single_quote = '\'' == src[offset];
const char quote_to_use = is_single_quote ? '\'' : '"';
const size_t flags_bitset = state->flags_bitset;
unsigned long codepoint;
unsigned long high_surrogate = 0;
if ((json_parse_flags_allow_location_information & flags_bitset) != 0 &&
is_key != 0) {
state->dom_size += sizeof(struct json_string_ex_s);
} else {
state->dom_size += sizeof(struct json_string_s);
}
if ('"' != src[offset]) {
if (!((json_parse_flags_allow_single_quoted_strings & flags_bitset) &&
is_single_quote)) {
state->error = json_parse_error_expected_opening_quote;
state->offset = offset;
return 1;
}
}
offset++;
while ((offset < size) && (quote_to_use != src[offset])) {
data_size++;
switch (src[offset]) {
default:
break;
case '\0':
case '\t':
state->error = json_parse_error_invalid_string;
state->offset = offset;
return 1;
}
if ('\\' == src[offset]) {
offset++;
if (offset == size) {
state->error = json_parse_error_premature_end_of_buffer;
state->offset = offset;
return 1;
}
switch (src[offset]) {
default:
state->error = json_parse_error_invalid_string_escape_sequence;
state->offset = offset;
return 1;
case '"':
case '\\':
case '/':
case 'b':
case 'f':
case 'n':
case 'r':
case 't':
offset++;
break;
case 'u':
if (!(offset + 5 < size)) {
state->error = json_parse_error_invalid_string_escape_sequence;
state->offset = offset;
return 1;
}
codepoint = 0;
if (!json_hexadecimal_value(&src[offset + 1], 4, &codepoint)) {
state->error = json_parse_error_invalid_string_escape_sequence;
state->offset = offset;
return 1;
}
if (high_surrogate != 0) {
if (codepoint >= 0xdc00 &&
codepoint <= 0xdfff) {
data_size += 3;
high_surrogate = 0;
} else {
state->error = json_parse_error_invalid_string_escape_sequence;
state->offset = offset;
return 1;
}
} else if (codepoint <= 0x7f) {
data_size += 0;
} else if (codepoint <= 0x7ff) {
data_size += 1;
} else if (codepoint >= 0xd800 &&
codepoint <= 0xdbff) {
if (offset + 11 > size || '\\' != src[offset + 5] ||
'u' != src[offset + 6]) {
state->error = json_parse_error_invalid_string_escape_sequence;
state->offset = offset;
return 1;
}
high_surrogate = codepoint;
} else if (codepoint >= 0xd800 &&
codepoint <= 0xdfff) {
state->error = json_parse_error_invalid_string_escape_sequence;
state->offset = offset;
return 1;
} else {
data_size += 2;
}
offset += 5;
break;
}
} else if (('\r' == src[offset]) || ('\n' == src[offset])) {
if (!(json_parse_flags_allow_multi_line_strings & flags_bitset)) {
state->error = json_parse_error_invalid_string_escape_sequence;
state->offset = offset;
return 1;
}
offset++;
} else {
offset++;
}
}
if (offset == size) {
state->error = json_parse_error_premature_end_of_buffer;
state->offset = offset - 1;
return 1;
}
offset++;
state->data_size += data_size;
state->data_size++;
state->offset = offset;
return 0;
}
| {
"array_type": 1,
"break_continue_statement": 3,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 17,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 12,
"struct_type": 1,
"switch_statement": 2,
"type_casting": 2,
"union_type": 0,
"while_loop": 1
} |
tmux#layout_prep#layout_spread_out.c | tmux | layout.c | layout_spread_out | 16 | void
layout_spread_out(struct window_pane *wp)
{
struct layout_cell *parent;
struct window *w = wp->window;
parent = wp->layout_cell->parent;
if (parent == ((void *)0))
return;
do {
if (layout_spread_cell(w, parent)) {
layout_fix_offsets(parent);
layout_fix_panes(w, w->sx, w->sy);
break;
}
} while ((parent = parent->parent) != ((void *)0));
}
| {
"array_type": 0,
"break_continue_statement": 1,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 2,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 2,
"return_statement": 1,
"struct_type": 3,
"switch_statement": 0,
"type_casting": 2,
"union_type": 0,
"while_loop": 1
} |
transcoder-set#TOTAL_NUMBER_OF_NON_DECREASING_NUMBERS_WITH_N_DIGITS_1_prep#min.c | transcoder-set | TOTAL_NUMBER_OF_NON_DECREASING_NUMBERS_WITH_N_DIGITS_1.c | min | 1 | int min(int x, int y) { return (x < y)? x: y; }
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
cflow-1.7#parser_prep#skip_balanced.c | cflow-1.7 | parser.c | skip_balanced | 25 | int
skip_balanced(int open_tok, int close_tok, int level)
{
if (level == 0) {
if (nexttoken() != open_tok) {
return 1;
}
level++;
}
while (nexttoken()) {
if (tok.type == LBRACE0 && open_tok == '{')
tok.type = '{';
else if (tok.type == RBRACE0 && close_tok == '}')
tok.type = '}';
if (tok.type == open_tok)
level++;
else if (tok.type == close_tok) {
if (--level == 0) {
nexttoken();
return 0;
}
}
}
return -1;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 7,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 3,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 1
} |
transcoder-set#CHECK_STRING_FOLLOWS_ANBN_PATTERN_NOT_prep#min.c | transcoder-set | CHECK_STRING_FOLLOWS_ANBN_PATTERN_NOT.c | min | 1 | int min(int x, int y) { return (x < y)? x: y; }
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
wget-1.21.4#init_prep#wgetrc_user_file_name.c | wget-1.21.4 | init.c | wgetrc_user_file_name | 16 | char *
wgetrc_user_file_name (void)
{
char *file = ((void *)0);
if (opt.homedir) {
file = ajoin_dir_file(opt.homedir, ".wgetrc");
}
if (!file)
return ((void *)0);
if (!file_exists_p (file, ((void *)0)))
{
do { free ((void *) (file)); file = ((void *)0); } while (0);
return ((void *)0);
}
return file;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 3,
"memory_management": 1,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 3,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 6,
"union_type": 0,
"while_loop": 1
} |
transcoder-set#CEILING_IN_A_SORTED_ARRAY_prep#len.c | transcoder-set | CEILING_IN_A_SORTED_ARRAY.c | len | 1 | int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
libxml2#xmlstring_prep#xmlUTF8Strsub.c | libxml2 | xmlstring.c | xmlUTF8Strsub | 22 | xmlChar *
xmlUTF8Strsub(const xmlChar *utf, int start, int len) {
int i;
int ch;
if (utf == ((void *)0)) return(((void *)0));
if (start < 0) return(((void *)0));
if (len < 0) return(((void *)0));
for (i = 0; i < start; i++) {
ch = *utf++;
if (ch == 0)
return(((void *)0));
if (ch & 0x80) {
ch <<= 1;
while (ch & 0x80) {
if (*utf++ == 0)
return(((void *)0));
ch <<= 1;
}
}
}
return(xmlUTF8Strndup(utf, len));
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 6,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 6,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 5,
"union_type": 0,
"while_loop": 1
} |
transcoder-set#COUNT_PAIRS_TWO_SORTED_ARRAYS_WHOSE_SUM_EQUAL_GIVEN_VALUE_X_prep#len.c | transcoder-set | COUNT_PAIRS_TWO_SORTED_ARRAYS_WHOSE_SUM_EQUAL_GIVEN_VALUE_X.c | len | 1 | int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#FIND_WHETHER_A_GIVEN_NUMBER_IS_A_POWER_OF_4_OR_NOT_1_prep#f_filled.c | transcoder-set | FIND_WHETHER_A_GIVEN_NUMBER_IS_A_POWER_OF_4_OR_NOT_1.c | f_filled | 1 | _Bool f_filled ( unsigned int n ) {}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
less-633#edit_prep#save_curr_ifile.c | less-633 | edit.c | save_curr_ifile | 6 | void* save_curr_ifile(void)
{
if (curr_ifile != ((void*)((void *)0)))
hold_ifile(curr_ifile, 1);
return (curr_ifile);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 2,
"union_type": 0,
"while_loop": 0
} |
nettle-3.9.1#eax_prep#nettle_eax_set_key.c | nettle-3.9.1 | eax.c | nettle_eax_set_key | 9 | void
nettle_eax_set_key (struct eax_key *key, const void *cipher, nettle_cipher_func *f)
{
static const union nettle_block16 zero_block;
f (cipher, 16, key->pad_block.b, zero_block.b);
block16_mulx_be (&key->pad_block, &key->pad_block);
block16_mulx_be (&key->pad_partial, &key->pad_block);
block16_xor (&key->pad_partial, &key->pad_block);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 1,
"switch_statement": 0,
"type_casting": 0,
"union_type": 1,
"while_loop": 0
} |
transcoder-set#CHECK_WHETHER_TRIANGLE_VALID_NOT_SIDES_GIVEN_prep#sort.c | transcoder-set | CHECK_WHETHER_TRIANGLE_VALID_NOT_SIDES_GIVEN.c | sort | 1 | void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
libosip2-5.3.1#sdp_message_prep#sdp_message_clone.c | libosip2-5.3.1 | sdp_message.c | sdp_message_clone | 18 | int sdp_message_clone(sdp_message_t *sdp, sdp_message_t **dest) {
int i;
char *body;
i = sdp_message_init(dest);
if (i != 0)
return -1;
i = sdp_message_to_str(sdp, &body);
if (i != 0)
goto error_sc1;
i = sdp_message_parse(*dest, body);
{ if (body != ((void *)0)) { if (osip_free_func) osip_free_func(body); else free(body); } };
if (i != 0)
goto error_sc1;
return 0;
error_sc1:
sdp_message_free(*dest);
return -1;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 2,
"if_statement": 4,
"memory_management": 1,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 3,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#COUNT_MINIMUM_NUMBER_SUBSETS_SUBSEQUENCES_CONSECUTIVE_NUMBERS_prep#f_gold.c | transcoder-set | COUNT_MINIMUM_NUMBER_SUBSETS_SUBSEQUENCES_CONSECUTIVE_NUMBERS.c | f_gold | 10 | int f_gold ( int arr [ ], int n ) {
sort ( arr, arr + n );
int count = 1;
for ( int i = 0;
i < n - 1;
i ++ ) {
if ( arr [ i ] + 1 != arr [ i + 1 ] ) count ++;
}
return count;
}
| {
"array_type": 1,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#DETECT_IF_TWO_INTEGERS_HAVE_OPPOSITE_SIGNS_prep#sort.c | transcoder-set | DETECT_IF_TWO_INTEGERS_HAVE_OPPOSITE_SIGNS.c | sort | 1 | void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
nano-7.2#winio_prep#convert_SS3_sequence.c | nano-7.2 | winio.c | convert_SS3_sequence | 116 | int convert_SS3_sequence(const int *seq, size_t length, int *consumed)
{
switch (seq[0]) {
case '1':
if (length > 3 && seq[1] == ';') {
*consumed = 4;
switch (seq[2]) {
case '2':
if ('A' <= seq[3] && seq[3] <= 'D') {
shift_held = 1;
return arrow_from_ABCD(seq[3]);
}
break;
case '5':
switch (seq[3]) {
case 'A':
return 0x403;
case 'B':
return 0x404;
case 'C':
return 0x402;
case 'D':
return 0x401;
}
break;
}
}
break;
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
if (length > 1) {
*consumed = 2;
if (seq[0] == '4' || seq[0] > '5')
return 0x4FC;
switch (seq[1]) {
case 'A':
return 0x403;
case 'B':
return 0x404;
case 'C':
return 0x402;
case 'D':
return 0x401;
}
return (seq[1] - 0x40);
}
break;
case 'A':
case 'B':
case 'C':
case 'D':
return arrow_from_ABCD(seq[0]);
case 'F':
return 0550;
case 'H':
return 0406;
case 'M':
return 0527;
case 'P':
case 'Q':
case 'R':
case 'S':
return (0410 +(seq[0] - 'O'));
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
return (0410 +(seq[0] - 'O'));
case 'a':
return 0x403;
case 'b':
return 0x404;
case 'c':
return 0x402;
case 'd':
return 0x401;
case 'j':
return '*';
case 'k':
return '+';
case 'l':
return ',';
case 'm':
return '-';
case 'n':
return 0512;
case 'o':
return '/';
case 'p':
return 0513;
case 'q':
return 0550;
case 'r':
return 0402;
case 's':
return 0522;
case 't':
return 0404;
case 'v':
return 0405;
case 'w':
return 0406;
case 'x':
return 0403;
case 'y':
return 0523;
}
return 0x4FC;
}
| {
"array_type": 1,
"break_continue_statement": 4,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 4,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 37,
"struct_type": 0,
"switch_statement": 4,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
units-2.22#units_prep#initializeunit.c | units-2.22 | units.c | initializeunit | 6 | void
initializeunit(struct unittype *theunit)
{
theunit->factor = 1.0;
theunit->numerator[0] = theunit->denominator[0] = ((void *)0);
}
| {
"array_type": 2,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 1,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
libxml2#xmlreader_prep#xmlTextReaderGetParserLineNumber.c | libxml2 | xmlreader.c | xmlTextReaderGetParserLineNumber | 9 | int
xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader)
{
if ((reader == ((void *)0)) || (reader->ctxt == ((void *)0)) ||
(reader->ctxt->input == ((void *)0))) {
return (0);
}
return (reader->ctxt->input->line);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 2,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 2,
"union_type": 0,
"while_loop": 0
} |
gzip-1.12#bits_prep#bi_reverse.c | gzip-1.12 | bits.c | bi_reverse | 11 | unsigned bi_reverse(code, len)
unsigned code;
int len;
{
register unsigned res = 0;
do {
res |= code & 1;
code >>= 1, res <<= 1;
} while (--len > 0);
return res >> 1;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 1
} |
mtools-4.0.43#stream_prep#pwrite_pass_through.c | mtools-4.0.43 | stream.c | pwrite_pass_through | 5 | ssize_t pwrite_pass_through(Stream_t *Stream, char *buf,
mt_off_t start, size_t len)
{
return ((Stream->Next)->Class->pwrite)( (Stream->Next), (char *) (buf), (start), (len) );
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
indent-2.2.13#output_prep#close_output.c | indent-2.2.13 | output.c | close_output | 25 | extern void close_output(
struct stat * file_stats,
const char * filename)
{
if (output != stdout)
{
if (fclose(output) != 0)
{
fatal(gettext("Can't close output file %s"), filename);
}
else
{
if (file_stats != ((void *)0) && filename)
{
struct utimbuf buf;
buf.actime = time (((void *)0));
buf.modtime = file_stats->st_mtim.tv_sec;
if (utime(filename, &buf) != 0)
{
message(gettext("Warning"), gettext("Can't preserve modification time on output file %s"), (char *)(filename), (char *)(0));
}
}
}
}
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 4,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 3,
"union_type": 0,
"while_loop": 0
} |
gawk-5.2.2#symbol_prep#release_symbols.c | gawk-5.2.2 | symbol.c | release_symbols | 13 | void
release_symbols(NODE *symlist, int keep_globals)
{
NODE *p, *next;
for (p = symlist->sub.nodep.r.rptr; p != ((void *)0); p = next) {
if (! keep_globals) {
destroy_symbol(p->sub.nodep.l.lptr);
}
next = p->sub.nodep.r.rptr;
(void) (((struct block_item *) p)->freep = nextfree[BLOCK_NODE].freep, nextfree[BLOCK_NODE].freep = (struct block_item *) p);
}
symlist->sub.nodep.r.rptr = ((void *)0);
}
| {
"array_type": 1,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 2,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 3,
"union_type": 0,
"while_loop": 0
} |
optipng-0.7.8#pngrtran_prep#png_do_read_transformations.c | optipng-0.7.8 | pngrtran.c | png_do_read_transformations | 17 | void
png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
{
((void)0);
if (png_ptr->row_buf == ((void *)0))
{
png_error(png_ptr, "NULL row buffer");
}
if ((png_ptr->flags & 0x4000U) != 0 &&
(png_ptr->flags & 0x0040U) == 0)
{
png_error(png_ptr, "Uninitialized row");
}
if (row_info->color_type == (2 | 1) &&
png_ptr->num_palette_max >= 0)
png_do_check_palette_indexes(png_ptr, row_info);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 3,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 2,
"union_type": 0,
"while_loop": 0
} |
tulipindicators-0.9.1#ppo_prep#ti_ppo.c | tulipindicators-0.9.1 | ppo.c | ti_ppo | 23 | int ti_ppo(int size, double const *const *inputs, double const *options, double *const *outputs) {
const double *input = inputs[0];
double *ppo = outputs[0];
const int short_period = (int)options[0];
const int long_period = (int)options[1];
if (short_period < 1) return 1;
if (long_period < 2) return 1;
if (long_period < short_period) return 1;
if (size <= ti_ppo_start(options)) return 0;
double short_per = 2 / ((double)short_period + 1);
double long_per = 2 / ((double)long_period + 1);
double short_ema = input[0];
double long_ema = input[0];
int i;
for (i = 1; i < size; ++i) {
short_ema = (input[i]-short_ema) * short_per + short_ema;
long_ema = (input[i]-long_ema) * long_per + long_ema;
const double out = 100.0 * (short_ema - long_ema) / long_ema;
*ppo++ = out;
}
((void) sizeof ((ppo - outputs[0] == size - ti_ppo_start(options)) ? 1 : 0), __extension__ ({ if (ppo - outputs[0] == size - ti_ppo_start(options)) ; else __assert_fail ("ppo - outputs[0] == size - ti_ppo_start(options)", "indicators/ppo.c", 63, __extension__ __PRETTY_FUNCTION__); }));
return 0;
}
| {
"array_type": 4,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 5,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 2,
"return_statement": 5,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 5,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#BIN_PACKING_PROBLEM_MINIMIZE_NUMBER_OF_USED_BINS_prep#len.c | transcoder-set | BIN_PACKING_PROBLEM_MINIMIZE_NUMBER_OF_USED_BINS.c | len | 1 | int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
tulipindicators-0.9.1#bop_prep#ti_bop.c | tulipindicators-0.9.1 | bop.c | ti_bop | 18 | int ti_bop(int size, double const *const *inputs, double const *options, double *const *outputs) {
const double *open = inputs[0];
const double *high = inputs[1];
const double *low = inputs[2];
const double *close = inputs[3];
(void)options;
double *output = outputs[0];
int i;
for (i = 0; i < size; ++i) {
double hl = high[i] - low[i];
if (hl <= 0.0) {
output[i] = 0;
} else {
output[i] = (close[i] - open[i]) / hl;
}
}
return 0;
}
| {
"array_type": 7,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 5,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
json.h#allow_multi_line_strings_prep#json_write_pretty.c | json.h | allow_multi_line_strings.c | json_write_pretty | 42 | void *json_write_pretty(const struct json_value_s *value, const char *indent,
const char *newline, size_t *out_size) {
size_t size = 0;
size_t indent_size = 0;
size_t newline_size = 0;
char *data = 0;
char *data_end = 0;
if (0 == value) {
return 0;
}
if (0 == indent) {
indent = " ";
}
if (0 == newline) {
newline = "\n";
}
while ('\0' != indent[indent_size]) {
++indent_size;
}
while ('\0' != newline[newline_size]) {
++newline_size;
}
if (json_write_pretty_get_value_size(value, 0, indent_size, newline_size,
&size)) {
return 0;
}
size += 1;
data = (char *)malloc(size);
if (0 == data) {
return 0;
}
data_end = json_write_pretty_value(value, 0, indent, newline, data);
if (0 == data_end) {
free(data);
return 0;
}
*data_end = '\0';
if (0 != out_size) {
*out_size = size;
}
return data;
}
| {
"array_type": 2,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 7,
"memory_management": 2,
"memory_operation": 0,
"pointer_type": 2,
"return_statement": 5,
"struct_type": 1,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 2
} |
gprolog-1.5.0#bc_supp_prep#Pl_BC_Start_Emit_0.c | gprolog-1.5.0 | bc_supp.c | Pl_BC_Start_Emit_0 | 5 | void
Pl_BC_Start_Emit_0(void)
{
bc_sp = bc;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#SUM_PAIRWISE_PRODUCTS_2_prep#main.c | transcoder-set | SUM_PAIRWISE_PRODUCTS_2.c | main | 15 | int main(void)
{
int n_success = 0;
int param0[] = {57, 18, 97, 9, 42, 67, 71, 66, 69, 18};
for (int i = 0; i < len(param0); ++i)
{
if (f_filled(param0[i]) == f_gold(param0[i]))
{
n_success += 1;
}
break;
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
}
| {
"array_type": 1,
"break_continue_statement": 1,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
libosip2-5.3.1#osip_dialog_prep#osip_dialog_update_osip_cseq_as_uas.c | libosip2-5.3.1 | osip_dialog.c | osip_dialog_update_osip_cseq_as_uas | 8 | int osip_dialog_update_osip_cseq_as_uas(osip_dialog_t *dialog, osip_message_t *invite) {
if (dialog == ((void *)0))
return -2;
if (invite == ((void *)0) || invite->cseq == ((void *)0) || invite->cseq->number == ((void *)0))
return -2;
dialog->remote_cseq = osip_atoi(invite->cseq->number);
return 0;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 2,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 3,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 2,
"union_type": 0,
"while_loop": 0
} |
libxml2#libxml2-py_prep#libxml_xmlUCSIsHiragana.c | libxml2 | libxml2-py.c | libxml_xmlUCSIsHiragana | 13 | PyObject *
libxml_xmlUCSIsHiragana(PyObject *self __attribute__ ((__unused__)), PyObject *args) {
PyObject *py_retval;
int c_retval;
int code;
if (libxml_deprecationWarning("xmlUCSIsHiragana") == -1)
return(((void *)0));
if (!_PyArg_ParseTuple_SizeT(args, (char *)"i:xmlUCSIsHiragana", &code))
return(((void *)0));
c_retval = xmlUCSIsHiragana(code);
py_retval = libxml_intWrap((int) c_retval);
return(py_retval);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 2,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 3,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 4,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#HOW_TO_BEGIN_WITH_COMPETITIVE_PROGRAMMING_prep#min.c | transcoder-set | HOW_TO_BEGIN_WITH_COMPETITIVE_PROGRAMMING.c | min | 1 | int min(int x, int y) { return (x < y)? x: y; }
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
libosip2-5.3.1#port_fifo_prep#osip_fifo_free.c | libosip2-5.3.1 | port_fifo.c | osip_fifo_free | 7 | void osip_fifo_free(osip_fifo_t *ff) {
if (ff == ((void *)0))
return;
osip_mutex_destroy(ff->qislocked);
osip_sem_destroy(ff->qisempty);
{ if (ff != ((void *)0)) { if (osip_free_func) osip_free_func(ff); else free(ff); } };
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 2,
"memory_management": 1,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 2,
"union_type": 0,
"while_loop": 0
} |
nano-7.2#files_prep#do_writeout.c | nano-7.2 | files.c | do_writeout | 5 | void do_writeout(void)
{
if (write_it_out(0, 1) == 2)
close_and_go();
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
nano-7.2#color_prep#found_in_list.c | nano-7.2 | color.c | found_in_list | 7 | _Bool found_in_list(regexlisttype *head, const char *shibboleth)
{
for (regexlisttype *item = head; item != ((void *)0); item = item->next)
if (regexec(item->one_rgx, shibboleth, 0, ((void *)0), 0) == 0)
return 1;
return 0;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 2,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 2,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#HOW_TO_CHECK_IF_A_GIVEN_ARRAY_REPRESENTS_A_BINARY_HEAP_prep#len.c | transcoder-set | HOW_TO_CHECK_IF_A_GIVEN_ARRAY_REPRESENTS_A_BINARY_HEAP.c | len | 1 | int len (int arr [ ]) {return ((int) (sizeof (arr) / sizeof (arr)[0]));}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
json-c#json_object_prep#json_object_object_length.c | json-c | json_object.c | json_object_object_length | 5 | int json_object_object_length(const struct json_object *jso)
{
((void) sizeof ((json_object_get_type(jso) == json_type_object) ? 1 : 0), __extension__ ({ if (json_object_get_type(jso) == json_type_object) ; else __assert_fail ("json_object_get_type(jso) == json_type_object", "/home/melih/storage/Transpiler/Dataset/projects/codebases_v2/json-c/json_object.c", 601, __extension__ __PRETTY_FUNCTION__); }));
return lh_table_length(JC_OBJECT_C(jso)->c_object);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 1,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#MAKING_ELEMENTS_OF_TWO_ARRAYS_SAME_WITH_MINIMUM_INCREMENTDECREMENT_prep#f_filled.c | transcoder-set | MAKING_ELEMENTS_OF_TWO_ARRAYS_SAME_WITH_MINIMUM_INCREMENTDECREMENT.c | f_filled | 1 | int f_filled ( int a [ ], int b [ ], int n ) {}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#PRIMALITY_TEST_SET_1_INTRODUCTION_AND_SCHOOL_METHOD_1_prep#cmpfunc.c | transcoder-set | PRIMALITY_TEST_SET_1_INTRODUCTION_AND_SCHOOL_METHOD_1.c | cmpfunc | 1 | int cmpfunc (const void * a, const void * b) {return ( *(int*)a - *(int*)b );}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
patch-2.7.6#verror_prep#verror_at_line.c | patch-2.7.6 | verror.c | verror_at_line | 19 | void
verror_at_line (int status, int errnum, const char *file,
unsigned int line_number, const char *format, va_list args)
{
char *message = xvasprintf (format, args);
if (message)
{
if (file)
error_at_line (status, errnum, file, line_number, "%s", message);
else
error (status, errnum, "%s", message);
}
else
{
error (0, (*__errno_location ()), "unable to display error message");
abort ();
}
free (message);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 2,
"memory_management": 1,
"memory_operation": 0,
"pointer_type": 1,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#MAXIMUM_PRODUCT_SUBSET_ARRAY_prep#sort.c | transcoder-set | MAXIMUM_PRODUCT_SUBSET_ARRAY.c | sort | 1 | void sort (int arr [ ], int n) {qsort (arr, n, sizeof(int), cmpfunc);}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
tar-1.34#misc_prep#blocking_read.c | tar-1.34 | misc.c | blocking_read | 13 | size_t
blocking_read (int fd, void *buf, size_t count)
{
size_t bytes = safe_read (fd, buf, count);
if (bytes == ((size_t) -1) && (*__errno_location ()) == 11)
{
int flags = rpl_fcntl (fd, 3);
if (0 <= flags && flags & 04000
&& rpl_fcntl (fd, 4, flags & ~04000) != -1)
bytes = safe_read (fd, buf, count);
}
return bytes;
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 2,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
cpio-2.14#paxerror_prep#truncate_error.c | cpio-2.14 | paxerror.c | truncate_error | 5 | void
truncate_error (char const *name)
{
call_arg_error ("truncate", name);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
cflow-1.7#symbol_prep#delete_autos.c | cflow-1.7 | symbol.c | delete_autos | 6 | void
delete_autos(int level)
{
linked_list_iterate(&auto_symbol_list, delete_level_autos, &level);
linked_list_iterate(&static_symbol_list, delete_level_statics, &level);
}
| {
"array_type": 0,
"break_continue_statement": 0,
"enum_type": 0,
"for_loop": 0,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 0,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 0,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 0,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#QUICK_WAY_CHECK_CHARACTERS_STRING_prep#main.c | transcoder-set | QUICK_WAY_CHECK_CHARACTERS_STRING.c | main | 14 | int main(void) {
int n_success = 0;
char param0[][100] = {"","ggg","11","KoYIHns","232","10111000011101","DDDD","11","11111","ewJvixQzu"};
for(int i = 0; i < len(param0); ++i)
{
if(f_filled(param0[i]) == f_gold(param0[i]))
{
n_success+=1;
}
break;
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
}
| {
"array_type": 1,
"break_continue_statement": 1,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
transcoder-set#AREA_OF_THE_CIRCLE_THAT_HAS_A_SQUARE_AND_A_CIRCLE_INSCRIBED_IN_IT_prep#main.c | transcoder-set | AREA_OF_THE_CIRCLE_THAT_HAS_A_SQUARE_AND_A_CIRCLE_INSCRIBED_IN_IT.c | main | 14 | int main(void) {
int n_success = 0;
int param0[] = {669,18,83,39,68,28,71,14,21,73};
for(int i = 0; i < len(param0); ++i)
{
if(abs(1 - (0.0000001 + abs(f_gold(param0[i])) )/ (abs(f_filled(param0[i])) + 0.0000001)) < 0.001F)
{
n_success+=1;
}
break;
}
printf("#Results:", " ", n_success, ", ", len(param0));
return 0;
}
| {
"array_type": 1,
"break_continue_statement": 1,
"enum_type": 0,
"for_loop": 1,
"function_pointer": 0,
"goto_statement": 0,
"if_statement": 1,
"memory_management": 0,
"memory_operation": 0,
"pointer_type": 0,
"return_statement": 1,
"struct_type": 0,
"switch_statement": 0,
"type_casting": 1,
"union_type": 0,
"while_loop": 0
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.