idx
int64 | func
string | target
int64 |
|---|---|---|
110,391 |
inline void ThrowTypeErrorOnFailureHelper::ThrowTypeErrorOnFailure(BOOL operationSucceeded)
{
if (IsThrowTypeError(operationSucceeded))
{
ThrowTypeErrorOnFailure();
}
}
| 0 |
434,498 |
int parse_sa_P_opt(char *argv[], int *opt, unsigned int *flags, struct activity *act[])
{
int p;
p = get_activity_position(act, A_CPU, EXIT_IF_NOT_FOUND);
if (argv[++(*opt)]) {
if (parse_values(argv[*opt], act[p]->bitmap->b_array,
act[p]->bitmap->b_size, K_LOWERALL))
return 1;
(*opt)++;
*flags |= S_F_OPTION_P;
return 0;
}
return 1;
}
| 0 |
146,895 |
static const char *urlsection(cmd_parms *cmd, void *mconfig, const char *arg)
{
const char *errmsg;
const char *endp = ap_strrchr_c(arg, '>');
int old_overrides = cmd->override;
char *old_path = cmd->path;
core_dir_config *conf;
ap_regex_t *r = NULL;
const command_rec *thiscmd = cmd->cmd;
ap_conf_vector_t *new_url_conf = ap_create_per_dir_config(cmd->pool);
const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_LOC_FILE);
if (err != NULL) {
return err;
}
if (endp == NULL) {
return unclosed_directive(cmd);
}
arg = apr_pstrndup(cmd->temp_pool, arg, endp - arg);
if (!arg[0]) {
return missing_container_arg(cmd);
}
cmd->path = ap_getword_conf(cmd->pool, &arg);
cmd->override = OR_ALL|ACCESS_CONF;
if (thiscmd->cmd_data) { /* <LocationMatch> */
r = ap_pregcomp(cmd->pool, cmd->path, AP_REG_EXTENDED);
if (!r) {
return "Regex could not be compiled";
}
}
else if (!strcmp(cmd->path, "~")) {
cmd->path = ap_getword_conf(cmd->pool, &arg);
r = ap_pregcomp(cmd->pool, cmd->path, AP_REG_EXTENDED);
if (!r) {
return "Regex could not be compiled";
}
}
/* initialize our config and fetch it */
conf = ap_set_config_vectors(cmd->server, new_url_conf, cmd->path,
&core_module, cmd->pool);
errmsg = ap_walk_config(cmd->directive->first_child, cmd, new_url_conf);
if (errmsg != NULL)
return errmsg;
conf->d = apr_pstrdup(cmd->pool, cmd->path); /* No mangling, please */
conf->d_is_fnmatch = apr_fnmatch_test(conf->d) != 0;
conf->r = r;
if (r) {
conf->refs = apr_array_make(cmd->pool, 8, sizeof(char *));
ap_regname(r, conf->refs, AP_REG_MATCH, 1);
}
ap_add_per_url_conf(cmd->server, new_url_conf);
if (*arg != '\0') {
return apr_pstrcat(cmd->pool, "Multiple ", thiscmd->name,
"> arguments not (yet) supported.", NULL);
}
cmd->path = old_path;
cmd->override = old_overrides;
return NULL;
}
| 0 |
20,418 |
static void dct_unquantize_mpeg1_intra_c ( MpegEncContext * s , int16_t * block , int n , int qscale ) {
int i , level , nCoeffs ;
const uint16_t * quant_matrix ;
nCoeffs = s -> block_last_index [ n ] ;
if ( n < 4 ) block [ 0 ] = block [ 0 ] * s -> y_dc_scale ;
else block [ 0 ] = block [ 0 ] * s -> c_dc_scale ;
quant_matrix = s -> intra_matrix ;
for ( i = 1 ;
i <= nCoeffs ;
i ++ ) {
int j = s -> intra_scantable . permutated [ i ] ;
level = block [ j ] ;
if ( level ) {
if ( level < 0 ) {
level = - level ;
level = ( int ) ( level * qscale * quant_matrix [ j ] ) >> 3 ;
level = ( level - 1 ) | 1 ;
level = - level ;
}
else {
level = ( int ) ( level * qscale * quant_matrix [ j ] ) >> 3 ;
level = ( level - 1 ) | 1 ;
}
block [ j ] = level ;
}
}
}
| 0 |
517,775 |
static int add_keyword_string(String *str, const char *keyword,
bool quoted, const char *keystr)
{
int err= str->append(' ');
err+= str->append(keyword);
str->append(STRING_WITH_LEN(" = "));
if (quoted)
{
err+= str->append('\'');
err+= str->append_for_single_quote(keystr);
err+= str->append('\'');
}
else
err+= str->append(keystr);
return err;
}
| 0 |
415,284 |
real_new_secrets (NMVpnServicePlugin *plugin,
NMConnection *connection,
GError **error)
{
NMVPNCPluginPrivate *priv = NM_VPNC_PLUGIN_GET_PRIVATE (plugin);
NMSettingVpn *s_vpn;
const char *secret;
if (!interactive_available || !priv->interactive) {
g_set_error_literal (error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_FAILED,
_("Could not use new secrets as interactive mode is disabled."));
return FALSE;
}
s_vpn = nm_connection_get_setting_vpn (connection);
if (!s_vpn) {
g_set_error_literal (error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_INVALID_CONNECTION,
_("Could not process the request because the VPN connection settings were invalid."));
return FALSE;
}
if (!priv->pending_auth) {
g_set_error_literal (error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_INVALID_CONNECTION,
_("Could not process the request because no pending authentication is required."));
return FALSE;
}
_LOGD ("VPN received new secrets; sending to '%s' vpnc stdin", priv->pending_auth);
secret = nm_setting_vpn_get_secret (s_vpn, priv->pending_auth);
if (!secret) {
g_set_error (error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_INVALID_CONNECTION,
_("Could not process the request because the requested info “%s” was not provided."),
priv->pending_auth);
return FALSE;
}
/* Ignoring secret flags here; if vpnc requested the item, we must provide it */
write_config_option (priv->infd, "%s", secret);
priv->pending_auth = NULL;
return TRUE;
}
| 0 |
106,071 |
void ff_mov_close_hinting(MOVTrack *track) {
AVFormatContext* rtp_ctx = track->rtp_ctx;
uint8_t *ptr;
av_freep(&track->enc);
sample_queue_free(&track->sample_queue);
if (!rtp_ctx)
return;
if (rtp_ctx->pb) {
av_write_trailer(rtp_ctx);
url_close_dyn_buf(rtp_ctx->pb, &ptr);
av_free(ptr);
}
av_metadata_free(&rtp_ctx->streams[0]->metadata);
av_metadata_free(&rtp_ctx->metadata);
av_free(rtp_ctx->streams[0]);
av_freep(&rtp_ctx);
}
| 1 |
74,796 |
int pam_sm_setcred (pam_handle_t * pamh, int flags,
int argc, const char **argv) {
int ctrl = _pam_parse (argc, argv);
if (ctrl & PAM_TAC_DEBUG)
syslog (LOG_DEBUG, "%s: called (pam_tacplus v%u.%u.%u)"
, __FUNCTION__, PAM_TAC_VMAJ, PAM_TAC_VMIN, PAM_TAC_VPAT);
return PAM_SUCCESS;
} /* pam_sm_setcred */
| 0 |
227,172 |
void RenderWidgetHostImpl::CopyFromBackingStore(
const gfx::Rect& src_subrect,
const gfx::Size& accelerated_dst_size,
const ReadbackRequestCallback& callback,
const SkColorType preferred_color_type) {
if (view_) {
TRACE_EVENT0("browser",
"RenderWidgetHostImpl::CopyFromBackingStore::FromCompositingSurface");
gfx::Rect accelerated_copy_rect = src_subrect.IsEmpty() ?
gfx::Rect(view_->GetViewBounds().size()) : src_subrect;
view_->CopyFromCompositingSurface(accelerated_copy_rect,
accelerated_dst_size, callback,
preferred_color_type);
return;
}
callback.Run(SkBitmap(), content::READBACK_FAILED);
}
| 0 |
14,028 |
void TransportTexture::OnTexturesCreated(std::vector<int> textures) {
bool ret = decoder_->MakeCurrent();
if (!ret) {
LOG(ERROR) << "Failed to switch context";
return;
}
output_textures_->clear();
for (size_t i = 0; i < textures.size(); ++i) {
uint32 gl_texture = 0;
ret = decoder_->GetServiceTextureId(textures[i], &gl_texture);
DCHECK(ret) << "Cannot translate client texture ID to service ID";
output_textures_->push_back(gl_texture);
texture_map_.insert(std::make_pair(gl_texture, textures[i]));
}
create_task_->Run();
create_task_.reset();
output_textures_ = NULL;
}
| 1 |
249,963 |
bool SocketPair(int* fd1, int* fd2) {
int pipe_fds[2];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds) != 0) {
PLOG(ERROR) << "socketpair()";
return false;
}
if (fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK) == -1 ||
fcntl(pipe_fds[1], F_SETFL, O_NONBLOCK) == -1) {
PLOG(ERROR) << "fcntl(O_NONBLOCK)";
HANDLE_EINTR(close(pipe_fds[0]));
HANDLE_EINTR(close(pipe_fds[1]));
return false;
}
*fd1 = pipe_fds[0];
*fd2 = pipe_fds[1];
return true;
}
| 0 |
515,122 |
char *findFill(node_t * n)
{
return (findFillDflt(n, DEFAULT_FILL));
}
| 0 |
393,969 |
static int sched_copy_attr(struct sched_attr __user *uattr,
struct sched_attr *attr)
{
u32 size;
int ret;
if (!access_ok(VERIFY_WRITE, uattr, SCHED_ATTR_SIZE_VER0))
return -EFAULT;
/*
* zero the full structure, so that a short copy will be nice.
*/
memset(attr, 0, sizeof(*attr));
ret = get_user(size, &uattr->size);
if (ret)
return ret;
if (size > PAGE_SIZE) /* silly large */
goto err_size;
if (!size) /* abi compat */
size = SCHED_ATTR_SIZE_VER0;
if (size < SCHED_ATTR_SIZE_VER0)
goto err_size;
/*
* If we're handed a bigger struct than we know of,
* ensure all the unknown bits are 0 - i.e. new
* user-space does not rely on any kernel feature
* extensions we dont know about yet.
*/
if (size > sizeof(*attr)) {
unsigned char __user *addr;
unsigned char __user *end;
unsigned char val;
addr = (void __user *)uattr + sizeof(*attr);
end = (void __user *)uattr + size;
for (; addr < end; addr++) {
ret = get_user(val, addr);
if (ret)
return ret;
if (val)
goto err_size;
}
size = sizeof(*attr);
}
ret = copy_from_user(attr, uattr, size);
if (ret)
return -EFAULT;
/*
* XXX: do we want to be lenient like existing syscalls; or do we want
* to be strict and return an error on out-of-bounds values?
*/
attr->sched_nice = clamp(attr->sched_nice, MIN_NICE, MAX_NICE);
return 0;
err_size:
put_user(sizeof(*attr), &uattr->size);
return -E2BIG;
}
| 0 |
152,753 |
inline size_t PrecedenceClimbing::parse_expression(const char *s, size_t n,
SemanticValues &sv,
Context &c, any &dt,
size_t min_prec) const {
auto len = atom_->parse(s, n, sv, c, dt);
if (fail(len)) { return len; }
std::string tok;
auto &rule = get_reference_for_binop(c);
auto action = rule.action;
rule.action = [&](SemanticValues &sv2, any &dt2) -> any {
tok = sv2.token();
if (action) {
return action(sv2, dt2);
} else if (!sv2.empty()) {
return sv2[0];
}
return any();
};
auto action_se = make_scope_exit([&]() { rule.action = action; });
auto save_error_pos = c.error_pos;
auto i = len;
while (i < n) {
std::vector<any> save_values(sv.begin(), sv.end());
auto save_tokens = sv.tokens;
auto chv = c.push();
auto chl = binop_->parse(s + i, n - i, chv, c, dt);
c.pop();
if (fail(chl)) {
c.error_pos = save_error_pos;
break;
}
auto it = info_.find(tok);
if (it == info_.end()) { break; }
auto level = std::get<0>(it->second);
auto assoc = std::get<1>(it->second);
if (level < min_prec) { break; }
sv.emplace_back(std::move(chv[0]));
i += chl;
auto next_min_prec = level;
if (assoc == 'L') { next_min_prec = level + 1; }
chv = c.push();
chl = parse_expression(s + i, n - i, chv, c, dt, next_min_prec);
c.pop();
if (fail(chl)) {
sv.assign(save_values.begin(), save_values.end());
sv.tokens = save_tokens;
c.error_pos = save_error_pos;
break;
}
sv.emplace_back(std::move(chv[0]));
i += chl;
any val;
if (rule_.action) {
sv.s_ = s;
sv.n_ = i;
val = rule_.action(sv, dt);
} else if (!sv.empty()) {
val = sv[0];
}
sv.clear();
sv.emplace_back(std::move(val));
}
return i;
}
| 0 |
118,316 |
static unsigned char *EncodeRLE(unsigned char *destination,
unsigned char *source,size_t literal,size_t repeat)
{
if (literal > 0)
*destination++=(unsigned char) (literal-1);
(void) CopyMagickMemory(destination,source,literal);
destination+=literal;
if (repeat > 0)
{
*destination++=(unsigned char) (0x80 | (repeat-1));
*destination++=source[literal];
}
return(destination);
}
| 0 |
248,603 |
void ContentSecurityPolicy::AddAndReportPolicyFromHeaderValue(
const String& header,
ContentSecurityPolicyHeaderType type,
ContentSecurityPolicyHeaderSource source) {
wtf_size_t previous_policy_count = policies_.size();
AddPolicyFromHeaderValue(header, type, source);
WebVector<WebContentSecurityPolicy> policies(policies_.size() -
previous_policy_count);
for (wtf_size_t i = previous_policy_count; i < policies_.size(); ++i) {
policies[i - previous_policy_count] =
policies_[i]->ExposeForNavigationalChecks();
}
if (GetDocument() && GetDocument()->GetFrame()) {
GetDocument()->GetFrame()->Client()->DidAddContentSecurityPolicies(
policies);
}
}
| 0 |
301,664 |
static void * load_buffer(RBinFile *bf, RBuffer *buf, ut64 loadaddr, Sdb *sdb) {
struct Elf_(r_bin_elf_obj_t) *res;
if (!buf) {
return NULL;
}
res = Elf_(r_bin_elf_new_buf) (buf, bf->rbin->verbose);
if (res) {
sdb_ns_set (sdb, "info", res->kv);
}
return res;
}
| 0 |
58,783 |
static u32 tg3_read_indirect_reg32(struct tg3 *tp, u32 off)
{
unsigned long flags;
u32 val;
spin_lock_irqsave(&tp->indirect_lock, flags);
pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off);
pci_read_config_dword(tp->pdev, TG3PCI_REG_DATA, &val);
spin_unlock_irqrestore(&tp->indirect_lock, flags);
return val;
}
| 0 |
427,719 |
static void rtreeCheckNode(
RtreeCheck *pCheck,
int iDepth, /* Depth of iNode (0==leaf) */
u8 *aParent, /* Buffer containing parent coords */
i64 iNode /* Node to check */
){
u8 *aNode = 0;
int nNode = 0;
assert( iNode==1 || aParent!=0 );
assert( pCheck->nDim>0 );
aNode = rtreeCheckGetNode(pCheck, iNode, &nNode);
if( aNode ){
if( nNode<4 ){
rtreeCheckAppendMsg(pCheck,
"Node %lld is too small (%d bytes)", iNode, nNode
);
}else{
int nCell; /* Number of cells on page */
int i; /* Used to iterate through cells */
if( aParent==0 ){
iDepth = readInt16(aNode);
if( iDepth>RTREE_MAX_DEPTH ){
rtreeCheckAppendMsg(pCheck, "Rtree depth out of range (%d)", iDepth);
sqlite3_free(aNode);
return;
}
}
nCell = readInt16(&aNode[2]);
if( (4 + nCell*(8 + pCheck->nDim*2*4))>nNode ){
rtreeCheckAppendMsg(pCheck,
"Node %lld is too small for cell count of %d (%d bytes)",
iNode, nCell, nNode
);
}else{
for(i=0; i<nCell; i++){
u8 *pCell = &aNode[4 + i*(8 + pCheck->nDim*2*4)];
i64 iVal = readInt64(pCell);
rtreeCheckCellCoord(pCheck, iNode, i, &pCell[8], aParent);
if( iDepth>0 ){
rtreeCheckMapping(pCheck, 0, iVal, iNode);
rtreeCheckNode(pCheck, iDepth-1, &pCell[8], iVal);
pCheck->nNonLeaf++;
}else{
rtreeCheckMapping(pCheck, 1, iVal, iNode);
pCheck->nLeaf++;
}
}
}
}
sqlite3_free(aNode);
}
}
| 0 |
266,231 |
static BOOL wf_cliprdr_get_file_contents(WCHAR* file_name, BYTE* buffer, LONG positionLow,
LONG positionHigh, DWORD nRequested, DWORD* puSize)
{
BOOL res = FALSE;
HANDLE hFile;
DWORD nGet, rc;
if (!file_name || !buffer || !puSize)
{
WLog_ERR(TAG, "get file contents Invalid Arguments.");
return FALSE;
}
hFile = CreateFileW(file_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (hFile == INVALID_HANDLE_VALUE)
return FALSE;
rc = SetFilePointer(hFile, positionLow, &positionHigh, FILE_BEGIN);
if (rc == INVALID_SET_FILE_POINTER)
goto error;
if (!ReadFile(hFile, buffer, nRequested, &nGet, NULL))
{
DEBUG_CLIPRDR("ReadFile failed with 0x%08lX.", GetLastError());
goto error;
}
res = TRUE;
error:
if (!CloseHandle(hFile))
res = FALSE;
if (res)
*puSize = nGet;
return res;
}
| 0 |
91,815 |
install_keyword_root(const char *string, void (*handler) (vector_t *), bool active)
{
/* If the root keyword is inactive, the handler will still be called,
* but with a NULL strvec */
keyword_alloc(keywords, string, handler, active);
}
| 0 |
24,368 |
static void cirrus_linear_bitblt_write ( void * opaque , hwaddr addr , uint64_t val , unsigned size ) {
CirrusVGAState * s = opaque ;
if ( s -> cirrus_srcptr != s -> cirrus_srcptr_end ) {
* s -> cirrus_srcptr ++ = ( uint8_t ) val ;
if ( s -> cirrus_srcptr >= s -> cirrus_srcptr_end ) {
cirrus_bitblt_cputovideo_next ( s ) ;
}
}
}
| 0 |
164,908 |
void WriteReplyAndDeleteThis(const IPC::ChannelHandle& handle) {
ViewHostMsg_OpenChannelToPlugin::WriteReplyParams(reply_msg(),
handle, info_);
filter()->OnCompletedOpenChannelToNpapiPlugin(this);
SendReplyAndDeleteThis();
}
| 0 |
275,429 |
BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpCtx (gdIOCtx * infile)
{
int width, height;
uint8_t *filedata = NULL;
uint8_t *argb = NULL;
unsigned char *read, *temp;
size_t size = 0, n;
gdImagePtr im;
int x, y;
uint8_t *p;
do {
temp = gdRealloc(filedata, size+GD_WEBP_ALLOC_STEP);
if (temp) {
filedata = temp;
read = temp + size;
} else {
if (filedata) {
gdFree(filedata);
}
gd_error("WebP decode: realloc failed");
return NULL;
}
n = gdGetBuf(read, GD_WEBP_ALLOC_STEP, infile);
if (n>0 && n!=EOF) {
size += n;
}
} while (n>0 && n!=EOF);
if (WebPGetInfo(filedata,size, &width, &height) == 0) {
gd_error("gd-webp cannot get webp info");
gdFree(temp);
return NULL;
}
im = gdImageCreateTrueColor(width, height);
if (!im) {
gdFree(temp);
return NULL;
}
argb = WebPDecodeARGB(filedata, size, &width, &height);
if (!argb) {
gd_error("gd-webp cannot allocate temporary buffer");
gdFree(temp);
gdImageDestroy(im);
return NULL;
}
for (y = 0, p = argb; y < height; y++) {
for (x = 0; x < width; x++) {
register uint8_t a = gdAlphaMax - (*(p++) >> 1);
register uint8_t r = *(p++);
register uint8_t g = *(p++);
register uint8_t b = *(p++);
im->tpixels[y][x] = gdTrueColorAlpha(r, g, b, a);
}
}
/* do not use gdFree here, in case gdFree/alloc is mapped to something else than libc */
free(argb);
gdFree(temp);
im->saveAlphaFlag = 1;
return im;
}
| 0 |
283,225 |
static int mptsas_scsi_device_find(MPTSASState *s, int bus, int target,
uint8_t *lun, SCSIDevice **sdev)
{
if (bus != 0) {
return MPI_IOCSTATUS_SCSI_INVALID_BUS;
}
if (target >= s->max_devices) {
return MPI_IOCSTATUS_SCSI_INVALID_TARGETID;
}
*sdev = scsi_device_find(&s->bus, bus, target, lun[1]);
if (!*sdev) {
return MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE;
}
return 0;
}
| 0 |
214,871 |
bool ImeObserver::IsInterestedInKeyEvent() const {
return ShouldForwardKeyEvent();
}
| 0 |
195,022 |
bool AllSamplesPassedQuery::Process() {
GLuint available = 0;
glGetQueryObjectuivARB(
service_id_, GL_QUERY_RESULT_AVAILABLE_EXT, &available);
if (!available) {
return true;
}
GLuint result = 0;
glGetQueryObjectuivARB(
service_id_, GL_QUERY_RESULT_EXT, &result);
return MarkAsCompleted(result != 0);
}
| 0 |
293,874 |
otError Commissioner::Start(otCommissionerStateCallback aStateCallback,
otCommissionerJoinerCallback aJoinerCallback,
void * aCallbackContext)
{
otError error = OT_ERROR_NONE;
VerifyOrExit(Get<Mle::MleRouter>().IsAttached(), error = OT_ERROR_INVALID_STATE);
VerifyOrExit(mState == OT_COMMISSIONER_STATE_DISABLED, error = OT_ERROR_INVALID_STATE);
SuccessOrExit(error = Get<Coap::CoapSecure>().Start(SendRelayTransmit, this));
Get<Coap::CoapSecure>().SetConnectedCallback(&Commissioner::HandleCoapsConnected, this);
mStateCallback = aStateCallback;
mJoinerCallback = aJoinerCallback;
mCallbackContext = aCallbackContext;
mTransmitAttempts = 0;
SuccessOrExit(error = SendPetition());
SetState(OT_COMMISSIONER_STATE_PETITION);
exit:
return error;
}
| 0 |
374,202 |
has_foreign_data_wrapper_privilege_name(PG_FUNCTION_ARGS)
{
text *fdwname = PG_GETARG_TEXT_P(0);
text *priv_type_text = PG_GETARG_TEXT_P(1);
Oid roleid;
Oid fdwid;
AclMode mode;
AclResult aclresult;
roleid = GetUserId();
fdwid = convert_foreign_data_wrapper_name(fdwname);
mode = convert_foreign_data_wrapper_priv_string(priv_type_text);
aclresult = pg_foreign_data_wrapper_aclcheck(fdwid, roleid, mode);
PG_RETURN_BOOL(aclresult == ACLCHECK_OK);
}
| 0 |
90,921 |
UnicodeString::removeRef() {
return umtx_atomic_dec((u_atomic_int32_t *)fUnion.fFields.fArray - 1);
}
| 0 |
203,563 |
void PrintWebViewHelper::UpdateFrameAndViewFromCssPageLayout(
WebKit::WebFrame* frame,
const WebKit::WebNode& node,
PrepareFrameAndViewForPrint* prepare,
const PrintMsg_Print_Params& params,
bool ignore_css_margins) {
if (PrintingNodeOrPdfFrame(frame, node))
return;
bool fit_to_page = ignore_css_margins &&
params.print_scaling_option ==
WebKit::WebPrintScalingOptionFitToPrintableArea;
PrintMsg_Print_Params print_params = CalculatePrintParamsForCss(
frame, 0, params, ignore_css_margins, fit_to_page, NULL);
prepare->UpdatePrintParams(print_params);
}
| 0 |
441,813 |
int force_sig_fault_to_task(int sig, int code, void __user *addr
___ARCH_SI_TRAPNO(int trapno)
___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
, struct task_struct *t)
{
struct kernel_siginfo info;
clear_siginfo(&info);
info.si_signo = sig;
info.si_errno = 0;
info.si_code = code;
info.si_addr = addr;
#ifdef __ARCH_SI_TRAPNO
info.si_trapno = trapno;
#endif
#ifdef __ia64__
info.si_imm = imm;
info.si_flags = flags;
info.si_isr = isr;
#endif
return force_sig_info_to_task(&info, t);
}
| 0 |
222,138 |
static ActivationState ParseActivationState(
const std::string& activation_state) {
if (activation_state == kActivationStateActivated)
return ACTIVATION_STATE_ACTIVATED;
if (activation_state == kActivationStateActivating)
return ACTIVATION_STATE_ACTIVATING;
if (activation_state == kActivationStateNotActivated)
return ACTIVATION_STATE_NOT_ACTIVATED;
if (activation_state == kActivationStateUnknown)
return ACTIVATION_STATE_UNKNOWN;
if (activation_state == kActivationStatePartiallyActivated)
return ACTIVATION_STATE_PARTIALLY_ACTIVATED;
return ACTIVATION_STATE_UNKNOWN;
}
| 0 |
277,792 |
static unsigned uivector_push_back(uivector* p, unsigned c)
{
if(!uivector_resize(p, p->size + 1)) return 0;
p->data[p->size - 1] = c;
return 1;
}
| 0 |
484,760 |
static size_t compute_user_elem_size(size_t size, unsigned int count)
{
return sizeof(struct user_element) + size * count;
}
| 0 |
63,435 |
static int srpt_parse_i_port_id(u8 i_port_id[16], const char *name)
{
const char *p;
unsigned len, count, leading_zero_bytes;
int ret, rc;
p = name;
if (strncasecmp(p, "0x", 2) == 0)
p += 2;
ret = -EINVAL;
len = strlen(p);
if (len % 2)
goto out;
count = min(len / 2, 16U);
leading_zero_bytes = 16 - count;
memset(i_port_id, 0, leading_zero_bytes);
rc = hex2bin(i_port_id + leading_zero_bytes, p, count);
if (rc < 0)
pr_debug("hex2bin failed for srpt_parse_i_port_id: %d\n", rc);
ret = 0;
out:
return ret;
}
| 0 |
105,298 |
__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
{
_PyErr_StackItem *exc_info = tstate->exc_info;
while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
exc_info->previous_item != NULL)
{
exc_info = exc_info->previous_item;
}
return exc_info;
}
| 0 |
281,780 |
JSValue jsTestObjUnsignedLongLongAttr(ExecState* exec, JSValue slotBase, const Identifier&)
{
JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
UNUSED_PARAM(exec);
TestObj* impl = static_cast<TestObj*>(castedThis->impl());
JSValue result = jsNumber(impl->unsignedLongLongAttr());
return result;
}
| 0 |
59,076 |
static ssize_t clear_refs_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
struct task_struct *task;
char buffer[PROC_NUMBUF];
struct mm_struct *mm;
struct vm_area_struct *vma;
long type;
memset(buffer, 0, sizeof(buffer));
if (count > sizeof(buffer) - 1)
count = sizeof(buffer) - 1;
if (copy_from_user(buffer, buf, count))
return -EFAULT;
if (strict_strtol(strstrip(buffer), 10, &type))
return -EINVAL;
if (type < CLEAR_REFS_ALL || type > CLEAR_REFS_MAPPED)
return -EINVAL;
task = get_proc_task(file->f_path.dentry->d_inode);
if (!task)
return -ESRCH;
mm = get_task_mm(task);
if (mm) {
struct mm_walk clear_refs_walk = {
.pmd_entry = clear_refs_pte_range,
.mm = mm,
};
down_read(&mm->mmap_sem);
for (vma = mm->mmap; vma; vma = vma->vm_next) {
clear_refs_walk.private = vma;
if (is_vm_hugetlb_page(vma))
continue;
/*
* Writing 1 to /proc/pid/clear_refs affects all pages.
*
* Writing 2 to /proc/pid/clear_refs only affects
* Anonymous pages.
*
* Writing 3 to /proc/pid/clear_refs only affects file
* mapped pages.
*/
if (type == CLEAR_REFS_ANON && vma->vm_file)
continue;
if (type == CLEAR_REFS_MAPPED && !vma->vm_file)
continue;
walk_page_range(vma->vm_start, vma->vm_end,
&clear_refs_walk);
}
flush_tlb_mm(mm);
up_read(&mm->mmap_sem);
mmput(mm);
}
put_task_struct(task);
return count;
}
| 0 |
176,159 |
void WebPageProxy::backForwardItemAtIndex(int32_t index, uint64_t& itemID)
{
WebBackForwardListItem* item = m_backForwardList->itemAtIndex(index);
itemID = item ? item->itemID() : 0;
}
| 0 |
80,230 |
int ipc_parse_version (int *cmd)
{
if (*cmd & IPC_64) {
*cmd ^= IPC_64;
return IPC_64;
} else {
return IPC_OLD;
}
}
| 0 |
445,305 |
void resumeListening() override { udp_listener_->enable(); }
| 0 |
161,344 |
static void check_sync_rss_stat(struct task_struct *task)
{
}
| 0 |
376,759 |
void HGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
ASSERT(!HasStackOverflow());
ASSERT(current_block() != NULL);
ASSERT(current_block()->HasPredecessor());
if (IsClassOfTest(expr)) {
CallRuntime* call = expr->left()->AsCallRuntime();
ASSERT(call->arguments()->length() == 1);
CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
HValue* value = Pop();
Literal* literal = expr->right()->AsLiteral();
Handle<String> rhs = Handle<String>::cast(literal->handle());
HClassOfTestAndBranch* instr =
new(zone()) HClassOfTestAndBranch(value, rhs);
instr->set_position(expr->position());
return ast_context()->ReturnControl(instr, expr->id());
}
TypeInfo type_info = oracle()->CompareType(expr);
// Check if this expression was ever executed according to type feedback.
// Note that for the special typeof/null/undefined cases we get unknown here.
if (type_info.IsUninitialized()) {
AddInstruction(new(zone()) HSoftDeoptimize);
current_block()->MarkAsDeoptimizing();
type_info = TypeInfo::Unknown();
}
CHECK_ALIVE(VisitForValue(expr->left()));
CHECK_ALIVE(VisitForValue(expr->right()));
HValue* context = environment()->LookupContext();
HValue* right = Pop();
HValue* left = Pop();
Token::Value op = expr->op();
HTypeof* typeof_expr = NULL;
Handle<String> check;
if (IsLiteralCompareTypeof(left, op, right, &typeof_expr, &check)) {
return HandleLiteralCompareTypeof(expr, typeof_expr, check);
}
HValue* sub_expr = NULL;
Factory* f = graph()->isolate()->factory();
if (IsLiteralCompareNil(left, op, right, f->undefined_value(), &sub_expr)) {
return HandleLiteralCompareNil(expr, sub_expr, kUndefinedValue);
}
if (IsLiteralCompareNil(left, op, right, f->null_value(), &sub_expr)) {
return HandleLiteralCompareNil(expr, sub_expr, kNullValue);
}
if (IsLiteralCompareBool(left, op, right)) {
HCompareObjectEqAndBranch* result =
new(zone()) HCompareObjectEqAndBranch(left, right);
result->set_position(expr->position());
return ast_context()->ReturnControl(result, expr->id());
}
if (op == Token::INSTANCEOF) {
// Check to see if the rhs of the instanceof is a global function not
// residing in new space. If it is we assume that the function will stay the
// same.
Handle<JSFunction> target = Handle<JSFunction>::null();
VariableProxy* proxy = expr->right()->AsVariableProxy();
bool global_function = (proxy != NULL) && proxy->var()->IsUnallocated();
if (global_function &&
info()->has_global_object() &&
!info()->global_object()->IsAccessCheckNeeded()) {
Handle<String> name = proxy->name();
Handle<GlobalObject> global(info()->global_object());
LookupResult lookup(isolate());
global->Lookup(*name, &lookup);
if (lookup.IsNormal() && lookup.GetValue()->IsJSFunction()) {
Handle<JSFunction> candidate(JSFunction::cast(lookup.GetValue()));
// If the function is in new space we assume it's more likely to
// change and thus prefer the general IC code.
if (!isolate()->heap()->InNewSpace(*candidate)) {
target = candidate;
}
}
}
// If the target is not null we have found a known global function that is
// assumed to stay the same for this instanceof.
if (target.is_null()) {
HInstanceOf* result = new(zone()) HInstanceOf(context, left, right);
result->set_position(expr->position());
return ast_context()->ReturnInstruction(result, expr->id());
} else {
AddInstruction(new(zone()) HCheckFunction(right, target));
HInstanceOfKnownGlobal* result =
new(zone()) HInstanceOfKnownGlobal(context, left, target);
result->set_position(expr->position());
return ast_context()->ReturnInstruction(result, expr->id());
}
} else if (op == Token::IN) {
HIn* result = new(zone()) HIn(context, left, right);
result->set_position(expr->position());
return ast_context()->ReturnInstruction(result, expr->id());
} else if (type_info.IsNonPrimitive()) {
switch (op) {
case Token::EQ:
case Token::EQ_STRICT: {
// Can we get away with map check and not instance type check?
Handle<Map> map = oracle()->GetCompareMap(expr);
if (!map.is_null()) {
AddInstruction(new(zone()) HCheckNonSmi(left));
AddInstruction(HCheckMaps::NewWithTransitions(left, map, zone()));
AddInstruction(new(zone()) HCheckNonSmi(right));
AddInstruction(HCheckMaps::NewWithTransitions(right, map, zone()));
HCompareObjectEqAndBranch* result =
new(zone()) HCompareObjectEqAndBranch(left, right);
result->set_position(expr->position());
return ast_context()->ReturnControl(result, expr->id());
} else {
AddInstruction(new(zone()) HCheckNonSmi(left));
AddInstruction(HCheckInstanceType::NewIsSpecObject(left, zone()));
AddInstruction(new(zone()) HCheckNonSmi(right));
AddInstruction(HCheckInstanceType::NewIsSpecObject(right, zone()));
HCompareObjectEqAndBranch* result =
new(zone()) HCompareObjectEqAndBranch(left, right);
result->set_position(expr->position());
return ast_context()->ReturnControl(result, expr->id());
}
}
default:
return Bailout("Unsupported non-primitive compare");
}
} else if (type_info.IsString() && oracle()->IsSymbolCompare(expr) &&
(op == Token::EQ || op == Token::EQ_STRICT)) {
AddInstruction(new(zone()) HCheckNonSmi(left));
AddInstruction(HCheckInstanceType::NewIsSymbol(left, zone()));
AddInstruction(new(zone()) HCheckNonSmi(right));
AddInstruction(HCheckInstanceType::NewIsSymbol(right, zone()));
HCompareObjectEqAndBranch* result =
new(zone()) HCompareObjectEqAndBranch(left, right);
result->set_position(expr->position());
return ast_context()->ReturnControl(result, expr->id());
} else {
Representation r = ToRepresentation(type_info);
if (r.IsTagged()) {
HCompareGeneric* result =
new(zone()) HCompareGeneric(context, left, right, op);
result->set_position(expr->position());
return ast_context()->ReturnInstruction(result, expr->id());
} else {
HCompareIDAndBranch* result =
new(zone()) HCompareIDAndBranch(left, right, op);
result->set_position(expr->position());
result->SetInputRepresentation(r);
return ast_context()->ReturnControl(result, expr->id());
}
}
}
| 0 |
281,046 |
SAPI_API void sapi_activate(TSRMLS_D)
{
zend_llist_init(&SG(sapi_headers).headers, sizeof(sapi_header_struct), (void (*)(void *)) sapi_free_header, 0);
SG(sapi_headers).send_default_content_type = 1;
/*
SG(sapi_headers).http_response_code = 200;
*/
SG(sapi_headers).http_status_line = NULL;
SG(sapi_headers).mimetype = NULL;
SG(headers_sent) = 0;
SG(callback_run) = 0;
SG(callback_func) = NULL;
SG(read_post_bytes) = 0;
SG(request_info).post_data = NULL;
SG(request_info).raw_post_data = NULL;
SG(request_info).current_user = NULL;
SG(request_info).current_user_length = 0;
SG(request_info).no_headers = 0;
SG(request_info).post_entry = NULL;
SG(request_info).proto_num = 1000; /* Default to HTTP 1.0 */
SG(global_request_time) = 0;
/* It's possible to override this general case in the activate() callback, if necessary. */
if (SG(request_info).request_method && !strcmp(SG(request_info).request_method, "HEAD")) {
SG(request_info).headers_only = 1;
} else {
SG(request_info).headers_only = 0;
}
SG(rfc1867_uploaded_files) = NULL;
/* Handle request method */
if (SG(server_context)) {
if (PG(enable_post_data_reading) && SG(request_info).request_method) {
if (SG(request_info).content_type && !strcmp(SG(request_info).request_method, "POST")) {
/* HTTP POST may contain form data to be processed into variables
* depending on given content type */
sapi_read_post_data(TSRMLS_C);
} else {
/* Any other method with content payload will fill $HTTP_RAW_POST_DATA
* if it is enabled by always_populate_raw_post_data.
* It's up to the webserver to decide whether to allow a method or not. */
SG(request_info).content_type_dup = NULL;
if (sapi_module.default_post_reader) {
sapi_module.default_post_reader(TSRMLS_C);
}
}
} else {
SG(request_info).content_type_dup = NULL;
}
/* Cookies */
SG(request_info).cookie_data = sapi_module.read_cookies(TSRMLS_C);
if (sapi_module.activate) {
sapi_module.activate(TSRMLS_C);
}
}
if (sapi_module.input_filter_init) {
sapi_module.input_filter_init(TSRMLS_C);
}
}
| 0 |
510,662 |
table_map Item_ref::used_tables() const
{
return get_depended_from() ? OUTER_REF_TABLE_BIT : (*ref)->used_tables();
}
| 0 |
10,214 |
image_transform_mod_end(PNG_CONST image_transform *this, image_pixel *that,
png_const_structp pp, PNG_CONST transform_display *display)
{
PNG_CONST unsigned int scale = (1U<<that->sample_depth)-1;
UNUSED(this)
UNUSED(pp)
UNUSED(display)
/* At the end recalculate the digitized red green and blue values according
* to the current sample_depth of the pixel.
*
* The sample value is simply scaled to the maximum, checking for over
* and underflow (which can both happen for some image transforms,
* including simple size scaling, though libpng doesn't do that at present.
*/
that->red = sample_scale(that->redf, scale);
/* The error value is increased, at the end, according to the lowest sBIT
* value seen. Common sense tells us that the intermediate integer
* representations are no more accurate than +/- 0.5 in the integral values,
* the sBIT allows the implementation to be worse than this. In addition the
* PNG specification actually permits any error within the range (-1..+1),
* but that is ignored here. Instead the final digitized value is compared,
* below to the digitized value of the error limits - this has the net effect
* of allowing (almost) +/-1 in the output value. It's difficult to see how
* any algorithm that digitizes intermediate results can be more accurate.
*/
that->rede += 1./(2*((1U<<that->red_sBIT)-1));
if (that->colour_type & PNG_COLOR_MASK_COLOR)
{
that->green = sample_scale(that->greenf, scale);
that->blue = sample_scale(that->bluef, scale);
that->greene += 1./(2*((1U<<that->green_sBIT)-1));
that->bluee += 1./(2*((1U<<that->blue_sBIT)-1));
}
else
{
that->blue = that->green = that->red;
that->bluef = that->greenf = that->redf;
that->bluee = that->greene = that->rede;
}
if ((that->colour_type & PNG_COLOR_MASK_ALPHA) ||
that->colour_type == PNG_COLOR_TYPE_PALETTE)
{
that->alpha = sample_scale(that->alphaf, scale);
that->alphae += 1./(2*((1U<<that->alpha_sBIT)-1));
}
else
{
that->alpha = scale; /* opaque */
that->alpha = 1; /* Override this. */
that->alphae = 0; /* It's exact ;-) */
}
}
| 1 |
112,010 |
static void cit_send_x_00_05_02_08_01(struct gspca_dev *gspca_dev, u16 x)
{
cit_write_reg(gspca_dev, x, 0x0127);
cit_write_reg(gspca_dev, 0x0000, 0x0124);
cit_write_reg(gspca_dev, 0x0005, 0x0124);
cit_write_reg(gspca_dev, 0x0002, 0x0124);
cit_write_reg(gspca_dev, 0x0008, 0x0124);
cit_write_reg(gspca_dev, 0x0001, 0x0124);
}
| 0 |
15,248 |
static int nextch ( IO * wrapper ) {
int ch ;
_IO * io = wrapper -> top ;
static const char * foguvec [ ] = {
"moveto " , "rlineto " , "rrcurveto " , " " , " " , "Cache " , "10 div setlinewidth " , "ShowInt " , " " , " " , " " , " " , "FillStroke " , " " , " " , "SetWid " , "100 mul add " , "togNS_ " , " " , "closepath " , " " , "SG " }
;
while ( io != NULL ) {
if ( io -> backedup != EOF ) {
ch = io -> backedup ;
io -> backedup = EOF ;
return ( ch ) ;
}
else if ( io -> ps != NULL ) {
if ( ( ch = getc ( io -> ps ) ) != EOF ) return ( ch ) ;
}
else if ( io -> fog != NULL ) {
if ( io -> macro != NULL && * io -> macro != '\0' ) return ( * ( io -> macro ++ ) ) ;
ch = getfoghex ( io ) ;
if ( ch >= 233 ) {
io -> macro = foguvec [ ch - 233 ] ;
return ( * ( io -> macro ++ ) ) ;
}
else if ( ch != EOF && ch < 200 ) {
sprintf ( io -> fogbuf , "%d " , ch - 100 ) ;
io -> macro = io -> fogbuf ;
return ( * ( io -> macro ++ ) ) ;
}
else if ( ch != EOF ) {
sprintf ( io -> fogbuf , "%d %s " , ch - 233 + 17 , io -> fogns ? "2 exch exp 3 1 roll 100 mul add mul" : "100 mul add" ) ;
io -> macro = io -> fogbuf ;
return ( * ( io -> macro ++ ) ) ;
}
}
else {
if ( ( ch = * ( io -> macro ++ ) ) != '\0' ) return ( ch ) ;
if ( -- io -> cnt > 0 ) {
io -> macro = io -> start ;
return ( nextch ( wrapper ) ) ;
}
}
wrapper -> top = io -> prev ;
if ( io -> isstopped ) wrapper -> endedstopped = true ;
if ( io -> start != NULL ) free ( io -> start ) ;
io -> start = NULL ;
free ( io ) ;
io = wrapper -> top ;
}
return ( EOF ) ;
}
| 0 |
504,264 |
unsigned long tipc_link_tolerance(struct tipc_link *l)
{
return l->tolerance;
}
| 0 |
337,651 |
static void isapc_machine_options(MachineClass *m)
{
pc_common_machine_options(m);
m->desc = "ISA-only PC";
m->max_cpus = 1;
}
| 0 |
416,616 |
int gx_device_unsubclass(gx_device *dev)
{
generic_subclass_data *psubclass_data;
gx_device *parent, *child;
gs_memory_struct_type_t *a_std = 0, *b_std = 0;
int dynamic, ref_count;
/* This should not happen... */
if (!dev)
return 0;
ref_count = dev->rc.ref_count;
child = dev->child;
psubclass_data = (generic_subclass_data *)dev->subclass_data;
parent = dev->parent;
dynamic = dev->stype_is_dynamic;
/* We need to account for the fact that we are removing ourselves from
* the device chain after a clist device has been pushed, due to a
* compositor action. Since we patched the clist 'create_compositor'
* method (and target device) when it was pushed.
* A point to note; we *don't* want to change the forwarding device's
* 'target', because when we copy the child up to replace 'this' device
* we do still want the forwarding device to point here. NB its the *child*
* device that goes away.
*/
if (psubclass_data != NULL && psubclass_data->forwarding_dev != NULL && psubclass_data->saved_compositor_method)
psubclass_data->forwarding_dev->procs.create_compositor = psubclass_data->saved_compositor_method;
/* If ths device's stype is dynamically allocated, keep a copy of it
* in case we might need it.
*/
if (dynamic) {
a_std = (gs_memory_struct_type_t *)dev->stype;
if (child)
*a_std = *child->stype;
}
/* If ths device has any private storage, free it now */
if (psubclass_data)
gs_free_object(dev->memory->non_gc_memory, psubclass_data, "subclass memory for first-last page");
/* Copy the child device into ths device's memory */
if (child) {
b_std = (gs_memory_struct_type_t *)dev->stype;
rc_decrement(dev->icc_struct, "unsubclass device");
rc_increment(child->icc_struct);
memcpy(dev, child, child->stype->ssize);
/* Patch back the 'stype' in the memory manager */
gs_set_object_type(child->memory, dev, b_std);
dev->stype = b_std;
/* The reference count of the subclassing device may have been changed
* (eg graphics states pointing to it) after we subclassed the device. We
* need to ensure that we do not overwrite this when we copy back the subclassed
* device.
*/
dev->rc.ref_count = ref_count;
/* If we have a chain of devices, make sure the chain beond the device we're unsubclassing
* doesn't get broken, we needd to detach the lower chain and reattach it at the new
* highest level
*/
if (child->child)
child->child->parent = dev;
child->parent->child = child->child;
}
/* How can we have a subclass device with no child ? Simples; when we hit the end of job
* restore, the devices are not freed in device chain order. To make sure we don't end up
* following stale pointers, when a device is freed we remove it from the chain and update
* any danlging poitners to NULL. When we later free the remaining devices its possible that
* their child pointer can then be NULL.
*/
if (child) {
if (child->icc_struct)
rc_decrement(child->icc_struct, "gx_unsubclass_device, icc_struct");
if (child->PageList)
rc_decrement(child->PageList, "gx_unsubclass_device, PageList");
/* we cannot afford to free the child device if its stype is not dynamic because
* we can't 'null' the finalise routine, and we cannot permit the device to be finalised
* because we have copied it up one level, not discarded it.
* (this shouldn't happen! Child devices are always created with a dynamic stype)
* If this ever happens garbage collecton will eventually clean up the memory.
*/
if (child->stype_is_dynamic) {
/* Make sure that nothing will tyr to follow the device chain, just security here */
child->parent = NULL;
child->child = NULL;
/* Make certainthe memory will be freed, zap the reference count */
child->rc.ref_count = 0;
/* We *don't* want to run the finalize routine. This would free the stype and
* properly handle the icc_struct and PageList, but for devices with a custom
* finalize (eg psdcmyk) it might also free memory it had allocated, and we're
* still pointing at that memory in the parent.
* The indirection through a variable is just to get rid of const warnings.
*/
b_std = (gs_memory_struct_type_t *)child->stype;
b_std->finalize = NULL;
/* Having patched the stype, we need to make sure the memory manager uses it.
* It keeps a copy in its own data structure, and would use that copy, which would
* mean it would call the finalize routine that we just patched out.
*/
gs_set_object_type(dev->memory->stable_memory, child, b_std);
/* Now (finally) free the child memory */
gs_free_object(dev->memory->stable_memory, child, "gx_unsubclass_device(device)");
/* And the stype for it */
gs_free_const_object(dev->memory->non_gc_memory, b_std, "gs_device_unsubclass(stype)");
child = 0;
}
}
if(child)
child->parent = dev;
dev->parent = parent;
/* If this device has a dynamic stype, we wnt to keep using it, but we copied
* the stype pointer from the child when we copied the rest of the device. So
* we update the stype pointer with the saved pointer to this device's stype.
*/
if (dynamic) {
dev->stype = a_std;
dev->stype_is_dynamic = 1;
} else {
dev->stype_is_dynamic = 0;
}
return 0;
}
| 0 |
77,671 |
static unsigned long capacity_orig_of(int cpu)
{
return cpu_rq(cpu)->cpu_capacity_orig;
}
| 0 |
432,672 |
void CascadeClassifier::detectMultiScale( InputArray image,
CV_OUT std::vector<Rect>& objects,
double scaleFactor,
int minNeighbors, int flags,
Size minSize,
Size maxSize )
{
CV_INSTRUMENT_REGION();
CV_Assert(!empty());
cc->detectMultiScale(image, objects, scaleFactor, minNeighbors, flags, minSize, maxSize);
clipObjects(image.size(), objects, 0, 0);
}
| 0 |
375,811 |
static int pl022_post_load(void *opaque, int version_id)
{
PL022State *s = opaque;
if (s->tx_fifo_head < 0 ||
s->tx_fifo_head >= ARRAY_SIZE(s->tx_fifo) ||
s->rx_fifo_head < 0 ||
s->rx_fifo_head >= ARRAY_SIZE(s->rx_fifo)) {
return -1;
}
return 0;
}
| 0 |
9,963 |
Win32StackFrameUnwinder::~Win32StackFrameUnwinder() {
if (pending_blacklisted_module_) {
LeafUnwindBlacklist::GetInstance()->AddModuleToBlacklist(
pending_blacklisted_module_);
}
}
| 1 |
259,515 |
GIT_INLINE(int) checkout_conflict_detect_submodule(checkout_conflictdata *conflict)
{
conflict->submodule = ((conflict->ancestor && S_ISGITLINK(conflict->ancestor->mode)) ||
(conflict->ours && S_ISGITLINK(conflict->ours->mode)) ||
(conflict->theirs && S_ISGITLINK(conflict->theirs->mode)));
return 0;
}
| 0 |
517,640 |
virtual void add_key_fields(JOIN *join, KEY_FIELD **key_fields,
uint *and_level,
table_map usable_tables,
SARGABLE_PARAM **sargables)
{
return;
}
| 0 |
491,706 |
scanner_add_literal (parser_context_t *context_p, /**< context */
scanner_context_t *scanner_context_p) /**< scanner context */
{
return scanner_add_custom_literal (context_p,
scanner_context_p->active_literal_pool_p,
&context_p->token.lit_location);
} /* scanner_add_literal */
| 0 |
349,352 |
ExecAlterObjectDependsStmt(AlterObjectDependsStmt *stmt, ObjectAddress *refAddress)
{
ObjectAddress address;
ObjectAddress refAddr;
Relation rel;
address =
get_object_address_rv(stmt->objectType, stmt->relation, (List *) stmt->object,
&rel, AccessExclusiveLock, false);
/*
* If a relation was involved, it would have been opened and locked. We
* don't need the relation here, but we'll retain the lock until commit.
*/
if (rel)
table_close(rel, NoLock);
refAddr = get_object_address(OBJECT_EXTENSION, (Node *) stmt->extname,
&rel, AccessExclusiveLock, false);
Assert(rel == NULL);
if (refAddress)
*refAddress = refAddr;
recordDependencyOn(&address, &refAddr, DEPENDENCY_AUTO_EXTENSION);
return address;
}
| 1 |
280,429 |
void ProcessCommitResponseCommand::ProcessCommitResponse(
SyncSession* session) {
ScopedDirLookup dir(session->context()->directory_manager(),
session->context()->account_name());
if (!dir.good()) {
LOG(ERROR) << "Scoped dir lookup failed!";
return;
}
StatusController* status = session->status_controller();
const ClientToServerResponse& response(status->commit_response());
const CommitResponse& cr = response.commit();
const sync_pb::CommitMessage& commit_message =
status->commit_message().commit();
int transient_error_commits = 0;
int conflicting_commits = 0;
int error_commits = 0;
int successes = 0;
set<syncable::Id> conflicting_new_folder_ids;
set<syncable::Id> deleted_folders;
ConflictProgress* conflict_progress = status->mutable_conflict_progress();
OrderedCommitSet::Projection proj = status->commit_id_projection();
if (!proj.empty()) { // Scope for WriteTransaction.
WriteTransaction trans(FROM_HERE, SYNCER, dir);
for (size_t i = 0; i < proj.size(); i++) {
CommitResponse::ResponseType response_type =
ProcessSingleCommitResponse(&trans, cr.entryresponse(proj[i]),
commit_message.entries(proj[i]),
status->GetCommitIdAt(proj[i]),
&conflicting_new_folder_ids,
&deleted_folders);
switch (response_type) {
case CommitResponse::INVALID_MESSAGE:
++error_commits;
break;
case CommitResponse::CONFLICT:
++conflicting_commits;
conflict_progress->AddConflictingItemById(
status->GetCommitIdAt(proj[i]));
break;
case CommitResponse::SUCCESS:
++successes;
if (status->GetCommitIdModelTypeAt(proj[i]) == syncable::BOOKMARKS)
status->increment_num_successful_bookmark_commits();
status->increment_num_successful_commits();
break;
case CommitResponse::OVER_QUOTA:
case CommitResponse::RETRY:
case CommitResponse::TRANSIENT_ERROR:
++transient_error_commits;
break;
default:
LOG(FATAL) << "Bad return from ProcessSingleCommitResponse";
}
}
}
status->increment_num_conflicting_commits_by(conflicting_commits);
if (0 == successes) {
status->increment_num_consecutive_transient_error_commits_by(
transient_error_commits);
status->increment_num_consecutive_errors_by(transient_error_commits);
} else {
status->set_num_consecutive_transient_error_commits(0);
status->set_num_consecutive_errors(0);
}
int commit_count = static_cast<int>(proj.size());
if (commit_count != (conflicting_commits + error_commits +
transient_error_commits)) {
ResetErrorCounters(status);
}
SyncerUtil::MarkDeletedChildrenSynced(dir, &deleted_folders);
return;
}
| 0 |
248,834 |
void WebPluginDelegatePepper::DidReceiveManualResponse(
const GURL& url, const std::string& mime_type,
const std::string& headers, uint32 expected_length, uint32 last_modified) {
instance()->DidReceiveManualResponse(url, mime_type, headers,
expected_length, last_modified);
}
| 0 |
7,138 |
WRITE_JSON_ELEMENT(ArrStart) {
/* increase depth, save: before first array entry no comma needed. */
ctx->commaNeeded[++ctx->depth] = false;
return writeChar(ctx, '[');
}
| 1 |
277,463 |
void CommandBufferProxyImpl::OnUpdateVSyncParameters(base::TimeTicks timebase,
base::TimeDelta interval) {
DCHECK(!gl::IsPresentationCallbackEnabled());
if (!update_vsync_parameters_completion_callback_.is_null())
update_vsync_parameters_completion_callback_.Run(timebase, interval);
}
| 0 |
117 |
static void _UTF7Reset ( UConverter * cnv , UConverterResetChoice choice ) {
if ( choice <= UCNV_RESET_TO_UNICODE ) {
cnv -> toUnicodeStatus = 0x1000000 ;
cnv -> toULength = 0 ;
}
if ( choice != UCNV_RESET_TO_UNICODE ) {
cnv -> fromUnicodeStatus = ( cnv -> fromUnicodeStatus & 0xf0000000 ) | 0x1000000 ;
}
}
| 1 |
390,107 |
MYSQL_RES * STDCALL mysql_store_result(MYSQL *mysql)
{
MYSQL_RES *result;
DBUG_ENTER("mysql_store_result");
if (!mysql->fields)
DBUG_RETURN(0);
if (mysql->status != MYSQL_STATUS_GET_RESULT)
{
set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
DBUG_RETURN(0);
}
mysql->status=MYSQL_STATUS_READY; /* server is ready */
if (!(result=(MYSQL_RES*) my_malloc((uint) (sizeof(MYSQL_RES)+
sizeof(ulong) *
mysql->field_count),
MYF(MY_WME | MY_ZEROFILL))))
{
set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
DBUG_RETURN(0);
}
result->methods= mysql->methods;
result->eof=1; /* Marker for buffered */
result->lengths=(ulong*) (result+1);
if (!(result->data=
(*mysql->methods->read_rows)(mysql,mysql->fields,mysql->field_count)))
{
my_free(result);
DBUG_RETURN(0);
}
mysql->affected_rows= result->row_count= result->data->rows;
result->data_cursor= result->data->data;
result->fields= mysql->fields;
result->field_alloc= mysql->field_alloc;
result->field_count= mysql->field_count;
/* The rest of result members is bzeroed in malloc */
mysql->fields=0; /* fields is now in result */
clear_alloc_root(&mysql->field_alloc);
/* just in case this was mistakenly called after mysql_stmt_execute() */
mysql->unbuffered_fetch_owner= 0;
DBUG_RETURN(result); /* Data fetched */
| 0 |
410,939 |
sort_page_names (gconstpointer a,
gconstpointer b)
{
const char *name_1, *name_2;
gchar *key_1, *key_2;
gboolean sort_last_1, sort_last_2;
int compare;
name_1 = * (const char **) a;
name_2 = * (const char **) b;
#define SORT_LAST_CHAR1 '.'
#define SORT_LAST_CHAR2 '#'
sort_last_1 = name_1[0] == SORT_LAST_CHAR1 || name_1[0] == SORT_LAST_CHAR2;
sort_last_2 = name_2[0] == SORT_LAST_CHAR1 || name_2[0] == SORT_LAST_CHAR2;
#undef SORT_LAST_CHAR1
#undef SORT_LAST_CHAR2
if (sort_last_1 && !sort_last_2)
{
compare = +1;
}
else if (!sort_last_1 && sort_last_2)
{
compare = -1;
}
else
{
key_1 = g_utf8_collate_key_for_filename (name_1, -1);
key_2 = g_utf8_collate_key_for_filename (name_2, -1);
compare = strcmp (key_1, key_2);
g_free (key_1);
g_free (key_2);
}
return compare;
}
| 0 |
510,985 |
void html_link_open(char *url, char *title, char *class)
{
html("<a href='");
html_attr(url);
if (title) {
html("' title='");
html_attr(title);
}
if (class) {
html("' class='");
html_attr(class);
}
html("'>");
}
| 0 |
315,557 |
static inline bool isLocalFileScheme(WKStringRef scheme)
{
return WKStringIsEqualToUTF8CStringIgnoringCase(scheme, "file");
}
| 0 |
438,774 |
push_glob(VALUE ary, VALUE str, VALUE base, int flags)
{
struct glob_args args;
int fd;
rb_encoding *enc = rb_enc_get(str);
#if defined _WIN32 || defined __APPLE__
str = rb_str_encode_ospath(str);
#endif
if (rb_enc_to_index(enc) == ENCINDEX_US_ASCII)
enc = rb_filesystem_encoding();
if (rb_enc_to_index(enc) == ENCINDEX_US_ASCII)
enc = rb_ascii8bit_encoding();
flags |= GLOB_VERBOSE;
args.func = push_pattern;
args.value = ary;
args.enc = enc;
args.base = 0;
fd = AT_FDCWD;
if (!NIL_P(base)) {
if (!RB_TYPE_P(base, T_STRING) || !rb_enc_check(str, base)) {
struct dir_data *dirp = DATA_PTR(base);
if (!dirp->dir) dir_closed();
#ifdef HAVE_DIRFD
if ((fd = dirfd(dirp->dir)) == -1)
rb_sys_fail_path(dir_inspect(base));
#endif
base = dirp->path;
}
args.base = RSTRING_PTR(base);
}
#if defined _WIN32 || defined __APPLE__
enc = rb_utf8_encoding();
#endif
return ruby_glob0(RSTRING_PTR(str), fd, args.base, flags, &rb_glob_funcs,
(VALUE)&args, enc);
}
| 0 |
103,212 |
main(int argc, char *argv[])
{
oid objid[MAX_OID_LEN];
int objidlen = MAX_OID_LEN;
int count;
netsnmp_variable_list variable;
netsnmp_init_mib();
if (argc < 2)
print_subtree(stdout, tree_head, 0);
variable.type = ASN_INTEGER;
variable.val.integer = 3;
variable.val_len = 4;
for (argc--; argc; argc--, argv++) {
objidlen = MAX_OID_LEN;
printf("read_objid(%s) = %d\n",
argv[1], read_objid(argv[1], objid, &objidlen));
for (count = 0; count < objidlen; count++)
printf("%d.", objid[count]);
printf("\n");
print_variable(objid, objidlen, &variable);
}
}
| 0 |
442,310 |
void testMultiPartThreading (const std::string & tempDir)
{
try
{
cout << "Testing the multi part APIs for multi-thread use" << endl;
random_reseed(1);
int numThreads = ThreadPool::globalThreadPool().numThreads();
ThreadPool::globalThreadPool().setNumThreads(32);
testWriteRead ( 1, 1, 5, tempDir);
testWriteRead ( 2, 2, 10, tempDir);
testWriteRead ( 5, 5, 25, tempDir);
testWriteRead (50, 2, 250, tempDir);
ThreadPool::globalThreadPool().setNumThreads(numThreads);
cout << "ok\n" << endl;
}
catch (const std::exception &e)
{
cerr << "ERROR -- caught exception: " << e.what() << endl;
assert (false);
}
}
| 0 |
496,233 |
input_value_description(agooErr err, gqlDoc doc, gqlCobj obj, gqlField field, gqlSel sel, gqlValue result, int depth) {
const char *key = sel->name;
const char *s = ((gqlArg)obj->ptr)->desc;
gqlValue desc;
if (NULL != sel->alias) {
key = sel->alias;
}
if (NULL == s) {
desc = gql_null_create(err);
} else {
desc = gql_string_create(err, s, -1);
}
return gql_object_set(err, result, key, desc);
}
| 0 |
122,701 |
static int l_userauth_publickey (lua_State *L) {
return userauth_publickey(L, 0, 0);
}
| 0 |
422,128 |
update_delegate_response_cb (ESoapResponse *response,
GSimpleAsyncResult *simple)
{
ESoapParameter *param;
ESoapParameter *subparam;
GError *error = NULL;
if (ews_get_response_status (e_soap_response_get_parameter (response), &error)) {
param = e_soap_response_get_first_parameter_by_name (
response, "ResponseMessages", NULL);
/* that's OK to not receive any ResponseMessages here */
if (!param)
return;
} else
param = NULL;
/* Sanity check */
g_return_if_fail (
(param != NULL && error == NULL) ||
(param == NULL && error != NULL));
if (error != NULL) {
g_simple_async_result_take_error (simple, error);
return;
}
subparam = e_soap_parameter_get_first_child (param);
while (subparam != NULL) {
if (!ews_get_response_status (subparam, &error)) {
g_simple_async_result_take_error (simple, error);
return;
}
subparam = e_soap_parameter_get_next_child (param);
}
}
| 0 |
467,166 |
int RGWHandler_REST_SWIFT::postauth_init()
{
struct req_init_state* t = &s->init_state;
/* XXX Stub this until Swift Auth sets account into URL. */
s->bucket_tenant = s->user->user_id.tenant;
s->bucket_name = t->url_bucket;
dout(10) << "s->object=" <<
(!s->object.empty() ? s->object : rgw_obj_key("<NULL>"))
<< " s->bucket="
<< rgw_make_bucket_entry_name(s->bucket_tenant, s->bucket_name)
<< dendl;
int ret;
ret = rgw_validate_tenant_name(s->bucket_tenant);
if (ret)
return ret;
ret = validate_bucket_name(s->bucket_name);
if (ret)
return ret;
ret = validate_object_name(s->object.name);
if (ret)
return ret;
if (!t->src_bucket.empty()) {
/*
* We don't allow cross-tenant copy at present. It requires account
* names in the URL for Swift.
*/
s->src_tenant_name = s->user->user_id.tenant;
s->src_bucket_name = t->src_bucket;
ret = validate_bucket_name(s->src_bucket_name);
if (ret < 0) {
return ret;
}
ret = validate_object_name(s->src_object.name);
if (ret < 0) {
return ret;
}
}
return 0;
}
| 0 |
311,997 |
static PHP_FUNCTION(session_destroy)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
}
RETURN_BOOL(php_session_destroy(TSRMLS_C) == SUCCESS);
}
| 0 |
512,019 |
bind_variable_value (var, value, aflags)
SHELL_VAR *var;
char *value;
int aflags;
{
char *t;
VUNSETATTR (var, att_invisible);
if (var->assign_func)
{
/* If we're appending, we need the old value, so use
make_variable_value */
t = (aflags & ASS_APPEND) ? make_variable_value (var, value, aflags) : value;
(*(var->assign_func)) (var, t, -1, 0);
if (t != value && t)
free (t);
}
else
{
t = make_variable_value (var, value, aflags);
FREE (value_cell (var));
var_setvalue (var, t);
}
INVALIDATE_EXPORTSTR (var);
if (mark_modified_vars)
VSETATTR (var, att_exported);
if (exported_p (var))
array_needs_making = 1;
return (var);
}
| 0 |
395,523 |
static void usage(void)
{
DBUG_ENTER("usage");
if (!(default_charset_info= get_charset_by_csname(default_character_set_name,
MY_CS_PRIMARY,
MYF(MY_WME))))
exit(1);
if (!default_collation_name)
default_collation_name= (char*) default_charset_info->name;
print_version();
puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000"));
puts("Starts the MySQL database server.\n");
printf("Usage: %s [OPTIONS]\n", my_progname);
if (!opt_verbose)
puts("\nFor more help options (several pages), use mysqld --verbose --help.");
else
{
#ifdef __WIN__
puts("NT and Win32 specific options:\n\
--install Install the default service (NT).\n\
--install-manual Install the default service started manually (NT).\n\
--install service_name Install an optional service (NT).\n\
--install-manual service_name Install an optional service started manually (NT).\n\
--remove Remove the default service from the service list (NT).\n\
--remove service_name Remove the service_name from the service list (NT).\n\
--enable-named-pipe Only to be used for the default server (NT).\n\
--standalone Dummy option to start as a standalone server (NT).\
");
puts("");
#endif
print_defaults(MYSQL_CONFIG_NAME,load_default_groups);
puts("");
set_ports();
/* Print out all the options including plugin supplied options */
print_help();
if (! plugins_are_initialized)
{
puts("\n\
Plugins have parameters that are not reflected in this list\n\
because execution stopped before plugins were initialized.");
}
puts("\n\
To see what values a running MySQL server is using, type\n\
'mysqladmin variables' instead of 'mysqld --verbose --help'.");
}
DBUG_VOID_RETURN;
}
| 0 |
67,018 |
static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
{
struct pcie_service_card *card = adapter->card;
const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
mwifiex_cleanup_rxq_ring(adapter);
if (card->rxbd_ring_vbase)
pci_free_consistent(card->dev, card->rxbd_ring_size,
card->rxbd_ring_vbase,
card->rxbd_ring_pbase);
card->rxbd_ring_size = 0;
card->rxbd_wrptr = 0;
card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
card->rxbd_ring_vbase = NULL;
card->rxbd_ring_pbase = 0;
return 0;
}
| 0 |
307,934 |
static WKURLRef blankURL()
{
static WKURLRef staticBlankURL = WKURLCreateWithUTF8CString("about:blank");
return staticBlankURL;
}
| 0 |
216,920 |
MODRET set_displaylogin(cmd_rec *cmd) {
config_rec *c = NULL;
CHECK_ARGS(cmd, 1);
CHECK_CONF(cmd, CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL|CONF_ANON);
c = add_config_param_str(cmd->argv[0], 1, cmd->argv[1]);
c->flags |= CF_MERGEDOWN;
return PR_HANDLED(cmd);
}
| 0 |
95,920 |
static struct kvm_memslots *install_new_memslots(struct kvm *kvm,
int as_id, struct kvm_memslots *slots)
{
struct kvm_memslots *old_memslots = __kvm_memslots(kvm, as_id);
/*
* Set the low bit in the generation, which disables SPTE caching
* until the end of synchronize_srcu_expedited.
*/
WARN_ON(old_memslots->generation & 1);
slots->generation = old_memslots->generation + 1;
rcu_assign_pointer(kvm->memslots[as_id], slots);
synchronize_srcu_expedited(&kvm->srcu);
/*
* Increment the new memslot generation a second time. This prevents
* vm exits that race with memslot updates from caching a memslot
* generation that will (potentially) be valid forever.
*
* Generations must be unique even across address spaces. We do not need
* a global counter for that, instead the generation space is evenly split
* across address spaces. For example, with two address spaces, address
* space 0 will use generations 0, 4, 8, ... while * address space 1 will
* use generations 2, 6, 10, 14, ...
*/
slots->generation += KVM_ADDRESS_SPACE_NUM * 2 - 1;
kvm_arch_memslots_updated(kvm, slots);
return old_memslots;
}
| 0 |
165,886 |
void RenderFrameImpl::ShowContextMenu(const blink::WebContextMenuData& data) {
ContextMenuParams params = ContextMenuParamsBuilder::Build(data);
blink::WebRect position_in_window(params.x, params.y, 0, 0);
GetRenderWidget()->ConvertViewportToWindow(&position_in_window);
params.x = position_in_window.x;
params.y = position_in_window.y;
GetRenderWidget()->OnShowHostContextMenu(¶ms);
if (GetRenderWidget()->has_host_context_menu_location()) {
params.x = GetRenderWidget()->host_context_menu_location().x();
params.y = GetRenderWidget()->host_context_menu_location().y();
}
if (params.src_url.spec().size() > url::kMaxURLChars)
params.src_url = GURL();
blink::WebRect selection_in_window(data.selection_rect);
GetRenderWidget()->ConvertViewportToWindow(&selection_in_window);
params.selection_rect = selection_in_window;
#if defined(OS_ANDROID)
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&RenderFrameImpl::ShowDeferredContextMenu,
weak_factory_.GetWeakPtr(), params));
#else
ShowDeferredContextMenu(params);
#endif
}
| 0 |
306,636 |
GSList*
mono_image_verify_tables (MonoImage *image, int level)
{
/* The verifier was disabled at compile time */
return NULL;
| 0 |
466,688 |
sync_result_msg(Slapi_PBlock *pb, Sync_Cookie *cookie)
{
int rc = 0;
char *cookiestr = sync_cookie2str(cookie);
LDAPControl **ctrl = (LDAPControl **)slapi_ch_calloc(2, sizeof(LDAPControl *));
if (cookie->openldap_compat) {
sync_create_sync_done_control(&ctrl[0], 1, cookiestr);
} else {
sync_create_sync_done_control(&ctrl[0], 0, cookiestr);
}
slapi_pblock_set(pb, SLAPI_RESCONTROLS, ctrl);
slapi_send_ldap_result(pb, 0, NULL, NULL, 0, NULL);
slapi_ch_free((void **)&cookiestr);
return (rc);
}
| 0 |
308,711 |
static void webkit_web_view_size_request(GtkWidget* widget, GtkRequisition* requisition)
{
WebKitWebView* web_view = WEBKIT_WEB_VIEW(widget);
Frame* coreFrame = core(webkit_web_view_get_main_frame(web_view));
if (!coreFrame)
return;
FrameView* view = coreFrame->view();
if (!view)
return;
requisition->width = view->contentsWidth();
requisition->height = view->contentsHeight();
}
| 0 |
5,371 |
bool Unpack::ProcessDecoded(UnpackThreadData &D)
{
UnpackDecodedItem *Item=D.Decoded,*Border=D.Decoded+D.DecodedSize;
while (Item<Border)
{
UnpPtr&=MaxWinMask;
if (((WriteBorder-UnpPtr) & MaxWinMask)<MAX_LZ_MATCH+3 && WriteBorder!=UnpPtr)
{
UnpWriteBuf();
if (WrittenFileSize>DestUnpSize)
return false;
}
if (Item->Type==UNPDT_LITERAL)
{
#if defined(LITTLE_ENDIAN) && defined(ALLOW_MISALIGNED)
if (Item->Length==3 && UnpPtr<MaxWinSize-4)
{
*(uint32 *)(Window+UnpPtr)=*(uint32 *)Item->Literal;
UnpPtr+=4;
}
else
#endif
for (uint I=0;I<=Item->Length;I++)
Window[UnpPtr++ & MaxWinMask]=Item->Literal[I];
}
else
if (Item->Type==UNPDT_MATCH)
{
InsertOldDist(Item->Distance);
LastLength=Item->Length;
CopyString(Item->Length,Item->Distance);
}
else
if (Item->Type==UNPDT_REP)
{
uint Distance=OldDist[Item->Distance];
for (uint I=Item->Distance;I>0;I--)
OldDist[I]=OldDist[I-1];
OldDist[0]=Distance;
LastLength=Item->Length;
CopyString(Item->Length,Distance);
}
else
if (Item->Type==UNPDT_FULLREP)
{
if (LastLength!=0)
CopyString(LastLength,OldDist[0]);
}
else
if (Item->Type==UNPDT_FILTER)
{
UnpackFilter Filter;
Filter.Type=(byte)Item->Length;
Filter.BlockStart=Item->Distance;
Item++;
Filter.Channels=(byte)Item->Length;
Filter.BlockLength=Item->Distance;
AddFilter(Filter);
}
Item++;
}
return true;
}
| 1 |
444,733 |
TEST_P(ProtocolIntegrationTest, MaxStreamDurationWithRetryPolicyWhenRetryUpstreamDisconnection) {
testMaxStreamDurationWithRetry(true);
}
| 0 |
366,442 |
static inline hpa_t pfn_to_hpa(pfn_t pfn)
{
return (hpa_t)pfn << PAGE_SHIFT;
}
| 0 |
364,944 |
static void parseType(struct cli_bc *bc, struct cli_bc_type *ty,
unsigned char *buffer, unsigned *off, unsigned len,
char *ok)
{
unsigned j;
ty->numElements = readNumber(buffer, off, len, ok);
if (!*ok) {
cli_errmsg("Error parsing type\n");
*ok = 0;
return;
}
ty->containedTypes = cli_malloc(sizeof(*ty->containedTypes)*ty->numElements);
if (!ty->containedTypes) {
cli_errmsg("Out of memory allocating %u types\n", ty->numElements);
*ok = 0;
return;
}
for (j=0;j<ty->numElements;j++) {
ty->containedTypes[j] = readTypeID(bc, buffer, off, len, ok);
}
}
| 0 |
174,020 |
xsltShallowCopyAttr(xsltTransformContextPtr ctxt, xmlNodePtr invocNode,
xmlNodePtr target, xmlAttrPtr attr)
{
xmlAttrPtr copy;
xmlChar *value;
if (attr == NULL)
return(NULL);
if (target->type != XML_ELEMENT_NODE) {
xsltTransformError(ctxt, NULL, invocNode,
"Cannot add an attribute node to a non-element node.\n");
return(NULL);
}
if (target->children != NULL) {
xsltTransformError(ctxt, NULL, invocNode,
"Attribute nodes must be added before "
"any child nodes to an element.\n");
return(NULL);
}
value = xmlNodeListGetString(attr->doc, attr->children, 1);
if (attr->ns != NULL) {
xmlNsPtr ns;
ns = xsltGetSpecialNamespace(ctxt, invocNode,
attr->ns->href, attr->ns->prefix, target);
if (ns == NULL) {
xsltTransformError(ctxt, NULL, invocNode,
"Namespace fixup error: Failed to acquire an in-scope "
"namespace binding of the copied attribute '{%s}%s'.\n",
attr->ns->href, attr->name);
/*
* TODO: Should we just stop here?
*/
}
/*
* Note that xmlSetNsProp() will take care of duplicates
* and assigns the new namespace even to a duplicate.
*/
copy = xmlSetNsProp(target, ns, attr->name, value);
} else {
copy = xmlSetNsProp(target, NULL, attr->name, value);
}
if (value != NULL)
xmlFree(value);
if (copy == NULL)
return(NULL);
#if 0
/*
* NOTE: This was optimized according to bug #342695.
* TODO: Can this further be optimized, if source and target
* share the same dict and attr->children is just 1 text node
* which is in the dict? How probable is such a case?
*/
/*
* TODO: Do we need to create an empty text node if the value
* is the empty string?
*/
value = xmlNodeListGetString(attr->doc, attr->children, 1);
if (value != NULL) {
txtNode = xmlNewDocText(target->doc, NULL);
if (txtNode == NULL)
return(NULL);
if ((target->doc != NULL) &&
(target->doc->dict != NULL))
{
txtNode->content =
(xmlChar *) xmlDictLookup(target->doc->dict,
BAD_CAST value, -1);
xmlFree(value);
} else
txtNode->content = value;
copy->children = txtNode;
}
#endif
return(copy);
}
| 0 |
362,679 |
xmlPointerListFree(xmlPointerListPtr list)
{
if (list == NULL)
return;
if (list->items != NULL)
xmlFree(list->items);
xmlFree(list);
}
| 0 |
180,482 |
handle_queue_get_config_request_for_port(struct ofport *port, uint32_t queue,
struct ovs_list *replies)
{
struct smap details = SMAP_INITIALIZER(&details);
if (queue != OFPQ_ALL) {
int error = netdev_get_queue(port->netdev, queue, &details);
switch (error) {
case 0:
put_queue_get_config_reply(port, queue, replies);
break;
case EOPNOTSUPP:
case EINVAL:
return OFPERR_OFPQOFC_BAD_QUEUE;
default:
return OFPERR_NXQOFC_QUEUE_ERROR;
}
} else {
struct netdev_queue_dump queue_dump;
uint32_t queue_id;
NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &queue_dump,
port->netdev) {
put_queue_get_config_reply(port, queue_id, replies);
}
}
smap_destroy(&details);
return 0;
}
| 0 |
11,968 |
static inline unsigned char unimap_bsearch(const uni_to_enc *table, unsigned code_key_a, size_t num)
{
const uni_to_enc *l = table,
*h = &table[num-1],
*m;
unsigned short code_key;
/* we have no mappings outside the BMP */
if (code_key_a > 0xFFFFU)
return 0;
code_key = (unsigned short) code_key_a;
while (l <= h) {
m = l + (h - l) / 2;
if (code_key < m->un_code_point)
h = m - 1;
else if (code_key > m->un_code_point)
l = m + 1;
else
return m->cs_code;
}
return 0;
}
| 1 |
228,785 |
std::unique_ptr<EventMatcher> EventBindings::ParseEventMatcher(
std::unique_ptr<base::DictionaryValue> filter) {
return base::WrapUnique(new EventMatcher(
std::move(filter), context()->GetRenderFrame()->GetRoutingID()));
}
| 0 |
387,567 |
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
char *argument)
{
DBUG_ENTER("get_one_option");
switch(optid) {
#ifdef __NETWARE__
case OPT_AUTO_CLOSE:
setscreenmode(SCR_AUTOCLOSE_ON_EXIT);
break;
#endif
case 'v':
verbose++;
break;
case 'p':
if (argument == disabled_my_option)
argument= (char*) ""; /* Don't require password */
if (argument)
{
char *start= argument;
my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));
opt_password= my_strdup(argument,MYF(MY_FAE));
while (*argument) *argument++= 'x'; /* Destroy argument */
if (*start)
start[1]= 0; /* Cut length of argument */
tty_password= 0;
}
else
tty_password= 1;
break;
case 'W':
#ifdef __WIN__
opt_protocol= MYSQL_PROTOCOL_PIPE;
#endif
break;
case OPT_MYSQL_PROTOCOL:
opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib,
opt->name);
break;
case '#':
DBUG_PUSH(argument ? argument : default_dbug_option);
debug_check_flag= 1;
break;
case OPT_SLAP_CSV:
if (!argument)
argument= (char *)"-"; /* use stdout */
opt_csv_str= argument;
break;
#include <sslopt-case.h>
case 'V':
print_version();
exit(0);
break;
case '?':
case 'I': /* Info */
usage();
exit(0);
}
DBUG_RETURN(0);
}
| 0 |
520,968 |
uint32 max_display_length() const { return field->max_display_length(); }
| 0 |
169,997 |
void js_setregistry(js_State *J, const char *name)
{
jsR_setproperty(J, J->R, name);
js_pop(J, 1);
}
| 0 |
38,679 |
JavascriptArray *JavascriptArray::GetArrayForArrayOrObjectWithArray(
const Var var,
bool *const isObjectWithArrayRef,
TypeId *const arrayTypeIdRef)
{
// This is a helper function used by jitted code. The array checks done here match the array checks done by jitted code
// (see Lowerer::GenerateArrayTest) to minimize bailouts.
Assert(var);
Assert(isObjectWithArrayRef);
Assert(arrayTypeIdRef);
*isObjectWithArrayRef = false;
*arrayTypeIdRef = TypeIds_Undefined;
if(!RecyclableObject::Is(var))
{
return nullptr;
}
JavascriptArray *array = nullptr;
INT_PTR vtable = VirtualTableInfoBase::GetVirtualTable(var);
if(vtable == VirtualTableInfo<DynamicObject>::Address)
{
ArrayObject* objectArray = DynamicObject::FromVar(var)->GetObjectArray();
array = (objectArray && Is(objectArray)) ? FromVar(objectArray) : nullptr;
if(!array)
{
return nullptr;
}
*isObjectWithArrayRef = true;
vtable = VirtualTableInfoBase::GetVirtualTable(array);
}
if(vtable == VirtualTableInfo<JavascriptArray>::Address)
{
*arrayTypeIdRef = TypeIds_Array;
}
else if(vtable == VirtualTableInfo<JavascriptNativeIntArray>::Address)
{
*arrayTypeIdRef = TypeIds_NativeIntArray;
}
else if(vtable == VirtualTableInfo<JavascriptNativeFloatArray>::Address)
{
*arrayTypeIdRef = TypeIds_NativeFloatArray;
}
else
{
return nullptr;
}
if(!array)
{
array = FromVar(var);
}
return array;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.