hash
int64 -9,197,960,073,880,366,000
9,199,363,627B
| project
stringclasses 2
values | size
int64 2
5.68k
| label
int64 0
1
| functionSource
stringlengths 31
235k
|
|---|---|---|---|---|
1,788,300,783,882,316,800 | debian | 17 | 0 | static inline void set_p_mv_tables ( MpegEncContext * s , int mx , int my , int mv4 ) {
const int xy = s -> mb_x + s -> mb_y * s -> mb_stride ;
s -> p_mv_table [ xy ] [ 0 ] = mx ;
s -> p_mv_table [ xy ] [ 1 ] = my ;
if ( mv4 ) {
int mot_xy = s -> block_index [ 0 ] ;
s -> current_picture . motion_val [ 0 ] [ mot_xy ] [ 0 ] = mx ;
s -> current_picture . motion_val [ 0 ] [ mot_xy ] [ 1 ] = my ;
s -> current_picture . motion_val [ 0 ] [ mot_xy + 1 ] [ 0 ] = mx ;
s -> current_picture . motion_val [ 0 ] [ mot_xy + 1 ] [ 1 ] = my ;
mot_xy += s -> b8_stride ;
s -> current_picture . motion_val [ 0 ] [ mot_xy ] [ 0 ] = mx ;
s -> current_picture . motion_val [ 0 ] [ mot_xy ] [ 1 ] = my ;
s -> current_picture . motion_val [ 0 ] [ mot_xy + 1 ] [ 0 ] = mx ;
s -> current_picture . motion_val [ 0 ] [ mot_xy + 1 ] [ 1 ] = my ;
}
} |
9,173,748,358,801,811,000 | debian | 10 | 0 | const char * mgs_hook_http_scheme ( const request_rec * r ) {
mgs_srvconf_rec * sc ;
if ( r == NULL ) return NULL ;
sc = ( mgs_srvconf_rec * ) ap_get_module_config ( r -> server -> module_config , & gnutls_module ) ;
_gnutls_log ( debug_log_fp , "%s: %d\n" , __func__ , __LINE__ ) ;
if ( sc -> enabled == GNUTLS_ENABLED_FALSE ) {
return NULL ;
}
return "https" ;
} |
-8,028,756,826,159,774,000 | debian | 22 | 0 | void WriteHead ( ArchiveHandle * AH ) {
struct tm crtm ;
( * AH -> WriteBufPtr ) ( AH , "PGDMP" , 5 ) ;
( * AH -> WriteBytePtr ) ( AH , AH -> vmaj ) ;
( * AH -> WriteBytePtr ) ( AH , AH -> vmin ) ;
( * AH -> WriteBytePtr ) ( AH , AH -> vrev ) ;
( * AH -> WriteBytePtr ) ( AH , AH -> intSize ) ;
( * AH -> WriteBytePtr ) ( AH , AH -> offSize ) ;
( * AH -> WriteBytePtr ) ( AH , AH -> format ) ;
WriteInt ( AH , AH -> compression ) ;
crtm = * localtime ( & AH -> createDate ) ;
WriteInt ( AH , crtm . tm_sec ) ;
WriteInt ( AH , crtm . tm_min ) ;
WriteInt ( AH , crtm . tm_hour ) ;
WriteInt ( AH , crtm . tm_mday ) ;
WriteInt ( AH , crtm . tm_mon ) ;
WriteInt ( AH , crtm . tm_year ) ;
WriteInt ( AH , crtm . tm_isdst ) ;
WriteStr ( AH , PQdb ( AH -> connection ) ) ;
WriteStr ( AH , AH -> public . remoteVersionStr ) ;
WriteStr ( AH , PG_VERSION ) ;
} |
-714,975,729,066,076,400 | chrome | 6 | 0 | hb_blob_t * hb_blob_get_empty ( void ) {
static const hb_blob_t _hb_blob_nil = {
HB_OBJECT_HEADER_STATIC , true , NULL , 0 , HB_MEMORY_MODE_READONLY , NULL , NULL }
;
return const_cast < hb_blob_t * > ( & _hb_blob_nil ) ;
} |
2,895,622,461,494,525,400 | debian | 21 | 0 | void mct_start_logging ( const char * test_case_name ) {
const char * tmp_dir = getenv ( "MYSQL_TMP_DIR" ) ;
if ( ! tmp_dir ) {
printf ( "Warning: MYSQL_TMP_DIR is not set. Logging is disabled.\n" ) ;
return ;
}
if ( mct_log_file ) {
printf ( "Warning: can not start logging for test case '%s' " "because log is already open\n" , ( const char * ) test_case_name ) ;
return ;
}
if ( strlen ( tmp_dir ) + strlen ( test_case_name ) + 10 > FILE_PATH_SIZE ) {
printf ( "Warning: MYSQL_TMP_DIR is too long. Logging is disabled.\n" ) ;
return ;
}
my_snprintf ( mct_log_file_path , FILE_PATH_SIZE , "%s/%s.out.log" , ( const char * ) tmp_dir , ( const char * ) test_case_name ) ;
mct_log_file = my_fopen ( mct_log_file_path , O_WRONLY | O_BINARY , MYF ( MY_WME ) ) ;
if ( ! mct_log_file ) {
printf ( "Warning: can not open log file (%s): %s. Logging is disabled.\n" , ( const char * ) mct_log_file_path , ( const char * ) strerror ( errno ) ) ;
return ;
}
} |
-7,777,644,912,037,189,000 | debian | 20 | 0 | static void udvm_state_create ( guint8 * state_buff , guint8 * state_identifier , guint16 p_id_length ) {
char partial_state [ STATE_BUFFER_SIZE ] ;
guint i ;
gchar * partial_state_str ;
gchar * dummy_buff ;
i = 0 ;
while ( i < p_id_length && i < STATE_BUFFER_SIZE ) {
partial_state [ i ] = state_identifier [ i ] ;
i ++ ;
}
partial_state_str = bytes_to_str ( NULL , partial_state , p_id_length ) ;
dummy_buff = ( gchar * ) g_hash_table_lookup ( state_buffer_table , partial_state_str ) ;
if ( dummy_buff == NULL ) {
g_hash_table_insert ( state_buffer_table , g_strdup ( partial_state_str ) , state_buff ) ;
}
else {
g_free ( state_buff ) ;
}
wmem_free ( NULL , partial_state_str ) ;
} |
6,393,050,609,822,898,000 | debian | 4 | 0 | static uint64_t xhci_doorbell_read ( void * ptr , hwaddr reg , unsigned size ) {
trace_usb_xhci_doorbell_read ( reg , 0 ) ;
return 0 ;
} |
6,298,409,723,927,571,000 | chrome | 37 | 0 | static inline void insert_dotted_circles ( const hb_ot_shape_plan_t * plan HB_UNUSED , hb_font_t * font , hb_buffer_t * buffer ) {
bool has_broken_syllables = false ;
unsigned int count = buffer -> len ;
hb_glyph_info_t * info = buffer -> info ;
for ( unsigned int i = 0 ;
i < count ;
i ++ ) if ( ( info [ i ] . syllable ( ) & 0x0F ) == broken_cluster ) {
has_broken_syllables = true ;
break ;
}
if ( likely ( ! has_broken_syllables ) ) return ;
hb_codepoint_t dottedcircle_glyph ;
if ( ! font -> get_glyph ( 0x25CCu , 0 , & dottedcircle_glyph ) ) return ;
hb_glyph_info_t dottedcircle = {
0 }
;
dottedcircle . codepoint = 0x25CCu ;
set_myanmar_properties ( dottedcircle ) ;
dottedcircle . codepoint = dottedcircle_glyph ;
buffer -> clear_output ( ) ;
buffer -> idx = 0 ;
unsigned int last_syllable = 0 ;
while ( buffer -> idx < buffer -> len ) {
unsigned int syllable = buffer -> cur ( ) . syllable ( ) ;
syllable_type_t syllable_type = ( syllable_type_t ) ( syllable & 0x0F ) ;
if ( unlikely ( last_syllable != syllable && syllable_type == broken_cluster ) ) {
last_syllable = syllable ;
hb_glyph_info_t info = dottedcircle ;
info . cluster = buffer -> cur ( ) . cluster ;
info . mask = buffer -> cur ( ) . mask ;
info . syllable ( ) = buffer -> cur ( ) . syllable ( ) ;
buffer -> output_info ( info ) ;
}
else buffer -> next_glyph ( ) ;
}
buffer -> swap_buffers ( ) ;
} |
5,400,542,917,484,464,000 | chrome | 5 | 1 | char * vpx_svc_get_rc_stats_buffer ( const SvcContext * svc_ctx ) {
const SvcInternal * const si = get_const_svc_internal ( svc_ctx ) ;
if ( svc_ctx == NULL || si == NULL ) return NULL ;
return si -> rc_stats_buf ;
} |
3,599,206,110,384,554,500 | debian | 13 | 0 | static ossl_inline unsigned long lh_ ## type ## _get_down_load ( LHASH_OF ( type ) * lh ) {
return OPENSSL_LH_get_down_load ( ( OPENSSL_LHASH * ) lh ) ;
}
static ossl_inline void lh_ ## type ## _set_down_load ( LHASH_OF ( type ) * lh , unsigned long dl ) {
OPENSSL_LH_set_down_load ( ( OPENSSL_LHASH * ) lh , dl ) ;
}
static ossl_inline void lh_ ## type ## _doall ( LHASH_OF ( type ) * lh , void ( * doall ) ( type * ) ) {
OPENSSL_LH_doall ( ( OPENSSL_LHASH * ) lh , ( OPENSSL_LH_DOALL_FUNC ) doall ) ;
}
LHASH_OF ( type ) # define IMPLEMENT_LHASH_DOALL_ARG_CONST ( type , argtype ) int_implement_lhash_doall ( type , argtype , const type ) # define IMPLEMENT_LHASH_DOALL_ARG ( type , argtype ) int_implement_lhash_doall ( type , argtype , type ) # define int_implement_lhash_doall ( type , argtype , cbargtype ) static ossl_inline void lh_ ## type ## _doall_ ## argtype ( LHASH_OF ( type ) * lh , void ( * fn ) ( cbargtype * , argtype * ) , argtype * arg ) {
OPENSSL_LH_doall_arg ( ( OPENSSL_LHASH * ) lh , ( OPENSSL_LH_DOALL_FUNCARG ) fn , ( void * ) arg ) ;
}
LHASH_OF ( type ) DEFINE_LHASH_OF ( OPENSSL_STRING ) |
-3,062,453,801,436,404,700 | debian | 9 | 1 | static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char ) |
2,895,622,461,494,525,400 | debian | 61 | 0 | static void test_bug1115 ( ) {
MYSQL_STMT * stmt ;
int rc ;
MYSQL_BIND my_bind [ 1 ] ;
ulong length [ 1 ] ;
char szData [ 11 ] ;
char query [ MAX_TEST_QUERY_LENGTH ] ;
myheader ( "test_bug1115" ) ;
rc = mysql_query ( mysql , "DROP TABLE IF EXISTS test_select" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "CREATE TABLE test_select(\ session_id char(9) NOT NULL, \ a int(8) unsigned NOT NULL, \ b int(5) NOT NULL, \ c int(5) NOT NULL, \ d datetime NOT NULL)" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "INSERT INTO test_select VALUES " "(\"abc\", 1, 2, 3, 2003-08-30), " "(\"abd\", 1, 2, 3, 2003-08-30), " "(\"abf\", 1, 2, 3, 2003-08-30), " "(\"abg\", 1, 2, 3, 2003-08-30), " "(\"abh\", 1, 2, 3, 2003-08-30), " "(\"abj\", 1, 2, 3, 2003-08-30), " "(\"abk\", 1, 2, 3, 2003-08-30), " "(\"abl\", 1, 2, 3, 2003-08-30), " "(\"abq\", 1, 2, 3, 2003-08-30) " ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "INSERT INTO test_select VALUES " "(\"abw\", 1, 2, 3, 2003-08-30), " "(\"abe\", 1, 2, 3, 2003-08-30), " "(\"abr\", 1, 2, 3, 2003-08-30), " "(\"abt\", 1, 2, 3, 2003-08-30), " "(\"aby\", 1, 2, 3, 2003-08-30), " "(\"abu\", 1, 2, 3, 2003-08-30), " "(\"abi\", 1, 2, 3, 2003-08-30), " "(\"abo\", 1, 2, 3, 2003-08-30), " "(\"abp\", 1, 2, 3, 2003-08-30), " "(\"abz\", 1, 2, 3, 2003-08-30), " "(\"abx\", 1, 2, 3, 2003-08-30)" ) ;
myquery ( rc ) ;
strmov ( query , "SELECT * FROM test_select WHERE " "CONVERT(session_id USING utf8)= ?" ) ;
stmt = mysql_simple_prepare ( mysql , query ) ;
check_stmt ( stmt ) ;
verify_param_count ( stmt , 1 ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
strmov ( szData , ( char * ) "abc" ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_STRING ;
my_bind [ 0 ] . buffer = ( void * ) szData ;
my_bind [ 0 ] . buffer_length = 10 ;
my_bind [ 0 ] . length = & length [ 0 ] ;
length [ 0 ] = 3 ;
rc = mysql_stmt_bind_param ( stmt , my_bind ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = my_process_stmt_result ( stmt ) ;
DIE_UNLESS ( rc == 1 ) ;
strmov ( szData , ( char * ) "venu" ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_STRING ;
my_bind [ 0 ] . buffer = ( void * ) szData ;
my_bind [ 0 ] . buffer_length = 10 ;
my_bind [ 0 ] . length = & length [ 0 ] ;
length [ 0 ] = 4 ;
my_bind [ 0 ] . is_null = 0 ;
rc = mysql_stmt_bind_param ( stmt , my_bind ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = my_process_stmt_result ( stmt ) ;
DIE_UNLESS ( rc == 0 ) ;
strmov ( szData , ( char * ) "abc" ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_STRING ;
my_bind [ 0 ] . buffer = ( void * ) szData ;
my_bind [ 0 ] . buffer_length = 10 ;
my_bind [ 0 ] . length = & length [ 0 ] ;
length [ 0 ] = 3 ;
my_bind [ 0 ] . is_null = 0 ;
rc = mysql_stmt_bind_param ( stmt , my_bind ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = my_process_stmt_result ( stmt ) ;
DIE_UNLESS ( rc == 1 ) ;
mysql_stmt_close ( stmt ) ;
} |
-6,552,851,419,396,579,000 | debian | 31 | 0 | static int dissect_NOTIFY_INFO_DATA ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep ) {
proto_item * item ;
proto_tree * subtree ;
guint32 count ;
guint16 type , field ;
const char * field_string ;
subtree = proto_tree_add_subtree ( tree , tvb , offset , 0 , ett_NOTIFY_INFO_DATA , & item , "" ) ;
offset = dissect_ndr_uint16 ( tvb , offset , pinfo , subtree , di , drep , hf_notify_info_data_type , & type ) ;
offset = dissect_notify_field ( tvb , offset , pinfo , subtree , di , drep , type , & field ) ;
switch ( type ) {
case PRINTER_NOTIFY_TYPE : field_string = val_to_str_ext ( field , & printer_notify_option_data_vals_ext , "Unknown (%d)" ) ;
break ;
case JOB_NOTIFY_TYPE : field_string = val_to_str_ext ( field , & job_notify_option_data_vals_ext , "Unknown (%d)" ) ;
break ;
default : field_string = "Unknown field" ;
break ;
}
proto_item_append_text ( item , "%s, %s" , val_to_str ( type , printer_notify_types , "Unknown (%d)" ) , field_string ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_notify_info_data_count , & count ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_notify_info_data_id , NULL ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_notify_info_data_count , NULL ) ;
switch ( type ) {
case PRINTER_NOTIFY_TYPE : offset = dissect_NOTIFY_INFO_DATA_printer ( tvb , offset , pinfo , subtree , item , di , drep , field ) ;
break ;
case JOB_NOTIFY_TYPE : offset = dissect_NOTIFY_INFO_DATA_job ( tvb , offset , pinfo , subtree , item , di , drep , field ) ;
break ;
default : expert_add_info ( pinfo , item , & ei_notify_info_data_type ) ;
break ;
}
return offset ;
} |
-5,706,788,925,640,467,000 | chrome | 21 | 1 | static void update_state_rt ( VP9_COMP * cpi , PICK_MODE_CONTEXT * ctx , int mi_row , int mi_col , int bsize ) {
VP9_COMMON * const cm = & cpi -> common ;
MACROBLOCK * const x = & cpi -> mb ;
MACROBLOCKD * const xd = & x -> e_mbd ;
MB_MODE_INFO * const mbmi = & xd -> mi [ 0 ] -> mbmi ;
const struct segmentation * const seg = & cm -> seg ;
* ( xd -> mi [ 0 ] ) = ctx -> mic ;
if ( ( cpi -> oxcf . aq_mode == CYCLIC_REFRESH_AQ ) && seg -> enabled ) {
vp9_cyclic_refresh_update_segment ( cpi , & xd -> mi [ 0 ] -> mbmi , mi_row , mi_col , bsize , 1 ) ;
vp9_init_plane_quantizers ( cpi , x ) ;
}
if ( is_inter_block ( mbmi ) ) {
vp9_update_mv_count ( cm , xd ) ;
if ( cm -> interp_filter == SWITCHABLE ) {
const int pred_ctx = vp9_get_pred_context_switchable_interp ( xd ) ;
++ cm -> counts . switchable_interp [ pred_ctx ] [ mbmi -> interp_filter ] ;
}
}
x -> skip = ctx -> skip ;
x -> skip_txfm [ 0 ] = mbmi -> segment_id ? 0 : ctx -> skip_txfm [ 0 ] ;
} |
-9,032,389,459,913,766,000 | debian | 3 | 0 | static inline int snmp6_unregister_dev ( struct inet6_dev * idev ) {
return 0 ;
} |
6,595,989,226,414,083,000 | debian | 7 | 0 | static __inline__ __u64 __fswab64 ( __u64 val ) {
# if defined ( __arch_swab64 ) return __arch_swab64 ( val ) ;
# elif defined ( __SWAB_64_THRU_32__ ) __u32 h = val >> 32 ;
__u32 l = val & ( ( 1ULL << 32 ) - 1 ) ;
return ( ( ( __u64 ) __fswab32 ( l ) ) << 32 ) | ( ( __u64 ) ( __fswab32 ( h ) ) ) ;
# else return ___constant_swab64 ( val ) ;
# endif } |
3,599,206,110,384,554,500 | debian | 75 | 1 | static ossl_inline int sk_ ## t1 ## _num ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_num ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _value ( const STACK_OF ( t1 ) * sk , int idx ) {
return ( t2 * ) OPENSSL_sk_value ( ( const OPENSSL_STACK * ) sk , idx ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _new ( sk_ ## t1 ## _compfunc compare ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_new ( ( OPENSSL_sk_compfunc ) compare ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _new_null ( void ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_new_null ( ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _new_reserve ( sk_ ## t1 ## _compfunc compare , int n ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_new_reserve ( ( OPENSSL_sk_compfunc ) compare , n ) ;
}
static ossl_inline int sk_ ## t1 ## _reserve ( STACK_OF ( t1 ) * sk , int n ) {
return OPENSSL_sk_reserve ( ( OPENSSL_STACK * ) sk , n ) ;
}
static ossl_inline void sk_ ## t1 ## _free ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_free ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _zero ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_zero ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _delete ( STACK_OF ( t1 ) * sk , int i ) {
return ( t2 * ) OPENSSL_sk_delete ( ( OPENSSL_STACK * ) sk , i ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _delete_ptr ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_delete_ptr ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _push ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_push ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _unshift ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_unshift ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _pop ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_pop ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _shift ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_shift ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _pop_free ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _freefunc freefunc ) {
OPENSSL_sk_pop_free ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline int sk_ ## t1 ## _insert ( STACK_OF ( t1 ) * sk , t2 * ptr , int idx ) {
return OPENSSL_sk_insert ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr , idx ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _set ( STACK_OF ( t1 ) * sk , int idx , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_set ( ( OPENSSL_STACK * ) sk , idx , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find_ex ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find_ex ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline void sk_ ## t1 ## _sort ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_sort ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char ) DEFINE_SPECIAL_STACK_OF_CONST ( OPENSSL_CSTRING , char ) |
6,323,824,267,898,511,000 | debian | 4 | 0 | const char * fz_colorspace_colorant ( fz_context * ctx , const fz_colorspace * cs , int i ) {
if ( ! cs || i < 0 || i >= cs -> n ) fz_throw ( ctx , FZ_ERROR_GENERIC , "Colorant out of range" ) ;
return cs -> colorant [ i ] ;
} |
594,127,775,011,357,000 | debian | 94 | 0 | static void ImportAlphaQuantum ( const Image * image , QuantumInfo * quantum_info , const MagickSizeType number_pixels , const unsigned char * magick_restrict p , Quantum * magick_restrict q , ExceptionInfo * exception ) {
QuantumAny range ;
register ssize_t x ;
unsigned int pixel ;
assert ( image != ( Image * ) NULL ) ;
assert ( image -> signature == MagickCoreSignature ) ;
switch ( quantum_info -> depth ) {
case 8 : {
unsigned char pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushCharPixel ( p , & pixel ) ;
SetPixelAlpha ( image , ScaleCharToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 16 : {
unsigned short pixel ;
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelAlpha ( image , ClampToQuantum ( QuantumRange * HalfToSinglePrecision ( pixel ) ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelAlpha ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 32 : {
unsigned int pixel ;
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
float pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushFloatPixel ( quantum_info , p , & pixel ) ;
SetPixelAlpha ( image , ClampToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelAlpha ( image , ScaleLongToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 64 : {
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
double pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
SetPixelAlpha ( image , ClampToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
}
default : {
range = GetQuantumRange ( quantum_info -> depth ) ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelAlpha ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
}
} |
8,947,170,728,280,516,000 | debian | 9 | 0 | static void ECCategorizePoints ( EntityChar * ec ) {
Entity * ent ;
for ( ent = ec -> splines ;
ent != NULL ;
ent = ent -> next ) if ( ent -> type == et_splines ) {
SPLCategorizePoints ( ent -> u . splines . splines ) ;
SPLCategorizePoints ( ent -> clippath ) ;
}
} |
-8,884,965,407,551,054,000 | debian | 3 | 0 | void decoder_UnlinkPicture ( decoder_t * p_decoder , picture_t * p_picture ) {
p_decoder -> pf_picture_unlink ( p_decoder , p_picture ) ;
} |
5,610,242,550,647,094,000 | debian | 9 | 0 | static void fill_vaapi_RefPicList ( VAPictureH264 RefPicList [ 32 ] , Picture * ref_list , unsigned int ref_count ) {
unsigned int i , n = 0 ;
for ( i = 0 ;
i < ref_count ;
i ++ ) if ( ref_list [ i ] . reference ) fill_vaapi_pic ( & RefPicList [ n ++ ] , & ref_list [ i ] , 0 ) ;
for ( ;
n < 32 ;
n ++ ) init_vaapi_pic ( & RefPicList [ n ] ) ;
} |
-3,165,961,362,620,712,400 | chrome | 3 | 0 | static inline bool is_halant_or_coeng ( const hb_glyph_info_t & info ) {
return is_one_of ( info , HALANT_OR_COENG_FLAGS ) ;
} |
4,180,964,683,905,831,000 | debian | 10 | 0 | static int selinux_dentry_create_files_as ( struct dentry * dentry , int mode , struct qstr * name , const struct cred * old , struct cred * new ) {
u32 newsid ;
int rc ;
struct task_security_struct * tsec ;
rc = selinux_determine_inode_label ( old -> security , d_inode ( dentry -> d_parent ) , name , inode_mode_to_security_class ( mode ) , & newsid ) ;
if ( rc ) return rc ;
tsec = new -> security ;
tsec -> create_sid = newsid ;
return 0 ;
} |
-6,359,684,484,462,176,000 | debian | 7 | 0 | int i2d_ECParameters ( EC_KEY * a , unsigned char * * out ) {
if ( a == NULL ) {
ECerr ( EC_F_I2D_ECPARAMETERS , ERR_R_PASSED_NULL_PARAMETER ) ;
return 0 ;
}
return i2d_ECPKParameters ( a -> group , out ) ;
} |
2,335,222,688,263,906,300 | debian | 53 | 1 | static void rv34_pred_mv ( RV34DecContext * r , int block_type , int subblock_no , int dmv_no ) {
MpegEncContext * s = & r -> s ;
int mv_pos = s -> mb_x * 2 + s -> mb_y * 2 * s -> b8_stride ;
int A [ 2 ] = {
0 }
, B [ 2 ] , C [ 2 ] ;
int i , j ;
int mx , my ;
int * avail = r -> avail_cache + avail_indexes [ subblock_no ] ;
int c_off = part_sizes_w [ block_type ] ;
mv_pos += ( subblock_no & 1 ) + ( subblock_no >> 1 ) * s -> b8_stride ;
if ( subblock_no == 3 ) c_off = - 1 ;
if ( avail [ - 1 ] ) {
A [ 0 ] = s -> current_picture_ptr -> f . motion_val [ 0 ] [ mv_pos - 1 ] [ 0 ] ;
A [ 1 ] = s -> current_picture_ptr -> f . motion_val [ 0 ] [ mv_pos - 1 ] [ 1 ] ;
}
if ( avail [ - 4 ] ) {
B [ 0 ] = s -> current_picture_ptr -> f . motion_val [ 0 ] [ mv_pos - s -> b8_stride ] [ 0 ] ;
B [ 1 ] = s -> current_picture_ptr -> f . motion_val [ 0 ] [ mv_pos - s -> b8_stride ] [ 1 ] ;
}
else {
B [ 0 ] = A [ 0 ] ;
B [ 1 ] = A [ 1 ] ;
}
if ( ! avail [ c_off - 4 ] ) {
if ( avail [ - 4 ] && ( avail [ - 1 ] || r -> rv30 ) ) {
C [ 0 ] = s -> current_picture_ptr -> f . motion_val [ 0 ] [ mv_pos - s -> b8_stride - 1 ] [ 0 ] ;
C [ 1 ] = s -> current_picture_ptr -> f . motion_val [ 0 ] [ mv_pos - s -> b8_stride - 1 ] [ 1 ] ;
}
else {
C [ 0 ] = A [ 0 ] ;
C [ 1 ] = A [ 1 ] ;
}
}
else {
C [ 0 ] = s -> current_picture_ptr -> f . motion_val [ 0 ] [ mv_pos - s -> b8_stride + c_off ] [ 0 ] ;
C [ 1 ] = s -> current_picture_ptr -> f . motion_val [ 0 ] [ mv_pos - s -> b8_stride + c_off ] [ 1 ] ;
}
mx = mid_pred ( A [ 0 ] , B [ 0 ] , C [ 0 ] ) ;
my = mid_pred ( A [ 1 ] , B [ 1 ] , C [ 1 ] ) ;
mx += r -> dmv [ dmv_no ] [ 0 ] ;
my += r -> dmv [ dmv_no ] [ 1 ] ;
for ( j = 0 ;
j < part_sizes_h [ block_type ] ;
j ++ ) {
for ( i = 0 ;
i < part_sizes_w [ block_type ] ;
i ++ ) {
s -> current_picture_ptr -> f . motion_val [ 0 ] [ mv_pos + i + j * s -> b8_stride ] [ 0 ] = mx ;
s -> current_picture_ptr -> f . motion_val [ 0 ] [ mv_pos + i + j * s -> b8_stride ] [ 1 ] = my ;
}
}
} |
4,489,017,523,191,997,000 | debian | 6 | 0 | static int dissect_h225_T_messageContent_item ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 770 "./asn1/h225/h225.cnf" tvbuff_t * next_tvb = NULL ;
offset = dissect_per_octet_string ( tvb , offset , actx , tree , hf_index , NO_BOUND , NO_BOUND , FALSE , & next_tvb ) ;
next_tvb_add_handle ( & tp_list , next_tvb , ( h225_tp_in_tree ) ? tree : NULL , tp_handle ) ;
return offset ;
} |
-8,046,645,508,582,877,000 | debian | 40 | 0 | static void generate_new_codebooks ( RoqContext * enc , RoqTempdata * tempData ) {
int i , j ;
RoqCodebooks * codebooks = & tempData -> codebooks ;
int max = enc -> width * enc -> height / 16 ;
uint8_t mb2 [ 3 * 4 ] ;
roq_cell * results4 = av_malloc ( sizeof ( roq_cell ) * MAX_CBS_4x4 * 4 ) ;
uint8_t * yuvClusters = av_malloc ( sizeof ( int ) * max * 6 * 4 ) ;
int * points = av_malloc ( max * 6 * 4 * sizeof ( int ) ) ;
int bias ;
create_clusters ( enc -> frame_to_enc , enc -> width , enc -> height , yuvClusters ) ;
for ( i = 0 ;
i < max * 24 ;
i ++ ) {
bias = ( ( i % 6 ) < 4 ) ? 1 : CHROMA_BIAS ;
points [ i ] = bias * yuvClusters [ i ] ;
}
generate_codebook ( enc , tempData , points , max , results4 , 4 , MAX_CBS_4x4 ) ;
codebooks -> numCB4 = MAX_CBS_4x4 ;
tempData -> closest_cb2 = av_malloc ( max * 4 * sizeof ( int ) ) ;
generate_codebook ( enc , tempData , points , max * 4 , enc -> cb2x2 , 2 , MAX_CBS_2x2 ) ;
codebooks -> numCB2 = MAX_CBS_2x2 ;
for ( i = 0 ;
i < codebooks -> numCB2 ;
i ++ ) unpack_roq_cell ( enc -> cb2x2 + i , codebooks -> unpacked_cb2 + i * 2 * 2 * 3 ) ;
for ( i = 0 ;
i < codebooks -> numCB4 ;
i ++ ) {
for ( j = 0 ;
j < 4 ;
j ++ ) {
unpack_roq_cell ( & results4 [ 4 * i + j ] , mb2 ) ;
index_mb ( mb2 , codebooks -> unpacked_cb2 , codebooks -> numCB2 , & enc -> cb4x4 [ i ] . idx [ j ] , 2 ) ;
}
unpack_roq_qcell ( codebooks -> unpacked_cb2 , enc -> cb4x4 + i , codebooks -> unpacked_cb4 + i * 4 * 4 * 3 ) ;
enlarge_roq_mb4 ( codebooks -> unpacked_cb4 + i * 4 * 4 * 3 , codebooks -> unpacked_cb4_enlarged + i * 8 * 8 * 3 ) ;
}
av_free ( yuvClusters ) ;
av_free ( points ) ;
av_free ( results4 ) ;
} |
1,415,862,279,747,793,700 | chrome | 30 | 0 | int linux_udev_scan_devices ( struct libusb_context * ctx ) {
struct udev_enumerate * enumerator ;
struct udev_list_entry * devices , * entry ;
struct udev_device * udev_dev ;
const char * sys_name ;
int r ;
assert ( udev_ctx != NULL ) ;
enumerator = device : : udev_enumerate_new ( udev_ctx ) ;
if ( NULL == enumerator ) {
usbi_err ( ctx , "error creating udev enumerator" ) ;
return LIBUSB_ERROR_OTHER ;
}
device : : udev_enumerate_add_match_subsystem ( enumerator , "usb" ) ;
device : : udev_enumerate_scan_devices ( enumerator ) ;
devices = device : : udev_enumerate_get_list_entry ( enumerator ) ;
udev_list_entry_foreach ( entry , devices ) {
const char * path = device : : udev_list_entry_get_name ( entry ) ;
uint8_t busnum = 0 , devaddr = 0 ;
udev_dev = device : : udev_device_new_from_syspath ( udev_ctx , path ) ;
r = udev_device_info ( ctx , 0 , udev_dev , & busnum , & devaddr , & sys_name ) ;
if ( r ) {
device : : udev_device_unref ( udev_dev ) ;
continue ;
}
linux_enumerate_device ( ctx , busnum , devaddr , sys_name ) ;
device : : udev_device_unref ( udev_dev ) ;
}
device : : udev_enumerate_unref ( enumerator ) ;
return LIBUSB_SUCCESS ;
} |
5,611,940,141,018,434,000 | chrome | 5 | 0 | static void write_sync_code ( struct vp9_write_bit_buffer * wb ) {
vp9_wb_write_literal ( wb , VP9_SYNC_CODE_0 , 8 ) ;
vp9_wb_write_literal ( wb , VP9_SYNC_CODE_1 , 8 ) ;
vp9_wb_write_literal ( wb , VP9_SYNC_CODE_2 , 8 ) ;
} |
-3,569,070,884,878,445,600 | debian | 60 | 0 | static int svq3_decode_slice_header ( AVCodecContext * avctx ) {
SVQ3Context * s = avctx -> priv_data ;
H264Context * h = & s -> h ;
const int mb_xy = h -> mb_xy ;
int i , header ;
unsigned slice_id ;
header = get_bits ( & h -> gb , 8 ) ;
if ( ( ( header & 0x9F ) != 1 && ( header & 0x9F ) != 2 ) || ( header & 0x60 ) == 0 ) {
av_log ( avctx , AV_LOG_ERROR , "unsupported slice header (%02X)\n" , header ) ;
return - 1 ;
}
else {
int length = header >> 5 & 3 ;
s -> next_slice_index = get_bits_count ( & h -> gb ) + 8 * show_bits ( & h -> gb , 8 * length ) + 8 * length ;
if ( s -> next_slice_index > h -> gb . size_in_bits ) {
av_log ( avctx , AV_LOG_ERROR , "slice after bitstream end\n" ) ;
return - 1 ;
}
h -> gb . size_in_bits = s -> next_slice_index - 8 * ( length - 1 ) ;
skip_bits ( & h -> gb , 8 ) ;
if ( s -> watermark_key ) {
uint32_t header = AV_RL32 ( & h -> gb . buffer [ ( get_bits_count ( & h -> gb ) >> 3 ) + 1 ] ) ;
AV_WL32 ( & h -> gb . buffer [ ( get_bits_count ( & h -> gb ) >> 3 ) + 1 ] , header ^ s -> watermark_key ) ;
}
if ( length > 0 ) {
memcpy ( ( uint8_t * ) & h -> gb . buffer [ get_bits_count ( & h -> gb ) >> 3 ] , & h -> gb . buffer [ h -> gb . size_in_bits >> 3 ] , length - 1 ) ;
}
skip_bits_long ( & h -> gb , 0 ) ;
}
if ( ( slice_id = svq3_get_ue_golomb ( & h -> gb ) ) >= 3 ) {
av_log ( h -> avctx , AV_LOG_ERROR , "illegal slice type %d \n" , slice_id ) ;
return - 1 ;
}
h -> slice_type = golomb_to_pict_type [ slice_id ] ;
if ( ( header & 0x9F ) == 2 ) {
i = ( h -> mb_num < 64 ) ? 6 : ( 1 + av_log2 ( h -> mb_num - 1 ) ) ;
h -> mb_skip_run = get_bits ( & h -> gb , i ) - ( h -> mb_y * h -> mb_width + h -> mb_x ) ;
}
else {
skip_bits1 ( & h -> gb ) ;
h -> mb_skip_run = 0 ;
}
h -> slice_num = get_bits ( & h -> gb , 8 ) ;
h -> qscale = get_bits ( & h -> gb , 5 ) ;
s -> adaptive_quant = get_bits1 ( & h -> gb ) ;
skip_bits1 ( & h -> gb ) ;
if ( s -> unknown_flag ) skip_bits1 ( & h -> gb ) ;
skip_bits1 ( & h -> gb ) ;
skip_bits ( & h -> gb , 2 ) ;
while ( get_bits1 ( & h -> gb ) ) skip_bits ( & h -> gb , 8 ) ;
if ( h -> mb_x > 0 ) {
memset ( h -> intra4x4_pred_mode + h -> mb2br_xy [ mb_xy - 1 ] + 3 , - 1 , 4 * sizeof ( int8_t ) ) ;
memset ( h -> intra4x4_pred_mode + h -> mb2br_xy [ mb_xy - h -> mb_x ] , - 1 , 8 * sizeof ( int8_t ) * h -> mb_x ) ;
}
if ( h -> mb_y > 0 ) {
memset ( h -> intra4x4_pred_mode + h -> mb2br_xy [ mb_xy - h -> mb_stride ] , - 1 , 8 * sizeof ( int8_t ) * ( h -> mb_width - h -> mb_x ) ) ;
if ( h -> mb_x > 0 ) h -> intra4x4_pred_mode [ h -> mb2br_xy [ mb_xy - h -> mb_stride - 1 ] + 3 ] = - 1 ;
}
return 0 ;
} |
-1,102,844,685,921,778,700 | debian | 20 | 0 | int archive_mstring_get_mbs ( struct archive * a , struct archive_mstring * aes , const char * * p ) {
int r , ret = 0 ;
( void ) a ;
if ( aes -> aes_set & AES_SET_MBS ) {
* p = aes -> aes_mbs . s ;
return ( ret ) ;
}
* p = NULL ;
if ( aes -> aes_set & AES_SET_WCS ) {
archive_string_empty ( & ( aes -> aes_mbs ) ) ;
r = archive_string_append_from_wcs ( & ( aes -> aes_mbs ) , aes -> aes_wcs . s , aes -> aes_wcs . length ) ;
* p = aes -> aes_mbs . s ;
if ( r == 0 ) {
aes -> aes_set |= AES_SET_MBS ;
return ( ret ) ;
}
else ret = - 1 ;
}
return ( ret ) ;
} |
58,020,529,414,140,130 | chrome | 31 | 0 | static void count_segs_sb ( const VP9_COMMON * cm , MACROBLOCKD * xd , const TileInfo * tile , MODE_INFO * mi , int * no_pred_segcounts , int ( * temporal_predictor_count ) [ 2 ] , int * t_unpred_seg_counts , int mi_row , int mi_col , BLOCK_SIZE bsize ) {
const int mis = cm -> mi_stride ;
int bw , bh ;
const int bs = num_8x8_blocks_wide_lookup [ bsize ] , hbs = bs / 2 ;
if ( mi_row >= cm -> mi_rows || mi_col >= cm -> mi_cols ) return ;
bw = num_8x8_blocks_wide_lookup [ mi [ 0 ] . src_mi -> mbmi . sb_type ] ;
bh = num_8x8_blocks_high_lookup [ mi [ 0 ] . src_mi -> mbmi . sb_type ] ;
if ( bw == bs && bh == bs ) {
count_segs ( cm , xd , tile , mi , no_pred_segcounts , temporal_predictor_count , t_unpred_seg_counts , bs , bs , mi_row , mi_col ) ;
}
else if ( bw == bs && bh < bs ) {
count_segs ( cm , xd , tile , mi , no_pred_segcounts , temporal_predictor_count , t_unpred_seg_counts , bs , hbs , mi_row , mi_col ) ;
count_segs ( cm , xd , tile , mi + hbs * mis , no_pred_segcounts , temporal_predictor_count , t_unpred_seg_counts , bs , hbs , mi_row + hbs , mi_col ) ;
}
else if ( bw < bs && bh == bs ) {
count_segs ( cm , xd , tile , mi , no_pred_segcounts , temporal_predictor_count , t_unpred_seg_counts , hbs , bs , mi_row , mi_col ) ;
count_segs ( cm , xd , tile , mi + hbs , no_pred_segcounts , temporal_predictor_count , t_unpred_seg_counts , hbs , bs , mi_row , mi_col + hbs ) ;
}
else {
const BLOCK_SIZE subsize = subsize_lookup [ PARTITION_SPLIT ] [ bsize ] ;
int n ;
assert ( bw < bs && bh < bs ) ;
for ( n = 0 ;
n < 4 ;
n ++ ) {
const int mi_dc = hbs * ( n & 1 ) ;
const int mi_dr = hbs * ( n >> 1 ) ;
count_segs_sb ( cm , xd , tile , & mi [ mi_dr * mis + mi_dc ] , no_pred_segcounts , temporal_predictor_count , t_unpred_seg_counts , mi_row + mi_dr , mi_col + mi_dc , subsize ) ;
}
}
} |
-5,861,178,779,585,942,000 | debian | 7 | 0 | const char * tok2strary_internal ( register const char * * lp , int n , register const char * fmt , register int v ) {
static char buf [ TOKBUFSIZE ] ;
if ( v >= 0 && v < n && lp [ v ] != NULL ) return lp [ v ] ;
if ( fmt == NULL ) fmt = "#%d" ;
( void ) snprintf ( buf , sizeof ( buf ) , fmt , v ) ;
return ( buf ) ;
} |
3,728,341,105,073,176,600 | debian | 44 | 1 | static ossl_inline LHASH_OF ( type ) * lh_ ## type ## _new ( unsigned long ( * hfn ) ( const type * ) , int ( * cfn ) ( const type * , const type * ) ) {
return ( LHASH_OF ( type ) * ) OPENSSL_LH_new ( ( OPENSSL_LH_HASHFUNC ) hfn , ( OPENSSL_LH_COMPFUNC ) cfn ) ;
}
static ossl_inline void lh_ ## type ## _free ( LHASH_OF ( type ) * lh ) {
OPENSSL_LH_free ( ( OPENSSL_LHASH * ) lh ) ;
}
static ossl_inline type * lh_ ## type ## _insert ( LHASH_OF ( type ) * lh , type * d ) {
return ( type * ) OPENSSL_LH_insert ( ( OPENSSL_LHASH * ) lh , d ) ;
}
static ossl_inline type * lh_ ## type ## _delete ( LHASH_OF ( type ) * lh , const type * d ) {
return ( type * ) OPENSSL_LH_delete ( ( OPENSSL_LHASH * ) lh , d ) ;
}
static ossl_inline type * lh_ ## type ## _retrieve ( LHASH_OF ( type ) * lh , const type * d ) {
return ( type * ) OPENSSL_LH_retrieve ( ( OPENSSL_LHASH * ) lh , d ) ;
}
static ossl_inline int lh_ ## type ## _error ( LHASH_OF ( type ) * lh ) {
return OPENSSL_LH_error ( ( OPENSSL_LHASH * ) lh ) ;
}
static ossl_inline unsigned long lh_ ## type ## _num_items ( LHASH_OF ( type ) * lh ) {
return OPENSSL_LH_num_items ( ( OPENSSL_LHASH * ) lh ) ;
}
static ossl_inline void lh_ ## type ## _node_stats_bio ( const LHASH_OF ( type ) * lh , BIO * out ) {
OPENSSL_LH_node_stats_bio ( ( const OPENSSL_LHASH * ) lh , out ) ;
}
static ossl_inline void lh_ ## type ## _node_usage_stats_bio ( const LHASH_OF ( type ) * lh , BIO * out ) {
OPENSSL_LH_node_usage_stats_bio ( ( const OPENSSL_LHASH * ) lh , out ) ;
}
static ossl_inline void lh_ ## type ## _stats_bio ( const LHASH_OF ( type ) * lh , BIO * out ) {
OPENSSL_LH_stats_bio ( ( const OPENSSL_LHASH * ) lh , out ) ;
}
static ossl_inline unsigned long lh_ ## type ## _get_down_load ( LHASH_OF ( type ) * lh ) {
return OPENSSL_LH_get_down_load ( ( OPENSSL_LHASH * ) lh ) ;
}
static ossl_inline void lh_ ## type ## _set_down_load ( LHASH_OF ( type ) * lh , unsigned long dl ) {
OPENSSL_LH_set_down_load ( ( OPENSSL_LHASH * ) lh , dl ) ;
}
static ossl_inline void lh_ ## type ## _doall ( LHASH_OF ( type ) * lh , void ( * doall ) ( type * ) ) {
OPENSSL_LH_doall ( ( OPENSSL_LHASH * ) lh , ( OPENSSL_LH_DOALL_FUNC ) doall ) ;
}
LHASH_OF ( type ) # define IMPLEMENT_LHASH_DOALL_ARG_CONST ( type , argtype ) int_implement_lhash_doall ( type , argtype , const type ) # define IMPLEMENT_LHASH_DOALL_ARG ( type , argtype ) int_implement_lhash_doall ( type , argtype , type ) # define int_implement_lhash_doall ( type , argtype , cbargtype ) static ossl_inline void lh_ ## type ## _doall_ ## argtype ( LHASH_OF ( type ) * lh , void ( * fn ) ( cbargtype * , argtype * ) , argtype * arg ) {
OPENSSL_LH_doall_arg ( ( OPENSSL_LHASH * ) lh , ( OPENSSL_LH_DOALL_FUNCARG ) fn , ( void * ) arg ) ;
}
LHASH_OF ( type ) DEFINE_LHASH_OF ( OPENSSL_STRING ) ;
# ifdef _MSC_VER # pragma warning ( push ) # pragma warning ( disable : 4090 ) # endif DEFINE_LHASH_OF ( OPENSSL_CSTRING ) |
-7,256,256,713,578,558,000 | debian | 122 | 0 | static int parsedate ( const char * date , time_t * output ) {
time_t t = 0 ;
int wdaynum = - 1 ;
int monnum = - 1 ;
int mdaynum = - 1 ;
int hournum = - 1 ;
int minnum = - 1 ;
int secnum = - 1 ;
int yearnum = - 1 ;
int tzoff = - 1 ;
struct my_tm tm ;
enum assume dignext = DATE_MDAY ;
const char * indate = date ;
int part = 0 ;
while ( * date && ( part < 6 ) ) {
bool found = FALSE ;
skip ( & date ) ;
if ( ISALPHA ( * date ) ) {
char buf [ 32 ] = "" ;
size_t len ;
if ( sscanf ( date , "%31[ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz]" , buf ) ) len = strlen ( buf ) ;
else len = 0 ;
if ( wdaynum == - 1 ) {
wdaynum = checkday ( buf , len ) ;
if ( wdaynum != - 1 ) found = TRUE ;
}
if ( ! found && ( monnum == - 1 ) ) {
monnum = checkmonth ( buf ) ;
if ( monnum != - 1 ) found = TRUE ;
}
if ( ! found && ( tzoff == - 1 ) ) {
tzoff = checktz ( buf ) ;
if ( tzoff != - 1 ) found = TRUE ;
}
if ( ! found ) return PARSEDATE_FAIL ;
date += len ;
}
else if ( ISDIGIT ( * date ) ) {
int val ;
char * end ;
int len = 0 ;
if ( ( secnum == - 1 ) && ( 3 == sscanf ( date , "%02d:%02d:%02d%n" , & hournum , & minnum , & secnum , & len ) ) ) {
date += len ;
}
else if ( ( secnum == - 1 ) && ( 2 == sscanf ( date , "%02d:%02d%n" , & hournum , & minnum , & len ) ) ) {
date += len ;
secnum = 0 ;
}
else {
long lval ;
int error ;
int old_errno ;
old_errno = ERRNO ;
SET_ERRNO ( 0 ) ;
lval = strtol ( date , & end , 10 ) ;
error = ERRNO ;
if ( error != old_errno ) SET_ERRNO ( old_errno ) ;
if ( error ) return PARSEDATE_FAIL ;
# if LONG_MAX != INT_MAX if ( ( lval > ( long ) INT_MAX ) || ( lval < ( long ) INT_MIN ) ) return PARSEDATE_FAIL ;
# endif val = curlx_sltosi ( lval ) ;
if ( ( tzoff == - 1 ) && ( ( end - date ) == 4 ) && ( val <= 1400 ) && ( indate < date ) && ( ( date [ - 1 ] == '+' || date [ - 1 ] == '-' ) ) ) {
found = TRUE ;
tzoff = ( val / 100 * 60 + val % 100 ) * 60 ;
tzoff = date [ - 1 ] == '+' ? - tzoff : tzoff ;
}
if ( ( ( end - date ) == 8 ) && ( yearnum == - 1 ) && ( monnum == - 1 ) && ( mdaynum == - 1 ) ) {
found = TRUE ;
yearnum = val / 10000 ;
monnum = ( val % 10000 ) / 100 - 1 ;
mdaynum = val % 100 ;
}
if ( ! found && ( dignext == DATE_MDAY ) && ( mdaynum == - 1 ) ) {
if ( ( val > 0 ) && ( val < 32 ) ) {
mdaynum = val ;
found = TRUE ;
}
dignext = DATE_YEAR ;
}
if ( ! found && ( dignext == DATE_YEAR ) && ( yearnum == - 1 ) ) {
yearnum = val ;
found = TRUE ;
if ( yearnum < 1900 ) {
if ( yearnum > 70 ) yearnum += 1900 ;
else yearnum += 2000 ;
}
if ( mdaynum == - 1 ) dignext = DATE_MDAY ;
}
if ( ! found ) return PARSEDATE_FAIL ;
date = end ;
}
}
part ++ ;
}
if ( - 1 == secnum ) secnum = minnum = hournum = 0 ;
if ( ( - 1 == mdaynum ) || ( - 1 == monnum ) || ( - 1 == yearnum ) ) return PARSEDATE_FAIL ;
# if SIZEOF_TIME_T < 5 if ( yearnum > 2037 ) {
* output = 0x7fffffff ;
return PARSEDATE_LATER ;
}
# endif if ( yearnum < 1970 ) {
* output = 0 ;
return PARSEDATE_SOONER ;
}
if ( ( mdaynum > 31 ) || ( monnum > 11 ) || ( hournum > 23 ) || ( minnum > 59 ) || ( secnum > 60 ) ) return PARSEDATE_FAIL ;
tm . tm_sec = secnum ;
tm . tm_min = minnum ;
tm . tm_hour = hournum ;
tm . tm_mday = mdaynum ;
tm . tm_mon = monnum ;
tm . tm_year = yearnum - 1900 ;
t = my_timegm ( & tm ) ;
if ( - 1 != ( int ) t ) {
long delta = ( long ) ( tzoff != - 1 ? tzoff : 0 ) ;
if ( ( delta > 0 ) && ( t > LONG_MAX - delta ) ) {
* output = 0x7fffffff ;
return PARSEDATE_LATER ;
}
t += delta ;
}
* output = t ;
return PARSEDATE_OK ;
} |
5,357,882,892,791,796,000 | debian | 10 | 0 | static void e1000e_set_rx_control ( E1000ECore * core , int index , uint32_t val ) {
core -> mac [ RCTL ] = val ;
trace_e1000e_rx_set_rctl ( core -> mac [ RCTL ] ) ;
if ( val & E1000_RCTL_EN ) {
e1000e_parse_rxbufsize ( core ) ;
e1000e_calc_rxdesclen ( core ) ;
core -> rxbuf_min_shift = ( ( val / E1000_RCTL_RDMTS_QUAT ) & 3 ) + 1 + E1000_RING_DESC_LEN_SHIFT ;
e1000e_start_recv ( core ) ;
}
} |
-398,565,394,354,770,750 | debian | 13 | 0 | static inline int get_dwords ( OHCIState * ohci , dma_addr_t addr , uint32_t * buf , int num ) {
int i ;
addr += ohci -> localmem_base ;
for ( i = 0 ;
i < num ;
i ++ , buf ++ , addr += sizeof ( * buf ) ) {
if ( dma_memory_read ( ohci -> as , addr , buf , sizeof ( * buf ) ) ) {
return - 1 ;
}
* buf = le32_to_cpu ( * buf ) ;
}
return 0 ;
} |
3,246,343,243,711,264,300 | debian | 22 | 0 | static void handle_a_request ( int dns_fd , struct query * q , int fakeip ) {
char buf [ 64 * 1024 ] ;
int len ;
if ( fakeip ) {
in_addr_t ip = inet_addr ( "127.0.0.1" ) ;
memcpy ( & q -> destination . s_addr , & ip , sizeof ( in_addr_t ) ) ;
}
else if ( ns_ip != INADDR_ANY ) {
memcpy ( & q -> destination . s_addr , & ns_ip , sizeof ( in_addr_t ) ) ;
}
len = dns_encode_a_response ( buf , sizeof ( buf ) , q ) ;
if ( len < 1 ) {
warnx ( "dns_encode_a_response doesn't fit" ) ;
return ;
}
if ( debug >= 2 ) {
fprintf ( stderr , "TX: client %s, type %d, name %s, %d bytes A reply\n" , format_addr ( & q -> from , q -> fromlen ) , q -> type , q -> name , len ) ;
}
if ( sendto ( dns_fd , buf , len , 0 , ( struct sockaddr * ) & q -> from , q -> fromlen ) <= 0 ) {
warn ( "a reply send error" ) ;
}
} |
-8,665,368,283,409,782,000 | debian | 9 | 0 | static inline void reset_all_seen ( void ) {
unsigned int i ;
for ( i = 0 ;
i < seen_objects_nr ;
++ i ) {
seen_objects [ i ] -> flags &= ~ ( SEEN | ADDED | SHOWN ) ;
}
seen_objects_nr = 0 ;
} |
6,667,142,528,452,942,000 | debian | 24 | 0 | static int dump_tablespaces_for_tables ( char * db , char * * table_names , int tables ) {
DYNAMIC_STRING where ;
int r ;
int i ;
char name_buff [ NAME_LEN * 2 + 3 ] ;
mysql_real_escape_string ( mysql , name_buff , db , ( ulong ) strlen ( db ) ) ;
init_dynamic_string_checked ( & where , " AND TABLESPACE_NAME IN (" "SELECT DISTINCT TABLESPACE_NAME FROM" " INFORMATION_SCHEMA.PARTITIONS" " WHERE" " TABLE_SCHEMA='" , 256 , 1024 ) ;
dynstr_append_checked ( & where , name_buff ) ;
dynstr_append_checked ( & where , "' AND TABLE_NAME IN (" ) ;
for ( i = 0 ;
i < tables ;
i ++ ) {
mysql_real_escape_string ( mysql , name_buff , table_names [ i ] , ( ulong ) strlen ( table_names [ i ] ) ) ;
dynstr_append_checked ( & where , "'" ) ;
dynstr_append_checked ( & where , name_buff ) ;
dynstr_append_checked ( & where , "'," ) ;
}
dynstr_trunc ( & where , 1 ) ;
dynstr_append_checked ( & where , "))" ) ;
DBUG_PRINT ( "info" , ( "Dump TS for Tables where: %s" , where . str ) ) ;
r = dump_tablespaces ( where . str ) ;
dynstr_free ( & where ) ;
return r ;
} |
5,045,872,831,385,413,000 | debian | 91 | 0 | void proto_reg_handoff_btgatt ( void ) {
const struct uuid_dissectors_t {
const gchar * const uuid ;
gchar * const short_name ;
int ( * const dissect_func ) ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , void * data ) ;
}
uuid_dissectors [ ] = {
{
"6e400001-b5a3-f393-e0a9-e50e24dcca9e" , "Nordic UART Service" , NULL }
, {
"6e400002-b5a3-f393-e0a9-e50e24dcca9e" , "Nordic UART Tx" , dissect_btgatt_nordic_uart_tx }
, {
"6e400003-b5a3-f393-e0a9-e50e24dcca9e" , "Nordic UART Rx" , dissect_btgatt_nordic_uart_rx }
, {
"00001530-1212-efde-1523-785feabcd123" , "Nordic DFU Service" , NULL }
, {
"00001531-1212-efde-1523-785feabcd123" , "Nordic DFU Control Point" , dissect_btgatt_nordic_dfu_control_point }
, {
"00001532-1212-efde-1523-785feabcd123" , "Nordic DFU Packet" , dissect_btgatt_nordic_dfu_packet }
, {
"e95d0753-251d-470a-a062-fa1922dfa9a8" , "micro:bit Accelerometer Service" , NULL }
, {
"e95dca4b-251d-470a-a062-fa1922dfa9a8" , "micro:bit Accelerometer Data" , dissect_btgatt_microbit_accelerometer_data }
, {
"e95dfb24-251d-470a-a062-fa1922dfa9a8" , "micro:bit Accelerometer Period" , dissect_btgatt_microbit_accelerometer_period }
, {
"e95df2d8-251d-470a-a062-fa1922dfa9a8" , "micro:bit Magnetometer Service" , NULL }
, {
"e95dfb11-251d-470a-a062-fa1922dfa9a8" , "micro:bit Magnetometer Data" , dissect_btgatt_microbit_magnetometer_data }
, {
"e95d386c-251d-470a-a062-fa1922dfa9a8" , "micro:bit Magnetometer Period" , dissect_btgatt_microbit_magnetometer_period }
, {
"e95d9715-251d-470a-a062-fa1922dfa9a8" , "micro:bit Magnetometer Bearing" , dissect_btgatt_microbit_magnetometer_bearing }
, {
"e95d9882-251d-470a-a062-fa1922dfa9a8" , "micro:bit Button Service" , NULL }
, {
"e95dda90-251d-470a-a062-fa1922dfa9a8" , "micro:bit Button A State" , dissect_btgatt_microbit_button_a_state }
, {
"e95dda91-251d-470a-a062-fa1922dfa9a8" , "micro:bit Button B State" , dissect_btgatt_microbit_button_b_state }
, {
"e95d127b-251d-470a-a062-fa1922dfa9a8" , "micro:bit IO Pin Service" , NULL }
, {
"e95d8d00-251d-470a-a062-fa1922dfa9a8" , "micro:bit Pin Data" , dissect_btgatt_microbit_pin_data }
, {
"e95d5899-251d-470a-a062-fa1922dfa9a8" , "micro:bit Pin AD Configuration" , dissect_btgatt_microbit_pin_ad_config }
, {
"e95db9fe-251d-470a-a062-fa1922dfa9a8" , "micro:bit Pin IO Configuration" , dissect_btgatt_microbit_pin_io_config }
, {
"e95dd822-251d-470a-a062-fa1922dfa9a8" , "micro:bit PWM Control" , dissect_btgatt_microbit_pwm_control }
, {
"e95dd91d-251d-470a-a062-fa1922dfa9a8" , "micro:bit LED Service" , NULL }
, {
"e95d7b77-251d-470a-a062-fa1922dfa9a8" , "micro:bit LED Matrix State" , dissect_btgatt_microbit_led_matrix }
, {
"e95d93ee-251d-470a-a062-fa1922dfa9a8" , "micro:bit LED Text" , dissect_btgatt_microbit_led_text }
, {
"e95d0d2d-251d-470a-a062-fa1922dfa9a8" , "micro:bit Scrolling Delay" , dissect_btgatt_microbit_scrolling_delay }
, {
"e95d93af-251d-470a-a062-fa1922dfa9a8" , "micro:bit Event Service" , NULL }
, {
"e95db84c-251d-470a-a062-fa1922dfa9a8" , "micro:bit MicroBit Requirements" , dissect_btgatt_microbit_microbit_requirements }
, {
"e95d9775-251d-470a-a062-fa1922dfa9a8" , "micro:bit MicroBit Event" , dissect_btgatt_microbit_microbit_event }
, {
"e95d23c4-251d-470a-a062-fa1922dfa9a8" , "micro:bit Client Requirements" , dissect_btgatt_microbit_client_requirements }
, {
"e95d5404-251d-470a-a062-fa1922dfa9a8" , "micro:bit Client Event" , dissect_btgatt_microbit_client_event }
, {
"e95d93b0-251d-470a-a062-fa1922dfa9a8" , "micro:bit DFU Control Service" , NULL }
, {
"e95d93b1-251d-470a-a062-fa1922dfa9a8" , "micro:bit DFU Control" , dissect_btgatt_microbit_dfu_control }
, {
"e95d6100-251d-470a-a062-fa1922dfa9a8" , "micro:bit Temperature Service" , NULL }
, {
"e95d9250-251d-470a-a062-fa1922dfa9a8" , "micro:bit Temperature" , dissect_btgatt_microbit_temperature_value }
, {
"e95d1b25-251d-470a-a062-fa1922dfa9a8" , "micro:bit Temperature Period" , dissect_btgatt_microbit_temperature_period }
, {
NULL , NULL , NULL }
, }
;
for ( gint i = 0 ;
uuid_dissectors [ i ] . uuid ;
i ++ ) {
wmem_tree_insert_string ( bluetooth_uuids , uuid_dissectors [ i ] . uuid , uuid_dissectors [ i ] . short_name , 0 ) ;
if ( uuid_dissectors [ i ] . dissect_func ) {
dissector_handle_t handle = create_dissector_handle ( uuid_dissectors [ i ] . dissect_func , proto_btgatt ) ;
dissector_add_string ( "bluetooth.uuid" , uuid_dissectors [ i ] . uuid , handle ) ;
}
}
} |
7,039,307,292,471,245,000 | debian | 6 | 0 | static guint16 de_clg_party_sub_addr ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo , guint32 offset , guint len , gchar * add_string _U_ , int string_len _U_ ) {
gchar * extr_addr ;
de_sub_addr ( tvb , tree , pinfo , offset , len , & extr_addr ) ;
if ( extr_addr && add_string ) g_snprintf ( add_string , string_len , " - (%s)" , extr_addr ) ;
return ( len ) ;
} |
3,919,646,340,804,521,500 | debian | 7 | 0 | static int ofscmp ( const void * a_ , const void * b_ ) {
struct in_pack_object * a = ( struct in_pack_object * ) a_ ;
struct in_pack_object * b = ( struct in_pack_object * ) b_ ;
if ( a -> offset < b -> offset ) return - 1 ;
else if ( a -> offset > b -> offset ) return 1 ;
else return oidcmp ( & a -> object -> oid , & b -> object -> oid ) ;
} |
2,895,622,461,494,525,400 | debian | 22 | 0 | static void test_bug19671 ( ) {
MYSQL_RES * result ;
int rc ;
myheader ( "test_bug19671" ) ;
mysql_query ( mysql , "set sql_mode=''" ) ;
rc = mysql_query ( mysql , "drop table if exists t1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "drop view if exists v1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "create table t1(f1 int)" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "create view v1 as select va.* from t1 va" ) ;
myquery ( rc ) ;
result = mysql_list_fields ( mysql , "v1" , NULL ) ;
mytest ( result ) ;
rc = my_process_result_set ( result ) ;
DIE_UNLESS ( rc == 0 ) ;
verify_prepare_field ( result , 0 , "f1" , "f1" , MYSQL_TYPE_LONG , "v1" , "v1" , current_db , 11 , "0" ) ;
mysql_free_result ( result ) ;
myquery ( mysql_query ( mysql , "drop view v1" ) ) ;
myquery ( mysql_query ( mysql , "drop table t1" ) ) ;
} |
6,600,620,671,673,715,000 | debian | 13 | 1 | static void * i_alloc_struct_array ( gs_memory_t * mem , uint num_elements , gs_memory_type_ptr_t pstype , client_name_t cname ) {
gs_ref_memory_t * const imem = ( gs_ref_memory_t * ) mem ;
obj_header_t * obj ;
# ifdef MEMENTO if ( Memento_failThisEvent ( ) ) return NULL ;
# endif ALLOC_CHECK_SIZE ( mem , pstype ) ;
# ifdef DEBUG if ( pstype -> enum_ptrs == basic_enum_ptrs ) {
dmprintf2 ( mem , " i_alloc_struct_array: called with incorrect structure type (not element), struct='%s', client='%s'\n" , pstype -> sname , cname ) ;
return NULL ;
}
# endif obj = alloc_obj ( imem , ( ulong ) num_elements * pstype -> ssize , pstype , ALLOC_DIRECT , cname ) ;
if_debug7m ( 'A' , mem , "[a%d:+<.]%s %s*(%lu=%u*%u) = 0x%lx\n" , alloc_trace_space ( imem ) , client_name_string ( cname ) , struct_type_name_string ( pstype ) , ( ulong ) num_elements * pstype -> ssize , num_elements , pstype -> ssize , ( ulong ) obj ) ;
return ( char * ) obj ;
} |
-5,268,859,819,325,808,000 | debian | 26 | 0 | static void start_monitoring_file_list ( NautilusDirectory * directory ) {
DirectoryLoadState * state ;
if ( ! directory -> details -> file_list_monitored ) {
g_assert ( ! directory -> details -> directory_load_in_progress ) ;
directory -> details -> file_list_monitored = TRUE ;
nautilus_file_list_ref ( directory -> details -> file_list ) ;
}
if ( directory -> details -> directory_loaded || directory -> details -> directory_load_in_progress != NULL ) {
return ;
}
if ( ! async_job_start ( directory , "file list" ) ) {
return ;
}
mark_all_files_unconfirmed ( directory ) ;
state = g_new0 ( DirectoryLoadState , 1 ) ;
state -> directory = directory ;
state -> cancellable = g_cancellable_new ( ) ;
state -> load_mime_list_hash = istr_set_new ( ) ;
state -> load_file_count = 0 ;
g_assert ( directory -> details -> location != NULL ) ;
state -> load_directory_file = nautilus_directory_get_corresponding_file ( directory ) ;
state -> load_directory_file -> details -> loading_directory = TRUE ;
# ifdef DEBUG_LOAD_DIRECTORY g_message ( "load_directory called to monitor file list of %p" , directory -> details -> location ) ;
# endif directory -> details -> directory_load_in_progress = state ;
g_file_enumerate_children_async ( directory -> details -> location , NAUTILUS_FILE_DEFAULT_ATTRIBUTES , 0 , G_PRIORITY_DEFAULT , state -> cancellable , enumerate_children_callback , state ) ;
} |
-8,665,368,283,409,782,000 | debian | 10 | 0 | static void write_hash_cache ( struct sha1file * f , struct pack_idx_entry * * index , uint32_t index_nr ) {
uint32_t i ;
for ( i = 0 ;
i < index_nr ;
++ i ) {
struct object_entry * entry = ( struct object_entry * ) index [ i ] ;
uint32_t hash_value = htonl ( entry -> hash ) ;
sha1write ( f , & hash_value , sizeof ( hash_value ) ) ;
}
} |
-3,405,049,855,481,808,000 | chrome | 3 | 0 | int xmlIsChar ( unsigned int ch ) {
return ( xmlIsCharQ ( ch ) ) ;
} |
1,981,604,082,870,872,600 | chrome | 56 | 0 | static int32_t u_printf_scientific_handler ( const u_printf_stream_handler * handler , void * context , ULocaleBundle * formatBundle , const u_printf_spec_info * info , const ufmt_args * args ) {
double num = ( double ) ( args [ 0 ] . doubleValue ) ;
UNumberFormat * format ;
UChar result [ UPRINTF_BUFFER_SIZE ] ;
UChar prefixBuffer [ UPRINTF_BUFFER_SIZE ] ;
int32_t prefixBufferLen = sizeof ( prefixBuffer ) ;
int32_t minDecimalDigits ;
int32_t maxDecimalDigits ;
UErrorCode status = U_ZERO_ERROR ;
UChar srcExpBuf [ UPRINTF_SYMBOL_BUFFER_SIZE ] ;
int32_t srcLen , expLen ;
int32_t resultLen ;
UChar expBuf [ UPRINTF_SYMBOL_BUFFER_SIZE ] ;
prefixBuffer [ 0 ] = 0 ;
format = u_locbund_getNumberFormat ( formatBundle , UNUM_SCIENTIFIC ) ;
if ( format == 0 ) return 0 ;
srcLen = unum_getSymbol ( format , UNUM_EXPONENTIAL_SYMBOL , srcExpBuf , sizeof ( srcExpBuf ) , & status ) ;
if ( info -> fSpec == ( UChar ) 0x65 ) {
expLen = u_strToLower ( expBuf , ( int32_t ) sizeof ( expBuf ) , srcExpBuf , srcLen , formatBundle -> fLocale , & status ) ;
}
else {
expLen = u_strToUpper ( expBuf , ( int32_t ) sizeof ( expBuf ) , srcExpBuf , srcLen , formatBundle -> fLocale , & status ) ;
}
unum_setSymbol ( format , UNUM_EXPONENTIAL_SYMBOL , expBuf , expLen , & status ) ;
minDecimalDigits = unum_getAttribute ( format , UNUM_MIN_FRACTION_DIGITS ) ;
maxDecimalDigits = unum_getAttribute ( format , UNUM_MAX_FRACTION_DIGITS ) ;
if ( info -> fPrecision != - 1 ) {
if ( info -> fOrigSpec == ( UChar ) 0x65 || info -> fOrigSpec == ( UChar ) 0x45 ) {
unum_setAttribute ( format , UNUM_FRACTION_DIGITS , info -> fPrecision ) ;
}
else {
unum_setAttribute ( format , UNUM_MIN_FRACTION_DIGITS , 1 ) ;
unum_setAttribute ( format , UNUM_MAX_FRACTION_DIGITS , info -> fPrecision ) ;
}
}
else if ( info -> fAlt ) {
unum_setAttribute ( format , UNUM_FRACTION_DIGITS , 6 ) ;
}
else {
unum_setAttribute ( format , UNUM_FRACTION_DIGITS , 6 ) ;
}
if ( info -> fShowSign ) {
u_printf_set_sign ( format , info , prefixBuffer , & prefixBufferLen , & status ) ;
}
resultLen = unum_formatDouble ( format , num , result , UPRINTF_BUFFER_SIZE , 0 , & status ) ;
if ( U_FAILURE ( status ) ) {
resultLen = 0 ;
}
unum_setAttribute ( format , UNUM_MIN_FRACTION_DIGITS , minDecimalDigits ) ;
unum_setAttribute ( format , UNUM_MAX_FRACTION_DIGITS , maxDecimalDigits ) ;
if ( info -> fShowSign ) {
UErrorCode localStatus = U_ZERO_ERROR ;
u_printf_reset_sign ( format , info , prefixBuffer , & prefixBufferLen , & localStatus ) ;
}
return handler -> pad_and_justify ( context , info , result , resultLen ) ;
} |
6,323,824,267,898,511,000 | debian | 22 | 0 | void fz_colorspace_name_colorant ( fz_context * ctx , fz_colorspace * cs , int i , const char * name ) {
if ( ! cs ) return ;
if ( i < 0 || i >= cs -> n ) fz_throw ( ctx , FZ_ERROR_GENERIC , "Attempt to name out of range colorant" ) ;
fz_free ( ctx , cs -> colorant [ i ] ) ;
cs -> colorant [ i ] = NULL ;
if ( name ) {
cs -> colorant [ i ] = fz_strdup ( ctx , name ) ;
if ( cs -> type == FZ_COLORSPACE_SEPARATION ) {
if ( i == 0 ) {
if ( strcmp ( name , "Cyan" ) == 0 || strcmp ( name , "Magenta" ) == 0 || strcmp ( name , "Yellow" ) == 0 || strcmp ( name , "Black" ) == 0 ) {
cs -> flags |= FZ_CS_HAS_CMYK ;
}
}
else {
if ( ( cs -> flags & FZ_CS_HAS_CMYK_AND_SPOTS ) != FZ_CS_HAS_CMYK_AND_SPOTS ) {
if ( strcmp ( name , "Cyan" ) == 0 || strcmp ( name , "Magenta" ) == 0 || strcmp ( name , "Yellow" ) == 0 || strcmp ( name , "Black" ) == 0 ) cs -> flags |= FZ_CS_HAS_CMYK ;
else cs -> flags |= FZ_CS_HAS_SPOTS ;
}
}
}
}
} |
2,782,335,626,401,254,000 | debian | 6 | 0 | static int s_aes_init ( stream_state * ss ) {
stream_aes_state * const state = ( stream_aes_state * ) ss ;
state -> initialized = 0 ;
state -> ctx = NULL ;
return 0 ;
} |
7,092,216,800,726,730,000 | debian | 4 | 0 | static int dissect_h245_KeyProtectionMethod ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_KeyProtectionMethod , KeyProtectionMethod_sequence ) ;
return offset ;
} |
7,607,805,321,589,710,000 | debian | 6 | 0 | static int zexecuteonly ( i_ctx_t * i_ctx_p ) {
os_ptr op = osp ;
check_op ( 1 ) ;
if ( r_has_type ( op , t_dictionary ) ) return_error ( gs_error_typecheck ) ;
return access_check ( i_ctx_p , a_execute , true ) ;
} |
8,849,962,823,026,424,000 | debian | 6 | 0 | static void qio_channel_websock_unset_watch ( QIOChannelWebsock * ioc ) {
if ( ioc -> io_tag ) {
g_source_remove ( ioc -> io_tag ) ;
ioc -> io_tag = 0 ;
}
} |
-7,555,034,601,056,330,000 | debian | 8 | 0 | void virLogFilterListFree ( virLogFilterPtr * list , int count ) {
size_t i ;
if ( ! list || count < 0 ) return ;
for ( i = 0 ;
i < count ;
i ++ ) virLogFilterFree ( list [ i ] ) ;
VIR_FREE ( list ) ;
} |
-2,928,324,134,072,492,500 | debian | 42 | 0 | static int H245dgcalls_packet ( void * ptr _U_ , packet_info * pinfo , epan_dissect_t * edt _U_ , const void * H245info ) {
voip_calls_tapinfo_t * tapinfo = & the_tapinfo_struct ;
voip_calls_info_t * tmp_listinfo ;
voip_calls_info_t * callsinfo = NULL ;
h323_calls_info_t * tmp_h323info ;
GList * list ;
GList * list2 ;
h245_address_t * h245_add = NULL ;
const h245_packet_info * pi = ( const h245_packet_info * ) H245info ;
list = g_list_first ( tapinfo -> callsinfo_list ) ;
while ( list ) {
tmp_listinfo = ( voip_calls_info_t * ) list -> data ;
if ( tmp_listinfo -> protocol == VOIP_H323 ) {
tmp_h323info = ( h323_calls_info_t * ) tmp_listinfo -> prot_info ;
list2 = g_list_first ( tmp_h323info -> h245_list ) ;
while ( list2 ) {
h245_add = ( h245_address_t * ) list2 -> data ;
if ( ( ADDRESSES_EQUAL ( & ( h245_add -> h245_address ) , & ( pinfo -> src ) ) && ( h245_add -> h245_port == pinfo -> srcport ) ) || ( ADDRESSES_EQUAL ( & ( h245_add -> h245_address ) , & ( pinfo -> dst ) ) && ( h245_add -> h245_port == pinfo -> destport ) ) ) {
callsinfo = ( voip_calls_info_t * ) ( list -> data ) ;
++ ( callsinfo -> npackets ) ;
++ ( tapinfo -> npackets ) ;
break ;
}
list2 = g_list_next ( list2 ) ;
}
if ( callsinfo != NULL ) break ;
}
list = g_list_next ( list ) ;
}
if ( callsinfo != NULL ) {
++ ( callsinfo -> npackets ) ;
++ ( tapinfo -> npackets ) ;
if ( ! append_to_frame_graph ( tapinfo , pinfo -> fd -> num , pi -> frame_label , pi -> comment ) ) {
add_to_graph ( tapinfo , pinfo , pi -> frame_label , pi -> comment , callsinfo -> call_num , & ( pinfo -> src ) , & ( pinfo -> dst ) , 1 ) ;
}
}
else {
h245_add_label ( pinfo -> fd -> num , ( gchar * ) pi -> frame_label , ( gchar * ) pi -> comment ) ;
}
tapinfo -> redraw = TRUE ;
return 1 ;
} |
8,461,782,184,979,846,000 | chrome | 7 | 0 | TEST_F ( ProtocolHandlerRegistryTest , TestIsRegistered ) {
ProtocolHandler ph1 = CreateProtocolHandler ( "test" , "test1" ) ;
ProtocolHandler ph2 = CreateProtocolHandler ( "test" , "test2" ) ;
registry ( ) -> OnAcceptRegisterProtocolHandler ( ph1 ) ;
registry ( ) -> OnAcceptRegisterProtocolHandler ( ph2 ) ;
ASSERT_TRUE ( registry ( ) -> IsRegistered ( ph1 ) ) ;
} |
4,489,017,523,191,997,000 | debian | 4 | 0 | static int dissect_h225_AddressPattern ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h225_AddressPattern , AddressPattern_choice , NULL ) ;
return offset ;
} |
5,045,872,831,385,413,000 | debian | 3 | 0 | static gboolean is_writeable_request ( guint8 opcode ) {
return ( opcode == ATT_OPCODE_WRITE_REQUEST || opcode == ATT_OPCODE_WRITE_PREPARE_REQUEST ) ;
} |
-2,584,200,269,856,679,000 | debian | 4 | 0 | void bn_sqr_comba8 ( BN_ULONG * r , const BN_ULONG * a ) {
BN_ULONG t [ 16 ] ;
bn_sqr_normal ( r , a , 8 , t ) ;
} |
1,245,821,301,839,614,700 | debian | 18 | 0 | static void create_task_done ( GObject * source_object , GAsyncResult * res , gpointer user_data ) {
CreateJob * job ;
job = user_data ;
if ( job -> done_callback ) {
job -> done_callback ( job -> created_file , ! job_aborted ( ( CommonJob * ) job ) , job -> done_callback_data ) ;
}
g_object_unref ( job -> dest_dir ) ;
if ( job -> src ) {
g_object_unref ( job -> src ) ;
}
g_free ( job -> src_data ) ;
g_free ( job -> filename ) ;
if ( job -> created_file ) {
g_object_unref ( job -> created_file ) ;
}
finalize_common ( ( CommonJob * ) job ) ;
nautilus_file_changes_consume_changes ( TRUE ) ;
} |
5,917,118,798,851,366,000 | debian | 40 | 0 | void proto_register_zbee_zcl_appl_idt ( void ) {
static hf_register_info hf [ ] = {
{
& hf_zbee_zcl_appl_idt_attr_id , {
"Attribute" , "zbee_zcl_ha.applident.attr_id" , FT_UINT16 , BASE_HEX , VALS ( zbee_zcl_appl_idt_attr_names ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_appl_idt_company_id , {
"Company ID" , "zbee_zcl_ha.applident.attr.company.id" , FT_UINT16 , BASE_HEX , VALS ( zbee_zcl_appl_idt_company_names ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_appl_idt_brand_id , {
"Brand ID" , "zbee_zcl_ha.applident.attr.brand.id" , FT_UINT16 , BASE_HEX , VALS ( zbee_zcl_appl_idt_brand_names ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_appl_idt_string_len , {
"Length" , "zbee_zcl_ha.applident.string.len" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_appl_idt_prod_type_name , {
"Product Type Name" , "zbee_zcl_ha.applident.attr.prod_type.name" , FT_UINT16 , BASE_HEX , VALS ( zbee_zcl_appl_idt_prod_type_name_names ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_appl_idt_prod_type_id , {
"Product Type ID" , "zbee_zcl_ha.applident.attr.prod_type.id" , FT_UINT16 , BASE_HEX , VALS ( zbee_zcl_appl_idt_prod_type_names ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_appl_idt_ceced_spec_ver , {
"CECED Spec. Version" , "zbee_zcl_ha.applident.attr.ceced_spec_ver" , FT_UINT8 , BASE_HEX , VALS ( zbee_zcl_appl_idt_ceced_spec_ver_names ) , 0x00 , NULL , HFILL }
}
}
;
gint * ett [ ZBEE_ZCL_APPL_IDT_NUM_ETT ] ;
ett [ 0 ] = & ett_zbee_zcl_appl_idt ;
ett [ 1 ] = & ett_zbee_zcl_appl_idt_basic ;
proto_zbee_zcl_appl_idt = proto_register_protocol ( "ZigBee ZCL Appliance Identification" , "ZCL Appliance Identification" , ZBEE_PROTOABBREV_ZCL_APPLIDT ) ;
proto_register_field_array ( proto_zbee_zcl_appl_idt , hf , array_length ( hf ) ) ;
proto_register_subtree_array ( ett , array_length ( ett ) ) ;
register_dissector ( ZBEE_PROTOABBREV_ZCL_APPLIDT , dissect_zbee_zcl_appl_idt , proto_zbee_zcl_appl_idt ) ;
} |
-6,216,181,551,924,088,000 | chrome | 5 | 1 | static unsigned int get_joining_type ( hb_codepoint_t u , hb_unicode_general_category_t gen_cat ) {
unsigned int j_type = joining_type ( u ) ;
if ( likely ( j_type != JOINING_TYPE_X ) ) return j_type ;
return ( FLAG ( gen_cat ) & ( FLAG ( HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK ) | FLAG ( HB_UNICODE_GENERAL_CATEGORY_ENCLOSING_MARK ) | FLAG ( HB_UNICODE_GENERAL_CATEGORY_FORMAT ) ) ) ? JOINING_TYPE_T : JOINING_TYPE_U ;
} |
-5,883,714,287,021,299,000 | chrome | 27 | 0 | static uint32_t write8 ( FileStream * out , uint8_t byte , uint32_t column ) {
char s [ 4 ] ;
int i = 0 ;
if ( byte >= 100 ) {
s [ i ++ ] = ( char ) ( '0' + byte / 100 ) ;
byte %= 100 ;
}
if ( i > 0 || byte >= 10 ) {
s [ i ++ ] = ( char ) ( '0' + byte / 10 ) ;
byte %= 10 ;
}
s [ i ++ ] = ( char ) ( '0' + byte ) ;
s [ i ] = 0 ;
if ( column == MAX_COLUMN ) {
column = 1 ;
}
else if ( column < 16 ) {
T_FileStream_writeLine ( out , "," ) ;
++ column ;
}
else {
T_FileStream_writeLine ( out , ",\n" ) ;
column = 1 ;
}
T_FileStream_writeLine ( out , s ) ;
return column ;
} |
4,180,964,683,905,831,000 | debian | 15 | 0 | static int selinux_inode_setsecurity ( struct inode * inode , const char * name , const void * value , size_t size , int flags ) {
struct inode_security_struct * isec = inode_security_novalidate ( inode ) ;
u32 newsid ;
int rc ;
if ( strcmp ( name , XATTR_SELINUX_SUFFIX ) ) return - EOPNOTSUPP ;
if ( ! value || ! size ) return - EACCES ;
rc = security_context_to_sid ( value , size , & newsid , GFP_KERNEL ) ;
if ( rc ) return rc ;
spin_lock ( & isec -> lock ) ;
isec -> sclass = inode_mode_to_security_class ( inode -> i_mode ) ;
isec -> sid = newsid ;
isec -> initialized = LABEL_INITIALIZED ;
spin_unlock ( & isec -> lock ) ;
return 0 ;
} |
-8,620,097,311,326,519,000 | chrome | 20 | 0 | err_status_t srtp_create ( srtp_t * session , const srtp_policy_t * policy ) {
err_status_t stat ;
srtp_ctx_t * ctx ;
if ( session == NULL ) return err_status_bad_param ;
ctx = ( srtp_ctx_t * ) crypto_alloc ( sizeof ( srtp_ctx_t ) ) ;
if ( ctx == NULL ) return err_status_alloc_fail ;
* session = ctx ;
ctx -> stream_template = NULL ;
ctx -> stream_list = NULL ;
ctx -> user_data = NULL ;
while ( policy != NULL ) {
stat = srtp_add_stream ( ctx , policy ) ;
if ( stat ) {
srtp_dealloc ( * session ) ;
return stat ;
}
policy = policy -> next ;
}
return err_status_ok ;
} |
7,493,853,980,473,701,000 | debian | 12 | 0 | static uint32_t gic_cpu_read ( GICState * s , int cpu , int offset ) {
switch ( offset ) {
case 0x00 : return s -> cpu_enabled [ cpu ] ;
case 0x04 : return s -> priority_mask [ cpu ] ;
case 0x08 : return 0 ;
case 0x0c : return gic_acknowledge_irq ( s , cpu ) ;
case 0x14 : return s -> running_priority [ cpu ] ;
case 0x18 : return s -> current_pending [ cpu ] ;
default : qemu_log_mask ( LOG_GUEST_ERROR , "gic_cpu_read: Bad offset %x\n" , ( int ) offset ) ;
return 0 ;
}
} |
-4,008,264,846,350,093,300 | chrome | 4 | 0 | IN_PROC_BROWSER_TEST_F ( MessageCenterNotificationsTest , RetrieveBaseParts ) {
EXPECT_TRUE ( manager ( ) ) ;
EXPECT_TRUE ( message_center ( ) ) ;
} |
7,092,216,800,726,730,000 | debian | 5 | 0 | static int dissect_h245_CloseLogicalChannel ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_CloseLogicalChannel , CloseLogicalChannel_sequence ) ;
# line 548 "../../asn1/h245/h245.cnf" if ( h245_pi != NULL ) h245_pi -> msg_type = H245_CloseLogChn ;
return offset ;
} |
-2,908,211,205,972,632,000 | debian | 7 | 0 | static void cmd_window_rgrow ( const char * data ) {
int count ;
count = * data == '\0' ? 1 : atoi ( data ) ;
if ( ! mainwindow_rgrow ( WINDOW_MAIN ( active_win ) , count ) ) {
printformat_window ( active_win , MSGLEVEL_CLIENTNOTICE , TXT_WINDOW_TOO_SMALL ) ;
}
} |
-5,260,094,338,219,890,000 | debian | 7 | 0 | static void stroke_user_creds ( private_stroke_socket_t * this , stroke_msg_t * msg , FILE * out ) {
pop_string ( msg , & msg -> user_creds . name ) ;
pop_string ( msg , & msg -> user_creds . username ) ;
pop_string ( msg , & msg -> user_creds . password ) ;
DBG1 ( DBG_CFG , "received stroke: user-creds '%s'" , msg -> user_creds . name ) ;
this -> config -> set_user_credentials ( this -> config , msg , out ) ;
} |
-273,984,976,102,410,660 | chrome | 3 | 0 | static inline void uprv_arrayCopy ( const double * src , int32_t srcStart , double * dst , int32_t dstStart , int32_t count ) {
uprv_memcpy ( dst + dstStart , src + srcStart , ( size_t ) count * sizeof ( * src ) ) ;
} |
3,887,066,622,454,352,400 | chrome | 10 | 0 | static void choose_intra_uv_mode ( VP9_COMP * cpi , PICK_MODE_CONTEXT * ctx , BLOCK_SIZE bsize , TX_SIZE max_tx_size , int * rate_uv , int * rate_uv_tokenonly , int64_t * dist_uv , int * skip_uv , PREDICTION_MODE * mode_uv ) {
MACROBLOCK * const x = & cpi -> mb ;
if ( cpi -> sf . use_uv_intra_rd_estimate ) {
rd_sbuv_dcpred ( cpi , x , rate_uv , rate_uv_tokenonly , dist_uv , skip_uv , bsize < BLOCK_8X8 ? BLOCK_8X8 : bsize ) ;
}
else {
rd_pick_intra_sbuv_mode ( cpi , x , ctx , rate_uv , rate_uv_tokenonly , dist_uv , skip_uv , bsize < BLOCK_8X8 ? BLOCK_8X8 : bsize , max_tx_size ) ;
}
* mode_uv = x -> e_mbd . mi [ 0 ] . src_mi -> mbmi . uv_mode ;
} |
5,357,882,892,791,796,000 | debian | 9 | 0 | static inline bool e1000e_is_tcp_ack ( E1000ECore * core , struct NetRxPkt * rx_pkt ) {
if ( ! net_rx_pkt_is_tcp_ack ( rx_pkt ) ) {
return false ;
}
if ( core -> mac [ RFCTL ] & E1000_RFCTL_ACK_DATA_DIS ) {
return ! net_rx_pkt_has_tcp_data ( rx_pkt ) ;
}
return true ;
} |
-1,487,877,838,474,751,200 | debian | 25 | 0 | PHP_FUNCTION ( locale_parse ) {
const char * loc_name = NULL ;
int loc_name_len = 0 ;
int grOffset = 0 ;
intl_error_reset ( NULL TSRMLS_CC ) ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "s" , & loc_name , & loc_name_len ) == FAILURE ) {
intl_error_set ( NULL , U_ILLEGAL_ARGUMENT_ERROR , "locale_parse: unable to parse input params" , 0 TSRMLS_CC ) ;
RETURN_FALSE ;
}
if ( loc_name_len == 0 ) {
loc_name = intl_locale_get_default ( TSRMLS_C ) ;
}
array_init ( return_value ) ;
grOffset = findOffset ( LOC_GRANDFATHERED , loc_name ) ;
if ( grOffset >= 0 ) {
add_assoc_string ( return_value , LOC_GRANDFATHERED_LANG_TAG , estrdup ( loc_name ) , FALSE ) ;
}
else {
add_array_entry ( loc_name , return_value , LOC_LANG_TAG TSRMLS_CC ) ;
add_array_entry ( loc_name , return_value , LOC_SCRIPT_TAG TSRMLS_CC ) ;
add_array_entry ( loc_name , return_value , LOC_REGION_TAG TSRMLS_CC ) ;
add_array_entry ( loc_name , return_value , LOC_VARIANT_TAG TSRMLS_CC ) ;
add_array_entry ( loc_name , return_value , LOC_PRIVATE_TAG TSRMLS_CC ) ;
}
} |
3,919,646,340,804,521,500 | debian | 7 | 1 | static void show_object ( struct object * obj , const struct name_path * path , const char * last , void * data ) {
char * name = path_name ( path , last ) ;
add_preferred_base_object ( name ) ;
add_object_entry ( obj -> oid . hash , obj -> type , name , 0 ) ;
obj -> flags |= OBJECT_ADDED ;
free ( ( char * ) name ) ;
} |
-7,555,034,601,056,330,000 | debian | 10 | 0 | void virLogSetFromEnv ( void ) {
const char * debugEnv ;
if ( virLogInitialize ( ) < 0 ) return ;
debugEnv = virGetEnvAllowSUID ( "LIBVIRT_DEBUG" ) ;
if ( debugEnv && * debugEnv ) virLogSetDefaultPriority ( virLogParseDefaultPriority ( debugEnv ) ) ;
debugEnv = virGetEnvAllowSUID ( "LIBVIRT_LOG_FILTERS" ) ;
if ( debugEnv && * debugEnv ) virLogSetFilters ( debugEnv ) ;
debugEnv = virGetEnvAllowSUID ( "LIBVIRT_LOG_OUTPUTS" ) ;
if ( debugEnv && * debugEnv ) virLogSetOutputs ( debugEnv ) ;
} |
-4,032,982,860,280,343,600 | chrome | 11 | 0 | static int8_t getWindow ( const uint32_t offsets [ 8 ] , uint32_t c ) {
int i ;
for ( i = 0 ;
i < 8 ;
++ i ) {
if ( ( uint32_t ) ( c - offsets [ i ] ) <= 0x7f ) {
return ( int8_t ) ( i ) ;
}
}
return - 1 ;
} |
-5,706,788,925,640,467,000 | chrome | 20 | 0 | static void get_sb_partition_size_range ( MACROBLOCKD * xd , MODE_INFO * mi_8x8 , BLOCK_SIZE * min_block_size , BLOCK_SIZE * max_block_size , int bs_hist [ BLOCK_SIZES ] ) {
int sb_width_in_blocks = MI_BLOCK_SIZE ;
int sb_height_in_blocks = MI_BLOCK_SIZE ;
int i , j ;
int index = 0 ;
for ( i = 0 ;
i < sb_height_in_blocks ;
++ i ) {
for ( j = 0 ;
j < sb_width_in_blocks ;
++ j ) {
MODE_INFO * mi = mi_8x8 [ index + j ] . src_mi ;
BLOCK_SIZE sb_type = mi ? mi -> mbmi . sb_type : 0 ;
bs_hist [ sb_type ] ++ ;
* min_block_size = MIN ( * min_block_size , sb_type ) ;
* max_block_size = MAX ( * max_block_size , sb_type ) ;
}
index += xd -> mi_stride ;
}
} |
313,627,013,719,508,800 | debian | 3 | 0 | static inline size_t GetPixelMetaChannels ( const Image * restrict image ) {
return ( image -> number_meta_channels ) ;
} |
7,039,307,292,471,245,000 | debian | 229 | 0 | guint16 de_bearer_cap ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len , gchar * add_string , int string_len ) {
guint8 oct ;
guint8 itc ;
gboolean extended ;
guint32 curr_offset ;
guint32 saved_offset ;
proto_tree * subtree ;
proto_item * item ;
const gchar * str ;
# define DE_BC_ITC_SPEECH 0x00 # define DE_BC_ITC_UDI 0x01 # define DE_BC_ITC_EX_PLMN 0x02 # define DE_BC_ITC_FASC_G3 0x03 # define DE_BC_ITC_OTHER_ITC 0x05 # define DE_BC_ITC_RSVD_NET 0x07 curr_offset = offset ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_3 , NULL , "Octet 3" ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
itc = oct & 0x07 ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
switch ( is_uplink ) {
case IS_UPLINK_FALSE : str = "Spare" ;
break ;
case IS_UPLINK_TRUE : switch ( itc ) {
case DE_BC_ITC_SPEECH : if ( extended ) {
switch ( ( oct & 0x60 ) >> 5 ) {
case 1 : str = "MS supports at least full rate speech version 1 but does not support half rate speech version 1" ;
break ;
case 2 : str = "MS supports at least full rate speech version 1 and half rate speech version 1. MS has a greater preference for half rate speech version 1 than for full rate speech version 1" ;
break ;
case 3 : str = "MS supports at least full rate speech version 1 and half rate speech version 1. MS has a greater preference for full rate speech version 1 than for half rate speech version 1" ;
break ;
default : str = "Reserved" ;
break ;
}
}
else {
switch ( ( oct & 0x60 ) >> 5 ) {
case 1 : str = "Full rate support only MS/fullrate speech version 1 supported" ;
break ;
case 2 : str = "Dual rate support MS/half rate speech version 1 preferred, full rate speech version 1 also supported" ;
break ;
case 3 : str = "Dual rate support MS/full rate speech version 1 preferred, half rate speech version 1 also supported" ;
break ;
default : str = "Reserved" ;
break ;
}
}
break ;
default : switch ( ( oct & 0x60 ) >> 5 ) {
case 1 : str = "Full rate support only MS" ;
break ;
case 2 : str = "Dual rate support MS/half rate preferred" ;
break ;
case 3 : str = "Dual rate support MS/full rate preferred" ;
break ;
default : str = "Reserved" ;
break ;
}
break ;
}
break ;
default : str = "(dissect problem)" ;
break ;
}
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_radio_channel_requirement , tvb , curr_offset , 1 , oct , "%s" , str ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_bearer_cap_coding_standard , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_transfer_mode , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_itc , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
if ( add_string ) g_snprintf ( add_string , string_len , " - (%s)" , str ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
switch ( itc ) {
case DE_BC_ITC_SPEECH : subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , - 1 , ett_bc_oct_3a , & item , "Octets 3a - Speech Versions" ) ;
saved_offset = curr_offset ;
do {
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_coding , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_bits_item ( subtree , hf_gsm_a_spare_bits , tvb , ( curr_offset << 3 ) + 2 , 2 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_speech_vers_ind , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
}
while ( extended && ( ( len - ( curr_offset - offset ) ) > 0 ) ) ;
proto_item_set_len ( item , curr_offset - saved_offset ) ;
break ;
default : subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_4 , NULL , "Octet 4" ) ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , is_uplink ? hf_gsm_a_dtap_compression_up : hf_gsm_a_dtap_compression , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_structure , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_duplex_mode , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_configuration , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_nirr , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_establishment , tvb , curr_offset , 1 , ENC_NA ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_5 , NULL , "Octet 5" ) ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_access_identity , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_rate_adaption , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_signalling_access_protocol , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
if ( ! extended ) goto bc_octet_6 ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_5a , NULL , "Octet 5a" ) ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_other_itc , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_other_rate_adaption , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_bits_item ( tree , hf_gsm_a_spare_bits , tvb , ( curr_offset << 3 ) + 5 , 3 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
if ( ! extended ) goto bc_octet_6 ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_5b , NULL , "Octet 5b" ) ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_rate_adaption_header , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_multiple_frame_establishment_support , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_mode_of_operation , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_logical_link_identifier_negotiation , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_assignor_assignee , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_in_out_band , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_bits_item ( tree , hf_gsm_a_spare_bits , tvb , ( curr_offset << 3 ) + 7 , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
bc_octet_6 : subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_6 , NULL , "Octet 6" ) ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_layer_1_identity , tvb , curr_offset , 1 , oct , "%s" , ( ( oct & 0x60 ) == 0x20 ) ? "Octet identifier" : "Reserved" ) ;
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_user_information_layer_1_protocol , tvb , curr_offset , 1 , oct , "%s" , ( oct & 0x1e ) ? "Reserved" : "Default layer 1 protocol" ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_synchronous , tvb , curr_offset , 1 , ENC_NA ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
if ( ! extended ) goto bc_octet_7 ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_6a , NULL , "Octet 6a" ) ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_number_of_stop_bits , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_negotiation , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_number_of_data_bits , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_user_rate , tvb , curr_offset , 1 , oct , "%s" , val_to_str_const ( oct & 0xF , gsm_a_dtap_user_rate_vals , "Reserved" ) ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
if ( ! extended ) goto bc_octet_7 ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_6b , NULL , "Octet 6b" ) ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_v110_x30_rate_adaptation , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_nic_on_tx , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_nic_on_rx , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_parity_information , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
if ( ! extended ) goto bc_octet_7 ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_6c , NULL , "Octet 6c" ) ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_connection_element , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_modem_type , tvb , curr_offset , 1 , oct , "%s" , val_to_str_const ( oct & 0x1f , gsm_a_dtap_modem_type_vals , "Reserved" ) ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
if ( ! extended ) goto bc_octet_7 ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_6d , NULL , "Octet 6d" ) ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_other_modem_type , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_fixed_network_user_rate , tvb , curr_offset , 1 , oct , "%s" , val_to_str_const ( oct & 0x1f , gsm_a_dtap_fixed_network_user_rate_vals , "Reserved" ) ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
if ( ! extended ) goto bc_octet_7 ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_6e , NULL , "Octet 6e" ) ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
if ( is_uplink == IS_UPLINK_TRUE ) {
proto_tree_add_item ( subtree , hf_gsm_a_dtap_acceptable_channel_codings_TCH_F14_4 , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_acceptable_channel_codings_spare20 , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_acceptable_channel_codings_TCH_F9_6 , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_acceptable_channel_codings_TCH_F4_8 , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_maximum_number_of_traffic_channels , tvb , curr_offset , 1 , ( oct & 0x07 ) + 1 , "%u TCH" , ( oct & 0x07 ) + 1 ) ;
}
else {
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_acceptable_channel_codings_spare78 , tvb , curr_offset , 1 , oct , "Spare" ) ;
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_maximum_number_of_traffic_channels , tvb , curr_offset , 1 , oct , "Spare" ) ;
}
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
if ( ! extended ) goto bc_octet_7 ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_6f , NULL , "Octet 6f" ) ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
extended = ( oct & 0x80 ) ? FALSE : TRUE ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_uimi , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
if ( is_uplink == IS_UPLINK_TRUE ) {
proto_tree_add_item ( subtree , hf_gsm_a_dtap_wanted_air_interface_user_rate , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
}
else {
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_wanted_air_interface_user_rate , tvb , curr_offset , 1 , oct , "Spare" ) ;
}
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
if ( ! extended ) goto bc_octet_7 ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_6g , NULL , "Octet 6g" ) ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
if ( is_uplink == IS_UPLINK_TRUE ) {
proto_tree_add_item ( subtree , hf_gsm_a_dtap_acceptable_channel_codings_ext_TCH_F28_8 , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_acceptable_channel_codings_ext_TCH_F32_0 , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_acceptable_channel_codings_ext_TCH_F43_2 , tvb , curr_offset , 1 , ENC_NA ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_channel_coding_asymmetry_indication , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
}
else {
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_edge_channel_codings , tvb , curr_offset , 1 , oct , "Spare" ) ;
}
proto_tree_add_bits_item ( tree , hf_gsm_a_spare_bits , tvb , ( curr_offset << 3 ) + 6 , 2 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
NO_MORE_DATA_CHECK ( len ) ;
bc_octet_7 : subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_bc_oct_7 , NULL , "Octet 7" ) ;
proto_tree_add_item ( subtree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_layer_2_identity , tvb , curr_offset , 1 , oct , "%s" , ( ( oct & 0x60 ) == 0x40 ) ? "Octet identifier" : "Reserved" ) ;
proto_tree_add_uint_format_value ( subtree , hf_gsm_a_dtap_user_information_layer_2_protocol , tvb , curr_offset , 1 , oct , "%s" , val_to_str_const ( oct & 0x1F , gsm_a_dtap_user_info_layer2_vals , "Reserved" ) ) ;
break ;
}
EXTRANEOUS_DATA_CHECK ( len , curr_offset - offset , pinfo , & ei_gsm_a_dtap_extraneous_data ) ;
return ( curr_offset - offset ) ;
} |
-8,919,449,269,326,402,000 | debian | 15 | 0 | static int dissect_s_validator_prod_cons_fault_count ( packet_info * pinfo , proto_tree * tree , proto_item * item , tvbuff_t * tvb , int offset , int total_len ) {
int i , size ;
proto_tree_add_item ( tree , hf_cip_svalidator_prod_cons_fault_count_size , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ;
size = tvb_get_guint8 ( tvb , offset ) ;
if ( total_len < size + 1 ) {
expert_add_info ( pinfo , item , & ei_mal_svalidator_prod_cons_fault_count ) ;
return total_len ;
}
for ( i = 0 ;
i < size ;
i ++ ) {
proto_tree_add_item ( tree , hf_cip_svalidator_prod_cons_fault_count_item , tvb , offset + 1 + i , 1 , ENC_LITTLE_ENDIAN ) ;
}
return ( size + 1 ) ;
} |
7,406,835,591,406,201,000 | chrome | 27 | 0 | static UChar32 getMirror ( const UBiDiProps * bdp , UChar32 c , uint16_t props ) {
int32_t delta = UBIDI_GET_MIRROR_DELTA ( props ) ;
if ( delta != UBIDI_ESC_MIRROR_DELTA ) {
return c + delta ;
}
else {
const uint32_t * mirrors ;
uint32_t m ;
int32_t i , length ;
UChar32 c2 ;
mirrors = bdp -> mirrors ;
length = bdp -> indexes [ UBIDI_IX_MIRROR_LENGTH ] ;
for ( i = 0 ;
i < length ;
++ i ) {
m = mirrors [ i ] ;
c2 = UBIDI_GET_MIRROR_CODE_POINT ( m ) ;
if ( c == c2 ) {
return UBIDI_GET_MIRROR_CODE_POINT ( mirrors [ UBIDI_GET_MIRROR_INDEX ( m ) ] ) ;
}
else if ( c < c2 ) {
break ;
}
}
return c ;
}
} |
-2,723,830,976,796,502,500 | chrome | 25 | 1 | static vpx_codec_err_t encoder_init ( vpx_codec_ctx_t * ctx , vpx_codec_priv_enc_mr_cfg_t * data ) {
vpx_codec_err_t res = VPX_CODEC_OK ;
( void ) data ;
if ( ctx -> priv == NULL ) {
vpx_codec_alg_priv_t * const priv = vpx_calloc ( 1 , sizeof ( * priv ) ) ;
if ( priv == NULL ) return VPX_CODEC_MEM_ERROR ;
ctx -> priv = ( vpx_codec_priv_t * ) priv ;
ctx -> priv -> init_flags = ctx -> init_flags ;
ctx -> priv -> enc . total_encoders = 1 ;
if ( ctx -> config . enc ) {
priv -> cfg = * ctx -> config . enc ;
ctx -> config . enc = & priv -> cfg ;
}
priv -> extra_cfg = default_extra_cfg ;
vp9_initialize_enc ( ) ;
res = validate_config ( priv , & priv -> cfg , & priv -> extra_cfg ) ;
if ( res == VPX_CODEC_OK ) {
set_encoder_config ( & priv -> oxcf , & priv -> cfg , & priv -> extra_cfg ) ;
priv -> cpi = vp9_create_compressor ( & priv -> oxcf ) ;
if ( priv -> cpi == NULL ) res = VPX_CODEC_MEM_ERROR ;
else priv -> cpi -> output_pkt_list = & priv -> pkt_list . head ;
}
}
return res ;
} |
-4,299,048,894,522,449,400 | debian | 31 | 0 | static int imc_decode_frame ( AVCodecContext * avctx , void * data , int * got_frame_ptr , AVPacket * avpkt ) {
AVFrame * frame = data ;
const uint8_t * buf = avpkt -> data ;
int buf_size = avpkt -> size ;
int ret , i ;
IMCContext * q = avctx -> priv_data ;
LOCAL_ALIGNED_16 ( uint16_t , buf16 , [ IMC_BLOCK_SIZE / 2 ] ) ;
if ( buf_size < IMC_BLOCK_SIZE * avctx -> channels ) {
av_log ( avctx , AV_LOG_ERROR , "frame too small!\n" ) ;
return AVERROR_INVALIDDATA ;
}
frame -> nb_samples = COEFFS ;
if ( ( ret = ff_get_buffer ( avctx , frame , 0 ) ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "get_buffer() failed\n" ) ;
return ret ;
}
for ( i = 0 ;
i < avctx -> channels ;
i ++ ) {
q -> out_samples = ( float * ) frame -> extended_data [ i ] ;
q -> dsp . bswap16_buf ( buf16 , ( const uint16_t * ) buf , IMC_BLOCK_SIZE / 2 ) ;
init_get_bits ( & q -> gb , ( const uint8_t * ) buf16 , IMC_BLOCK_SIZE * 8 ) ;
buf += IMC_BLOCK_SIZE ;
if ( ( ret = imc_decode_block ( avctx , q , i ) ) < 0 ) return ret ;
}
if ( avctx -> channels == 2 ) {
q -> fdsp . butterflies_float ( ( float * ) frame -> extended_data [ 0 ] , ( float * ) frame -> extended_data [ 1 ] , COEFFS ) ;
}
* got_frame_ptr = 1 ;
return IMC_BLOCK_SIZE * avctx -> channels ;
} |
229,962,612,204,197,000 | debian | 55 | 0 | static int locking_available ( void ) {
struct active_request_slot * slot ;
struct slot_results results ;
struct strbuf in_buffer = STRBUF_INIT ;
struct buffer out_buffer = {
STRBUF_INIT , 0 }
;
struct curl_slist * dav_headers = NULL ;
struct xml_ctx ctx ;
int lock_flags = 0 ;
char * escaped ;
escaped = xml_entities ( repo -> url ) ;
strbuf_addf ( & out_buffer . buf , PROPFIND_SUPPORTEDLOCK_REQUEST , escaped ) ;
free ( escaped ) ;
dav_headers = curl_slist_append ( dav_headers , "Depth: 0" ) ;
dav_headers = curl_slist_append ( dav_headers , "Content-Type: text/xml" ) ;
slot = get_active_slot ( ) ;
slot -> results = & results ;
curl_setup_http ( slot -> curl , repo -> url , DAV_PROPFIND , & out_buffer , fwrite_buffer ) ;
curl_easy_setopt ( slot -> curl , CURLOPT_HTTPHEADER , dav_headers ) ;
curl_easy_setopt ( slot -> curl , CURLOPT_FILE , & in_buffer ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
if ( results . curl_result == CURLE_OK ) {
XML_Parser parser = XML_ParserCreate ( NULL ) ;
enum XML_Status result ;
ctx . name = xcalloc ( 10 , 1 ) ;
ctx . len = 0 ;
ctx . cdata = NULL ;
ctx . userFunc = handle_lockprop_ctx ;
ctx . userData = & lock_flags ;
XML_SetUserData ( parser , & ctx ) ;
XML_SetElementHandler ( parser , xml_start_tag , xml_end_tag ) ;
result = XML_Parse ( parser , in_buffer . buf , in_buffer . len , 1 ) ;
free ( ctx . name ) ;
if ( result != XML_STATUS_OK ) {
fprintf ( stderr , "XML error: %s\n" , XML_ErrorString ( XML_GetErrorCode ( parser ) ) ) ;
lock_flags = 0 ;
}
XML_ParserFree ( parser ) ;
if ( ! lock_flags ) error ( "no DAV locking support on %s" , repo -> url ) ;
}
else {
error ( "Cannot access URL %s, return code %d" , repo -> url , results . curl_result ) ;
lock_flags = 0 ;
}
}
else {
error ( "Unable to start PROPFIND request on %s" , repo -> url ) ;
}
strbuf_release ( & out_buffer . buf ) ;
strbuf_release ( & in_buffer ) ;
curl_slist_free_all ( dav_headers ) ;
return lock_flags ;
} |
1,286,774,465,219,423,200 | debian | 6 | 1 | static int jbig2_find_changing_element_of_color ( const byte * line , int x , int w , int color ) {
if ( line == 0 ) return w ;
x = jbig2_find_changing_element ( line , x , w ) ;
if ( x < w && getbit ( line , x ) != color ) x = jbig2_find_changing_element ( line , x , w ) ;
return x ;
} |
3,527,528,132,581,042,000 | debian | 82 | 0 | int main ( int argc , char * * argv ) {
int ArgIndex ;
int NumErrs = 0 ;
char * Args [ MAXARGS ] ;
int aindex = 0 ;
int rc ;
int pid ;
char tmpJobID [ PBS_MAXCLTJOBID ] ;
char JobID [ PBS_MAXCLTJOBID ] ;
char ServerName [ MAXSERVERNAME ] ;
int DoBackground = 0 ;
tmpJobID [ 0 ] = '\0' ;
# define GETOPT_ARGS "bj:" while ( ( ArgIndex = getopt ( argc , argv , GETOPT_ARGS ) ) != EOF ) {
switch ( ArgIndex ) {
case 'b' : DoBackground = 1 ;
break ;
case 'j' : strncpy ( tmpJobID , optarg , sizeof ( tmpJobID ) ) ;
if ( tmpJobID [ PBS_MAXCLTJOBID - 1 ] != '\0' ) {
fprintf ( stderr , "pbs_track: given job ID too large (> %d)\n" , PBS_MAXCLTJOBID ) ;
exit ( - 1 ) ;
}
break ;
default : NumErrs ++ ;
break ;
}
}
if ( ( NumErrs > 0 ) || ( optind >= argc ) || ( tmpJobID [ 0 ] == '\0' ) ) {
static char Usage [ ] = "USAGE: pbs_track [-j <JOBID>] [-b] -- a.out arg1 arg2 ... argN\n" ;
fprintf ( stderr , "%s" , Usage ) ;
exit ( 2 ) ;
}
if ( getenv ( NO_SERVER_SUFFIX ) != NULL ) {
snprintf ( JobID , sizeof ( JobID ) , "%s" , tmpJobID ) ;
}
else {
if ( get_server ( tmpJobID , JobID , sizeof ( JobID ) , ServerName , sizeof ( ServerName ) ) ) {
fprintf ( stderr , "pbs_track: illegally formed job identifier: '%s'\n" , JobID ) ;
exit ( 1 ) ;
}
}
aindex = 0 ;
for ( ;
optind < argc ;
optind ++ ) {
Args [ aindex ++ ] = strdup ( argv [ optind ] ) ;
printf ( "Got arg: %s\n" , Args [ aindex - 1 ] ) ;
}
Args [ aindex ] = NULL ;
pid = 1 ;
if ( DoBackground == 1 ) {
printf ( "FORKING!\n" ) ;
pid = fork ( ) ;
}
if ( ( DoBackground == 0 ) || ( pid == 0 ) ) {
rc = tm_adopt ( JobID , TM_ADOPT_JOBID , getpid ( ) ) ;
switch ( rc ) {
case TM_SUCCESS : break ;
case TM_ENOTFOUND : fprintf ( stderr , "pbs_track: MOM could not find job %s\n" , JobID ) ;
break ;
case TM_ESYSTEM : case TM_ENOTCONNECTED : fprintf ( stderr , "pbs_track: error occurred while trying to communication with pbs_mom: %s (%d)\n" , pbse_to_txt ( rc ) , rc ) ;
break ;
case TM_EPERM : fprintf ( stderr , "pbs_track: permission denied: %s (%d)\n" , pbse_to_txt ( rc ) , rc ) ;
default : fprintf ( stderr , "pbs_track: unexpected error %s (%d) occurred\n" , pbse_to_txt ( rc ) , rc ) ;
break ;
}
if ( rc != TM_SUCCESS ) {
exit ( - 1 ) ;
}
if ( execvp ( Args [ 0 ] , Args ) == - 1 ) {
fprintf ( stderr , "execvp failed with error %d, message:\n%s\n" , errno , strerror ( errno ) ) ;
}
}
else if ( pid > 0 ) {
fclose ( stdin ) ;
fclose ( stdout ) ;
fclose ( stderr ) ;
}
else if ( pid < 0 ) {
fprintf ( stderr , "pbs_track: could not fork (%d:%s)\n" , errno , strerror ( errno ) ) ;
}
exit ( 0 ) ;
} |
2,895,622,461,494,525,400 | debian | 32 | 0 | static void test_bind_nagative ( ) {
MYSQL_STMT * stmt_insert ;
char * query ;
int rc ;
MYSQL_BIND my_bind [ 1 ] ;
int32 my_val = 0 ;
ulong my_length = 0L ;
my_bool my_null = FALSE ;
myheader ( "test_insert_select" ) ;
rc = mysql_query ( mysql , "DROP TABLE IF EXISTS t1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "create temporary table t1 (c1 int unsigned)" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "INSERT INTO t1 VALUES (1), (-1)" ) ;
myquery ( rc ) ;
query = ( char * ) "INSERT INTO t1 VALUES (?)" ;
stmt_insert = mysql_simple_prepare ( mysql , query ) ;
check_stmt ( stmt_insert ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_LONG ;
my_bind [ 0 ] . buffer = ( void * ) & my_val ;
my_bind [ 0 ] . length = & my_length ;
my_bind [ 0 ] . is_null = ( char * ) & my_null ;
rc = mysql_stmt_bind_param ( stmt_insert , my_bind ) ;
check_execute ( stmt_insert , rc ) ;
my_val = - 1 ;
rc = mysql_stmt_execute ( stmt_insert ) ;
check_execute ( stmt_insert , rc ) ;
mysql_stmt_close ( stmt_insert ) ;
rc = mysql_query ( mysql , "drop table t1" ) ;
myquery ( rc ) ;
} |
7,092,216,800,726,730,000 | debian | 4 | 0 | static int dissect_h245_RedundancyEncodingDTModeElement ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_RedundancyEncodingDTModeElement , RedundancyEncodingDTModeElement_sequence ) ;
return offset ;
} |
-4,456,702,502,726,364,000 | debian | 14 | 0 | static int decode_cabac_mb_cbp_luma ( H264Context * h ) {
int cbp_b , cbp_a , ctx , cbp = 0 ;
cbp_a = h -> left_cbp ;
cbp_b = h -> top_cbp ;
ctx = ! ( cbp_a & 0x02 ) + 2 * ! ( cbp_b & 0x04 ) ;
cbp += get_cabac_noinline ( & h -> cabac , & h -> cabac_state [ 73 + ctx ] ) ;
ctx = ! ( cbp & 0x01 ) + 2 * ! ( cbp_b & 0x08 ) ;
cbp += get_cabac_noinline ( & h -> cabac , & h -> cabac_state [ 73 + ctx ] ) << 1 ;
ctx = ! ( cbp_a & 0x08 ) + 2 * ! ( cbp & 0x01 ) ;
cbp += get_cabac_noinline ( & h -> cabac , & h -> cabac_state [ 73 + ctx ] ) << 2 ;
ctx = ! ( cbp & 0x04 ) + 2 * ! ( cbp & 0x02 ) ;
cbp += get_cabac_noinline ( & h -> cabac , & h -> cabac_state [ 73 + ctx ] ) << 3 ;
return cbp ;
} |
7,039,307,292,471,245,000 | debian | 10 | 0 | static void dtap_cc_start_cc ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len ) {
guint32 curr_offset ;
guint32 consumed ;
guint curr_len ;
curr_offset = offset ;
curr_len = len ;
is_uplink = IS_UPLINK_FALSE ;
ELEM_OPT_TLV ( 0x15 , GSM_A_PDU_TYPE_DTAP , DE_CC_CAP , NULL ) ;
EXTRANEOUS_DATA_CHECK ( curr_len , 0 , pinfo , & ei_gsm_a_dtap_extraneous_data ) ;
} |
-5,689,214,734,378,700,000 | debian | 13 | 0 | static long long millis_from_datetime ( PyObject * datetime ) {
struct TM timeinfo ;
long long millis ;
timeinfo . tm_year = PyDateTime_GET_YEAR ( datetime ) - 1900 ;
timeinfo . tm_mon = PyDateTime_GET_MONTH ( datetime ) - 1 ;
timeinfo . tm_mday = PyDateTime_GET_DAY ( datetime ) ;
timeinfo . tm_hour = PyDateTime_DATE_GET_HOUR ( datetime ) ;
timeinfo . tm_min = PyDateTime_DATE_GET_MINUTE ( datetime ) ;
timeinfo . tm_sec = PyDateTime_DATE_GET_SECOND ( datetime ) ;
millis = timegm64 ( & timeinfo ) * 1000 ;
millis += PyDateTime_DATE_GET_MICROSECOND ( datetime ) / 1000 ;
return millis ;
} |
3,804,373,597,256,531,000 | debian | 25 | 0 | static void acl_update_user ( const char * user , const char * host , const char * password , uint password_len , enum SSL_type ssl_type , const char * ssl_cipher , const char * x509_issuer , const char * x509_subject , USER_RESOURCES * mqh , ulong privileges ) {
safe_mutex_assert_owner ( & acl_cache -> lock ) ;
for ( uint i = 0 ;
i < acl_users . elements ;
i ++ ) {
ACL_USER * acl_user = dynamic_element ( & acl_users , i , ACL_USER * ) ;
if ( ( ! acl_user -> user && ! user [ 0 ] ) || ( acl_user -> user && ! strcmp ( user , acl_user -> user ) ) ) {
if ( ( ! acl_user -> host . hostname && ! host [ 0 ] ) || ( acl_user -> host . hostname && ! my_strcasecmp ( system_charset_info , host , acl_user -> host . hostname ) ) ) {
acl_user -> access = privileges ;
if ( mqh -> specified_limits & USER_RESOURCES : : QUERIES_PER_HOUR ) acl_user -> user_resource . questions = mqh -> questions ;
if ( mqh -> specified_limits & USER_RESOURCES : : UPDATES_PER_HOUR ) acl_user -> user_resource . updates = mqh -> updates ;
if ( mqh -> specified_limits & USER_RESOURCES : : CONNECTIONS_PER_HOUR ) acl_user -> user_resource . conn_per_hour = mqh -> conn_per_hour ;
if ( mqh -> specified_limits & USER_RESOURCES : : USER_CONNECTIONS ) acl_user -> user_resource . user_conn = mqh -> user_conn ;
if ( ssl_type != SSL_TYPE_NOT_SPECIFIED ) {
acl_user -> ssl_type = ssl_type ;
acl_user -> ssl_cipher = ( ssl_cipher ? strdup_root ( & mem , ssl_cipher ) : 0 ) ;
acl_user -> x509_issuer = ( x509_issuer ? strdup_root ( & mem , x509_issuer ) : 0 ) ;
acl_user -> x509_subject = ( x509_subject ? strdup_root ( & mem , x509_subject ) : 0 ) ;
}
if ( password ) set_user_salt ( acl_user , password , password_len ) ;
break ;
}
}
}
} |
-6,552,851,419,396,579,000 | debian | 4 | 0 | static int SpoolssFCPN_r ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep ) {
offset = dissect_doserror ( tvb , offset , pinfo , tree , di , drep , hf_rc , NULL ) ;
return offset ;
} |
6,667,142,528,452,942,000 | debian | 6 | 0 | static int add_stop_slave ( void ) {
if ( opt_comments ) fprintf ( md_result_file , "\n--\n-- stop slave statement to make a recovery dump)\n--\n\n" ) ;
fprintf ( md_result_file , "STOP SLAVE;
\n" ) ;
return ( 0 ) ;
} |
-5,241,093,592,682,744,000 | debian | 8 | 0 | static int element_compare ( const void * key1 , const void * key2 , void * arg ) {
Datum d1 = * ( ( const Datum * ) key1 ) ;
Datum d2 = * ( ( const Datum * ) key2 ) ;
FmgrInfo * cmpfunc = ( FmgrInfo * ) arg ;
Datum c ;
c = FunctionCall2Coll ( cmpfunc , DEFAULT_COLLATION_OID , d1 , d2 ) ;
return DatumGetInt32 ( c ) ;
} |
3,528,176,083,733,952,000 | debian | 9 | 1 | void vmmouse_get_data ( uint32_t * data ) {
CPUX86State * env = cpu_single_env ;
data [ 0 ] = env -> regs [ R_EAX ] ;
data [ 1 ] = env -> regs [ R_EBX ] ;
data [ 2 ] = env -> regs [ R_ECX ] ;
data [ 3 ] = env -> regs [ R_EDX ] ;
data [ 4 ] = env -> regs [ R_ESI ] ;
data [ 5 ] = env -> regs [ R_EDI ] ;
} |
-2,584,200,269,856,679,000 | debian | 6 | 0 | void bn_mul_comba4 ( BN_ULONG * r , BN_ULONG * a , BN_ULONG * b ) {
r [ 4 ] = bn_mul_words ( & ( r [ 0 ] ) , a , 4 , b [ 0 ] ) ;
r [ 5 ] = bn_mul_add_words ( & ( r [ 1 ] ) , a , 4 , b [ 1 ] ) ;
r [ 6 ] = bn_mul_add_words ( & ( r [ 2 ] ) , a , 4 , b [ 2 ] ) ;
r [ 7 ] = bn_mul_add_words ( & ( r [ 3 ] ) , a , 4 , b [ 3 ] ) ;
} |