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 |
|---|---|---|---|---|---|---|
posix_setsid(PyObject *self, PyObject *noargs)
{
if (setsid() < 0)
return posix_error();
Py_INCREF(Py_None);
return Py_None;
} | false | false | false | false | false | 0 |
onCmdDragged(FXObject*sender,FXSelector,void*ptr){
FXWindow * window = (FXWindow*)sender;
FXEvent* event=(FXEvent*)ptr;
FXDragAction action=DRAG_COPY;
if(event->state&ALTMASK) action=DRAG_LINK;
window->handleDrag(event->root_x,event->root_y,action);
action=window->didAccept();
if (window->didAccept()!=DRAG_REJECT) {
if (action==DRAG_MOVE)
window->setDragCursor(getApp()->getDefaultCursor(DEF_DNDMOVE_CURSOR));
else if (action==DRAG_LINK)
window->setDragCursor(getApp()->getDefaultCursor(DEF_DNDLINK_CURSOR));
else
window->setDragCursor(getApp()->getDefaultCursor(DEF_DNDCOPY_CURSOR));
}
else {
window->setDragCursor(getApp()->getDefaultCursor(DEF_DNDSTOP_CURSOR));
}
return 1;
} | false | false | false | false | false | 0 |
get_float(const OPDBlock *header,
guint nblocks,
const gchar *name,
gdouble *value,
GError **error)
{
const guchar *p;
guint i;
if ((i = find_block(header, nblocks, name)) == nblocks) {
err_MISSING_FIELD(error, name);
return FALSE;
}
if (header[i].type != OPD_FLOAT) {
err_INVALID(error, name);
return FALSE;
}
p = header[i].data;
*value = gwy_get_gfloat_le(&p);
gwy_debug("%s = %g", name, *value);
return TRUE;
} | false | false | false | false | false | 0 |
create_socket(char *name)
{
int s;
struct sockaddr_un sockun;
s = socket(PF_UNIX, SOCK_STREAM, 0);
if (s < 0)
return -1;
sockun.sun_family = AF_UNIX;
strcpy(sockun.sun_path, name);
if (bind(s, (struct sockaddr*)&sockun, sizeof(sockun)) < 0)
{
close(s);
return -1;
}
if (listen(s, 128) < 0)
{
close(s);
return -1;
}
if (setnonblocking(s) < 0)
{
close(s);
return -1;
}
/* chmod it to prevent any suprises */
if (chmod(name, 0600) < 0)
{
close(s);
return -1;
}
return s;
} | false | false | false | false | false | 0 |
mono_get_optimizations_for_method (MonoMethod *method, guint32 default_opt)
{
g_assert (method);
if (!mono_do_single_method_regression)
return default_opt;
if (!mono_current_single_method) {
if (!mono_single_method_hash)
mono_single_method_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
if (!g_hash_table_lookup (mono_single_method_hash, method)) {
g_hash_table_insert (mono_single_method_hash, method, method);
mono_single_method_list = g_slist_prepend (mono_single_method_list, method);
}
return default_opt;
}
if (method == mono_current_single_method)
return mono_single_method_regression_opt;
return default_opt;
} | false | false | false | false | false | 0 |
__col_newparamrhsexpr(void)
{
int32 parlevel, catlevel;
struct expr_t *ndp;
__last_xtk = -1;
ndp = __alloc_exprnd();
ndp->optyp = LPAR;
for (parlevel = 0, catlevel = 0;;)
{
switch ((byte) __toktyp) {
case LPAR: parlevel++; break;
case RPAR: parlevel--; break;
case LCB: catlevel++; break;
case RCB: catlevel--; break;
case SEMI:
chk_empty:
/* empty = ; form illegal */
if (__last_xtk == -1)
{
__pv_ferr(1106, "right hand side expression missing");
goto bad_end;
}
ndp = __alloc_exprnd();
ndp->optyp = RPAR;
return(TRUE);
case COMMA:
if (parlevel <= 0 && catlevel <= 0) goto chk_empty;
break;
case TEOF:
if (__pv_err_cnt <= __saverr_cnt)
__pv_ferr(1093,
"illegal token %s in parameter right hand side expression",
__prt_vtok());
goto bad_end;
}
if (!__bld_expnode()) goto bad_end;
__get_vtok();
}
bad_end:
/* replace entire expression with 1 bit x - not op empty */
__set_xtab_errval();
return(FALSE);
} | false | false | false | false | false | 0 |
iter_do_var(GelCtx *ctx, GelETree *n, GelEFunc *f)
{
if(f->type == GEL_VARIABLE_FUNC) {
D_ENSURE_USER_BODY (f);
copyreplacenode(n,f->data.user);
} else if(f->type == GEL_USER_FUNC) {
D_ENSURE_USER_BODY (f);
freetree_full(n,TRUE,FALSE);
n->type = GEL_FUNCTION_NODE;
/* FIXME: are we ok with passing the token as well? */
n->func.func = d_copyfunc (f);
/* The function can no longer be local */
n->func.func->is_local = 0;
if ( ! f->on_subst_list)
n->func.func->context = -1;
} else if(f->type == GEL_BUILTIN_FUNC) {
GelETree *ret;
gboolean exception = FALSE;
if(f->nargs != 0) {
freetree_full(n,TRUE,FALSE);
n->type = GEL_FUNCTION_NODE;
/* FIXME: are we ok with passing the token (f->id) as well? */
n->func.func = d_makerealfunc(f,f->id,FALSE);
if ( ! n->func.func->on_subst_list)
n->func.func->context = -1;
/* FIXME: no need for extra_dict right? */
return TRUE;
}
ret = (*f->data.func)(ctx,NULL,&exception);
/* interruption happened during the function, which
means an exception */
if G_UNLIKELY (gel_interrupted) {
exception = TRUE;
}
if G_UNLIKELY (exception) {
if(ret)
gel_freetree(ret);
return FALSE;
} else if G_LIKELY (ret) {
replacenode(n,ret);
}
} else if(f->type == GEL_REFERENCE_FUNC) {
GelETree *i;
f = f->data.ref;
GEL_GET_NEW_NODE(i);
i->type = GEL_IDENTIFIER_NODE;
i->id.uninitialized = FALSE;
if(f->id) {
i->id.id = f->id;
} else {
/*make up a new fake id*/
GelToken *tok = g_new0(GelToken,1);
tok->refs = g_slist_append(NULL,f);
i->id.id = tok;
}
i->any.next = NULL;
freetree_full(n,TRUE,FALSE);
n->type = GEL_OPERATOR_NODE;
n->op.oper = GEL_E_REFERENCE;
n->op.args = i;
n->op.nargs = 1;
} else
gel_errorout (_("Unevaluatable function type encountered!"));
return TRUE;
} | false | false | false | false | false | 0 |
i40e_vsi_free_irq(struct i40e_vsi *vsi)
{
struct i40e_pf *pf = vsi->back;
struct i40e_hw *hw = &pf->hw;
int base = vsi->base_vector;
u32 val, qp;
int i;
if (pf->flags & I40E_FLAG_MSIX_ENABLED) {
if (!vsi->q_vectors)
return;
if (!vsi->irqs_ready)
return;
vsi->irqs_ready = false;
for (i = 0; i < vsi->num_q_vectors; i++) {
u16 vector = i + base;
/* free only the irqs that were actually requested */
if (!vsi->q_vectors[i] ||
!vsi->q_vectors[i]->num_ringpairs)
continue;
/* clear the affinity_mask in the IRQ descriptor */
irq_set_affinity_hint(pf->msix_entries[vector].vector,
NULL);
free_irq(pf->msix_entries[vector].vector,
vsi->q_vectors[i]);
/* Tear down the interrupt queue link list
*
* We know that they come in pairs and always
* the Rx first, then the Tx. To clear the
* link list, stick the EOL value into the
* next_q field of the registers.
*/
val = rd32(hw, I40E_PFINT_LNKLSTN(vector - 1));
qp = (val & I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK)
>> I40E_PFINT_LNKLSTN_FIRSTQ_INDX_SHIFT;
val |= I40E_QUEUE_END_OF_LIST
<< I40E_PFINT_LNKLSTN_FIRSTQ_INDX_SHIFT;
wr32(hw, I40E_PFINT_LNKLSTN(vector - 1), val);
while (qp != I40E_QUEUE_END_OF_LIST) {
u32 next;
val = rd32(hw, I40E_QINT_RQCTL(qp));
val &= ~(I40E_QINT_RQCTL_MSIX_INDX_MASK |
I40E_QINT_RQCTL_MSIX0_INDX_MASK |
I40E_QINT_RQCTL_CAUSE_ENA_MASK |
I40E_QINT_RQCTL_INTEVENT_MASK);
val |= (I40E_QINT_RQCTL_ITR_INDX_MASK |
I40E_QINT_RQCTL_NEXTQ_INDX_MASK);
wr32(hw, I40E_QINT_RQCTL(qp), val);
val = rd32(hw, I40E_QINT_TQCTL(qp));
next = (val & I40E_QINT_TQCTL_NEXTQ_INDX_MASK)
>> I40E_QINT_TQCTL_NEXTQ_INDX_SHIFT;
val &= ~(I40E_QINT_TQCTL_MSIX_INDX_MASK |
I40E_QINT_TQCTL_MSIX0_INDX_MASK |
I40E_QINT_TQCTL_CAUSE_ENA_MASK |
I40E_QINT_TQCTL_INTEVENT_MASK);
val |= (I40E_QINT_TQCTL_ITR_INDX_MASK |
I40E_QINT_TQCTL_NEXTQ_INDX_MASK);
wr32(hw, I40E_QINT_TQCTL(qp), val);
qp = next;
}
}
} else {
free_irq(pf->pdev->irq, pf);
val = rd32(hw, I40E_PFINT_LNKLST0);
qp = (val & I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK)
>> I40E_PFINT_LNKLSTN_FIRSTQ_INDX_SHIFT;
val |= I40E_QUEUE_END_OF_LIST
<< I40E_PFINT_LNKLST0_FIRSTQ_INDX_SHIFT;
wr32(hw, I40E_PFINT_LNKLST0, val);
val = rd32(hw, I40E_QINT_RQCTL(qp));
val &= ~(I40E_QINT_RQCTL_MSIX_INDX_MASK |
I40E_QINT_RQCTL_MSIX0_INDX_MASK |
I40E_QINT_RQCTL_CAUSE_ENA_MASK |
I40E_QINT_RQCTL_INTEVENT_MASK);
val |= (I40E_QINT_RQCTL_ITR_INDX_MASK |
I40E_QINT_RQCTL_NEXTQ_INDX_MASK);
wr32(hw, I40E_QINT_RQCTL(qp), val);
val = rd32(hw, I40E_QINT_TQCTL(qp));
val &= ~(I40E_QINT_TQCTL_MSIX_INDX_MASK |
I40E_QINT_TQCTL_MSIX0_INDX_MASK |
I40E_QINT_TQCTL_CAUSE_ENA_MASK |
I40E_QINT_TQCTL_INTEVENT_MASK);
val |= (I40E_QINT_TQCTL_ITR_INDX_MASK |
I40E_QINT_TQCTL_NEXTQ_INDX_MASK);
wr32(hw, I40E_QINT_TQCTL(qp), val);
}
} | false | false | false | false | false | 0 |
ndmca_tt_basic_getstate (struct ndm_session *sess)
{
int rc;
ndmca_test_phase (sess, "T-BGS", "Tape Get State Basics");
rc = ndmca_test_tape_get_state (sess, NDMP9_DEV_NOT_OPEN_ERR);
if (rc) return rc;
rc = ndmca_test_tape_open(sess,NDMP9_NO_ERR,0,NDMP9_TAPE_READ_MODE);
if (rc) return rc;
rc = ndmca_test_tape_get_state (sess, NDMP9_NO_ERR);
if (rc) return rc;
rc = ndmca_test_tape_close (sess, NDMP9_NO_ERR);
if (rc) return rc;
return 0; /* pass */
} | false | false | false | false | false | 0 |
snd_pcm_shm_dump(snd_pcm_t *pcm, snd_output_t *out)
{
snd_output_printf(out, "Shm PCM\n");
if (pcm->setup) {
snd_output_printf(out, "Its setup is:\n");
snd_pcm_dump_setup(pcm, out);
}
} | false | false | false | false | false | 0 |
acdArgsScan(ajint argc, char * const argv[])
{
ajint i;
char* cp;
for(i=0; i < argc; i++)
{
cp = argv[i];
if(*cp && strchr("-/", *cp)) /* first character vs. qualifier starts */
{
cp++;
if(*cp == '-') /* allow --qualifier */
cp++;
}
else
continue;
if(!*cp)
continue;
if(!strcmp(cp, "debug"))
{
acdDebug = ajTrue;
acdDebugSet = ajTrue;
}
if(!strcmp(cp, "nodebug"))
{
acdDebug = ajFalse;
acdDebugSet = ajTrue;
}
if(!strcmp(cp, "stdout"))
acdStdout = ajTrue;
if(!strcmp(cp, "filter"))
acdFilter = ajTrue;
if(!strcmp(cp, "options"))
acdOptions = ajTrue;
if(!strcmp(cp, "verbose"))
acdVerbose = ajTrue;
if(!strcmp(cp, "version"))
acdDoVersion = ajTrue;
if(!strcmp(cp, "help"))
acdDoHelp = ajTrue;
if(!strcmp(cp, "auto"))
{
acdPromptTry = 1;
acdAuto = ajTrue;
}
if(!strcmp(cp, "warning"))
AjErrorLevel.warning = ajTrue;
if(!strcmp(cp, "nowarning"))
AjErrorLevel.warning = ajFalse;
if(!strcmp(cp, "error"))
AjErrorLevel.error = ajTrue;
if(!strcmp(cp, "noerror"))
AjErrorLevel.error = ajFalse;
if(!strcmp(cp, "-fatal"))
AjErrorLevel.fatal = ajTrue;
if(!strcmp(cp, "nofatal"))
AjErrorLevel.fatal = ajFalse;
if(!strcmp(cp, "die"))
AjErrorLevel.die = ajTrue;
if(!strcmp(cp, "nodie"))
AjErrorLevel.die = ajFalse;
if(!strcmp(cp, "help"))
acdLog("acdArgsScan -help argv[%d]\n", i);
}
acdLog("acdArgsScan acdDebug %B acdDoHelp %B\n", acdDebug, acdDoHelp);
return;
} | false | false | false | false | false | 0 |
load_profile_to_callback(pTHX_ NYTP_file in, SV *cb)
{
Loader_state_callback state;
int i;
HV *cb_hv = NULL;
CV *default_cb = NULL;
if (SvTYPE(cb) == SVt_PVHV) {
/* A default callback is stored with an empty key. */
SV **svp;
cb_hv = (HV *)cb;
svp = hv_fetch(cb_hv, "", 0, 0);
if (svp) {
if (!SvROK(*svp) && SvTYPE(SvRV(*svp)) != SVt_PVCV)
croak("Default callback is not a CODE reference");
default_cb = (CV *)SvRV(*svp);
}
} else if (SvTYPE(cb) == SVt_PVCV) {
default_cb = (CV *) cb;
} else
croak("Not a CODE or HASH reference");
#ifdef MULTIPLICITY
state.interp = my_perl;
#endif
state.base_state.input_chunk_seqn = 0;
state.input_chunk_seqn_sv = save_scalar(gv_fetchpv(".", GV_ADD, SVt_IV));
i = C_ARRAY_LENGTH(state.tag_names);
while (--i) {
if (callback_info[i].args) {
state.tag_names[i]
= newSVpvn_flags(callback_info[i].description,
callback_info[i].len, SVs_TEMP);
SvREADONLY_on(state.tag_names[i]);
/* Don't steal the string buffer. */
SvTEMP_off(state.tag_names[i]);
} else
state.tag_names[i] = NULL;
if (cb_hv) {
SV **svp = hv_fetch(cb_hv, callback_info[i].description,
(I32)(callback_info[i].len), 0);
if (svp) {
if (!SvROK(*svp) && SvTYPE(SvRV(*svp)) != SVt_PVCV)
croak("Callback for %s is not a CODE reference",
callback_info[i].description);
state.cb[i] = (CV *)SvRV(*svp);
} else
state.cb[i] = default_cb;
} else
state.cb[i] = default_cb;
}
for (i = 0; i < C_ARRAY_LENGTH(state.cb_args); i++)
state.cb_args[i] = sv_newmortal();
load_profile_data_from_stream(perl_callbacks, (Loader_state_base *)&state,
in);
} | false | false | false | false | false | 0 |
pfx_chk (const char * word, int len, struct affent* ep, int num)
{
struct affent * aent;
int cond;
int tlen;
struct hentry * hent;
unsigned char * cp;
int i;
char tword[MAX_WD_LEN];
for (aent = ep, i = num; i > 0; aent++, i--) {
tlen = len - aent->appndl;
if (tlen > 0 && (aent->appndl == 0 ||
strncmp(aent->appnd, word, aent->appndl) == 0)
&& tlen + aent->stripl >= aent->numconds) {
if (aent->stripl) strcpy (tword, aent->strip);
strcpy((tword + aent->stripl), (word + aent->appndl));
/* now go through the conds and make sure they all match */
cp = (unsigned char *) tword;
for (cond = 0; cond < aent->numconds; cond++) {
if ((aent->conds[*cp++] & (1 << cond)) == 0)
break;
}
if (cond >= aent->numconds) {
tlen += aent->stripl;
if ((hent = lookup(tword)) != NULL) {
if (numroots < MAX_ROOTS) {
roots[numroots].hashent = hent;
roots[numroots].prefix = aent;
roots[numroots].suffix = NULL;
numroots++;
}
}
}
}
}
} | false | false | false | false | false | 0 |
rule_rhs_print (rule const *r, FILE *out)
{
if (0 <= *r->rhs)
{
item_number *rp;
for (rp = r->rhs; *rp >= 0; rp++)
fprintf (out, " %s", symbols[*rp]->tag);
}
else
fputs (" %empty", out);
} | false | false | false | false | false | 0 |
_PyLong_FormatAdvancedWriter(_PyUnicodeWriter *writer,
PyObject *obj,
PyObject *format_spec,
Py_ssize_t start, Py_ssize_t end)
{
PyObject *tmp = NULL, *str = NULL;
InternalFormatSpec format;
int result = -1;
/* check for the special case of zero length format spec, make
it equivalent to str(obj) */
if (start == end) {
if (PyLong_CheckExact(obj))
return _PyLong_FormatWriter(writer, obj, 10, 0);
else
return format_obj(obj, writer);
}
/* parse the format_spec */
if (!parse_internal_render_format_spec(format_spec, start, end,
&format, 'd', '>'))
goto done;
/* type conversion? */
switch (format.type) {
case 'b':
case 'c':
case 'd':
case 'o':
case 'x':
case 'X':
case 'n':
/* no type conversion needed, already an int. do the formatting */
result = format_long_internal(obj, &format, writer);
break;
case 'e':
case 'E':
case 'f':
case 'F':
case 'g':
case 'G':
case '%':
/* convert to float */
tmp = PyNumber_Float(obj);
if (tmp == NULL)
goto done;
result = format_float_internal(tmp, &format, writer);
break;
default:
/* unknown */
unknown_presentation_type(format.type, obj->ob_type->tp_name);
goto done;
}
done:
Py_XDECREF(tmp);
Py_XDECREF(str);
return result;
} | false | false | false | false | false | 0 |
FreeWadLevel(level_t *level)
{
while (level->children)
{
lump_t *head = level->children;
level->children = head->next;
// the ol' recursion trick... :)
FreeLump(head);
}
UtilFree(level);
} | false | false | false | false | false | 0 |
get_out_name(GLEFileLocation* inname, CmdLineObj& cmdline, GLEFileLocation* outname) {
if (cmdline.hasOption(GLE_OPT_OUTPUT)) {
const string& o_file = cmdline.getOptionString(GLE_OPT_OUTPUT);
if (str_i_equals(o_file, "STDOUT")) {
outname->createStdout();
} else {
if (str_i_ends_with(o_file, ".ps")) force_device(GLE_DEVICE_PS, cmdline);
if (str_i_ends_with(o_file, ".pdf")) force_device(GLE_DEVICE_PDF, cmdline);
if (str_i_ends_with(o_file, ".svg")) force_device(GLE_DEVICE_SVG, cmdline);
if (str_i_ends_with(o_file, ".jpg")) force_device(GLE_DEVICE_JPEG, cmdline);
if (str_i_ends_with(o_file, ".png")) force_device(GLE_DEVICE_PNG, cmdline);
string main_name;
GetMainName(o_file, main_name);
outname->fromFileNameDir(main_name, GLE_WORKING_DIR);
}
} else {
if (inname->isStdin()) {
outname->createStdout();
} else {
string main_name;
GetMainNameExt(inname->getFullPath(), ".gle", main_name);
outname->fromAbsolutePath(main_name);
}
}
} | false | false | false | false | false | 0 |
defaultName(string path)
{
string::iterator b, e, c;
b=path.begin();
e=path.end();
c=b;
while (b != e)
if (*b++ == '/')
c=b;
path=string(c, e);
char *p=libmail_u_convert_tobuf(path.c_str(),
unicode_x_imap_modutf7,
unicode_default_chset(),
NULL);
if (p)
{
try {
path=p;
free(p);
} catch (...) {
free(p);
LIBMAIL_THROW(LIBMAIL_THROW_EMPTY);
}
}
return path;
} | false | false | false | false | false | 0 |
vxge_rem_msix_isr(struct vxgedev *vdev)
{
int intr_cnt;
for (intr_cnt = 0; intr_cnt < (vdev->no_of_vpath * 2 + 1);
intr_cnt++) {
if (vdev->vxge_entries[intr_cnt].in_use) {
synchronize_irq(vdev->entries[intr_cnt].vector);
free_irq(vdev->entries[intr_cnt].vector,
vdev->vxge_entries[intr_cnt].arg);
vdev->vxge_entries[intr_cnt].in_use = 0;
}
}
kfree(vdev->entries);
kfree(vdev->vxge_entries);
vdev->entries = NULL;
vdev->vxge_entries = NULL;
if (vdev->config.intr_type == MSI_X)
pci_disable_msix(vdev->pdev);
} | false | false | false | false | false | 0 |
GetAbstractArray(const char *arrayName, int &index)
{
int i;
const char *name;
index = -1;
if (!arrayName)
{
return NULL;
}
for (i=0; i < this->GetNumberOfArrays(); i++)
{
name = this->GetArrayName(i);
if ( name && !strcmp(name,arrayName) )
{
index = i;
return this->GetAbstractArray(i);
}
}
return NULL;
} | false | false | false | false | false | 0 |
gt_contigs_writer_delete(GtContigsWriter *contigs_writer)
{
if (contigs_writer == NULL)
return;
GT_FREEARRAY(&contigs_writer->contig, char);
gt_str_delete(contigs_writer->contig_desc);
gt_str_delete(contigs_writer->path_desc);
gt_assembly_stats_calculator_delete(contigs_writer->asc);
gt_encseq_reader_delete(contigs_writer->esr);
gt_free(contigs_writer);
} | false | false | false | false | false | 0 |
Translate(double *p1, double *p2)
{
//Get the motion vector
double v[3];
v[0] = p2[0] - p1[0];
v[1] = p2[1] - p1[1];
v[2] = p2[2] - p1[2];
//int res = this->PlaneSource->GetXResolution();
double *o = this->PlaneSource->GetOrigin();
double *pt1 = this->PlaneSource->GetPoint1();
double *pt2 = this->PlaneSource->GetPoint2();
double origin[3], point1[3], point2[3];
for (int i=0; i<3; i++)
{
origin[i] = o[i] + v[i];
point1[i] = pt1[i] + v[i];
point2[i] = pt2[i] + v[i];
}
this->PlaneSource->SetOrigin(origin);
this->PlaneSource->SetPoint1(point1);
this->PlaneSource->SetPoint2(point2);
this->PlaneSource->Update();
this->PositionHandles();
} | false | false | false | false | false | 0 |
via_checksum(struct via_metadata *v)
{
uint8_t i = 50, cs = 0;
while (i--)
cs += ((uint8_t*) v)[i];
return cs;
} | false | false | false | false | false | 0 |
set_mii_flow_control(struct velocity_info *vptr)
{
/*Enable or Disable PAUSE in ANAR */
switch (vptr->options.flow_cntl) {
case FLOW_CNTL_TX:
MII_REG_BITS_OFF(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
MII_REG_BITS_ON(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
break;
case FLOW_CNTL_RX:
MII_REG_BITS_ON(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
MII_REG_BITS_ON(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
break;
case FLOW_CNTL_TX_RX:
MII_REG_BITS_ON(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
MII_REG_BITS_OFF(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
break;
case FLOW_CNTL_DISABLE:
MII_REG_BITS_OFF(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
MII_REG_BITS_OFF(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
break;
default:
break;
}
} | false | false | false | false | false | 0 |
_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = args ? (int)PyObject_Length(args) : 0;
for (ii = 0; (ii < 2) && (ii < argc); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_SwigPyIterator_decr__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_SwigPyIterator_decr__SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
" Possible C/C++ prototypes are:\n"
" swig::SwigPyIterator::decr(size_t)\n"
" swig::SwigPyIterator::decr()\n");
return 0;
} | false | false | false | false | false | 0 |
_dlist_element_remove_all (DList * list)
{
DListElement * tmp = list->head;
while (tmp) {
DListElement * aux = tmp;
tmp = tmp->next;
_dlist_element_free (aux);
}
list->head = list->tail = NULL;
} | false | false | false | false | false | 0 |
gst_mpegv_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
{
GstMpegvParse *mpvparse = GST_MPEGVIDEO_PARSE (parse);
GstBuffer *buffer = frame->buffer;
if (G_UNLIKELY (mpvparse->pichdr.pic_type == GST_MPEG_VIDEO_PICTURE_TYPE_I))
GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
else
GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
/* maybe only sequence in this buffer, though not recommended,
* so mark it as such and force 0 duration */
if (G_UNLIKELY (mpvparse->pic_offset < 0)) {
GST_DEBUG_OBJECT (mpvparse, "frame holds no picture data");
frame->flags |= GST_BASE_PARSE_FRAME_FLAG_NO_FRAME;
GST_BUFFER_DURATION (buffer) = 0;
}
if (mpvparse->pic_offset > 4) {
gst_base_parse_set_ts_at_offset (parse, mpvparse->pic_offset - 4);
}
if (mpvparse->frame_repeat_count
&& GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DURATION (buffer))) {
GST_BUFFER_DURATION (buffer) =
(1 + mpvparse->frame_repeat_count) * GST_BUFFER_DURATION (buffer) / 2;
}
if (G_UNLIKELY (mpvparse->drop && !mpvparse->config)) {
GST_DEBUG_OBJECT (mpvparse, "dropping frame as no config yet");
return GST_BASE_PARSE_FLOW_DROPPED;
}
gst_mpegv_parse_update_src_caps (mpvparse);
return GST_FLOW_OK;
} | false | false | false | false | false | 0 |
istgt_iscsi_parse_params(ISCSI_PARAM **params, const uint8_t *data, int len)
{
const uint8_t *p, *q;
const uint8_t *last;
char *key = NULL;
char *val = NULL;
int rc;
int n;
/* for each key/val temporary store */
key = xmalloc(ISCSI_TEXT_MAX_KEY_LEN + 1);
val = xmalloc(ISCSI_TEXT_MAX_VAL_LEN + 1);
/* data = "KEY=VAL<NUL>KEY=VAL<NUL>..." */
p = data;
last = data + len;
while (p < last && *p != '\0') {
q = p;
/* q = "KEY=VAL<NUL>" */
while (q < last && *q != '\0') {
if (*q == '=') {
break;
}
q++;
}
if (q >= last || *q == '\0') {
ISTGT_ERRLOG("'=' not found\n");
error_return:
xfree(key);
xfree(val);
return -1;
}
n = q - p;
if (n > ISCSI_TEXT_MAX_KEY_LEN) {
ISTGT_ERRLOG("Overflow Key %d\n", n);
goto error_return;
}
memcpy(key, p, n);
key[n] = '\0';
p = q + 1;
q = p;
/* q = "VAL<NUL>" */
while (q < last && *q != '\0') {
q++;
}
n = q - p;
if (n > ISCSI_TEXT_MAX_VAL_LEN) {
ISTGT_ERRLOG("Overflow Val %d\n", n);
goto error_return;
}
memcpy(val, p, n);
val[n] = '\0';
rc = istgt_iscsi_param_add(params, key, val, NULL, 0);
if (rc < 0) {
ISTGT_ERRLOG("iscsi_param_add() failed\n");
goto error_return;
}
p = q + 1;
while (p < last && *p == '\0') {
p++;
}
}
xfree(key);
xfree(val);
return 0;
} | false | false | false | false | false | 0 |
rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev)
{
void *reply_buf;
int ret;
void *p;
reply_buf = kzalloc(RBD_OBJ_PREFIX_LEN_MAX, GFP_KERNEL);
if (!reply_buf)
return -ENOMEM;
ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
"rbd", "get_object_prefix", NULL, 0,
reply_buf, RBD_OBJ_PREFIX_LEN_MAX);
dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
if (ret < 0)
goto out;
p = reply_buf;
rbd_dev->header.object_prefix = ceph_extract_encoded_string(&p,
p + ret, NULL, GFP_NOIO);
ret = 0;
if (IS_ERR(rbd_dev->header.object_prefix)) {
ret = PTR_ERR(rbd_dev->header.object_prefix);
rbd_dev->header.object_prefix = NULL;
} else {
dout(" object_prefix = %s\n", rbd_dev->header.object_prefix);
}
out:
kfree(reply_buf);
return ret;
} | false | false | false | false | false | 0 |
cftimer_create(int id, long delay, object *ob, int mode) {
if (id >= MAX_TIMERS)
return TIMER_ERR_ID;
if (id < 0)
return TIMER_ERR_ID;
if (timers_table[id].mode != TIMER_MODE_DEAD)
return TIMER_ERR_ID;
if ((mode != TIMER_MODE_SECONDS) && (mode != TIMER_MODE_CYCLES))
return TIMER_ERR_MODE;
if (ob == NULL)
return TIMER_ERR_OBJ;
if (object_find_by_type_subtype(ob, EVENT_CONNECTOR, EVENT_TIMER) == NULL)
return TIMER_ERR_OBJ;
timers_table[id].mode = mode;
timers_table[id].ob_tag = ob->count;
if (mode == TIMER_MODE_CYCLES)
timers_table[id].delay = delay;
else
timers_table[id].delay = seconds()+delay;
return TIMER_ERR_NONE;
} | false | false | false | false | false | 0 |
fvi_segment_plane(vec3d *new_pnt,
vec3d *plane_pnt,vec3d *plane_norm,
vec3d *p0,vec3d *p1,float rad)
{
float t;
vec3d d;
vm_vec_sub( &d, p1, p0 );
t = fvi_ray_plane(new_pnt,
plane_pnt,plane_norm, // Plane description, a point and a normal
p0,&d, // Ray description, a point and a direction
rad);
if ( t < 0.0f ) return 0; // intersection lies behind p0
if ( t > 1.0f ) return 0; // intersection lies past p1
return 1; // They intersect!
} | false | false | false | false | false | 0 |
LineTo_16bpp(HGDI_DC hdc, int nXEnd, int nYEnd)
{
int x, y;
int x1, y1;
int x2, y2;
int e, e2;
int dx, dy;
int sx, sy;
HGDI_BITMAP bmp;
int bx1, by1;
int bx2, by2;
int irop2;
uint16 pen;
uint16 *pixel;
x1 = hdc->pen->posX;
y1 = hdc->pen->posY;
x2 = nXEnd;
y2 = nYEnd;
dx = (x1 > x2) ? x1 - x2 : x2 - x1;
dy = (y1 > y2) ? y1 - y2 : y2 - y1;
sx = (x1 < x2) ? 1 : -1;
sy = (y1 < y2) ? 1 : -1;
e = dx - dy;
x = x1;
y = y1;
irop2 = gdi_GetROP2(hdc) - 1;
bmp = (HGDI_BITMAP) hdc->selectedObject;
if (hdc->clip->null)
{
bx1 = (x1 < x2) ? x1 : x2;
by1 = (y1 < y2) ? y1 : y2;
bx2 = (x1 > x2) ? x1 : x2;
by2 = (y1 > y2) ? y1 : y2;
}
else
{
bx1 = hdc->clip->x;
by1 = hdc->clip->y;
bx2 = bx1 + hdc->clip->w - 1;
by2 = by1 + hdc->clip->h - 1;
}
pen = gdi_GetPenColor_16bpp(hdc->pen);
while (1)
{
if (!(x == x2 && y == y2))
{
if ((x >= bx1 && x <= bx2) && (y >= by1 && y <= by2))
{
pixel = gdi_GetPointer_16bpp(bmp, x, y);
SetPixel16_ROP2_[irop2](pixel, &pen);
}
}
else
{
break;
}
e2 = 2 * e;
if (e2 > -dy)
{
e -= dy;
x += sx;
}
if (e2 < dx)
{
e += dx;
y += sy;
}
}
return 1;
} | false | false | false | false | false | 0 |
CalcHash(const vector<int>& frag)
{
//Something like... whole of fragment treated as a binary number modulus 1021
const int MODINT = 108; //2^32 % 1021
unsigned int hash=0;
for(unsigned i=0;i<frag.size();++i)
hash= (hash*MODINT + (frag[i] % 1021)) % 1021;
return hash;
} | false | false | false | false | false | 0 |
StateMap(const std::string& state) {
std::string state_ = state;
/*
Infosys states (mapped from GM states):
ACCEPTING
ACCEPTED
PREPARED
SUBMITTING
INLRMS: *
KILLING
EXECUTED
KILLED
FAILED
GM states (either not mapped or somehow obtained directly):
ACCEPTED
PREPARING
SUBMIT
INLRMS
CANCELING
FINISHING
FINISHED
DELETED
PENDING:*
*/
/// \mapname GM Grid Manager
/// \mapnote Prefix "PENDING:" and spaces are ignored when mapping states.
if (state_.substr(0,8) == "PENDING:") state_.erase(0,8);
// remove spaces because sometimes we may have 'INLRMS: *'
std::string::size_type p = 0;
while((p = state_.find(' ',p)) != std::string::npos)
state_.erase(p,1);
/// \mapattr ACCEPTED -> ACCEPTED
/// \mapattr ACCEPTING -> ACCEPTED
if ((state_ == "ACCEPTED") ||
(state_ == "ACCEPTING"))
return JobState::ACCEPTED;
/// \mapattr PREPARING -> PREPARING
/// \mapattr PREPARED -> PREPARING
else if ((state_ == "PREPARING") ||
(state_ == "PREPARED"))
return JobState::PREPARING;
/// \mapattr SUBMIT -> SUBMITTING
/// \mapattr SUBMITTING -> SUBMITTING
else if ((state_ == "SUBMIT") ||
(state_ == "SUBMITTING"))
return JobState::SUBMITTING;
/// \mapattr INLRMS:Q -> QUEUING
else if (state_ == "INLRMS:Q")
return JobState::QUEUING;
/// \mapattr INLRMS:R -> RUNNING
else if (state_ == "INLRMS:R")
return JobState::RUNNING;
/// \mapattr INLRMS:H -> HOLD
else if (state_ == "INLRMS:H")
return JobState::HOLD;
/// \mapattr INLRMS* -> QUEUING
else if (state_.substr(0,6) == "INLRMS")
return JobState::QUEUING; // expect worst ?
/// \mapattr FINISHING -> FINISHING
/// \mapattr KILLING -> FINISHING
/// \mapattr CANCELING -> FINISHING
/// \mapattr EXECUTED -> FINISHING
else if ((state_ == "FINISHING") ||
(state_ == "KILLING") ||
(state_ == "CANCELING") ||
(state_ == "EXECUTED"))
return JobState::FINISHING;
/// \mapattr FINISHED -> FINISHED
else if (state_ == "FINISHED")
return JobState::FINISHED;
/// \mapattr KILLED -> KILLED
else if (state_ == "KILLED")
return JobState::KILLED;
/// \mapattr FAILED -> FAILED
else if (state_ == "FAILED")
return JobState::FAILED;
/// \mapattr DELETED -> DELETED
else if (state_ == "DELETED")
return JobState::DELETED;
/// \mapattr "" -> UNDEFINED
else if (state_ == "")
return JobState::UNDEFINED;
/// \mapattr Any other state -> OTHER
else
return JobState::OTHER;
}
} | false | false | false | false | false | 0 |
startmon(struct ast_channel *chan, struct ast_audiohook *audiohook)
{
struct ast_channel *peer = NULL;
int res = 0;
if (!chan)
return -1;
ast_audiohook_attach(chan, audiohook);
if (!res && ast_test_flag(ast_channel_flags(chan), AST_FLAG_NBRIDGE) && (peer = ast_bridged_channel(chan)))
ast_softhangup(peer, AST_SOFTHANGUP_UNBRIDGE);
return res;
} | false | false | false | false | false | 0 |
krb5_cc_cache_match (krb5_context context,
krb5_principal client,
krb5_ccache *id)
{
krb5_cccol_cursor cursor;
krb5_error_code ret;
krb5_ccache cache = NULL;
krb5_ccache expired_match = NULL;
*id = NULL;
ret = krb5_cccol_cursor_new (context, &cursor);
if (ret)
return ret;
while (krb5_cccol_cursor_next(context, cursor, &cache) == 0 && cache != NULL) {
krb5_principal principal;
krb5_boolean match;
time_t lifetime;
ret = krb5_cc_get_principal(context, cache, &principal);
if (ret)
goto next;
if (client->name.name_string.len == 0)
match = (strcmp(client->realm, principal->realm) == 0);
else
match = krb5_principal_compare(context, principal, client);
krb5_free_principal(context, principal);
if (!match)
goto next;
if (expired_match == NULL &&
(krb5_cc_get_lifetime(context, cache, &lifetime) != 0 || lifetime == 0)) {
expired_match = cache;
cache = NULL;
goto next;
}
break;
next:
if (cache)
krb5_cc_close(context, cache);
cache = NULL;
}
krb5_cccol_cursor_free(context, &cursor);
if (cache == NULL && expired_match) {
cache = expired_match;
expired_match = NULL;
} else if (expired_match) {
krb5_cc_close(context, expired_match);
} else if (cache == NULL) {
char *str;
krb5_unparse_name(context, client, &str);
krb5_set_error_message(context, KRB5_CC_NOTFOUND,
N_("Principal %s not found in any "
"credential cache", ""),
str ? str : "<out of memory>");
if (str)
free(str);
return KRB5_CC_NOTFOUND;
}
*id = cache;
return 0;
} | false | false | false | false | false | 0 |
sym_name(const char *sym_strtab, Elf32_Sym *sym)
{
const char *name;
name = "<noname>";
if (sym->st_name) {
name = sym_strtab + sym->st_name;
}
else {
name = sec_name(sym->st_shndx);
}
return name;
} | false | false | false | false | false | 0 |
seahorse_pgp_uid_get_name (SeahorsePgpUid *self)
{
g_return_val_if_fail (SEAHORSE_IS_PGP_UID (self), NULL);
if (!self->pv->name)
self->pv->name = g_strdup ("");
return self->pv->name;
} | false | false | false | false | false | 0 |
scm_subr_p (SCM obj)
{
if (SCM_NIMP (obj))
switch (SCM_TYP7 (obj))
{
case scm_tcs_subrs:
return 1;
default:
;
}
return 0;
} | false | false | false | false | false | 0 |
atkin_q2_precomp()
{
int i = 0;
for (int x = 1; x <= 10; ++x)
{
for (int y = 1; y <= 30; ++y)
{
if (atkin_q2_filter[(3 * x * x + y * y) % 60] != 0)
{
atkin_q2_x0[i] = x;
atkin_q2_y0[i] = y;
++i;
}
}
}
atkin_q2_x0[i] = 0;
atkin_q2_y0[i] = 0;
} | false | false | false | false | false | 0 |
analyserfindlabel(Symbol *labels, const char *label)
{
if (labels) {
int i = strcmp(label, labels->name);
if (i < 0) return analyserfindlabel(labels->left, label);
if (i > 0) return analyserfindlabel(labels->right, label);
return labels->location ? labels : NULL;
}
return NULL;
} | false | false | false | false | false | 0 |
deviceTypeCode(int type)
{
const ant_sensor_type_t *st=ant_sensor_types;
do {
if (st->device_id==type) return st->suffix;
} while (++st, st->type != ANTChannel::CHANNEL_TYPE_GUARD);
return '-';
} | false | false | false | false | false | 0 |
EventHandler()
{
if( !valid) return;
// dummy call to get private function set_stream() called
// char dummy;
// gesc( &dummy);
//
// plgpls( &pls);
XwDev *dev = (XwDev *) pls->dev;
// if( dev == NULL)
// this->plstream::init();
//
// plgpls( &pls);
//
// dev = (XwDev *) pls->dev;
if( dev == NULL)
{
cerr << "X window invalid." << endl;
valid = false;
return;
}
XwDisplay *xwd = (XwDisplay *) dev->xwd;
if( xwd == NULL)
{
cerr << "X window not set." << endl;
valid = false;
return;
}
XEvent event;
if( XCheckTypedWindowEvent( xwd->display, dev->window,
ClientMessage, &event))
{
if( event.xclient.message_type == wm_protocols &&
event.xclient.data.l[0] == wm_delete_window)
{
valid = false;
return; // no more event handling
}
else
XPutBackEvent( xwd->display, &event);
}
// plplot event handler
plstream::cmd( PLESC_EH, NULL);
} | false | false | false | false | false | 0 |
audio_loadwav(int effectnr) {
char file[MAXPATHLEN];
Mix_Chunk *result;
snprintf(file,MAXPATHLEN,"%s/ffrenzy/sounds/ffrenzy_%s_sound.wav",
DATADIR,
audio_effectnames[effectnr]);
result = Mix_LoadWAV(file);
if (result == NULL) {
WARN("Couldn't load %s sound from %s",audio_effectnames[effectnr],file);
}
return result;
} | false | false | false | false | false | 0 |
cli_bcapi_buffer_pipe_read_get(struct cli_bc_ctx *ctx , int32_t id, uint32_t size)
{
struct bc_buffer *b = get_buffer(ctx, id);
if (!b || size > cli_bcapi_buffer_pipe_read_avail(ctx, id) || !size)
return NULL;
if (b->data)
return b->data + b->read_cursor;
return fmap_need_off(ctx->fmap, b->read_cursor, size);
} | false | false | false | false | false | 0 |
dw_spi_dma_tx_done(void *arg)
{
struct dw_spi *dws = arg;
clear_bit(TX_BUSY, &dws->dma_chan_busy);
if (test_bit(RX_BUSY, &dws->dma_chan_busy))
return;
spi_finalize_current_transfer(dws->master);
} | false | false | false | false | false | 0 |
find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
{
struct find_typenames_t *d = (struct find_typenames_t *)data;
tree mv = NULL_TREE;
if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
/* Add the type of the typedef without any additional cv-quals. */
mv = TREE_TYPE (TYPE_NAME (*tp));
else if (TREE_CODE (*tp) == TYPENAME_TYPE
|| TREE_CODE (*tp) == DECLTYPE_TYPE)
/* Add the typename without any cv-qualifiers. */
mv = TYPE_MAIN_VARIANT (*tp);
if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
VEC_safe_push (tree, gc, d->typenames, mv);
/* Search into class template arguments, which cp_walk_subtrees
doesn't do. */
if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
data, d->p_set);
return NULL_TREE;
} | false | false | false | false | false | 0 |
render_pixmap(int lp, enum what_display what)
{
GdkPixbuf **pb=which_pixbuf(lp,what);
GdkPixmap **pm=which_pixmap(lp,what);
int w,h;
which_pixbuf_size(lp, what, &w, &h);
if( *pm==NULL) {
g_debug("creating pixmap [%d] type %d",lp,what);
create__pixmap(lp,what);
}
if( *pb==NULL) {
g_debug("creating pixbuf [%d] type %d",lp,what);
create__pixbuf(lp,what);
}
#ifdef DIM
//FIXME dim image a bit to better view mesh DONE BELOW
gdk_pixbuf_saturate_and_pixelate
(const GdkPixbuf *src,
GdkPixbuf *dest,
gfloat saturation,
gboolean pixelate);
#endif
{
int dx=0, dy=0;
GdkPixbuf* new;
if ( what == PIXLOADED )
{ dy+=PIXLOADEDBORDER; dx+=PIXLOADEDBORDER; }
if ( what == PIXSUBIMAGE)
{ dy+=PIXEDITBORDER; dx+=PIXEDITBORDER; }
if(what != PIXWARPED && image_settings_get_value("dim image",lp))
{
new=gdk_pixbuf_copy (*pb);
dim(new);
}
else
{
new=*pb;
gdk_pixbuf_ref(new);
}
gdk_pixbuf_render_to_drawable
(new,
*pm,
sp->im_widget[lp]->style->black_gc, //GdkGC *gc,
0, //int src_x,
0, //int src_y,
dx, //int dest_x,
dy, //int dest_y,
w,h, //width, height,
GDK_RGB_DITHER_NORMAL,//GdkRgbDither dither,
0, //int x_dither,
0 ); //int y_dither);
gdk_pixbuf_unref(new);
}
} | false | false | false | false | false | 0 |
AddNewCallback(unsigned short code, bool mostRecentOnly, Callback *instance, Callback::Method method)
{
// init the udp layer before we add the callback
instance->UdpLayer().Init();
bool found = false;
for (ListSender::iterator it = _clients.begin(); !found && it != _clients.end(); ++it)
{
if (it->instance == instance)
{
found = true;
CallbackMethod &c = it->methods[code];
c.method = method;
c.currentSequence = -1;
c.mostRecentOnly = mostRecentOnly;
}
}
// if not found insert a new callback instance
if (!found)
LOG_ERROR << "UdpConnection::AddNewCallback: Failed to retreive the callback instance" << std::endl;
} | false | false | false | false | false | 0 |
totem_sublang_update (Totem *totem)
{
GList *list;
list = bacon_video_widget_get_languages (totem->bvw);
if (totem_sublang_equal_lists (totem->language_list, list) == TRUE) {
totem_g_list_deep_free (list);
} else {
totem_languages_update (totem, list);
}
list = bacon_video_widget_get_subtitles (totem->bvw);
if (totem_sublang_equal_lists (totem->subtitles_list, list) == TRUE) {
totem_g_list_deep_free (list);
} else {
totem_subtitles_update (totem, list);
}
} | false | false | false | false | false | 0 |
set_schema_list(const Glib::ustring& key,const SListHandle_ValueSchema& list)
{
Value v(VALUE_LIST);
v.set_list_type(VALUE_SCHEMA);
v.set_schema_list(list);
this->set(key, v);
} | false | false | false | false | false | 0 |
tree_mem_ref_addr (tree type, tree mem_ref)
{
tree addr;
tree act_elem;
tree step = TMR_STEP (mem_ref), offset = TMR_OFFSET (mem_ref);
tree addr_base = NULL_TREE, addr_off = NULL_TREE;
addr_base = fold_convert (type, TMR_BASE (mem_ref));
act_elem = TMR_INDEX (mem_ref);
if (act_elem)
{
if (step)
act_elem = fold_build2 (MULT_EXPR, TREE_TYPE (act_elem),
act_elem, step);
addr_off = act_elem;
}
act_elem = TMR_INDEX2 (mem_ref);
if (act_elem)
{
if (addr_off)
addr_off = fold_build2 (PLUS_EXPR, TREE_TYPE (addr_off),
addr_off, act_elem);
else
addr_off = act_elem;
}
if (offset && !integer_zerop (offset))
{
if (addr_off)
addr_off = fold_build2 (PLUS_EXPR, TREE_TYPE (addr_off), addr_off,
fold_convert (TREE_TYPE (addr_off), offset));
else
addr_off = offset;
}
if (addr_off)
addr = fold_build_pointer_plus (addr_base, addr_off);
else
addr = addr_base;
return addr;
} | false | false | false | false | true | 1 |
ecore_thread_local_data_set(Ecore_Thread *thread,
const char *key,
void *value,
Eina_Free_Cb cb)
{
#ifdef EFL_HAVE_THREADS
Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *)thread;
Ecore_Thread_Data *d, *r;
void *ret;
#endif
if ((!thread) || (!key) || (!value))
return NULL;
#ifdef EFL_HAVE_THREADS
if (!PHE(worker->self, PHS())) return NULL;
if (!worker->hash)
worker->hash = eina_hash_string_small_new(_ecore_thread_data_free);
if (!worker->hash)
return NULL;
if (!(d = malloc(sizeof(Ecore_Thread_Data))))
return NULL;
d->data = value;
d->cb = cb;
r = eina_hash_set(worker->hash, key, d);
CDB(worker->cond);
ret = r->data;
free(r);
return ret;
#else
(void) cb;
return NULL;
#endif
} | false | false | false | false | false | 0 |
_dbus_marshal_skip_basic (const DBusString *str,
int type,
int byte_order,
int *pos)
{
_dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
byte_order == DBUS_BIG_ENDIAN);
switch (type)
{
case DBUS_TYPE_BYTE:
(*pos)++;
break;
case DBUS_TYPE_INT16:
case DBUS_TYPE_UINT16:
*pos = _DBUS_ALIGN_VALUE (*pos, 2);
*pos += 2;
break;
case DBUS_TYPE_BOOLEAN:
case DBUS_TYPE_INT32:
case DBUS_TYPE_UINT32:
case DBUS_TYPE_UNIX_FD:
*pos = _DBUS_ALIGN_VALUE (*pos, 4);
*pos += 4;
break;
case DBUS_TYPE_INT64:
case DBUS_TYPE_UINT64:
case DBUS_TYPE_DOUBLE:
*pos = _DBUS_ALIGN_VALUE (*pos, 8);
*pos += 8;
break;
case DBUS_TYPE_STRING:
case DBUS_TYPE_OBJECT_PATH:
{
int len;
len = _dbus_marshal_read_uint32 (str, *pos, byte_order, pos);
*pos += len + 1; /* length plus nul */
}
break;
case DBUS_TYPE_SIGNATURE:
{
int len;
len = _dbus_string_get_byte (str, *pos);
*pos += len + 2; /* length byte plus length plus nul */
}
break;
default:
_dbus_warn ("type %s not a basic type\n",
_dbus_type_to_string (type));
_dbus_assert_not_reached ("not a basic type");
break;
}
} | false | false | false | false | false | 0 |
replace_delimiter (const GMatchInfo *match_info,
GString *expanded_regex,
gpointer data)
{
gchar *delim, *escapes;
ParserState *parser_state = data;
escapes = g_match_info_fetch (match_info, 1);
g_string_append (expanded_regex, escapes);
delim = g_match_info_fetch (match_info, 2);
DEBUG (g_message ("replacing '\\%%%s'", delim));
switch (delim[0])
{
case '[':
g_string_append (expanded_regex,
parser_state->opening_delimiter);
break;
case ']':
g_string_append (expanded_regex,
parser_state->closing_delimiter);
break;
}
g_free (delim);
g_free (escapes);
return FALSE;
} | false | false | false | false | false | 0 |
poptGetContext(const char * name, int argc, const char ** argv,
const struct poptOption * options, int flags) {
poptContext con = (poptContext)malloc(sizeof(*con));
memset(con, 0, sizeof(*con));
con->os = con->optionStack;
con->os->argc = argc;
con->os->argv = argv;
con->os->argb = NULL;
if (!(flags & POPT_CONTEXT_KEEP_FIRST))
con->os->next = 1; /* skip argv[0] */
con->leftovers = (const char**)calloc( (argc + 1), sizeof(char *) );
con->options = options;
con->aliases = NULL;
con->numAliases = 0;
con->flags = flags;
con->execs = NULL;
con->numExecs = 0;
con->finalArgvAlloced = argc * 2;
con->finalArgv = (const char**)calloc( con->finalArgvAlloced, sizeof(*con->finalArgv) );
con->execAbsolute = 1;
con->arg_strip = NULL;
if (getenv("POSIXLY_CORRECT") || getenv("POSIX_ME_HARDER"))
con->flags |= POPT_CONTEXT_POSIXMEHARDER;
if (name)
con->appName = strcpy((char*)malloc(strlen(name) + 1), name);
invokeCallbacks(con, con->options, 0);
return con;
} | false | false | false | false | false | 0 |
rsn_parsetter_check_caps (RsnParSetter * parset, GstCaps * caps)
{
GstStructure *s;
gint width, height;
gint par_n, par_d;
guint dar_n, dar_d;
gboolean ret = FALSE;
if (parset->in_caps_last &&
(caps == parset->in_caps_last ||
gst_caps_is_equal (caps, parset->in_caps_last))) {
ret = parset->in_caps_was_ok;
goto out;
}
/* Calculate the DAR from the incoming caps, and return TRUE if it matches
* the required DAR, FALSE if not */
s = gst_caps_get_structure (caps, 0);
if (s == NULL)
goto out;
if (!gst_structure_get_int (s, "width", &width) ||
!gst_structure_get_int (s, "height", &height))
goto out;
if (!gst_structure_get_fraction (s, "pixel-aspect-ratio", &par_n, &par_d))
par_n = par_d = 1;
if (!gst_video_calculate_display_ratio (&dar_n, &dar_d, width, height,
par_n, par_d, 1, 1))
goto out;
GST_DEBUG_OBJECT (parset,
"Incoming video caps now: w %d h %d PAR %d/%d = DAR %d/%d",
width, height, par_n, par_d, dar_n, dar_d);
if (parset->is_widescreen) {
if (dar_n == 16 && dar_d == 9)
ret = TRUE;
} else {
if (dar_n == 4 && dar_d == 3)
ret = TRUE;
}
gst_caps_replace (&parset->in_caps_last, caps);
gst_caps_replace (&parset->in_caps_converted, NULL);
parset->in_caps_was_ok = ret;
out:
return ret;
} | false | false | false | false | false | 0 |
qlcnic_83xx_idc_need_reset_state(struct qlcnic_adapter *adapter)
{
struct qlcnic_mailbox *mbx = adapter->ahw->mailbox;
int ret = 0;
if (adapter->ahw->idc.prev_state != QLC_83XX_IDC_DEV_NEED_RESET) {
qlcnic_83xx_idc_update_audit_reg(adapter, 0, 1);
set_bit(__QLCNIC_RESETTING, &adapter->state);
clear_bit(QLC_83XX_MBX_READY, &mbx->status);
if (adapter->ahw->nic_mode == QLCNIC_VNIC_MODE)
qlcnic_83xx_disable_vnic_mode(adapter, 1);
if (qlcnic_check_diag_status(adapter)) {
dev_info(&adapter->pdev->dev,
"%s: Wait for diag completion\n", __func__);
adapter->ahw->idc.delay_reset = 1;
return 0;
} else {
qlcnic_83xx_idc_update_drv_ack_reg(adapter, 1, 1);
qlcnic_83xx_idc_detach_driver(adapter);
}
}
if (qlcnic_check_diag_status(adapter)) {
dev_info(&adapter->pdev->dev,
"%s: Wait for diag completion\n", __func__);
return -1;
} else {
if (adapter->ahw->idc.delay_reset) {
qlcnic_83xx_idc_update_drv_ack_reg(adapter, 1, 1);
qlcnic_83xx_idc_detach_driver(adapter);
adapter->ahw->idc.delay_reset = 0;
}
/* Check for ACK from other functions */
ret = qlcnic_83xx_idc_check_reset_ack_reg(adapter);
if (ret) {
dev_info(&adapter->pdev->dev,
"%s: Waiting for reset ACK\n", __func__);
return -1;
}
}
/* Transit to INIT state and restart the HW */
qlcnic_83xx_idc_enter_init_state(adapter, 1);
return ret;
} | false | false | false | false | false | 0 |
PQregisterThreadLock(pgthreadlock_t newhandler)
{
pgthreadlock_t prev = pg_g_threadlock;
if (newhandler)
pg_g_threadlock = newhandler;
else
pg_g_threadlock = default_threadlock;
return prev;
} | false | false | false | false | false | 0 |
textHeight(char *txt, int len)
{
if (!txt) return 0;
if (!len) return 0;
return ft->height((const char*)txt, len);
} | false | false | false | false | false | 0 |
strtok_delim(const strtok_t *s)
{
strtok_check(s);
if (NULL == s->p || s->string == s->p)
return '\0';
g_assert(s->p > s->string);
return *(s->p - 1);
} | false | false | false | false | false | 0 |
binop(int token, union yystype *val, int op, int noeval)
{
intmax_t a = primary(token, val, op, noeval);
op = last_token;
if (op < ARITH_BINOP_MIN || op >= ARITH_BINOP_MAX)
return a;
return binop2(a, op, ARITH_MAX_PREC, noeval);
} | false | false | false | false | false | 0 |
arcmsr_flush_adapter_cache(struct AdapterControlBlock *acb)
{
switch (acb->adapter_type) {
case ACB_ADAPTER_TYPE_A: {
arcmsr_hbaA_flush_cache(acb);
}
break;
case ACB_ADAPTER_TYPE_B: {
arcmsr_hbaB_flush_cache(acb);
}
break;
case ACB_ADAPTER_TYPE_C: {
arcmsr_hbaC_flush_cache(acb);
}
break;
case ACB_ADAPTER_TYPE_D:
arcmsr_hbaD_flush_cache(acb);
break;
}
} | false | false | false | false | false | 0 |
M_SetupWriteFields(void)
{
this->ClearFields();
MET_FieldRecordType * mF;
if(strlen(m_Comment)>0)
{
mF = new MET_FieldRecordType;
MET_InitWriteField(mF, "Comment", MET_STRING, strlen(m_Comment), m_Comment);
m_Fields.push_back(mF);
}
strcpy(m_ObjectTypeName,"Scene");
mF = new MET_FieldRecordType;
MET_InitWriteField(mF, "ObjectType", MET_STRING, strlen(m_ObjectTypeName),
m_ObjectTypeName);
m_Fields.push_back(mF);
mF = new MET_FieldRecordType;
MET_InitWriteField(mF, "NDims", MET_INT, m_NDims);
m_Fields.push_back(mF);
mF = new MET_FieldRecordType;
MET_InitWriteField(mF, "NObjects", MET_INT, m_NObjects);
m_Fields.push_back(mF);
} | false | false | false | false | false | 0 |
AddToList(char *name, char *icon_name, unsigned long off_flags,
unsigned long on_flags, int desk, int bw, int nobw,
char *forecolor, char *backcolor,
unsigned long off_buttons, unsigned long on_buttons)
{
name_list *nptr,*lastptr = NULL;
if((name == NULL)||((off_flags == 0)&&(on_flags == 0)&&(on_buttons == 0)&&
(off_buttons == 0)))
{
if(name)
free(name);
if(icon_name)
free(icon_name);
return;
}
/* used to merge duplicate entries, but that is no longer
* appropriate since conficting styles are possible, and the
* last match should win! */
for (nptr = Scr.TheList; nptr != NULL; nptr = nptr->next)
{
lastptr=nptr;
}
nptr = (name_list *)safemalloc(sizeof(name_list));
nptr->next = NULL;
nptr->name = name;
nptr->on_flags = on_flags;
nptr->off_flags = off_flags;
nptr->value = icon_name;
nptr->Desk = desk;
nptr->border_width = bw;
nptr->resize_width = nobw;
nptr->ForeColor = forecolor;
nptr->BackColor = backcolor;
nptr->off_buttons = off_buttons;
nptr->on_buttons = on_buttons;
if(lastptr != NULL)
lastptr->next = nptr;
else
Scr.TheList = nptr;
} | false | false | false | false | false | 0 |
halfdelay(int t)
{
T((T_CALLED("halfdelay(%d)"), t));
if (t < 1 || t > 255 || SP == 0)
returnCode(ERR);
cbreak();
SP->_cbreak = t + 1;
returnCode(OK);
} | false | false | false | false | false | 0 |
info_set_user_tag (CamelMessageInfo *info,
const gchar *name,
const gchar *value)
{
CamelMessageInfoBase *mi = (CamelMessageInfoBase *) info;
gint res;
res = camel_tag_set (&mi->user_tags, name, value);
if (mi->summary && res && mi->summary->priv->folder && mi->uid
&& camel_folder_summary_check_uid (mi->summary, mi->uid)) {
CamelFolderChangeInfo *changes = camel_folder_change_info_new ();
mi->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED;
mi->dirty = TRUE;
camel_folder_summary_touch (mi->summary);
camel_folder_change_info_change_uid (changes, camel_message_info_uid (info));
camel_folder_changed (mi->summary->priv->folder, changes);
camel_folder_change_info_free (changes);
}
return res;
} | false | false | false | false | false | 0 |
midgard_core_workspace_get_context_ids (MidgardConnection *mgd, guint id)
{
g_return_val_if_fail (mgd != NULL, NULL);
g_return_val_if_fail (id != 0, NULL);
guint row_id;
const GValue *up_val = midgard_core_workspace_get_value_by_id (mgd, MGD_WORKSPACE_FIELD_IDX_UP, id, &row_id);
guint up_id = 0;
if (G_VALUE_HOLDS_UINT (up_val))
up_id = g_value_get_uint (up_val);
else
up_id = (guint) g_value_get_int (up_val);
GSList *l = _get_parent_values (mgd, up_id, MGD_WORKSPACE_FIELD_IDX_ID);
GValue *id_val = g_new0 (GValue, 1);
g_value_init (id_val, G_TYPE_UINT);
g_value_set_uint (id_val, id);
if (l)
l = g_slist_reverse (l);
l = g_slist_prepend (l, (gpointer) id_val);
return l;
} | false | false | false | false | false | 0 |
conf_mute_moh_inactive_waitmarked(struct conference_bridge_user *user)
{
/* Be sure we are muted so we can't talk to anybody else waiting */
user->features.mute = 1;
/* Start music on hold if needed */
if (ast_test_flag(&user->u_profile, USER_OPT_MUSICONHOLD)) {
conf_moh_start(user);
}
} | false | false | false | false | false | 0 |
e_dbhash_remove (EDbHash *edbh,
const gchar *key)
{
DB *db;
DBT dkey;
g_return_if_fail (edbh != NULL);
g_return_if_fail (edbh->priv != NULL);
g_return_if_fail (key != NULL);
db = edbh->priv->db;
/* Key dbt */
string_to_dbt (key, &dkey);
/* Remove from database */
db->del (db, NULL, &dkey, 0);
} | false | false | false | false | false | 0 |
epu_dma_done_irq(struct cx18 *cx, struct cx18_in_work_order *order)
{
u32 handle, mdl_ack_offset, mdl_ack_count;
struct cx18_mailbox *mb;
int i;
mb = &order->mb;
handle = mb->args[0];
mdl_ack_offset = mb->args[1];
mdl_ack_count = mb->args[2];
if (handle == CX18_INVALID_TASK_HANDLE ||
mdl_ack_count == 0 || mdl_ack_count > CX18_MAX_MDL_ACKS) {
if ((order->flags & CX18_F_EWO_MB_STALE) == 0)
mb_ack_irq(cx, order);
return -1;
}
for (i = 0; i < sizeof(struct cx18_mdl_ack) * mdl_ack_count; i += sizeof(u32))
((u32 *)order->mdl_ack)[i / sizeof(u32)] =
cx18_readl(cx, cx->enc_mem + mdl_ack_offset + i);
if ((order->flags & CX18_F_EWO_MB_STALE) == 0)
mb_ack_irq(cx, order);
return 1;
} | false | false | false | false | false | 0 |
stun_check_message_integrity_by_key_str(turn_credential_type ct, u08bits *buf, size_t len, hmackey_t key, st_password_t pwd, SHATYPE shatype, int *too_weak)
{
int res = 0;
u08bits new_hmac[MAXSHASIZE];
unsigned int shasize;
const u08bits *old_hmac = NULL;
stun_attr_ref sar = stun_attr_get_first_by_type_str(buf, len, STUN_ATTRIBUTE_MESSAGE_INTEGRITY);
if (!sar)
return -1;
int sarlen = stun_attr_get_len(sar);
switch(sarlen) {
case SHA256SIZEBYTES:
shasize = SHA256SIZEBYTES;
if(shatype != SHATYPE_SHA256)
return -1;
break;
case SHA1SIZEBYTES:
shasize = SHA1SIZEBYTES;
if(shatype != SHATYPE_SHA1) {
if(too_weak)
*too_weak = 1;
return -1;
}
break;
default:
return -1;
};
int orig_len = stun_get_command_message_len_str(buf, len);
if (orig_len < 0)
return -1;
int new_len = ((const u08bits*) sar - buf) + 4 + shasize;
if (new_len > orig_len)
return -1;
if (stun_set_command_message_len_str(buf, new_len) < 0)
return -1;
if(ct == TURN_CREDENTIALS_SHORT_TERM) {
res = stun_calculate_hmac(buf, (size_t) new_len - 4 - shasize, pwd, strlen((char*)pwd), new_hmac, &shasize, shatype);
} else {
res = stun_calculate_hmac(buf, (size_t) new_len - 4 - shasize, key, get_hmackey_size(shatype), new_hmac, &shasize, shatype);
}
stun_set_command_message_len_str(buf, orig_len);
if(res<0)
return -1;
old_hmac = stun_attr_get_value(sar);
if(!old_hmac)
return -1;
if(bcmp(old_hmac,new_hmac,shasize))
return 0;
return +1;
} | false | false | false | false | false | 0 |
release_card(struct fritzcard *card)
{
u_long flags;
disable_hwirq(card);
spin_lock_irqsave(&card->lock, flags);
modehdlc(&card->bch[0], ISDN_P_NONE);
modehdlc(&card->bch[1], ISDN_P_NONE);
spin_unlock_irqrestore(&card->lock, flags);
card->isac.release(&card->isac);
free_irq(card->irq, card);
mISDN_freebchannel(&card->bch[1]);
mISDN_freebchannel(&card->bch[0]);
mISDN_unregister_device(&card->isac.dch.dev);
release_region(card->addr, 32);
pci_disable_device(card->pdev);
pci_set_drvdata(card->pdev, NULL);
write_lock_irqsave(&card_lock, flags);
list_del(&card->list);
write_unlock_irqrestore(&card_lock, flags);
kfree(card);
AVM_cnt--;
} | false | false | false | false | false | 0 |
test_sample_is_vbox(char *name, int quiet)
{
struct tm *timelocal;
struct stat status;
vaheader_t header;
time_t timestamp;
long int compression;
int fd;
char timestring[256];
compression = 255;
if ((fd = open(name, O_RDONLY)) != -1)
{
if (header_get(fd, &header))
{
compression = ntohl(header.compression);
if ((compression < 2) || (compression > 6)) compression = 0;
if (fstat(fd, &status) == 0)
{
timestamp = ntohl(header.time);
timelocal = localtime(×tamp);
if (strftime(timestring, 255, "%c\n", timelocal) == 255)
{
printstring(timestring, "???\n");
}
if (!quiet)
{
fprintf(stdout, "\n");
fprintf(stdout, "Creation time...........: %s", timestring);
fprintf(stdout, "Compression.............: %s\n", compressions[compression]);
fprintf(stdout, "Length..................: %d seconds\n", get_message_ptime(compression, (status.st_size - sizeof(vaheader_t))));
fprintf(stdout, "Speaker name............: %s\n", header.name);
fprintf(stdout, "Speaker caller number...: %s\n", header.callerid);
fprintf(stdout, "Speaker phone number....: %s\n", header.phone);
fprintf(stdout, "Speaker location........: %s\n", header.location);
fprintf(stdout, "\n");
}
}
}
close(fd);
}
else fprintf(stderr, "%s: can't open \"%s\" (vbox sample test).\n", vbasename, name);
return(compression);
} | true | true | false | false | true | 1 |
build_plselection_prompt(char *buf, int buflen, int rolenum, int racenum, int gendnum, int alignnum)
{
const char *defprompt = "Shall I pick a character for you? [ynq] ";
int num_post_attribs = 0;
char tmpbuf[BUFSZ];
if (buflen < QBUFSZ)
return (char *)defprompt;
strcpy(tmpbuf, "Shall I pick ");
if (racenum != ROLE_NONE || validrole(rolenum))
strcat(tmpbuf, "your ");
else
{
strcat(tmpbuf, "a ");
}
/* <your> */
root_plselection_prompt(eos(tmpbuf), buflen - strlen(tmpbuf),
rolenum, racenum, gendnum, alignnum);
sprintf(buf, "%s", s_suffix(tmpbuf));
/* buf should now be:
* < your lawful female gnomish cavewoman's> || <your lawful female gnome's>
* || <your lawful female character's>
*
* Now append the post attributes to it
*/
num_post_attribs = post_attribs;
if (post_attribs)
{
if (pa[BP_RACE])
{
promptsep(eos(buf), num_post_attribs);
strcat(buf, "race");
}
if (pa[BP_ROLE])
{
promptsep(eos(buf), num_post_attribs);
strcat(buf, "role");
}
if (pa[BP_GEND])
{
promptsep(eos(buf), num_post_attribs);
strcat(buf, "gender");
}
if (pa[BP_ALIGN])
{
promptsep(eos(buf), num_post_attribs);
strcat(buf, "alignment");
}
}
strcat(buf, " for you? [ynq] ");
return buf;
} | false | false | false | false | false | 0 |
ws()
{
while ( (Pos < Text.length()) && (Text[Pos] == ' ') )
++Pos;
} | false | false | false | false | false | 0 |
temp_prefs_get_double(TempPrefs *temp_prefs, const gchar *key) {
gchar *string; /* Hash value string */
gdouble value; /* Returned value */
g_return_val_if_fail (temp_prefs && temp_prefs->tree, 0);
g_return_val_if_fail (key, 0);
value = 0.0f;
string = g_tree_lookup(temp_prefs->tree, key);
if (string)
value = g_ascii_strtod(string, NULL);
return value;
} | false | false | false | false | false | 0 |
prune_old(void *key, void *value, size_t u_len, void *u_data)
{
const kuid_t *id = key;
const struct lifedata *ld = value;
time_delta_t d;
bool expired;
double p;
(void) u_len;
(void) u_data;
d = delta_time(tm_time(), ld->last_seen);
if (d <= STABLE_EXPIRE) {
expired = FALSE;
p = 1.0;
} else {
p = stable_still_alive_probability(ld->first_seen, ld->last_seen);
expired = p < STABLE_PROBA;
}
if (GNET_PROPERTY(dht_stable_debug) > 4) {
g_debug("DHT STABLE node %s life=%s last_seen=%s, p=%.2f%%%s",
kuid_to_hex_string(id),
compact_time(delta_time(ld->last_seen, ld->first_seen)),
compact_time2(d), p * 100.0,
expired ? " [EXPIRED]" : "");
}
return expired;
} | false | false | false | false | false | 0 |
ses_do_frame(fr)
frame_T *fr;
{
frame_T *frc;
if (fr->fr_layout == FR_LEAF)
return ses_do_win(fr->fr_win);
for (frc = fr->fr_child; frc != NULL; frc = frc->fr_next)
if (ses_do_frame(frc))
return TRUE;
return FALSE;
} | false | false | false | false | false | 0 |
gst_rtp_h263p_pay_flush (GstRtpH263PPay * rtph263ppay)
{
guint avail;
GstBuffer *outbuf;
GstFlowReturn ret;
gboolean fragmented;
avail = gst_adapter_available (rtph263ppay->adapter);
if (avail == 0)
return GST_FLOW_OK;
fragmented = FALSE;
/* This algorithm assumes the H263/+/++ encoder sends complete frames in each
* buffer */
/* With Fragmentation Mode at GST_FRAGMENTATION_MODE_NORMAL:
* This algorithm implements the Follow-on packets method for packetization.
* This assumes low packet loss network.
* With Fragmentation Mode at GST_FRAGMENTATION_MODE_SYNC:
* This algorithm separates large frames at synchronisation points (Segments)
* (See RFC 4629 section 6). It would be interesting to have a property such as network
* quality to select between both packetization methods */
/* TODO Add VRC supprt (See RFC 4629 section 5.2) */
while (avail > 0) {
guint towrite;
guint8 *payload;
guint payload_len;
gint header_len;
guint next_gop = 0;
gboolean found_gob = FALSE;
GstRTPBuffer rtp = { NULL };
if (rtph263ppay->fragmentation_mode == GST_FRAGMENTATION_MODE_SYNC) {
/* start after 1st gop possible */
guint parsed_len = 3;
const guint8 *parse_data = NULL;
parse_data = gst_adapter_map (rtph263ppay->adapter, avail);
/* Check if we have a gob or eos , eossbs */
/* FIXME EOS and EOSSBS packets should never contain any gobs and vice-versa */
if (avail >= 3 && *parse_data == 0 && *(parse_data + 1) == 0
&& *(parse_data + 2) >= 0x80) {
GST_DEBUG_OBJECT (rtph263ppay, " Found GOB header");
found_gob = TRUE;
}
/* Find next and cut the packet accordingly */
/* TODO we should get as many gobs as possible until MTU is reached, this
* code seems to just get one GOB per packet */
while (parsed_len + 2 < avail) {
if (parse_data[parsed_len] == 0 && parse_data[parsed_len + 1] == 0
&& parse_data[parsed_len + 2] >= 0x80) {
next_gop = parsed_len;
GST_DEBUG_OBJECT (rtph263ppay, " Next GOB Detected at : %d",
next_gop);
break;
}
parsed_len++;
}
gst_adapter_unmap (rtph263ppay->adapter);
}
/* for picture start frames (non-fragmented), we need to remove the first
* two 0x00 bytes and set P=1 */
header_len = (fragmented && !found_gob) ? 2 : 0;
towrite = MIN (avail, gst_rtp_buffer_calc_payload_len
(GST_RTP_BASE_PAYLOAD_MTU (rtph263ppay) - header_len, 0, 0));
if (next_gop > 0)
towrite = MIN (next_gop, towrite);
payload_len = header_len + towrite;
outbuf = gst_rtp_buffer_new_allocate (payload_len, 0, 0);
gst_rtp_buffer_map (outbuf, GST_MAP_WRITE, &rtp);
/* last fragment gets the marker bit set */
gst_rtp_buffer_set_marker (&rtp, avail > towrite ? 0 : 1);
payload = gst_rtp_buffer_get_payload (&rtp);
gst_adapter_copy (rtph263ppay->adapter, &payload[header_len], 0, towrite);
/* 0 1
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | RR |P|V| PLEN |PEBIT|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
/* if fragmented or gop header , write p bit =1 */
payload[0] = (fragmented && !found_gob) ? 0x00 : 0x04;
payload[1] = 0;
GST_BUFFER_TIMESTAMP (outbuf) = rtph263ppay->first_timestamp;
GST_BUFFER_DURATION (outbuf) = rtph263ppay->first_duration;
gst_rtp_buffer_unmap (&rtp);
gst_adapter_flush (rtph263ppay->adapter, towrite);
ret =
gst_rtp_base_payload_push (GST_RTP_BASE_PAYLOAD (rtph263ppay), outbuf);
avail -= towrite;
fragmented = TRUE;
}
return ret;
} | false | false | false | false | false | 0 |
count_used_sockets(item *it)
{
int i;
int count = 0;
const char *addon;
for (i = 0; i < it->upgrade_sockets.size; i++) {
addon = it->upgrade_sockets.arr[i].addon;
if (addon)
count++;
}
return count;
} | false | false | false | false | false | 0 |
gnc_job_window_refresh_handler (GHashTable *changes, gpointer user_data)
{
JobWindow *jw = user_data;
const EventInfo *info;
GncJob *job = jw_get_job (jw);
/* If there isn't a job behind us, close down */
if (!job)
{
gnc_close_gui_component (jw->component_id);
return;
}
/* Next, close if this is a destroy event */
if (changes)
{
info = gnc_gui_get_entity_events (changes, &jw->job_guid);
if (info && (info->event_mask & QOF_EVENT_DESTROY))
{
gnc_close_gui_component (jw->component_id);
return;
}
}
} | false | false | false | false | false | 0 |
xhci_abort_cmd_ring(struct xhci_hcd *xhci, unsigned long flags)
{
u64 temp_64;
int ret;
xhci_dbg(xhci, "Abort command ring\n");
reinit_completion(&xhci->cmd_ring_stop_completion);
temp_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
xhci_write_64(xhci, temp_64 | CMD_RING_ABORT,
&xhci->op_regs->cmd_ring);
/* Section 4.6.1.2 of xHCI 1.0 spec says software should
* time the completion od all xHCI commands, including
* the Command Abort operation. If software doesn't see
* CRR negated in a timely manner (e.g. longer than 5
* seconds), then it should assume that the there are
* larger problems with the xHC and assert HCRST.
*/
ret = xhci_handshake(&xhci->op_regs->cmd_ring,
CMD_RING_RUNNING, 0, 5 * 1000 * 1000);
if (ret < 0) {
/* we are about to kill xhci, give it one more chance */
xhci_write_64(xhci, temp_64 | CMD_RING_ABORT,
&xhci->op_regs->cmd_ring);
udelay(1000);
ret = xhci_handshake(&xhci->op_regs->cmd_ring,
CMD_RING_RUNNING, 0, 3 * 1000 * 1000);
if (ret < 0) {
xhci_err(xhci, "Stopped the command ring failed, "
"maybe the host is dead\n");
xhci->xhc_state |= XHCI_STATE_DYING;
xhci_quiesce(xhci);
xhci_halt(xhci);
return -ESHUTDOWN;
}
}
/*
* Writing the CMD_RING_ABORT bit should cause a cmd completion event,
* however on some host hw the CMD_RING_RUNNING bit is correctly cleared
* but the completion event in never sent. Wait 2 secs (arbitrary
* number) to handle those cases after negation of CMD_RING_RUNNING.
*/
spin_unlock_irqrestore(&xhci->lock, flags);
ret = wait_for_completion_timeout(&xhci->cmd_ring_stop_completion,
msecs_to_jiffies(2000));
spin_lock_irqsave(&xhci->lock, flags);
if (!ret) {
xhci_dbg(xhci, "No stop event for abort, ring start fail?\n");
xhci_cleanup_command_queue(xhci);
} else {
xhci_handle_stopped_cmd_ring(xhci, xhci_next_queued_cmd(xhci));
}
return 0;
} | false | false | false | false | false | 0 |
PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os, indent);
os << indent << "Directory: " <<
(this->GetDirectory() ? this->GetDirectory() : " none") << "\n";
os << indent << "Pattern: " <<
(this->GetPattern() ? this->GetPattern() : " none") << "\n";
os << indent << "Recurse: " << (this->GetRecurse() ? "On\n" : "Off\n");
os << indent << "FileNames: (" << this->GetFileNames() << ")\n";
indent = indent.GetNextIndent();
for(int i = 0; i < this->FileNames->GetNumberOfValues(); i++)
{
os << indent << this->FileNames->GetValue(i) << "\n";
}
} | false | false | false | false | false | 0 |
halo(double *array1, int gridID1, double *array2, int lhalo, int rhalo)
{
int nlon1, nlat;
int ilat, ilon;
int nmin, nmax;
nlon1 = gridInqXsize(gridID1);
nlat = gridInqYsize(gridID1);
nmin = 0;
nmax = nlon1;
if ( lhalo < 0 ) nmin = -lhalo;
if ( rhalo < 0 ) nmax += rhalo;
for ( ilat = 0; ilat < nlat; ilat++ )
{
for ( ilon = nlon1-lhalo; ilon < nlon1; ilon++ )
*array2++ = array1[ilat*nlon1 + ilon];
for ( ilon = nmin; ilon < nmax; ilon++ )
*array2++ = array1[ilat*nlon1 + ilon];
for ( ilon = 0; ilon < rhalo; ilon++ )
*array2++ = array1[ilat*nlon1 + ilon];
}
} | false | false | false | false | false | 0 |
dove_thermal_probe(struct platform_device *pdev)
{
struct thermal_zone_device *thermal = NULL;
struct dove_thermal_priv *priv;
struct resource *res;
int ret;
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
priv->sensor = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(priv->sensor))
return PTR_ERR(priv->sensor);
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
priv->control = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(priv->control))
return PTR_ERR(priv->control);
ret = dove_init_sensor(priv);
if (ret) {
dev_err(&pdev->dev, "Failed to initialize sensor\n");
return ret;
}
thermal = thermal_zone_device_register("dove_thermal", 0, 0,
priv, &ops, NULL, 0, 0);
if (IS_ERR(thermal)) {
dev_err(&pdev->dev,
"Failed to register thermal zone device\n");
return PTR_ERR(thermal);
}
platform_set_drvdata(pdev, thermal);
return 0;
} | false | false | false | false | false | 0 |
bgzf_flush(BGZF *fp)
{
if (!fp->is_write) return 0;
if (fp->mt) return mt_flush(fp);
while (fp->block_offset > 0) {
int block_length;
block_length = deflate_block(fp, fp->block_offset);
if (block_length < 0) return -1;
if (fwrite(fp->compressed_block, 1, block_length, fp->fp) != block_length) {
fp->errcode |= BGZF_ERR_IO; // possibly truncated file
return -1;
}
fp->block_address += block_length;
}
return 0;
} | false | false | false | false | false | 0 |
fluid_settings_getnum_range(fluid_settings_t* settings, const char *name,
double* min, double* max)
{
fluid_setting_node_t *node;
fluid_return_if_fail (settings != NULL);
fluid_return_if_fail (name != NULL);
fluid_return_if_fail (name[0] != '\0');
fluid_return_if_fail (min != NULL);
fluid_return_if_fail (max != NULL);
fluid_rec_mutex_lock (settings->mutex);
if (fluid_settings_get(settings, name, &node)
&& (node->type == FLUID_NUM_TYPE)) {
fluid_num_setting_t* setting = (fluid_num_setting_t*) node;
*min = setting->min;
*max = setting->max;
}
fluid_rec_mutex_unlock (settings->mutex);
} | false | false | false | false | false | 0 |
gs_manager_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GSManager *self;
self = GS_MANAGER (object);
switch (prop_id) {
case PROP_LOCK_ENABLED:
g_value_set_boolean (value, self->priv->lock_enabled);
break;
case PROP_LOCK_TIMEOUT:
g_value_set_long (value, self->priv->lock_timeout);
break;
case PROP_LOGOUT_ENABLED:
g_value_set_boolean (value, self->priv->logout_enabled);
break;
case PROP_KEYBOARD_ENABLED:
g_value_set_boolean (value, self->priv->keyboard_enabled);
break;
case PROP_USER_SWITCH_ENABLED:
g_value_set_boolean (value, self->priv->user_switch_enabled);
break;
case PROP_LOGOUT_TIMEOUT:
g_value_set_long (value, self->priv->logout_timeout);
break;
case PROP_LOGOUT_COMMAND:
g_value_set_string (value, self->priv->logout_command);
break;
case PROP_KEYBOARD_COMMAND:
g_value_set_string (value, self->priv->keyboard_command);
break;
case PROP_STATUS_MESSAGE:
g_value_set_string (value, self->priv->status_message);
break;
case PROP_ACTIVE:
g_value_set_boolean (value, self->priv->active);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
} | false | false | false | false | false | 0 |
identify_old(struct fet_device *dev)
{
char idtext[64];
if (xfer(dev, C_IDENTIFY, NULL, 0, 2, 70, 0) < 0)
return -1;
if (dev->fet_reply.datalen < 0x26) {
printc_err("fet: missing info\n");
return -1;
}
memcpy(idtext, dev->fet_reply.data + 4, 32);
idtext[32] = 0;
dev->code_start = LE_WORD(dev->fet_reply.data, 0x24);
dev->base.max_breakpoints = LE_WORD(dev->fet_reply.data, 0x2a);
show_dev_info(idtext, dev);
return 0;
} | true | true | false | false | false | 1 |
bonus(bigint nbonus, AtomVec *ptr, const char *type)
{
int i,m,nchunk,eof;
int mapflag = 0;
if (atom->map_style == 0) {
mapflag = 1;
atom->map_style = 1;
atom->map_init();
atom->map_set();
}
bigint nread = 0;
bigint natoms = nbonus;
while (nread < natoms) {
nchunk = MIN(natoms-nread,CHUNK);
eof = comm->read_lines_from_file(fp,nchunk,MAXLINE,buffer);
if (eof) error->all(FLERR,"Unexpected end of data file");
atom->data_bonus(nchunk,buffer,ptr);
nread += nchunk;
}
if (mapflag) {
atom->map_delete();
atom->map_style = 0;
}
if (me == 0) {
if (screen) fprintf(screen," " BIGINT_FORMAT " %s\n",natoms,type);
if (logfile) fprintf(logfile," " BIGINT_FORMAT " %s\n",natoms,type);
}
} | false | false | false | false | false | 0 |
settingsDialogCanceled()
{
m_playerSettings->discardUnsavedSettings();
m_tempRandomArenaModeArenaList.clear();
if(m_currentThemeIdentifier != m_themeProvider->currentTheme()->identifier())
{
QList<const KgTheme*> themeList = m_themeProvider->themes();
foreach(const KgTheme* theme, themeList)
{
if(theme->identifier() == m_currentThemeIdentifier)
{
m_themeProvider->setCurrentTheme(theme);
break;
}
}
}
} | false | false | false | false | false | 0 |
main(int argc, char *argv[])
{
int delay = 0;
int res = 0;
gchar *socket_file = NULL;
gchar *service = NULL;
GError *error = NULL;
char *error_str;
GOptionContext *context;
GOptionEntry option_entries[] =
{
{"socket", 'f', 0, G_OPTION_ARG_FILENAME, &socket_file, "Socket filename to use.", ""},
{"service", 's', 0, G_OPTION_ARG_STRING, &service, "Service to poke.", ""},
{"delay", 'd', 0, G_OPTION_ARG_INT, &delay, "Keep in pending for n seconds unless a newer poke comes in.", ""},
{NULL}
};
context = g_option_context_new("- Service Poke Client");
g_option_context_add_main_entries(context, option_entries, NULL);
res = g_option_context_parse(context, &argc, &argv, &error);
if(!res)
{
fprintf(stderr, "Failed to parse arguments.\n");
exit(-1);
}
if(!socket_file)
{
fprintf(stderr, "You must specify the socket file with -f\n");
exit(-1);
}
if(!service)
{
fprintf(stderr, "You must specify the service with -s\n");
exit(-1);
}
res = service_poke(socket_file, service, delay, &error_str);
if(res)
{
fprintf(stderr, "%s\n", error_str);
}
return res;
} | false | false | false | false | false | 0 |
exhalbtc_init_coex_dm(struct btc_coexist *btcoexist)
{
struct rtl_priv *rtlpriv = btcoexist->adapter;
struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
if (!halbtc_is_bt_coexist_available(btcoexist))
return;
btcoexist->statistics.cnt_init_coex_dm++;
if (rtlhal->hw_type == HARDWARE_TYPE_RTL8723BE)
ex_btc8723b2ant_init_coex_dm(btcoexist);
btcoexist->initilized = true;
} | false | false | false | false | false | 0 |
anjuta_window_layout_load (AnjutaWindow *win, const gchar *layout_filename,
const gchar *name)
{
g_return_if_fail (ANJUTA_IS_WINDOW (win));
if (!layout_filename ||
!gdl_dock_layout_load_from_file (win->layout_manager, layout_filename))
{
gchar *datadir, *filename;
datadir = anjuta_res_get_data_dir();
filename = g_build_filename (datadir, "layout.xml", NULL);
DEBUG_PRINT ("Layout = %s", filename);
g_free (datadir);
if (!gdl_dock_layout_load_from_file (win->layout_manager, filename))
g_warning ("Loading layout from '%s' failed!!", filename);
g_free (filename);
}
if (!gdl_dock_layout_load_layout (win->layout_manager, name))
g_warning ("Loading layout failed!!");
/* Layout loaded from file are not maximized */
win->maximized = FALSE;
} | false | false | false | false | false | 0 |
minix_new_block(struct inode * inode)
{
struct minix_sb_info *sbi = minix_sb(inode->i_sb);
int bits_per_zone = 8 * inode->i_sb->s_blocksize;
int i;
for (i = 0; i < sbi->s_zmap_blocks; i++) {
struct buffer_head *bh = sbi->s_zmap[i];
int j;
spin_lock(&bitmap_lock);
j = minix_find_first_zero_bit(bh->b_data, bits_per_zone);
if (j < bits_per_zone) {
minix_set_bit(j, bh->b_data);
spin_unlock(&bitmap_lock);
mark_buffer_dirty(bh);
j += i * bits_per_zone + sbi->s_firstdatazone-1;
if (j < sbi->s_firstdatazone || j >= sbi->s_nzones)
break;
return j;
}
spin_unlock(&bitmap_lock);
}
return 0;
} | false | false | false | false | false | 0 |
ioctl(int fd, unsigned long int request, ...)
{
void *arg;
va_list ap;
va_start(ap, request);
arg = va_arg(ap, void *);
va_end(ap);
return v4l2_ioctl(fd, request, arg);
} | false | false | false | false | false | 0 |
radeon_surface_best(struct radeon_surface_manager *surf_man,
struct radeon_surface *surf)
{
unsigned mode, type;
int r;
type = RADEON_SURF_GET(surf->flags, TYPE);
mode = RADEON_SURF_GET(surf->flags, MODE);
r = radeon_surface_sanity(surf_man, surf, type, mode);
if (r) {
return r;
}
return surf_man->surface_best(surf_man, surf);
} | false | false | false | false | false | 0 |
e_cal_component_get_id (ECalComponent *comp)
{
ECalComponentPrivate *priv;
ECalComponentId *id = NULL;
g_return_val_if_fail (comp != NULL, NULL);
g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), NULL);
priv = comp->priv;
g_return_val_if_fail (priv->icalcomp != NULL, NULL);
id = g_new0 (ECalComponentId, 1);
id->uid = g_strdup (icalproperty_get_uid (priv->uid));
id->rid = e_cal_component_get_recurid_as_string (comp);
return id;
} | false | false | false | false | false | 0 |
mlx4_en_replace_mac(struct mlx4_en_priv *priv, int qpn,
unsigned char *new_mac, unsigned char *prev_mac)
{
struct mlx4_en_dev *mdev = priv->mdev;
struct mlx4_dev *dev = mdev->dev;
int err = 0;
u64 new_mac_u64 = mlx4_mac_to_u64(new_mac);
if (dev->caps.steering_mode != MLX4_STEERING_MODE_A0) {
struct hlist_head *bucket;
unsigned int mac_hash;
struct mlx4_mac_entry *entry;
struct hlist_node *tmp;
u64 prev_mac_u64 = mlx4_mac_to_u64(prev_mac);
bucket = &priv->mac_hash[prev_mac[MLX4_EN_MAC_HASH_IDX]];
hlist_for_each_entry_safe(entry, tmp, bucket, hlist) {
if (ether_addr_equal_64bits(entry->mac, prev_mac)) {
mlx4_en_uc_steer_release(priv, entry->mac,
qpn, entry->reg_id);
mlx4_unregister_mac(dev, priv->port,
prev_mac_u64);
hlist_del_rcu(&entry->hlist);
synchronize_rcu();
memcpy(entry->mac, new_mac, ETH_ALEN);
entry->reg_id = 0;
mac_hash = new_mac[MLX4_EN_MAC_HASH_IDX];
hlist_add_head_rcu(&entry->hlist,
&priv->mac_hash[mac_hash]);
mlx4_register_mac(dev, priv->port, new_mac_u64);
err = mlx4_en_uc_steer_add(priv, new_mac,
&qpn,
&entry->reg_id);
if (err)
return err;
if (priv->tunnel_reg_id) {
mlx4_flow_detach(priv->mdev->dev, priv->tunnel_reg_id);
priv->tunnel_reg_id = 0;
}
err = mlx4_en_tunnel_steer_add(priv, new_mac, qpn,
&priv->tunnel_reg_id);
return err;
}
}
return -EINVAL;
}
return __mlx4_replace_mac(dev, priv->port, qpn, new_mac_u64);
} | true | true | false | false | false | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.