functionSource stringlengths 20 97.4k | CWE-119 bool 2
classes | CWE-120 bool 2
classes | CWE-469 bool 2
classes | CWE-476 bool 2
classes | CWE-other bool 2
classes | combine int64 0 1 |
|---|---|---|---|---|---|---|
reconfigure_canvas (GooCanvas *canvas,
gboolean redraw_if_needed)
{
gint width_pixels, height_pixels;
gint window_x = 0, window_y = 0, window_width, window_height;
gint new_x_offset = 0, new_y_offset = 0;
GtkWidget *widget;
widget = GTK_WIDGET (canvas);
/* Make sure the bounds are sane. */
if (canvas->bounds.x2 < canvas->bounds.x1)
canvas->bounds.x2 = canvas->bounds.x1;
if (canvas->bounds.y2 < canvas->bounds.y1)
canvas->bounds.y2 = canvas->bounds.y1;
/* Recalculate device_to_pixels_x & device_to_pixels_y. */
recalculate_scales (canvas);
/* This is the natural size of the canvas window in pixels, rounded up to
the next pixel. */
width_pixels = ((canvas->bounds.x2 - canvas->bounds.x1) * canvas->device_to_pixels_x) + 1;
height_pixels = ((canvas->bounds.y2 - canvas->bounds.y1) * canvas->device_to_pixels_y) + 1;
/* The actual window size is always at least as big as the widget's window.*/
window_width = MAX (width_pixels, widget->allocation.width);
window_height = MAX (height_pixels, widget->allocation.height);
/* If the width or height is smaller than the window, we need to calculate
the canvas x & y offsets according to the anchor. */
if (width_pixels < widget->allocation.width)
{
switch (canvas->anchor)
{
case GTK_ANCHOR_NORTH_WEST:
case GTK_ANCHOR_WEST:
case GTK_ANCHOR_SOUTH_WEST:
new_x_offset = 0;
break;
case GTK_ANCHOR_NORTH:
case GTK_ANCHOR_CENTER:
case GTK_ANCHOR_SOUTH:
new_x_offset = (widget->allocation.width - width_pixels) / 2;
break;
case GTK_ANCHOR_NORTH_EAST:
case GTK_ANCHOR_EAST:
case GTK_ANCHOR_SOUTH_EAST:
new_x_offset = widget->allocation.width - width_pixels;
break;
}
}
if (height_pixels < widget->allocation.height)
{
switch (canvas->anchor)
{
case GTK_ANCHOR_NORTH_WEST:
case GTK_ANCHOR_NORTH:
case GTK_ANCHOR_NORTH_EAST:
new_y_offset = 0;
break;
case GTK_ANCHOR_WEST:
case GTK_ANCHOR_CENTER:
case GTK_ANCHOR_EAST:
new_y_offset = (widget->allocation.height - height_pixels) / 2;
break;
case GTK_ANCHOR_SOUTH_WEST:
case GTK_ANCHOR_SOUTH:
case GTK_ANCHOR_SOUTH_EAST:
new_y_offset = widget->allocation.height - height_pixels;
break;
}
}
canvas->freeze_count++;
if (canvas->hadjustment)
{
goo_canvas_configure_hadjustment (canvas, window_width);
window_x = - canvas->hadjustment->value;
}
if (canvas->vadjustment)
{
goo_canvas_configure_vadjustment (canvas, window_height);
window_y = - canvas->vadjustment->value;
}
canvas->freeze_count--;
#if GTK_CHECK_VERSION(2, 19, 0)
if (gtk_widget_get_realized (GTK_WIDGET(canvas)))
#else
if (GTK_WIDGET_REALIZED (canvas))
#endif
{
gdk_window_move_resize (canvas->canvas_window, window_x, window_y,
window_width, window_height);
}
/* If one of the offsets has changed we have to redraw the widget. */
if (canvas->canvas_x_offset != new_x_offset
|| canvas->canvas_y_offset != new_y_offset)
{
canvas->canvas_x_offset = new_x_offset;
canvas->canvas_y_offset = new_y_offset;
if (redraw_if_needed)
gtk_widget_queue_draw (GTK_WIDGET (canvas));
}
} | false | false | false | false | false | 0 |
show (const char *format, ...)
{
va_list arg_ptr;
if (!verbose)
return;
fprintf (stderr, "%s: ", PGM);
va_start (arg_ptr, format);
vfprintf (stderr, format, arg_ptr);
va_end (arg_ptr);
} | false | false | false | false | false | 0 |
LineParse_line(LineParse *lp){
register int ch;
g_string_truncate(lp->line, 0);
while((ch = getc(lp->fp)) != EOF){ /* read a line */
if(ch == '\n')
return lp->line->len;
g_string_append_c(lp->line, ch);
}
return lp->line->len?lp->line->len:EOF;
} | false | false | false | false | false | 0 |
_bev_group_random_element(struct bufferevent_rate_limit_group *group)
{
int which;
struct bufferevent_private *bev;
/* requires group lock */
if (!group->n_members)
return NULL;
EVUTIL_ASSERT(! TAILQ_EMPTY(&group->members));
which = _evutil_weakrand() % group->n_members;
bev = TAILQ_FIRST(&group->members);
while (which--)
bev = TAILQ_NEXT(bev, rate_limiting->next_in_group);
return bev;
} | false | false | false | false | false | 0 |
_elm_gengrid_item_unrealize(Elm_Gen_Item *it,
Eina_Bool calc)
{
Evas_Object *content;
if (!it->realized) return;
if (GG_IT(it)->wsd->reorder_it == it) return;
evas_event_freeze(evas_object_evas_get(WIDGET(it)));
if (!calc)
evas_object_smart_callback_call(WIDGET(it), SIG_UNREALIZED, it);
if (it->long_timer)
{
ecore_timer_del(it->long_timer);
it->long_timer = NULL;
}
elm_widget_stringlist_free(it->texts);
it->texts = NULL;
elm_widget_stringlist_free(it->contents);
it->contents = NULL;
elm_widget_stringlist_free(it->states);
it->states = NULL;
EINA_LIST_FREE (it->content_objs, content)
evas_object_del(content);
it->unrealize_cb(it);
it->realized = EINA_FALSE;
it->want_unrealize = EINA_FALSE;
evas_event_thaw(evas_object_evas_get(WIDGET(it)));
evas_event_thaw_eval(evas_object_evas_get(WIDGET(it)));
} | false | false | false | false | false | 0 |
nextStringLine (const char** const next)
{
char* result = NULL;
size_t length;
const char* end;
Assert (*next != NULL);
for (end = *next ; *end != '\n' && *end != '\0' ; ++end)
;
length = end - *next;
if (length > 0)
{
result = xMalloc (length + 1, char);
strncpy (result, *next, length);
result [length] = '\0';
}
if (*end == '\n')
++end;
*next = end;
return result;
} | false | true | false | false | false | 1 |
operator() (string key) throw (except_done)
{
long key_index;
MOpt::iterator iter;
iter = tDict.find (key);
if (iter == tDict.end ()) {
cerr << herr (" COpts::operator() :\n")
<< " Option not found : \"" << key << "\".\n"
<< "\n\n";
throw except_done ();
}
return ((*iter).second);
} | false | false | false | false | false | 0 |
PortamentoDown(MODCHANNEL *pChn, UINT param)
//-----------------------------------------------------------
{
if (param) pChn->nOldPortaUpDown = param; else param = pChn->nOldPortaUpDown;
if ((m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_STM)) && ((param & 0xF0) >= 0xE0))
{
if (param & 0x0F)
{
if ((param & 0xF0) == 0xF0)
{
FinePortamentoDown(pChn, param & 0x0F);
} else
if ((param & 0xF0) == 0xE0)
{
ExtraFinePortamentoDown(pChn, param & 0x0F);
}
}
return;
}
if (!(m_dwSongFlags & SONG_FIRSTTICK)) DoFreqSlide(pChn, (int)(param << 2));
} | false | false | false | false | false | 0 |
section_entry_bool_new(struct section *psection,
const char *name, bool value)
{
struct entry *pentry = entry_new(psection, name);
if (NULL != pentry) {
pentry->type = ENTRY_BOOL;
pentry->boolean.value = value;
}
return pentry;
} | false | false | false | false | false | 0 |
posix_major(PyObject *self, PyObject *args)
{
int device;
if (!PyArg_ParseTuple(args, "i:major", &device))
return NULL;
return PyLong_FromLong((long)major(device));
} | false | false | false | false | false | 0 |
kvm_assign_ioeventfd(struct kvm *kvm, struct kvm_ioeventfd *args)
{
enum kvm_bus bus_idx;
int ret;
bus_idx = ioeventfd_bus_from_flags(args->flags);
/* must be natural-word sized, or 0 to ignore length */
switch (args->len) {
case 0:
case 1:
case 2:
case 4:
case 8:
break;
default:
return -EINVAL;
}
/* check for range overflow */
if (args->addr + args->len < args->addr)
return -EINVAL;
/* check for extra flags that we don't understand */
if (args->flags & ~KVM_IOEVENTFD_VALID_FLAG_MASK)
return -EINVAL;
/* ioeventfd with no length can't be combined with DATAMATCH */
if (!args->len && (args->flags & KVM_IOEVENTFD_FLAG_DATAMATCH))
return -EINVAL;
ret = kvm_assign_ioeventfd_idx(kvm, bus_idx, args);
if (ret)
goto fail;
/* When length is ignored, MMIO is also put on a separate bus, for
* faster lookups.
*/
if (!args->len && bus_idx == KVM_MMIO_BUS) {
ret = kvm_assign_ioeventfd_idx(kvm, KVM_FAST_MMIO_BUS, args);
if (ret < 0)
goto fast_fail;
}
return 0;
fast_fail:
kvm_deassign_ioeventfd_idx(kvm, bus_idx, args);
fail:
return ret;
} | false | false | false | false | false | 0 |
dwc_handle_cyclic(struct dw_dma *dw, struct dw_dma_chan *dwc,
u32 status_block, u32 status_err, u32 status_xfer)
{
unsigned long flags;
if (status_block & dwc->mask) {
void (*callback)(void *param);
void *callback_param;
dev_vdbg(chan2dev(&dwc->chan), "new cyclic period llp 0x%08x\n",
channel_readl(dwc, LLP));
dma_writel(dw, CLEAR.BLOCK, dwc->mask);
callback = dwc->cdesc->period_callback;
callback_param = dwc->cdesc->period_callback_param;
if (callback)
callback(callback_param);
}
/*
* Error and transfer complete are highly unlikely, and will most
* likely be due to a configuration error by the user.
*/
if (unlikely(status_err & dwc->mask) ||
unlikely(status_xfer & dwc->mask)) {
int i;
dev_err(chan2dev(&dwc->chan),
"cyclic DMA unexpected %s interrupt, stopping DMA transfer\n",
status_xfer ? "xfer" : "error");
spin_lock_irqsave(&dwc->lock, flags);
dwc_dump_chan_regs(dwc);
dwc_chan_disable(dw, dwc);
/* Make sure DMA does not restart by loading a new list */
channel_writel(dwc, LLP, 0);
channel_writel(dwc, CTL_LO, 0);
channel_writel(dwc, CTL_HI, 0);
dma_writel(dw, CLEAR.BLOCK, dwc->mask);
dma_writel(dw, CLEAR.ERROR, dwc->mask);
dma_writel(dw, CLEAR.XFER, dwc->mask);
for (i = 0; i < dwc->cdesc->periods; i++)
dwc_dump_lli(dwc, &dwc->cdesc->desc[i]->lli);
spin_unlock_irqrestore(&dwc->lock, flags);
}
/* Re-enable interrupts */
channel_set_bit(dw, MASK.BLOCK, dwc->mask);
} | false | false | false | false | false | 0 |
dialog_dump(void)
{
gint i=0;
struct dialog_pak *dialog;
GSList *list;
for (list=sysenv.dialog_list ; list ; list=g_slist_next(list))
{
dialog = list->data;
printf("[%d] model: %p, type: %d\n", i++, dialog->model, dialog->type);
}
} | false | false | false | false | false | 0 |
isCons(Tree x, Tree& h, Tree& t)
{
if (isList(x)) {
h = hd(x); t = tl(x);
return true;
} else
return false;
} | false | false | false | false | false | 0 |
qla82xx_set_driver_version(scsi_qla_host_t *vha, char *version)
{
int rval;
mbx_cmd_t mc;
mbx_cmd_t *mcp = &mc;
int i;
int len;
uint16_t *str;
struct qla_hw_data *ha = vha->hw;
if (!IS_P3P_TYPE(ha))
return QLA_FUNCTION_FAILED;
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x117b,
"Entered %s.\n", __func__);
str = (void *)version;
len = strlen(version);
mcp->mb[0] = MBC_SET_RNID_PARAMS;
mcp->mb[1] = RNID_TYPE_SET_VERSION << 8;
mcp->out_mb = MBX_1|MBX_0;
for (i = 4; i < 16 && len; i++, str++, len -= 2) {
mcp->mb[i] = cpu_to_le16p(str);
mcp->out_mb |= 1<<i;
}
for (; i < 16; i++) {
mcp->mb[i] = 0;
mcp->out_mb |= 1<<i;
}
mcp->in_mb = MBX_1|MBX_0;
mcp->tov = MBX_TOV_SECONDS;
mcp->flags = 0;
rval = qla2x00_mailbox_command(vha, mcp);
if (rval != QLA_SUCCESS) {
ql_dbg(ql_dbg_mbx, vha, 0x117c,
"Failed=%x mb[0]=%x,%x.\n", rval, mcp->mb[0], mcp->mb[1]);
} else {
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x117d,
"Done %s.\n", __func__);
}
return rval;
} | false | false | false | false | false | 0 |
softhangup_exec(struct ast_channel *chan, const char *data)
{
struct ast_channel *c = NULL;
char *cut, *opts[0];
char name[AST_CHANNEL_NAME] = "", *parse;
struct ast_flags flags = {0};
int lenmatch;
AST_DECLARE_APP_ARGS(args,
AST_APP_ARG(channel);
AST_APP_ARG(options);
);
struct ast_channel_iterator *iter;
if (ast_strlen_zero(data)) {
ast_log(LOG_WARNING, "SoftHangup requires an argument (Technology/resource)\n");
return 0;
}
parse = ast_strdupa(data);
AST_STANDARD_APP_ARGS(args, parse);
if (args.argc == 2)
ast_app_parse_options(app_opts, &flags, opts, args.options);
lenmatch = strlen(args.channel);
if (!(iter = ast_channel_iterator_by_name_new(args.channel, lenmatch))) {
return -1;
}
while ((c = ast_channel_iterator_next(iter))) {
ast_channel_lock(c);
ast_copy_string(name, ast_channel_name(c), sizeof(name));
if (ast_test_flag(&flags, OPTION_ALL)) {
/* CAPI is set up like CAPI[foo/bar]/clcnt */
if (!strcmp(ast_channel_tech(c)->type, "CAPI")) {
cut = strrchr(name, '/');
/* Basically everything else is Foo/Bar-Z */
} else {
/* use strrchr() because Foo/Bar-Z could actually be Foo/B-a-r-Z */
cut = strrchr(name,'-');
}
/* Get rid of what we've cut */
if (cut)
*cut = 0;
}
if (!strcasecmp(name, args.channel)) {
ast_log(LOG_WARNING, "Soft hanging %s up.\n", ast_channel_name(c));
ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
if (!ast_test_flag(&flags, OPTION_ALL)) {
ast_channel_unlock(c);
c = ast_channel_unref(c);
break;
}
}
ast_channel_unlock(c);
c = ast_channel_unref(c);
}
ast_channel_iterator_destroy(iter);
return 0;
} | false | false | false | false | false | 0 |
ya_set_extlg_array_template(Alg_set *alg_set, Expand_tlg *extlg,
IntSet local_array, const int level)
{
Module_table *module = alg_set->module;
int **dim_size = alg_set->array_templ_dim_size;
int *array_size = alg_set->array_size;
#if 0
Array_table *atbl;
#endif
if (localize_verbose > 4) {
fprintf(stdout, "Ya_template info\n");
fput_extlg(extlg);
}
#if 0
for (atbl = module->array_head; atbl != NULL; atbl = atbl->next) {
Ya_template *template;
int entry = atbl->entry;
if (in_IntSet(local_array, entry)) {
if ((template = ya_search_template(module, atbl, dim_size[entry],
array_size[entry], level))
== NULL) {
template = ya_make_template(module, atbl, dim_size[entry],
array_size[entry], level);
ya_append_template(template);
}
if (localize_verbose > 4) {
fput_ya_template(template, atbl);
}
} else {
template = NULL;
}
alg_set->ya_template[level][entry] = template;
}
#else
if(localize_with_pa)
ya_set_extlg_array_template_body_pa(module, module->memory_access_region_head, alg_set,
dim_size, array_size, level, local_array);
else
ya_set_extlg_array_template_body(module, module->array_head, alg_set,
dim_size, array_size, level, local_array);
#endif
} | false | false | false | false | false | 0 |
jsonsl_jpr_new(const char *path, jsonsl_error_t *errp)
{
char *my_copy = NULL;
int count, curidx;
struct jsonsl_jpr_st *ret = NULL;
struct jsonsl_jpr_component_st *components = NULL;
size_t origlen;
jsonsl_error_t errstacked;
#define JPR_BAIL(err) *errp = err; goto GT_ERROR;
if (errp == NULL) {
errp = &errstacked;
}
if (path == NULL || *path != '/') {
JPR_BAIL(JSONSL_ERROR_JPR_NOROOT);
return NULL;
}
count = 1;
path++;
{
const char *c = path;
for (; *c; c++) {
if (*c == '/') {
count++;
if (*(c+1) == '/') {
JPR_BAIL(JSONSL_ERROR_JPR_DUPSLASH);
}
}
}
}
if(*path) {
count++;
}
components = (struct jsonsl_jpr_component_st *)
malloc(sizeof(*components) * count);
if (!components) {
JPR_BAIL(JSONSL_ERROR_ENOMEM);
}
my_copy = (char *)malloc(strlen(path) + 1);
if (!my_copy) {
JPR_BAIL(JSONSL_ERROR_ENOMEM);
}
strcpy(my_copy, path);
components[0].ptype = JSONSL_PATH_ROOT;
if (*my_copy) {
char *cur = my_copy;
int pathret = JSONSL_PATH_STRING;
curidx = 1;
while (pathret > 0 && curidx < count) {
pathret = populate_component(cur, components + curidx, &cur, errp);
if (pathret > 0) {
curidx++;
} else {
break;
}
}
if (pathret == JSONSL_PATH_INVALID) {
JPR_BAIL(JSONSL_ERROR_JPR_BADPATH);
}
} else {
curidx = 1;
}
path--; /*revert path to leading '/' */
origlen = strlen(path) + 1;
ret = (struct jsonsl_jpr_st *)malloc(sizeof(*ret));
if (!ret) {
JPR_BAIL(JSONSL_ERROR_ENOMEM);
}
ret->orig = (char *)malloc(origlen);
if (!ret->orig) {
JPR_BAIL(JSONSL_ERROR_ENOMEM);
}
ret->components = components;
ret->ncomponents = curidx;
ret->basestr = my_copy;
ret->norig = origlen-1;
strcpy(ret->orig, path);
return ret;
GT_ERROR:
free(my_copy);
free(components);
if (ret) {
free(ret->orig);
}
free(ret);
return NULL;
#undef JPR_BAIL
} | false | true | false | false | false | 1 |
bcma_hcd_init_chip_arm(struct bcma_device *dev)
{
bcma_core_enable(dev, 0);
if (dev->bus->chipinfo.id == BCMA_CHIP_ID_BCM4707 ||
dev->bus->chipinfo.id == BCMA_CHIP_ID_BCM53018) {
if (dev->bus->chipinfo.pkg == BCMA_PKG_ID_BCM4707 ||
dev->bus->chipinfo.pkg == BCMA_PKG_ID_BCM4708)
bcma_hcd_init_chip_arm_phy(dev);
bcma_hcd_init_chip_arm_hc(dev);
}
} | false | false | false | false | false | 0 |
findstat(int mtn, int dir, statRec *st, cond_kind kind)
{
int j;
for (j=0 ; ; j++)
if (st[j].mtn==mtn && st[j].kind==kind)
if (kind==NON || st[j].dir==dir)
break;
return j;
} | false | false | false | false | false | 0 |
e1000_free_irq(struct e1000_adapter *adapter)
{
struct net_device *netdev = adapter->netdev;
if (adapter->msix_entries) {
int vector = 0;
free_irq(adapter->msix_entries[vector].vector, netdev);
vector++;
free_irq(adapter->msix_entries[vector].vector, netdev);
vector++;
/* Other Causes interrupt vector */
free_irq(adapter->msix_entries[vector].vector, netdev);
return;
}
free_irq(adapter->pdev->irq, netdev);
} | false | false | false | false | false | 0 |
is_device(char *name, int allow_virtual)
{
char syspath[PATH_MAX];
char *slash;
/* Some devices may have a slash in their name (eg. cciss/c0d0...) */
while ((slash = strchr(name, '/'))) {
*slash = '!';
}
snprintf(syspath, sizeof(syspath), "%s/%s%s", SYSFS_BLOCK, name,
allow_virtual ? "" : "/device");
return !(access(syspath, F_OK));
} | true | true | false | false | true | 1 |
parameter_description(int param, struct PARAM_DESCRIPTION *pd) const
{
pd->default_value = 1;
pd->description = get_parameter_name(param);
pd->bounded_above = false;
pd->upper_bound = 0.0f;
pd->bounded_below = true;
pd->lower_bound = 1.0f;
pd->toggled = false;
pd->integer = true;
pd->logarithmic = false;
pd->output = false;
} | false | false | false | false | false | 0 |
maki_mode_has_parameter (makiServer* serv, gchar sign, gchar mode)
{
guint type;
const gchar* chanmodes;
if (strchr(maki_server_support(serv, MAKI_SERVER_SUPPORT_PREFIX_MODES), mode) != NULL)
{
return TRUE;
}
if ((chanmodes = maki_server_support(serv, MAKI_SERVER_SUPPORT_CHANMODES)) == NULL)
{
return FALSE;
}
for (type = 0; *chanmodes != '\0'; chanmodes++)
{
if (*chanmodes == ',')
{
type++;
continue;
}
if (*chanmodes == mode)
{
if (type == 0 || type == 1)
{
return TRUE;
}
else if (type == 2)
{
return (sign == '+');
}
else if (type == 3)
{
return FALSE;
}
}
}
return FALSE;
} | false | false | false | false | false | 0 |
tgt_unbind_host_to_target(int tid, int host_no)
{
struct bound_host *bhost;
list_for_each_entry(bhost, &bound_host_list, bhost_siblings) {
if (bhost->host_no == host_no) {
if (!list_empty(&bhost->target->it_nexus_list)) {
eprintf("the target has IT_nexus\n");
return -EBUSY;
}
list_del(&bhost->bhost_siblings);
free(bhost);
return 0;
}
}
return -ENOENT;
} | false | false | false | false | false | 0 |
gst_tag_lib_mux_change_state (GstElement * element, GstStateChange transition)
{
GstTagLibMux *mux;
GstStateChangeReturn result;
mux = GST_TAG_LIB_MUX (element);
result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (result != GST_STATE_CHANGE_SUCCESS) {
return result;
}
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:{
if (mux->newsegment_ev) {
gst_event_unref (mux->newsegment_ev);
mux->newsegment_ev = NULL;
}
if (mux->event_tags) {
gst_tag_list_free (mux->event_tags);
mux->event_tags = NULL;
}
mux->tag_size = 0;
mux->render_tag = TRUE;
break;
}
default:
break;
}
return result;
} | false | false | false | false | false | 0 |
ldapGetCn (void)
{
size_t slen = 0;
char *temp;
if (globalLdap->first_name && globalLdap->last_name)
{
slen =
strlen (globalLdap->first_name) + strlen (globalLdap->last_name) + 2;
temp = (char *) malloc (sizeof (char) * slen);
if (temp == NULL)
return NULL;
bzero (temp, slen * sizeof (char));
snprintf (temp, slen, "%s %s", globalLdap->first_name,
globalLdap->last_name);
}
else if (globalLdap->first_name)
temp = globalLdap->first_name;
else if (globalLdap->last_name)
temp = globalLdap->last_name;
else
temp = globalLdap->passent->pw_name;
return temp;
} | false | true | false | false | false | 1 |
zval_collect_white(zval *pz TSRMLS_DC)
{
Bucket *p;
tail_call:
if (((zval_gc_info*)(pz))->u.buffered == (gc_root_buffer*)GC_WHITE) {
p = NULL;
GC_ZVAL_SET_BLACK(pz);
if (Z_TYPE_P(pz) == IS_OBJECT && EG(objects_store).object_buckets) {
struct _store_object *obj = &EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].bucket.obj;
if (obj->buffered == (gc_root_buffer*)GC_WHITE) {
/* PURPLE instead of BLACK to prevent buffering in nested gc calls */
GC_SET_PURPLE(obj->buffered);
if (EXPECTED(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].valid &&
Z_OBJ_HANDLER_P(pz, get_properties) != NULL)) {
HashTable *props = Z_OBJPROP_P(pz);
if(!props) {
return;
}
p = props->pListHead;
}
}
} else {
if (Z_TYPE_P(pz) == IS_ARRAY) {
p = Z_ARRVAL_P(pz)->pListHead;
}
}
/* restore refcount and put into list to free */
pz->refcount__gc++;
((zval_gc_info*)pz)->u.next = GC_G(zval_to_free);
GC_G(zval_to_free) = (zval_gc_info*)pz;
while (p != NULL) {
pz = *(zval**)p->pData;
if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
pz->refcount__gc++;
}
if (p->pListNext == NULL) {
goto tail_call;
} else {
zval_collect_white(pz TSRMLS_CC);
}
p = p->pListNext;
}
}
} | false | false | false | false | false | 0 |
alt_name_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t len)
{
struct nd_region *nd_region = to_nd_region(dev->parent);
ssize_t rc;
device_lock(dev);
nvdimm_bus_lock(dev);
wait_nvdimm_bus_probe_idle(dev);
rc = __alt_name_store(dev, buf, len);
if (rc >= 0)
rc = nd_namespace_label_update(nd_region, dev);
dev_dbg(dev, "%s: %s(%zd)\n", __func__, rc < 0 ? "fail " : "", rc);
nvdimm_bus_unlock(dev);
device_unlock(dev);
return rc < 0 ? rc : len;
} | false | false | false | false | false | 0 |
champlain_label_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ChamplainLabelPrivate *priv = CHAMPLAIN_LABEL (object)->priv;
switch (prop_id)
{
case PROP_TEXT:
g_value_set_string (value, priv->text);
break;
case PROP_IMAGE:
g_value_set_object (value, priv->image);
break;
case PROP_USE_MARKUP:
g_value_set_boolean (value, priv->use_markup);
break;
case PROP_ALIGNMENT:
g_value_set_enum (value, priv->alignment);
break;
case PROP_COLOR:
clutter_value_set_color (value, priv->color);
break;
case PROP_TEXT_COLOR:
clutter_value_set_color (value, priv->text_color);
break;
case PROP_FONT_NAME:
g_value_set_string (value, priv->font_name);
break;
case PROP_WRAP:
g_value_set_boolean (value, priv->wrap);
break;
case PROP_WRAP_MODE:
g_value_set_enum (value, priv->wrap_mode);
break;
case PROP_DRAW_BACKGROUND:
g_value_set_boolean (value, priv->draw_background);
break;
case PROP_ELLIPSIZE:
g_value_set_enum (value, priv->ellipsize);
break;
case PROP_SINGLE_LINE_MODE:
g_value_set_enum (value, priv->single_line_mode);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
} | false | false | false | false | false | 0 |
GenerateRayDifferential(const CameraSample &sample,
RayDifferential *ray) const {
// Compute main orthographic viewing ray
// Generate raster and camera samples
Point Pras(sample.imageX, sample.imageY, 0);
Point Pcamera;
RasterToCamera(Pras, &Pcamera);
*ray = RayDifferential(Pcamera, Vector(0,0,1), 0., INFINITY);
// Modify ray for depth of field
if (lensRadius > 0.) {
// Sample point on lens
float lensU, lensV;
ConcentricSampleDisk(sample.lensU, sample.lensV, &lensU, &lensV);
lensU *= lensRadius;
lensV *= lensRadius;
// Compute point on plane of focus
float ft = focalDistance / ray->d.z;
Point Pfocus = (*ray)(ft);
// Update ray for effect of lens
ray->o = Point(lensU, lensV, 0.f);
ray->d = Normalize(Pfocus - ray->o);
}
ray->time = Lerp(sample.time, shutterOpen, shutterClose);
ray->rxOrigin = ray->o + dxCamera;
ray->ryOrigin = ray->o + dyCamera;
ray->rxDirection = ray->ryDirection = ray->d;
ray->hasDifferentials = true;
CameraToWorld(*ray, ray);
return 1.f;
} | false | false | false | false | false | 0 |
fluid_synth_get_sfont(fluid_synth_t* synth, unsigned int num)
{
fluid_sfont_t *sfont = NULL;
fluid_list_t *list;
fluid_return_val_if_fail (synth != NULL, NULL);
fluid_synth_api_enter(synth);
list = fluid_list_nth (synth->sfont_info, num);
if (list) sfont = ((fluid_sfont_info_t *)fluid_list_get (list))->sfont;
FLUID_API_RETURN(sfont);
} | false | false | false | false | false | 0 |
check_case_value (tree value)
{
if (value == NULL_TREE)
return value;
if (TREE_CODE (value) == INTEGER_CST)
/* Promote char or short to int. */
value = perform_integral_promotions (value);
else if (value != error_mark_node)
{
error ("case label does not reduce to an integer constant");
value = error_mark_node;
}
constant_expression_warning (value);
return value;
} | false | false | false | false | false | 0 |
get_command_name( const char * arg0 )
{
char *p;
char *s = fl_strdup( arg0 );
char *cmd_name = s;
#ifdef __VMS
/* vms command disk:[path]command.exe */
if ( ( p = strrchr( s, ']' ) ) )
cmd_name = p + 1;
#else
#ifdef FL_WIN32
_splitpath( arg0, NULL, NULL, cmd_name, NULL );
#else
if ( ( p = strrchr( s, '/' ) ) )
cmd_name = p + 1;
#endif
#endif
/* Remove the extension and the period */
if ( ( p = strrchr( cmd_name, '.' ) ) )
*p = '\0';
/* Prevent a valgrind warning about a possible memory leak. */
if ( s != cmd_name )
{
cmd_name = fl_strdup( cmd_name );
fl_free( s );
}
return cmd_name;
} | false | false | false | false | false | 0 |
theme_load_sound( char *name )
{
struct stat filestat;
StkSound *sound = 0;
sprintf( theme_path, "%s/%s", theme_dir, name );
if ( stat( theme_path, &filestat ) == -1 ||
( sound = stk_sound_load( -1, theme_path ) ) == 0 )
sound = stk_sound_load( -1, name );
return sound;
} | false | false | false | false | false | 0 |
findLeader(const BasicBlock *BB, uint32_t num) {
LeaderTableEntry Vals = LeaderTable[num];
if (!Vals.Val) return nullptr;
Value *Val = nullptr;
if (DT->dominates(Vals.BB, BB)) {
Val = Vals.Val;
if (isa<Constant>(Val)) return Val;
}
LeaderTableEntry* Next = Vals.Next;
while (Next) {
if (DT->dominates(Next->BB, BB)) {
if (isa<Constant>(Next->Val)) return Next->Val;
if (!Val) Val = Next->Val;
}
Next = Next->Next;
}
return Val;
} | false | false | false | false | false | 0 |
beginTurn()
{
if ( !player[actplayer].exist() )
if ( replayinfo )
if ( replayinfo->guidata[actplayer] ) {
delete replayinfo->guidata[actplayer];
replayinfo->guidata[actplayer] = NULL;
}
for ( Player::VehicleList::const_iterator i = player[actplayer].vehicleList.begin(); i != player[actplayer].vehicleList.end(); i++ )
(*i)->beginTurn();
if ( player[actplayer].exist() && player[actplayer].stat != Player::off )
sigPlayerTurnBegins( player[actplayer] );
} | false | false | false | false | false | 0 |
gst_rtp_pt_demux_clear_pt_map (GstRtpPtDemux * rtpdemux)
{
GSList *walk;
GST_OBJECT_LOCK (rtpdemux);
GST_DEBUG ("clearing pt map");
for (walk = rtpdemux->srcpads; walk; walk = g_slist_next (walk)) {
GstRtpPtDemuxPad *pad = walk->data;
pad->newcaps = TRUE;
}
GST_OBJECT_UNLOCK (rtpdemux);
} | false | false | false | false | false | 0 |
insert_address(void *address, const int free_b,
const unsigned int tot_size)
{
skip_alloc_t *new_p;
/* get a new entry */
new_p = get_slot();
if (new_p == NULL) {
/* error code set in get_slot */
return NULL;
}
if (free_b) {
new_p->sa_flags = ALLOC_FLAG_FREE;
}
else {
new_p->sa_flags = ALLOC_FLAG_USER;
}
new_p->sa_mem = address;
new_p->sa_total_size = tot_size;
/* now try and insert the slot into the skip-list */
if (! insert_slot(new_p, free_b)) {
/* Sanity check. error code set in insert_slot(). */
return NULL;
}
return new_p;
} | false | false | false | false | false | 0 |
crypt_get_iv_offset(struct crypt_device *cd)
{
if (isPLAIN(cd->type))
return cd->u.plain.hdr.skip;
if (isLUKS(cd->type))
return 0;
if (isLOOPAES(cd->type))
return cd->u.loopaes.hdr.skip;
#if CM_UNSUPPORTED
if (isTCRYPT(cd->type))
return TCRYPT_get_iv_offset(cd, &cd->u.tcrypt.hdr, &cd->u.tcrypt.params);
#endif
return 0;
} | false | false | false | false | false | 0 |
hpi_cmn_control_cache_sync_to_msg(struct hpi_control_cache *p_cache,
struct hpi_message *phm, struct hpi_response *phr)
{
struct hpi_control_cache_single *pC;
struct hpi_control_cache_info *pI;
if (phr->error)
return;
if (!find_control(phm->obj_index, p_cache, &pI)) {
HPI_DEBUG_LOG(VERBOSE,
"HPICMN find_control() failed for adap %d\n",
phm->adapter_index);
return;
}
/* pC is the default cached control strucure.
May be cast to something else in the following switch statement.
*/
pC = (struct hpi_control_cache_single *)pI;
hpi_cmn_control_cache_sync_to_msg_single(pC, phm, phr);
} | false | false | false | false | false | 0 |
image_blank(const amide_intpoint_t width, const amide_intpoint_t height, rgba_t image_color) {
GdkPixbuf * temp_image;
amide_intpoint_t i,j;
guchar * rgb_data;
if ((rgb_data = g_try_new(guchar, 3*width*height)) == NULL) {
g_warning(_("couldn't allocate memory for rgb_data for blank image"));
return NULL;
}
for (i=0 ; i < height; i++)
for (j=0; j < width; j++) {
rgb_data[i*width*3+j*3+0] = image_color.r;
rgb_data[i*width*3+j*3+1] = image_color.g;
rgb_data[i*width*3+j*3+2] = image_color.b;
}
temp_image = gdk_pixbuf_new_from_data(rgb_data, GDK_COLORSPACE_RGB,
FALSE,8,width,height,width*3*sizeof(guchar),
image_free_rgb_data, NULL);
return temp_image;
} | false | false | false | false | false | 0 |
operator+= (const Matrix3& rkMatrix) {
for (int iRow = 0; iRow < 3; iRow++) {
for (int iCol = 0; iCol < 3; iCol++) {
elt[iRow][iCol] = elt[iRow][iCol] + rkMatrix.elt[iRow][iCol];
}
}
return *this;
} | false | false | false | false | false | 0 |
gx_pattern_size_estimate(gs_pattern1_instance_t *pinst, int has_tags)
{
gx_device *tdev = pinst->saved->device;
int depth = (pinst->templat.PaintType == 2 ? 1 : tdev->color_info.depth);
int64_t raster;
int64_t size;
if (pinst->templat.uses_transparency) {
raster = (pinst->size.x * ((depth/8) + 1 + has_tags));
size = raster > max_int / pinst->size.y ? (max_int & ~0xFFFF) : raster * pinst->size.y;
} else {
raster = (pinst->size.x * depth + 7) / 8;
size = raster * pinst->size.y;
}
if (size > (int64_t)max_int)
size = (int64_t)max_int;
return (int)size;
} | false | false | false | false | false | 0 |
calcAndCacheWidth(unsigned short codePoint)
{
unsigned rowNum = codePoint >> 8;
RowInfo* row = rows[rowNum];
if (!row)
row = rows[rowNum] = new RowInfo();
unsigned width = fm.width(QChar(codePoint));
return (row->widths[codePoint & 0xFF] = qMin(width, 0xFFu));
} | false | false | false | false | false | 0 |
bjc_build_gamma_table(gx_device_bjc_printer *dev, float gamma, char color)
{ int i;
int *table;
switch(color) {
case CMYK_C:
table = dev->bjc_gamma_tableC;
break;
case CMYK_M:
table = dev->bjc_gamma_tableM;
break;
case CMYK_Y:
table = dev->bjc_gamma_tableY;
break;
case CMYK_K:
default:
table = dev->bjc_gamma_tableK;
break;
}
if(gamma == 1.0) for (i = 0; i < 256; i++) table[i] = (255 - i) << 4;
else for (i = 0; i < 256; i++) table[i] =
4080 - (int)(pow((double)i / 255.0, gamma) * 4080.0 + .5);
} | false | false | false | false | false | 0 |
formatOutput(MSString& str_)
{
static const char blank[]={" "};
A outStr=aplus_nl;
if (model() && ((AplusModel *)model())->aplusVar())
{
V v=((AplusModel*)model())->aplusVar();
A a=((AplusModel*)model())->a();
ACharStrFunction *outFunc=((AplusModel *)model())->getOutFunc(v);
if (outFunc!=0)
{
outStr=(A)outFunc->invoke(v,a);
outStr=(outStr->t==Ct)?outStr:aplus_nl;
}
}
if (isNull(outStr)==MSTrue) return (char *) 0;
str_ = (Ct==outStr->t) ? (const char *)outStr->p : blank;
dc(outStr);
return str_;
} | false | false | false | false | false | 0 |
ab3100_registers_print(struct seq_file *s, void *p)
{
struct ab3100 *ab3100 = s->private;
u8 value;
u8 reg;
seq_puts(s, "AB3100 registers:\n");
for (reg = 0; reg < 0xff; reg++) {
ab3100_get_register_interruptible(ab3100, reg, &value);
seq_printf(s, "[0x%x]: 0x%x\n", reg, value);
}
return 0;
} | false | false | false | false | false | 0 |
nct7802_write_fan_min(struct nct7802_data *data, u8 reg_fan_low,
u8 reg_fan_high, unsigned long limit)
{
int err;
if (limit)
limit = DIV_ROUND_CLOSEST(1350000U, limit);
else
limit = 0x1fff;
limit = clamp_val(limit, 0, 0x1fff);
mutex_lock(&data->access_lock);
err = regmap_write(data->regmap, reg_fan_low, limit & 0xff);
if (err < 0)
goto abort;
err = regmap_write(data->regmap, reg_fan_high, (limit & 0x1f00) >> 5);
abort:
mutex_unlock(&data->access_lock);
return err;
} | false | false | false | false | false | 0 |
isWhitespace(const QChar& c)
{
unsigned short u = c.unicode();
if (u > 0x20)
return false;
return u == ' ' || u == '\n' || u == '\r' || u == '\t';
} | false | false | false | false | false | 0 |
ea_calendar_cell_get_index_in_parent (AtkObject *accessible)
{
GObject *g_obj;
ECalendarCell *cell;
AtkObject *parent;
g_return_val_if_fail (EA_IS_CALENDAR_CELL (accessible), -1);
g_obj = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (accessible));
if (!g_obj)
return -1;
cell = E_CALENDAR_CELL (g_obj);
parent = atk_object_get_parent (accessible);
return atk_table_get_index_at (
ATK_TABLE (parent),
cell->row, cell->column);
} | false | false | false | false | false | 0 |
vm_thread_start(struct vm_object *vmthread)
{
/* Force object finalizer execution for vmthread */
if (gc_register_finalizer(vmthread, vm_object_finalizer)) {
throw_internal_error();
return -1;
}
struct vm_thread *thread = vm_thread_alloc();
if (!thread) {
throw_oom_error();
return -1;
}
struct vm_exec_env *ee = alloc_exec_env();
if (!ee) {
throw_oom_error();
goto out_free_thread;
}
pthread_attr_t attr;
if (pthread_attr_init(&attr)) {
throw_internal_error();
goto out_free_thread;
}
if (pthread_attr_setdetachstate(&attr, true)) {
throw_internal_error();
goto out_free_thread;
}
/* XXX: no need to lock because @thread is not yet visible to
* other threads. */
thread->vmthread = vmthread;
atomic_set(&thread->state, VM_THREAD_STATE_RUNNABLE);
field_set_object(vmthread, vm_java_lang_VMThread_vmdata,
(struct vm_object *) thread);
if (!vm_thread_is_daemon(thread)) {
pthread_mutex_lock(&threads_mutex);
nr_non_daemons++;
pthread_mutex_unlock(&threads_mutex);
}
pthread_mutex_lock(&threads_mutex);
while (thread_count_locked)
pthread_cond_wait(&thread_count_lock_cond, &threads_mutex);
vm_thread_attach_thread(thread);
thread->ee = ee;
thread->ee->thread = thread;
if (pthread_create(&thread->posix_id, &attr, &vm_thread_entry, thread->ee)) {
vm_thread_detach_thread(thread);
thread->ee = NULL;
free_exec_env(ee);
pthread_mutex_unlock(&threads_mutex);
signal_new_exception(vm_java_lang_Error, "Unable to create native thread");
return -1;
}
pthread_mutex_unlock(&threads_mutex);
pthread_attr_destroy(&attr);
return 0;
out_free_thread:
vm_thread_free(thread);
return -1;
} | false | false | false | false | false | 0 |
gdata_parsable_get_xml (GDataParsable *self)
{
GString *xml_string;
g_return_val_if_fail (GDATA_IS_PARSABLE (self), NULL);
xml_string = g_string_sized_new (1000);
g_string_append (xml_string, "<?xml version='1.0' encoding='UTF-8'?>");
_gdata_parsable_get_xml (self, xml_string, TRUE);
return g_string_free (xml_string, FALSE);
} | false | false | false | false | false | 0 |
on_eos_event (GtkWidget *widget, TotemObject *totem)
{
reset_seek_status (totem);
if (bacon_video_widget_get_logo_mode (totem->bvw) != FALSE)
return FALSE;
if (totem_playlist_has_next_mrl (totem->playlist) == FALSE &&
totem_playlist_get_repeat (totem->playlist) == FALSE &&
(totem_playlist_get_last (totem->playlist) != 0 ||
totem_is_seekable (totem) == FALSE)) {
char *mrl, *subtitle;
/* Set play button status */
totem_playlist_set_at_start (totem->playlist);
update_buttons (totem);
totem_action_stop (totem);
mrl = totem_playlist_get_current_mrl (totem->playlist, &subtitle);
totem_action_set_mrl_with_warning (totem, mrl, subtitle, FALSE);
bacon_video_widget_pause (totem->bvw);
g_free (mrl);
g_free (subtitle);
} else {
if (totem_playlist_get_last (totem->playlist) == 0 &&
totem_is_seekable (totem)) {
if (totem_playlist_get_repeat (totem->playlist) != FALSE) {
totem_action_seek_time (totem, 0, FALSE);
totem_action_play (totem);
} else {
totem_action_pause (totem);
totem_action_seek_time (totem, 0, FALSE);
}
} else {
totem_action_next (totem);
}
}
return FALSE;
} | false | false | false | false | false | 0 |
tms34010_get_reg(int regnum)
{
switch (regnum)
{
case REG_PC:
case TMS34010_PC: return PC;
case REG_SP:
case TMS34010_SP: return SP;
case TMS34010_ST: return ST;
case TMS34010_A0: return AREG(0);
case TMS34010_A1: return AREG(1);
case TMS34010_A2: return AREG(2);
case TMS34010_A3: return AREG(3);
case TMS34010_A4: return AREG(4);
case TMS34010_A5: return AREG(5);
case TMS34010_A6: return AREG(6);
case TMS34010_A7: return AREG(7);
case TMS34010_A8: return AREG(8);
case TMS34010_A9: return AREG(9);
case TMS34010_A10: return AREG(10);
case TMS34010_A11: return AREG(11);
case TMS34010_A12: return AREG(12);
case TMS34010_A13: return AREG(13);
case TMS34010_A14: return AREG(14);
case TMS34010_B0: return BREG(BINDEX(0));
case TMS34010_B1: return BREG(BINDEX(1));
case TMS34010_B2: return BREG(BINDEX(2));
case TMS34010_B3: return BREG(BINDEX(3));
case TMS34010_B4: return BREG(BINDEX(4));
case TMS34010_B5: return BREG(BINDEX(5));
case TMS34010_B6: return BREG(BINDEX(6));
case TMS34010_B7: return BREG(BINDEX(7));
case TMS34010_B8: return BREG(BINDEX(8));
case TMS34010_B9: return BREG(BINDEX(9));
case TMS34010_B10: return BREG(BINDEX(10));
case TMS34010_B11: return BREG(BINDEX(11));
case TMS34010_B12: return BREG(BINDEX(12));
case TMS34010_B13: return BREG(BINDEX(13));
case TMS34010_B14: return BREG(BINDEX(14));
/* TODO: return contents of [SP + wordsize * (CPU_SP_CONTENTS-regnum)] */
default:
if (regnum <= REG_SP_CONTENTS)
{
unsigned offset = SP + 4 * (REG_SP_CONTENTS - regnum);
return (cpu_readmem29lew_word(TOBYTE(offset)+2) << 16) | cpu_readmem29lew_word(TOBYTE(offset));
}
}
return 0;
} | false | false | false | false | false | 0 |
clear_task (GtkSourceSearchContext *search)
{
if (search->priv->task_region != NULL)
{
gtk_text_region_destroy (search->priv->task_region);
search->priv->task_region = NULL;
}
if (search->priv->task != NULL)
{
GCancellable *cancellable = g_task_get_cancellable (search->priv->task);
if (cancellable != NULL)
{
g_cancellable_cancel (cancellable);
g_task_return_error_if_cancelled (search->priv->task);
}
g_clear_object (&search->priv->task);
}
} | false | false | false | false | false | 0 |
hsv(double H, double S, double V) {
H = fmod(H,6.0); if (H < 0.0) H += 6.0;
if (S < 0.0) S = 0.0; else if (S > 1.0) S = 1.0;
if (V < 0.0) V = 0.0; else if (V > 1.0) V = 1.0;
if (H == hue_ && S == saturation_ && V == value_) return 0;
double ph = hue_;
double ps = saturation_;
double pv = value_;
hue_ = H; saturation_ = S; value_ = V;
if (value_ != pv) {
#ifdef UPDATE_HUE_BOX
huebox.damage(FL_DAMAGE_SCROLL);
#endif
valuebox.damage(FL_DAMAGE_EXPOSE);}
if (hue_ != ph || saturation_ != ps) {
huebox.damage(FL_DAMAGE_EXPOSE);
valuebox.damage(FL_DAMAGE_SCROLL);
}
hsv2rgb(H,S,V,r_,g_,b_);
set_valuators();
set_changed();
return 1;
} | false | false | false | false | false | 0 |
isKnownPredicate(ICmpInst::Predicate Pred,
const SCEV *X,
const SCEV *Y) const {
if (Pred == CmpInst::ICMP_EQ ||
Pred == CmpInst::ICMP_NE) {
if ((isa<SCEVSignExtendExpr>(X) &&
isa<SCEVSignExtendExpr>(Y)) ||
(isa<SCEVZeroExtendExpr>(X) &&
isa<SCEVZeroExtendExpr>(Y))) {
const SCEVCastExpr *CX = cast<SCEVCastExpr>(X);
const SCEVCastExpr *CY = cast<SCEVCastExpr>(Y);
const SCEV *Xop = CX->getOperand();
const SCEV *Yop = CY->getOperand();
if (Xop->getType() == Yop->getType()) {
X = Xop;
Y = Yop;
}
}
}
if (SE->isKnownPredicate(Pred, X, Y))
return true;
// If SE->isKnownPredicate can't prove the condition,
// we try the brute-force approach of subtracting
// and testing the difference.
// By testing with SE->isKnownPredicate first, we avoid
// the possibility of overflow when the arguments are constants.
const SCEV *Delta = SE->getMinusSCEV(X, Y);
switch (Pred) {
case CmpInst::ICMP_EQ:
return Delta->isZero();
case CmpInst::ICMP_NE:
return SE->isKnownNonZero(Delta);
case CmpInst::ICMP_SGE:
return SE->isKnownNonNegative(Delta);
case CmpInst::ICMP_SLE:
return SE->isKnownNonPositive(Delta);
case CmpInst::ICMP_SGT:
return SE->isKnownPositive(Delta);
case CmpInst::ICMP_SLT:
return SE->isKnownNegative(Delta);
default:
llvm_unreachable("unexpected predicate in isKnownPredicate");
}
} | false | false | false | false | false | 0 |
arena_new(arena_t *arena, unsigned ind)
{
unsigned i;
arena_bin_t *bin;
arena->ind = ind;
arena->nthreads = 0;
if (malloc_mutex_init(&arena->lock))
return (true);
if (config_stats) {
memset(&arena->stats, 0, sizeof(arena_stats_t));
arena->stats.lstats =
(malloc_large_stats_t *)base_alloc(nlclasses *
sizeof(malloc_large_stats_t));
if (arena->stats.lstats == NULL)
return (true);
memset(arena->stats.lstats, 0, nlclasses *
sizeof(malloc_large_stats_t));
if (config_tcache)
ql_new(&arena->tcache_ql);
}
if (config_prof)
arena->prof_accumbytes = 0;
arena->dss_prec = chunk_dss_prec_get();
/* Initialize chunks. */
arena_chunk_dirty_new(&arena->chunks_dirty);
arena->spare = NULL;
arena->nactive = 0;
arena->ndirty = 0;
arena->npurgatory = 0;
arena_avail_tree_new(&arena->runs_avail);
/* Initialize bins. */
for (i = 0; i < NBINS; i++) {
bin = &arena->bins[i];
if (malloc_mutex_init(&bin->lock))
return (true);
bin->runcur = NULL;
arena_run_tree_new(&bin->runs);
if (config_stats)
memset(&bin->stats, 0, sizeof(malloc_bin_stats_t));
}
return (false);
} | false | false | false | false | false | 0 |
fs_decimal_init_from_str(fs_decimal *d, const char *str)
{
fs_decimal_init(d);
int decpos = -1;
int negative = 0;
int len = strlen(str);
for (int cpos = 0; str[cpos]; cpos++) {
if (str[cpos] < '0' || str[cpos] > '9') {
if (str[cpos] == '-' && cpos == 0) {
negative = 1;
d->flags = FS_D_NEGATIVE;
} else if (str[cpos] == '+' && cpos == 0) {
/* do nothing, +ve is default */
} else if (str[cpos] == '.') {
if (decpos == -1) {
decpos = cpos;
} else {
d->flags = FS_D_SYNTAX_ERROR;
return 1;
}
} else {
d->flags = FS_D_SYNTAX_ERROR;
return 1;
}
}
}
if (decpos == -1) decpos = len;
int offset = negative ? 1 : 0;
for (int cpos = offset; cpos < decpos; cpos++) {
int dpos = FS_D_OVER_DIGITS + FS_D_INT_DIGITS - decpos + cpos;
d->digit[dpos] = str[cpos] - '0';
}
for (int cpos = decpos + 1; cpos < len; cpos++) {
int dpos = FS_D_OVER_DIGITS + FS_D_INT_DIGITS - decpos + cpos - 1;
d->digit[dpos] = str[cpos] - '0';
}
return 0;
} | false | true | false | false | false | 1 |
snd_config_expand(snd_config_t *config, snd_config_t *root, const char *args,
snd_config_t *private_data, snd_config_t **result)
{
int err;
snd_config_t *defs, *subs = NULL, *res;
err = snd_config_search(config, "@args", &defs);
if (err < 0) {
if (args != NULL) {
SNDERR("Unknown parameters %s", args);
return -EINVAL;
}
err = snd_config_copy(&res, config);
if (err < 0)
return err;
} else {
err = snd_config_top(&subs);
if (err < 0)
return err;
err = load_defaults(subs, defs);
if (err < 0) {
SNDERR("Load defaults error: %s", snd_strerror(err));
goto _end;
}
err = parse_args(subs, args, defs);
if (err < 0) {
SNDERR("Parse arguments error: %s", snd_strerror(err));
goto _end;
}
err = snd_config_evaluate(subs, root, private_data, NULL);
if (err < 0) {
SNDERR("Args evaluate error: %s", snd_strerror(err));
goto _end;
}
err = snd_config_walk(config, root, &res, _snd_config_expand, subs);
if (err < 0) {
SNDERR("Expand error (walk): %s", snd_strerror(err));
goto _end;
}
}
err = snd_config_evaluate(res, root, private_data, NULL);
if (err < 0) {
SNDERR("Evaluate error: %s", snd_strerror(err));
snd_config_delete(res);
goto _end;
}
*result = res;
err = 1;
_end:
if (subs)
snd_config_delete(subs);
return err;
} | false | false | false | false | false | 0 |
InsertInSRQ(U8 type,U8 id,void* arg) {
P_SQC pcell;
U8 cnt;
U8 heed;
IRQ_DISABLE_SAVE();
if (ServiceReq.cnt >= CFG_MAX_SERVICE_REQUEST) {
IRQ_ENABLE_RESTORE ();
return Co_FALSE; /* Error return */
}
cnt = Inc8(&ServiceReq.cnt);
heed = ServiceReq.head;
IsrReq = Co_TRUE;
pcell = &ServiceReq.cell[((cnt+heed)%CFG_MAX_SERVICE_REQUEST)];/*the tail */
pcell->type = type; /* Save service request type, */
pcell->id = id; /* event id */
pcell->arg = arg; /* and parameter */
IRQ_ENABLE_RESTORE ();
return Co_TRUE; /* Return OK */
} | false | false | false | false | false | 0 |
c_parser_objc_message_args (c_parser *parser)
{
tree sel = c_parser_objc_selector (parser);
tree list = NULL_TREE;
if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
return sel;
while (true)
{
tree keywordexpr;
if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
return error_mark_node;
keywordexpr = c_parser_objc_keywordexpr (parser);
list = chainon (list, build_tree_list (sel, keywordexpr));
sel = c_parser_objc_selector (parser);
if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
break;
}
return list;
} | false | false | false | false | false | 0 |
zv_slash(x1, x2, out)
ZVEC *x1, *x2, *out;
{
int i;
Real r2, t_re, t_im;
complex tmp;
if ( ! x1 || ! x2 )
error(E_NULL,"zv_slash");
if ( x1->dim != x2->dim )
error(E_SIZES,"zv_slash");
out = zv_resize(out,x1->dim);
for ( i = 0; i < x1->dim; i++ )
{
r2 = x1->ve[i].re*x1->ve[i].re + x1->ve[i].im*x1->ve[i].im;
if ( r2 == 0.0 )
error(E_SING,"zv_slash");
tmp.re = x1->ve[i].re / r2;
tmp.im = - x1->ve[i].im / r2;
t_re = tmp.re*x2->ve[i].re - tmp.im*x2->ve[i].im;
t_im = tmp.re*x2->ve[i].im - tmp.im*x2->ve[i].re;
out->ve[i].re = t_re;
out->ve[i].im = t_im;
}
return out;
} | false | false | false | true | false | 1 |
ace_load_jumbo_rx_ring(struct net_device *dev, int nr_bufs)
{
struct ace_private *ap = netdev_priv(dev);
struct ace_regs __iomem *regs = ap->regs;
short i, idx;
idx = ap->rx_jumbo_skbprd;
for (i = 0; i < nr_bufs; i++) {
struct sk_buff *skb;
struct rx_desc *rd;
dma_addr_t mapping;
skb = netdev_alloc_skb_ip_align(dev, ACE_JUMBO_BUFSIZE);
if (!skb)
break;
mapping = pci_map_page(ap->pdev, virt_to_page(skb->data),
offset_in_page(skb->data),
ACE_JUMBO_BUFSIZE,
PCI_DMA_FROMDEVICE);
ap->skb->rx_jumbo_skbuff[idx].skb = skb;
dma_unmap_addr_set(&ap->skb->rx_jumbo_skbuff[idx],
mapping, mapping);
rd = &ap->rx_jumbo_ring[idx];
set_aceaddr(&rd->addr, mapping);
rd->size = ACE_JUMBO_BUFSIZE;
rd->idx = idx;
idx = (idx + 1) % RX_JUMBO_RING_ENTRIES;
}
if (!i)
goto error_out;
atomic_add(i, &ap->cur_jumbo_bufs);
ap->rx_jumbo_skbprd = idx;
if (ACE_IS_TIGON_I(ap)) {
struct cmd cmd;
cmd.evt = C_SET_RX_JUMBO_PRD_IDX;
cmd.code = 0;
cmd.idx = ap->rx_jumbo_skbprd;
ace_issue_cmd(regs, &cmd);
} else {
writel(idx, ®s->RxJumboPrd);
wmb();
}
out:
clear_bit(0, &ap->jumbo_refill_busy);
return;
error_out:
if (net_ratelimit())
printk(KERN_INFO "Out of memory when allocating "
"jumbo receive buffers\n");
goto out;
} | false | false | false | false | false | 0 |
reduce_erroneous_units (NODE_T * p)
{
/* Constructs are reduced to units in an attempt to limit spurious diagnostics */
NODE_T *q;
for (q = p; q != NO_NODE; FORWARD (q)) {
/* Some implementations allow selection from a tertiary, when there is no risk
of ambiguity. Algol68G follows RR, so some extra attention here to guide an
unsuspecting user */
if (whether (q, SELECTOR, -SECONDARY, STOP)) {
diagnostic_node (A68_SYNTAX_ERROR, NEXT (q), ERROR_SYNTAX_EXPECTED, SECONDARY);
reduce (q, NO_NOTE, NO_TICK, UNIT, SELECTOR, WILDCARD, STOP);
}
/* Attention for identity relations that require tertiaries */
if (whether (q, -TERTIARY, IS_SYMBOL, TERTIARY, STOP) || whether (q, TERTIARY, IS_SYMBOL, -TERTIARY, STOP) || whether (q, -TERTIARY, IS_SYMBOL, -TERTIARY, STOP)) {
diagnostic_node (A68_SYNTAX_ERROR, NEXT (q), ERROR_SYNTAX_EXPECTED, TERTIARY);
reduce (q, NO_NOTE, NO_TICK, UNIT, WILDCARD, IS_SYMBOL, WILDCARD, STOP);
} else if (whether (q, -TERTIARY, ISNT_SYMBOL, TERTIARY, STOP) || whether (q, TERTIARY, ISNT_SYMBOL, -TERTIARY, STOP) || whether (q, -TERTIARY, ISNT_SYMBOL, -TERTIARY, STOP)) {
diagnostic_node (A68_SYNTAX_ERROR, NEXT (q), ERROR_SYNTAX_EXPECTED, TERTIARY);
reduce (q, NO_NOTE, NO_TICK, UNIT, WILDCARD, ISNT_SYMBOL, WILDCARD, STOP);
}
}
} | false | false | false | false | false | 0 |
reallocate(size_t size)
{
if (size>datasize){
return allocate(size);
}
size_t alignment = (reinterpret_cast<size_t>(pdata))&(GEM_VECTORALIGNMENT/8-1);
size_t offset = (alignment == 0?0:(GEM_VECTORALIGNMENT/8-alignment));
notowned=false;
data=pdata+offset;
return data;
} | false | false | false | false | false | 0 |
segment_extend(Segment *segment, size_t req_length)
{
int i, st;
char ch;
off_t pos;
size_t ext, new_length;
if (segment == NULL)
return(-1);
if (!segment_done_init)
return(-1);
if (system_mmap_mapfixed_works != 1)
return(-1);
if (segment->status == SEGMENT_UNKNOWN)
return(-1);
new_length = nbytes_to_pagebytes(req_length);
if (new_length <= segment->length) {
segment->req_length = req_length;
return(1);
}
st = -1;
if (lockf(segment->fd_lock, F_LOCK, 0) == -1) {
segment->errmsg = ds_xprintf("lockf: %s", strerror(errno));
goto fail;
}
/*
* The backing store file must be extended.
* Note: whether ftruncate() can grow a file is unspecified and
* non-portable.
* FreeBSD's mmap(2) says:
* "Extending a file with ftruncate(2), thus creating a big hole,
* and then filling the hole by modifying a shared mmap() can lead to
* severe file fragmentation. In order to avoid such fragmentation you
* should always pre-allocate the file's backing store by
* write()ing zero's into the newly extended area prior to
* modifying the area via your mmap()."
*/
ext = new_length - segment->length;
if ((pos = lseek(segment->fd_shm, 0, SEEK_END)) == (off_t) -1) {
segment->errmsg = ds_xprintf("lseek: %s", strerror(errno));
goto fail;
}
ch = 0;
for (i = 0; i < ext; i++) {
if ((st = write(segment->fd_shm, &ch, 1)) == -1) {
segment->errmsg = ds_xprintf("write: %s", strerror(errno));
goto fail;
}
}
/*
* Map the shared memory object.
* The actual length has been rounded up to the nearest multiple of
* the system's page size since mmap() does that anyway.
*/
segment->ptr = mmap(segment->ptr, new_length,
PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED,
segment->fd_shm, 0);
if (segment->ptr == MAP_FAILED) {
segment->errmsg = ds_xprintf("mmap: %s", strerror(errno));
goto fail;
}
st = 1;
segment->req_length = req_length;
segment->length = new_length;
fail:
lseek(segment->fd_lock, 0, SEEK_SET);
lockf(segment->fd_lock, F_ULOCK, 0);
return(st);
} | false | false | false | false | false | 0 |
ocfs2_refcount_unlock(struct ocfs2_refcount_tree *ref_tree, int ex)
{
int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
struct ocfs2_lock_res *lockres = &ref_tree->rf_lockres;
struct ocfs2_super *osb = lockres->l_priv;
if (!ocfs2_mount_local(osb))
ocfs2_cluster_unlock(osb, lockres, level);
} | false | false | false | false | false | 0 |
pixConvert24To32(PIX *pixs)
{
l_uint8 *lines;
l_int32 w, h, d, i, j, wpls, wpld, rval, gval, bval;
l_uint32 pixel;
l_uint32 *datas, *datad, *lined;
PIX *pixd;
PROCNAME("pixConvert24to32");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
pixGetDimensions(pixs, &w, &h, &d);
if (d != 24)
return (PIX *)ERROR_PTR("pixs not 24 bpp", procName, NULL);
pixd = pixCreateNoInit(w, h, 32);
datas = pixGetData(pixs);
datad = pixGetData(pixd);
wpls = pixGetWpl(pixs);
wpld = pixGetWpl(pixd);
for (i = 0; i < h; i++) {
lines = (l_uint8 *)(datas + i * wpls);
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
rval = *lines++;
gval = *lines++;
bval = *lines++;
composeRGBPixel(rval, gval, bval, &pixel);
lined[j] = pixel;
}
}
pixCopyResolution(pixd, pixs);
pixCopyInputFormat(pixd, pixs);
return pixd;
} | false | false | false | false | false | 0 |
resetGids(void)
{
#ifdef HAVE_INITGROUPS
if (setgroups(0, &p->pw_gid /* anything */) < 0) {
logError("restoring groups failed: %m\n");
return False;
}
#endif
if (setgid(0) < 0) {
logError("restoring gid failed: %m\n");
return False;
}
return True;
} | false | false | false | false | false | 0 |
Perl_ck_exists(pTHX_ OP *o)
{
dVAR;
PERL_ARGS_ASSERT_CK_EXISTS;
o = ck_fun(o);
if (o->op_flags & OPf_KIDS) {
OP * const kid = cUNOPo->op_first;
if (kid->op_type == OP_ENTERSUB) {
(void) ref(kid, o->op_type);
if (kid->op_type != OP_RV2CV
&& !(PL_parser && PL_parser->error_count))
Perl_croak(aTHX_ "%s argument is not a subroutine name",
OP_DESC(o));
o->op_private |= OPpEXISTS_SUB;
}
else if (kid->op_type == OP_AELEM)
o->op_flags |= OPf_SPECIAL;
else if (kid->op_type != OP_HELEM)
Perl_croak(aTHX_ "%s argument is not a HASH or ARRAY element or a subroutine",
OP_DESC(o));
op_null(kid);
}
return o;
} | false | false | false | false | false | 0 |
print_deadlock_bug(struct task_struct *curr, struct held_lock *prev,
struct held_lock *next)
{
if (!debug_locks_off_graph_unlock() || debug_locks_silent)
return 0;
printk("\n");
printk("=============================================\n");
printk("[ INFO: possible recursive locking detected ]\n");
print_kernel_ident();
printk("---------------------------------------------\n");
printk("%s/%d is trying to acquire lock:\n",
curr->comm, task_pid_nr(curr));
print_lock(next);
printk("\nbut task is already holding lock:\n");
print_lock(prev);
printk("\nother info that might help us debug this:\n");
print_deadlock_scenario(next, prev);
lockdep_print_held_locks(curr);
printk("\nstack backtrace:\n");
dump_stack();
return 0;
} | false | true | false | false | true | 1 |
check_stab(struct csa *csa, double tol_dj)
{ int n = csa->n;
char *stat = csa->stat;
double *cbar = csa->cbar;
int j;
for (j = 1; j <= n; j++)
{ if (cbar[j] < - tol_dj)
if (stat[j] == GLP_NL || stat[j] == GLP_NF) return 1;
if (cbar[j] > + tol_dj)
if (stat[j] == GLP_NU || stat[j] == GLP_NF) return 1;
}
return 0;
} | false | false | false | false | false | 0 |
OutputMolsFromReaction
(OBReaction* pReact, OBConversion* pConv, OBFormat* pFormat)
{
//Output all the constituent molecules of the reaction
//Collect the molecules first, just for convenience
vector<obsharedptr<OBMol> > mols;
unsigned i;
for(i=0;i<pReact->NumReactants();i++)
mols.push_back(pReact->GetReactant(i));
for(i=0;i<pReact->NumProducts();i++)
mols.push_back(pReact->GetProduct(i));
if(pReact->GetAgent())
mols.push_back(pReact->GetAgent());
if(pReact->GetTransitionState())
mols.push_back(pReact->GetTransitionState());
pConv->SetOutputIndex(pConv->GetOutputIndex() - 1); // The OBReaction object is not output
if((pFormat->Flags() & WRITEONEONLY) && mols.size()>1)
{
stringstream ss;
ss << "There are " << mols.size() << " molecules to be output,"
<< "but this format is for single molecules only";
obErrorLog.ThrowError(__FUNCTION__, ss.str(), obWarning);
mols.resize(1);
}
bool ok = true;
for(i=0;i<mols.size() && ok;++i)
{
if(mols[i])
{
//Have to do set these manually because not using "Convert" interface
pConv->SetLast(i==mols.size()-1);
pConv->SetOutputIndex(pConv->GetOutputIndex()+1);
ok = pFormat->WriteMolecule(
mols[i]->DoTransformations(pConv->GetOptions(OBConversion::GENOPTIONS), pConv),pConv);
}
}
return ok;
} | false | false | false | false | false | 0 |
emitFPUDefaultAttributes() {
switch (FPU) {
case ARM::FK_VFP:
case ARM::FK_VFPV2:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv2,
/* OverwriteExisting= */ false);
break;
case ARM::FK_VFPV3:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv3A,
/* OverwriteExisting= */ false);
break;
case ARM::FK_VFPV3_FP16:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv3A,
/* OverwriteExisting= */ false);
setAttributeItem(ARMBuildAttrs::FP_HP_extension,
ARMBuildAttrs::AllowHPFP,
/* OverwriteExisting= */ false);
break;
case ARM::FK_VFPV3_D16:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv3B,
/* OverwriteExisting= */ false);
break;
case ARM::FK_VFPV3_D16_FP16:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv3B,
/* OverwriteExisting= */ false);
setAttributeItem(ARMBuildAttrs::FP_HP_extension,
ARMBuildAttrs::AllowHPFP,
/* OverwriteExisting= */ false);
break;
case ARM::FK_VFPV3XD:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv3B,
/* OverwriteExisting= */ false);
break;
case ARM::FK_VFPV3XD_FP16:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv3B,
/* OverwriteExisting= */ false);
setAttributeItem(ARMBuildAttrs::FP_HP_extension,
ARMBuildAttrs::AllowHPFP,
/* OverwriteExisting= */ false);
break;
case ARM::FK_VFPV4:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv4A,
/* OverwriteExisting= */ false);
break;
// ABI_HardFP_use is handled in ARMAsmPrinter, so _SP_D16 is treated the same
// as _D16 here.
case ARM::FK_FPV4_SP_D16:
case ARM::FK_VFPV4_D16:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv4B,
/* OverwriteExisting= */ false);
break;
case ARM::FK_FP_ARMV8:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPARMv8A,
/* OverwriteExisting= */ false);
break;
// FPV5_D16 is identical to FP_ARMV8 except for the number of D registers, so
// uses the FP_ARMV8_D16 build attribute.
case ARM::FK_FPV5_SP_D16:
case ARM::FK_FPV5_D16:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPARMv8B,
/* OverwriteExisting= */ false);
break;
case ARM::FK_NEON:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv3A,
/* OverwriteExisting= */ false);
setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
ARMBuildAttrs::AllowNeon,
/* OverwriteExisting= */ false);
break;
case ARM::FK_NEON_FP16:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv3A,
/* OverwriteExisting= */ false);
setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
ARMBuildAttrs::AllowNeon,
/* OverwriteExisting= */ false);
setAttributeItem(ARMBuildAttrs::FP_HP_extension,
ARMBuildAttrs::AllowHPFP,
/* OverwriteExisting= */ false);
break;
case ARM::FK_NEON_VFPV4:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPv4A,
/* OverwriteExisting= */ false);
setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
ARMBuildAttrs::AllowNeon2,
/* OverwriteExisting= */ false);
break;
case ARM::FK_NEON_FP_ARMV8:
case ARM::FK_CRYPTO_NEON_FP_ARMV8:
setAttributeItem(ARMBuildAttrs::FP_arch,
ARMBuildAttrs::AllowFPARMv8A,
/* OverwriteExisting= */ false);
// 'Advanced_SIMD_arch' must be emitted not here, but within
// ARMAsmPrinter::emitAttributes(), depending on hasV8Ops() and hasV8_1a()
break;
case ARM::FK_SOFTVFP:
case ARM::FK_NONE:
break;
default:
report_fatal_error("Unknown FPU: " + Twine(FPU));
break;
}
} | false | false | false | false | false | 0 |
gp_init_itdbs(gpointer data) {
gint i;
for (i = 0;; ++i) {
ExtraiTunesDBData *eitdb;
iTunesDB *itdb = setup_itdb_n(i);
if (itdb == NULL) {
gtkpod_statusbar_message(_("Importing of ipods completed."));
break;
}
/* add to the display */
gp_itdb_add(itdb, -1);
/* update/sync playlists according to options set */
eitdb = itdb->userdata;
g_return_val_if_fail (eitdb, FALSE);
if (eitdb->itdb_imported) {
/* take care of autosync... */
sync_all_playlists(itdb);
/* update all live SPLs */
itdb_spl_update_live(itdb);
}
}
/* Itdbs now ready. Initiate autodetection */
autodetection_init();
return FALSE;
} | false | false | false | false | false | 0 |
dvb_channel_list_real_iterator (GeeIterable* base) {
DVBChannelList * self;
GeeIterator* result = NULL;
GeeHashMap* _tmp0_ = NULL;
GeeCollection* _tmp1_ = NULL;
GeeCollection* _tmp2_ = NULL;
GeeCollection* _tmp3_ = NULL;
GeeIterator* _tmp4_ = NULL;
GeeIterator* _tmp5_ = NULL;
self = (DVBChannelList*) base;
_tmp0_ = self->channels;
_tmp1_ = gee_abstract_map_get_values ((GeeMap*) _tmp0_);
_tmp2_ = _tmp1_;
_tmp3_ = _tmp2_;
_tmp4_ = gee_iterable_iterator ((GeeIterable*) _tmp3_);
_tmp5_ = _tmp4_;
_g_object_unref0 (_tmp3_);
result = _tmp5_;
return result;
} | false | false | false | false | false | 0 |
t4_alloc_vi(struct adapter *adap, unsigned int mbox, unsigned int port,
unsigned int pf, unsigned int vf, unsigned int nmac, u8 *mac,
unsigned int *rss_size)
{
int ret;
struct fw_vi_cmd c;
memset(&c, 0, sizeof(c));
c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_VI_CMD) | FW_CMD_REQUEST_F |
FW_CMD_WRITE_F | FW_CMD_EXEC_F |
FW_VI_CMD_PFN_V(pf) | FW_VI_CMD_VFN_V(vf));
c.alloc_to_len16 = cpu_to_be32(FW_VI_CMD_ALLOC_F | FW_LEN16(c));
c.portid_pkd = FW_VI_CMD_PORTID_V(port);
c.nmac = nmac - 1;
ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
if (ret)
return ret;
if (mac) {
memcpy(mac, c.mac, sizeof(c.mac));
switch (nmac) {
case 5:
memcpy(mac + 24, c.nmac3, sizeof(c.nmac3));
case 4:
memcpy(mac + 18, c.nmac2, sizeof(c.nmac2));
case 3:
memcpy(mac + 12, c.nmac1, sizeof(c.nmac1));
case 2:
memcpy(mac + 6, c.nmac0, sizeof(c.nmac0));
}
}
if (rss_size)
*rss_size = FW_VI_CMD_RSSSIZE_G(be16_to_cpu(c.rsssize_pkd));
return FW_VI_CMD_VIID_G(be16_to_cpu(c.type_viid));
} | false | false | false | false | false | 0 |
nfs41_is_outlier_target_slotid(struct nfs4_slot_table *tbl,
u32 new_target)
{
s32 d_target, d2_target;
bool ret = true;
d_target = nfs41_derivative_target_slotid(new_target,
tbl->target_highest_slotid);
d2_target = nfs41_derivative_target_slotid(d_target,
tbl->d_target_highest_slotid);
/* Is first derivative same sign? */
if (nfs41_same_sign_or_zero_s32(d_target, tbl->d_target_highest_slotid))
ret = false;
/* Is second derivative same sign? */
if (nfs41_same_sign_or_zero_s32(d2_target, tbl->d2_target_highest_slotid))
ret = false;
tbl->d_target_highest_slotid = d_target;
tbl->d2_target_highest_slotid = d2_target;
return ret;
} | false | false | false | false | false | 0 |
filter_set_vector(seaudit_filter_t * filter, apol_vector_t ** tgt, const apol_vector_t * v)
{
apol_vector_t *new_v = NULL;
if (v != NULL) {
if ((new_v = apol_vector_create_from_vector(v, apol_str_strdup, NULL, free)) == NULL) {
return -1;
}
}
apol_vector_destroy(tgt);
*tgt = new_v;
if (filter->model != NULL) {
model_notify_filter_changed(filter->model, filter);
}
return 0;
} | false | false | false | false | false | 0 |
afr_sh_entry_impunge_symlink (call_frame_t *impunge_frame, xlator_t *this,
int child_index, const char *linkname)
{
afr_private_t *priv = NULL;
afr_local_t *impunge_local = NULL;
dict_t *dict = NULL;
struct iatt *buf = NULL;
int ret = 0;
priv = this->private;
impunge_local = impunge_frame->local;
buf = &impunge_local->cont.symlink.buf;
dict = dict_new ();
if (!dict) {
afr_sh_entry_call_impunge_done (impunge_frame, this,
-1, ENOMEM);
goto out;
}
GF_ASSERT (!uuid_is_null (buf->ia_gfid));
ret = afr_set_dict_gfid (dict, buf->ia_gfid);
if (ret)
gf_log (this->name, GF_LOG_INFO,
"%s: dict set gfid failed",
impunge_local->loc.path);
gf_log (this->name, GF_LOG_DEBUG,
"creating missing symlink %s -> %s on %s",
impunge_local->loc.path, linkname,
priv->children[child_index]->name);
STACK_WIND_COOKIE (impunge_frame, afr_sh_entry_impunge_newfile_cbk,
(void *) (long) child_index,
priv->children[child_index],
priv->children[child_index]->fops->symlink,
linkname, &impunge_local->loc, 0, dict);
if (dict)
dict_unref (dict);
out:
return 0;
} | false | false | false | false | false | 0 |
FindOneBool(const string &name, bool d) const {
LOOKUP_ONE(bools);
} | false | false | false | false | false | 0 |
AddGeometry( CPLXMLNode* psGeom )
{
if (m_nGeometryCount == 0)
{
m_apsGeometry[0] = psGeom;
}
else if (m_nGeometryCount == 1)
{
m_papsGeometry = (CPLXMLNode **) CPLMalloc(
(m_nGeometryCount + 2) * sizeof(CPLXMLNode *));
m_papsGeometry[0] = m_apsGeometry[0];
m_apsGeometry[0] = NULL;
m_papsGeometry[m_nGeometryCount] = psGeom;
m_papsGeometry[m_nGeometryCount + 1] = NULL;
}
else
{
m_papsGeometry = (CPLXMLNode **) CPLRealloc(m_papsGeometry,
(m_nGeometryCount + 2) * sizeof(CPLXMLNode *));
m_papsGeometry[m_nGeometryCount] = psGeom;
m_papsGeometry[m_nGeometryCount + 1] = NULL;
}
m_nGeometryCount ++;
} | false | false | false | false | false | 0 |
cleanup( QString &err ) {
emit updateStatus(tr("Erase all records on computer"));
if (JOULE_DEBUG) printf("Erase all records on computer\n");
if (!dev->open(err)) {
err = tr("ERROR: open failed: ") + err;
}
dev->setBaudRate(57600, err);
JoulePacket versionResponse;
getUnitVersion(versionResponse, err);
bool isJouleGPS = getJouleGPS(versionResponse);
QList<DeviceStoredRideItem> trainings;
if (!getDownloadableRides(trainings, isJouleGPS, err))
return false;
for (int i=0; i<trainings.count(); i++) {
emit updateStatus(QString(tr("Delete ride detail for ride %1/%2")).arg(i+1).arg(trainings.count()));
JoulePacket request(ERASE_RIDE_DETAIL);
int id1 = (trainings.at(i).id>255?trainings.at(i).id-255:trainings.at(i).id);
int id2 = (trainings.at(i).id>255?trainings.at(i).id%255:0);
request.addToPayload((char)id1);
request.addToPayload((char)id2);
request.addToPayload((char)id1);
request.addToPayload((char)id2);
if (!request.write(dev, err)) return false;
JoulePacket response = JoulePacket(ERASE_RIDE_DETAIL);
if (!response.read(dev, err))
return false;
}
dev->close();
return true;
} | false | false | false | false | false | 0 |
keyboard_move_to (NemoIconContainer *container,
NemoIcon *icon,
NemoIcon *from,
GdkEventKey *event)
{
if (icon == NULL) {
return;
}
if (event != NULL &&
(event->state & GDK_CONTROL_MASK) != 0 &&
(event->state & GDK_SHIFT_MASK) == 0) {
/* Move the keyboard focus. Use Control modifier
* rather than Alt to avoid Sawfish conflict.
*/
set_keyboard_focus (container, icon);
container->details->keyboard_rubberband_start = NULL;
} else if (event != NULL &&
((event->state & GDK_CONTROL_MASK) != 0 ||
!container->details->auto_layout) &&
(event->state & GDK_SHIFT_MASK) != 0) {
/* Do rubberband selection */
EelDRect rect;
if (from && !container->details->keyboard_rubberband_start) {
set_keyboard_rubberband_start (container, from);
}
set_keyboard_focus (container, icon);
if (icon && container->details->keyboard_rubberband_start) {
rect = get_rubberband (container->details->keyboard_rubberband_start,
icon);
rubberband_select (container, NULL, &rect);
}
} else if (event != NULL &&
(event->state & GDK_CONTROL_MASK) == 0 &&
(event->state & GDK_SHIFT_MASK) != 0) {
/* Select range */
NemoIcon *start_icon;
start_icon = container->details->range_selection_base_icon;
if (start_icon == NULL || !start_icon->is_selected) {
start_icon = icon;
container->details->range_selection_base_icon = icon;
}
set_keyboard_focus (container, icon);
if (select_range (container, start_icon, icon, TRUE)) {
g_signal_emit (container,
signals[SELECTION_CHANGED], 0);
}
} else {
/* Select icons and get rid of the special keyboard focus. */
clear_keyboard_focus (container);
clear_keyboard_rubberband_start (container);
container->details->range_selection_base_icon = icon;
if (select_one_unselect_others (container, icon)) {
g_signal_emit (container,
signals[SELECTION_CHANGED], 0);
}
}
schedule_keyboard_icon_reveal (container, icon);
} | false | false | false | false | false | 0 |
vectoyaw (vec3_t vec)
{
float yaw;
// FIXES HERE FROM 3.20 -FB
if ( /*vec[YAW] == 0 && */ vec[PITCH] == 0)
{
yaw = 0;
if (vec[YAW] > 0)
yaw = 90;
else if (vec[YAW] < 0)
yaw = -90;
}
// ^^^
else
{
yaw = (int) (atan2 (vec[YAW], vec[PITCH]) * 180 / M_PI);
if (yaw < 0)
yaw += 360;
}
return yaw;
} | false | false | false | false | false | 0 |
dump_marks_helper(FILE *f,
uintmax_t base,
struct mark_set *m)
{
uintmax_t k;
if (m->shift) {
for (k = 0; k < 1024; k++) {
if (m->data.sets[k])
dump_marks_helper(f, (base + k) << m->shift,
m->data.sets[k]);
}
} else {
for (k = 0; k < 1024; k++) {
if (m->data.marked[k])
fprintf(f, ":%" PRIuMAX " %s\n", base + k,
sha1_to_hex(m->data.marked[k]->sha1));
}
}
} | false | false | false | false | false | 0 |
pdb_read_rec(pdbfile *fin, gbuint8 *flags, gbuint8 *category, gbuint32 *rec_id, void **data)
{
if (pdb_eof(fin)) {
return -1;
} else {
pdbrec_t *rec = fin->rec_curr;
fin->rec_curr = rec->next;
if (data) {
*data = rec->data;
}
if (flags) {
*flags = rec->flags;
}
if (category) {
*category = rec->category;
}
if (rec_id) {
*rec_id = rec->id;
}
return rec->size;
}
} | false | false | false | false | false | 0 |
initialize_bresen(state_t *s, int funct_nr, int argc, reg_t *argv, reg_t mover, int step_factor,
int deltax, int deltay)
{
reg_t client = GET_SEL32(mover, client);
int stepx = GET_SEL32SV(client, xStep) * step_factor;
int stepy = GET_SEL32SV(client, yStep) * step_factor;
int numsteps_x = stepx? (abs(deltax) + stepx-1) / stepx : 0;
int numsteps_y = stepy? (abs(deltay) + stepy-1) / stepy : 0;
int bdi, i1;
int numsteps;
int deltax_step;
int deltay_step;
if (numsteps_x > numsteps_y) {
numsteps = numsteps_x;
deltax_step = (deltax < 0)? -stepx : stepx;
deltay_step = numsteps? deltay / numsteps : deltay;
} else { /* numsteps_x <= numsteps_y */
numsteps = numsteps_y;
deltay_step = (deltay < 0)? -stepy : stepy;
deltax_step = numsteps? deltax / numsteps : deltax;
}
/* if (abs(deltax) > abs(deltay)) {*/ /* Bresenham on y */
if (numsteps_y < numsteps_x) {
PUT_SEL32V(mover, b_xAxis, _K_BRESEN_AXIS_Y);
PUT_SEL32V(mover, b_incr, (deltay < 0)? -1 : 1);
/*
i1 = 2 * (abs(deltay) - abs(deltay_step * numsteps)) * abs(deltax_step);
bdi = -abs(deltax);
*/
i1 = 2*(abs(deltay) - abs(deltay_step * (numsteps - 1))) * abs(deltax_step);
bdi = -abs(deltax);
} else { /* Bresenham on x */
PUT_SEL32V(mover, b_xAxis, _K_BRESEN_AXIS_X);
PUT_SEL32V(mover, b_incr, (deltax < 0)? -1 : 1);
/*
i1= 2 * (abs(deltax) - abs(deltax_step * numsteps)) * abs(deltay_step);
bdi = -abs(deltay);
*/
i1 = 2*(abs(deltax) - abs(deltax_step * (numsteps - 1))) * abs(deltay_step);
bdi = -abs(deltay);
}
PUT_SEL32V(mover, dx, deltax_step);
PUT_SEL32V(mover, dy, deltay_step);
SCIkdebug(SCIkBRESEN, "Init bresen for mover "PREG": d=(%d,%d)\n", PRINT_REG(mover), deltax, deltay);
SCIkdebug(SCIkBRESEN, " steps=%d, mv=(%d, %d), i1= %d, i2=%d\n",
numsteps, deltax_step, deltay_step, i1, bdi*2);
/* PUT_SEL32V(mover, b_movCnt, numsteps); *//* Needed for HQ1/Ogre? */
PUT_SEL32V(mover, b_di, bdi);
PUT_SEL32V(mover, b_i1, i1);
PUT_SEL32V(mover, b_i2, bdi * 2);
} | false | false | false | false | false | 0 |
toggle_offline_mode() {
if (prefs.offline_mode) {
/* Restore clipboard contents before turning offline mode off */
gtk_clipboard_set_text(clipboard, clipboard_text != NULL ? clipboard_text : "", -1);
}
prefs.offline_mode = !prefs.offline_mode;
/* Save the change */
save_preferences();
} | false | false | false | false | false | 0 |
newBlock(MEMORYADMIN* ma, unsigned int capacityIncrement) {
FUNCNAME("newBlock");
BLOCK* block;
FREEMEMORY *freeMem;
void **i;
size_t ma_objectSize_div_sizeofvoid;
size_t sizeofBlock = ALIGNSIZE(sizeof(BLOCK));
ma_objectSize_div_sizeofvoid = ma->objectSize / sizeof(void*);
block = (BLOCK *)alberta_alloc(sizeofBlock + capacityIncrement * ma->objectSize, funcName, __FILE__, __LINE__);
ma->capacity += capacityIncrement;
block->next = ma->blocks;
ma->blocks = block;
freeMem = (FREEMEMORY*)((void**)block + sizeofBlock / sizeof(void*));
block->end = ((void**)freeMem) + capacityIncrement * ma_objectSize_div_sizeofvoid;
for(i = (void**)freeMem; i < (void**)(block->end) - ma_objectSize_div_sizeofvoid; i += ma_objectSize_div_sizeofvoid) {
((FREEMEMORY*)i)->next = (FREEMEMORY*)(i + ma_objectSize_div_sizeofvoid);
}
((FREEMEMORY*)i)->next = ma->freeMem;
ma->freeMem = freeMem;
return 0;
} | false | false | false | false | false | 0 |
arrayHasNonConstPointers(Expressions *elems)
{
for (size_t i = 0; i < elems->dim; i++)
{ Expression *e = (*elems)[i];
if (e && hasNonConstPointers(e))
return true;
}
return false;
} | false | false | false | false | false | 0 |
jtagmkI_getparm(PROGRAMMER * pgm, unsigned char parm,
unsigned char * value)
{
unsigned char buf[2], resp[3];
if (verbose >= 2)
fprintf(stderr, "%s: jtagmkI_getparm()\n", progname);
buf[0] = CMD_GET_PARAM;
buf[1] = parm;
if (verbose >= 2)
fprintf(stderr, "%s: jtagmkI_getparm(): "
"Sending get parameter command (parm 0x%02x): ",
progname, parm);
jtagmkI_send(pgm, buf, 2);
jtagmkI_recv(pgm, resp, 3);
if (resp[0] != RESP_OK) {
if (verbose >= 2)
putc('\n', stderr);
fprintf(stderr,
"%s: jtagmkI_getparm(): "
"timeout/error communicating with programmer (resp %c)\n",
progname, resp[0]);
return -1;
} else if (resp[2] != RESP_OK) {
if (verbose >= 2)
putc('\n', stderr);
fprintf(stderr,
"%s: jtagmkI_getparm(): "
"unknown parameter 0x%02x\n",
progname, parm);
return -1;
} else {
if (verbose == 2)
fprintf(stderr, "OK, value 0x%02x\n", resp[1]);
}
*value = resp[1];
return 0;
} | true | true | false | false | false | 1 |
_ecore_evas_x_event_window_damage(void *data __UNUSED__, int type __UNUSED__, void *event)
{
Ecore_Evas *ee;
Ecore_X_Event_Window_Damage *e;
e = event;
ee = ecore_event_window_match(e->win);
if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
if (ee->engine.x.using_bg_pixmap) return ECORE_CALLBACK_PASS_ON;
// printf("EXPOSE %p [%i] %i %i %ix%i\n", ee, ee->prop.avoid_damage, e->x, e->y, e->w, e->h);
if (ee->prop.avoid_damage)
{
Ecore_X_Rectangle rect;
Ecore_X_XRegion *tmpr;
if (!ee->engine.x.damages)
ee->engine.x.damages = ecore_x_xregion_new();
tmpr = ecore_x_xregion_new();
rect.x = e->x;
rect.y = e->y;
rect.width = e->w;
rect.height = e->h;
ecore_x_xregion_union_rect(tmpr, ee->engine.x.damages, &rect);
ecore_x_xregion_free(ee->engine.x.damages);
ee->engine.x.damages = tmpr;
/* no - this breaks things badly. disable. Ecore_X_Rectangle != XRectangle - see
* the typedefs in x's headers and ecore_x's. also same with Region - it's a pointer in x - not an X ID
Ecore_X_Rectangle rect;
Ecore_X_XRegion *tmpr;
if (!ee->engine.x.damages) ee->engine.x.damages = ecore_x_xregion_new();
tmpr = ecore_x_xregion_new();
rect.x = e->x;
rect.y = e->y;
rect.width = e->w;
rect.height = e->h;
ecore_x_xregion_union_rect(tmpr, ee->engine.x.damages, &rect);
ecore_x_xregion_free(ee->engine.x.damages);
ee->engine.x.damages = tmpr;
*/
}
else
{
if (ee->rotation == 0)
evas_damage_rectangle_add(ee->evas, e->x, e->y, e->w, e->h);
else if (ee->rotation == 90)
evas_damage_rectangle_add(ee->evas,
ee->h - e->y - e->h, e->x, e->h, e->w);
else if (ee->rotation == 180)
evas_damage_rectangle_add(ee->evas, ee->w - e->x - e->w,
ee->h - e->y - e->h, e->w, e->h);
else if (ee->rotation == 270)
evas_damage_rectangle_add(ee->evas, e->y, ee->w - e->x - e->w,
e->h, e->w);
}
return ECORE_CALLBACK_PASS_ON;
} | false | false | false | false | false | 0 |
misc_readstring(uschar *p, int *lptr, uschar *buffer, int blength)
{
int term = *p;
int length;
uschar *pp, *yield;
for (pp = p + 1;; pp++)
{
if (*pp == 0) break;
if (*pp == term) { if (pp[1] != term) break; pp++; }
}
length = pp - p; /* stringlength, over-estimate if any doubled */
if (lptr != NULL) *lptr = length + 1;
if (buffer == NULL)
{
yield = pp = misc_malloc(length + 1);
}
else
{
if (length + 1 > blength) error(20, length + 1, blength); /* Hard */
yield = pp = buffer;
}
for (++p;; p++)
{
if (*p == 0) break;
if (*p == term) { if (p[1] != term) break; p++; }
*pp++ = *p;
}
*pp = 0;
return yield;
} | false | false | false | false | false | 0 |
gw_menu_file_exit_save_file_no ( GtkWidget *bt, GtkWindow *dg) {
gboolean result = FALSE;
#ifdef GW_DEBUG_GUI_CALLBACK_COMPONENT
g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
if ( dg != NULL ) {
gtk_widget_destroy ( GTK_WIDGET ( dg));
gw_menu_file_exit ( );
result = TRUE;
}
return result;
} | false | false | false | false | false | 0 |
FslSetDimensionality(FSLIO *fslio, size_t dim)
{
if (fslio==NULL) FSLIOERR("FslSetDimensionality: Null pointer passed for FSLIO");
if (fslio->niftiptr!=NULL) {
fslio->niftiptr->ndim = dim;
fslio->niftiptr->dim[0] = dim;
}
if (fslio->mincptr!=NULL) {
fprintf(stderr,"Warning:: Minc is not yet supported\n");
}
} | false | false | false | false | false | 0 |
e_destination_export (const EDestination *dest)
{
xmlNodePtr dest_node;
xmlDocPtr dest_doc;
xmlChar *buffer = NULL;
gint size = -1;
gchar *str;
g_return_val_if_fail (dest && E_IS_DESTINATION (dest), NULL);
dest_node = e_destination_xml_encode (dest);
if (dest_node == NULL)
return NULL;
dest_doc = xmlNewDoc ((xmlChar *) XML_DEFAULT_VERSION);
xmlDocSetRootElement (dest_doc, dest_node);
xmlDocDumpMemory (dest_doc, &buffer, &size);
xmlFreeDoc (dest_doc);
str = null_terminate_and_remove_extra_whitespace (buffer, size);
xmlFree (buffer);
return str;
} | false | false | false | false | false | 0 |
configfs_remove_dir(struct config_item * item)
{
struct dentry * dentry = dget(item->ci_dentry);
if (!dentry)
return;
remove_dir(dentry);
/**
* Drop reference from dget() on entrance.
*/
dput(dentry);
} | false | false | false | false | false | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.