Datasets:
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
|
|---|---|---|---|---|
-8,690,690,140,780,653,000 | debian | 8 | 0 | OM_uint32 kg_sync_ccache_name ( krb5_context context , OM_uint32 * minor_status ) {
OM_uint32 err = 0 ;
if ( ! err ) {
err = krb5_cc_set_default_name ( context , ( char * ) k5_getspecific ( K5_KEY_GSS_KRB5_CCACHE_NAME ) ) ;
}
* minor_status = err ;
return ( * minor_status == 0 ) ? GSS_S_COMPLETE : GSS_S_FAILURE ;
} |
-6,245,610,163,896,160,000 | debian | 94 | 0 | static void write_bootloader ( CPUMIPSState * env , uint8_t * base , int64_t kernel_entry ) {
uint32_t * p ;
p = ( uint32_t * ) base ;
stl_raw ( p ++ , 0x0bf00160 ) ;
stl_raw ( p ++ , 0x00000000 ) ;
stl_raw ( base + 0x500 , 0xbfc00580 ) ;
stl_raw ( base + 0x504 , 0xbfc0083c ) ;
stl_raw ( base + 0x520 , 0xbfc00580 ) ;
stl_raw ( base + 0x52c , 0xbfc00800 ) ;
stl_raw ( base + 0x534 , 0xbfc00808 ) ;
stl_raw ( base + 0x538 , 0xbfc00800 ) ;
stl_raw ( base + 0x53c , 0xbfc00800 ) ;
stl_raw ( base + 0x540 , 0xbfc00800 ) ;
stl_raw ( base + 0x544 , 0xbfc00800 ) ;
stl_raw ( base + 0x548 , 0xbfc00800 ) ;
stl_raw ( base + 0x54c , 0xbfc00800 ) ;
stl_raw ( base + 0x550 , 0xbfc00800 ) ;
stl_raw ( base + 0x554 , 0xbfc00800 ) ;
p = ( uint32_t * ) ( base + 0x580 ) ;
stl_raw ( p ++ , 0x24040002 ) ;
stl_raw ( p ++ , 0x3c1d0000 | ( ( ( ENVP_ADDR - 64 ) >> 16 ) & 0xffff ) ) ;
stl_raw ( p ++ , 0x37bd0000 | ( ( ENVP_ADDR - 64 ) & 0xffff ) ) ;
stl_raw ( p ++ , 0x3c050000 | ( ( ENVP_ADDR >> 16 ) & 0xffff ) ) ;
stl_raw ( p ++ , 0x34a50000 | ( ENVP_ADDR & 0xffff ) ) ;
stl_raw ( p ++ , 0x3c060000 | ( ( ( ENVP_ADDR + 8 ) >> 16 ) & 0xffff ) ) ;
stl_raw ( p ++ , 0x34c60000 | ( ( ENVP_ADDR + 8 ) & 0xffff ) ) ;
stl_raw ( p ++ , 0x3c070000 | ( loaderparams . ram_size >> 16 ) ) ;
stl_raw ( p ++ , 0x34e70000 | ( loaderparams . ram_size & 0xffff ) ) ;
stl_raw ( p ++ , 0x3c09b400 ) ;
# ifdef TARGET_WORDS_BIGENDIAN stl_raw ( p ++ , 0x3c08df00 ) ;
# else stl_raw ( p ++ , 0x340800df ) ;
# endif stl_raw ( p ++ , 0xad280068 ) ;
stl_raw ( p ++ , 0x3c09bbe0 ) ;
# ifdef TARGET_WORDS_BIGENDIAN stl_raw ( p ++ , 0x3c08c000 ) ;
# else stl_raw ( p ++ , 0x340800c0 ) ;
# endif stl_raw ( p ++ , 0xad280048 ) ;
# ifdef TARGET_WORDS_BIGENDIAN stl_raw ( p ++ , 0x3c084000 ) ;
# else stl_raw ( p ++ , 0x34080040 ) ;
# endif stl_raw ( p ++ , 0xad280050 ) ;
# ifdef TARGET_WORDS_BIGENDIAN stl_raw ( p ++ , 0x3c088000 ) ;
# else stl_raw ( p ++ , 0x34080080 ) ;
# endif stl_raw ( p ++ , 0xad280058 ) ;
# ifdef TARGET_WORDS_BIGENDIAN stl_raw ( p ++ , 0x3c083f00 ) ;
# else stl_raw ( p ++ , 0x3408003f ) ;
# endif stl_raw ( p ++ , 0xad280060 ) ;
# ifdef TARGET_WORDS_BIGENDIAN stl_raw ( p ++ , 0x3c08c100 ) ;
# else stl_raw ( p ++ , 0x340800c1 ) ;
# endif stl_raw ( p ++ , 0xad280080 ) ;
# ifdef TARGET_WORDS_BIGENDIAN stl_raw ( p ++ , 0x3c085e00 ) ;
# else stl_raw ( p ++ , 0x3408005e ) ;
# endif stl_raw ( p ++ , 0xad280088 ) ;
stl_raw ( p ++ , 0x3c1f0000 | ( ( kernel_entry >> 16 ) & 0xffff ) ) ;
stl_raw ( p ++ , 0x37ff0000 | ( kernel_entry & 0xffff ) ) ;
stl_raw ( p ++ , 0x03e00008 ) ;
stl_raw ( p ++ , 0x00000000 ) ;
p = ( uint32_t * ) ( base + 0x800 ) ;
stl_raw ( p ++ , 0x03e00008 ) ;
stl_raw ( p ++ , 0x24020000 ) ;
stl_raw ( p ++ , 0x03e06821 ) ;
stl_raw ( p ++ , 0x00805821 ) ;
stl_raw ( p ++ , 0x00a05021 ) ;
stl_raw ( p ++ , 0x91440000 ) ;
stl_raw ( p ++ , 0x254a0001 ) ;
stl_raw ( p ++ , 0x10800005 ) ;
stl_raw ( p ++ , 0x00000000 ) ;
stl_raw ( p ++ , 0x0ff0021c ) ;
stl_raw ( p ++ , 0x00000000 ) ;
stl_raw ( p ++ , 0x08000205 ) ;
stl_raw ( p ++ , 0x00000000 ) ;
stl_raw ( p ++ , 0x01a00008 ) ;
stl_raw ( p ++ , 0x01602021 ) ;
stl_raw ( p ++ , 0x03e06821 ) ;
stl_raw ( p ++ , 0x00805821 ) ;
stl_raw ( p ++ , 0x00a05021 ) ;
stl_raw ( p ++ , 0x00c06021 ) ;
stl_raw ( p ++ , 0x91440000 ) ;
stl_raw ( p ++ , 0x0ff0021c ) ;
stl_raw ( p ++ , 0x00000000 ) ;
stl_raw ( p ++ , 0x254a0001 ) ;
stl_raw ( p ++ , 0x258cffff ) ;
stl_raw ( p ++ , 0x1580fffa ) ;
stl_raw ( p ++ , 0x00000000 ) ;
stl_raw ( p ++ , 0x01a00008 ) ;
stl_raw ( p ++ , 0x01602021 ) ;
stl_raw ( p ++ , 0x3c08b800 ) ;
stl_raw ( p ++ , 0x350803f8 ) ;
stl_raw ( p ++ , 0x91090005 ) ;
stl_raw ( p ++ , 0x00000000 ) ;
stl_raw ( p ++ , 0x31290040 ) ;
stl_raw ( p ++ , 0x1120fffc ) ;
stl_raw ( p ++ , 0x00000000 ) ;
stl_raw ( p ++ , 0x03e00008 ) ;
stl_raw ( p ++ , 0xa1040000 ) ;
} |
7,324,112,841,603,622,000 | debian | 6 | 0 | static bool search_header ( struct message_search_context * ctx , const struct message_header_line * hdr ) {
static const unsigned char crlf [ 2 ] = {
'\r' , '\n' }
;
return str_find_more ( ctx -> str_find_ctx , ( const unsigned char * ) hdr -> name , hdr -> name_len ) || str_find_more ( ctx -> str_find_ctx , hdr -> middle , hdr -> middle_len ) || str_find_more ( ctx -> str_find_ctx , hdr -> full_value , hdr -> full_value_len ) || ( ! hdr -> no_newline && str_find_more ( ctx -> str_find_ctx , crlf , 2 ) ) ;
} |
-3,299,391,226,809,811,500 | debian | 53 | 0 | static int qemuAgentIOProcessLine ( qemuAgentPtr mon , const char * line , qemuAgentMessagePtr msg ) {
virJSONValuePtr obj = NULL ;
int ret = - 1 ;
VIR_DEBUG ( "Line [%s]" , line ) ;
if ( ! ( obj = virJSONValueFromString ( line ) ) ) {
if ( msg && msg -> sync && msg -> first ) {
VIR_DEBUG ( "Received garbage on sync" ) ;
msg -> finished = 1 ;
return 0 ;
}
goto cleanup ;
}
if ( obj -> type != VIR_JSON_TYPE_OBJECT ) {
virReportError ( VIR_ERR_INTERNAL_ERROR , _ ( "Parsed JSON reply '%s' isn't an object" ) , line ) ;
goto cleanup ;
}
if ( virJSONValueObjectHasKey ( obj , "QMP" ) == 1 ) {
ret = 0 ;
}
else if ( virJSONValueObjectHasKey ( obj , "event" ) == 1 ) {
ret = qemuAgentIOProcessEvent ( mon , obj ) ;
}
else if ( virJSONValueObjectHasKey ( obj , "error" ) == 1 || virJSONValueObjectHasKey ( obj , "return" ) == 1 ) {
if ( msg ) {
if ( msg -> sync ) {
unsigned long long id ;
if ( virJSONValueObjectGetNumberUlong ( obj , "return" , & id ) < 0 ) {
VIR_DEBUG ( "Ignoring delayed reply on sync" ) ;
ret = 0 ;
goto cleanup ;
}
VIR_DEBUG ( "Guest returned ID: %llu" , id ) ;
if ( msg -> id != id ) {
VIR_DEBUG ( "Guest agent returned ID: %llu instead of %llu" , id , msg -> id ) ;
ret = 0 ;
goto cleanup ;
}
}
msg -> rxObject = obj ;
msg -> finished = 1 ;
obj = NULL ;
}
else {
VIR_DEBUG ( "Ignoring delayed reply" ) ;
}
ret = 0 ;
}
else {
virReportError ( VIR_ERR_INTERNAL_ERROR , _ ( "Unknown JSON reply '%s'" ) , line ) ;
}
cleanup : virJSONValueFree ( obj ) ;
return ret ;
} |
-6,580,451,576,689,963,000 | debian | 6 | 0 | static char * default_opaque_literal_tag ( tvbuff_t * tvb , guint32 offset , const char * token _U_ , guint8 codepage _U_ , guint32 * length ) {
guint32 data_len = tvb_get_guintvar ( tvb , offset , length ) ;
char * str = wmem_strdup_printf ( wmem_packet_scope ( ) , "(%d bytes of opaque data)" , data_len ) ;
* length += data_len ;
return str ;
} |
-1,123,689,860,280,933,400 | debian | 70 | 0 | static void auth_server_send_new_request ( struct auth_server_connection * conn , struct auth_client_request * request , const struct auth_request_info * info ) {
string_t * str ;
str = t_str_new ( 512 ) ;
str_printfa ( str , "AUTH\t%u\t" , request -> id ) ;
str_append_tabescaped ( str , info -> mech ) ;
str_append ( str , "\tservice=" ) ;
str_append_tabescaped ( str , info -> service ) ;
if ( ( info -> flags & AUTH_REQUEST_FLAG_SUPPORT_FINAL_RESP ) != 0 ) str_append ( str , "\tfinal-resp-ok" ) ;
if ( ( info -> flags & AUTH_REQUEST_FLAG_SECURED ) != 0 ) {
str_append ( str , "\tsecured" ) ;
if ( ( info -> flags & AUTH_REQUEST_FLAG_TRANSPORT_SECURITY_TLS ) != 0 ) str_append ( str , "=tls" ) ;
}
else {
i_assert ( ( info -> flags & AUTH_REQUEST_FLAG_TRANSPORT_SECURITY_TLS ) == 0 ) ;
}
if ( ( info -> flags & AUTH_REQUEST_FLAG_NO_PENALTY ) != 0 ) str_append ( str , "\tno-penalty" ) ;
if ( ( info -> flags & AUTH_REQUEST_FLAG_VALID_CLIENT_CERT ) != 0 ) str_append ( str , "\tvalid-client-cert" ) ;
if ( ( info -> flags & AUTH_REQUEST_FLAG_DEBUG ) != 0 ) str_append ( str , "\tdebug" ) ;
if ( info -> session_id != NULL ) {
str_append ( str , "\tsession=" ) ;
str_append_tabescaped ( str , info -> session_id ) ;
}
if ( info -> cert_username != NULL ) {
str_append ( str , "\tcert_username=" ) ;
str_append_tabescaped ( str , info -> cert_username ) ;
}
if ( info -> local_ip . family != 0 ) str_printfa ( str , "\tlip=%s" , net_ip2addr ( & info -> local_ip ) ) ;
if ( info -> remote_ip . family != 0 ) str_printfa ( str , "\trip=%s" , net_ip2addr ( & info -> remote_ip ) ) ;
if ( info -> local_port != 0 ) str_printfa ( str , "\tlport=%u" , info -> local_port ) ;
if ( info -> remote_port != 0 ) str_printfa ( str , "\trport=%u" , info -> remote_port ) ;
if ( info -> real_local_ip . family != 0 && ! net_ip_compare ( & info -> real_local_ip , & info -> local_ip ) ) {
str_printfa ( str , "\treal_lip=%s" , net_ip2addr ( & info -> real_local_ip ) ) ;
}
if ( info -> real_remote_ip . family != 0 && ! net_ip_compare ( & info -> real_remote_ip , & info -> remote_ip ) ) {
str_printfa ( str , "\treal_rip=%s" , net_ip2addr ( & info -> real_remote_ip ) ) ;
}
if ( info -> real_local_port != 0 && info -> real_local_port != info -> local_port ) str_printfa ( str , "\treal_lport=%u" , info -> real_local_port ) ;
if ( info -> real_remote_port != 0 && info -> real_remote_port != info -> remote_port ) str_printfa ( str , "\treal_rport=%u" , info -> real_remote_port ) ;
if ( info -> local_name != NULL && * info -> local_name != '\0' ) {
str_append ( str , "\tlocal_name=" ) ;
str_append_tabescaped ( str , info -> local_name ) ;
}
if ( info -> ssl_cipher_bits != 0 && info -> ssl_cipher != NULL ) {
str_append ( str , "\tssl_cipher=" ) ;
str_append_tabescaped ( str , info -> ssl_cipher ) ;
str_printfa ( str , "\tssl_cipher_bits=%u" , info -> ssl_cipher_bits ) ;
if ( info -> ssl_pfs != NULL ) {
str_append ( str , "\tssl_pfs=" ) ;
str_append_tabescaped ( str , info -> ssl_pfs ) ;
}
}
if ( info -> ssl_protocol != NULL ) {
str_append ( str , "\tssl_protocol=" ) ;
str_append_tabescaped ( str , info -> ssl_protocol ) ;
}
if ( info -> client_id != NULL && * info -> client_id != '\0' ) {
str_append ( str , "\tclient_id=" ) ;
str_append_tabescaped ( str , info -> client_id ) ;
}
if ( info -> forward_fields != NULL && * info -> forward_fields != '\0' ) {
str_append ( str , "\tforward_fields=" ) ;
str_append_tabescaped ( str , info -> forward_fields ) ;
}
if ( info -> initial_resp_base64 != NULL ) {
str_append ( str , "\tresp=" ) ;
str_append_tabescaped ( str , info -> initial_resp_base64 ) ;
}
str_append_c ( str , '\n' ) ;
if ( o_stream_send ( conn -> output , str_data ( str ) , str_len ( str ) ) < 0 ) i_error ( "Error sending request to auth server: %m" ) ;
} |
1,458,662,858,915,721,500 | debian | 21 | 0 | void tb_invalidate_phys_page_fast ( tb_page_addr_t start , int len ) {
PageDesc * p ;
int offset , b ;
# if 0 if ( 1 ) {
qemu_log ( "modifying code at 0x%x size=%d EIP=%x PC=%08x\n" , cpu_single_env -> mem_io_vaddr , len , cpu_single_env -> eip , cpu_single_env -> eip + ( intptr_t ) cpu_single_env -> segs [ R_CS ] . base ) ;
}
# endif p = page_find ( start >> TARGET_PAGE_BITS ) ;
if ( ! p ) {
return ;
}
if ( p -> code_bitmap ) {
offset = start & ~ TARGET_PAGE_MASK ;
b = p -> code_bitmap [ offset >> 3 ] >> ( offset & 7 ) ;
if ( b & ( ( 1 << len ) - 1 ) ) {
goto do_invalidate ;
}
}
else {
do_invalidate : tb_invalidate_phys_page_range ( start , start + len , 1 ) ;
}
} |
-7,455,544,248,455,991,000 | debian | 44 | 0 | int kvm_arch_process_async_events ( CPUState * cs ) {
X86CPU * cpu = X86_CPU ( cs ) ;
CPUX86State * env = & cpu -> env ;
if ( cs -> interrupt_request & CPU_INTERRUPT_MCE ) {
assert ( env -> mcg_cap ) ;
cs -> interrupt_request &= ~ CPU_INTERRUPT_MCE ;
kvm_cpu_synchronize_state ( cs ) ;
if ( env -> exception_injected == EXCP08_DBLE ) {
qemu_system_reset_request ( SHUTDOWN_CAUSE_GUEST_RESET ) ;
cs -> exit_request = 1 ;
return 0 ;
}
env -> exception_injected = EXCP12_MCHK ;
env -> has_error_code = 0 ;
cs -> halted = 0 ;
if ( kvm_irqchip_in_kernel ( ) && env -> mp_state == KVM_MP_STATE_HALTED ) {
env -> mp_state = KVM_MP_STATE_RUNNABLE ;
}
}
if ( ( cs -> interrupt_request & CPU_INTERRUPT_INIT ) && ! ( env -> hflags & HF_SMM_MASK ) ) {
kvm_cpu_synchronize_state ( cs ) ;
do_cpu_init ( cpu ) ;
}
if ( kvm_irqchip_in_kernel ( ) ) {
return 0 ;
}
if ( cs -> interrupt_request & CPU_INTERRUPT_POLL ) {
cs -> interrupt_request &= ~ CPU_INTERRUPT_POLL ;
apic_poll_irq ( cpu -> apic_state ) ;
}
if ( ( ( cs -> interrupt_request & CPU_INTERRUPT_HARD ) && ( env -> eflags & IF_MASK ) ) || ( cs -> interrupt_request & CPU_INTERRUPT_NMI ) ) {
cs -> halted = 0 ;
}
if ( cs -> interrupt_request & CPU_INTERRUPT_SIPI ) {
kvm_cpu_synchronize_state ( cs ) ;
do_cpu_sipi ( cpu ) ;
}
if ( cs -> interrupt_request & CPU_INTERRUPT_TPR ) {
cs -> interrupt_request &= ~ CPU_INTERRUPT_TPR ;
kvm_cpu_synchronize_state ( cs ) ;
apic_handle_tpr_access_report ( cpu -> apic_state , env -> eip , env -> tpr_access_type ) ;
}
return cs -> halted ;
} |
5,347,874,611,477,979,000 | chrome | 15 | 0 | static void test_simplesignal ( void ) {
struct event ev ;
struct itimerval itv ;
setup_test ( "Simple signal: " ) ;
signal_set ( & ev , SIGALRM , signal_cb , & ev ) ;
signal_add ( & ev , NULL ) ;
signal_del ( & ev ) ;
signal_add ( & ev , NULL ) ;
memset ( & itv , 0 , sizeof ( itv ) ) ;
itv . it_value . tv_sec = 1 ;
if ( setitimer ( ITIMER_REAL , & itv , NULL ) == - 1 ) goto skip_simplesignal ;
event_dispatch ( ) ;
skip_simplesignal : if ( signal_del ( & ev ) == - 1 ) test_ok = 0 ;
cleanup_test ( ) ;
} |
1,760,449,185,745,615,400 | debian | 5 | 0 | int TSHttpTxnIsWebsocket ( TSHttpTxn txnp ) {
sdk_assert ( sdk_sanity_check_txn ( txnp ) == TS_SUCCESS ) ;
HttpSM * sm = ( HttpSM * ) txnp ;
return sm -> t_state . is_websocket ;
} |
-8,925,552,398,357,902,000 | chrome | 6 | 0 | static void is_skippable ( int plane , int block , BLOCK_SIZE plane_bsize , TX_SIZE tx_size , void * argv ) {
struct is_skippable_args * args = argv ;
( void ) plane_bsize ;
( void ) tx_size ;
args -> skippable [ 0 ] &= ( ! args -> x -> plane [ plane ] . eobs [ block ] ) ;
} |
9,040,629,826,477,850,000 | debian | 23 | 0 | static inline void decode2x2 ( GetBitContext * gb , uint8_t * dst , int linesize ) {
int i , j , v [ 2 ] ;
switch ( get_bits ( gb , 2 ) ) {
case 1 : v [ 0 ] = get_bits ( gb , 8 ) ;
for ( j = 0 ;
j < 2 ;
j ++ ) memset ( dst + j * linesize , v [ 0 ] , 2 ) ;
break ;
case 2 : v [ 0 ] = get_bits ( gb , 8 ) ;
v [ 1 ] = get_bits ( gb , 8 ) ;
for ( j = 0 ;
j < 2 ;
j ++ ) for ( i = 0 ;
i < 2 ;
i ++ ) dst [ j * linesize + i ] = v [ get_bits1 ( gb ) ] ;
break ;
case 3 : for ( j = 0 ;
j < 2 ;
j ++ ) for ( i = 0 ;
i < 2 ;
i ++ ) dst [ j * linesize + i ] = get_bits ( gb , 8 ) ;
}
} |
3,599,206,110,384,554,500 | debian | 27 | 0 | int PEM_write_bio_ ## name ( BIO * bp , type * x ) ;
# define DECLARE_PEM_write_bio_const ( name , type ) int PEM_write_bio_ ## name ( BIO * bp , const type * x ) ;
# define DECLARE_PEM_write_cb_bio ( name , type ) int PEM_write_bio_ ## name ( BIO * bp , type * x , const EVP_CIPHER * enc , unsigned char * kstr , int klen , pem_password_cb * cb , void * u ) ;
# define DECLARE_PEM_write ( name , type ) DECLARE_PEM_write_bio ( name , type ) DECLARE_PEM_write_fp ( name , type ) # define DECLARE_PEM_write_const ( name , type ) DECLARE_PEM_write_bio_const ( name , type ) DECLARE_PEM_write_fp_const ( name , type ) # define DECLARE_PEM_write_cb ( name , type ) DECLARE_PEM_write_cb_bio ( name , type ) DECLARE_PEM_write_cb_fp ( name , type ) # define DECLARE_PEM_read ( name , type ) DECLARE_PEM_read_bio ( name , type ) DECLARE_PEM_read_fp ( name , type ) # define DECLARE_PEM_rw ( name , type ) DECLARE_PEM_read ( name , type ) DECLARE_PEM_write ( name , type ) # define DECLARE_PEM_rw_const ( name , type ) DECLARE_PEM_read ( name , type ) DECLARE_PEM_write_const ( name , type ) # define DECLARE_PEM_rw_cb ( name , type ) DECLARE_PEM_read ( name , type ) DECLARE_PEM_write_cb ( name , type ) typedef int pem_password_cb ( char * buf , int size , int rwflag , void * userdata ) ;
int PEM_get_EVP_CIPHER_INFO ( char * header , EVP_CIPHER_INFO * cipher ) ;
int PEM_do_header ( EVP_CIPHER_INFO * cipher , unsigned char * data , long * len , pem_password_cb * callback , void * u ) ;
int PEM_read_bio ( BIO * bp , char * * name , char * * header , unsigned char * * data , long * len ) ;
# define PEM_FLAG_SECURE 0x1 # define PEM_FLAG_EAY_COMPATIBLE 0x2 # define PEM_FLAG_ONLY_B64 0x4 int PEM_read_bio_ex ( BIO * bp , char * * name , char * * header , unsigned char * * data , long * len , unsigned int flags ) ;
int PEM_bytes_read_bio_secmem ( unsigned char * * pdata , long * plen , char * * pnm , const char * name , BIO * bp , pem_password_cb * cb , void * u ) ;
int PEM_write_bio ( BIO * bp , const char * name , const char * hdr , const unsigned char * data , long len ) ;
int PEM_bytes_read_bio ( unsigned char * * pdata , long * plen , char * * pnm , const char * name , BIO * bp , pem_password_cb * cb , void * u ) ;
void * PEM_ASN1_read_bio ( d2i_of_void * d2i , const char * name , BIO * bp , void * * x , pem_password_cb * cb , void * u ) ;
int PEM_ASN1_write_bio ( i2d_of_void * i2d , const char * name , BIO * bp , void * x , const EVP_CIPHER * enc , unsigned char * kstr , int klen , pem_password_cb * cb , void * u ) ;
STACK_OF ( X509_INFO ) * PEM_X509_INFO_read_bio ( BIO * bp , STACK_OF ( X509_INFO ) * sk , pem_password_cb * cb , void * u ) ;
int PEM_X509_INFO_write_bio ( BIO * bp , X509_INFO * xi , EVP_CIPHER * enc , unsigned char * kstr , int klen , pem_password_cb * cd , void * u ) ;
# ifndef OPENSSL_NO_STDIO int PEM_read ( FILE * fp , char * * name , char * * header , unsigned char * * data , long * len ) ;
int PEM_write ( FILE * fp , const char * name , const char * hdr , const unsigned char * data , long len ) ;
void * PEM_ASN1_read ( d2i_of_void * d2i , const char * name , FILE * fp , void * * x , pem_password_cb * cb , void * u ) ;
int PEM_ASN1_write ( i2d_of_void * i2d , const char * name , FILE * fp , void * x , const EVP_CIPHER * enc , unsigned char * kstr , int klen , pem_password_cb * callback , void * u ) ;
STACK_OF ( X509_INFO ) * PEM_X509_INFO_read ( FILE * fp , STACK_OF ( X509_INFO ) * sk , pem_password_cb * cb , void * u ) ;
# endif int PEM_SignInit ( EVP_MD_CTX * ctx , EVP_MD * type ) ;
int PEM_SignUpdate ( EVP_MD_CTX * ctx , unsigned char * d , unsigned int cnt ) ;
int PEM_SignFinal ( EVP_MD_CTX * ctx , unsigned char * sigret , unsigned int * siglen , EVP_PKEY * pkey ) ;
int PEM_def_callback ( char * buf , int num , int rwflag , void * userdata ) ;
void PEM_proc_type ( char * buf , int type ) ;
void PEM_dek_info ( char * buf , const char * type , int len , char * str ) ;
# include < openssl / symhacks . h > DECLARE_PEM_rw ( X509 , X509 ) DECLARE_PEM_rw ( X509_AUX , X509 ) DECLARE_PEM_rw ( X509_REQ , X509_REQ ) DECLARE_PEM_write ( X509_REQ_NEW , X509_REQ ) DECLARE_PEM_rw ( X509_CRL , X509_CRL ) DECLARE_PEM_rw ( PKCS7 , PKCS7 ) DECLARE_PEM_rw ( NETSCAPE_CERT_SEQUENCE , NETSCAPE_CERT_SEQUENCE ) DECLARE_PEM_rw ( PKCS8 , X509_SIG ) DECLARE_PEM_rw ( PKCS8_PRIV_KEY_INFO , PKCS8_PRIV_KEY_INFO ) # ifndef OPENSSL_NO_RSA DECLARE_PEM_rw_cb ( RSAPrivateKey , RSA ) DECLARE_PEM_rw_const ( RSAPublicKey , RSA ) DECLARE_PEM_rw ( RSA_PUBKEY , RSA ) # endif # ifndef OPENSSL_NO_DSA DECLARE_PEM_rw_cb ( DSAPrivateKey , DSA ) DECLARE_PEM_rw ( DSA_PUBKEY , DSA ) DECLARE_PEM_rw_const ( DSAparams , DSA ) # endif # ifndef OPENSSL_NO_EC DECLARE_PEM_rw_const ( ECPKParameters , EC_GROUP ) DECLARE_PEM_rw_cb ( ECPrivateKey , EC_KEY ) DECLARE_PEM_rw ( EC_PUBKEY , EC_KEY ) # endif # ifndef OPENSSL_NO_DH DECLARE_PEM_rw_const ( DHparams , DH ) DECLARE_PEM_write_const ( DHxparams , DH ) # endif DECLARE_PEM_rw_cb ( PrivateKey , EVP_PKEY ) DECLARE_PEM_rw ( PUBKEY , EVP_PKEY ) |
2,895,622,461,494,525,400 | debian | 17 | 0 | static void test_list_fields ( ) {
MYSQL_RES * result ;
int rc ;
myheader ( "test_list_fields" ) ;
rc = mysql_query ( mysql , "drop table if exists t1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "create table t1(c1 int primary key auto_increment, c2 char(10) default 'mysql')" ) ;
myquery ( rc ) ;
result = mysql_list_fields ( mysql , "t1" , NULL ) ;
mytest ( result ) ;
rc = my_process_result_set ( result ) ;
DIE_UNLESS ( rc == 0 ) ;
verify_prepare_field ( result , 0 , "c1" , "c1" , MYSQL_TYPE_LONG , "t1" , "t1" , current_db , 11 , "0" ) ;
verify_prepare_field ( result , 1 , "c2" , "c2" , MYSQL_TYPE_STRING , "t1" , "t1" , current_db , 10 , "mysql" ) ;
mysql_free_result ( result ) ;
myquery ( mysql_query ( mysql , "drop table t1" ) ) ;
} |
2,064,081,176,034,684,200 | debian | 24 | 0 | static int matroska_probe ( AVProbeData * p ) {
uint64_t total = 0 ;
int len_mask = 0x80 , size = 1 , n = 1 , i ;
if ( AV_RB32 ( p -> buf ) != EBML_ID_HEADER ) return 0 ;
total = p -> buf [ 4 ] ;
while ( size <= 8 && ! ( total & len_mask ) ) {
size ++ ;
len_mask >>= 1 ;
}
if ( size > 8 ) return 0 ;
total &= ( len_mask - 1 ) ;
while ( n < size ) total = ( total << 8 ) | p -> buf [ 4 + n ++ ] ;
if ( p -> buf_size < 4 + size + total ) return 0 ;
for ( i = 0 ;
i < FF_ARRAY_ELEMS ( matroska_doctypes ) ;
i ++ ) {
int probelen = strlen ( matroska_doctypes [ i ] ) ;
if ( total < probelen ) continue ;
for ( n = 4 + size ;
n <= 4 + size + total - probelen ;
n ++ ) if ( ! memcmp ( p -> buf + n , matroska_doctypes [ i ] , probelen ) ) return AVPROBE_SCORE_MAX ;
}
return AVPROBE_SCORE_EXTENSION ;
} |
-398,565,394,354,770,750 | debian | 4 | 0 | static void ohci_eof_timer ( OHCIState * ohci ) {
ohci -> sof_time = qemu_clock_get_ns ( QEMU_CLOCK_VIRTUAL ) ;
timer_mod ( ohci -> eof_timer , ohci -> sof_time + usb_frame_time ) ;
} |
7,092,216,800,726,730,000 | debian | 4 | 0 | static int dissect_h245_H261VideoMode ( 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_H261VideoMode , H261VideoMode_sequence ) ;
return offset ;
} |
7,399,683,071,036,019,000 | debian | 17 | 0 | static void pdo_stmt_iter_move_forwards ( zend_object_iterator * iter TSRMLS_DC ) {
struct php_pdo_iterator * I = ( struct php_pdo_iterator * ) iter -> data ;
if ( I -> fetch_ahead ) {
zval_ptr_dtor ( & I -> fetch_ahead ) ;
I -> fetch_ahead = NULL ;
}
MAKE_STD_ZVAL ( I -> fetch_ahead ) ;
if ( ! do_fetch ( I -> stmt , TRUE , I -> fetch_ahead , PDO_FETCH_USE_DEFAULT , PDO_FETCH_ORI_NEXT , 0 , 0 TSRMLS_CC ) ) {
pdo_stmt_t * stmt = I -> stmt ;
PDO_HANDLE_STMT_ERR ( ) ;
I -> key = ( ulong ) - 1 ;
FREE_ZVAL ( I -> fetch_ahead ) ;
I -> fetch_ahead = NULL ;
return ;
}
I -> key ++ ;
} |
794,575,292,121,248,500 | debian | 31 | 1 | static void voutf ( struct GlobalConfig * config , const char * prefix , const char * fmt , va_list ap ) {
size_t width = ( 79 - strlen ( prefix ) ) ;
if ( ! config -> mute ) {
size_t len ;
char * ptr ;
char * print_buffer ;
print_buffer = curlx_mvaprintf ( fmt , ap ) ;
if ( ! print_buffer ) return ;
len = strlen ( print_buffer ) ;
ptr = print_buffer ;
while ( len > 0 ) {
fputs ( prefix , config -> errors ) ;
if ( len > width ) {
size_t cut = width - 1 ;
while ( ! ISSPACE ( ptr [ cut ] ) && cut ) {
cut -- ;
}
if ( 0 == cut ) cut = width - 1 ;
( void ) fwrite ( ptr , cut + 1 , 1 , config -> errors ) ;
fputs ( "\n" , config -> errors ) ;
ptr += cut + 1 ;
len -= cut ;
}
else {
fputs ( ptr , config -> errors ) ;
len = 0 ;
}
}
curl_free ( print_buffer ) ;
}
} |
313,627,013,719,508,800 | debian | 3 | 0 | static inline PixelTrait GetPixelGreenTraits ( const Image * restrict image ) {
return ( image -> channel_map [ GreenPixelChannel ] . traits ) ;
} |
5,357,882,892,791,796,000 | debian | 3 | 0 | static void e1000e_set_fcrth ( E1000ECore * core , int index , uint32_t val ) {
core -> mac [ FCRTH ] = val & 0xFFF8 ;
} |
355,220,887,711,506,900 | debian | 43 | 0 | double get_variable_numdistinct ( VariableStatData * vardata , bool * isdefault ) {
double stadistinct ;
double stanullfrac = 0.0 ;
double ntuples ;
* isdefault = false ;
if ( HeapTupleIsValid ( vardata -> statsTuple ) ) {
Form_pg_statistic stats ;
stats = ( Form_pg_statistic ) GETSTRUCT ( vardata -> statsTuple ) ;
stadistinct = stats -> stadistinct ;
stanullfrac = stats -> stanullfrac ;
}
else if ( vardata -> vartype == BOOLOID ) {
stadistinct = 2.0 ;
}
else {
if ( vardata -> var && IsA ( vardata -> var , Var ) ) {
switch ( ( ( Var * ) vardata -> var ) -> varattno ) {
case ObjectIdAttributeNumber : case SelfItemPointerAttributeNumber : stadistinct = - 1.0 ;
break ;
case TableOidAttributeNumber : stadistinct = 1.0 ;
break ;
default : stadistinct = 0.0 ;
break ;
}
}
else stadistinct = 0.0 ;
}
if ( vardata -> isunique ) stadistinct = - 1.0 * ( 1.0 - stanullfrac ) ;
if ( stadistinct > 0.0 ) return clamp_row_est ( stadistinct ) ;
if ( vardata -> rel == NULL ) {
* isdefault = true ;
return DEFAULT_NUM_DISTINCT ;
}
ntuples = vardata -> rel -> tuples ;
if ( ntuples <= 0.0 ) {
* isdefault = true ;
return DEFAULT_NUM_DISTINCT ;
}
if ( stadistinct < 0.0 ) return clamp_row_est ( - stadistinct * ntuples ) ;
if ( ntuples < DEFAULT_NUM_DISTINCT ) return clamp_row_est ( ntuples ) ;
* isdefault = true ;
return DEFAULT_NUM_DISTINCT ;
} |
-1,335,877,942,018,854,400 | chrome | 3 | 0 | IN_PROC_BROWSER_TEST_F ( UnloadTest , BrowserCloseInfiniteBeforeUnload ) {
LoadUrlAndQuitBrowser ( INFINITE_BEFORE_UNLOAD_HTML , "infinitebeforeunload" ) ;
} |
-6,024,601,983,167,899,000 | debian | 13 | 0 | static LaunchLocation * find_launch_location_for_file ( GList * list , NautilusFile * file ) {
LaunchLocation * location ;
GList * l ;
for ( l = list ;
l != NULL ;
l = l -> next ) {
location = l -> data ;
if ( location -> file == file ) {
return location ;
}
}
return NULL ;
} |
3,599,206,110,384,554,500 | debian | 24 | 1 | 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 ) |
6,336,384,260,629,386,000 | debian | 90 | 0 | void proto_register_zbee_zcl_part ( void ) {
guint8 i , j ;
static hf_register_info hf [ ] = {
{
& hf_zbee_zcl_part_attr_id , {
"Attribute" , "zbee_zcl_general.part.attr_id" , FT_UINT16 , BASE_HEX , VALS ( zbee_zcl_part_attr_names ) , 0x0 , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_srv_tx_cmd_id , {
"Command" , "zbee_zcl_general.part.cmd.srv_tx.id" , FT_UINT8 , BASE_HEX , VALS ( zbee_zcl_part_srv_tx_cmd_names ) , 0x0 , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_srv_rx_cmd_id , {
"Command" , "zbee_zcl_general.part.cmd.srv_rx.id" , FT_UINT8 , BASE_HEX , VALS ( zbee_zcl_part_srv_rx_cmd_names ) , 0x0 , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_opt , {
"Fragmentation Options" , "zbee_zcl_general.part.opt" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_opt_first_block , {
"First Block" , "zbee_zcl_general.part.opt.first_block" , FT_UINT8 , BASE_HEX , NULL , ZBEE_ZCL_PART_OPT_1_BLOCK , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_opt_indic_len , {
"Indicator length" , "zbee_zcl_general.part.opt.indic_len" , FT_UINT8 , BASE_DEC , VALS ( zbee_zcl_part_id_length_names ) , ZBEE_ZCL_PART_OPT_INDIC_LEN , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_opt_res , {
"Reserved" , "zbee_zcl_general.part.opt.res" , FT_UINT8 , BASE_HEX , NULL , ZBEE_ZCL_PART_OPT_RESERVED , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_first_frame_id , {
"First Frame ID" , "zbee_zcl_general.part.first_frame_id" , FT_UINT16 , BASE_DEC , NULL , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_part_indicator , {
"Partition Indicator" , "zbee_zcl_general.part.part_indicator" , FT_UINT16 , BASE_DEC , NULL , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_part_frame_len , {
"Partition Frame Length" , "zbee_zcl_general.part.part_frame_length" , FT_UINT8 , BASE_DEC , NULL , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_part_frame , {
"Partition Frame" , "zbee_zcl_general.part.part_frame" , FT_BYTES , SEP_COLON , NULL , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_partitioned_cluster_id , {
"Partitioned Cluster ID" , "zbee_zcl_general.part.part_cluster_id" , FT_UINT16 , BASE_HEX , VALS ( zbee_aps_cid_names ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_ack_opt , {
"Ack Options" , "zbee_zcl_general.ack_opt.part" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_ack_opt_nack_id_len , {
"Nack Id Length" , "zbee_zcl_general.ack_opt.part.nack_id.len" , FT_UINT8 , BASE_HEX , VALS ( zbee_zcl_part_id_length_names ) , ZBEE_ZCL_PART_ACK_OPT_NACK_LEN , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_ack_opt_res , {
"Reserved" , "zbee_zcl_general.part.ack_opt.reserved" , FT_UINT8 , BASE_HEX , NULL , ZBEE_ZCL_PART_ACK_OPT_RESERVED , NULL , HFILL }
}
, {
& hf_zbee_zcl_part_nack_id , {
"Nack Id" , "zbee_zcl_general.part.nack_id" , FT_UINT16 , BASE_DEC , NULL , 0x00 , NULL , HFILL }
}
}
;
gint * ett [ ZBEE_ZCL_PART_NUM_ETT ] ;
ett [ 0 ] = & ett_zbee_zcl_part ;
ett [ 1 ] = & ett_zbee_zcl_part_fragm_options ;
ett [ 2 ] = & ett_zbee_zcl_part_ack_opts ;
for ( i = 0 , j = ZBEE_ZCL_PART_NUM_GENERIC_ETT ;
i < ZBEE_ZCL_PART_NUM_NACK_ID_ETT ;
i ++ , j ++ ) {
ett_zbee_zcl_part_nack_id_list [ i ] = - 1 ;
ett [ j ] = & ett_zbee_zcl_part_nack_id_list [ i ] ;
}
for ( i = 0 ;
i < ZBEE_ZCL_PART_NUM_ATTRS_ID_ETT ;
i ++ , j ++ ) {
ett_zbee_zcl_part_attrs_id_list [ i ] = - 1 ;
ett [ j ] = & ett_zbee_zcl_part_attrs_id_list [ i ] ;
}
proto_zbee_zcl_part = proto_register_protocol ( "ZigBee ZCL Partition" , "ZCL Partition" , ZBEE_PROTOABBREV_ZCL_PART ) ;
proto_register_field_array ( proto_zbee_zcl_part , hf , array_length ( hf ) ) ;
proto_register_subtree_array ( ett , array_length ( ett ) ) ;
register_dissector ( ZBEE_PROTOABBREV_ZCL_PART , dissect_zbee_zcl_part , proto_zbee_zcl_part ) ;
} |
2,895,622,461,494,525,400 | debian | 96 | 0 | static void test_bug17667 ( ) {
int rc ;
MYSQL_STMT * stmt ;
enum query_type {
QT_NORMAL , QT_PREPARED }
;
struct buffer_and_length {
enum query_type qt ;
const char * buffer ;
const uint length ;
}
statements [ ] = {
{
QT_NORMAL , "drop table if exists bug17667" , 29 }
, {
QT_NORMAL , "create table bug17667 (c varchar(20))" , 37 }
, {
QT_NORMAL , "insert into bug17667 (c) values ('regular') /* NUL=\0 with comment */" , 68 }
, {
QT_PREPARED , "insert into bug17667 (c) values ('prepared') /* NUL=\0 with comment */" , 69 , }
, {
QT_NORMAL , "insert into bug17667 (c) values ('NUL=\0 in value')" , 50 }
, {
QT_NORMAL , "insert into bug17667 (c) values ('5 NULs=\0\0\0\0\0')" , 48 }
, {
QT_PREPARED , "insert into bug17667 (c) values ('6 NULs=\0\0\0\0\0\0')" , 50 }
, {
QT_NORMAL , "/* NUL=\0 with comment */ insert into bug17667 (c) values ('encore')" , 67 }
, {
QT_NORMAL , "drop table bug17667" , 19 }
, {
QT_NORMAL , NULL , 0 }
}
;
struct buffer_and_length * statement_cursor ;
FILE * log_file ;
char * master_log_filename ;
myheader ( "test_bug17667" ) ;
master_log_filename = ( char * ) malloc ( strlen ( opt_vardir ) + strlen ( "/log/master.log" ) + 1 ) ;
strxmov ( master_log_filename , opt_vardir , "/log/master.log" , NullS ) ;
if ( ! opt_silent ) printf ( "Opening '%s'\n" , master_log_filename ) ;
log_file = my_fopen ( master_log_filename , ( int ) ( O_RDONLY | O_BINARY ) , MYF ( 0 ) ) ;
free ( master_log_filename ) ;
if ( log_file == NULL ) {
if ( ! opt_silent ) {
printf ( "Could not find the log file, VARDIR/log/master.log, so " "test_bug17667 is not run.\n" "Run test from the mysql-test/mysql-test-run* program to set up " "correct environment for this test.\n\n" ) ;
}
return ;
}
enable_query_logs ( 1 ) ;
for ( statement_cursor = statements ;
statement_cursor -> buffer != NULL ;
statement_cursor ++ ) {
if ( statement_cursor -> qt == QT_NORMAL ) {
rc = mysql_real_query ( mysql , statement_cursor -> buffer , statement_cursor -> length ) ;
myquery ( rc ) ;
}
else if ( statement_cursor -> qt == QT_PREPARED ) {
stmt = mysql_stmt_init ( mysql ) ;
rc = mysql_stmt_prepare ( stmt , statement_cursor -> buffer , statement_cursor -> length ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
mysql_stmt_close ( stmt ) ;
}
else {
DIE_UNLESS ( 0 == 1 ) ;
}
}
rc = mysql_query ( mysql , "flush logs" ) ;
myquery ( rc ) ;
for ( statement_cursor = statements ;
statement_cursor -> buffer != NULL ;
statement_cursor ++ ) {
int expected_hits = 1 , hits = 0 ;
char line_buffer [ MAX_TEST_QUERY_LENGTH * 2 ] ;
if ( statement_cursor -> qt == QT_PREPARED ) expected_hits ++ ;
do {
do {
memset ( line_buffer , '/' , MAX_TEST_QUERY_LENGTH * 2 ) ;
if ( fgets ( line_buffer , MAX_TEST_QUERY_LENGTH * 2 , log_file ) == NULL ) {
if ( feof ( log_file ) ) DIE ( "Found EOF before all statements where found" ) ;
fprintf ( stderr , "Got error %d while reading from file\n" , ferror ( log_file ) ) ;
DIE ( "Read error" ) ;
}
}
while ( my_memmem ( line_buffer , MAX_TEST_QUERY_LENGTH * 2 , statement_cursor -> buffer , statement_cursor -> length ) == NULL ) ;
hits ++ ;
}
while ( hits < expected_hits ) ;
if ( ! opt_silent ) printf ( "Found statement starting with \"%s\"\n" , statement_cursor -> buffer ) ;
}
restore_query_logs ( ) ;
if ( ! opt_silent ) printf ( "success. All queries found intact in the log.\n" ) ;
my_fclose ( log_file , MYF ( 0 ) ) ;
} |
1,760,449,185,745,615,400 | debian | 18 | 0 | TSReturnCode TSHttpTxnCacheLookupStatusGet ( TSHttpTxn txnp , int * lookup_status ) {
sdk_assert ( sdk_sanity_check_txn ( txnp ) == TS_SUCCESS ) ;
sdk_assert ( sdk_sanity_check_null_ptr ( ( void * ) lookup_status ) == TS_SUCCESS ) ;
HttpSM * sm = ( HttpSM * ) txnp ;
switch ( sm -> t_state . cache_lookup_result ) {
case HttpTransact : : CACHE_LOOKUP_MISS : case HttpTransact : : CACHE_LOOKUP_DOC_BUSY : * lookup_status = TS_CACHE_LOOKUP_MISS ;
break ;
case HttpTransact : : CACHE_LOOKUP_HIT_STALE : * lookup_status = TS_CACHE_LOOKUP_HIT_STALE ;
break ;
case HttpTransact : : CACHE_LOOKUP_HIT_WARNING : case HttpTransact : : CACHE_LOOKUP_HIT_FRESH : * lookup_status = TS_CACHE_LOOKUP_HIT_FRESH ;
break ;
case HttpTransact : : CACHE_LOOKUP_SKIPPED : * lookup_status = TS_CACHE_LOOKUP_SKIPPED ;
break ;
case HttpTransact : : CACHE_LOOKUP_NONE : default : return TS_ERROR ;
}
;
return TS_SUCCESS ;
} |
-2,242,211,406,757,466,600 | debian | 266 | 1 | static gint parse_arg ( tvbuff_t * tvb , packet_info * pinfo , proto_item * header_item , guint encoding , gint offset , proto_tree * field_tree , gboolean is_reply_to , guint8 type_id , guint8 field_code , guint8 * * signature , guint8 * signature_length , gint field_starting_offset ) {
gint length ;
gint padding_start ;
const gchar * header_type_name = NULL ;
switch ( type_id ) {
case ARG_INVALID : header_type_name = "invalid" ;
offset = round_to_8byte ( offset + 1 , field_starting_offset ) ;
break ;
case ARG_ARRAY : {
static gchar bad_array_format [ ] = "BAD DATA: Array length (in bytes) is %d. Remaining packet length is %d." ;
proto_item * item ;
proto_tree * tree ;
guint8 * sig_saved ;
gint starting_offset ;
gint number_of_items = 0 ;
guint8 remaining_sig_length = * signature_length ;
gint packet_length = ( gint ) tvb_reported_length ( tvb ) ;
header_type_name = "array" ;
if ( * signature == NULL || * signature_length < 1 ) {
col_add_fstr ( pinfo -> cinfo , COL_INFO , "BAD DATA: A %s argument needs a signature." , header_type_name ) ;
return tvb_reported_length ( tvb ) ;
}
sig_saved = ( * signature ) + 1 ;
padding_start = offset ;
offset = round_to_4byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
length = ( gint ) get_uint32 ( tvb , offset , encoding ) ;
padding_start = offset + 4 ;
starting_offset = pad_according_to_type ( padding_start , field_starting_offset , packet_length , * sig_saved ) ;
if ( length < 0 || length > MAX_ARRAY_LEN || starting_offset + length > packet_length ) {
col_add_fstr ( pinfo -> cinfo , COL_INFO , bad_array_format , length , tvb_reported_length_remaining ( tvb , starting_offset ) ) ;
return tvb_reported_length ( tvb ) ;
}
item = proto_tree_add_item ( field_tree , hf_alljoyn_mess_body_array , tvb , offset , ( starting_offset - offset ) + length , encoding ) ;
tree = proto_item_add_subtree ( item , ett_alljoyn_mess_body_parameters ) ;
offset = starting_offset ;
add_padding_item ( padding_start , offset , tvb , tree ) ;
if ( 0 == length ) {
advance_to_end_of_signature ( signature , & remaining_sig_length ) ;
}
else {
while ( ( offset - starting_offset ) < length ) {
guint8 * sig_pointer ;
number_of_items ++ ;
sig_pointer = sig_saved ;
remaining_sig_length = * signature_length - 1 ;
offset = parse_arg ( tvb , pinfo , header_item , encoding , offset , tree , is_reply_to , * sig_pointer , field_code , & sig_pointer , & remaining_sig_length , field_starting_offset ) ;
* signature = sig_pointer ;
}
}
* signature_length = remaining_sig_length ;
if ( item ) {
proto_item_append_text ( item , " of %d '%c' elements" , number_of_items , * sig_saved ) ;
}
}
break ;
case ARG_BOOLEAN : header_type_name = "boolean" ;
padding_start = offset ;
offset = round_to_4byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
proto_tree_add_item ( field_tree , hf_alljoyn_boolean , tvb , offset , 4 , encoding ) ;
offset += 4 ;
break ;
case ARG_DOUBLE : header_type_name = "IEEE 754 double" ;
padding_start = offset ;
offset = round_to_8byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
proto_tree_add_item ( field_tree , hf_alljoyn_double , tvb , offset , 8 , encoding ) ;
offset += 8 ;
break ;
case ARG_SIGNATURE : header_type_name = "signature" ;
* signature_length = tvb_get_guint8 ( tvb , offset ) ;
if ( * signature_length + 2 > tvb_reported_length_remaining ( tvb , offset ) ) {
gint bytes_left = tvb_reported_length_remaining ( tvb , offset ) ;
col_add_fstr ( pinfo -> cinfo , COL_INFO , "BAD DATA: Signature length is %d. Only %d bytes left in packet." , ( gint ) ( * signature_length ) , bytes_left ) ;
return tvb_reported_length ( tvb ) ;
}
length = * signature_length + 1 ;
proto_tree_add_item ( field_tree , hf_alljoyn_mess_body_signature_length , tvb , offset , 1 , encoding ) ;
offset += 1 ;
proto_tree_add_item ( field_tree , hf_alljoyn_mess_body_signature , tvb , offset , length , ENC_ASCII | ENC_NA ) ;
* signature = tvb_get_string_enc ( wmem_packet_scope ( ) , tvb , offset , length , ENC_ASCII ) ;
if ( HDR_SIGNATURE == field_code ) {
col_append_fstr ( pinfo -> cinfo , COL_INFO , " (%s)" , * signature ) ;
}
offset += length ;
break ;
case ARG_HANDLE : header_type_name = "socket handle" ;
padding_start = offset ;
offset = round_to_4byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
proto_tree_add_item ( field_tree , hf_alljoyn_handle , tvb , offset , 4 , encoding ) ;
offset += 4 ;
break ;
case ARG_INT32 : header_type_name = "int32" ;
padding_start = offset ;
offset = round_to_4byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
proto_tree_add_item ( field_tree , hf_alljoyn_int32 , tvb , offset , 4 , encoding ) ;
offset += 4 ;
break ;
case ARG_INT16 : header_type_name = "int16" ;
padding_start = offset ;
offset = round_to_2byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
proto_tree_add_item ( field_tree , hf_alljoyn_int16 , tvb , offset , 2 , encoding ) ;
offset += 2 ;
break ;
case ARG_OBJ_PATH : header_type_name = "object path" ;
length = get_uint32 ( tvb , offset , encoding ) + 1 ;
if ( length < 0 || length > MAX_ARRAY_LEN || length + 4 > tvb_reported_length_remaining ( tvb , offset ) ) {
col_add_fstr ( pinfo -> cinfo , COL_INFO , "BAD DATA: Object path length is %d. Only %d bytes left in packet." , length , tvb_reported_length_remaining ( tvb , offset + 4 ) ) ;
return tvb_reported_length ( tvb ) ;
}
proto_tree_add_item ( field_tree , hf_alljoyn_uint32 , tvb , offset , 4 , encoding ) ;
offset += 4 ;
proto_tree_add_item ( field_tree , hf_alljoyn_string_data , tvb , offset , length , ENC_ASCII | ENC_NA ) ;
offset += length ;
break ;
case ARG_UINT16 : header_type_name = "uint16" ;
padding_start = offset ;
offset = round_to_2byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
proto_tree_add_item ( field_tree , hf_alljoyn_uint16 , tvb , offset , 2 , encoding ) ;
offset += 2 ;
break ;
case ARG_STRING : header_type_name = "string" ;
padding_start = offset ;
offset = round_to_4byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
proto_tree_add_item ( field_tree , hf_alljoyn_string_size_32bit , tvb , offset , 4 , encoding ) ;
length = ( gint ) get_uint32 ( tvb , offset , encoding ) ;
if ( length < 0 || length > tvb_reported_length_remaining ( tvb , offset ) ) {
col_add_fstr ( pinfo -> cinfo , COL_INFO , "BAD DATA: String length is %d. Remaining packet length is %d." , length , ( gint ) tvb_reported_length_remaining ( tvb , offset ) ) ;
return tvb_reported_length ( tvb ) ;
}
length += 1 ;
offset += 4 ;
proto_tree_add_item ( field_tree , hf_alljoyn_string_data , tvb , offset , length , ENC_UTF_8 | ENC_NA ) ;
if ( HDR_MEMBER == field_code ) {
guint8 * member_name ;
member_name = tvb_get_string_enc ( wmem_packet_scope ( ) , tvb , offset , length , ENC_UTF_8 ) ;
col_append_fstr ( pinfo -> cinfo , COL_INFO , " %s" , member_name ) ;
}
offset += length ;
break ;
case ARG_UINT64 : header_type_name = "uint64" ;
padding_start = offset ;
offset = round_to_8byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
proto_tree_add_item ( field_tree , hf_alljoyn_uint64 , tvb , offset , 8 , encoding ) ;
offset += 8 ;
break ;
case ARG_UINT32 : header_type_name = "uint32" ;
padding_start = offset ;
offset = round_to_4byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
if ( is_reply_to ) {
static const gchar format [ ] = " Replies to: %09u" ;
guint32 replies_to ;
replies_to = get_uint32 ( tvb , offset , encoding ) ;
col_append_fstr ( pinfo -> cinfo , COL_INFO , format , replies_to ) ;
if ( header_item ) {
proto_item * item ;
item = proto_tree_add_item ( field_tree , hf_alljoyn_uint32 , tvb , offset , 4 , encoding ) ;
proto_item_set_text ( item , format + 1 , replies_to ) ;
}
}
else {
proto_tree_add_item ( field_tree , hf_alljoyn_uint32 , tvb , offset , 4 , encoding ) ;
}
offset += 4 ;
break ;
case ARG_VARIANT : {
proto_item * item ;
proto_tree * tree ;
guint8 * sig_saved ;
guint8 * sig_pointer ;
guint8 variant_sig_length ;
header_type_name = "variant" ;
variant_sig_length = tvb_get_guint8 ( tvb , offset ) ;
length = variant_sig_length ;
if ( length > tvb_reported_length_remaining ( tvb , offset ) ) {
gint bytes_left = tvb_reported_length_remaining ( tvb , offset ) ;
col_add_fstr ( pinfo -> cinfo , COL_INFO , "BAD DATA: Variant signature length is %d. Only %d bytes left in packet." , length , bytes_left ) ;
offset = tvb_reported_length ( tvb ) ;
}
length += 1 ;
item = proto_tree_add_item ( field_tree , hf_alljoyn_mess_body_variant , tvb , offset , 4 , encoding ) ;
tree = proto_item_add_subtree ( item , ett_alljoyn_mess_body_parameters ) ;
proto_tree_add_item ( tree , hf_alljoyn_mess_body_signature_length , tvb , offset , 1 , encoding ) ;
offset += 1 ;
tree = proto_item_add_subtree ( item , ett_alljoyn_mess_body_parameters ) ;
proto_tree_add_item ( tree , hf_alljoyn_mess_body_signature , tvb , offset , length , ENC_ASCII | ENC_NA ) ;
sig_saved = tvb_get_string_enc ( wmem_packet_scope ( ) , tvb , offset , length , ENC_ASCII ) ;
offset += length ;
sig_pointer = sig_saved ;
while ( ( ( sig_pointer - sig_saved ) < ( length - 1 ) ) && ( tvb_reported_length_remaining ( tvb , offset ) > 0 ) ) {
proto_item_append_text ( item , "%c" , * sig_pointer ) ;
offset = parse_arg ( tvb , pinfo , header_item , encoding , offset , tree , is_reply_to , * sig_pointer , field_code , & sig_pointer , & variant_sig_length , field_starting_offset ) ;
}
proto_item_append_text ( item , "'" ) ;
proto_item_set_end ( item , tvb , offset ) ;
}
break ;
case ARG_INT64 : header_type_name = "int64" ;
padding_start = offset ;
offset = round_to_8byte ( offset , field_starting_offset ) ;
add_padding_item ( padding_start , offset , tvb , field_tree ) ;
proto_tree_add_item ( field_tree , hf_alljoyn_int64 , tvb , offset , 8 , encoding ) ;
offset += 8 ;
break ;
case ARG_BYTE : header_type_name = "byte" ;
proto_tree_add_item ( field_tree , hf_alljoyn_uint8 , tvb , offset , 1 , encoding ) ;
offset += 1 ;
break ;
case ARG_DICT_ENTRY : case ARG_STRUCT : {
proto_item * item ;
proto_tree * tree ;
int hf ;
guint8 type_stop ;
if ( type_id == ARG_STRUCT ) {
header_type_name = "structure" ;
hf = hf_alljoyn_mess_body_structure ;
type_stop = ')' ;
}
else {
header_type_name = "dictionary" ;
hf = hf_alljoyn_mess_body_dictionary_entry ;
type_stop = '}
' ;
}
if ( * signature == NULL || * signature_length < 1 ) {
col_add_fstr ( pinfo -> cinfo , COL_INFO , "BAD DATA: A %s argument needs a signature." , header_type_name ) ;
return tvb_reported_length ( tvb ) ;
}
item = proto_tree_add_item ( field_tree , hf , tvb , offset , 4 , encoding ) ;
append_struct_signature ( item , * signature , * signature_length , type_stop ) ;
tree = proto_item_add_subtree ( item , ett_alljoyn_mess_body_parameters ) ;
padding_start = offset ;
offset = pad_according_to_type ( offset , field_starting_offset , tvb_reported_length ( tvb ) , type_id ) ;
add_padding_item ( padding_start , offset , tvb , tree ) ;
( * signature ) ++ ;
( * signature_length ) -- ;
while ( * signature && * * signature && * * signature != type_stop && tvb_reported_length_remaining ( tvb , offset ) > 0 ) {
offset = parse_arg ( tvb , pinfo , header_item , encoding , offset , tree , is_reply_to , * * signature , field_code , signature , signature_length , field_starting_offset ) ;
}
proto_item_set_end ( item , tvb , offset ) ;
}
break ;
default : header_type_name = "unexpected" ;
offset = tvb_reported_length ( tvb ) ;
break ;
}
if ( * signature && ARG_ARRAY != type_id && HDR_INVALID == field_code ) {
( * signature ) ++ ;
( * signature_length ) -- ;
}
if ( NULL != header_item && NULL != header_type_name ) {
proto_item_append_text ( header_item , "%s" , header_type_name ) ;
}
if ( offset > ( gint ) tvb_reported_length ( tvb ) ) {
offset = ( gint ) tvb_reported_length ( tvb ) ;
}
return offset ;
} |
8,849,962,823,026,424,000 | debian | 18 | 0 | static gboolean qio_channel_websock_flush ( QIOChannel * ioc , GIOCondition condition , gpointer user_data ) {
QIOChannelWebsock * wioc = QIO_CHANNEL_WEBSOCK ( user_data ) ;
ssize_t ret ;
if ( condition & G_IO_OUT ) {
ret = qio_channel_websock_write_wire ( wioc , & wioc -> io_err ) ;
if ( ret < 0 ) {
goto cleanup ;
}
}
if ( condition & G_IO_IN ) {
ret = qio_channel_websock_read_wire ( wioc , & wioc -> io_err ) ;
if ( ret < 0 ) {
goto cleanup ;
}
}
cleanup : qio_channel_websock_set_watch ( wioc ) ;
return FALSE ;
} |
-6,351,630,154,286,607,000 | debian | 20 | 0 | static void unfold_conds ( struct condition * cnd , u_int32 a , u_int32 b ) {
struct unfold_elm * ue = NULL ;
do {
ef_debug ( 1 , "?" ) ;
SAFE_CALLOC ( ue , 1 , sizeof ( struct unfold_elm ) ) ;
memcpy ( & ue -> fop , & cnd -> fop , sizeof ( struct filter_op ) ) ;
TAILQ_INSERT_TAIL ( & unfolded_tree , ue , next ) ;
SAFE_CALLOC ( ue , 1 , sizeof ( struct unfold_elm ) ) ;
if ( cnd -> op == COND_OR ) {
ue -> fop . opcode = FOP_JTRUE ;
ue -> fop . op . jmp = a ;
}
else {
ue -> fop . opcode = FOP_JFALSE ;
ue -> fop . op . jmp = b ;
}
TAILQ_INSERT_TAIL ( & unfolded_tree , ue , next ) ;
}
while ( ( cnd = cnd -> next ) ) ;
} |
4,489,017,523,191,997,000 | debian | 4 | 0 | static int dissect_h225_SEQUENCE_OF_DisplayName ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence_of ( tvb , offset , actx , tree , hf_index , ett_h225_SEQUENCE_OF_DisplayName , SEQUENCE_OF_DisplayName_sequence_of ) ;
return offset ;
} |
-4,525,941,100,783,780,000 | debian | 3 | 0 | static cmsBool isfirstidchar ( int c ) {
return ! isdigit ( c ) && ismiddle ( c ) ;
} |
-1,102,844,685,921,778,700 | debian | 26 | 0 | static int best_effort_strncat_from_utf16 ( struct archive_string * as , const void * _p , size_t bytes , struct archive_string_conv * sc , int be ) {
const char * utf16 = ( const char * ) _p ;
char * mbs ;
uint32_t uc ;
int n , ret ;
( void ) sc ;
ret = 0 ;
if ( archive_string_ensure ( as , as -> length + bytes + 1 ) == NULL ) return ( - 1 ) ;
mbs = as -> s + as -> length ;
while ( ( n = utf16_to_unicode ( & uc , utf16 , bytes , be ) ) != 0 ) {
if ( n < 0 ) {
n *= - 1 ;
ret = - 1 ;
}
bytes -= n ;
utf16 += n ;
if ( uc > 127 ) {
* mbs ++ = '?' ;
ret = - 1 ;
}
else * mbs ++ = ( char ) uc ;
}
as -> length = mbs - as -> s ;
as -> s [ as -> length ] = '\0' ;
return ( ret ) ;
} |
6,667,142,528,452,942,000 | debian | 7 | 0 | static FILE * open_sql_file_for_table ( const char * table , int flags ) {
FILE * res ;
char filename [ FN_REFLEN ] , tmp_path [ FN_REFLEN ] ;
convert_dirname ( tmp_path , path , NullS ) ;
res = my_fopen ( fn_format ( filename , table , tmp_path , ".sql" , 4 ) , flags , MYF ( MY_WME ) ) ;
return res ;
} |
6,879,275,573,700,338,000 | debian | 16 | 0 | static void flac_set_bps ( FLACContext * s ) {
enum AVSampleFormat req = s -> avctx -> request_sample_fmt ;
int need32 = s -> bps > 16 ;
int want32 = av_get_bytes_per_sample ( req ) > 2 ;
int planar = av_sample_fmt_is_planar ( req ) ;
if ( need32 || want32 ) {
if ( planar ) s -> avctx -> sample_fmt = AV_SAMPLE_FMT_S32P ;
else s -> avctx -> sample_fmt = AV_SAMPLE_FMT_S32 ;
s -> sample_shift = 32 - s -> bps ;
}
else {
if ( planar ) s -> avctx -> sample_fmt = AV_SAMPLE_FMT_S16P ;
else s -> avctx -> sample_fmt = AV_SAMPLE_FMT_S16 ;
s -> sample_shift = 16 - s -> bps ;
}
} |
-2,222,463,888,415,250,000 | chrome | 77 | 0 | static void configure_static_seg_features ( VP9_COMP * cpi ) {
VP9_COMMON * const cm = & cpi -> common ;
const RATE_CONTROL * const rc = & cpi -> rc ;
struct segmentation * const seg = & cm -> seg ;
int high_q = ( int ) ( rc -> avg_q > 48.0 ) ;
int qi_delta ;
if ( cm -> frame_type == KEY_FRAME ) {
vpx_memset ( cpi -> segmentation_map , 0 , cm -> mi_rows * cm -> mi_cols ) ;
seg -> update_map = 0 ;
seg -> update_data = 0 ;
cpi -> static_mb_pct = 0 ;
vp9_disable_segmentation ( seg ) ;
vp9_clearall_segfeatures ( seg ) ;
}
else if ( cpi -> refresh_alt_ref_frame ) {
vpx_memset ( cpi -> segmentation_map , 0 , cm -> mi_rows * cm -> mi_cols ) ;
seg -> update_map = 0 ;
seg -> update_data = 0 ;
cpi -> static_mb_pct = 0 ;
vp9_disable_segmentation ( seg ) ;
vp9_clearall_segfeatures ( seg ) ;
vp9_update_mbgraph_stats ( cpi ) ;
if ( seg -> enabled ) {
seg -> update_map = 1 ;
seg -> update_data = 1 ;
qi_delta = vp9_compute_qdelta ( rc , rc -> avg_q , rc -> avg_q * 0.875 , cm -> bit_depth ) ;
vp9_set_segdata ( seg , 1 , SEG_LVL_ALT_Q , qi_delta - 2 ) ;
vp9_set_segdata ( seg , 1 , SEG_LVL_ALT_LF , - 2 ) ;
vp9_enable_segfeature ( seg , 1 , SEG_LVL_ALT_Q ) ;
vp9_enable_segfeature ( seg , 1 , SEG_LVL_ALT_LF ) ;
seg -> abs_delta = SEGMENT_DELTADATA ;
}
}
else if ( seg -> enabled ) {
if ( rc -> frames_since_golden == 0 ) {
if ( rc -> source_alt_ref_active ) {
seg -> update_map = 0 ;
seg -> update_data = 1 ;
seg -> abs_delta = SEGMENT_DELTADATA ;
qi_delta = vp9_compute_qdelta ( rc , rc -> avg_q , rc -> avg_q * 1.125 , cm -> bit_depth ) ;
vp9_set_segdata ( seg , 1 , SEG_LVL_ALT_Q , qi_delta + 2 ) ;
vp9_enable_segfeature ( seg , 1 , SEG_LVL_ALT_Q ) ;
vp9_set_segdata ( seg , 1 , SEG_LVL_ALT_LF , - 2 ) ;
vp9_enable_segfeature ( seg , 1 , SEG_LVL_ALT_LF ) ;
if ( high_q || ( cpi -> static_mb_pct == 100 ) ) {
vp9_set_segdata ( seg , 1 , SEG_LVL_REF_FRAME , ALTREF_FRAME ) ;
vp9_enable_segfeature ( seg , 1 , SEG_LVL_REF_FRAME ) ;
vp9_enable_segfeature ( seg , 1 , SEG_LVL_SKIP ) ;
}
}
else {
vp9_disable_segmentation ( seg ) ;
vpx_memset ( cpi -> segmentation_map , 0 , cm -> mi_rows * cm -> mi_cols ) ;
seg -> update_map = 0 ;
seg -> update_data = 0 ;
vp9_clearall_segfeatures ( seg ) ;
}
}
else if ( rc -> is_src_frame_alt_ref ) {
vp9_enable_segfeature ( seg , 0 , SEG_LVL_REF_FRAME ) ;
vp9_enable_segfeature ( seg , 1 , SEG_LVL_REF_FRAME ) ;
vp9_clear_segdata ( seg , 0 , SEG_LVL_REF_FRAME ) ;
vp9_set_segdata ( seg , 0 , SEG_LVL_REF_FRAME , ALTREF_FRAME ) ;
vp9_clear_segdata ( seg , 1 , SEG_LVL_REF_FRAME ) ;
vp9_set_segdata ( seg , 1 , SEG_LVL_REF_FRAME , ALTREF_FRAME ) ;
if ( high_q ) {
vp9_enable_segfeature ( seg , 0 , SEG_LVL_SKIP ) ;
vp9_enable_segfeature ( seg , 1 , SEG_LVL_SKIP ) ;
}
seg -> update_data = 1 ;
}
else {
seg -> update_map = 0 ;
seg -> update_data = 0 ;
}
}
} |
-1,919,011,628,477,389,000 | debian | 11 | 0 | static int output_to_inttgt ( int output ) {
int i ;
for ( i = 0 ;
i < ARRAY_SIZE ( inttgt_output ) ;
i ++ ) {
if ( inttgt_output [ i ] [ 1 ] == output ) {
return inttgt_output [ i ] [ 0 ] ;
}
}
abort ( ) ;
} |
6,336,384,260,629,386,000 | debian | 21 | 0 | static void dissect_zcl_ota_imagepagereq ( tvbuff_t * tvb , proto_tree * tree , guint * offset ) {
guint8 field_ctrl ;
field_ctrl = dissect_zcl_ota_field_ctrl_field ( tvb , tree , offset ) ;
proto_tree_add_item ( tree , hf_zbee_zcl_ota_manufacturer_code , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
proto_tree_add_item ( tree , hf_zbee_zcl_ota_image_type , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
dissect_zcl_ota_file_version_field ( tvb , tree , offset ) ;
proto_tree_add_item ( tree , hf_zbee_zcl_ota_file_offset , tvb , * offset , 4 , ENC_LITTLE_ENDIAN ) ;
* offset += 4 ;
proto_tree_add_item ( tree , hf_zbee_zcl_ota_max_data_size , tvb , * offset , 1 , ENC_NA ) ;
* offset += 1 ;
proto_tree_add_item ( tree , hf_zbee_zcl_ota_page_size , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
proto_tree_add_item ( tree , hf_zbee_zcl_ota_rsp_spacing , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
if ( field_ctrl & ZBEE_ZCL_OTA_FIELD_CTRL_IEEE_ADDR_PRESENT ) {
proto_tree_add_item ( tree , hf_zbee_zcl_ota_req_node_addr , tvb , * offset , 8 , ENC_LITTLE_ENDIAN ) ;
* offset += 8 ;
}
} |
7,839,247,307,514,698,000 | debian | 100 | 0 | static Image * ReadLABELImage ( const ImageInfo * image_info , ExceptionInfo * exception ) {
char geometry [ MaxTextExtent ] , * property ;
const char * label ;
DrawInfo * draw_info ;
Image * image ;
MagickBooleanType status ;
TypeMetric metrics ;
size_t height , width ;
assert ( image_info != ( const ImageInfo * ) NULL ) ;
assert ( image_info -> signature == MagickSignature ) ;
if ( image_info -> debug != MagickFalse ) ( void ) LogMagickEvent ( TraceEvent , GetMagickModule ( ) , "%s" , image_info -> filename ) ;
assert ( exception != ( ExceptionInfo * ) NULL ) ;
assert ( exception -> signature == MagickSignature ) ;
image = AcquireImage ( image_info ) ;
( void ) ResetImagePage ( image , "0x0+0+0" ) ;
property = InterpretImageProperties ( image_info , image , image_info -> filename ) ;
( void ) SetImageProperty ( image , "label" , property ) ;
property = DestroyString ( property ) ;
label = GetImageProperty ( image , "label" ) ;
draw_info = CloneDrawInfo ( image_info , ( DrawInfo * ) NULL ) ;
draw_info -> text = ConstantString ( label ) ;
metrics . width = 0 ;
metrics . ascent = 0.0 ;
status = GetMultilineTypeMetrics ( image , draw_info , & metrics ) ;
if ( ( image -> columns == 0 ) && ( image -> rows == 0 ) ) {
image -> columns = ( size_t ) floor ( metrics . width + draw_info -> stroke_width + 0.5 ) ;
image -> rows = ( size_t ) floor ( metrics . height + draw_info -> stroke_width + 0.5 ) ;
}
else if ( ( strlen ( label ) > 0 ) && ( ( ( image -> columns == 0 ) || ( image -> rows == 0 ) ) || ( fabs ( image_info -> pointsize ) < MagickEpsilon ) ) ) {
double high , low ;
for ( ;
;
draw_info -> pointsize *= 2.0 ) {
( void ) FormatLocaleString ( geometry , MaxTextExtent , "%+g%+g" , - metrics . bounds . x1 , metrics . ascent ) ;
if ( draw_info -> gravity == UndefinedGravity ) ( void ) CloneString ( & draw_info -> geometry , geometry ) ;
( void ) GetMultilineTypeMetrics ( image , draw_info , & metrics ) ;
width = ( size_t ) floor ( metrics . width + draw_info -> stroke_width + 0.5 ) ;
height = ( size_t ) floor ( metrics . height + draw_info -> stroke_width + 0.5 ) ;
if ( ( image -> columns != 0 ) && ( image -> rows != 0 ) ) {
if ( ( width >= image -> columns ) && ( height >= image -> rows ) ) break ;
}
else if ( ( ( image -> columns != 0 ) && ( width >= image -> columns ) ) || ( ( image -> rows != 0 ) && ( height >= image -> rows ) ) ) break ;
}
high = draw_info -> pointsize ;
for ( low = 1.0 ;
( high - low ) > 0.5 ;
) {
draw_info -> pointsize = ( low + high ) / 2.0 ;
( void ) FormatLocaleString ( geometry , MaxTextExtent , "%+g%+g" , - metrics . bounds . x1 , metrics . ascent ) ;
if ( draw_info -> gravity == UndefinedGravity ) ( void ) CloneString ( & draw_info -> geometry , geometry ) ;
( void ) GetMultilineTypeMetrics ( image , draw_info , & metrics ) ;
width = ( size_t ) floor ( metrics . width + draw_info -> stroke_width + 0.5 ) ;
height = ( size_t ) floor ( metrics . height + draw_info -> stroke_width + 0.5 ) ;
if ( ( image -> columns != 0 ) && ( image -> rows != 0 ) ) {
if ( ( width < image -> columns ) && ( height < image -> rows ) ) low = draw_info -> pointsize + 0.5 ;
else high = draw_info -> pointsize - 0.5 ;
}
else if ( ( ( image -> columns != 0 ) && ( width < image -> columns ) ) || ( ( image -> rows != 0 ) && ( height < image -> rows ) ) ) low = draw_info -> pointsize + 0.5 ;
else high = draw_info -> pointsize - 0.5 ;
}
draw_info -> pointsize = ( low + high ) / 2.0 - 0.5 ;
}
status = GetMultilineTypeMetrics ( image , draw_info , & metrics ) ;
if ( status == MagickFalse ) {
draw_info = DestroyDrawInfo ( draw_info ) ;
InheritException ( exception , & image -> exception ) ;
image = DestroyImageList ( image ) ;
return ( ( Image * ) NULL ) ;
}
if ( image -> columns == 0 ) image -> columns = ( size_t ) floor ( metrics . width + draw_info -> stroke_width + 0.5 ) ;
if ( image -> columns == 0 ) image -> columns = ( size_t ) floor ( draw_info -> pointsize + draw_info -> stroke_width + 0.5 ) ;
if ( image -> rows == 0 ) image -> rows = ( size_t ) floor ( metrics . ascent - metrics . descent + draw_info -> stroke_width + 0.5 ) ;
if ( image -> rows == 0 ) image -> rows = ( size_t ) floor ( draw_info -> pointsize + draw_info -> stroke_width + 0.5 ) ;
status = SetImageExtent ( image , image -> columns , image -> rows ) ;
if ( status == MagickFalse ) {
draw_info = DestroyDrawInfo ( draw_info ) ;
InheritException ( exception , & image -> exception ) ;
return ( DestroyImageList ( image ) ) ;
}
if ( SetImageBackgroundColor ( image ) == MagickFalse ) {
draw_info = DestroyDrawInfo ( draw_info ) ;
InheritException ( exception , & image -> exception ) ;
image = DestroyImageList ( image ) ;
return ( ( Image * ) NULL ) ;
}
( void ) FormatLocaleString ( geometry , MaxTextExtent , "%+g%+g" , draw_info -> direction == RightToLeftDirection ? image -> columns - metrics . bounds . x2 : 0.0 , draw_info -> gravity == UndefinedGravity ? metrics . ascent : 0.0 ) ;
( void ) CloneString ( & draw_info -> geometry , geometry ) ;
status = AnnotateImage ( image , draw_info ) ;
if ( image_info -> pointsize == 0.0 ) {
char pointsize [ MaxTextExtent ] ;
( void ) FormatLocaleString ( pointsize , MaxTextExtent , "%.20g" , draw_info -> pointsize ) ;
( void ) SetImageProperty ( image , "label:pointsize" , pointsize ) ;
}
draw_info = DestroyDrawInfo ( draw_info ) ;
if ( status == MagickFalse ) {
image = DestroyImageList ( image ) ;
return ( ( Image * ) NULL ) ;
}
return ( GetFirstImageInList ( image ) ) ;
} |
6,250,095,321,513,210,000 | debian | 17 | 0 | void rfbSendBell ( rfbScreenInfoPtr rfbScreen ) {
rfbClientIteratorPtr i ;
rfbClientPtr cl ;
rfbBellMsg b ;
i = rfbGetClientIterator ( rfbScreen ) ;
while ( ( cl = rfbClientIteratorNext ( i ) ) ) {
b . type = rfbBell ;
LOCK ( cl -> sendMutex ) ;
if ( rfbWriteExact ( cl , ( char * ) & b , sz_rfbBellMsg ) < 0 ) {
rfbLogPerror ( "rfbSendBell: write" ) ;
rfbCloseClient ( cl ) ;
}
UNLOCK ( cl -> sendMutex ) ;
}
rfbStatRecordMessageSent ( cl , rfbBell , sz_rfbBellMsg , sz_rfbBellMsg ) ;
rfbReleaseClientIterator ( i ) ;
} |
-7,614,722,514,335,376,000 | chrome | 14 | 0 | TEST_F ( ProfileInfoCacheTest , CreateSupervisedTestingProfile ) {
testing_profile_manager_ . CreateTestingProfile ( "default" ) ;
base : : string16 supervised_user_name = ASCIIToUTF16 ( "Supervised User" ) ;
testing_profile_manager_ . CreateTestingProfile ( "test1" , scoped_ptr < PrefServiceSyncable > ( ) , supervised_user_name , 0 , "TEST_ID" , TestingProfile : : TestingFactories ( ) ) ;
for ( size_t i = 0 ;
i < GetCache ( ) -> GetNumberOfProfiles ( ) ;
i ++ ) {
bool is_supervised = GetCache ( ) -> GetNameOfProfileAtIndex ( i ) == supervised_user_name ;
EXPECT_EQ ( is_supervised , GetCache ( ) -> ProfileIsSupervisedAtIndex ( i ) ) ;
std : : string supervised_user_id = is_supervised ? "TEST_ID" : "" ;
EXPECT_EQ ( supervised_user_id , GetCache ( ) -> GetSupervisedUserIdOfProfileAtIndex ( i ) ) ;
}
TestingBrowserProcess : : GetGlobal ( ) -> SetProfileManager ( NULL ) ;
} |
7,651,945,086,108,393,000 | debian | 12 | 0 | int qemuMonitorJSONSetMigrationSpeed ( qemuMonitorPtr mon , unsigned long bandwidth ) {
int ret ;
virJSONValuePtr cmd ;
virJSONValuePtr reply = NULL ;
cmd = qemuMonitorJSONMakeCommand ( "migrate_set_speed" , "U:value" , bandwidth * 1024ULL * 1024ULL , NULL ) ;
if ( ! cmd ) return - 1 ;
ret = qemuMonitorJSONCommand ( mon , cmd , & reply ) ;
if ( ret == 0 ) ret = qemuMonitorJSONCheckError ( cmd , reply ) ;
virJSONValueFree ( cmd ) ;
virJSONValueFree ( reply ) ;
return ret ;
} |
7,092,216,800,726,730,000 | debian | 6 | 0 | static int dissect_h245_T_al3_sendBufferSize ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 332 "../../asn1/h245/h245.cnf" guint32 value ;
offset = dissect_per_constrained_integer ( tvb , offset , actx , tree , hf_index , 0U , 16777215U , & value , FALSE ) ;
if ( h223_lc_params_temp && h223_lc_params_temp -> al_params ) ( ( h223_al3_params * ) h223_lc_params_temp -> al_params ) -> send_buffer_size = value & 0xfffff ;
return offset ;
} |
3,599,206,110,384,554,500 | debian | 44 | 0 | 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 ) |
-3,337,205,971,666,909,000 | debian | 42 | 0 | static void qtmd_update_model ( struct qtmd_model * model ) {
struct qtmd_modelsym tmp ;
int i , j ;
if ( -- model -> shiftsleft ) {
for ( i = model -> entries - 1 ;
i >= 0 ;
i -- ) {
model -> syms [ i ] . cumfreq >>= 1 ;
if ( model -> syms [ i ] . cumfreq <= model -> syms [ i + 1 ] . cumfreq ) {
model -> syms [ i ] . cumfreq = model -> syms [ i + 1 ] . cumfreq + 1 ;
}
}
}
else {
model -> shiftsleft = 50 ;
for ( i = 0 ;
i < model -> entries ;
i ++ ) {
model -> syms [ i ] . cumfreq -= model -> syms [ i + 1 ] . cumfreq ;
model -> syms [ i ] . cumfreq ++ ;
model -> syms [ i ] . cumfreq >>= 1 ;
}
for ( i = 0 ;
i < model -> entries - 1 ;
i ++ ) {
for ( j = i + 1 ;
j < model -> entries ;
j ++ ) {
if ( model -> syms [ i ] . cumfreq < model -> syms [ j ] . cumfreq ) {
tmp = model -> syms [ i ] ;
model -> syms [ i ] = model -> syms [ j ] ;
model -> syms [ j ] = tmp ;
}
}
}
for ( i = model -> entries - 1 ;
i >= 0 ;
i -- ) {
model -> syms [ i ] . cumfreq += model -> syms [ i + 1 ] . cumfreq ;
}
}
} |
4,208,859,344,475,021,000 | chrome | 19 | 0 | static void get_symbols ( const UDateFormat * fmt , UDateFormatSymbolType type , UChar * array [ ] , int32_t arrayLength , int32_t lowestIndex , int32_t firstIndex , UErrorCode * status ) {
int32_t count , i ;
if ( U_FAILURE ( * status ) ) {
return ;
}
count = udat_countSymbols ( fmt , type ) ;
if ( count != arrayLength + lowestIndex ) {
return ;
}
for ( i = 0 ;
i < arrayLength ;
i ++ ) {
int32_t idx = ( i + firstIndex ) % arrayLength ;
int32_t size = 1 + udat_getSymbols ( fmt , type , idx + lowestIndex , NULL , 0 , status ) ;
array [ idx ] = ( UChar * ) malloc ( sizeof ( UChar ) * size ) ;
* status = U_ZERO_ERROR ;
udat_getSymbols ( fmt , type , idx + lowestIndex , array [ idx ] , size , status ) ;
}
} |
7,364,333,987,762,520,000 | chrome | 24 | 1 | static void print_mi_data ( VP9_COMMON * cm , FILE * file , const char * descriptor , size_t member_offset ) {
int mi_row , mi_col ;
int mi_index = 0 ;
MODE_INFO * * mi = cm -> mi_grid_visible ;
int rows = cm -> mi_rows ;
int cols = cm -> mi_cols ;
char prefix = descriptor [ 0 ] ;
log_frame_info ( cm , descriptor , file ) ;
mi_index = 0 ;
for ( mi_row = 0 ;
mi_row < rows ;
mi_row ++ ) {
fprintf ( file , "%c " , prefix ) ;
for ( mi_col = 0 ;
mi_col < cols ;
mi_col ++ ) {
fprintf ( file , "%2d " , * ( ( int * ) ( ( char * ) ( & mi [ mi_index ] -> mbmi ) + member_offset ) ) ) ;
mi_index ++ ;
}
fprintf ( file , "\n" ) ;
mi_index += 8 ;
}
fprintf ( file , "\n" ) ;
} |
3,804,373,597,256,531,000 | debian | 4 | 0 | static uchar * check_get_key ( ACL_USER * buff , size_t * length , my_bool not_used __attribute__ ( ( unused ) ) ) {
* length = buff -> hostname_length ;
return ( uchar * ) buff -> host . hostname ;
} |
2,895,622,461,494,525,400 | debian | 63 | 0 | static void test_long_data_str ( ) {
MYSQL_STMT * stmt ;
int rc , i ;
char data [ 255 ] ;
long length ;
ulong length1 ;
MYSQL_RES * result ;
MYSQL_BIND my_bind [ 2 ] ;
my_bool is_null [ 2 ] ;
char query [ MAX_TEST_QUERY_LENGTH ] ;
myheader ( "test_long_data_str" ) ;
rc = mysql_autocommit ( mysql , TRUE ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "DROP TABLE IF EXISTS test_long_data_str" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "CREATE TABLE test_long_data_str(id int, longstr long varchar)" ) ;
myquery ( rc ) ;
strmov ( query , "INSERT INTO test_long_data_str VALUES(?, ?)" ) ;
stmt = mysql_simple_prepare ( mysql , query ) ;
check_stmt ( stmt ) ;
verify_param_count ( stmt , 2 ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
my_bind [ 0 ] . buffer = ( void * ) & length ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_LONG ;
my_bind [ 0 ] . is_null = & is_null [ 0 ] ;
is_null [ 0 ] = 0 ;
length = 0 ;
my_bind [ 1 ] . buffer = data ;
my_bind [ 1 ] . buffer_type = MYSQL_TYPE_STRING ;
my_bind [ 1 ] . length = & length1 ;
my_bind [ 1 ] . is_null = & is_null [ 1 ] ;
is_null [ 1 ] = 0 ;
rc = mysql_stmt_bind_param ( stmt , my_bind ) ;
check_execute ( stmt , rc ) ;
length = 40 ;
strmov ( data , "MySQL AB" ) ;
for ( i = 0 ;
i < 4 ;
i ++ ) {
rc = mysql_stmt_send_long_data ( stmt , 1 , ( char * ) data , 5 ) ;
check_execute ( stmt , rc ) ;
}
rc = mysql_stmt_execute ( stmt ) ;
if ( ! opt_silent ) fprintf ( stdout , " mysql_stmt_execute() returned %d\n" , rc ) ;
check_execute ( stmt , rc ) ;
mysql_stmt_close ( stmt ) ;
rc = mysql_commit ( mysql ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "SELECT LENGTH(longstr), longstr FROM test_long_data_str" ) ;
myquery ( rc ) ;
result = mysql_store_result ( mysql ) ;
mytest ( result ) ;
rc = my_process_result_set ( result ) ;
DIE_UNLESS ( rc == 1 ) ;
mysql_free_result ( result ) ;
sprintf ( data , "%d" , i * 5 ) ;
verify_col_data ( "test_long_data_str" , "LENGTH(longstr)" , data ) ;
data [ 0 ] = '\0' ;
while ( i -- ) strxmov ( data , data , "MySQL" , NullS ) ;
verify_col_data ( "test_long_data_str" , "longstr" , data ) ;
rc = mysql_query ( mysql , "DROP TABLE test_long_data_str" ) ;
myquery ( rc ) ;
} |
-8,178,805,850,432,685,000 | debian | 8 | 0 | static guint32 pad_offset ( struct tcpinfo * tcpinfo , guint32 fpdu_total_len , guint8 pad_len ) {
if ( ( tcpinfo -> nxtseq - MPA_CRC_LEN - MPA_MARKER_LEN ) % MPA_MARKER_INTERVAL == 0 ) {
return fpdu_total_len - MPA_CRC_LEN - MPA_MARKER_LEN - pad_len ;
}
else {
return fpdu_total_len - MPA_CRC_LEN - pad_len ;
}
} |
-4,271,192,073,087,307,000 | debian | 61 | 1 | static int cavs_decode_frame ( AVCodecContext * avctx , void * data , int * got_frame , AVPacket * avpkt ) {
AVSContext * h = avctx -> priv_data ;
const uint8_t * buf = avpkt -> data ;
int buf_size = avpkt -> size ;
AVFrame * picture = data ;
uint32_t stc = - 1 ;
int input_size ;
const uint8_t * buf_end ;
const uint8_t * buf_ptr ;
if ( buf_size == 0 ) {
if ( ! h -> low_delay && h -> DPB [ 0 ] . f -> data [ 0 ] ) {
* got_frame = 1 ;
* picture = * h -> DPB [ 0 ] . f ;
if ( h -> cur . f -> data [ 0 ] ) avctx -> release_buffer ( avctx , h -> cur . f ) ;
FFSWAP ( AVSFrame , h -> cur , h -> DPB [ 0 ] ) ;
}
return 0 ;
}
buf_ptr = buf ;
buf_end = buf + buf_size ;
for ( ;
;
) {
buf_ptr = avpriv_mpv_find_start_code ( buf_ptr , buf_end , & stc ) ;
if ( ( stc & 0xFFFFFE00 ) || buf_ptr == buf_end ) return FFMAX ( 0 , buf_ptr - buf ) ;
input_size = ( buf_end - buf_ptr ) * 8 ;
switch ( stc ) {
case CAVS_START_CODE : init_get_bits ( & h -> gb , buf_ptr , input_size ) ;
decode_seq_header ( h ) ;
break ;
case PIC_I_START_CODE : if ( ! h -> got_keyframe ) {
if ( h -> DPB [ 0 ] . f -> data [ 0 ] ) avctx -> release_buffer ( avctx , h -> DPB [ 0 ] . f ) ;
if ( h -> DPB [ 1 ] . f -> data [ 0 ] ) avctx -> release_buffer ( avctx , h -> DPB [ 1 ] . f ) ;
h -> got_keyframe = 1 ;
}
case PIC_PB_START_CODE : * got_frame = 0 ;
if ( ! h -> got_keyframe ) break ;
init_get_bits ( & h -> gb , buf_ptr , input_size ) ;
h -> stc = stc ;
if ( decode_pic ( h ) ) break ;
* got_frame = 1 ;
if ( h -> cur . f -> pict_type != AV_PICTURE_TYPE_B ) {
if ( h -> DPB [ 1 ] . f -> data [ 0 ] ) {
* picture = * h -> DPB [ 1 ] . f ;
}
else {
* got_frame = 0 ;
}
}
else * picture = * h -> cur . f ;
break ;
case EXT_START_CODE : break ;
case USER_START_CODE : break ;
default : if ( stc <= SLICE_MAX_START_CODE ) {
init_get_bits ( & h -> gb , buf_ptr , input_size ) ;
decode_slice_header ( h , & h -> gb ) ;
}
break ;
}
}
} |
-6,068,399,010,699,046,000 | debian | 160 | 1 | static int dca_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 lfe_samples ;
int num_core_channels = 0 ;
int i , ret ;
float * * samples_flt ;
DCAContext * s = avctx -> priv_data ;
int channels , full_channels ;
int core_ss_end ;
s -> xch_present = 0 ;
s -> dca_buffer_size = ff_dca_convert_bitstream ( buf , buf_size , s -> dca_buffer , DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE ) ;
if ( s -> dca_buffer_size == AVERROR_INVALIDDATA ) {
av_log ( avctx , AV_LOG_ERROR , "Not a valid DCA frame\n" ) ;
return AVERROR_INVALIDDATA ;
}
init_get_bits ( & s -> gb , s -> dca_buffer , s -> dca_buffer_size * 8 ) ;
if ( ( ret = dca_parse_frame_header ( s ) ) < 0 ) {
return ret ;
}
avctx -> sample_rate = s -> sample_rate ;
avctx -> bit_rate = s -> bit_rate ;
s -> profile = FF_PROFILE_DTS ;
for ( i = 0 ;
i < ( s -> sample_blocks / 8 ) ;
i ++ ) {
if ( ( ret = dca_decode_block ( s , 0 , i ) ) ) {
av_log ( avctx , AV_LOG_ERROR , "error decoding block\n" ) ;
return ret ;
}
}
num_core_channels = s -> prim_channels ;
if ( s -> ext_coding ) s -> core_ext_mask = dca_ext_audio_descr_mask [ s -> ext_descr ] ;
else s -> core_ext_mask = 0 ;
core_ss_end = FFMIN ( s -> frame_size , s -> dca_buffer_size ) * 8 ;
if ( s -> core_ext_mask < 0 || s -> core_ext_mask & DCA_EXT_XCH ) {
s -> core_ext_mask = FFMAX ( s -> core_ext_mask , 0 ) ;
skip_bits_long ( & s -> gb , ( - get_bits_count ( & s -> gb ) ) & 31 ) ;
while ( core_ss_end - get_bits_count ( & s -> gb ) >= 32 ) {
uint32_t bits = get_bits_long ( & s -> gb , 32 ) ;
switch ( bits ) {
case 0x5a5a5a5a : {
int ext_amode , xch_fsize ;
s -> xch_base_channel = s -> prim_channels ;
xch_fsize = show_bits ( & s -> gb , 10 ) ;
if ( ( s -> frame_size != ( get_bits_count ( & s -> gb ) >> 3 ) - 4 + xch_fsize ) && ( s -> frame_size != ( get_bits_count ( & s -> gb ) >> 3 ) - 4 + xch_fsize + 1 ) ) continue ;
skip_bits ( & s -> gb , 10 ) ;
s -> core_ext_mask |= DCA_EXT_XCH ;
if ( ( ext_amode = get_bits ( & s -> gb , 4 ) ) != 1 ) {
av_log ( avctx , AV_LOG_ERROR , "XCh extension amode %d not" " supported!\n" , ext_amode ) ;
continue ;
}
dca_parse_audio_coding_header ( s , s -> xch_base_channel ) ;
for ( i = 0 ;
i < ( s -> sample_blocks / 8 ) ;
i ++ ) if ( ( ret = dca_decode_block ( s , s -> xch_base_channel , i ) ) ) {
av_log ( avctx , AV_LOG_ERROR , "error decoding XCh extension\n" ) ;
continue ;
}
s -> xch_present = 1 ;
break ;
}
case 0x47004a03 : s -> core_ext_mask |= DCA_EXT_XXCH ;
break ;
case 0x1d95f262 : {
int fsize96 = show_bits ( & s -> gb , 12 ) + 1 ;
if ( s -> frame_size != ( get_bits_count ( & s -> gb ) >> 3 ) - 4 + fsize96 ) continue ;
av_log ( avctx , AV_LOG_DEBUG , "X96 extension found at %d bits\n" , get_bits_count ( & s -> gb ) ) ;
skip_bits ( & s -> gb , 12 ) ;
av_log ( avctx , AV_LOG_DEBUG , "FSIZE96 = %d bytes\n" , fsize96 ) ;
av_log ( avctx , AV_LOG_DEBUG , "REVNO = %d\n" , get_bits ( & s -> gb , 4 ) ) ;
s -> core_ext_mask |= DCA_EXT_X96 ;
break ;
}
}
skip_bits_long ( & s -> gb , ( - get_bits_count ( & s -> gb ) ) & 31 ) ;
}
}
else {
skip_bits_long ( & s -> gb , core_ss_end - get_bits_count ( & s -> gb ) ) ;
}
if ( s -> core_ext_mask & DCA_EXT_X96 ) s -> profile = FF_PROFILE_DTS_96_24 ;
else if ( s -> core_ext_mask & ( DCA_EXT_XCH | DCA_EXT_XXCH ) ) s -> profile = FF_PROFILE_DTS_ES ;
if ( s -> dca_buffer_size - s -> frame_size > 32 && get_bits_long ( & s -> gb , 32 ) == DCA_HD_MARKER ) dca_exss_parse_header ( s ) ;
avctx -> profile = s -> profile ;
full_channels = channels = s -> prim_channels + ! ! s -> lfe ;
if ( s -> amode < 16 ) {
avctx -> channel_layout = dca_core_channel_layout [ s -> amode ] ;
if ( s -> xch_present && ( ! avctx -> request_channels || avctx -> request_channels > num_core_channels + ! ! s -> lfe ) ) {
avctx -> channel_layout |= AV_CH_BACK_CENTER ;
if ( s -> lfe ) {
avctx -> channel_layout |= AV_CH_LOW_FREQUENCY ;
s -> channel_order_tab = dca_channel_reorder_lfe_xch [ s -> amode ] ;
}
else {
s -> channel_order_tab = dca_channel_reorder_nolfe_xch [ s -> amode ] ;
}
}
else {
channels = num_core_channels + ! ! s -> lfe ;
s -> xch_present = 0 ;
if ( s -> lfe ) {
avctx -> channel_layout |= AV_CH_LOW_FREQUENCY ;
s -> channel_order_tab = dca_channel_reorder_lfe [ s -> amode ] ;
}
else s -> channel_order_tab = dca_channel_reorder_nolfe [ s -> amode ] ;
}
if ( channels > ! ! s -> lfe && s -> channel_order_tab [ channels - 1 - ! ! s -> lfe ] < 0 ) return AVERROR_INVALIDDATA ;
if ( avctx -> request_channels == 2 && s -> prim_channels > 2 ) {
channels = 2 ;
s -> output = DCA_STEREO ;
avctx -> channel_layout = AV_CH_LAYOUT_STEREO ;
}
}
else {
av_log ( avctx , AV_LOG_ERROR , "Non standard configuration %d !\n" , s -> amode ) ;
return AVERROR_INVALIDDATA ;
}
avctx -> channels = channels ;
frame -> nb_samples = 256 * ( s -> sample_blocks / 8 ) ;
if ( ( ret = ff_get_buffer ( avctx , frame ) ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "get_buffer() failed\n" ) ;
return ret ;
}
samples_flt = ( float * * ) frame -> extended_data ;
if ( avctx -> channels < full_channels ) {
ret = av_samples_get_buffer_size ( NULL , full_channels - channels , frame -> nb_samples , avctx -> sample_fmt , 0 ) ;
if ( ret < 0 ) return ret ;
av_fast_malloc ( & s -> extra_channels_buffer , & s -> extra_channels_buffer_size , ret ) ;
if ( ! s -> extra_channels_buffer ) return AVERROR ( ENOMEM ) ;
ret = av_samples_fill_arrays ( ( uint8_t * * ) s -> extra_channels , NULL , s -> extra_channels_buffer , full_channels - channels , frame -> nb_samples , avctx -> sample_fmt , 0 ) ;
if ( ret < 0 ) return ret ;
}
for ( i = 0 ;
i < ( s -> sample_blocks / 8 ) ;
i ++ ) {
int ch ;
for ( ch = 0 ;
ch < channels ;
ch ++ ) s -> samples_chanptr [ ch ] = samples_flt [ ch ] + i * 256 ;
for ( ;
ch < full_channels ;
ch ++ ) s -> samples_chanptr [ ch ] = s -> extra_channels [ ch - channels ] + i * 256 ;
dca_filter_channels ( s , i ) ;
if ( ( s -> source_pcm_res & 1 ) && s -> xch_present ) {
float * back_chan = s -> samples_chanptr [ s -> channel_order_tab [ s -> xch_base_channel ] ] ;
float * lt_chan = s -> samples_chanptr [ s -> channel_order_tab [ s -> xch_base_channel - 2 ] ] ;
float * rt_chan = s -> samples_chanptr [ s -> channel_order_tab [ s -> xch_base_channel - 1 ] ] ;
s -> fdsp . vector_fmac_scalar ( lt_chan , back_chan , - M_SQRT1_2 , 256 ) ;
s -> fdsp . vector_fmac_scalar ( rt_chan , back_chan , - M_SQRT1_2 , 256 ) ;
}
}
lfe_samples = 2 * s -> lfe * ( s -> sample_blocks / 8 ) ;
for ( i = 0 ;
i < 2 * s -> lfe * 4 ;
i ++ ) s -> lfe_data [ i ] = s -> lfe_data [ i + lfe_samples ] ;
* got_frame_ptr = 1 ;
return buf_size ;
} |
-6,068,399,010,699,046,000 | debian | 3 | 0 | static int dca_exss_mask2count ( int mask ) {
return av_popcount ( mask ) + av_popcount ( mask & ( DCA_EXSS_CENTER_LEFT_RIGHT | DCA_EXSS_FRONT_LEFT_RIGHT | DCA_EXSS_FRONT_HIGH_LEFT_RIGHT | DCA_EXSS_WIDE_LEFT_RIGHT | DCA_EXSS_SIDE_LEFT_RIGHT | DCA_EXSS_SIDE_HIGH_LEFT_RIGHT | DCA_EXSS_SIDE_REAR_LEFT_RIGHT | DCA_EXSS_REAR_LEFT_RIGHT | DCA_EXSS_REAR_HIGH_LEFT_RIGHT ) ) ;
} |
-2,423,144,171,479,607,000 | debian | 5 | 0 | static void pdf_copy_gstate ( fz_context * ctx , pdf_gstate * gs , pdf_gstate * old ) {
pdf_drop_gstate ( ctx , gs ) ;
* gs = * old ;
pdf_keep_gstate ( ctx , gs ) ;
} |
-4,534,372,572,324,105,700 | debian | 17 | 0 | static int get_riff ( AVFormatContext * s , AVIOContext * pb ) {
AVIContext * avi = s -> priv_data ;
char header [ 8 ] = {
0 }
;
int i ;
avio_read ( pb , header , 4 ) ;
avi -> riff_end = avio_rl32 ( pb ) ;
avi -> riff_end += avio_tell ( pb ) ;
avio_read ( pb , header + 4 , 4 ) ;
for ( i = 0 ;
avi_headers [ i ] [ 0 ] ;
i ++ ) if ( ! memcmp ( header , avi_headers [ i ] , 8 ) ) break ;
if ( ! avi_headers [ i ] [ 0 ] ) return AVERROR_INVALIDDATA ;
if ( header [ 7 ] == 0x19 ) av_log ( s , AV_LOG_INFO , "This file has been generated by a totally broken muxer.\n" ) ;
return 0 ;
} |
3,599,206,110,384,554,500 | debian | 36 | 0 | 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 ) |
-7,777,644,912,037,189,000 | debian | 559 | 0 | static void dissect_udvm_bytecode ( tvbuff_t * udvm_tvb , packet_info * pinfo , proto_tree * sigcomp_udvm_tree , guint start_address ) {
guint instruction ;
gint offset = 0 ;
gint start_offset = 0 ;
gint len ;
gint n ;
guint instruction_no = 0 ;
guint16 value = 0 ;
proto_item * item , * item2 ;
guint UDVM_address = start_address ;
gboolean is_memory_address ;
guint16 msg_length = tvb_reported_length_remaining ( udvm_tvb , offset ) ;
while ( msg_length > offset ) {
instruction = tvb_get_guint8 ( udvm_tvb , offset ) ;
instruction_no ++ ;
UDVM_address = start_address + offset ;
item = proto_tree_add_uint_format ( sigcomp_udvm_tree , hf_sigcomp_udvm_instruction , udvm_tvb , offset , 1 , instruction_no , "######### UDVM instruction %u at UDVM-address %u (0x%x) #########" , instruction_no , UDVM_address , UDVM_address ) ;
PROTO_ITEM_SET_GENERATED ( item ) ;
proto_tree_add_item ( sigcomp_udvm_tree , hf_sigcomp_udvm_instr , udvm_tvb , offset , 1 , ENC_BIG_ENDIAN ) ;
offset ++ ;
switch ( instruction ) {
case SIGCOMP_INSTR_AND : offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_1 , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2 , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_OR : offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_1 , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2 , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_NOT : offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_1 , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_LSHIFT : offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_1 , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2 , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_RSHIFT : offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_1 , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2 , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_ADD : offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_1 , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2 , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_SUBTRACT : offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_1 , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2 , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_MULTIPLY : offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_1 , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2 , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_DIVIDE : offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_1 , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2 , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_REMAINDER : offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_1 , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_operand_2 , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_SORT_ASCENDING : offset = offset + tvb_reported_length_remaining ( udvm_tvb , offset ) ;
break ;
case SIGCOMP_INSTR_SORT_DESCENDING : offset = offset + tvb_reported_length_remaining ( udvm_tvb , offset ) ;
break ;
case SIGCOMP_INSTR_SHA_1 : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_position , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_length , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_ref_dest , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_LOAD : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_address , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_value , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_value , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_MULTILOAD : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_address , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_literal_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_literal_num , udvm_tvb , start_offset , len , value ) ;
n = value ;
while ( n > 0 ) {
n = n - 1 ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_value , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_value , udvm_tvb , start_offset , len , value ) ;
}
}
break ;
case SIGCOMP_INSTR_PUSH : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_value , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_value , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_POP : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_address , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_COPY : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_position , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_length , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_ref_dest , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_COPY_LITERAL : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_position , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_length , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_ref_dest , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_COPY_OFFSET : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_offset , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_offset , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_length , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_reference_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_ref_dest , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_MEMSET : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_address , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_length , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_start_value , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_offset , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_JUMP : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
value = ( value + UDVM_address ) & 0xffff ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_at_address , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_COMPARE : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_value , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_value , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_value , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_value , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
value = ( value + UDVM_address ) & 0xffff ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_at_address , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
value = ( value + UDVM_address ) & 0xffff ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_at_address , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
value = ( value + UDVM_address ) & 0xffff ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_at_address , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_CALL : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
value = ( value + UDVM_address ) & 0xffff ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_at_address , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_RETURN : break ;
case SIGCOMP_INSTR_SWITCH : offset = dissect_udvm_literal_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_literal_num , udvm_tvb , start_offset , len , value ) ;
n = value ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_j , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_j , udvm_tvb , start_offset , len , value ) ;
}
while ( n > 0 ) {
n = n - 1 ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
value = ( value + UDVM_address ) & 0xffff ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_at_address , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_CRC : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_value , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_value , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_position , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_length , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
value = ( value + UDVM_address ) & 0xffff ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_at_address , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_INPUT_BYTES : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_length , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_destination , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_destination , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
value = ( value + UDVM_address ) & 0xffff ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_at_address , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_INPUT_BITS : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_length , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_destination , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_destination , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
value = ( value + UDVM_address ) & 0xffff ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_at_address , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_INPUT_HUFFMAN : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_destination , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_destination , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
value = ( value + UDVM_address ) & 0xffff ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_at_address , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_literal_operand ( udvm_tvb , sigcomp_udvm_tree , offset , & start_offset , & value ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_literal_num , udvm_tvb , start_offset , len , value ) ;
n = value ;
while ( n > 0 ) {
n = n - 1 ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_bits , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_lower_bound , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_upper_bound , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , FALSE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_uncompressed , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_STATE_ACCESS : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_partial_identifier_start , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_partial_identifier_length , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_state_begin , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_length_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_address_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_address , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_instr , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_STATE_CREATE : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_length_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_address_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_address , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_instr , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_min_acc_len , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_ret_pri , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_STATE_FREE : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_partial_identifier_start , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_partial_identifier_length , udvm_tvb , start_offset , len , value ) ;
break ;
case SIGCOMP_INSTR_OUTPUT : offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_addr_output_start , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_output_start , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_output_length_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_output_length , udvm_tvb , start_offset , len , value ) ;
}
break ;
case SIGCOMP_INSTR_END_MESSAGE : if ( ( msg_length - 1 ) < offset ) {
proto_tree_add_expert ( sigcomp_udvm_tree , pinfo , & ei_sigcomp_all_remaining_parameters_zero , udvm_tvb , 0 , - 1 ) ;
return ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_req_feedback_loc , udvm_tvb , start_offset , len , value ) ;
if ( ( msg_length - 1 ) < offset ) {
proto_tree_add_expert ( sigcomp_udvm_tree , pinfo , & ei_sigcomp_all_remaining_parameters_zero , udvm_tvb , offset - 1 , - 1 ) ;
return ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_ret_param_loc , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_length_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_length , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
if ( is_memory_address ) {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_address_addr , udvm_tvb , start_offset , len , value ) ;
}
else {
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_address , udvm_tvb , start_offset , len , value ) ;
}
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_instr , udvm_tvb , start_offset , len , value ) ;
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_min_acc_len , udvm_tvb , start_offset , len , value ) ;
if ( tvb_reported_length_remaining ( udvm_tvb , offset ) != 0 ) {
offset = dissect_udvm_multitype_operand ( udvm_tvb , sigcomp_udvm_tree , offset , TRUE , & start_offset , & value , & is_memory_address ) ;
len = offset - start_offset ;
proto_tree_add_uint ( sigcomp_udvm_tree , hf_udvm_state_ret_pri , udvm_tvb , start_offset , len , value ) ;
}
else {
item2 = proto_tree_add_uint_format_value ( sigcomp_udvm_tree , hf_udvm_state_ret_pri , udvm_tvb , offset , 1 , 0 , "0 (Not in the uploaded code as UDVM buffer initialized to Zero" ) ;
PROTO_ITEM_SET_GENERATED ( item2 ) ;
}
if ( tvb_reported_length_remaining ( udvm_tvb , offset ) != 0 ) {
len = tvb_reported_length_remaining ( udvm_tvb , offset ) ;
UDVM_address = start_address + offset ;
proto_tree_add_bytes_format ( sigcomp_udvm_tree , hf_sigcomp_remaining_bytes , udvm_tvb , offset , len , NULL , "Remaining %u bytes starting at UDVM addr %u (0x%x)- State information ?" , len , UDVM_address , UDVM_address ) ;
}
offset = offset + tvb_reported_length_remaining ( udvm_tvb , offset ) ;
break ;
default : offset = offset + tvb_reported_length_remaining ( udvm_tvb , offset ) ;
break ;
}
}
return ;
} |
-8,365,810,778,652,022,000 | debian | 23 | 0 | static void virtio_net_set_status ( struct VirtIODevice * vdev , uint8_t status ) {
VirtIONet * n = to_virtio_net ( vdev ) ;
virtio_net_vhost_status ( n , status ) ;
if ( ! n -> tx_waiting ) {
return ;
}
if ( virtio_net_started ( n , status ) && ! n -> vhost_started ) {
if ( n -> tx_timer ) {
qemu_mod_timer ( n -> tx_timer , qemu_get_clock_ns ( vm_clock ) + n -> tx_timeout ) ;
}
else {
qemu_bh_schedule ( n -> tx_bh ) ;
}
}
else {
if ( n -> tx_timer ) {
qemu_del_timer ( n -> tx_timer ) ;
}
else {
qemu_bh_cancel ( n -> tx_bh ) ;
}
}
} |
-6,068,976,579,504,841,000 | debian | 13 | 0 | static void ctl_putint ( const char * tag , long ival ) {
register char * cp ;
register const char * cq ;
char buffer [ 200 ] ;
cp = buffer ;
cq = tag ;
while ( * cq != '\0' ) * cp ++ = * cq ++ ;
* cp ++ = '=' ;
INSIST ( ( cp - buffer ) < ( int ) sizeof ( buffer ) ) ;
snprintf ( cp , sizeof ( buffer ) - ( cp - buffer ) , "%ld" , ival ) ;
cp += strlen ( cp ) ;
ctl_putdata ( buffer , ( unsigned ) ( cp - buffer ) , 0 ) ;
} |
1,312,888,211,311,687,000 | debian | 10 | 0 | static guint64 lbmpdm_fetch_uint64_encoded ( tvbuff_t * tvb , int offset , int encoding ) {
guint64 value = 0 ;
if ( encoding == ENC_BIG_ENDIAN ) {
value = tvb_get_ntoh64 ( tvb , offset ) ;
}
else {
value = tvb_get_letoh64 ( tvb , offset ) ;
}
return ( value ) ;
} |
-192,019,917,869,801,250 | debian | 22 | 0 | static void steamdiscover_dissect_body_proofresponse ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , gint offset , gint bytes_left ) {
gint len ;
gint64 value ;
protobuf_desc_t pb = {
tvb , offset , bytes_left }
;
protobuf_tag_t tag = {
0 , 0 , 0 }
;
while ( protobuf_iter_next ( & pb , & tag ) ) {
switch ( tag . field_number ) {
case STEAMDISCOVER_FN_PROOFRESPONSE_RESPONSE : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_LENGTHDELIMITED ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_item ( tree , hf_steam_ihs_discovery_body_proofresponse_response , pb . tvb , pb . offset + len , ( gint ) value , ENC_NA ) ;
len += ( gint ) value ;
break ;
default : len = protobuf_dissect_unknown_field ( & pb , & tag , pinfo , tree , NULL ) ;
break ;
}
protobuf_seek_forward ( & pb , len ) ;
}
} |
-7,470,076,990,396,875,000 | chrome | 2 | 0 | static void kq_sighandler ( int sig ) {
} |
7,909,110,399,479,437,000 | chrome | 3 | 0 | void hb_set_add_range ( hb_set_t * set , hb_codepoint_t first , hb_codepoint_t last ) {
set -> add_range ( first , last ) ;
} |
-2,943,582,541,244,388,000 | chrome | 48 | 0 | unsigned int vp9_variance ## W ## x ## H ## _c ( const uint8_t * a , int a_stride , const uint8_t * b , int b_stride , unsigned int * sse ) {
int sum ;
variance ( a , a_stride , b , b_stride , W , H , sse , & sum ) ;
return * sse - ( ( ( int64_t ) sum * sum ) / ( W * H ) ) ;
\ }
# define SUBPIX_VAR ( W , H ) unsigned int vp9_sub_pixel_variance ## W ## x ## H ## _c ( const uint8_t * src , int src_stride , int xoffset , int yoffset , const uint8_t * dst , int dst_stride , unsigned int * sse ) {
uint16_t fdata3 [ ( H + 1 ) * W ] ;
uint8_t temp2 [ H * W ] ;
var_filter_block2d_bil_first_pass ( src , fdata3 , src_stride , 1 , H + 1 , W , BILINEAR_FILTERS_2TAP ( xoffset ) ) ;
var_filter_block2d_bil_second_pass ( fdata3 , temp2 , W , W , H , W , BILINEAR_FILTERS_2TAP ( yoffset ) ) ;
return vp9_variance ## W ## x ## H ## _c ( temp2 , W , dst , dst_stride , sse ) ;
\ }
# define SUBPIX_AVG_VAR ( W , H ) unsigned int vp9_sub_pixel_avg_variance ## W ## x ## H ## _c ( const uint8_t * src , int src_stride , int xoffset , int yoffset , const uint8_t * dst , int dst_stride , unsigned int * sse , const uint8_t * second_pred ) {
uint16_t fdata3 [ ( H + 1 ) * W ] ;
uint8_t temp2 [ H * W ] ;
DECLARE_ALIGNED_ARRAY ( 16 , uint8_t , temp3 , H * W ) ;
var_filter_block2d_bil_first_pass ( src , fdata3 , src_stride , 1 , H + 1 , W , BILINEAR_FILTERS_2TAP ( xoffset ) ) ;
var_filter_block2d_bil_second_pass ( fdata3 , temp2 , W , W , H , W , BILINEAR_FILTERS_2TAP ( yoffset ) ) ;
vp9_comp_avg_pred ( temp3 , second_pred , W , H , temp2 , W ) ;
return vp9_variance ## W ## x ## H ## _c ( temp3 , W , dst , dst_stride , sse ) ;
\ }
void vp9_get16x16var_c ( const uint8_t * src_ptr , int source_stride , const uint8_t * ref_ptr , int ref_stride , unsigned int * sse , int * sum ) {
variance ( src_ptr , source_stride , ref_ptr , ref_stride , 16 , 16 , sse , sum ) ;
}
void vp9_get8x8var_c ( const uint8_t * src_ptr , int source_stride , const uint8_t * ref_ptr , int ref_stride , unsigned int * sse , int * sum ) {
variance ( src_ptr , source_stride , ref_ptr , ref_stride , 8 , 8 , sse , sum ) ;
}
unsigned int vp9_mse16x16_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 16 , 16 , sse , & sum ) ;
return * sse ;
}
unsigned int vp9_mse16x8_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 16 , 8 , sse , & sum ) ;
return * sse ;
}
unsigned int vp9_mse8x16_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 8 , 16 , sse , & sum ) ;
return * sse ;
}
unsigned int vp9_mse8x8_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 8 , 8 , sse , & sum ) ;
return * sse ;
}
VAR ( 4 , 4 ) SUBPIX_VAR ( 4 , 4 ) SUBPIX_AVG_VAR ( 4 , 4 ) VAR ( 4 , 8 ) SUBPIX_VAR ( 4 , 8 ) SUBPIX_AVG_VAR ( 4 , 8 ) VAR ( 8 , 4 ) SUBPIX_VAR ( 8 , 4 ) SUBPIX_AVG_VAR ( 8 , 4 ) VAR ( 8 , 8 ) SUBPIX_VAR ( 8 , 8 ) SUBPIX_AVG_VAR ( 8 , 8 ) VAR ( 8 , 16 ) SUBPIX_VAR ( 8 , 16 ) SUBPIX_AVG_VAR ( 8 , 16 ) VAR ( 16 , 8 ) |
-5,615,323,818,347,734,000 | debian | 10 | 0 | void flush_thread_cache ( ) {
mysql_mutex_lock ( & LOCK_thread_count ) ;
kill_cached_threads ++ ;
while ( cached_thread_count ) {
mysql_cond_broadcast ( & COND_thread_cache ) ;
mysql_cond_wait ( & COND_flush_thread_cache , & LOCK_thread_count ) ;
}
kill_cached_threads -- ;
mysql_mutex_unlock ( & LOCK_thread_count ) ;
} |
8,323,148,621,905,689,000 | chrome | 49 | 0 | int vp8_denoiser_allocate ( VP8_DENOISER * denoiser , int width , int height , int num_mb_rows , int num_mb_cols , int mode ) {
int i ;
assert ( denoiser ) ;
denoiser -> num_mb_cols = num_mb_cols ;
for ( i = 0 ;
i < MAX_REF_FRAMES ;
i ++ ) {
denoiser -> yv12_running_avg [ i ] . flags = 0 ;
if ( vp8_yv12_alloc_frame_buffer ( & ( denoiser -> yv12_running_avg [ i ] ) , width , height , VP8BORDERINPIXELS ) < 0 ) {
vp8_denoiser_free ( denoiser ) ;
return 1 ;
}
vpx_memset ( denoiser -> yv12_running_avg [ i ] . buffer_alloc , 0 , denoiser -> yv12_running_avg [ i ] . frame_size ) ;
}
denoiser -> yv12_mc_running_avg . flags = 0 ;
if ( vp8_yv12_alloc_frame_buffer ( & ( denoiser -> yv12_mc_running_avg ) , width , height , VP8BORDERINPIXELS ) < 0 ) {
vp8_denoiser_free ( denoiser ) ;
return 1 ;
}
vpx_memset ( denoiser -> yv12_mc_running_avg . buffer_alloc , 0 , denoiser -> yv12_mc_running_avg . frame_size ) ;
if ( vp8_yv12_alloc_frame_buffer ( & denoiser -> yv12_last_source , width , height , VP8BORDERINPIXELS ) < 0 ) {
vp8_denoiser_free ( denoiser ) ;
return 1 ;
}
vpx_memset ( denoiser -> yv12_last_source . buffer_alloc , 0 , denoiser -> yv12_last_source . frame_size ) ;
denoiser -> denoise_state = vpx_calloc ( ( num_mb_rows * num_mb_cols ) , 1 ) ;
vpx_memset ( denoiser -> denoise_state , 0 , ( num_mb_rows * num_mb_cols ) ) ;
vp8_denoiser_set_parameters ( denoiser , mode ) ;
denoiser -> nmse_source_diff = 0 ;
denoiser -> nmse_source_diff_count = 0 ;
denoiser -> qp_avg = 0 ;
denoiser -> qp_threshold_up = 80 ;
denoiser -> qp_threshold_down = 128 ;
denoiser -> bitrate_threshold = 200000 ;
denoiser -> threshold_aggressive_mode = 35 ;
if ( width * height > 640 * 480 ) {
denoiser -> bitrate_threshold = 500000 ;
denoiser -> threshold_aggressive_mode = 100 ;
}
else if ( width * height > 960 * 540 ) {
denoiser -> bitrate_threshold = 800000 ;
denoiser -> threshold_aggressive_mode = 150 ;
}
else if ( width * height > 1280 * 720 ) {
denoiser -> bitrate_threshold = 2000000 ;
denoiser -> threshold_aggressive_mode = 1400 ;
}
return 0 ;
} |
-4,765,077,557,530,511,000 | chrome | 35 | 0 | static int ogg_read_header ( AVFormatContext * s ) {
struct ogg * ogg = s -> priv_data ;
int ret , i ;
ogg -> curidx = - 1 ;
do {
ret = ogg_packet ( s , NULL , NULL , NULL , NULL ) ;
if ( ret < 0 ) {
ogg_read_close ( s ) ;
return ret ;
}
}
while ( ! ogg -> headers ) ;
av_log ( s , AV_LOG_TRACE , "found headers\n" ) ;
for ( i = 0 ;
i < ogg -> nstreams ;
i ++ ) {
struct ogg_stream * os = ogg -> streams + i ;
if ( ogg -> streams [ i ] . header < 0 ) {
av_log ( s , AV_LOG_ERROR , "Header parsing failed for stream %d\n" , i ) ;
ogg -> streams [ i ] . codec = NULL ;
av_freep ( & ogg -> streams [ i ] . private ) ;
}
else if ( os -> codec && os -> nb_header < os -> codec -> nb_header ) {
av_log ( s , AV_LOG_WARNING , "Headers mismatch for stream %d: " "expected %d received %d.\n" , i , os -> codec -> nb_header , os -> nb_header ) ;
if ( s -> error_recognition & AV_EF_EXPLODE ) return AVERROR_INVALIDDATA ;
}
if ( os -> start_granule != OGG_NOGRANULE_VALUE ) os -> lastpts = s -> streams [ i ] -> start_time = ogg_gptopts ( s , i , os -> start_granule , NULL ) ;
}
ret = ogg_get_length ( s ) ;
if ( ret < 0 ) {
ogg_read_close ( s ) ;
return ret ;
}
return 0 ;
} |
455,172,021,572,601,150 | debian | 7 | 0 | static int hextoint ( int c ) {
if ( ! isascii ( ( int ) c ) ) return ( - 1 ) ;
if ( isdigit ( ( int ) c ) ) return ( c - '0' ) ;
if ( ( c >= 'a' ) && ( c <= 'f' ) ) return ( c + 10 - 'a' ) ;
if ( ( c >= 'A' ) && ( c <= 'F' ) ) return ( c + 10 - 'A' ) ;
return ( - 1 ) ;
} |
-8,556,362,624,908,896,000 | debian | 73 | 0 | static void generate_joint_tables ( HYuvContext * s ) {
uint16_t symbols [ 1 << VLC_BITS ] ;
uint16_t bits [ 1 << VLC_BITS ] ;
uint8_t len [ 1 << VLC_BITS ] ;
if ( s -> bitstream_bpp < 24 ) {
int p , i , y , u ;
for ( p = 0 ;
p < 3 ;
p ++ ) {
for ( i = y = 0 ;
y < 256 ;
y ++ ) {
int len0 = s -> len [ 0 ] [ y ] ;
int limit = VLC_BITS - len0 ;
if ( limit <= 0 ) continue ;
for ( u = 0 ;
u < 256 ;
u ++ ) {
int len1 = s -> len [ p ] [ u ] ;
if ( len1 > limit ) continue ;
len [ i ] = len0 + len1 ;
bits [ i ] = ( s -> bits [ 0 ] [ y ] << len1 ) + s -> bits [ p ] [ u ] ;
symbols [ i ] = ( y << 8 ) + u ;
if ( symbols [ i ] != 0xffff ) i ++ ;
}
}
ff_free_vlc ( & s -> vlc [ 3 + p ] ) ;
ff_init_vlc_sparse ( & s -> vlc [ 3 + p ] , VLC_BITS , i , len , 1 , 1 , bits , 2 , 2 , symbols , 2 , 2 , 0 ) ;
}
}
else {
uint8_t ( * map ) [ 4 ] = ( uint8_t ( * ) [ 4 ] ) s -> pix_bgr_map ;
int i , b , g , r , code ;
int p0 = s -> decorrelate ;
int p1 = ! s -> decorrelate ;
for ( i = 0 , g = - 16 ;
g < 16 ;
g ++ ) {
int len0 = s -> len [ p0 ] [ g & 255 ] ;
int limit0 = VLC_BITS - len0 ;
if ( limit0 < 2 ) continue ;
for ( b = - 16 ;
b < 16 ;
b ++ ) {
int len1 = s -> len [ p1 ] [ b & 255 ] ;
int limit1 = limit0 - len1 ;
if ( limit1 < 1 ) continue ;
code = ( s -> bits [ p0 ] [ g & 255 ] << len1 ) + s -> bits [ p1 ] [ b & 255 ] ;
for ( r = - 16 ;
r < 16 ;
r ++ ) {
int len2 = s -> len [ 2 ] [ r & 255 ] ;
if ( len2 > limit1 ) continue ;
len [ i ] = len0 + len1 + len2 ;
bits [ i ] = ( code << len2 ) + s -> bits [ 2 ] [ r & 255 ] ;
if ( s -> decorrelate ) {
map [ i ] [ G ] = g ;
map [ i ] [ B ] = g + b ;
map [ i ] [ R ] = g + r ;
}
else {
map [ i ] [ B ] = g ;
map [ i ] [ G ] = b ;
map [ i ] [ R ] = r ;
}
i ++ ;
}
}
}
ff_free_vlc ( & s -> vlc [ 3 ] ) ;
init_vlc ( & s -> vlc [ 3 ] , VLC_BITS , i , len , 1 , 1 , bits , 2 , 2 , 0 ) ;
}
} |
3,649,198,920,984,613,400 | debian | 11 | 0 | static inline int vmsvga_fifo_length ( struct vmsvga_state_s * s ) {
int num ;
if ( ! s -> config || ! s -> enable ) {
return 0 ;
}
num = CMD ( next_cmd ) - CMD ( stop ) ;
if ( num < 0 ) {
num += CMD ( max ) - CMD ( min ) ;
}
return num >> 2 ;
} |
-6,351,630,154,286,607,000 | debian | 22 | 1 | size_t compile_tree ( struct filter_op * * fop ) {
int i = 1 ;
struct filter_op * array = NULL ;
struct unfold_elm * ue ;
BUG_IF ( tree_root == NULL ) ;
fprintf ( stdout , " Unfolding the meta-tree " ) ;
fflush ( stdout ) ;
unfold_blk ( & tree_root ) ;
fprintf ( stdout , " done.\n\n" ) ;
labels_to_offsets ( ) ;
TAILQ_FOREACH ( ue , & unfolded_tree , next ) {
if ( ue -> label == 0 ) {
SAFE_REALLOC ( array , i * sizeof ( struct filter_op ) ) ;
memcpy ( & array [ i - 1 ] , & ue -> fop , sizeof ( struct filter_op ) ) ;
i ++ ;
}
}
SAFE_REALLOC ( array , i * sizeof ( struct filter_op ) ) ;
array [ i - 1 ] . opcode = FOP_EXIT ;
* fop = array ;
return ( i ) ;
} |
-5,780,611,388,839,126,000 | chrome | 11 | 0 | xmlParserInputBufferCreateFilenameFunc xmlThrDefParserInputBufferCreateFilenameDefault ( xmlParserInputBufferCreateFilenameFunc func ) {
xmlParserInputBufferCreateFilenameFunc old ;
xmlMutexLock ( xmlThrDefMutex ) ;
old = xmlParserInputBufferCreateFilenameValueThrDef ;
if ( old == NULL ) {
old = __xmlParserInputBufferCreateFilename ;
}
xmlParserInputBufferCreateFilenameValueThrDef = func ;
xmlMutexUnlock ( xmlThrDefMutex ) ;
return ( old ) ;
} |
7,092,216,800,726,730,000 | debian | 4 | 0 | static int dissect_h245_CertSelectionCriteria ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_constrained_sequence_of ( tvb , offset , actx , tree , hf_index , ett_h245_CertSelectionCriteria , CertSelectionCriteria_sequence_of , 1 , 16 , FALSE ) ;
return offset ;
} |
6,862,887,795,439,011,000 | chrome | 27 | 0 | TEST_F ( SSLErrorAssistantTest , DynamicInterstitialListMatch ) {
ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ;
EXPECT_EQ ( 1u , ssl_info ( ) . public_key_hashes . size ( ) ) ;
auto config_proto = std : : make_unique < chrome_browser_ssl : : SSLErrorAssistantConfig > ( ) ;
config_proto -> set_version_id ( kLargeVersionId ) ;
chrome_browser_ssl : : DynamicInterstitial * filter = config_proto -> add_dynamic_interstitial ( ) ;
filter -> set_interstitial_type ( chrome_browser_ssl : : DynamicInterstitial : : INTERSTITIAL_PAGE_CAPTIVE_PORTAL ) ;
filter -> set_cert_error ( chrome_browser_ssl : : DynamicInterstitial : : UNKNOWN_CERT_ERROR ) ;
filter -> add_sha256_hash ( "sha256ightjar" ) ;
filter -> add_sha256_hash ( "sha256/frogmouth" ) ;
filter -> add_sha256_hash ( "sha256/poorwill" ) ;
filter -> set_mitm_software_name ( "UwS" ) ;
filter -> set_issuer_common_name_regex ( "whippoorwill" ) ;
filter = config_proto -> add_dynamic_interstitial ( ) ;
filter -> set_interstitial_type ( chrome_browser_ssl : : DynamicInterstitial : : INTERSTITIAL_PAGE_SSL ) ;
filter -> set_cert_error ( chrome_browser_ssl : : DynamicInterstitial : : ERR_CERT_COMMON_NAME_INVALID ) ;
filter -> add_sha256_hash ( "sha256uthatch" ) ;
filter -> add_sha256_hash ( ssl_info ( ) . public_key_hashes [ 0 ] . ToString ( ) ) ;
filter -> add_sha256_hash ( "sha256/treecreeper" ) ;
filter -> set_mitm_software_name ( "UwS" ) ;
filter -> set_issuer_common_name_regex ( issuer_common_name ( ) ) ;
filter -> set_issuer_organization_regex ( issuer_organization_name ( ) ) ;
error_assistant ( ) -> SetErrorAssistantProto ( std : : move ( config_proto ) ) ;
base : : Optional < DynamicInterstitialInfo > dynamic_interstitial = error_assistant ( ) -> MatchDynamicInterstitial ( ssl_info ( ) ) ;
ASSERT_TRUE ( dynamic_interstitial ) ;
EXPECT_EQ ( chrome_browser_ssl : : DynamicInterstitial : : INTERSTITIAL_PAGE_SSL , dynamic_interstitial -> interstitial_type ) ;
} |
7,092,216,800,726,730,000 | debian | 4 | 0 | static int dissect_h245_T_mobileOperationTransmitCapability ( 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_T_mobileOperationTransmitCapability , T_mobileOperationTransmitCapability_sequence ) ;
return offset ;
} |
4,511,225,370,772,574,700 | debian | 17 | 0 | static int sapi_uwsgi_read_post ( char * buffer , uint count_bytes TSRMLS_DC ) # endif {
uint read_bytes = 0 ;
struct wsgi_request * wsgi_req = ( struct wsgi_request * ) SG ( server_context ) ;
count_bytes = MIN ( count_bytes , wsgi_req -> post_cl - SG ( read_post_bytes ) ) ;
while ( read_bytes < count_bytes ) {
ssize_t rlen = 0 ;
char * buf = uwsgi_request_body_read ( wsgi_req , count_bytes - read_bytes , & rlen ) ;
if ( buf == uwsgi . empty ) break ;
if ( buf ) {
memcpy ( buffer , buf , rlen ) ;
read_bytes += rlen ;
continue ;
}
break ;
}
return read_bytes ;
} |
6,336,384,260,629,386,000 | debian | 50 | 0 | void dissect_zcl_power_config_attr_data ( proto_tree * tree , tvbuff_t * tvb , guint * offset , guint16 attr_id , guint data_type ) {
proto_item * it ;
static const int * mains_alarm_mask [ ] = {
& hf_zbee_zcl_power_config_mains_alarm_mask_low , & hf_zbee_zcl_power_config_mains_alarm_mask_high , & hf_zbee_zcl_power_config_mains_alarm_mask_reserved , NULL }
;
static const int * batt_alarm_mask [ ] = {
& hf_zbee_zcl_power_config_batt_alarm_mask_low , & hf_zbee_zcl_power_config_batt_alarm_mask_reserved , NULL }
;
switch ( attr_id ) {
case ZBEE_ZCL_ATTR_ID_POWER_CONF_MAINS_VOLTAGE : proto_tree_add_item ( tree , hf_zbee_zcl_power_config_mains_voltage , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_MAINS_FREQUENCY : proto_tree_add_item ( tree , hf_zbee_zcl_power_config_mains_frequency , tvb , * offset , 1 , ENC_LITTLE_ENDIAN ) ;
* offset += 1 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_MAINS_ALARM_MASK : proto_tree_add_bitmask ( tree , tvb , * offset , hf_zbee_zcl_power_config_mains_alarm_mask , ett_zbee_zcl_power_config_mains_alarm_mask , mains_alarm_mask , ENC_LITTLE_ENDIAN ) ;
* offset += 1 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_MAINS_VOLTAGE_MIN_THR : proto_tree_add_item ( tree , hf_zbee_zcl_power_config_mains_voltage_min_thr , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_MAINS_VOLTAGE_MAX_THR : proto_tree_add_item ( tree , hf_zbee_zcl_power_config_mains_voltage_max_thr , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_MAINS_VOLTAGE_DWELL_TP : it = proto_tree_add_item ( tree , hf_zbee_zcl_power_config_mains_voltage_dwell_tp , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
proto_item_append_text ( it , " [s]" ) ;
* offset += 2 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_BATTERY_SIZE : proto_tree_add_item ( tree , hf_zbee_zcl_power_config_batt_type , tvb , * offset , 1 , ENC_LITTLE_ENDIAN ) ;
* offset += 1 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_BATTERY_VOLTAGE : proto_tree_add_item ( tree , hf_zbee_zcl_power_config_batt_voltage , tvb , * offset , 1 , ENC_LITTLE_ENDIAN ) ;
* offset += 1 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_BATTERY_AH_RATING : proto_tree_add_item ( tree , hf_zbee_zcl_power_config_batt_ah_rating , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_BATTERY_RATED_VOLTAGE : proto_tree_add_item ( tree , hf_zbee_zcl_power_config_batt_rated_voltage , tvb , * offset , 1 , ENC_LITTLE_ENDIAN ) ;
* offset += 1 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_BATTERY_ALARM_MASK : proto_tree_add_bitmask ( tree , tvb , * offset , hf_zbee_zcl_power_config_batt_alarm_mask , ett_zbee_zcl_power_config_batt_alarm_mask , batt_alarm_mask , ENC_LITTLE_ENDIAN ) ;
* offset += 1 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_BATTERY_VOLTAGE_MIN_THR : proto_tree_add_item ( tree , hf_zbee_zcl_power_config_batt_voltage_min_thr , tvb , * offset , 1 , ENC_LITTLE_ENDIAN ) ;
* offset += 1 ;
break ;
case ZBEE_ZCL_ATTR_ID_POWER_CONF_BATTERY_MANUFACTURER : case ZBEE_ZCL_ATTR_ID_POWER_CONF_BATTERY_QUANTITY : default : dissect_zcl_attr_data ( tvb , tree , offset , data_type ) ;
break ;
}
} |
4,980,785,414,205,851,000 | chrome | 14 | 0 | IN_PROC_BROWSER_TEST_F ( FramebustBlockBrowserTest , AllowRadioButtonSelected ) {
const GURL url = embedded_test_server ( ) -> GetURL ( "/iframe.html" ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , url ) ;
auto * helper = GetFramebustTabHelper ( ) ;
helper -> AddBlockedUrl ( url , base : : BindOnce ( & FramebustBlockBrowserTest : : OnClick , base : : Unretained ( this ) ) ) ;
EXPECT_TRUE ( helper -> HasBlockedUrls ( ) ) ;
HostContentSettingsMap * settings_map = HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) ;
EXPECT_EQ ( CONTENT_SETTING_BLOCK , settings_map -> GetContentSetting ( url , GURL ( ) , CONTENT_SETTINGS_TYPE_POPUPS , std : : string ( ) ) ) ;
{
ContentSettingFramebustBlockBubbleModel framebust_block_bubble_model ( browser ( ) -> content_setting_bubble_model_delegate ( ) , GetWebContents ( ) , browser ( ) -> profile ( ) ) ;
framebust_block_bubble_model . OnRadioClicked ( kAllowRadioButtonIndex ) ;
}
EXPECT_EQ ( CONTENT_SETTING_ALLOW , settings_map -> GetContentSetting ( url , GURL ( ) , CONTENT_SETTINGS_TYPE_POPUPS , std : : string ( ) ) ) ;
} |
-3,819,889,754,140,204,000 | debian | 20 | 0 | static bool parse_policyConstraints ( chunk_t blob , int level0 , private_x509_cert_t * this ) {
asn1_parser_t * parser ;
chunk_t object ;
int objectID ;
bool success ;
parser = asn1_parser_create ( policyConstraintsObjects , blob ) ;
parser -> set_top_level ( parser , level0 ) ;
while ( parser -> iterate ( parser , & objectID , & object ) ) {
switch ( objectID ) {
case POLICY_CONSTRAINT_EXPLICIT : this -> require_explicit = parse_constraint ( object ) ;
break ;
case POLICY_CONSTRAINT_INHIBIT : this -> inhibit_mapping = parse_constraint ( object ) ;
break ;
default : break ;
}
}
success = parser -> success ( parser ) ;
parser -> destroy ( parser ) ;
return success ;
} |
-6,872,005,221,209,485,000 | chrome | 11 | 0 | static void decStatus ( decNumber * dn , uInt status , decContext * set ) {
if ( status & DEC_NaNs ) {
if ( status & DEC_sNaN ) status &= ~ DEC_sNaN ;
else {
uprv_decNumberZero ( dn ) ;
dn -> bits = DECNAN ;
}
}
uprv_decContextSetStatus ( set , status ) ;
return ;
} |
-7,237,039,260,294,671,000 | debian | 20 | 0 | static int dissect_nlm_test ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , int version , rpc_call_info_value * rpc_call ) {
if ( nlm_match_msgres ) {
if ( rpc_call -> proc == 6 ) {
if ( ( ! pinfo -> fd -> flags . visited ) ) {
nlm_register_unmatched_msg ( pinfo , tvb , offset ) ;
}
else {
nlm_print_msgres_request ( pinfo , tree , tvb ) ;
}
if ( nfs_fhandle_reqrep_matching ) {
nlm_match_fhandle_request ( pinfo , tree ) ;
}
}
}
offset = dissect_rpc_data ( tvb , tree , hf_nlm_cookie , offset ) ;
dissect_rpc_bool ( tvb , tree , hf_nlm_exclusive , offset ) ;
offset += 4 ;
offset = dissect_lock ( tvb , pinfo , tree , version , offset , rpc_call ) ;
return offset ;
} |
-3,740,862,514,502,467,000 | debian | 19 | 0 | static void dumpcffcidset ( struct alltabs * at ) {
int gid , start ;
putc ( 2 , at -> charset ) ;
start = - 1 ;
for ( gid = 1 ;
gid < at -> gi . gcnt ;
++ gid ) {
if ( start == - 1 ) start = gid ;
else if ( at -> gi . bygid [ gid ] - at -> gi . bygid [ start ] != gid - start ) {
putshort ( at -> charset , at -> gi . bygid [ start ] ) ;
putshort ( at -> charset , at -> gi . bygid [ gid - 1 ] - at -> gi . bygid [ start ] ) ;
start = gid ;
}
}
if ( start != - 1 ) {
putshort ( at -> charset , at -> gi . bygid [ start ] ) ;
putshort ( at -> charset , at -> gi . bygid [ gid - 1 ] - at -> gi . bygid [ start ] ) ;
}
} |
-5,268,859,819,325,808,000 | debian | 3 | 0 | static gboolean lacks_extension_info ( NautilusFile * file ) {
return file -> details -> pending_info_providers != NULL ;
} |
-1,929,262,071,302,712,000 | debian | 21 | 0 | static void * Type_Data_Read ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , cmsUInt32Number * nItems , cmsUInt32Number SizeOfTag ) {
cmsICCData * BinData ;
cmsUInt32Number LenOfData ;
* nItems = 0 ;
if ( SizeOfTag < sizeof ( cmsUInt32Number ) ) return NULL ;
LenOfData = SizeOfTag - sizeof ( cmsUInt32Number ) ;
if ( LenOfData > INT_MAX ) return NULL ;
BinData = ( cmsICCData * ) _cmsMalloc ( self -> ContextID , sizeof ( cmsICCData ) + LenOfData - 1 ) ;
if ( BinData == NULL ) return NULL ;
BinData -> len = LenOfData ;
if ( ! _cmsReadUInt32Number ( io , & BinData -> flag ) ) {
_cmsFree ( self -> ContextID , BinData ) ;
return NULL ;
}
if ( io -> Read ( io , BinData -> data , sizeof ( cmsUInt8Number ) , LenOfData ) != LenOfData ) {
_cmsFree ( self -> ContextID , BinData ) ;
return NULL ;
}
* nItems = 1 ;
return ( void * ) BinData ;
} |
2,578,089,348,587,614,000 | debian | 3 | 0 | EVP_PKEY * d2i_PrivateKey_fp ( FILE * fp , EVP_PKEY * * a ) {
return ASN1_d2i_fp_of ( EVP_PKEY , EVP_PKEY_new , d2i_AutoPrivateKey , fp , a ) ;
} |
4,489,017,523,191,997,000 | debian | 4 | 0 | static int dissect_h225_T_invalidTerminalAliases ( 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_h225_T_invalidTerminalAliases , T_invalidTerminalAliases_sequence ) ;
return offset ;
} |
7,749,168,290,238,235,000 | debian | 38 | 0 | static int test_streaming ( xd3_stream * in_stream , uint8_t * encbuf , uint8_t * decbuf , uint8_t * delbuf , usize_t megs ) {
xd3_stream estream , dstream ;
int ret ;
usize_t i , delsize , decsize ;
xd3_config cfg ;
xd3_init_config ( & cfg , in_stream -> flags ) ;
cfg . flags |= XD3_COMPLEVEL_6 ;
if ( ( ret = xd3_config_stream ( & estream , & cfg ) ) || ( ret = xd3_config_stream ( & dstream , & cfg ) ) ) {
goto fail ;
}
for ( i = 0 ;
i < megs ;
i += 1 ) {
( ( usize_t * ) encbuf ) [ 0 ] = i ;
if ( ( i % 200 ) == 199 ) {
DOT ( ) ;
}
if ( ( ret = xd3_process_stream ( 1 , & estream , xd3_encode_input , 0 , encbuf , 1 << 20 , delbuf , & delsize , 1 << 20 ) ) ) {
in_stream -> msg = estream . msg ;
goto fail ;
}
if ( ( ret = xd3_process_stream ( 0 , & dstream , xd3_decode_input , 0 , delbuf , delsize , decbuf , & decsize , 1 << 20 ) ) ) {
in_stream -> msg = dstream . msg ;
goto fail ;
}
if ( decsize != 1 << 20 || memcmp ( encbuf , decbuf , 1 << 20 ) != 0 ) {
in_stream -> msg = "wrong result" ;
ret = XD3_INTERNAL ;
goto fail ;
}
}
if ( ( ret = xd3_close_stream ( & estream ) ) || ( ret = xd3_close_stream ( & dstream ) ) ) {
goto fail ;
}
fail : xd3_free_stream ( & estream ) ;
xd3_free_stream ( & dstream ) ;
return ret ;
} |
7,072,059,544,915,634,000 | chrome | 404 | 0 | static void U_CALLCONV _LMBCSOpen ## n ( UConverter * _this , UConverterLoadArgs * pArgs , UErrorCode * err ) \ {
_LMBCSOpenWorker ( _this , pArgs , err , n ) ;
}
static void _LMBCSOpenWorker ( UConverter * _this , UConverterLoadArgs * pArgs , UErrorCode * err , ulmbcs_byte_t OptGroup ) {
UConverterDataLMBCS * extraInfo = ( UConverterDataLMBCS * ) uprv_malloc ( sizeof ( UConverterDataLMBCS ) ) ;
_this -> extraInfo = extraInfo ;
if ( extraInfo != NULL ) {
UConverterNamePieces stackPieces ;
UConverterLoadArgs stackArgs = UCNV_LOAD_ARGS_INITIALIZER ;
ulmbcs_byte_t i ;
uprv_memset ( extraInfo , 0 , sizeof ( UConverterDataLMBCS ) ) ;
stackArgs . onlyTestIsLoadable = pArgs -> onlyTestIsLoadable ;
for ( i = 0 ;
i <= ULMBCS_GRP_LAST && U_SUCCESS ( * err ) ;
i ++ ) {
if ( OptGroupByteToCPName [ i ] != NULL ) {
extraInfo -> OptGrpConverter [ i ] = ucnv_loadSharedData ( OptGroupByteToCPName [ i ] , & stackPieces , & stackArgs , err ) ;
}
}
if ( U_FAILURE ( * err ) || pArgs -> onlyTestIsLoadable ) {
_LMBCSClose ( _this ) ;
return ;
}
extraInfo -> OptGroup = OptGroup ;
extraInfo -> localeConverterIndex = FindLMBCSLocale ( pArgs -> locale ) ;
}
else {
* err = U_MEMORY_ALLOCATION_ERROR ;
}
}
U_CDECL_BEGIN static void U_CALLCONV _LMBCSClose ( UConverter * _this ) {
if ( _this -> extraInfo != NULL ) {
ulmbcs_byte_t Ix ;
UConverterDataLMBCS * extraInfo = ( UConverterDataLMBCS * ) _this -> extraInfo ;
for ( Ix = 0 ;
Ix <= ULMBCS_GRP_LAST ;
Ix ++ ) {
if ( extraInfo -> OptGrpConverter [ Ix ] != NULL ) ucnv_unloadSharedDataIfReady ( extraInfo -> OptGrpConverter [ Ix ] ) ;
}
if ( ! _this -> isExtraLocal ) {
uprv_free ( _this -> extraInfo ) ;
_this -> extraInfo = NULL ;
}
}
}
typedef struct LMBCSClone {
UConverter cnv ;
UConverterDataLMBCS lmbcs ;
}
LMBCSClone ;
static UConverter * U_CALLCONV _LMBCSSafeClone ( const UConverter * cnv , void * stackBuffer , int32_t * pBufferSize , UErrorCode * status ) {
( void ) status ;
LMBCSClone * newLMBCS ;
UConverterDataLMBCS * extraInfo ;
int32_t i ;
if ( * pBufferSize <= 0 ) {
* pBufferSize = ( int32_t ) sizeof ( LMBCSClone ) ;
return NULL ;
}
extraInfo = ( UConverterDataLMBCS * ) cnv -> extraInfo ;
newLMBCS = ( LMBCSClone * ) stackBuffer ;
uprv_memcpy ( & newLMBCS -> lmbcs , extraInfo , sizeof ( UConverterDataLMBCS ) ) ;
for ( i = 0 ;
i <= ULMBCS_GRP_LAST ;
++ i ) {
if ( extraInfo -> OptGrpConverter [ i ] != NULL ) {
ucnv_incrementRefCount ( extraInfo -> OptGrpConverter [ i ] ) ;
}
}
newLMBCS -> cnv . extraInfo = & newLMBCS -> lmbcs ;
newLMBCS -> cnv . isExtraLocal = TRUE ;
return & newLMBCS -> cnv ;
}
static size_t LMBCSConversionWorker ( UConverterDataLMBCS * extraInfo , ulmbcs_byte_t group , ulmbcs_byte_t * pStartLMBCS , UChar * pUniChar , ulmbcs_byte_t * lastConverterIndex , UBool * groups_tried ) {
ulmbcs_byte_t * pLMBCS = pStartLMBCS ;
UConverterSharedData * xcnv = extraInfo -> OptGrpConverter [ group ] ;
int bytesConverted ;
uint32_t value ;
ulmbcs_byte_t firstByte ;
U_ASSERT ( xcnv ) ;
U_ASSERT ( group < ULMBCS_GRP_UNICODE ) ;
bytesConverted = ucnv_MBCSFromUChar32 ( xcnv , * pUniChar , & value , FALSE ) ;
if ( bytesConverted > 0 ) {
firstByte = ( ulmbcs_byte_t ) ( value >> ( ( bytesConverted - 1 ) * 8 ) ) ;
}
else {
groups_tried [ group ] = TRUE ;
return 0 ;
}
* lastConverterIndex = group ;
U_ASSERT ( ( firstByte <= ULMBCS_C0END ) || ( firstByte >= ULMBCS_C1START ) || ( group == ULMBCS_GRP_EXCEPT ) ) ;
if ( group != ULMBCS_GRP_EXCEPT && extraInfo -> OptGroup != group ) {
* pLMBCS ++ = group ;
if ( bytesConverted == 1 && group >= ULMBCS_DOUBLEOPTGROUP_START ) {
* pLMBCS ++ = group ;
}
}
if ( bytesConverted == 1 && firstByte < 0x20 ) return 0 ;
switch ( bytesConverted ) {
case 4 : * pLMBCS ++ = ( ulmbcs_byte_t ) ( value >> 24 ) ;
U_FALLTHROUGH ;
case 3 : * pLMBCS ++ = ( ulmbcs_byte_t ) ( value >> 16 ) ;
U_FALLTHROUGH ;
case 2 : * pLMBCS ++ = ( ulmbcs_byte_t ) ( value >> 8 ) ;
U_FALLTHROUGH ;
case 1 : * pLMBCS ++ = ( ulmbcs_byte_t ) value ;
U_FALLTHROUGH ;
default : break ;
}
return ( pLMBCS - pStartLMBCS ) ;
}
static size_t LMBCSConvertUni ( ulmbcs_byte_t * pLMBCS , UChar uniChar ) {
uint8_t LowCh = ( uint8_t ) ( uniChar & 0x00FF ) ;
uint8_t HighCh = ( uint8_t ) ( uniChar >> 8 ) ;
* pLMBCS ++ = ULMBCS_GRP_UNICODE ;
if ( LowCh == 0 ) {
* pLMBCS ++ = ULMBCS_UNICOMPATZERO ;
* pLMBCS ++ = HighCh ;
}
else {
* pLMBCS ++ = HighCh ;
* pLMBCS ++ = LowCh ;
}
return ULMBCS_UNICODE_SIZE ;
}
static void U_CALLCONV _LMBCSFromUnicode ( UConverterFromUnicodeArgs * args , UErrorCode * err ) {
ulmbcs_byte_t lastConverterIndex = 0 ;
UChar uniChar ;
ulmbcs_byte_t LMBCS [ ULMBCS_CHARSIZE_MAX ] ;
ulmbcs_byte_t * pLMBCS ;
int32_t bytes_written ;
UBool groups_tried [ ULMBCS_GRP_LAST + 1 ] ;
UConverterDataLMBCS * extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
int sourceIndex = 0 ;
ulmbcs_byte_t OldConverterIndex = 0 ;
while ( args -> source < args -> sourceLimit && ! U_FAILURE ( * err ) ) {
OldConverterIndex = extraInfo -> localeConverterIndex ;
if ( args -> target >= args -> targetLimit ) {
* err = U_BUFFER_OVERFLOW_ERROR ;
break ;
}
uniChar = * ( args -> source ) ;
bytes_written = 0 ;
pLMBCS = LMBCS ;
if ( ( uniChar >= 0x80 ) && ( uniChar <= 0xff ) && ( uniChar != 0xB1 ) && ( uniChar != 0xD7 ) && ( uniChar != 0xF7 ) && ( uniChar != 0xB0 ) && ( uniChar != 0xB4 ) && ( uniChar != 0xB6 ) && ( uniChar != 0xA7 ) && ( uniChar != 0xA8 ) ) {
extraInfo -> localeConverterIndex = ULMBCS_GRP_L1 ;
}
if ( ( ( uniChar > ULMBCS_C0END ) && ( uniChar < ULMBCS_C1START ) ) || uniChar == 0 || uniChar == ULMBCS_HT || uniChar == ULMBCS_CR || uniChar == ULMBCS_LF || uniChar == ULMBCS_123SYSTEMRANGE ) {
* pLMBCS ++ = ( ulmbcs_byte_t ) uniChar ;
bytes_written = 1 ;
}
if ( ! bytes_written ) {
ulmbcs_byte_t group = FindLMBCSUniRange ( uniChar ) ;
if ( group == ULMBCS_GRP_UNICODE ) {
pLMBCS += LMBCSConvertUni ( pLMBCS , uniChar ) ;
bytes_written = ( int32_t ) ( pLMBCS - LMBCS ) ;
}
else if ( group == ULMBCS_GRP_CTRL ) {
if ( uniChar <= ULMBCS_C0END ) {
* pLMBCS ++ = ULMBCS_GRP_CTRL ;
* pLMBCS ++ = ( ulmbcs_byte_t ) ( ULMBCS_CTRLOFFSET + uniChar ) ;
}
else if ( uniChar >= ULMBCS_C1START && uniChar <= ULMBCS_C1START + ULMBCS_CTRLOFFSET ) {
* pLMBCS ++ = ULMBCS_GRP_CTRL ;
* pLMBCS ++ = ( ulmbcs_byte_t ) ( uniChar & 0x00FF ) ;
}
bytes_written = ( int32_t ) ( pLMBCS - LMBCS ) ;
}
else if ( group < ULMBCS_GRP_UNICODE ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , group , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written ) {
uprv_memset ( groups_tried , 0 , sizeof ( groups_tried ) ) ;
if ( ( extraInfo -> OptGroup != 1 ) && ( ULMBCS_AMBIGUOUS_MATCH ( group , extraInfo -> OptGroup ) ) ) {
if ( extraInfo -> localeConverterIndex < ULMBCS_DOUBLEOPTGROUP_START ) {
bytes_written = LMBCSConversionWorker ( extraInfo , ULMBCS_GRP_L1 , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
if ( ! bytes_written ) {
bytes_written = LMBCSConversionWorker ( extraInfo , ULMBCS_GRP_EXCEPT , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written ) {
bytes_written = LMBCSConversionWorker ( extraInfo , extraInfo -> localeConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
else {
bytes_written = LMBCSConversionWorker ( extraInfo , extraInfo -> localeConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
if ( ! bytes_written && ( extraInfo -> localeConverterIndex ) && ( ULMBCS_AMBIGUOUS_MATCH ( group , extraInfo -> localeConverterIndex ) ) ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , extraInfo -> localeConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written && ( lastConverterIndex ) && ( ULMBCS_AMBIGUOUS_MATCH ( group , lastConverterIndex ) ) ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , lastConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written ) {
ulmbcs_byte_t grp_start ;
ulmbcs_byte_t grp_end ;
ulmbcs_byte_t grp_ix ;
grp_start = ( ulmbcs_byte_t ) ( ( group == ULMBCS_AMBIGUOUS_MBCS ) ? ULMBCS_DOUBLEOPTGROUP_START : ULMBCS_GRP_L1 ) ;
grp_end = ( ulmbcs_byte_t ) ( ( group == ULMBCS_AMBIGUOUS_MBCS ) ? ULMBCS_GRP_LAST : ULMBCS_GRP_TH ) ;
if ( group == ULMBCS_AMBIGUOUS_ALL ) {
grp_start = ULMBCS_GRP_L1 ;
grp_end = ULMBCS_GRP_LAST ;
}
for ( grp_ix = grp_start ;
grp_ix <= grp_end && ! bytes_written ;
grp_ix ++ ) {
if ( extraInfo -> OptGrpConverter [ grp_ix ] && ! groups_tried [ grp_ix ] ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , grp_ix , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
if ( ! bytes_written && grp_start == ULMBCS_GRP_L1 ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , ULMBCS_GRP_EXCEPT , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
if ( ! bytes_written ) {
pLMBCS += LMBCSConvertUni ( pLMBCS , uniChar ) ;
bytes_written = ( int32_t ) ( pLMBCS - LMBCS ) ;
}
}
}
args -> source ++ ;
pLMBCS = LMBCS ;
while ( args -> target < args -> targetLimit && bytes_written -- ) {
* ( args -> target ) ++ = * pLMBCS ++ ;
if ( args -> offsets ) {
* ( args -> offsets ) ++ = sourceIndex ;
}
}
sourceIndex ++ ;
if ( bytes_written > 0 ) {
uint8_t * pErrorBuffer = args -> converter -> charErrorBuffer ;
* err = U_BUFFER_OVERFLOW_ERROR ;
args -> converter -> charErrorBufferLength = ( int8_t ) bytes_written ;
while ( bytes_written -- ) {
* pErrorBuffer ++ = * pLMBCS ++ ;
}
}
extraInfo -> localeConverterIndex = OldConverterIndex ;
}
}
static UChar GetUniFromLMBCSUni ( char const * * ppLMBCSin ) {
uint8_t HighCh = * ( * ppLMBCSin ) ++ ;
uint8_t LowCh = * ( * ppLMBCSin ) ++ ;
if ( HighCh == ULMBCS_UNICOMPATZERO ) {
HighCh = LowCh ;
LowCh = 0 ;
}
return ( UChar ) ( ( HighCh << 8 ) | LowCh ) ;
}
# define CHECK_SOURCE_LIMIT ( index ) if ( args -> source + index > args -> sourceLimit ) {
* err = U_TRUNCATED_CHAR_FOUND ;
args -> source = args -> sourceLimit ;
return 0xffff ;
}
static UChar32 U_CALLCONV _LMBCSGetNextUCharWorker ( UConverterToUnicodeArgs * args , UErrorCode * err ) {
UChar32 uniChar = 0 ;
ulmbcs_byte_t CurByte ;
if ( args -> source >= args -> sourceLimit ) {
* err = U_ILLEGAL_ARGUMENT_ERROR ;
return 0xffff ;
}
CurByte = * ( ( ulmbcs_byte_t * ) ( args -> source ++ ) ) ;
if ( ( ( CurByte > ULMBCS_C0END ) && ( CurByte < ULMBCS_C1START ) ) || ( CurByte == 0 ) || CurByte == ULMBCS_HT || CurByte == ULMBCS_CR || CurByte == ULMBCS_LF || CurByte == ULMBCS_123SYSTEMRANGE ) {
uniChar = CurByte ;
}
else {
UConverterDataLMBCS * extraInfo ;
ulmbcs_byte_t group ;
UConverterSharedData * cnv ;
if ( CurByte == ULMBCS_GRP_CTRL ) {
ulmbcs_byte_t C0C1byte ;
CHECK_SOURCE_LIMIT ( 1 ) ;
C0C1byte = * ( args -> source ) ++ ;
uniChar = ( C0C1byte < ULMBCS_C1START ) ? C0C1byte - ULMBCS_CTRLOFFSET : C0C1byte ;
}
else if ( CurByte == ULMBCS_GRP_UNICODE ) {
CHECK_SOURCE_LIMIT ( 2 ) ;
return GetUniFromLMBCSUni ( & ( args -> source ) ) ;
}
else if ( CurByte <= ULMBCS_CTRLOFFSET ) {
group = CurByte ;
extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
if ( group > ULMBCS_GRP_LAST || ( cnv = extraInfo -> OptGrpConverter [ group ] ) == NULL ) {
* err = U_INVALID_CHAR_FOUND ;
}
else if ( group >= ULMBCS_DOUBLEOPTGROUP_START ) {
CHECK_SOURCE_LIMIT ( 2 ) ;
if ( * args -> source == group ) {
++ args -> source ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source , 1 , FALSE ) ;
++ args -> source ;
}
else {
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source , 2 , FALSE ) ;
args -> source += 2 ;
}
}
else {
CHECK_SOURCE_LIMIT ( 1 ) ;
CurByte = * ( args -> source ) ++ ;
if ( CurByte >= ULMBCS_C1START ) {
uniChar = _MBCS_SINGLE_SIMPLE_GET_NEXT_BMP ( cnv , CurByte ) ;
}
else {
char bytes [ 2 ] ;
extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
cnv = extraInfo -> OptGrpConverter [ ULMBCS_GRP_EXCEPT ] ;
bytes [ 0 ] = group ;
bytes [ 1 ] = CurByte ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , bytes , 2 , FALSE ) ;
}
}
}
else if ( CurByte >= ULMBCS_C1START ) {
extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
group = extraInfo -> OptGroup ;
cnv = extraInfo -> OptGrpConverter [ group ] ;
if ( group >= ULMBCS_DOUBLEOPTGROUP_START ) {
if ( ! ucnv_MBCSIsLeadByte ( cnv , CurByte ) ) {
CHECK_SOURCE_LIMIT ( 0 ) ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source - 1 , 1 , FALSE ) ;
}
else {
CHECK_SOURCE_LIMIT ( 1 ) ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source - 1 , 2 , FALSE ) ;
++ args -> source ;
}
}
else {
uniChar = _MBCS_SINGLE_SIMPLE_GET_NEXT_BMP ( cnv , CurByte ) ;
}
}
}
return uniChar ;
}
static void U_CALLCONV _LMBCSToUnicodeWithOffsets ( UConverterToUnicodeArgs * args , UErrorCode * err ) {
char LMBCS [ ULMBCS_CHARSIZE_MAX ] ;
UChar uniChar ;
const char * saveSource ;
const char * pStartLMBCS = args -> source ;
const char * errSource = NULL ;
int8_t savebytes = 0 ;
while ( U_SUCCESS ( * err ) && args -> sourceLimit > args -> source && args -> targetLimit > args -> target ) {
saveSource = args -> source ;
if ( args -> converter -> toULength ) {
const char * saveSourceLimit ;
size_t size_old = args -> converter -> toULength ;
size_t size_new_maybe_1 = sizeof ( LMBCS ) - size_old ;
size_t size_new_maybe_2 = args -> sourceLimit - args -> source ;
size_t size_new = ( size_new_maybe_1 < size_new_maybe_2 ) ? size_new_maybe_1 : size_new_maybe_2 ;
uprv_memcpy ( LMBCS , args -> converter -> toUBytes , size_old ) ;
uprv_memcpy ( LMBCS + size_old , args -> source , size_new ) ;
saveSourceLimit = args -> sourceLimit ;
args -> source = errSource = LMBCS ;
args -> sourceLimit = LMBCS + size_old + size_new ;
savebytes = ( int8_t ) ( size_old + size_new ) ;
uniChar = ( UChar ) _LMBCSGetNextUCharWorker ( args , err ) ;
args -> source = saveSource + ( ( args -> source - LMBCS ) - size_old ) ;
args -> sourceLimit = saveSourceLimit ;
if ( * err == U_TRUNCATED_CHAR_FOUND ) {
args -> converter -> toULength = savebytes ;
uprv_memcpy ( args -> converter -> toUBytes , LMBCS , savebytes ) ;
args -> source = args -> sourceLimit ;
* err = U_ZERO_ERROR ;
return ;
}
else {
args -> converter -> toULength = 0 ;
}
}
else {
errSource = saveSource ;
uniChar = ( UChar ) _LMBCSGetNextUCharWorker ( args , err ) ;
savebytes = ( int8_t ) ( args -> source - saveSource ) ;
}
if ( U_SUCCESS ( * err ) ) {
if ( uniChar < 0xfffe ) {
* ( args -> target ) ++ = uniChar ;
if ( args -> offsets ) {
* ( args -> offsets ) ++ = ( int32_t ) ( saveSource - pStartLMBCS ) ;
}
}
else if ( uniChar == 0xfffe ) {
* err = U_INVALID_CHAR_FOUND ;
}
else {
* err = U_ILLEGAL_CHAR_FOUND ;
}
}
}
if ( U_SUCCESS ( * err ) && args -> sourceLimit > args -> source && args -> targetLimit <= args -> target ) {
* err = U_BUFFER_OVERFLOW_ERROR ;
}
else if ( U_FAILURE ( * err ) ) {
args -> converter -> toULength = savebytes ;
if ( savebytes > 0 ) {
uprv_memcpy ( args -> converter -> toUBytes , errSource , savebytes ) ;
}
if ( * err == U_TRUNCATED_CHAR_FOUND ) {
* err = U_ZERO_ERROR ;
}
}
}
DEFINE_LMBCS_OPEN ( 1 ) DEFINE_LMBCS_OPEN ( 2 ) |
-7,136,186,224,744,988,000 | debian | 5 | 0 | static bool checkprotoprefix ( struct Curl_easy * data , struct connectdata * conn , const char * s ) {
# ifndef CURL_DISABLE_RTSP if ( conn -> handler -> protocol & CURLPROTO_RTSP ) return checkrtspprefix ( data , s ) ;
# else ( void ) conn ;
# endif return checkhttpprefix ( data , s ) ;
} |
7,424,930,167,238,098,000 | debian | 16 | 0 | static void snoop_urb_data ( struct urb * urb , unsigned len ) {
int i , size ;
len = min ( len , usbfs_snoop_max ) ;
if ( ! usbfs_snoop || len == 0 ) return ;
if ( urb -> num_sgs == 0 ) {
print_hex_dump ( KERN_DEBUG , "data: " , DUMP_PREFIX_NONE , 32 , 1 , urb -> transfer_buffer , len , 1 ) ;
return ;
}
for ( i = 0 ;
i < urb -> num_sgs && len ;
i ++ ) {
size = ( len > USB_SG_SIZE ) ? USB_SG_SIZE : len ;
print_hex_dump ( KERN_DEBUG , "data: " , DUMP_PREFIX_NONE , 32 , 1 , sg_virt ( & urb -> sg [ i ] ) , size , 1 ) ;
len -= size ;
}
} |
5,918,484,636,148,311,000 | debian | 39 | 0 | gx_color_index mem_mapped_map_rgb_color ( gx_device * dev , const gx_color_value cv [ ] ) {
gx_device_memory * const mdev = ( gx_device_memory * ) dev ;
byte br = gx_color_value_to_byte ( cv [ 0 ] ) ;
register const byte * pptr = mdev -> palette . data ;
int cnt = mdev -> palette . size ;
const byte * which = 0 ;
int best = 256 * 3 ;
if ( mdev -> color_info . num_components != 1 ) {
byte bg = gx_color_value_to_byte ( cv [ 1 ] ) ;
byte bb = gx_color_value_to_byte ( cv [ 2 ] ) ;
while ( ( cnt -= 3 ) >= 0 ) {
register int diff = * pptr - br ;
if ( diff < 0 ) diff = - diff ;
if ( diff < best ) {
int dg = pptr [ 1 ] - bg ;
if ( dg < 0 ) dg = - dg ;
if ( ( diff += dg ) < best ) {
int db = pptr [ 2 ] - bb ;
if ( db < 0 ) db = - db ;
if ( ( diff += db ) < best ) which = pptr , best = diff ;
}
}
if ( diff == 0 ) break ;
pptr += 3 ;
}
}
else {
while ( ( cnt -= 3 ) >= 0 ) {
register int diff = * pptr - br ;
if ( diff < 0 ) diff = - diff ;
if ( diff < best ) {
which = pptr , best = diff ;
}
if ( diff == 0 ) break ;
pptr += 3 ;
}
}
return ( gx_color_index ) ( ( which - mdev -> palette . data ) / 3 ) ;
} |
-2,607,754,285,145,856,500 | debian | 11 | 0 | static void idr_set_num ( unsigned char * p , int num ) {
static const char xdig [ ] = {
'0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' , 'G' , 'H' , 'I' , 'J' , 'K' , 'L' , 'M' , 'N' , 'O' , 'P' , 'Q' , 'R' , 'S' , 'T' , 'U' , 'V' , 'W' , 'X' , 'Y' , 'Z' }
;
num %= sizeof ( xdig ) * sizeof ( xdig ) * sizeof ( xdig ) ;
p [ 0 ] = xdig [ ( num / ( sizeof ( xdig ) * sizeof ( xdig ) ) ) ] ;
num %= sizeof ( xdig ) * sizeof ( xdig ) ;
p [ 1 ] = xdig [ ( num / sizeof ( xdig ) ) ] ;
num %= sizeof ( xdig ) ;
p [ 2 ] = xdig [ num ] ;
} |
-3,203,201,540,003,796,000 | debian | 2 | 0 | static inline void tswap32s ( uint32_t * s ) {
} |
-7,990,991,774,694,156,000 | debian | 103 | 0 | static int unpack_superblocks ( Vp3DecodeContext * s , GetBitContext * gb ) {
int superblock_starts [ 3 ] = {
0 , s -> u_superblock_start , s -> v_superblock_start }
;
int bit = 0 ;
int current_superblock = 0 ;
int current_run = 0 ;
int num_partial_superblocks = 0 ;
int i , j ;
int current_fragment ;
int plane ;
if ( s -> keyframe ) {
memset ( s -> superblock_coding , SB_FULLY_CODED , s -> superblock_count ) ;
}
else {
bit = get_bits1 ( gb ) ^ 1 ;
current_run = 0 ;
while ( current_superblock < s -> superblock_count && get_bits_left ( gb ) > 0 ) {
if ( s -> theora && current_run == MAXIMUM_LONG_BIT_RUN ) bit = get_bits1 ( gb ) ;
else bit ^= 1 ;
current_run = get_vlc2 ( gb , s -> superblock_run_length_vlc . table , 6 , 2 ) + 1 ;
if ( current_run == 34 ) current_run += get_bits ( gb , 12 ) ;
if ( current_superblock + current_run > s -> superblock_count ) {
av_log ( s -> avctx , AV_LOG_ERROR , "Invalid partially coded superblock run length\n" ) ;
return - 1 ;
}
memset ( s -> superblock_coding + current_superblock , bit , current_run ) ;
current_superblock += current_run ;
if ( bit ) num_partial_superblocks += current_run ;
}
if ( num_partial_superblocks < s -> superblock_count ) {
int superblocks_decoded = 0 ;
current_superblock = 0 ;
bit = get_bits1 ( gb ) ^ 1 ;
current_run = 0 ;
while ( superblocks_decoded < s -> superblock_count - num_partial_superblocks && get_bits_left ( gb ) > 0 ) {
if ( s -> theora && current_run == MAXIMUM_LONG_BIT_RUN ) bit = get_bits1 ( gb ) ;
else bit ^= 1 ;
current_run = get_vlc2 ( gb , s -> superblock_run_length_vlc . table , 6 , 2 ) + 1 ;
if ( current_run == 34 ) current_run += get_bits ( gb , 12 ) ;
for ( j = 0 ;
j < current_run ;
current_superblock ++ ) {
if ( current_superblock >= s -> superblock_count ) {
av_log ( s -> avctx , AV_LOG_ERROR , "Invalid fully coded superblock run length\n" ) ;
return - 1 ;
}
if ( s -> superblock_coding [ current_superblock ] == SB_NOT_CODED ) {
s -> superblock_coding [ current_superblock ] = 2 * bit ;
j ++ ;
}
}
superblocks_decoded += current_run ;
}
}
if ( num_partial_superblocks ) {
current_run = 0 ;
bit = get_bits1 ( gb ) ;
bit ^= 1 ;
}
}
s -> total_num_coded_frags = 0 ;
memset ( s -> macroblock_coding , MODE_COPY , s -> macroblock_count ) ;
for ( plane = 0 ;
plane < 3 ;
plane ++ ) {
int sb_start = superblock_starts [ plane ] ;
int sb_end = sb_start + ( plane ? s -> c_superblock_count : s -> y_superblock_count ) ;
int num_coded_frags = 0 ;
for ( i = sb_start ;
i < sb_end && get_bits_left ( gb ) > 0 ;
i ++ ) {
for ( j = 0 ;
j < 16 ;
j ++ ) {
current_fragment = s -> superblock_fragments [ i * 16 + j ] ;
if ( current_fragment != - 1 ) {
int coded = s -> superblock_coding [ i ] ;
if ( s -> superblock_coding [ i ] == SB_PARTIALLY_CODED ) {
if ( current_run -- == 0 ) {
bit ^= 1 ;
current_run = get_vlc2 ( gb , s -> fragment_run_length_vlc . table , 5 , 2 ) ;
}
coded = bit ;
}
if ( coded ) {
s -> all_fragments [ current_fragment ] . coding_method = MODE_INTER_NO_MV ;
s -> coded_fragment_list [ plane ] [ num_coded_frags ++ ] = current_fragment ;
}
else {
s -> all_fragments [ current_fragment ] . coding_method = MODE_COPY ;
}
}
}
}
s -> total_num_coded_frags += num_coded_frags ;
for ( i = 0 ;
i < 64 ;
i ++ ) s -> num_coded_frags [ plane ] [ i ] = num_coded_frags ;
if ( plane < 2 ) s -> coded_fragment_list [ plane + 1 ] = s -> coded_fragment_list [ plane ] + num_coded_frags ;
}
return 0 ;
} |
-5,456,913,190,944,845,000 | chrome | 42 | 0 | TEST_F ( TemplateURLTest , Suggestions ) {
struct TestData {
const int accepted_suggestion ;
const base : : string16 original_query_for_suggestion ;
const std : : string expected_result ;
}
test_data [ ] = {
{
TemplateURLRef : : NO_SUGGESTIONS_AVAILABLE , base : : string16 ( ) , "http://bar/foo?q=foobar" }
, {
TemplateURLRef : : NO_SUGGESTIONS_AVAILABLE , ASCIIToUTF16 ( "foo" ) , "http://bar/foo?q=foobar" }
, {
TemplateURLRef : : NO_SUGGESTION_CHOSEN , base : : string16 ( ) , "http://bar/foo?q=foobar" }
, {
TemplateURLRef : : NO_SUGGESTION_CHOSEN , ASCIIToUTF16 ( "foo" ) , "http://bar/foo?q=foobar" }
, {
0 , base : : string16 ( ) , "http://bar/foo?oq=&q=foobar" }
, {
1 , ASCIIToUTF16 ( "foo" ) , "http://bar/foo?oq=foo&q=foobar" }
, }
;
TemplateURLData data ;
data . SetURL ( "http://bar/foo?{
google:originalQueryForSuggestion}
" "q={
searchTerms}
" ) ;
data . input_encodings . push_back ( "UTF-8" ) ;
TemplateURL url ( data ) ;
EXPECT_TRUE ( url . url_ref ( ) . IsValid ( search_terms_data_ ) ) ;
ASSERT_TRUE ( url . url_ref ( ) . SupportsReplacement ( search_terms_data_ ) ) ;
for ( size_t i = 0 ;
i < arraysize ( test_data ) ;
++ i ) {
TemplateURLRef : : SearchTermsArgs search_terms_args ( ASCIIToUTF16 ( "foobar" ) ) ;
search_terms_args . accepted_suggestion = test_data [ i ] . accepted_suggestion ;
search_terms_args . original_query = test_data [ i ] . original_query_for_suggestion ;
GURL result ( url . url_ref ( ) . ReplaceSearchTerms ( search_terms_args , search_terms_data_ ) ) ;
ASSERT_TRUE ( result . is_valid ( ) ) ;
EXPECT_EQ ( test_data [ i ] . expected_result , result . spec ( ) ) ;
}
} |
8,484,475,213,808,847,000 | debian | 11 | 0 | static void qdev_print_props ( Monitor * mon , DeviceState * dev , Property * props , const char * prefix , int indent ) {
char buf [ 64 ] ;
if ( ! props ) return ;
while ( props -> name ) {
if ( props -> info -> print ) {
props -> info -> print ( dev , props , buf , sizeof ( buf ) ) ;
qdev_printf ( "%s-prop: %s = %s\n" , prefix , props -> name , buf ) ;
}
props ++ ;
}
} |
1,760,449,185,745,615,400 | debian | 3 | 0 | void TSStatIntDecrement ( int id , TSMgmtInt amount ) {
RecDecrRawStat ( api_rsb , nullptr , id , amount ) ;
} |
3,919,646,340,804,521,500 | debian | 3 | 0 | static int pbase_tree_cache_ix_incr ( int ix ) {
return ( ix + 1 ) % ARRAY_SIZE ( pbase_tree_cache ) ;
} |
2,755,982,813,601,945,000 | debian | 10 | 0 | static void interpolate ( float * out , float v1 , float v2 , int size ) {
int i ;
float step = ( v1 - v2 ) / ( size + 1 ) ;
for ( i = 0 ;
i < size ;
i ++ ) {
v2 += step ;
out [ i ] = v2 ;
}
} |
End of preview. Expand
in Dataset Viewer.
This is an unofficial HuggingFace version of "ReVeal" dataset from "Deep Learning based Vulnerability Detection: Are We There Yet? ".
- Downloads last month
- 62