idx int64 | func string | target int64 |
|---|---|---|
343,276 | void dodele(char *name)
{
#ifndef ANON_CAN_DELETE
if (guest != 0) {
addreply_noformat(550, MSG_ANON_CANT_DELETE);
return;
}
#endif
if (name == NULL || *name == 0) {
addreply_noformat(501, MSG_NO_FILE_NAME);
return;
}
if (checknamesanity(name, dot_write_ok) != 0) {
... | 0 |
274,726 | callbacks_handle_log_messages(const gchar *log_domain, GLogLevelFlags log_level,
const gchar *message, gpointer user_data)
{
GtkTextBuffer *textbuffer = NULL;
GtkTextIter iter;
GtkTextTag *tag;
GtkTextMark *StartMark = NULL, *StopMark = NULL;
GtkTextIter StartIter, StopIter;
GtkWidget *dialog, *label;
i... | 0 |
206,510 | int udf_expand_file_adinicb(struct inode *inode)
{
struct page *page;
char *kaddr;
struct udf_inode_info *iinfo = UDF_I(inode);
int err;
struct writeback_control udf_wbc = {
.sync_mode = WB_SYNC_NONE,
.nr_to_write = 1,
};
WARN_ON_ONCE(!inode_is_locked(inode));
if (!iinfo->i_lenAlloc) {
if (UDF_QUERY_FLAG... | 1 |
309,878 | drv_read(TERMINAL_CONTROL_BLOCK * TCB, int *buf)
{
SCREEN *sp;
unsigned char c2 = 0;
int n;
AssertTCB();
assert(buf);
SetSP();
# if USE_PTHREADS_EINTR
if ((pthread_self) && (pthread_kill) && (pthread_equal))
_nc_globals.read_thread = pthread_self();
# endif
n = (int) read(sp->_ifd, &c... | 0 |
264,375 | const std::unordered_map<string, TensorSliceSet*>& Tensors() const {
return tensors_;
} | 0 |
230,122 | json_t * user_auth_scheme_module_load(struct config_module * config) {
UNUSED(config);
return json_pack("{si ss ss ss }",
"result", G_OK,
"name", "webauthn",
"display_name", "WebAuthn",
"description", "WebAuthn scheme module");
} | 0 |
261,760 | void RtmpProtocol::sendPeerBandwidth(uint32_t size) {
size = htonl(size);
std::string set_peerBandwidth((char *) &size, 4);
set_peerBandwidth.push_back((char) 0x02);
sendRequest(MSG_SET_PEER_BW, set_peerBandwidth);
} | 0 |
437,711 | static inline unsigned int clock_divider_to_freq(unsigned int divider,
unsigned int rollovers)
{
return DIV_ROUND_CLOSEST(CX23888_IR_REFCLK_FREQ,
(divider + 1) * rollovers);
} | 0 |
318,090 | static int rsi_write_multiple(struct rsi_hw *adapter,
u8 endpoint,
u8 *data,
u32 count)
{
struct rsi_91x_usbdev *dev;
if (!adapter)
return -ENODEV;
if (endpoint == 0)
return -EINVAL;
dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
if (dev->write_fail)
return -ENETDOWN;
return... | 0 |
229,341 | Status GetKernelOutputs(
std::vector<EagerKernelRet>* outputs, int num_outputs,
TensorHandle** retvals, EagerContext* ctx, KernelAndDevice* kernel,
const absl::optional<EagerFunctionParams>& eager_func_params) {
for (int i = 0, end = num_outputs; i < end; ++i) {
if (retvals[i] == nullptr) {
Eage... | 0 |
459,159 | static void tcf_act_put_cookie(struct flow_action_entry *entry)
{
flow_action_cookie_destroy(entry->cookie);
} | 0 |
281,131 | xfrm_secpath_reject(int idx, struct sk_buff *skb, const struct flowi *fl)
{
struct xfrm_state *x;
if (!skb->sp || idx < 0 || idx >= skb->sp->len)
return 0;
x = skb->sp->xvec[idx];
if (!x->type->reject)
return 0;
return x->type->reject(x, skb, fl);
} | 0 |
226,013 | void tpay_box_del(GF_Box *s)
{
gf_free((GF_TPAYBox *)s);
} | 0 |
225,494 | Status MutableGraphView::DeleteNodes(
const absl::flat_hash_set<string>& nodes_to_delete) {
TF_RETURN_IF_ERROR(CheckNodesCanBeDeleted(nodes_to_delete));
// Find nodes in internal state and delete.
for (const string& node_name_to_delete : nodes_to_delete) {
NodeDef* node = GetNode(node_name_to_delete);
... | 0 |
228,439 | size_t operator()(const ArrayOrObject data) const {
return data.toOpaque();
} | 0 |
229,333 | Status GetOrCreateKernelAndDevice(
EagerOperation* op, TensorHandle** retvals, int* num_retvals,
core::RefCountPtr<KernelAndDevice>* out_kernel) {
EagerContext& ctx = op->EagerContext();
Device* device = absl::get<Device*>(op->Device());
// Set the EagerOperation's device prior to extracting the input_de... | 0 |
250,689 | std::string HttpFileImpl::getMd5() const
{
return utils::getMd5(fileContent_.data(), fileContent_.size());
} | 0 |
476,140 | static int composite_ep0_queue(struct usb_composite_dev *cdev,
struct usb_request *req, gfp_t gfp_flags)
{
int ret;
ret = usb_ep_queue(cdev->gadget->ep0, req, gfp_flags);
if (ret == 0) {
if (cdev->req == req)
cdev->setup_pending = true;
else if (cdev->os_desc_req == req)
cdev->os_desc_pending = true;
... | 0 |
244,365 | GF_Err fdsa_box_size(GF_Box *s)
{
return GF_OK;
} | 0 |
418,785 | time_diff_ms(struct timeval *t1, struct timeval *t2)
{
// This handles wrapping of tv_usec correctly without any special case.
// Example of 2 pairs (tv_sec, tv_usec) with a duration of 5 ms:
// t1 = (1, 998000) t2 = (2, 3000) gives:
// (2 - 1) * 1000 + (3000 - 998000) / 1000 -> 5 ms.
return (... | 0 |
359,560 | DEFUN (bgp_redistribute_ipv4_rmap,
bgp_redistribute_ipv4_rmap_cmd,
"redistribute (connected|kernel|ospf|rip|static) route-map WORD",
"Redistribute information from another routing protocol\n"
"Connected\n"
"Kernel routes\n"
"Open Shurtest Path First (OSPF)\n"
"Routing In... | 0 |
195,908 | int btrfs_rm_device(struct btrfs_fs_info *fs_info, const char *device_path,
u64 devid)
{
struct btrfs_device *device;
struct btrfs_fs_devices *cur_devices;
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
u64 num_devices;
int ret = 0;
mutex_lock(&uuid_mutex);
num_devices = btrfs_num_devices(fs_... | 1 |
220,192 | const Edge* FindEdge(const Node* dst, int index) {
for (const Edge* e : dst->in_edges()) {
if (e->dst_input() == index) return e;
}
return nullptr;
} | 0 |
221,678 | int Socket::startSslClient(const std::string &certificate_path, String hostname)
{
if (isssl) {
stopSsl();
}
ERR_clear_error();
#if OPENSSL_VERSION_NUMBER < 0x10100000L
ctx = SSL_CTX_new(SSLv23_client_method());
#else
ctx = SSL_CTX_new(TLS_client_method());
#endif
if (ctx == NULL) {
#i... | 0 |
424,904 | void iwl_pcie_apply_destination(struct iwl_trans *trans)
{
const struct iwl_fw_dbg_dest_tlv_v1 *dest = trans->dbg.dest_tlv;
int i;
if (iwl_trans_dbg_ini_valid(trans)) {
if (!trans->dbg.num_blocks)
return;
IWL_DEBUG_FW(trans,
"WRT: Applying DRAM buffer[0] destination\n");
iwl_write_umac_prph(trans,... | 0 |
355,637 | eval6(
char_u **arg,
typval_T *rettv,
evalarg_T *evalarg,
int want_string) // after "." operator
{
#ifdef FEAT_FLOAT
int use_float = FALSE;
#endif
/*
* Get the first variable.
*/
if (eval7t(arg, rettv, evalarg, want_string) == FAIL)
return FAIL;
/*
* Repeat comput... | 0 |
226,330 |
GF_Err pcrb_box_size(GF_Box *s)
{
GF_PcrInfoBox *ptr = (GF_PcrInfoBox*) s;
ptr->size += 4;
ptr->size += ptr->subsegment_count * 6;
return GF_OK; | 0 |
247,078 | struct _gf_ft_mgr *gf_fs_get_font_manager(GF_FilterSession *fsess)
{
#ifdef GPAC_DISABLE_PLAYER
return NULL;
#else
if (!fsess->font_manager) {
fsess->font_manager = gf_font_manager_new();
}
return fsess->font_manager;
#endif
} | 0 |
229,166 | static void handle_control_message(VirtIOSerial *vser, void *buf, size_t len)
{
VirtIODevice *vdev = VIRTIO_DEVICE(vser);
struct VirtIOSerialPort *port;
VirtIOSerialPortClass *vsc;
struct virtio_console_control cpkt, *gcpkt;
uint8_t *buffer;
size_t buffer_len;
gcpkt = buf;
if (len < si... | 0 |
512,840 | cmp_item* cmp_item_row::make_same()
{
return new cmp_item_row();
} | 0 |
473,992 | st_init_numtable_with_size(st_index_t size)
{
return st_init_table_with_size(&type_numhash, size);
} | 0 |
226,150 |
void ssix_box_del(GF_Box *s)
{
u32 i;
GF_SubsegmentIndexBox *ptr = (GF_SubsegmentIndexBox *)s;
if (ptr == NULL) return;
if (ptr->subsegments) {
for (i = 0; i < ptr->subsegment_alloc; i++) {
GF_SubsegmentInfo *subsegment = &ptr->subsegments[i];
if (subsegment->ranges) gf_free(subsegment->ranges);
}
gf_f... | 0 |
409,501 | blink_state_is_inverted()
{
#ifdef FEAT_TERMRESPONSE
return rbm_status.tr_progress == STATUS_GOT
&& rcs_status.tr_progress == STATUS_GOT
&& initial_cursor_blink != initial_cursor_shape_blink;
#else
return FALSE;
#endif
} | 0 |
262,727 | njs_iterator_object_handler(njs_vm_t *vm, njs_iterator_handler_t handler,
njs_iterator_args_t *args, njs_value_t *key, int64_t i)
{
njs_int_t ret;
njs_value_t prop, *entry;
if (key != NULL) {
ret = njs_value_property(vm, args->value, key, &prop);
if (njs_slow_path(ret == NJS_ERROR))... | 0 |
445,929 | fr_window_populate_file_list (FrWindow *window,
GPtrArray *files)
{
int sort_column_id;
GtkSortType order;
int i;
if (! gtk_widget_get_realized (GTK_WIDGET (window))) {
_fr_window_stop_activity_mode (window);
return;
}
window->priv->populating_file_list = TRUE;
gtk_list_store_clea... | 0 |
446,061 | LZWPostEncode(TIFF* tif)
{
register LZWCodecState *sp = EncoderState(tif);
uint8* op = tif->tif_rawcp;
long nextbits = sp->lzw_nextbits;
unsigned long nextdata = sp->lzw_nextdata;
long outcount = sp->enc_outcount;
int nbits = sp->lzw_nbits;
if (op > sp->enc_rawlimit) {
tif->tif_rawcc = (tmsize_t)(op - tif->ti... | 0 |
220,101 | static int nfs4_setlease(struct file *file, long arg, struct file_lock **lease,
void **priv)
{
return nfs4_proc_setlease(file, arg, lease, priv);
} | 0 |
292,200 | inbound_ping_reply (session *sess, char *timestring, char *from,
const message_tags_data *tags_data)
{
unsigned long tim, nowtim, dif;
int lag = 0;
char outbuf[64];
if (strncmp (timestring, "LAG", 3) == 0)
{
timestring += 3;
lag = 1;
}
tim = strtoul (timestring, NULL, 10);
nowtim = make_ping_time ... | 0 |
232,314 | static void FixSDTPInTRAF(GF_MovieFragmentBox *moof)
{
u32 k;
if (!moof)
return;
for (k = 0; k < gf_list_count(moof->TrackList); k++) {
GF_TrackFragmentBox *traf = gf_list_get(moof->TrackList, k);
if (traf->sdtp) {
GF_TrackFragmentRunBox *trun;
u32 j = 0, sample_index = 0;
if (traf->sdtp->sampleCoun... | 0 |
226,078 | GF_Box *ftyp_box_new()
{
ISOM_DECL_BOX_ALLOC(GF_FileTypeBox, GF_ISOM_BOX_TYPE_FTYP);
return (GF_Box *)tmp;
} | 0 |
314,756 | cdf_tole2(uint16_t sv)
{
return CDF_TOLE2(sv);
} | 0 |
90,219 | bool CellularNetwork::is_gsm() const {
return network_technology_ != NETWORK_TECHNOLOGY_EVDO &&
network_technology_ != NETWORK_TECHNOLOGY_1XRTT &&
network_technology_ != NETWORK_TECHNOLOGY_UNKNOWN;
}
| 0 |
335,421 | excmd_get_cmdidx(char_u *cmd, int len)
{
cmdidx_T idx;
if (!one_letter_cmd(cmd, &idx))
for (idx = (cmdidx_T)0; (int)idx < (int)CMD_SIZE;
idx = (cmdidx_T)((int)idx + 1))
if (STRNCMP(cmdnames[(int)idx].cmd_name, cmd, (size_t)len) == 0)
break;
return idx;
} | 0 |
247,082 | Bool gf_fs_ui_event(GF_FilterSession *session, GF_Event *uievt)
{
Bool ret;
gf_mx_p(session->ui_mx);
ret = session->ui_event_proc(session->ui_opaque, uievt);
gf_mx_v(session->ui_mx);
return ret;
} | 0 |
335,089 | static int skcipher_alloc_sgl(struct sock *sk)
{
struct alg_sock *ask = alg_sk(sk);
struct skcipher_ctx *ctx = ask->private;
struct skcipher_sg_list *sgl;
struct scatterlist *sg = NULL;
sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
if (!list_empty(&ctx->tsgl))
sg = sgl->sg;
if (!sg || sgl-... | 0 |
317,229 | static int smk_curacc_msq(struct kern_ipc_perm *isp, int access)
{
struct smack_known *msp = smack_of_ipc(isp);
struct smk_audit_info ad;
int rc;
#ifdef CONFIG_AUDIT
smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
ad.a.u.ipc_id = isp->id;
#endif
rc = smk_curacc(msp, access, &ad);
rc = smk_bu_current("msq", msp,... | 0 |
197,111 | static int DecodeChunk(EXRImage *exr_image, const EXRHeader *exr_header,
const std::vector<tinyexr::tinyexr_uint64> &offsets,
const unsigned char *head, const size_t size,
std::string *err) {
int num_channels = exr_header->num_channels;
int num_s... | 1 |
310,135 | drv_setfilter(TERMINAL_CONTROL_BLOCK * TCB)
{
AssertTCB();
/* *INDENT-EQLS* */
clear_screen = ABSENT_STRING;
cursor_address = ABSENT_STRING;
cursor_down = ABSENT_STRING;
cursor_up = ABSENT_STRING;
parm_down_cursor = ABSENT_STRING;
parm_up_cursor = ABSENT_STRING;
... | 0 |
412,125 | dnsc_shared_secrets_cache_key(uint8_t* key,
uint8_t esversion,
uint8_t* pk,
uint8_t* sk)
{
key[0] = esversion;
memcpy(key + 1, pk, crypto_box_PUBLICKEYBYTES);
memcpy(key + 1 + crypto_box_PUBLICKEYBYTES, sk, crypto_box_... | 0 |
333,052 | st_pop(Frag_T **p, Frag_T *stack)
{
Frag_T *stackp;
*p = *p - 1;
stackp = *p;
if (stackp < stack)
return empty;
return **p;
} | 0 |
220,905 | void DependencyOptimizer::OptimizeNode(int node_idx,
SetVector<int>* nodes_to_simplify,
std::set<int>* nodes_to_delete) {
NodeDef* node = optimized_graph_->mutable_node(node_idx);
const bool is_noop = IsNoOp(*node);
const bool is_identi... | 0 |
242,663 | proto_register_sysdig_event(void)
{
/* XXX Match up with Sysdig's names. */
static hf_register_info hf[] = {
{ &hf_se_cpu_id,
{ "CPU ID", "sysdig.cpu_id",
FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_se_thread_id,
{ "Thread ID", "sysdig.thread_id",... | 0 |
424,939 | static int iwl_dbgfs_monitor_data_release(struct inode *inode,
struct file *file)
{
struct iwl_trans_pcie *trans_pcie =
IWL_TRANS_GET_PCIE_TRANS(inode->i_private);
if (trans_pcie->fw_mon_data.state == IWL_FW_MON_DBGFS_STATE_OPEN)
trans_pcie->fw_mon_data.state = IWL_FW_MON_DBGFS_STATE_CLOSED;
return 0;
} | 0 |
482,509 | passGetVariableNumber(
const FileInfo *file, CharsString *passLine, int *passLinepos, widechar *number) {
if (!passGetNumber(passLine, passLinepos, number)) {
compileError(file, "missing variable number");
return 0;
}
if ((*number >= 0) && (*number < NUMVAR)) return 1;
compileError(file, "variable number out ... | 0 |
509,520 | int ha_maria::index_read_idx_map(uchar * buf, uint index, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag)
{
int error;
register_handler(file);
/* Use the pushed index condition if it matches the index we're scanning */
end_range= NULL;
if (index == pushed_idx_cond_keyn... | 0 |
389,723 | check_for_string_or_list_or_blob_arg(typval_T *args, int idx)
{
if (args[idx].v_type != VAR_STRING
&& args[idx].v_type != VAR_LIST
&& args[idx].v_type != VAR_BLOB)
{
semsg(_(e_string_list_or_blob_required_for_argument_nr), idx + 1);
return FAIL;
}
return OK;
} | 0 |
275,509 | njs_vm_value_to_bytes(njs_vm_t *vm, njs_str_t *dst, njs_value_t *src)
{
u_char *start;
size_t size, length, offset;
njs_int_t ret;
njs_value_t value;
njs_typed_array_t *array;
njs_array_buffer_t *buffer;
if (njs_slow_path(src == NULL)) {
... | 0 |
313,557 | static int rose_dev_exists(rose_address *addr)
{
struct net_device *dev;
rcu_read_lock();
for_each_netdev_rcu(&init_net, dev) {
if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE &&
rosecmp(addr, (const rose_address *)dev->dev_addr) == 0)
goto out;
}
dev = NULL;
out:
rcu_read_unlock();
return dev ... | 0 |
261,951 | njs_string_create(njs_vm_t *vm, njs_value_t *value, const char *src,
size_t size)
{
njs_str_t str;
str.start = (u_char *) src;
str.length = size;
return njs_string_decode_utf8(vm, value, &str);
} | 0 |
317,314 | static int selinux_msg_msg_alloc_security(struct msg_msg *msg)
{
struct msg_security_struct *msec;
msec = selinux_msg_msg(msg);
msec->sid = SECINITSID_UNLABELED;
return 0;
} | 0 |
221,424 | static inline bool nested_npt_enabled(struct vcpu_svm *svm)
{
return svm->nested.ctl.nested_ctl & SVM_NESTED_CTL_NP_ENABLE;
} | 0 |
227,015 | IRC_PROTOCOL_CALLBACK(366)
{
struct t_irc_channel *ptr_channel;
struct t_infolist *infolist;
struct t_config_option *ptr_option;
int num_nicks, num_op, num_halfop, num_voice, num_normal, length, i;
char *string, str_nicks_count[2048], *color;
const char *prefix, *prefix_color, *nickname;
IR... | 0 |
286,733 | SWTPM_NVRAM_GetPlainData(unsigned char **plain, uint32_t *plain_length,
const unsigned char *data, uint32_t length,
uint16_t tag_data,
uint8_t hdrversion)
{
TPM_RESULT rc = 0;
tlv_data td[1];
switch (hdrversion) {
case 1:
... | 0 |
238,555 | static int check_func_proto(const struct bpf_func_proto *fn, int func_id)
{
return check_raw_mode_ok(fn) &&
check_arg_pair_ok(fn) &&
check_btf_id_ok(fn) &&
check_refcount_ok(fn, func_id) ? 0 : -EINVAL;
} | 0 |
439,170 | static MagickBooleanType IsFITS(const unsigned char *magick,const size_t length)
{
if (length < 6)
return(MagickFalse);
if (LocaleNCompare((const char *) magick,"IT0",3) == 0)
return(MagickTrue);
if (LocaleNCompare((const char *) magick,"SIMPLE",6) == 0)
return(MagickTrue);
return(MagickFalse);
} | 0 |
230,115 | static int update_credential(struct config_module * config, json_t * j_params, const char * username, const char * credential_id, int status) {
json_t * j_query;
char * username_escaped, * mod_name_escaped, * username_clause;
int res, ret;
username_escaped = h_escape_string_with_quotes(config->conn, username);... | 0 |
238,325 | void digest_algo_prints(const char *prefix)
{
struct digest_algo* d;
printf("%s%-15s\t%-20s\t%-15s\n", prefix, "name", "driver", "priority");
printf("%s--------------------------------------------------\n", prefix);
list_for_each_entry(d, &digests, list) {
printf("%s%-15s\t%-20s\t%d\n", prefix, d->base.name,
... | 0 |
238,517 | static int check_map_prog_compatibility(struct bpf_verifier_env *env,
struct bpf_map *map,
struct bpf_prog *prog)
{
enum bpf_prog_type prog_type = resolve_prog_type(prog);
/*
* Validate that trace type programs use preallocated hash maps.
*
* For programs attached to PERF events this is mandatory as ... | 0 |
487,658 | static void kernel_restart_prepare(char *cmd)
{
blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
system_state = SYSTEM_RESTART;
device_shutdown();
} | 0 |
249,975 | GF_Err DoWrite(MovieWriter *mw, GF_List *writers, GF_BitStream *bs, u8 Emulation, u64 StartOffset)
{
u32 i;
GF_Err e;
TrackWriter *writer;
u64 offset, sampOffset, predOffset;
u32 chunkNumber, descIndex, sampSize;
Bool force;
GF_StscEntry *stsc_ent;
u64 size, mdatSize = 0;
GF_ISOFile *movie = mw->movie;
/*wri... | 0 |
235,763 | Status ValidateShapes(OpKernelContext* ctx, const Tensor& hypothesis_indices,
const Tensor& hypothesis_values,
const Tensor& hypothesis_shape,
const Tensor& truth_indices, const Tensor& truth_values,
const Tensor& truth_shape) {
i... | 0 |
236,141 | GF_Err hlit_box_size(GF_Box *s)
{
s->size += 4;
return GF_OK;
} | 0 |
226,094 | GF_Box *tfra_box_new()
{
ISOM_DECL_BOX_ALLOC(GF_TrackFragmentRandomAccessBox, GF_ISOM_BOX_TYPE_TFRA);
return (GF_Box *)tmp;
} | 0 |
252,465 | static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len,
void *pUser) {
tdefl_output_buffer *p = (tdefl_output_buffer *)pUser;
size_t new_size = p->m_size + len;
if (new_size > p->m_capacity) {
size_t new_capacity = p->m_capacity;
mz_uint8 *pNew_buf;
... | 0 |
198,439 | mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *pc)
{
/* mrb_assert(MRB_PROC_CFUNC_P(proc)) */
const mrb_irep *irep = proc->body.irep;
const mrb_pool_value *pool = irep->pool;
const mrb_sym *syms = irep->syms;
mrb_code insn;
int ai = mrb_gc_arena_save(mrb);
struct mrb_jmpbuf *prev_jm... | 1 |
512,495 | void Item_in_optimizer::restore_first_argument()
{
if (!invisible_mode())
{
args[0]= ((Item_in_subselect *)args[1])->left_expr;
}
} | 0 |
437,689 | static inline void irqenable_tx(struct cx23885_dev *dev, u32 mask)
{
mask &= IRQEN_TSE;
cx23888_ir_and_or4(dev, CX23888_IR_IRQEN_REG, ~IRQEN_TSE, mask);
} | 0 |
139,211 | gfx::Rect OverlayWindowViews::CalculateControlsBounds(int x,
const gfx::Size& size) {
return gfx::Rect(
gfx::Point(x, (GetBounds().size().height() - size.height()) / 2), size);
}
| 0 |
505,658 | static int smtp_command_parse(struct smtp_command_parser *parser)
{
const unsigned char *begin;
size_t size, old_bytes = 0;
int ret;
while ((ret = i_stream_read_data(parser->input, &begin, &size,
old_bytes)) > 0) {
parser->cur = begin;
parser->end = parser->cur + size;
ret = smtp_command_parse_line(pa... | 0 |
439,107 | static MagickBooleanType ReadPSDChannelRLE(Image *image,const PSDInfo *psd_info,
const ssize_t type,MagickOffsetType *sizes,ExceptionInfo *exception)
{
MagickBooleanType
status;
size_t
length,
row_size;
ssize_t
count,
y;
unsigned char
*compact_pixels,
*pixels;
if (image->debu... | 0 |
473,964 | compile_string_node(Node* node, regex_t* reg)
{
int r, len, prev_len, slen, ambig;
OnigEncoding enc = reg->enc;
UChar *p, *prev, *end;
StrNode* sn;
sn = NSTR(node);
if (sn->end <= sn->s)
return 0;
end = sn->end;
ambig = NSTRING_IS_AMBIG(node);
p = prev = sn->s;
prev_len = enclen(enc, p, end);... | 0 |
247,160 | static void gf_fs_print_jsf_connection(GF_FilterSession *session, char *filter_name, GF_Filter *js_filter, void (*print_fn)(FILE *output, GF_SysPrintArgFlags flags, const char *fmt, ...) )
{
GF_CapsBundleStore capstore;
const char *js_name = NULL;
GF_Err e=GF_OK;
u32 i, j, count, nb_js_caps;
GF_List *sources, *sin... | 0 |
401,514 | static void invalidate_batched_entropy(void)
{
int cpu;
unsigned long flags;
for_each_possible_cpu (cpu) {
struct batched_entropy *batched_entropy;
batched_entropy = per_cpu_ptr(&batched_entropy_u32, cpu);
spin_lock_irqsave(&batched_entropy->batch_lock, flags);
batched_entropy->position = 0;
spin_unlock(... | 0 |
259,543 | static CURLUcode parseurl_and_replace(const char *url, CURLU *u,
unsigned int flags)
{
CURLUcode result;
CURLU tmpurl;
memset(&tmpurl, 0, sizeof(tmpurl));
result = parseurl(url, &tmpurl, flags);
if(!result) {
free_urlhandle(u);
*u = tmpurl;
}
else
free_url... | 0 |
221,078 | u32 gf_bs_read_ue_log_idx3(GF_BitStream *bs, const char *fname, s32 idx1, s32 idx2, s32 idx3)
{
u32 val=0, code;
s32 nb_lead = -1;
u32 bits = 0;
for (code=0; !code; nb_lead++) {
if (nb_lead>=32) {
break;
}
code = gf_bs_read_int(bs, 1);
bits++;
}
if (nb_lead>=32) {
//gf_bs_read_int keeps returning 0 ... | 0 |
487,627 | asmlinkage long sys_newuname(struct new_utsname __user * name)
{
int errno = 0;
down_read(&uts_sem);
if (copy_to_user(name, utsname(), sizeof *name))
errno = -EFAULT;
up_read(&uts_sem);
return errno;
} | 0 |
233,876 | */
static int wddx_stack_is_empty(wddx_stack *stack)
{
if (stack->top == 0) {
return 1;
} else {
return 0;
} | 0 |
437,383 | copy_opt_exact(OptExact* to, OptExact* from)
{
*to = *from;
} | 0 |
379,657 | R_API void r_anal_var_set_access(RAnalVar *var, const char *reg, ut64 access_addr, int access_type, st64 stackptr) {
r_return_if_fail (var);
st64 offset = access_addr - var->fcn->addr;
// accesses are stored ordered by offset, use binary search to get the matching existing or the index to insert a new one
size_t i... | 0 |
329,904 | mul8_8 (uint8_t a, uint8_t b)
{
uint16_t t = a * (uint16_t)b + ONE_HALF;
return ((t >> G_SHIFT) + t) >> G_SHIFT;
} | 0 |
436,138 |
static void io_ring_exit_work(struct work_struct *work)
{
struct io_ring_ctx *ctx = container_of(work, struct io_ring_ctx, exit_work);
unsigned long timeout = jiffies + HZ * 60 * 5;
struct io_tctx_exit exit;
struct io_tctx_node *node;
int ret;
/*
* If we're doing polled IO and end up having requests being
*... | 0 |
463,220 | static int find_cb(void *rock, const char *key, size_t keylen,
const char *data, size_t datalen)
{
struct find_rock *frock = (struct find_rock *) rock;
const char *mboxname, *entry, *userid;
unsigned int uid;
char newkey[MAX_MAILBOX_PATH+1];
size_t newkeylen;
struct buf value ... | 0 |
229,272 | future<utils::chunked_vector<client_data>> cql_server::get_client_data() {
utils::chunked_vector<client_data> ret;
co_await for_each_gently([&ret] (const generic_server::connection& c) {
const connection& conn = dynamic_cast<const connection&>(c);
ret.emplace_back(conn.make_client_data());
}... | 0 |
462,410 | AcceptConnReq(ptcplstn_t *pLstn, int *newSock, prop_t **peerName, prop_t **peerIP)
{
int sockflags;
struct sockaddr_storage addr;
socklen_t addrlen = sizeof(addr);
int iNewSock = -1;
DEFiRet;
iNewSock = accept(pLstn->sock, (struct sockaddr*) &addr, &addrlen);
if(iNewSock < 0) {
if(errno == EAGAIN || errno ==... | 0 |
436,054 |
static int io_uring_create(unsigned entries, struct io_uring_params *p,
struct io_uring_params __user *params)
{
struct io_ring_ctx *ctx;
struct file *file;
int ret;
if (!entries)
return -EINVAL;
if (entries > IORING_MAX_ENTRIES) {
if (!(p->flags & IORING_SETUP_CLAMP))
return -EINVAL;
entries = IO... | 0 |
225,744 |
GF_Box *stvi_box_new()
{
ISOM_DECL_BOX_ALLOC(GF_StereoVideoBox, GF_ISOM_BOX_TYPE_STVI);
return (GF_Box *)tmp; | 0 |
274,674 | callbacks_window_scroll_event(GtkWidget *widget, GdkEventScroll *event)
{
switch (event->direction) {
case GDK_SCROLL_UP:
render_zoom_display (ZOOM_IN_CMOUSE, 0, event->x, event->y);
break;
case GDK_SCROLL_DOWN:
render_zoom_display (ZOOM_OUT_CMOUSE, 0, event->x, event->y);
break;
case GDK_SCROLL_LEFT... | 0 |
336,607 | static int reds_set_migration_dest_info(RedsState *reds,
const char* dest,
int port, int secure_port,
const char* cert_subject)
{
RedsMigSpice *spice_migration = NULL;
reds_mig_release(reds->... | 0 |
369,250 | static inline int io_rw_prep_async(struct io_kiocb *req, int rw)
{
struct io_async_rw *iorw = req->async_data;
struct iovec *iov;
int ret;
/* submission path, ->uring_lock should already be taken */
ret = io_import_iovec(rw, req, &iov, &iorw->s, 0);
if (unlikely(ret < 0))
return ret;
iorw->bytes_done = 0;
i... | 0 |
455,391 | xfs_inode_clear_reclaim_tag(
struct xfs_perag *pag,
xfs_ino_t ino)
{
radix_tree_tag_clear(&pag->pag_ici_root,
XFS_INO_TO_AGINO(pag->pag_mount, ino),
XFS_ICI_RECLAIM_TAG);
xfs_perag_clear_reclaim_tag(pag);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.