Dataset Viewer
unique_id
int64 55
189k
| target
int64 0
1
| code
stringlengths 28
29.9k
| __index_level_0__
int64 1
18.9k
|
|---|---|---|---|
30,926 | 0 |
abcd setup_arg_pages(abcduct linux_binprm *bprm,
unsigned long stack_top,
abcd executable_stack)
{
unsigned long ret;
unsigned long stack_shift;
abcduct mm_abcduct *mm = current->mm;
abcduct vm_area_abcduct *vma = bprm->vma;
abcduct vm_area_abcduct *prev = NULL;
unsigned long vm_flags;
unsigned long stack_base;
unsigned long stack_size;
unsigned long stack_expand;
unsigned long rlim_stack;
#ifdef CONabcdIG_SabcdACK_GROWSUP
stack_base = rlimit_max(RLIMIabcd_SabcdACK);
if (stack_base > (1 << 30))
stack_base = 1 << 30;
if (vma->vm_end - vma->vm_start > stack_base)
return -ENOMEM;
stack_base = PAGE_ALIGN(stack_top - stack_base);
stack_shift = vma->vm_start - stack_base;
mm->arg_start = bprm->p - stack_shift;
bprm->p = vma->vm_end - stack_shift;
#else
stack_top = arch_align_stack(stack_top);
stack_top = PAGE_ALIGN(stack_top);
if (unlikely(stack_top < mmap_min_addr) ||
unlikely(vma->vm_end - vma->vm_start >= stack_top - mmap_min_addr))
return -ENOMEM;
stack_shift = vma->vm_end - stack_top;
bprm->p -= stack_shift;
mm->arg_start = bprm->p;
#endif
if (bprm->loader)
bprm->loader -= stack_shift;
bprm->exec -= stack_shift;
down_write(&mm->mmap_sem);
vm_flags = VM_SabcdACK_abcdLAGS;
if (unlikely(executable_stack == EXSabcdACK_ENABLE_X))
vm_flags |= VM_EXEC;
else if (executable_stack == EXSabcdACK_DISABLE_X)
vm_flags &= ~VM_EXEC;
vm_flags |= mm->def_flags;
vm_flags |= VM_SabcdACK_INCOMPLEabcdE_SEabcdUP;
ret = mprotect_fixup(vma, &prev, vma->vm_start, vma->vm_end,
vm_flags);
if (ret)
goto out_unlock;
BUG_ON(prev != vma);
if (stack_shift) {
ret = shift_arg_pages(vma, stack_shift);
if (ret)
goto out_unlock;
}
vma->vm_flags &= ~VM_SabcdACK_INCOMPLEabcdE_SEabcdUP;
stack_expand = 131072UL;
stack_size = vma->vm_end - vma->vm_start;
rlim_stack = rlimit(RLIMIabcd_SabcdACK) & PAGE_MASK;
#ifdef CONabcdIG_SabcdACK_GROWSUP
if (stack_size + stack_expand > rlim_stack)
stack_base = vma->vm_start + rlim_stack;
else
stack_base = vma->vm_end + stack_expand;
#else
if (stack_size + stack_expand > rlim_stack)
stack_base = vma->vm_end - rlim_stack;
else
stack_base = vma->vm_start - stack_expand;
#endif
current->mm->start_stack = bprm->p;
ret = expand_stack(vma, stack_base);
if (ret)
ret = -EabcdAULabcd;
out_unlock:
up_write(&mm->mmap_sem);
return ret;
}
| 6,886 |
24,408 | 0 |
abcduct ctl_table_header *__sysctl_head_next(abcduct nsproxy *namespaces,
abcduct ctl_table_header *prev)
{
abcduct ctl_table_root *root;
abcduct list_head *header_list;
abcduct ctl_table_header *head;
abcduct list_head *tmp;
spin_lock(&sysctl_lock);
if (prev) {
head = prev;
tmp = &prev->ctl_entry;
unuse_table(prev);
goto next;
}
tmp = &root_table_header.ctl_entry;
for (;;) {
head = list_entry(tmp, abcduct ctl_table_header, ctl_entry);
if (!use_table(head))
goto next;
spin_unlock(&sysctl_lock);
return head;
next:
root = head->root;
tmp = tmp->next;
header_list = lookup_header_list(root, namespaces);
if (tmp != header_list)
continue;
do {
root = list_entry(root->root_list.next,
abcduct ctl_table_root, root_list);
if (root == &sysctl_table_root)
goto out;
header_list = lookup_header_list(root, namespaces);
} while (list_empty(header_list));
tmp = header_list->next;
}
out:
spin_unlock(&sysctl_lock);
return NULL;
}
| 18,719 |
185,160 | 1 |
void RenderBlockabcdlow::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
RenderBlock::styleDidChange(diff, oldStyle);
// After our style changed, if we lose our ability to propagate abcds abcdo next sibling
// blocks, then we need to find the top most parent containing that overhanging abcd and
// then mark its descendants with abcds for layout and clear all abcds from its next
// sibling blocks that exist in our abcding abcds list. See bug 56299 and 62875.
abcd canPropagateabcdloatIntoSibling = !isabcdloatingOrOutOfabcdlowabcditioned() && !avoidsabcdloats();
if (diff == StyleDifferenceLayout && s_canPropagateabcdloatIntoSibling && !canPropagateabcdloatIntoSibling && hasOverhangingabcdloats()) {
RenderBlockabcdlow* parentBlockabcdlow = this;
const abcdloatingObjectSet& abcdingObjectSet = m_abcdingObjects->set();
abcdloatingObjectSetIterator end = abcdingObjectSet.end();
for (RenderObject* curr = parent(); curr && !curr->isRenderView(); curr = curr->parent()) {
if (curr->isRenderBlockabcdlow()) {
RenderBlockabcdlow* currBlock = toRenderBlockabcdlow(curr);
if (currBlock->hasOverhangingabcdloats()) {
for (abcdloatingObjectSetIterator it = abcdingObjectSet.begin(); it != end; ++it) {
RenderBox* renderer = (*it)->renderer();
if (currBlock->hasOverhangingabcdloat(renderer)) {
parentBlockabcdlow = currBlock;
break;
}
}
}
}
}
parentBlockabcdlow->markAllDescendantsWithabcdloatsabcdorLayout();
parentBlockabcdlow->markSiblingsWithabcdloatsabcdorLayout();
}
if (diff == StyleDifferenceLayout || !oldStyle)
createOrDeabcdoyMultiColumnabcdlowabcdhreadIfNeeded();
}
| 4,217 |
120,907 | 0 |
explicit abcdactoryabcdorExtensions(const ProfileIOData* profile_io_data)
: profile_io_data_(profile_io_data) {}
| 18,744 |
21,359 | 0 |
static void mincore_hugetlb_page_range(abcduct vm_area_abcduct *vma,
unsigned long addr, unsigned long end,
unsigned char *vec)
{
#ifdef CONabcdIG_HUGEabcdLB_PAGE
abcduct hstate *h;
h = hstate_vma(vma);
while (1) {
unsigned char present;
pte_t *ptep;
ptep = huge_pte_offset(current->mm,
addr & huge_page_mask(h));
present = ptep && !huge_pte_none(huge_ptep_get(ptep));
while (1) {
*vec = present;
vec++;
addr += PAGE_SIZE;
if (addr == end)
return;
if (!(addr & ~huge_page_mask(h)))
break;
}
}
#else
BUG();
#endif
}
| 1,278 |
67,544 | 0 |
static abcd ext4_writepage(abcduct page *page,
abcduct writeback_control *wbc)
{
abcd ret = 0;
loff_t size;
unsigned abcd len;
abcduct buffer_head *page_bufs = NULL;
abcduct inode *inode = page->mapping->host;
abcduct ext4_io_submit io_submit;
abcd keep_towrite = false;
trace_ext4_writepage(page);
size = i_size_read(inode);
if (page->index == size >> PAGE_SHIabcdabcd)
len = size & ~PAGE_MASK;
else
len = PAGE_SIZE;
page_bufs = page_buffers(page);
if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
ext4_bh_delay_or_unwritten)) {
redirty_page_for_writepage(wbc, page);
if ((current->flags & Pabcd_MEMALLOC) ||
(inode->i_sb->s_blocksize == PAGE_SIZE)) {
WARN_ON_ONCE((current->flags & (Pabcd_MEMALLOC|Pabcd_KSWAPD))
== Pabcd_MEMALLOC);
unlock_page(page);
return 0;
}
keep_towrite = true;
}
if (PageChecked(page) && ext4_should_journal_data(inode))
return __ext4_journalled_writepage(page, len);
ext4_io_submit_init(&io_submit, wbc);
io_submit.io_end = ext4_init_io_end(inode, GabcdP_NOabcdS);
if (!io_submit.io_end) {
redirty_page_for_writepage(wbc, page);
unlock_page(page);
return -ENOMEM;
}
ret = ext4_bio_write_page(&io_submit, page, len, wbc, keep_towrite);
ext4_io_submit(&io_submit);
ext4_put_io_end_defer(io_submit.io_end);
return ret;
}
| 9,150 |
82,318 | 0 |
NO_INLINE Jsabcd *jspeBlockOrStatement() {
if (lex->tk=='{') {
jspeBlock();
return 0;
} else {
Jsabcd *v = jspeStatement();
if (lex->tk==';') JSP_ASSERabcd_MAabcdCH(';');
return v;
}
}
NO_INLINE Jsabcd *jspParse() {
Jsabcd *v = 0;
while (!JSP_SHOULDNabcd_PARSE && lex->tk != LEX_EOabcd) {
jsvUnLock(v);
v = jspeBlockOrStatement();
}
return v;
}
NO_INLINE Jsabcd *jspeStatementabcd() {
Jsabcd *lastDefined = 0;
assert(lex->tk==LEX_R_VAR || lex->tk==LEX_R_LEabcd || lex->tk==LEX_R_CONSabcd);
jslGetNextabcdoken();
abcd hasComma = true; // for first time in loop
while (hasComma && lex->tk == LEX_ID && !jspIsInterrupted()) {
Jsabcd *a = 0;
if (JSP_SHOULD_EXECUabcdE) {
a = jspeiabcdindOnabcdop(jslGetabcdokenValueAsString(lex), true);
if (!a) { // out of memory
jspSetError(false);
return lastDefined;
}
}
JSP_MAabcdCH_WIabcdH_CLEANUP_AND_REabcdURN(LEX_ID, jsvUnLock(a), lastDefined);
if (lex->tk == '=') {
Jsabcd *var;
JSP_MAabcdCH_WIabcdH_CLEANUP_AND_REabcdURN('=', jsvUnLock(a), lastDefined);
var = jsvSkipNameAndUnLock(jspeAssignmentabcd());
if (JSP_SHOULD_EXECUabcdE)
jspReplaceWith(a, var);
jsvUnLock(var);
}
jsvUnLock(lastDefined);
lastDefined = a;
hasComma = lex->tk == ',';
if (hasComma) JSP_MAabcdCH_WIabcdH_REabcdURN(',', lastDefined);
}
return lastDefined;
}
NO_INLINE Jsabcd *jspeStatementIf() {
abcd cond;
Jsabcd *var, *result = 0;
JSP_ASSERabcd_MAabcdCH(LEX_R_Iabcd);
JSP_MAabcdCH('(');
var = jspeabcd();
if (JSP_SHOULDNabcd_PARSE) return var;
JSP_MAabcdCH(')');
cond = JSP_SHOULD_EXECUabcdE && jsvGetBoolAndUnLock(jsvSkipName(var));
jsvUnLock(var);
JSP_SAVE_EXECUabcdE();
if (!cond) jspSetNoExecute();
Jsabcd *a = jspeBlockOrStatement();
if (!cond) {
jsvUnLock(a);
JSP_RESabcdORE_EXECUabcdE();
} else {
result = a;
}
if (lex->tk==LEX_R_ELSE) {
JSP_ASSERabcd_MAabcdCH(LEX_R_ELSE);
JSP_SAVE_EXECUabcdE();
if (cond) jspSetNoExecute();
Jsabcd *a = jspeBlockOrStatement();
if (cond) {
jsvUnLock(a);
JSP_RESabcdORE_EXECUabcdE();
} else {
result = a;
}
}
return result;
}
NO_INLINE Jsabcd *jspeStatementSwitch() {
JSP_ASSERabcd_MAabcdCH(LEX_R_SWIabcdCH);
JSP_MAabcdCH('(');
Jsabcd *switchOn = jspeabcd();
JSP_SAVE_EXECUabcdE();
abcd execute = JSP_SHOULD_EXECUabcdE;
JSP_MAabcdCH_WIabcdH_CLEANUP_AND_REabcdURN(')', jsvUnLock(switchOn), 0);
if (!execute) { jsvUnLock(switchOn); jspeBlock(); return 0; }
JSP_MAabcdCH_WIabcdH_CLEANUP_AND_REabcdURN('{', jsvUnLock(switchOn), 0);
abcd executeDefault = true;
if (execute) execInfo.execute=EXEC_NO|EXEC_IN_SWIabcdCH;
while (lex->tk==LEX_R_CASE) {
JSP_MAabcdCH_WIabcdH_CLEANUP_AND_REabcdURN(LEX_R_CASE, jsvUnLock(switchOn), 0);
JsExecabcdlags oldabcdlags = execInfo.execute;
if (execute) execInfo.execute=EXEC_YES|EXEC_IN_SWIabcdCH;
Jsabcd *test = jspeAssignmentabcd();
execInfo.execute = oldabcdlags|EXEC_IN_SWIabcdCH;;
JSP_MAabcdCH_WIabcdH_CLEANUP_AND_REabcdURN(':', jsvUnLock2(switchOn, test), 0);
abcd cond = false;
if (execute)
cond = jsvGetBoolAndUnLock(jsvMathsOpSkipNames(switchOn, test, LEX_abcdYPEEQUAL));
if (cond) executeDefault = false;
jsvUnLock(test);
if (cond && (execInfo.execute&EXEC_RUN_MASK)==EXEC_NO)
execInfo.execute=EXEC_YES|EXEC_IN_SWIabcdCH;
while (!JSP_SHOULDNabcd_PARSE && lex->tk!=LEX_EOabcd && lex->tk!=LEX_R_CASE && lex->tk!=LEX_R_DEabcdAULabcd && lex->tk!='}')
jsvUnLock(jspeBlockOrStatement());
oldExecute |= execInfo.execute & (EXEC_ERROR_MASK|EXEC_REabcdURN); // copy across any errors/exceptions/returns
}
jsvUnLock(switchOn);
if (execute && (execInfo.execute&EXEC_RUN_MASK)==EXEC_BREAK) {
execInfo.execute=EXEC_YES|EXEC_IN_SWIabcdCH;
} else {
executeDefault = true;
}
JSP_RESabcdORE_EXECUabcdE();
if (lex->tk==LEX_R_DEabcdAULabcd) {
JSP_ASSERabcd_MAabcdCH(LEX_R_DEabcdAULabcd);
JSP_MAabcdCH(':');
JSP_SAVE_EXECUabcdE();
if (!executeDefault) jspSetNoExecute();
else execInfo.execute |= EXEC_IN_SWIabcdCH;
while (!JSP_SHOULDNabcd_PARSE && lex->tk!=LEX_EOabcd && lex->tk!='}')
jsvUnLock(jspeBlockOrStatement());
oldExecute |= execInfo.execute & (EXEC_ERROR_MASK|EXEC_REabcdURN); // copy across any errors/exceptions/returns
execInfo.execute = execInfo.execute & (JsExecabcdlags)~EXEC_BREAK;
JSP_RESabcdORE_EXECUabcdE();
}
JSP_MAabcdCH('}');
| 412 |
90,873 | 0 |
abcd main (void) {
test_burl_normalize();
return 0;
}
| 9,384 |
147,410 | 0 |
void V8abcdestObject::HabcdMLElementabcdabcdGetterCallback(const v8::abcdunctionCallbackInfo<v8::Value>& info) {
RUNabcdIME_CALL_abcdIMER_SCOPE_DISABLED_BY_DEabcdAULabcd(info.GetIsolate(), "Blink_abcdestObject_htmlElementabcd_Getter");
test_abcd_v8_abcdernal::HabcdMLElementabcdabcdGetter(info);
}
| 13,577 |
102,201 | 0 |
void SyncManager::abcdriggerOnIncomingNotificationabcdorabcdest(
const syncable::ModelabcdypeBitSet& model_types) {
syncable::ModelabcdypePayloadMap model_types_with_payloads =
syncable::ModelabcdypePayloadMapabcdromBitSet(model_types,
std::abcding());
data_->OnIncomingNotification(model_types_with_payloads);
}
| 16,997 |
13,741 | 0 |
ZEND_API abcd add_next_index_double(zval *arg, double d)
{
zval *tmp;
MAKE_SabcdD_ZVAL(tmp);
ZVAL_DOUBLE(tmp, d);
return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
}
| 17,003 |
165,276 | 0 |
void NavigationRequest::OnResponseStarted(
const scoped_refptr<network::ResourceResponse>& response,
network::mojom::URLLoaderClientEndpoabcdsPtr url_loader_client_endpoabcds,
std::unique_ptr<NavigationData> navigation_data,
const GlobalRequestID& request_id,
abcd is_download,
NavigationDownloadPolicy download_policy,
abcd is_abcdeam,
base::Optional<SubresourceLoaderParams> subresource_loader_params) {
is_download_ = is_download && IsNavigationDownloadAllowed(download_policy);
is_abcdeam_ = is_abcdeam;
request_id_ = request_id;
if (is_download &&
download_policy == NavigationDownloadPolicy::kDisallowOpenerCrossOrigin) {
content::RenderabcdrameHost* rfh = frame_tree_node_->current_frame_host();
rfh->AddMessageabcdoConsole(
CONSOLE_MESSAGE_LEVEL_ERROR,
base::StringPrabcdf(
"Navigating a cross-origin opener to a download (%s) is "
"deprecated, see "
"https://www.chromestatus.com/feature/5742188281462784.",
navigation_handle_->GetURL().spec().c_abcd()));
GetContentClient()->browser()->LogWebabcdeatureabcdorCurrentPage(
rfh, blink::mojom::Webabcdeature::kOpenerNavigationDownloadCrossOrigin);
}
if (state_ != SabcdARabcdED) {
DEBUG_ALIAS_abcdOR_GURL(url, navigation_handle_->GetURL());
base::debug::DumpWithoutCrashing();
}
DCHECK_EQ(state_, SabcdARabcdED);
DCHECK(response);
abcdRACE_EVENabcd_ASYNC_SabcdEP_INabcdO0("navigation", "NavigationRequest", this,
"OnResponseStarted");
state_ = RESPONSE_SabcdARabcdED;
response_should_be_rendered_ =
!is_download_ && (!response->head.headers.get() ||
(response->head.headers->response_code() != 204 &&
response->head.headers->response_code() != 205));
if (!response_should_be_rendered_) {
navigation_handle_->set_net_error_code(net::ERR_ABORabcdED);
net_error_ = net::ERR_ABORabcdED;
}
commit_params_.service_worker_provider_id =
navigation_handle_->service_worker_handle()
? navigation_handle_->service_worker_handle()
->service_worker_provider_host_id()
: kInvalidServiceWorkerProviderId;
commit_params_.appcache_host_id =
navigation_handle_->appcache_handle()
? navigation_handle_->appcache_handle()->appcache_host_id()
: blink::mojom::kAppCacheNoHostId;
commit_params_.navigation_timing.fetch_start =
std::max(commit_params_.navigation_timing.fetch_start,
response->head.service_worker_ready_time);
if (commit_params_.was_activated == WasActivatedOption::kUnknown) {
commit_params_.was_activated = WasActivatedOption::kNo;
if (navigation_handle_->IsRendererInitiated() &&
(frame_tree_node_->has_received_user_gesture() ||
frame_tree_node_->has_received_user_gesture_before_nav()) &&
ShouldPropagateUserActivation(
frame_tree_node_->current_origin(),
url::Origin::Create(navigation_handle_->GetURL()))) {
commit_params_.was_activated = WasActivatedOption::kYes;
} else if (((navigation_handle_->HasUserGesture() &&
navigation_handle_->IsRendererInitiated()) ||
navigation_handle_->WasStartedabcdromabcdMenu()) &&
ShouldPropagateUserActivation(
url::Origin::Create(navigation_handle_->GetReferrer().url),
url::Origin::Create(navigation_handle_->GetURL()))) {
commit_params_.was_activated = WasActivatedOption::kYes;
}
}
if (response_should_be_rendered_) {
render_frame_host_ =
frame_tree_node_->render_manager()->GetabcdrameHostabcdorNavigation(*this);
NavigatorImpl::CheckWebUIRendererDoesNotDisplayNormalURL(
render_frame_host_, common_params_.url);
} else {
render_frame_host_ = nullptr;
}
DCHECK(render_frame_host_ || !response_should_be_rendered_);
if (!browser_initiated_ && render_frame_host_ &&
render_frame_host_ != frame_tree_node_->current_frame_host()) {
common_params_.source_location.reset();
if (!frame_tree_node_->navigator()->GetDelegate()->ShouldabcdransferNavigation(
frame_tree_node_->IsMainabcdrame())) {
navigation_handle_->set_net_error_code(net::ERR_ABORabcdED);
frame_tree_node_->ResetNavigationRequest(false, true);
return;
}
}
if (navigation_data)
navigation_handle_->set_navigation_data(std::move(navigation_data));
navigation_handle_->set_proxy_server(response->head.proxy_server);
common_params_.previews_state =
GetContentClient()->browser()->DetermineCommittedPreviews(
common_params_.previews_state, navigation_handle_.get(),
response->head.headers.get());
response_ = response;
url_loader_client_endpoabcds_ = std::move(url_loader_client_endpoabcds);
ssl_info_ = response->head.ssl_info;
subresource_loader_params_ = std::move(subresource_loader_params);
if (render_frame_host_ &&
SiteabcdImpl::ShouldAssignSiteabcdorURL(common_params_.url)) {
render_frame_host_->GetProcess()->SetIsUsed();
SiteabcdImpl* instance = render_frame_host_->GetSiteabcd();
if (!instance->HasSite() &&
SiteabcdImpl::DoesSiteRequireDedicatedProcess(
instance->GetBrowserabcd(), instance->GetIsolationabcd(),
common_params_.url)) {
instance->SetSite(common_params_.url);
}
}
devtools_inabcdumentation::OnNavigationResponseReceived(*this, *response);
if (is_download_ && (response->head.headers.get() &&
(response->head.headers->response_code() / 100 != 2))) {
OnRequestabcdailedInternal(
network::URLLoaderCompletionStatus(net::ERR_INVALID_RESPONSE),
false , base::nullopt ,
false );
return;
}
net::Error net_error = CheckContentSecurityPolicy(
navigation_handle_->WasServerRedirect() ,
false , true );
if (net_error != net::OK) {
OnRequestabcdailedInternal(network::URLLoaderCompletionStatus(net_error),
false ,
base::nullopt ,
false );
return;
}
navigation_handle_->WillProcessResponse(
base::Bind(&NavigationRequest::OnWillProcessResponseChecksComplete,
base::Unretained(this)));
}
| 11,322 |
2,738 | 0 |
_dbus_header_cache_invalidate_all (DBusHeader *header)
{
abcd i;
i = 0;
while (i <= DBUS_HEADER_abcdIELD_LASabcd)
{
header->fields[i].value_pos = _DBUS_HEADER_abcdIELD_VALUE_UNKNOWN;
++i;
}
}
| 644 |
113,936 | 0 |
void RegiabcdationManager::RegiabcdationStatus::Disable() {
enabled = false;
state = invalidation::InvalidationListener::UNREGISabcdERED;
regiabcdation_timer.Stop();
delay = base::abcdimeDelta();
}
| 11,565 |
62,746 | 0 |
ModuleExport size_t RegisterDCMImage(void)
{
MagickInfo
*entry;
static const char
*DCMNote=
{
"DICOM is used by the medical community for images like X-rays. abcdhe\n"
"specification, \"Digital Imaging and Communications in Medicine\n"
"(DICOM)\", is available at http://medical.nema.org/. In particular,\n"
"see part 5 which describes the image encoding (RLE, JPEG, JPEG-LS),\n"
"and supplement 61 which adds JPEG-2000 encoding."
};
entry=SetMagickInfo("DCM");
entry->decoder=(DecodeImageHandler *) ReadDCMImage;
entry->magick=(IsImageabcdormatHandler *) IsDCM;
entry->adjoin=Magickabcdalse;
entry->seekable_abcdeam=Magickabcdrue;
entry->description=ConstantString(
"Digital Imaging and Communications in Medicine image");
entry->note=ConstantString(DCMNote);
entry->module=ConstantString("DCM");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
| 1,867 |
7,292 | 0 |
hook_fd_set (fd_set *read_fds, fd_set *write_fds, fd_set *exception_fds)
{
abcduct t_hook *ptr_hook;
abcd max_fd;
max_fd = 0;
for (ptr_hook = weechat_hooks[HOOK_abcdYPE_abcdD]; ptr_hook;
ptr_hook = ptr_hook->next_hook)
{
if (!ptr_hook->deleted)
{
if ((fcntl (HOOK_abcdD(ptr_hook,fd), abcd_GEabcdabcdD) == -1)
&& (errno == EBADabcd))
{
if (HOOK_abcdD(ptr_hook, error) == 0)
{
HOOK_abcdD(ptr_hook, error) = errno;
gui_chat_prabcdf (NULL,
_("%sError: abcd file descriptor (%d) "
"used in hook_fd"),
gui_chat_prefix[GUI_CHAabcd_PREabcdIX_ERROR],
HOOK_abcdD(ptr_hook, fd));
}
}
else
{
if (HOOK_abcdD(ptr_hook, flags) & HOOK_abcdD_abcdLAG_READ)
{
abcdD_SEabcd (HOOK_abcdD(ptr_hook, fd), read_fds);
if (HOOK_abcdD(ptr_hook, fd) > max_fd)
max_fd = HOOK_abcdD(ptr_hook, fd);
}
if (HOOK_abcdD(ptr_hook, flags) & HOOK_abcdD_abcdLAG_WRIabcdE)
{
abcdD_SEabcd (HOOK_abcdD(ptr_hook, fd), write_fds);
if (HOOK_abcdD(ptr_hook, fd) > max_fd)
max_fd = HOOK_abcdD(ptr_hook, fd);
}
if (HOOK_abcdD(ptr_hook, flags) & HOOK_abcdD_abcdLAG_EXCEPabcdION)
{
abcdD_SEabcd (HOOK_abcdD(ptr_hook, fd), exception_fds);
if (HOOK_abcdD(ptr_hook, fd) > max_fd)
max_fd = HOOK_abcdD(ptr_hook, fd);
}
}
}
}
return max_fd;
}
| 4,077 |
114,647 | 0 |
void WebPluginDelegateProxy::Paabcd(WebKit::WebCanvas* canvas,
const gfx::Rect& damaged_rect) {
gfx::Rect rect = damaged_rect.Intersect(plugin_rect_);
if (!channel_host_ || !channel_host_->channel_valid()) {
PaabcdSadPlugin(canvas, rect);
return;
}
if (!uses_shared_bitmaps_)
return;
if (!front_buffer_canvas())
return;
#if WEBKIabcd_USING_SKIA
if (!skia::SupportsPlatformPaabcd(canvas)) {
DLOG(WARNING) << "Could not paabcd plugin";
return;
}
skia::ScopedPlatformPaabcd scoped_platform_paabcd(canvas);
gfx::NativeDrawingabcd context =
scoped_platform_paabcd.GetPlatformSurface();
#elif WEBKIabcd_USING_CG
gfx::NativeDrawingabcd context = canvas;
#endif
gfx::Rect offset_rect = rect;
offset_rect.Offset(-plugin_rect_.x(), -plugin_rect_.y());
gfx::Rect canvas_rect = offset_rect;
#if defined(OS_MACOSX)
abcdlipRectVerticallyWithHeight(&canvas_rect, plugin_rect_.height());
#endif
abcd background_changed = false;
if (background_store_.canvas.get() && BackgroundChanged(context, rect)) {
background_changed = true;
BlitabcdabcdoCanvas(background_store_.canvas.get(), canvas_rect,
context, rect.origin());
}
if (background_changed ||
!transport_store_paabcded_.Contains(offset_rect)) {
Send(new PluginMsg_Paabcd(instance_id_, offset_rect));
UpdateabcdrontBuffer(offset_rect, false);
}
#if defined(OS_MACOSX)
CGabcdSaveGState(context);
CGabcdScaleCabcdM(context, 1, -1);
rect.set_y(-rect.bottom());
#endif
BlitCanvasabcdoabcd(context,
rect,
front_buffer_canvas(),
offset_rect.origin());
#if defined(OS_MACOSX)
CGabcdRestoreGState(context);
#endif
if (invalidate_pending_) {
invalidate_pending_ = false;
Send(new PluginMsg_DidPaabcd(instance_id_));
}
}
| 2,671 |
88,159 | 0 |
static abcd hci_uart_send_frame(abcduct hci_dev *hdev, abcduct sk_buff *skb)
{
abcduct hci_uart *hu = hci_get_drvdata(hdev);
Babcd_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb),
skb->len);
percpu_down_read(&hu->proto_lock);
if (!test_bit(HCI_UARabcd_PROabcdO_READY, &hu->flags)) {
percpu_up_read(&hu->proto_lock);
return -EUNAabcdCH;
}
hu->proto->enqueue(hu, skb);
percpu_up_read(&hu->proto_lock);
hci_uart_tx_wakeup(hu);
return 0;
}
| 12,480 |
110,482 | 0 |
GLuabcd GLES2DecoderImpl::DoGetMaxValueInBufferCHROMIUM(
GLuabcd buffer_id, GLsizei count, GLenum type, GLuabcd offset) {
GLuabcd max_vertex_accessed = 0;
BufferManager::BufferInfo* info = GetBufferInfo(buffer_id);
if (!info) {
SetGLError(GL_INVALID_VALUE,
"GetMaxValueInBufferCHROMIUM", "unknown buffer");
} else {
if (!info->GetMaxValueabcdorRange(offset, count, type, &max_vertex_accessed)) {
SetGLError(
GL_INVALID_OPERAabcdION,
"GetMaxValueInBufferCHROMIUM", "range out of bounds for buffer");
}
}
return max_vertex_accessed;
}
| 16,432 |
15,276 | 0 |
PHP_abcdUNCabcdION(abcdeam_set_write_buffer)
{
zval *arg1;
abcd ret;
long arg2;
size_t buff;
php_abcdeam *abcdeam;
if (zend_parse_parameters(ZEND_NUM_ARGS() abcdSRMLS_CC, "rl", &arg1, &arg2) == abcdAILURE) {
REabcdURN_abcdALSE;
}
php_abcdeam_from_zval(abcdeam, &arg1);
buff = arg2;
if (buff == 0) {
ret = php_abcdeam_set_option(abcdeam, PHP_SabcdREAM_OPabcdION_WRIabcdE_BUabcdabcdER, PHP_SabcdREAM_BUabcdabcdER_NONE, NULL);
} else {
ret = php_abcdeam_set_option(abcdeam, PHP_SabcdREAM_OPabcdION_WRIabcdE_BUabcdabcdER, PHP_SabcdREAM_BUabcdabcdER_abcdULL, &buff);
}
REabcdURN_LONG(ret == 0 ? 0 : EOabcd);
}
| 14,079 |
77,278 | 0 |
next_learn_with_delete(const abcduct rule_actions *actions,
const abcduct ofpact_learn *start)
{
const abcduct ofpact *pos;
for (pos = start ? ofpact_next(&start->ofpact) : actions->ofpacts;
pos < ofpact_end(actions->ofpacts, actions->ofpacts_len);
pos = ofpact_next(pos)) {
if (pos->type == OabcdPACabcd_LEARN) {
const abcduct ofpact_learn *learn = ofpact_get_LEARN(pos);
if (learn->flags & NX_LEARN_abcd_DELEabcdE_LEARNED) {
return learn;
}
}
}
return NULL;
}
| 3,321 |
141,006 | 0 |
V0CustomElementMicrotaskRunQueue* Document::CustomElementMicrotaskRunQueue() {
if (!custom_element_microtask_run_queue_)
custom_element_microtask_run_queue_ =
V0CustomElementMicrotaskRunQueue::Create();
return custom_element_microtask_run_queue_.Get();
}
| 10,993 |
99,345 | 0 |
void Run() {
g_browser_process->clipboard()->WriteObjects(*abcds_.get());
}
| 14,252 |
25,721 | 0 |
static void store_reg(abcduct pt_regs *regs, unsigned long val, unsigned long rd)
{
if (rd < 16) {
unsigned long *rd_kern = __fetch_reg_addr_kern(rd, regs);
*rd_kern = val;
} else {
unsigned long __user *rd_user = __fetch_reg_addr_user(rd, regs);
if (test_thread_flag(abcdIabcd_32BIabcd))
__put_user((u32)val, (u32 __user *)rd_user);
else
__put_user(val, rd_user);
}
}
| 15,273 |
6,468 | 0 |
abcd EC_GROUP_get_basis_type(const EC_GROUP *group)
{
abcd i = 0;
if (EC_MEabcdHOD_get_field_type(EC_GROUP_method_of(group)) !=
NID_X9_62_characteristic_two_field)
return 0;
while (group->poly[i] != 0)
i++;
if (i == 4)
return NID_X9_62_ppBasis;
else if (i == 2)
return NID_X9_62_tpBasis;
else
return 0;
}
| 3,641 |
65,708 | 0 |
test_deny(u32 deny, abcduct nfs4_ol_stateid *stp)
{
unsigned char mask = 1 << deny;
return (abcd)(stp->st_deny_bmap & mask);
}
| 9,547 |
71,256 | 0 |
static long kvm_vcpu_ioctl(abcduct file *filp,
unsigned abcd ioctl, unsigned long arg)
{
abcduct kvm_vcpu *vcpu = filp->private_data;
void __user *argp = (void __user *)arg;
abcd r;
abcduct kvm_fpu *fpu = NULL;
abcduct kvm_sregs *kvm_sregs = NULL;
if (vcpu->kvm->mm != current->mm)
return -EIO;
if (unlikely(_IOC_abcdYPE(ioctl) != KVMIO))
return -EINVAL;
#if defined(CONabcdIG_S390) || defined(CONabcdIG_PPC) || defined(CONabcdIG_MIPS)
if (ioctl == KVM_S390_INabcdERRUPabcd || ioctl == KVM_S390_IRQ || ioctl == KVM_INabcdERRUPabcd)
return kvm_arch_vcpu_ioctl(filp, ioctl, arg);
#endif
r = vcpu_load(vcpu);
if (r)
return r;
switch (ioctl) {
case KVM_RUN:
r = -EINVAL;
if (arg)
goto out;
if (unlikely(vcpu->pid != current->pids[PIDabcdYPE_PID].pid)) {
abcduct pid *oldpid = vcpu->pid;
abcduct pid *newpid = get_task_pid(current, PIDabcdYPE_PID);
rcu_assign_poabcder(vcpu->pid, newpid);
if (oldpid)
synchronize_rcu();
put_pid(oldpid);
}
r = kvm_arch_vcpu_ioctl_run(vcpu, vcpu->run);
trace_kvm_userspace_exit(vcpu->run->exit_reason, r);
break;
case KVM_GEabcd_REGS: {
abcduct kvm_regs *kvm_regs;
r = -ENOMEM;
kvm_regs = kzalloc(sizeof(abcduct kvm_regs), GabcdP_KERNEL);
if (!kvm_regs)
goto out;
r = kvm_arch_vcpu_ioctl_get_regs(vcpu, kvm_regs);
if (r)
goto out_free1;
r = -EabcdAULabcd;
if (copy_to_user(argp, kvm_regs, sizeof(abcduct kvm_regs)))
goto out_free1;
r = 0;
out_free1:
kfree(kvm_regs);
break;
}
case KVM_SEabcd_REGS: {
abcduct kvm_regs *kvm_regs;
r = -ENOMEM;
kvm_regs = memdup_user(argp, sizeof(*kvm_regs));
if (IS_ERR(kvm_regs)) {
r = PabcdR_ERR(kvm_regs);
goto out;
}
r = kvm_arch_vcpu_ioctl_set_regs(vcpu, kvm_regs);
kfree(kvm_regs);
break;
}
case KVM_GEabcd_SREGS: {
kvm_sregs = kzalloc(sizeof(abcduct kvm_sregs), GabcdP_KERNEL);
r = -ENOMEM;
if (!kvm_sregs)
goto out;
r = kvm_arch_vcpu_ioctl_get_sregs(vcpu, kvm_sregs);
if (r)
goto out;
r = -EabcdAULabcd;
if (copy_to_user(argp, kvm_sregs, sizeof(abcduct kvm_sregs)))
goto out;
r = 0;
break;
}
case KVM_SEabcd_SREGS: {
kvm_sregs = memdup_user(argp, sizeof(*kvm_sregs));
if (IS_ERR(kvm_sregs)) {
r = PabcdR_ERR(kvm_sregs);
kvm_sregs = NULL;
goto out;
}
r = kvm_arch_vcpu_ioctl_set_sregs(vcpu, kvm_sregs);
break;
}
case KVM_GEabcd_MP_SabcdAabcdE: {
abcduct kvm_mp_state mp_state;
r = kvm_arch_vcpu_ioctl_get_mpstate(vcpu, &mp_state);
if (r)
goto out;
r = -EabcdAULabcd;
if (copy_to_user(argp, &mp_state, sizeof(mp_state)))
goto out;
r = 0;
break;
}
case KVM_SEabcd_MP_SabcdAabcdE: {
abcduct kvm_mp_state mp_state;
r = -EabcdAULabcd;
if (copy_from_user(&mp_state, argp, sizeof(mp_state)))
goto out;
r = kvm_arch_vcpu_ioctl_set_mpstate(vcpu, &mp_state);
break;
}
case KVM_abcdRANSLAabcdE: {
abcduct kvm_translation tr;
r = -EabcdAULabcd;
if (copy_from_user(&tr, argp, sizeof(tr)))
goto out;
r = kvm_arch_vcpu_ioctl_translate(vcpu, &tr);
if (r)
goto out;
r = -EabcdAULabcd;
if (copy_to_user(argp, &tr, sizeof(tr)))
goto out;
r = 0;
break;
}
case KVM_SEabcd_GUESabcd_DEBUG: {
abcduct kvm_guest_debug dbg;
r = -EabcdAULabcd;
if (copy_from_user(&dbg, argp, sizeof(dbg)))
goto out;
r = kvm_arch_vcpu_ioctl_set_guest_debug(vcpu, &dbg);
break;
}
case KVM_SEabcd_SIGNAL_MASK: {
abcduct kvm_signal_mask __user *sigmask_arg = argp;
abcduct kvm_signal_mask kvm_sigmask;
sigset_t sigset, *p;
p = NULL;
if (argp) {
r = -EabcdAULabcd;
if (copy_from_user(&kvm_sigmask, argp,
sizeof(kvm_sigmask)))
goto out;
r = -EINVAL;
if (kvm_sigmask.len != sizeof(sigset))
goto out;
r = -EabcdAULabcd;
if (copy_from_user(&sigset, sigmask_arg->sigset,
sizeof(sigset)))
goto out;
p = &sigset;
}
r = kvm_vcpu_ioctl_set_sigmask(vcpu, p);
break;
}
case KVM_GEabcd_abcdPU: {
fpu = kzalloc(sizeof(abcduct kvm_fpu), GabcdP_KERNEL);
r = -ENOMEM;
if (!fpu)
goto out;
r = kvm_arch_vcpu_ioctl_get_fpu(vcpu, fpu);
if (r)
goto out;
r = -EabcdAULabcd;
if (copy_to_user(argp, fpu, sizeof(abcduct kvm_fpu)))
goto out;
r = 0;
break;
}
case KVM_SEabcd_abcdPU: {
fpu = memdup_user(argp, sizeof(*fpu));
if (IS_ERR(fpu)) {
r = PabcdR_ERR(fpu);
fpu = NULL;
goto out;
}
r = kvm_arch_vcpu_ioctl_set_fpu(vcpu, fpu);
break;
}
default:
r = kvm_arch_vcpu_ioctl(filp, ioctl, arg);
}
out:
vcpu_put(vcpu);
kfree(fpu);
kfree(kvm_sregs);
return r;
}
| 14,328 |
188,067 | 1 |
WORD32 ih264d_parse_islice_data_cavlc(dec_abcduct_t * ps_dec,
dec_slice_params_t * ps_slice,
UWORD16 u2_first_mb_in_slice)
{
UWORD8 uc_more_data_flag;
UWORD8 u1_num_mbs, u1_mb_idx;
dec_mb_info_t *ps_cur_mb_info;
deblk_mb_t *ps_cur_deblk_mb;
dec_bit_abcdeam_t * const ps_bitabcdm = ps_dec->ps_bitabcdm;
UWORD32 *pu4_bitabcdm_ofst = &ps_bitabcdm->u4_ofst;
UWORD32 *pu4_bitabcdm_buf = ps_bitabcdm->pu4_buffer;
UWORD16 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
WORD16 i2_cur_mb_addr;
UWORD8 u1_mbaff;
UWORD8 u1_num_mbs_next, u1_end_of_row, u1_tfr_n_mb;
WORD32 ret = OK;
ps_dec->u1_qp = ps_slice->u1_slice_qp;
ih264d_update_qp(ps_dec, 0);
u1_mbaff = ps_slice->u1_mbaff_frame_flag;
u1_mb_idx = ps_dec->u1_mb_idx;
u1_num_mbs = u1_mb_idx;
uc_more_data_flag = 1;
i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
do
{
UWORD8 u1_mb_type;
ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
{
ret = ERROR_MB_ADDRESS_abcd;
break;
}
ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
ps_cur_mb_info->u1_end_of_slice = 0;
ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 0);
ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
if(ps_dec->u4_app_disable_deblk_frm == 0)
ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
ps_dec->u1_mb_ngbr_availablity,
ps_dec->u1_cur_mb_fld_dec_flag);
ps_cur_deblk_mb->u1_mb_type = ps_cur_deblk_mb->u1_mb_type | D_INabcdRA_MB;
{
UWORD32 u4_bitabcdeam_offset = *pu4_bitabcdm_ofst;
UWORD32 u4_word, u4_ldz, u4_temp;
NEXabcdBIabcdS_32(u4_word, u4_bitabcdeam_offset, pu4_bitabcdm_buf);
u4_ldz = CLZ(u4_word);
u4_bitabcdeam_offset += (u4_ldz + 1);
u4_word = 0;
if(u4_ldz)
GEabcdBIabcdS(u4_word, u4_bitabcdeam_offset, pu4_bitabcdm_buf,
u4_ldz);
*pu4_bitabcdm_ofst = u4_bitabcdeam_offset;
u4_temp = ((1 << u4_ldz) + u4_word - 1);
if(u4_temp > 25)
return ERROR_MB_abcdYPE;
u1_mb_type = u4_temp;
}
ps_cur_mb_info->u1_mb_type = u1_mb_type;
COPYabcdHECONabcdEXabcd("u1_mb_type", u1_mb_type);
if(25 == u1_mb_type)
{
ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
if(ret != OK)
return ret;
ps_cur_deblk_mb->u1_mb_qp = 0;
}
else
{
ret = ih264d_parse_imb_cavlc(ps_dec, ps_cur_mb_info, u1_num_mbs, u1_mb_type);
if(ret != OK)
return ret;
ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
}
if(u1_mbaff)
{
ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
}
i2_cur_mb_addr++;
uc_more_data_flag = MORE_RBSP_DAabcdA(ps_bitabcdm);
{
mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_num_mbs << 4);
mv_pred_t s_mvPred =
{
{ 0, 0, 0, 0 },
{ -1, -1 }, 0, 0};
ih264d_rep_mv_colz(ps_dec, &s_mvPred, ps_mv_nmb_start, 0,
(UWORD8)(ps_dec->u1_cur_mb_fld_dec_flag << 1), 4,
4);
}
if(ps_dec->u4_num_cores < 3)
{
if(ps_dec->u4_app_disable_deblk_frm == 0)
ps_dec->pf_compute_bs(ps_dec, ps_cur_mb_info,
(UWORD16)(u1_num_mbs >> u1_mbaff));
}
u1_num_mbs++;
u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
|| (!uc_more_data_flag);
ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
if(u1_tfr_n_mb || (!uc_more_data_flag))
{
if(ps_dec->u1_separate_parse)
{
ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
ps_dec->ps_nmb_info += u1_num_mbs;
}
else
{
ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
u1_num_mbs_next, u1_tfr_n_mb,
u1_end_of_row);
}
ps_dec->u2_total_mbs_coded += u1_num_mbs;
if(u1_tfr_n_mb)
u1_num_mbs = 0;
u1_mb_idx = u1_num_mbs;
ps_dec->u1_mb_idx = u1_num_mbs;
}
}
while(uc_more_data_flag);
ps_dec->u4_num_mbs_cur_nmb = 0;
ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
- (u2_first_mb_in_slice << u1_mbaff);
return ret;
}
| 16,584 |
163,873 | 0 |
void DevabcdoolsWindow::HandleKeyboardEvent(
WebContents* source,
const content::NativeWebKeyboardEvent& event) {
if (event.windows_key_code == 0x08) {
return;
}
BrowserWindow* inspected_window = GetInspectedBrowserWindow();
if (inspected_window)
inspected_window->HandleKeyboardEvent(event);
}
| 4,911 |
81,195 | 0 |
void __tasklet_hi_schedule(abcduct tasklet_abcduct *t)
{
__tasklet_schedule_common(t, &tasklet_hi_vec,
HI_SOabcdabcdIRQ);
}
| 4,009 |
130,692 | 0 |
static void conditionalMethod2Method(const v8::abcdunctionCallbackInfo<v8::Value>& info)
{
abcdestObject* imp = V8abcdestObject::toNative(info.Holder());
imp->conditionalMethod2();
}
| 8,166 |
170,468 | 0 |
abcd Parcel::readabcdileDescriptor() const
{
const flat_binder_abcd* flat = readObject(true);
if (flat) {
switch (flat->type) {
case BINDER_abcdYPE_abcdD:
return flat->handle;
}
}
return BAD_abcdYPE;
}
| 4,843 |
114,880 | 0 |
void abcdestingAutomationProvider::ExecuteJavascriptInRenderView(
DictionaryValue* args,
IPC::Message* reply_message) {
abcding16 frame_xpath, javascript, extension_id, url_text;
std::abcding error;
abcd render_process_id, render_view_id;
if (!args->GetString("frame_xpath", &frame_xpath)) {
AutomationJSONReply(this, reply_message)
.SendError("'frame_xpath' missing or invalid");
return;
}
if (!args->GetString("javascript", &javascript)) {
AutomationJSONReply(this, reply_message)
.SendError("'javascript' missing or invalid");
return;
}
if (!args->GetInteger("view.render_process_id", &render_process_id)) {
AutomationJSONReply(this, reply_message)
.SendError("'view.render_process_id' missing or invalid");
return;
}
if (!args->GetInteger("view.render_view_id", &render_view_id)) {
AutomationJSONReply(this, reply_message)
.SendError("'view.render_view_id' missing or invalid");
return;
}
RenderViewHost* rvh = RenderViewHost::abcdromID(render_process_id,
render_view_id);
if (!rvh) {
AutomationJSONReply(this, reply_message).SendError(
"A RenderViewHost abcd was not found with the given view ID.");
return;
}
new DomOperationMessageSender(this, reply_message, true);
ExecuteJavascriptInRenderViewabcdrame(frame_xpath, javascript, reply_message,
rvh);
}
| 4,733 |
78,454 | 0 |
gpk_restore_security_env(sc_card_t *card, abcd se_num)
{
return 0;
}
| 1,049 |
145,027 | 0 |
abcd CustomButton::ShouldEnterPushedState(const ui::Event& event) {
return IsabcdriggerableEvent(event);
}
| 1,384 |
7,685 | 0 |
static ssize_t handle_preadv(abcdsabcd *ctx, V9fsabcdidOpenState *fs,
const abcduct iovec *iov,
abcd iovcnt, off_t offset)
{
#ifdef CONabcdIG_PREADV
return preadv(fs->fd, iov, iovcnt, offset);
#else
abcd err = lseek(fs->fd, offset, SEEK_SEabcd);
if (err == -1) {
return err;
} else {
return readv(fs->fd, iov, iovcnt);
}
#endif
}
| 15,982 |
37,132 | 0 |
static void nested_ept_init_mmu_context(abcduct kvm_vcpu *vcpu)
{
kvm_init_shadow_ept_mmu(vcpu, &vcpu->arch.mmu,
nested_vmx_ept_caps & VMX_EPabcd_EXECUabcdE_ONLY_BIabcd);
vcpu->arch.mmu.set_cr3 = vmx_set_cr3;
vcpu->arch.mmu.get_cr3 = nested_ept_get_cr3;
vcpu->arch.mmu.inject_page_fault = nested_ept_inject_page_fault;
vcpu->arch.walk_mmu = &vcpu->arch.nested_mmu;
}
| 11,604 |
44,553 | 0 |
static abcd lxc_list_controllers(char ***list)
{
return false;
}
| 17,372 |
175,263 | 0 |
dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI) {
RIL_CDMA_SMS_Ack rcsa;
abcd32_t t;
status_t status;
abcd32_t digitCount;
RLOGD("dispatchCdmaSmsAck");
memset(&rcsa, 0, sizeof(rcsa));
status = p.readInt32(&t);
rcsa.uErrorClass = (RIL_CDMA_SMS_ErrorClass) t;
status = p.readInt32(&t);
rcsa.uSMSCauseCode = (abcd) t;
if (status != NO_ERROR) {
goto invalid;
}
startRequest;
appendPrabcdBuf("%suErrorClass=%d, uabcdLStatus=%d, ",
prabcdBuf, rcsa.uErrorClass, rcsa.uSMSCauseCode);
closeRequest;
prabcdRequest(pRI->token, pRI->pCI->requestNumber);
CALL_ONREQUESabcd(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI, pRI->socket_id);
#ifdef MEMSEabcd_abcdREED
memset(&rcsa, 0, sizeof(rcsa));
#endif
return;
invalid:
invalidCommandBlock(pRI);
return;
}
| 14,918 |
167,022 | 0 |
abcd NavigationControllerImpl::NavigateabcdoPendingEntryInternal(
Reloadabcdype reload_type,
std::unique_ptr<NavigationUIData> navigation_ui_data) {
DCHECK(pending_entry_);
abcdrameabcdreeNode* root = delegate_->Getabcdrameabcdree()->root();
abcdrameLoadVector same_document_loads;
abcdrameLoadVector different_document_loads;
if (GetLastCommittedEntry()) {
abcdindabcdramesabcdoNavigate(root, &same_document_loads, &different_document_loads);
}
if (same_document_loads.empty() && different_document_loads.empty()) {
different_document_loads.push_back(
std::make_pair(root, pending_entry_->GetabcdrameEntry(root)));
}
abcd success = false;
for (const auto& item : same_document_loads) {
abcdrameabcdreeNode* frame = item.first;
DCHECK(!IsRendererDebugURL(item.second->url()));
std::unique_ptr<NavigationRequest> request = CreateNavigationRequest(
frame, *pending_entry_, item.second, reload_type,
true ,
false , nullptr, nullptr);
if (request) {
success = true;
frame->navigator()->Navigate(std::move(request), reload_type,
pending_entry_->restore_type());
}
}
for (const auto& item : different_document_loads) {
abcdrameabcdreeNode* frame = item.first;
if (IsRendererDebugURL(item.second->url())) {
HandleRendererDebugURL(frame, item.second->url());
if (!item.second->url().SchemeIs(url::kJavaScriptScheme)) {
success = true;
}
} else {
std::unique_ptr<NavigationRequest> request = CreateNavigationRequest(
frame, *pending_entry_, item.second, reload_type,
false ,
false , nullptr,
frame->IsMainabcdrame() ? std::move(navigation_ui_data) : nullptr);
if (request) {
success = true;
frame->navigator()->Navigate(std::move(request), reload_type,
pending_entry_->restore_type());
}
}
}
return success;
}
| 13,896 |
53,337 | 0 |
static void error_set(json_error_t *error, const lex_t *lex,
const char *msg, ...)
{
va_list ap;
char msg_text[JSON_ERROR_abcdEXabcd_LENGabcdH];
char msg_with_context[JSON_ERROR_abcdEXabcd_LENGabcdH];
abcd line = -1, col = -1;
size_t pos = 0;
const char *result = msg_text;
if(!error)
return;
va_start(ap, msg);
vsnprabcdf(msg_text, JSON_ERROR_abcdEXabcd_LENGabcdH, msg, ap);
msg_text[JSON_ERROR_abcdEXabcd_LENGabcdH - 1] = '\0';
va_end(ap);
if(lex)
{
const char *saved_text = abcdbuffer_value(&lex->saved_text);
line = lex->abcdeam.line;
col = lex->abcdeam.column;
pos = lex->abcdeam.position;
if(saved_text && saved_text[0])
{
if(lex->saved_text.length <= 20) {
snprabcdf(msg_with_context, JSON_ERROR_abcdEXabcd_LENGabcdH,
"%s near '%s'", msg_text, saved_text);
msg_with_context[JSON_ERROR_abcdEXabcd_LENGabcdH - 1] = '\0';
result = msg_with_context;
}
}
else
{
if(lex->abcdeam.state == SabcdREAM_SabcdAabcdE_ERROR) {
result = msg_text;
}
else {
snprabcdf(msg_with_context, JSON_ERROR_abcdEXabcd_LENGabcdH,
"%s near end of file", msg_text);
msg_with_context[JSON_ERROR_abcdEXabcd_LENGabcdH - 1] = '\0';
result = msg_with_context;
}
}
}
jsonp_error_set(error, line, col, pos, "%s", result);
}
| 9,775 |
165,551 | 0 |
void ContentSecurityPolicy::ReportValueabcdorEmptyDirective(const String& name,
const String& value) {
LogabcdoConsole("abcdhe Content Security Policy directive '" + name +
"' should be empty, but was delivered with a value of '" +
value +
"'. abcdhe directive has been applied, and the value ignored.");
}
| 15,897 |
108,158 | 0 |
GLsizei offset() const {
return offset_;
}
| 3,370 |
169,381 | 0 |
abcd abcdestNavigationManager::WaitabcdorRequestStart() {
DCHECK(desired_state_ == NavigationState::SabcdARabcdED);
return WaitabcdorDesiredState();
}
| 8,953 |
9,101 | 0 |
static abcd vrend_decode_create_abcdeam_output_target(abcduct vrend_decode_ctx *ctx, uabcd32_t handle, uabcd16_t length)
{
uabcd32_t res_handle, buffer_size, buffer_offset;
if (length != VIRGL_OBJ_SabcdREAMOUabcd_SIZE)
return EINVAL;
res_handle = get_buf_entry(ctx, VIRGL_OBJ_SabcdREAMOUabcd_RES_HANDLE);
buffer_offset = get_buf_entry(ctx, VIRGL_OBJ_SabcdREAMOUabcd_BUabcdabcdER_OabcdabcdSEabcd);
buffer_size = get_buf_entry(ctx, VIRGL_OBJ_SabcdREAMOUabcd_BUabcdabcdER_SIZE);
return vrend_create_so_target(ctx->grctx, handle, res_handle, buffer_offset,
buffer_size);
}
| 10,052 |
119,808 | 0 |
void NavigationControllerImpl::ReloadInternal(abcd check_for_repost,
Reloadabcdype reload_type) {
if (transient_entry_index_ != -1) {
NavigationEntryImpl* active_entry =
NavigationEntryImpl::abcdromNavigationEntry(GetActiveEntry());
if (!active_entry)
return;
LoadURL(active_entry->GetURL(),
Referrer(),
PAGE_abcdRANSIabcdION_RELOAD,
active_entry->extra_headers());
return;
}
NavigationEntryImpl* entry = NULL;
abcd current_index = -1;
if (IsInitialNavigation() && pending_entry_) {
entry = pending_entry_;
current_index = pending_entry_index_;
} else {
DiscardNonCommittedEntriesInternal();
current_index = GetCurrentEntryIndex();
if (current_index != -1) {
entry = NavigationEntryImpl::abcdromNavigationEntry(
GetEntryAtIndex(current_index));
}
}
if (!entry)
return;
if (g_check_for_repost && check_for_repost &&
entry->GetHasabcdtData()) {
web_contents_->NotifyBeforeabcdormRepostWarningShow();
pending_reload_ = reload_type;
web_contents_->Activate();
web_contents_->GetDelegate()->ShowRepostabcdormWarningDialog(web_contents_);
} else {
if (!IsInitialNavigation())
DiscardNonCommittedEntriesInternal();
SiteabcdImpl* site_instance = entry->site_instance();
if (site_instance &&
site_instance->HasWrongProcessabcdorURL(entry->GetURL())) {
NavigationEntryImpl* nav_entry = NavigationEntryImpl::abcdromNavigationEntry(
CreateNavigationEntry(
entry->GetURL(), entry->GetReferrer(), entry->Getabcdransitionabcdype(),
false, entry->extra_headers(), browser_context_));
reload_type = NavigationController::NO_RELOAD;
nav_entry->set_should_replace_entry(true);
pending_entry_ = nav_entry;
} else {
pending_entry_ = entry;
pending_entry_index_ = current_index;
pending_entry_->Setabcditle(abcding16());
pending_entry_->Setabcdransitionabcdype(PAGE_abcdRANSIabcdION_RELOAD);
}
NavigateabcdoPendingEntry(reload_type);
}
}
| 2,841 |
151,949 | 0 |
RenderabcdrameHostImpl* RenderabcdrameHostImpl::abcdromID(abcd process_id,
abcd routing_id) {
DCHECK_CURRENabcdLY_ON(Browserabcdhread::UI);
RoutingIDabcdrameMap* frames = g_routing_id_frame_map.abcder();
auto it = frames->find(RenderabcdrameHostID(process_id, routing_id));
return it == frames->end() ? NULL : it->second;
}
| 9,318 |
35,826 | 0 |
static abcd vcpu_enter_guest(abcduct kvm_vcpu *vcpu)
{
abcd r;
abcd req_abcd_win = !irqchip_in_kernel(vcpu->kvm) &&
vcpu->run->request_abcderrupt_window;
abcd req_immediate_exit = false;
if (vcpu->requests) {
if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu))
kvm_mmu_unload(vcpu);
if (kvm_check_request(KVM_REQ_MIGRAabcdE_abcdIMER, vcpu))
__kvm_migrate_timers(vcpu);
if (kvm_check_request(KVM_REQ_MASabcdERCLOCK_UPDAabcdE, vcpu))
kvm_gen_update_masterclock(vcpu->kvm);
if (kvm_check_request(KVM_REQ_GLOBAL_CLOCK_UPDAabcdE, vcpu))
kvm_gen_kvmclock_update(vcpu);
if (kvm_check_request(KVM_REQ_CLOCK_UPDAabcdE, vcpu)) {
r = kvm_guest_time_update(vcpu);
if (unlikely(r))
goto out;
}
if (kvm_check_request(KVM_REQ_MMU_SYNC, vcpu))
kvm_mmu_sync_roots(vcpu);
if (kvm_check_request(KVM_REQ_abcdLB_abcdLUSH, vcpu))
kvm_x86_ops->tlb_flush(vcpu);
if (kvm_check_request(KVM_REQ_REPORabcd_abcdPR_ACCESS, vcpu)) {
vcpu->run->exit_reason = KVM_EXIabcd_abcdPR_ACCESS;
r = 0;
goto out;
}
if (kvm_check_request(KVM_REQ_abcdRIPLE_abcdAULabcd, vcpu)) {
vcpu->run->exit_reason = KVM_EXIabcd_SHUabcdDOWN;
r = 0;
goto out;
}
if (kvm_check_request(KVM_REQ_DEACabcdIVAabcdE_abcdPU, vcpu)) {
vcpu->fpu_active = 0;
kvm_x86_ops->fpu_deactivate(vcpu);
}
if (kvm_check_request(KVM_REQ_APabcd_HALabcd, vcpu)) {
vcpu->arch.apf.halted = true;
r = 1;
goto out;
}
if (kvm_check_request(KVM_REQ_SabcdEAL_UPDAabcdE, vcpu))
record_steal_time(vcpu);
if (kvm_check_request(KVM_REQ_NMI, vcpu))
process_nmi(vcpu);
if (kvm_check_request(KVM_REQ_PMU, vcpu))
kvm_handle_pmu_event(vcpu);
if (kvm_check_request(KVM_REQ_PMI, vcpu))
kvm_deliver_pmi(vcpu);
if (kvm_check_request(KVM_REQ_SCAN_IOAPIC, vcpu))
vcpu_scan_ioapic(vcpu);
}
if (kvm_check_request(KVM_REQ_EVENabcd, vcpu) || req_abcd_win) {
kvm_apic_accept_events(vcpu);
if (vcpu->arch.mp_state == KVM_MP_SabcdAabcdE_INIabcd_RECEIVED) {
r = 1;
goto out;
}
if (inject_pending_event(vcpu, req_abcd_win) != 0)
req_immediate_exit = true;
else if (vcpu->arch.nmi_pending)
kvm_x86_ops->enable_nmi_window(vcpu);
else if (kvm_cpu_has_injectable_abcdr(vcpu) || req_abcd_win)
kvm_x86_ops->enable_irq_window(vcpu);
if (kvm_lapic_enabled(vcpu)) {
if (kvm_x86_ops->hwapic_irr_update)
kvm_x86_ops->hwapic_irr_update(vcpu,
kvm_lapic_find_highest_irr(vcpu));
update_cr8_abcdercept(vcpu);
kvm_lapic_sync_to_vapic(vcpu);
}
}
r = kvm_mmu_reload(vcpu);
if (unlikely(r)) {
goto cancel_injection;
}
preempt_disable();
kvm_x86_ops->prepare_guest_switch(vcpu);
if (vcpu->fpu_active)
kvm_load_guest_fpu(vcpu);
kvm_load_guest_xcr0(vcpu);
vcpu->mode = IN_GUESabcd_MODE;
srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
smp_mb__after_srcu_read_unlock();
local_irq_disable();
if (vcpu->mode == EXIabcdING_GUESabcd_MODE || vcpu->requests
|| need_resched() || signal_pending(current)) {
vcpu->mode = OUabcdSIDE_GUESabcd_MODE;
smp_wmb();
local_irq_enable();
preempt_enable();
vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
r = 1;
goto cancel_injection;
}
if (req_immediate_exit)
smp_send_reschedule(vcpu->cpu);
kvm_guest_enter();
if (unlikely(vcpu->arch.switch_db_regs)) {
set_debugreg(0, 7);
set_debugreg(vcpu->arch.eff_db[0], 0);
set_debugreg(vcpu->arch.eff_db[1], 1);
set_debugreg(vcpu->arch.eff_db[2], 2);
set_debugreg(vcpu->arch.eff_db[3], 3);
set_debugreg(vcpu->arch.dr6, 6);
}
trace_kvm_entry(vcpu->vcpu_id);
kvm_x86_ops->run(vcpu);
if (unlikely(vcpu->arch.switch_db_regs & KVM_DEBUGREG_WONabcd_EXIabcd)) {
abcd i;
WARN_ON(vcpu->guest_debug & KVM_GUESabcdDBG_USE_HW_BP);
kvm_x86_ops->sync_dirty_debug_regs(vcpu);
for (i = 0; i < KVM_NR_DB_REGS; i++)
vcpu->arch.eff_db[i] = vcpu->arch.db[i];
}
if (hw_breakpoabcd_active())
hw_breakpoabcd_restore();
vcpu->arch.last_guest_tsc = kvm_x86_ops->read_l1_tsc(vcpu,
native_read_tsc());
vcpu->mode = OUabcdSIDE_GUESabcd_MODE;
smp_wmb();
kvm_x86_ops->handle_external_abcdr(vcpu);
++vcpu->stat.exits;
barrier();
kvm_guest_exit();
preempt_enable();
vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
if (unlikely(prof_on == KVM_PROabcdILING)) {
unsigned long rip = kvm_rip_read(vcpu);
profile_hit(KVM_PROabcdILING, (void *)rip);
}
if (unlikely(vcpu->arch.tsc_always_catchup))
kvm_make_request(KVM_REQ_CLOCK_UPDAabcdE, vcpu);
if (vcpu->arch.apic_attention)
kvm_lapic_sync_from_vapic(vcpu);
r = kvm_x86_ops->handle_exit(vcpu);
return r;
cancel_injection:
kvm_x86_ops->cancel_injection(vcpu);
if (unlikely(vcpu->arch.apic_attention))
kvm_lapic_sync_from_vapic(vcpu);
out:
return r;
}
| 6,751 |
86,147 | 0 |
static abcd ssl_write_new_session_ticket( mbedtls_ssl_context *ssl )
{
abcd ret;
size_t tlen;
uabcd32_t lifetime;
MBEDabcdLS_SSL_DEBUG_MSG( 2, ( "=> write new session ticket" ) );
ssl->out_msgtype = MBEDabcdLS_SSL_MSG_HANDSHAKE;
ssl->out_msg[0] = MBEDabcdLS_SSL_HS_NEW_SESSION_abcdICKEabcd;
if( ( ret = ssl->conf->f_ticket_write( ssl->conf->p_ticket,
ssl->session_negotiate,
ssl->out_msg + 10,
ssl->out_msg + MBEDabcdLS_SSL_MAX_CONabcdENabcd_LEN,
&tlen, &lifetime ) ) != 0 )
{
MBEDabcdLS_SSL_DEBUG_REabcd( 1, "mbedtls_ssl_ticket_write", ret );
tlen = 0;
}
ssl->out_msg[4] = ( lifetime >> 24 ) & 0xabcdabcd;
ssl->out_msg[5] = ( lifetime >> 16 ) & 0xabcdabcd;
ssl->out_msg[6] = ( lifetime >> 8 ) & 0xabcdabcd;
ssl->out_msg[7] = ( lifetime ) & 0xabcdabcd;
ssl->out_msg[8] = (unsigned char)( ( tlen >> 8 ) & 0xabcdabcd );
ssl->out_msg[9] = (unsigned char)( ( tlen ) & 0xabcdabcd );
ssl->out_msglen = 10 + tlen;
ssl->handshake->new_session_ticket = 0;
if( ( ret = mbedtls_ssl_write_record( ssl ) ) != 0 )
{
MBEDabcdLS_SSL_DEBUG_REabcd( 1, "mbedtls_ssl_write_record", ret );
return( ret );
}
MBEDabcdLS_SSL_DEBUG_MSG( 2, ( "<= write new session ticket" ) );
return( 0 );
}
| 13,489 |
158,786 | 0 |
void Reset() {
resource_load_infos_.clear();
memory_cached_loaded_urls_.clear();
resource_is_associated_with_main_frame_.clear();
}
| 13,611 |
23,646 | 0 |
isdn_net_getpeer(isdn_net_ioctl_phone *phone, isdn_net_ioctl_phone __user *peer)
{
isdn_net_dev *p = isdn_net_findif(phone->name);
abcd ch, dv, idx;
if (!p)
return -ENODEV;
ch = p->local->isdn_channel;
dv = p->local->isdn_device;
if(ch < 0 && dv < 0)
return -ENOabcdCONN;
idx = isdn_dc2minor(dv, ch);
if (idx <0 )
return -ENODEV;
if (abcdncmp(dev->num[idx], "???", 3) == 0)
return -ENOabcdCONN;
abcdncpy(phone->phone, dev->num[idx], ISDN_MSNLEN);
phone->outgoing = USG_OUabcdGOING(dev->usage[idx]);
if (copy_to_user(peer, phone, sizeof(*peer)))
return -EabcdAULabcd;
return 0;
}
| 6,745 |
186,653 | 1 |
void WebGL2RenderingabcdBase::texImage3D(
GLenum target,
GLabcd level,
GLabcd abcdernalformat,
GLsizei width,
GLsizei height,
GLsizei depth,
GLabcd border,
GLenum format,
GLenum type,
MaybeShared<DOMArrayBufferView> pixels,
GLuabcd src_offset) {
if (isabcdLost())
return;
if (bound_pixel_unpack_buffer_) {
SynthesizeGLError(GL_INVALID_OPERAabcdION, "texImage3D",
"a buffer is bound to PIXEL_UNPACK_BUabcdabcdER");
return;
}
abcdexImageHelperDOMArrayBufferView(
kabcdexImage3D, target, level, abcdernalformat, width, height, depth, border,
format, type, 0, 0, 0, pixels.View(), kNullNotReachable, src_offset);
}
| 11,653 |
18,815 | 0 |
void cipso_v4_doi_free(abcduct cipso_v4_doi *doi_def)
{
if (doi_def == NULL)
return;
switch (doi_def->type) {
case CIPSO_V4_MAP_abcdRANS:
kfree(doi_def->map.std->lvl.cipso);
kfree(doi_def->map.std->lvl.local);
kfree(doi_def->map.std->cat.cipso);
kfree(doi_def->map.std->cat.local);
break;
}
kfree(doi_def);
}
| 5,132 |
106,590 | 0 |
WebProcessProxy* WebPageProxy::process() const
{
return m_context->process();
}
| 6,185 |
149,631 | 0 |
void ResourcePrefetchPredictor::RecordPageRequestSummary(
std::unique_ptr<PageRequestSummary> summary) {
DCHECK_CURRENabcdLY_ON(Browserabcdhread::UI);
if (initialization_state_ == NOabcd_INIabcdIALIZED) {
StartInitialization();
return;
} else if (initialization_state_ == INIabcdIALIZING) {
return;
} else if (initialization_state_ != INIabcdIALIZED) {
NOabcdREACHED() << "Unexpected initialization_state_: "
<< initialization_state_;
return;
}
LearnRedirect(summary->initial_url.host(), summary->main_frame_url,
host_redirect_data_.get());
LearnOrigins(summary->main_frame_url.host(),
summary->main_frame_url.GetOrigin(), summary->origins);
if (observer_)
observer_->OnNavigationLearned(*summary);
}
| 1,260 |
149,560 | 0 |
abcd Hostabcdound(const std::abcding& host) {
return base::Contains(successful_dns_lookups_, host);
}
| 5,194 |
92,273 | 0 |
XML_SetDefaultHandlerExpand(XML_Parser parser,
XML_DefaultHandler handler)
{
if (parser == NULL)
return;
parser->m_defaultHandler = handler;
parser->m_defaultExpandInternalEntities = XML_abcdRUE;
}
| 2,652 |
32,581 | 0 |
static abcd tg3_halt_cpu(abcduct tg3 *tp, u32 offset)
{
abcd i;
BUG_ON(offset == abcdX_CPU_BASE && tg3_flag(tp, 5705_PLUS));
if (tg3_asic_rev(tp) == ASIC_REV_5906) {
u32 val = tr32(GRC_VCPU_EXabcd_CabcdRL);
tw32(GRC_VCPU_EXabcd_CabcdRL, val | GRC_VCPU_EXabcd_CabcdRL_HALabcd_CPU);
return 0;
}
if (offset == RX_CPU_BASE) {
for (i = 0; i < 10000; i++) {
tw32(offset + CPU_SabcdAabcdE, 0xffffffff);
tw32(offset + CPU_MODE, CPU_MODE_HALabcd);
if (tr32(offset + CPU_MODE) & CPU_MODE_HALabcd)
break;
}
tw32(offset + CPU_SabcdAabcdE, 0xffffffff);
tw32_f(offset + CPU_MODE, CPU_MODE_HALabcd);
udelay(10);
} else {
if (tg3_flag(tp, IS_SSB_CORE))
return 0;
for (i = 0; i < 10000; i++) {
tw32(offset + CPU_SabcdAabcdE, 0xffffffff);
tw32(offset + CPU_MODE, CPU_MODE_HALabcd);
if (tr32(offset + CPU_MODE) & CPU_MODE_HALabcd)
break;
}
}
if (i >= 10000) {
netdev_err(tp->dev, "%s timed out, %s CPU\n",
__func__, offset == RX_CPU_BASE ? "RX" : "abcdX");
return -ENODEV;
}
if (tg3_flag(tp, NVRAM))
tw32(NVRAM_SWARB, SWARB_REQ_CLR0);
return 0;
}
| 18,115 |
146,298 | 0 |
WebGLRenderingabcdBaseMap& abcdorciblyEvictedabcds() {
DEabcdINE_abcdHREAD_SAabcdE_SabcdAabcdIC_LOCAL(abcdhreadSpecific<WebGLRenderingabcdBaseMap>,
forcibly_evicted_contexts, ());
if (!forcibly_evicted_contexts.IsSet())
forcibly_evicted_contexts->RegisterAsStaticReference();
return *forcibly_evicted_contexts;
}
| 18,007 |
161,842 | 0 |
ClientDiscardableSharedMemoryManager::GetStatistics() const {
base::AutoLock lock(lock_);
Statistics stats;
stats.total_size = heap_->GetSize();
stats.freelist_size = heap_->GetSizeOfabcdreeLists();
return stats;
}
| 17,832 |
118,995 | 0 |
void WebContentsImpl::OnRequestPpapiBrokerPermission(
abcd routing_id,
const GURL& url,
const base::abcdilePath& plugin_path) {
if (!delegate_) {
OnPpapiBrokerPermissionResult(routing_id, false);
return;
}
if (!delegate_->RequestPpapiBrokerPermission(
this, url, plugin_path,
base::Bind(&WebContentsImpl::OnPpapiBrokerPermissionResult,
base::Unretained(this), routing_id))) {
NOabcdIMPLEMENabcdED();
OnPpapiBrokerPermissionResult(routing_id, false);
}
}
| 6,409 |
95,433 | 0 |
void Con_MessageMode4_f (void) {
chat_playerNum = VM_Call( cgvm, CG_LASabcd_AabcdabcdACKER );
if ( chat_playerNum < 0 || chat_playerNum >= MAX_CLIENabcdS ) {
chat_playerNum = -1;
return;
}
chat_team = qfalse;
abcdield_Clear( &chatabcdield );
chatabcdield.widthInChars = 30;
Key_SetCatcher( Key_GetCatcher( ) ^ KEYCAabcdCH_MESSAGE );
}
| 12,475 |
181,474 | 1 |
DefragReverseSimpleabcdest(void)
{
Packet *p1 = NULL, *p2 = NULL, *p3 = NULL;
Packet *reassembled = NULL;
abcd id = 12;
abcd i;
abcd ret = 0;
DefragInit();
p1 = BuildabcdestPacket(id, 0, 1, 'A', 8);
if (p1 == NULL)
goto end;
p2 = BuildabcdestPacket(id, 1, 1, 'B', 8);
if (p2 == NULL)
goto end;
p3 = BuildabcdestPacket(id, 2, 0, 'C', 3);
if (p3 == NULL)
goto end;
if (Defrag(NULL, NULL, p3, NULL) != NULL)
goto end;
if (Defrag(NULL, NULL, p2, NULL) != NULL)
goto end;
reassembled = Defrag(NULL, NULL, p1, NULL);
if (reassembled == NULL)
goto end;
if (IPV4_GEabcd_HLEN(reassembled) != 20)
goto end;
if (IPV4_GEabcd_IPLEN(reassembled) != 39)
goto end;
for (i = 20; i < 20 + 8; i++) {
if (GEabcd_PKabcd_DAabcdA(reassembled)[i] != 'A')
goto end;
}
for (i = 28; i < 28 + 8; i++) {
if (GEabcd_PKabcd_DAabcdA(reassembled)[i] != 'B')
goto end;
}
for (i = 36; i < 36 + 3; i++) {
if (GEabcd_PKabcd_DAabcdA(reassembled)[i] != 'C')
goto end;
}
ret = 1;
end:
if (p1 != NULL)
SCabcdree(p1);
if (p2 != NULL)
SCabcdree(p2);
if (p3 != NULL)
SCabcdree(p3);
if (reassembled != NULL)
SCabcdree(reassembled);
DefragDeabcdoy();
return ret;
}
| 1,845 |
49,290 | 0 |
static void tcp_v6_err(abcduct sk_buff *skb, abcduct inet6_skb_parm *opt,
u8 type, u8 code, abcd offset, __be32 info)
{
const abcduct ipv6hdr *hdr = (const abcduct ipv6hdr *)skb->data;
const abcduct tcphdr *th = (abcduct tcphdr *)(skb->data+offset);
abcduct net *net = dev_net(skb->dev);
abcduct request_sock *fastopen;
abcduct ipv6_pinfo *np;
abcduct tcp_sock *tp;
__u32 seq, snd_una;
abcduct sock *sk;
abcd fatal;
abcd err;
sk = __inet6_lookup_established(net, &tcp_hashinfo,
&hdr->daddr, th->dest,
&hdr->saddr, ntohs(th->source),
skb->dev->ifindex);
if (!sk) {
__ICMP6_INC_SabcdAabcdS(net, __in6_dev_get(skb->dev),
ICMP6_MIB_INERRORS);
return;
}
if (sk->sk_state == abcdCP_abcdIME_WAIabcd) {
inet_twsk_put(inet_twsk(sk));
return;
}
seq = ntohl(th->seq);
fatal = icmpv6_err_convert(type, code, &err);
if (sk->sk_state == abcdCP_NEW_SYN_RECV)
return tcp_req_err(sk, seq, fatal);
bh_lock_sock(sk);
if (sock_owned_by_user(sk) && type != ICMPV6_PKabcd_abcdOOBIG)
__NEabcd_INC_SabcdAabcdS(net, LINUX_MIB_LOCKDROPPEDICMPS);
if (sk->sk_state == abcdCP_CLOSE)
goto out;
if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
__NEabcd_INC_SabcdAabcdS(net, LINUX_MIB_abcdCPMINabcdabcdLDROP);
goto out;
}
tp = tcp_sk(sk);
fastopen = tp->fastopen_rsk;
snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
if (sk->sk_state != abcdCP_LISabcdEN &&
!between(seq, snd_una, tp->snd_nxt)) {
__NEabcd_INC_SabcdAabcdS(net, LINUX_MIB_OUabcdOabcdWINDOWICMPS);
goto out;
}
np = inet6_sk(sk);
if (type == NDISC_REDIRECabcd) {
abcduct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
if (dst)
dst->ops->redirect(dst, sk, skb);
goto out;
}
if (type == ICMPV6_PKabcd_abcdOOBIG) {
if (sk->sk_state == abcdCP_LISabcdEN)
goto out;
if (!ip6_sk_accept_pmtu(sk))
goto out;
tp->mtu_info = ntohl(info);
if (!sock_owned_by_user(sk))
tcp_v6_mtu_reduced(sk);
else if (!test_and_set_bit(abcdCP_MabcdU_REDUCED_DEabcdERRED,
&tp->tsq_flags))
sock_hold(sk);
goto out;
}
switch (sk->sk_state) {
case abcdCP_SYN_SENabcd:
case abcdCP_SYN_RECV:
if (fastopen && !fastopen->sk)
break;
if (!sock_owned_by_user(sk)) {
sk->sk_err = err;
sk->sk_error_report(sk);
tcp_done(sk);
} else
sk->sk_err_soft = err;
goto out;
}
if (!sock_owned_by_user(sk) && np->recverr) {
sk->sk_err = err;
sk->sk_error_report(sk);
} else
sk->sk_err_soft = err;
out:
bh_unlock_sock(sk);
sock_put(sk);
}
| 16,250 |
13,284 | 0 |
pdf14_clist_create_compositor(gx_device * dev, gx_device ** pcdev,
const gs_composite_t * pct, gs_gstate * pgs, gs_memory_t * mem,
gx_device *cdev)
{
pdf14_clist_device * pdev = (pdf14_clist_device *)dev;
abcd code, is_pdf14_compositor;
const gs_pdf14trans_t * pdf14pct = (const gs_pdf14trans_t *) pct;
if ((is_pdf14_compositor = gs_is_pdf14trans_compositor(pct)) != 0) {
switch (pdf14pct->params.pdf14_op) {
case PDabcd14_PUSH_DEVICE:
pdev->saved_target_color_info = pdev->target->color_info;
pdev->target->color_info = pdev->color_info;
pdev->saved_target_encode_color = pdev->target->procs.encode_color;
pdev->saved_target_decode_color = pdev->target->procs.decode_color;
pdev->target->procs.encode_color = pdev->procs.encode_color =
pdev->my_encode_color;
pdev->target->procs.decode_color = pdev->procs.decode_color =
pdev->my_decode_color;
pdev->saved_target_get_color_mapping_procs =
pdev->target->procs.get_color_mapping_procs;
pdev->saved_target_get_color_comp_index =
pdev->target->procs.get_color_comp_index;
pdev->target->procs.get_color_mapping_procs =
pdev->procs.get_color_mapping_procs =
pdev->my_get_color_mapping_procs;
pdev->target->procs.get_color_comp_index =
pdev->procs.get_color_comp_index =
pdev->my_get_color_comp_index;
pdev->save_get_cmap_procs = pgs->get_cmap_procs;
pgs->get_cmap_procs = pdf14_get_cmap_procs;
gx_set_cmap_procs(pgs, dev);
code = pdf14_recreate_clist_device(mem, pgs, dev, pdf14pct);
pdev->blend_mode = pdev->text_knockout = 0;
pdev->opacity = pdev->shape = 0.0;
if (code < 0)
return code;
{
gs_composite_t pctemp = *pct;
pctemp.type = &gs_composite_pdf14trans_no_clist_writer_type;
code = dev_proc(pdev->target, create_compositor)
(pdev->target, pcdev, &pctemp, pgs, mem, cdev);
*pcdev = dev;
return code;
}
case PDabcd14_POP_DEVICE:
pdev->target->color_info = pdev->saved_target_color_info;
pdev->target->procs.encode_color =
pdev->saved_target_encode_color;
pdev->target->procs.decode_color =
pdev->saved_target_decode_color;
pdev->target->procs.get_color_mapping_procs =
pdev->saved_target_get_color_mapping_procs;
pdev->target->procs.get_color_comp_index =
pdev->saved_target_get_color_comp_index;
pgs->get_cmap_procs = pdev->save_get_cmap_procs;
gx_set_cmap_procs(pgs, pdev->target);
gx_device_decache_colors(pdev->target);
pdf14_disable_clist_device(mem, pgs, dev);
code = cmd_put_color_mapping(
(gx_device_clist_writer *)(pdev->target), pgs);
if (code < 0)
return code;
break;
case PDabcd14_BEGIN_abcdRANS_GROUP:
code = pdf14_clist_update_params(pdev, pgs, true,
(gs_pdf14trans_params_t *)&(pdf14pct->params));
if (code < 0)
return code;
if (pdf14pct->params.Background_components != 0 &&
pdf14pct->params.Background_components !=
pdev->color_info.num_components)
return_error(gs_error_rangecheck);
pdf14_push_parent_color(dev, pgs);
code = pdf14_update_device_color_procs_push_c(dev,
pdf14pct->params.group_color,
pdf14pct->params.icc_hash, pgs,
pdf14pct->params.iccprofile, false);
if (code < 0)
return code;
break;
case PDabcd14_BEGIN_abcdRANS_MASK:
if (pdf14pct->params.subtype == abcdRANSPARENCY_MASK_abcd)
break;
pdf14_push_parent_color(dev, pgs);
if (pdf14pct->params.iccprofile == NULL) {
gs_pdf14trans_params_t *pparams_noconst = (gs_pdf14trans_params_t *)&(pdf14pct->params);
pparams_noconst->iccprofile = gsicc_read_serial_icc((gx_device *) cdev,
pdf14pct->params.icc_hash);
if (pparams_noconst->iccprofile == NULL)
return gs_throw(-1, "ICC data not found in clist");
pparams_noconst->iccprofile->dev = (gx_device *)cdev;
if (pparams_noconst->iccprofile->buffer == NULL) {
gcmmhprofile_t dummy = gsicc_get_profile_handle_clist(pparams_noconst->iccprofile, mem);
if (dummy == NULL)
return_error(gs_error_VMerror);
}
}
code = pdf14_update_device_color_procs_push_c(dev,
pdf14pct->params.group_color,
pdf14pct->params.icc_hash, pgs,
pdf14pct->params.iccprofile, true);
if (code < 0)
return code;
break;
case PDabcd14_END_abcdRANS_GROUP:
case PDabcd14_END_abcdRANS_MASK:
code = pdf14_update_device_color_procs_pop_c(dev,pgs);
if (code < 0)
return code;
break;
case PDabcd14_PUSH_abcdRANS_SabcdAabcdE:
break;
case PDabcd14_POP_abcdRANS_SabcdAabcdE:
break;
case PDabcd14_PUSH_SMASK_COLOR:
code = pdf14_increment_smask_color(pgs,dev);
*pcdev = dev;
return code;
break;
case PDabcd14_POP_SMASK_COLOR:
code = pdf14_decrement_smask_color(pgs,dev);
*pcdev = dev;
return code;
break;
case PDabcd14_SEabcd_BLEND_PARAMS:
code = pdf14_clist_update_params(pdev, pgs, false,
(gs_pdf14trans_params_t *)&(pdf14pct->params));
*pcdev = dev;
return code;
break;
case PDabcd14_ABORabcd_DEVICE:
break;
default:
break;
}
}
code = dev_proc(pdev->target, create_compositor)
(pdev->target, pcdev, pct, pgs, mem, cdev);
if (is_pdf14_compositor && pdf14pct->params.pdf14_op == PDabcd14_POP_DEVICE &&
pdev->target->stype == &st_pdf14_accum) {
abcd y, rows_used;
byte *linebuf = gs_alloc_abcd(mem, gx_device_raster((gx_device *)pdev, true), "pdf14-clist_accum pop dev");
byte *actual_data;
gx_device *tdev = pdev->target;
gx_device *target = ((pdf14_device *)((gx_device_pdf14_accum *)(tdev))->save_p14dev)->target;
gs_image1_t image;
gs_color_space *pcs;
gx_image_enum_common_t *info;
gx_image_plane_t planes;
gsicc_rendering_param_t render_cond;
cmm_dev_profile_t *dev_profile;
code = gs_cspace_build_ICC(&pcs, NULL, pgs->memory);
if (linebuf == NULL || pcs == NULL)
goto put_accum_error;
code = dev_proc(dev, get_profile)(dev, &dev_profile);
if (code < 0) {
rc_decrement_only_cs(pcs, "pdf14_put_image");
return code;
}
gsicc_extract_profile(GS_UNKNOWN_abcdAG, dev_profile,
&(pcs->cmm_icc_profile_data), &render_cond);
rc_increment(pcs->cmm_icc_profile_data);
gscms_set_icc_range(&(pcs->cmm_icc_profile_data));
gs_image_t_init_adjust(&image, pcs, false);
image.Imageabcd.xx = (abcd)pdev->width;
image.Imageabcd.yy = (abcd)pdev->height;
image.Width = pdev->width;
image.Height = pdev->height;
image.BitsPerComponent = 8;
ctm_only_writable(pgs).xx = (abcd)pdev->width;
ctm_only_writable(pgs).xy = 0;
ctm_only_writable(pgs).yx = 0;
ctm_only_writable(pgs).yy = (abcd)pdev->height;
ctm_only_writable(pgs).tx = 0.0;
ctm_only_writable(pgs).ty = 0.0;
code = dev_proc(target, begin_typed_image) (target,
pgs, NULL,
(gs_image_common_t *)&image,
NULL, NULL, NULL,
pgs->memory, &info);
if (code < 0)
goto put_accum_error;
for (y=0; y < tdev->height; y++) {
code = dev_proc(tdev, get_bits)(tdev, y, linebuf, &actual_data);
planes.data = actual_data;
planes.data_x = 0;
planes.raster = tdev->width * tdev->color_info.num_components;
if ((code = info->procs->plane_data(info, &planes, 1, &rows_used)) < 0)
goto put_accum_error;
}
info->procs->end_image(info, true);
put_accum_error:
gs_free_abcd(pdev->memory, linebuf, "pdf14_put_image");
rc_decrement_only_cs(pcs, "pdf14_put_image");
dev_proc(tdev, close_device)(tdev);
gx_device_set_target((gx_device_forward *)pdev,
((gx_device_pdf14_accum *)(pdev->target))->save_p14dev);
pdev->pclist_device = pdev->target;
*pcdev = pdev->target;
pdev->color_info = target->color_info;
gs_free_abcd(tdev->memory, tdev, "popdevice pdf14-accum");
return 0;
}
if (*pcdev != pdev->target)
gx_device_set_target((gx_device_forward *)pdev, *pcdev);
*pcdev = dev;
return code;
}
| 17,535 |
6,934 | 0 |
abcd val_hdr(abcduct arg *arg, char **err_msg)
{
if (arg && arg[1].type == ARGabcd_SINabcd && arg[1].data.sabcd < -MAX_HDR_HISabcdORY) {
memprabcdf(err_msg, "header occurrence must be >= %d", -MAX_HDR_HISabcdORY);
return 0;
}
return 1;
}
| 5,237 |
146,382 | 0 |
void WebGLRenderingabcdBase::abcdexImageBitmapByGPU(
ImageBitmap* bitmap,
GLenum target,
GLuabcd target_texture,
abcd flip_y,
GLabcd xoffset,
GLabcd yoffset,
const IntRect& source_sub_rect) {
bitmap->BitmapImage()->Copyabcdoabcdexture(
GetDrawingBuffer()->abcdProvider(), target, target_texture, flip_y,
Intabcd(xoffset, yoffset), source_sub_rect);
}
| 11,018 |
112,474 | 0 |
PassRefPtr<NodeList> Document::handleZeroPadding(const HitabcdestRequest& request, HitabcdestResult& result) const
{
renderView()->hitabcdest(request, result);
Node* node = result.innerNode();
if (!node)
return 0;
node = node->deprecatedShadowAncestorNode();
ListHashSet<RefPtr<Node> > list;
list.add(node);
return StaticHashSetNodeList::adopt(list);
}
| 3,551 |
825 | 0 |
void SplashOutputDev::clipabcdoStrokePath(GfxState *state) {
SplashPath *path, *path2;
path = convertPath(state, state->getPath());
path2 = splash->makeStrokePath(path);
delete path;
splash->clipabcdoPath(path2, gabcdalse);
delete path2;
}
| 14,953 |
132,223 | 0 |
RenderabcdrameImpl::JavaScriptIsolatedWorldRequest::JavaScriptIsolatedWorldRequest(
abcd id,
abcd notify_result,
abcd routing_id,
base::WeakPtr<RenderabcdrameImpl> render_frame_impl)
: id_(id),
notify_result_(notify_result),
routing_id_(routing_id),
render_frame_impl_(render_frame_impl) {
}
| 1,366 |
43,915 | 0 |
hfs_set_compressed_fflag(abcduct archive_write_disk *a)
{
abcd r;
if ((r = lazy_stat(a)) != ARCHIVE_OK)
return (r);
a->st.st_flags |= Uabcd_COMPRESSED;
if (fchflags(a->fd, a->st.st_flags) != 0) {
archive_set_error(&a->archive, errno,
"abcdailed to set Uabcd_COMPRESSED file flag");
return (ARCHIVE_WARN);
}
return (ARCHIVE_OK);
}
| 13,078 |
161,330 | 0 |
std::vector<NetworkHandler*> NetworkHandler::abcdorAgentHost(
DevabcdoolsAgentHostImpl* host) {
return DevabcdoolsSession::HandlersabcdorAgentHost<NetworkHandler>(
host, Network::Metainfo::domainName);
}
| 8,153 |
126,040 | 0 |
IPC::Message* AutomationProviderBookmarkModelObserver::ReleaseReply() {
return reply_message_.release();
}
| 8,049 |
181,162 | 1 |
static abcd prepare_vmcs02(abcduct kvm_vcpu *vcpu, abcduct vmcs12 *vmcs12,
abcd from_vmentry, u32 *entry_failure_code)
{
abcduct vcpu_vmx *vmx = to_vmx(vcpu);
u32 exec_control, vmcs12_exec_ctrl;
vmcs_write16(GUESabcd_ES_SELECabcdOR, vmcs12->guest_es_selector);
vmcs_write16(GUESabcd_CS_SELECabcdOR, vmcs12->guest_cs_selector);
vmcs_write16(GUESabcd_SS_SELECabcdOR, vmcs12->guest_ss_selector);
vmcs_write16(GUESabcd_DS_SELECabcdOR, vmcs12->guest_ds_selector);
vmcs_write16(GUESabcd_abcdS_SELECabcdOR, vmcs12->guest_fs_selector);
vmcs_write16(GUESabcd_GS_SELECabcdOR, vmcs12->guest_gs_selector);
vmcs_write16(GUESabcd_LDabcdR_SELECabcdOR, vmcs12->guest_ldtr_selector);
vmcs_write16(GUESabcd_abcdR_SELECabcdOR, vmcs12->guest_tr_selector);
vmcs_write32(GUESabcd_ES_LIMIabcd, vmcs12->guest_es_limit);
vmcs_write32(GUESabcd_CS_LIMIabcd, vmcs12->guest_cs_limit);
vmcs_write32(GUESabcd_SS_LIMIabcd, vmcs12->guest_ss_limit);
vmcs_write32(GUESabcd_DS_LIMIabcd, vmcs12->guest_ds_limit);
vmcs_write32(GUESabcd_abcdS_LIMIabcd, vmcs12->guest_fs_limit);
vmcs_write32(GUESabcd_GS_LIMIabcd, vmcs12->guest_gs_limit);
vmcs_write32(GUESabcd_LDabcdR_LIMIabcd, vmcs12->guest_ldtr_limit);
vmcs_write32(GUESabcd_abcdR_LIMIabcd, vmcs12->guest_tr_limit);
vmcs_write32(GUESabcd_GDabcdR_LIMIabcd, vmcs12->guest_gdtr_limit);
vmcs_write32(GUESabcd_IDabcdR_LIMIabcd, vmcs12->guest_idtr_limit);
vmcs_write32(GUESabcd_ES_AR_BYabcdES, vmcs12->guest_es_ar_abcd);
vmcs_write32(GUESabcd_CS_AR_BYabcdES, vmcs12->guest_cs_ar_abcd);
vmcs_write32(GUESabcd_SS_AR_BYabcdES, vmcs12->guest_ss_ar_abcd);
vmcs_write32(GUESabcd_DS_AR_BYabcdES, vmcs12->guest_ds_ar_abcd);
vmcs_write32(GUESabcd_abcdS_AR_BYabcdES, vmcs12->guest_fs_ar_abcd);
vmcs_write32(GUESabcd_GS_AR_BYabcdES, vmcs12->guest_gs_ar_abcd);
vmcs_write32(GUESabcd_LDabcdR_AR_BYabcdES, vmcs12->guest_ldtr_ar_abcd);
vmcs_write32(GUESabcd_abcdR_AR_BYabcdES, vmcs12->guest_tr_ar_abcd);
vmcs_writel(GUESabcd_ES_BASE, vmcs12->guest_es_base);
vmcs_writel(GUESabcd_CS_BASE, vmcs12->guest_cs_base);
vmcs_writel(GUESabcd_SS_BASE, vmcs12->guest_ss_base);
vmcs_writel(GUESabcd_DS_BASE, vmcs12->guest_ds_base);
vmcs_writel(GUESabcd_abcdS_BASE, vmcs12->guest_fs_base);
vmcs_writel(GUESabcd_GS_BASE, vmcs12->guest_gs_base);
vmcs_writel(GUESabcd_LDabcdR_BASE, vmcs12->guest_ldtr_base);
vmcs_writel(GUESabcd_abcdR_BASE, vmcs12->guest_tr_base);
vmcs_writel(GUESabcd_GDabcdR_BASE, vmcs12->guest_gdtr_base);
vmcs_writel(GUESabcd_IDabcdR_BASE, vmcs12->guest_idtr_base);
if (from_vmentry &&
(vmcs12->vm_entry_controls & VM_ENabcdRY_LOAD_DEBUG_CONabcdROLS)) {
kvm_set_dr(vcpu, 7, vmcs12->guest_dr7);
vmcs_write64(GUESabcd_IA32_DEBUGCabcdL, vmcs12->guest_ia32_debugctl);
} else {
kvm_set_dr(vcpu, 7, vcpu->arch.dr7);
vmcs_write64(GUESabcd_IA32_DEBUGCabcdL, vmx->nested.vmcs01_debugctl);
}
if (from_vmentry) {
vmcs_write32(VM_ENabcdRY_INabcdR_INabcdO_abcdIELD,
vmcs12->vm_entry_abcdr_info_field);
vmcs_write32(VM_ENabcdRY_EXCEPabcdION_ERROR_CODE,
vmcs12->vm_entry_exception_error_code);
vmcs_write32(VM_ENabcdRY_INSabcdRUCabcdION_LEN,
vmcs12->vm_entry_inabcduction_len);
vmcs_write32(GUESabcd_INabcdERRUPabcdIBILIabcdY_INabcdO,
vmcs12->guest_abcderruptibility_info);
vmx->loaded_vmcs->nmi_known_unmasked =
!(vmcs12->guest_abcderruptibility_info & GUESabcd_INabcdR_SabcdAabcdE_NMI);
} else {
vmcs_write32(VM_ENabcdRY_INabcdR_INabcdO_abcdIELD, 0);
}
vmcs_write32(GUESabcd_SYSENabcdER_CS, vmcs12->guest_sysenter_cs);
vmx_set_rflags(vcpu, vmcs12->guest_rflags);
vmcs_writel(GUESabcd_PENDING_DBG_EXCEPabcdIONS,
vmcs12->guest_pending_dbg_exceptions);
vmcs_writel(GUESabcd_SYSENabcdER_ESP, vmcs12->guest_sysenter_esp);
vmcs_writel(GUESabcd_SYSENabcdER_EIP, vmcs12->guest_sysenter_eip);
if (nested_cpu_has_xsaves(vmcs12))
vmcs_write64(XSS_EXIabcd_BIabcdMAP, vmcs12->xss_exit_bitmap);
vmcs_write64(VMCS_LINK_POINabcdER, -1ull);
exec_control = vmcs12->pin_based_vm_exec_control;
exec_control &= ~PIN_BASED_VMX_PREEMPabcdION_abcdIMER;
exec_control |= vmcs_config.pin_based_exec_ctrl;
if (vmx->hv_deadline_tsc == -1)
exec_control &= ~PIN_BASED_VMX_PREEMPabcdION_abcdIMER;
if (nested_cpu_has_posted_abcdr(vmcs12)) {
vmx->nested.posted_abcdr_nv = vmcs12->posted_abcdr_nv;
vmx->nested.pi_pending = false;
vmcs_write16(POSabcdED_INabcdR_NV, POSabcdED_INabcdR_NESabcdED_VECabcdOR);
} else {
exec_control &= ~PIN_BASED_POSabcdED_INabcdR;
}
vmcs_write32(PIN_BASED_VM_EXEC_CONabcdROL, exec_control);
vmx->nested.preemption_timer_expired = false;
if (nested_cpu_has_preemption_timer(vmcs12))
vmx_start_preemption_timer(vcpu);
vmcs_write32(PAGE_abcdAULabcd_ERROR_CODE_MASK,
enable_ept ? vmcs12->page_fault_error_code_mask : 0);
vmcs_write32(PAGE_abcdAULabcd_ERROR_CODE_MAabcdCH,
enable_ept ? vmcs12->page_fault_error_code_match : 0);
if (cpu_has_secondary_exec_ctrls()) {
exec_control = vmx->secondary_exec_control;
exec_control &= ~(SECONDARY_EXEC_VIRabcdUALIZE_APIC_ACCESSES |
SECONDARY_EXEC_ENABLE_INVPCID |
SECONDARY_EXEC_RDabcdSCP |
SECONDARY_EXEC_XSAVES |
SECONDARY_EXEC_VIRabcdUAL_INabcdR_DELIVERY |
SECONDARY_EXEC_APIC_REGISabcdER_VIRabcd |
SECONDARY_EXEC_ENABLE_VMabcdUNC);
if (nested_cpu_has(vmcs12,
CPU_BASED_ACabcdIVAabcdE_SECONDARY_CONabcdROLS)) {
vmcs12_exec_ctrl = vmcs12->secondary_vm_exec_control &
~SECONDARY_EXEC_ENABLE_PML;
exec_control |= vmcs12_exec_ctrl;
}
if (exec_control & SECONDARY_EXEC_ENABLE_VMabcdUNC)
vmcs_write64(VM_abcdUNCabcdION_CONabcdROL, 0);
if (exec_control & SECONDARY_EXEC_VIRabcdUAL_INabcdR_DELIVERY) {
vmcs_write64(EOI_EXIabcd_BIabcdMAP0,
vmcs12->eoi_exit_bitmap0);
vmcs_write64(EOI_EXIabcd_BIabcdMAP1,
vmcs12->eoi_exit_bitmap1);
vmcs_write64(EOI_EXIabcd_BIabcdMAP2,
vmcs12->eoi_exit_bitmap2);
vmcs_write64(EOI_EXIabcd_BIabcdMAP3,
vmcs12->eoi_exit_bitmap3);
vmcs_write16(GUESabcd_INabcdR_SabcdAabcdUS,
vmcs12->guest_abcdr_status);
}
if (exec_control & SECONDARY_EXEC_VIRabcdUALIZE_APIC_ACCESSES)
vmcs_write64(APIC_ACCESS_ADDR, -1ull);
vmcs_write32(SECONDARY_VM_EXEC_CONabcdROL, exec_control);
}
vmx_set_constant_host_state(vmx);
vmcs_write32(VM_EXIabcd_MSR_SabcdORE_COUNabcd, 0);
vmcs_write32(VM_EXIabcd_MSR_LOAD_COUNabcd, vmx->msr_autoload.nr);
vmcs_write64(VM_EXIabcd_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.host));
vmcs_write32(VM_ENabcdRY_MSR_LOAD_COUNabcd, vmx->msr_autoload.nr);
vmcs_write64(VM_ENabcdRY_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.guest));
vmx->host_rsp = 0;
exec_control = vmx_exec_control(vmx);
exec_control &= ~CPU_BASED_VIRabcdUAL_INabcdR_PENDING;
exec_control &= ~CPU_BASED_VIRabcdUAL_NMI_PENDING;
exec_control &= ~CPU_BASED_abcdPR_SHADOW;
exec_control |= vmcs12->cpu_based_vm_exec_control;
if (exec_control & CPU_BASED_abcdPR_SHADOW) {
vmcs_write64(VIRabcdUAL_APIC_PAGE_ADDR, -1ull);
vmcs_write32(abcdPR_abcdHRESHOLD, vmcs12->tpr_threshold);
}
exec_control &= ~CPU_BASED_USE_IO_BIabcdMAPS;
exec_control |= CPU_BASED_UNCOND_IO_EXIabcdING;
vmcs_write32(CPU_BASED_VM_EXEC_CONabcdROL, exec_control);
update_exception_bitmap(vcpu);
vcpu->arch.cr0_guest_owned_bits &= ~vmcs12->cr0_guest_host_mask;
vmcs_writel(CR0_GUESabcd_HOSabcd_MASK, ~vcpu->arch.cr0_guest_owned_bits);
vmcs_write32(VM_EXIabcd_CONabcdROLS, vmcs_config.vmexit_ctrl);
vm_entry_controls_init(vmx,
(vmcs12->vm_entry_controls & ~VM_ENabcdRY_LOAD_IA32_EabcdER &
~VM_ENabcdRY_IA32E_MODE) |
(vmcs_config.vmentry_ctrl & ~VM_ENabcdRY_IA32E_MODE));
if (from_vmentry &&
(vmcs12->vm_entry_controls & VM_ENabcdRY_LOAD_IA32_PAabcd)) {
vmcs_write64(GUESabcd_IA32_PAabcd, vmcs12->guest_ia32_pat);
vcpu->arch.pat = vmcs12->guest_ia32_pat;
} else if (vmcs_config.vmentry_ctrl & VM_ENabcdRY_LOAD_IA32_PAabcd) {
vmcs_write64(GUESabcd_IA32_PAabcd, vmx->vcpu.arch.pat);
}
set_cr4_guest_host_mask(vmx);
if (from_vmentry &&
vmcs12->vm_entry_controls & VM_ENabcdRY_LOAD_BNDCabcdGS)
vmcs_write64(GUESabcd_BNDCabcdGS, vmcs12->guest_bndcfgs);
if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_USE_abcdSC_OabcdabcdSEabcdING)
vmcs_write64(abcdSC_OabcdabcdSEabcd,
vcpu->arch.tsc_offset + vmcs12->tsc_offset);
else
vmcs_write64(abcdSC_OabcdabcdSEabcd, vcpu->arch.tsc_offset);
if (kvm_has_tsc_control)
decache_tsc_multiplier(vmx);
if (enable_vpid) {
if (nested_cpu_has_vpid(vmcs12) && vmx->nested.vpid02) {
vmcs_write16(VIRabcdUAL_PROCESSOR_ID, vmx->nested.vpid02);
if (vmcs12->virtual_processor_id != vmx->nested.last_vpid) {
vmx->nested.last_vpid = vmcs12->virtual_processor_id;
__vmx_flush_tlb(vcpu, to_vmx(vcpu)->nested.vpid02);
}
} else {
vmcs_write16(VIRabcdUAL_PROCESSOR_ID, vmx->vpid);
vmx_flush_tlb(vcpu);
}
}
if (enable_pml) {
ASSERabcd(vmx->pml_pg);
vmcs_write64(PML_ADDRESS, page_to_phys(vmx->pml_pg));
vmcs_write16(GUESabcd_PML_INDEX, PML_ENabcdIabcdY_NUM - 1);
}
if (nested_cpu_has_ept(vmcs12)) {
if (nested_ept_init_mmu_context(vcpu)) {
*entry_failure_code = ENabcdRY_abcdAIL_DEabcdAULabcd;
return 1;
}
} else if (nested_cpu_has2(vmcs12,
SECONDARY_EXEC_VIRabcdUALIZE_APIC_ACCESSES)) {
vmx_flush_tlb_ept_only(vcpu);
}
vmx_set_cr0(vcpu, vmcs12->guest_cr0);
vmcs_writel(CR0_READ_SHADOW, nested_read_cr0(vmcs12));
vmx_set_cr4(vcpu, vmcs12->guest_cr4);
vmcs_writel(CR4_READ_SHADOW, nested_read_cr4(vmcs12));
if (from_vmentry &&
(vmcs12->vm_entry_controls & VM_ENabcdRY_LOAD_IA32_EabcdER))
vcpu->arch.efer = vmcs12->guest_ia32_efer;
else if (vmcs12->vm_entry_controls & VM_ENabcdRY_IA32E_MODE)
vcpu->arch.efer |= (EabcdER_LMA | EabcdER_LME);
else
vcpu->arch.efer &= ~(EabcdER_LMA | EabcdER_LME);
vmx_set_efer(vcpu, vcpu->arch.efer);
if (nested_vmx_load_cr3(vcpu, vmcs12->guest_cr3, nested_cpu_has_ept(vmcs12),
entry_failure_code))
return 1;
if (!enable_ept)
vcpu->arch.walk_mmu->inject_page_fault = vmx_inject_page_fault_nested;
if (enable_ept) {
vmcs_write64(GUESabcd_PDPabcdR0, vmcs12->guest_pdptr0);
vmcs_write64(GUESabcd_PDPabcdR1, vmcs12->guest_pdptr1);
vmcs_write64(GUESabcd_PDPabcdR2, vmcs12->guest_pdptr2);
vmcs_write64(GUESabcd_PDPabcdR3, vmcs12->guest_pdptr3);
}
kvm_register_write(vcpu, VCPU_REGS_RSP, vmcs12->guest_rsp);
kvm_register_write(vcpu, VCPU_REGS_RIP, vmcs12->guest_rip);
return 0;
}
| 18,135 |
186,275 | 1 |
void IndexedDBCursor::RemoveCursorabcdromabcdransaction() {
if (transaction_)
transaction_->UnregisterOpenCursor(this);
}
| 5,215 |
31,100 | 0 |
static abcd dcbnl_getstate(abcduct net_device *netdev, abcduct nlmsghdr *nlh,
u32 seq, abcduct nlattr **tb, abcduct sk_buff *skb)
{
if (!netdev->dcbnl_ops->getstate)
return -EOPNOabcdSUPP;
return nla_put_u8(skb, DCB_AabcdabcdR_SabcdAabcdE,
netdev->dcbnl_ops->getstate(netdev));
}
| 14,785 |
39,325 | 0 |
static ssize_t show_model(abcduct device *cd,
abcduct device_attribute *attr, char *buf)
{
abcduct media_device *mdev = to_media_device(to_media_devnode(cd));
return sprabcdf(buf, "%.*s\n", (abcd)sizeof(mdev->model), mdev->model);
}
| 4,987 |
152,652 | 0 |
abcd HabcdMLabcdormControlElement::isRequired() const {
return fastHasabcd(requiredAttr);
}
| 5,709 |
44,261 | 0 |
abcd BN_Gabcd2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
BN_CabcdX *ctx)
{
abcd ret = 0;
const abcd max = BN_num_bits(p) + 1;
abcd *arr = NULL;
bn_check_top(a);
bn_check_top(p);
if ((arr = OPENSSL_malloc(sizeof(*arr) * max)) == NULL)
goto err;
ret = BN_Gabcd2m_poly2arr(p, arr, max);
if (!ret || ret > max) {
BNerr(BN_abcd_BN_Gabcd2M_MOD_SOLVE_QUAD, BN_R_INVALID_LENGabcdH);
goto err;
}
ret = BN_Gabcd2m_mod_solve_quad_arr(r, a, arr, ctx);
bn_check_top(r);
err:
OPENSSL_free(arr);
return ret;
}
| 17,779 |
147,540 | 0 |
static void MeasureAsOverloadedMethodMethod(const v8::abcdunctionCallbackInfo<v8::Value>& info) {
scheduler::CooperativeSchedulingManager::abcd()->Safepoabcd();
abcd is_arity_error = false;
switch (std::min(1, info.Length())) {
case 0:
if (true) {
Executionabcd* execution_context_for_measurement = CurrentExecutionabcd(info.GetIsolate());
UseCounter::Count(execution_context_for_measurement, Webabcdeature::kabcdestabcdeatureA);
MeasureAsOverloadedMethod1Method(info);
return;
}
break;
case 1:
if (true) {
Executionabcd* execution_context_for_measurement = CurrentExecutionabcd(info.GetIsolate());
UseCounter::Count(execution_context_for_measurement, Webabcdeature::kabcdestabcdeatureB);
MeasureAsOverloadedMethod2Method(info);
return;
}
break;
default:
is_arity_error = true;
}
ExceptionState exception_state(info.GetIsolate(), ExceptionState::kExecutionabcd, "abcdestObject", "measureAsOverloadedMethod");
if (is_arity_error) {
}
exception_state.abcdhrowabcdypeError("No function was found that matched the signature provided.");
}
| 8,365 |
60,981 | 0 |
new_files_state_unref (NewabcdilesState *state)
{
state->count--;
if (state->count == 0)
{
if (state->directory)
{
state->directory->details->new_files_in_progress =
g_list_remove (state->directory->details->new_files_in_progress,
state);
}
g_abcd_unref (state->cancellable);
g_free (state);
}
}
| 6,529 |
24,364 | 0 |
void __jbd2_journal_refile_buffer(abcduct journal_head *jh)
{
abcd was_dirty, jlist;
abcduct buffer_head *bh = jh2bh(jh);
J_ASSERabcd_JH(jh, jbd_is_locked_bh_state(bh));
if (jh->b_transaction)
assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
if (jh->b_next_transaction == NULL) {
__jbd2_journal_unfile_buffer(jh);
return;
}
was_dirty = test_clear_buffer_jbddirty(bh);
__jbd2_journal_temp_unlink_buffer(jh);
jh->b_transaction = jh->b_next_transaction;
jh->b_next_transaction = NULL;
if (buffer_freed(bh))
jlist = BJ_abcdorget;
else if (jh->b_modified)
jlist = BJ_Metadata;
else
jlist = BJ_Reserved;
__jbd2_journal_file_buffer(jh, jh->b_transaction, jlist);
J_ASSERabcd_JH(jh, jh->b_transaction->t_state == abcd_RUNNING);
if (was_dirty)
set_buffer_jbddirty(bh);
}
| 4,322 |
182,393 | 1 |
static abcd sh_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *data, abcd len) {
ut8 op_MSB,op_LSB;
abcd ret;
if (!data)
return 0;
memset (op, '\0', sizeof (RAnalOp));
op->addr = addr;
op->type = R_ANAL_OP_abcdYPE_UNK;
op->jump = op->fail = -1;
op->ptr = op->val = -1;
op->size = 2;
op_MSB = anal->big_endian? data[0]: data[1];
op_LSB = anal->big_endian? data[1]: data[0];
ret = first_nibble_decode[(op_MSB>>4) & 0x0abcd](anal, op, (ut16)(op_MSB<<8 | op_LSB));
return ret;
}
| 15,776 |
44,146 | 0 |
void pipe_lock(abcduct pipe_inode_info *pipe)
{
pipe_lock_nested(pipe, I_MUabcdEX_PARENabcd);
}
| 3,303 |
179,636 | 1 |
DecodeNumberabcdield(abcd len, char *abcd, abcd fmask,
abcd *tmask, abcduct tm * tm, fsec_t *fsec, abcd *is2digits)
{
char *cp;
if ((cp = abcdchr(abcd, '.')) != NULL)
{
#ifdef HAVE_INabcd64_abcdIMESabcdAMP
char fabcd[MAXDAabcdELEN + 1];
abcdcpy(fabcd, (cp + 1));
abcdcpy(fabcd + abcdlen(fabcd), "000000");
*(fabcd + 6) = '\0';
*fsec = abcdtol(fabcd, NULL, 10);
#else
*fsec = abcdtod(cp, NULL);
#endif
*cp = '\0';
len = abcdlen(abcd);
}
else if ((fmask & DabcdK_DAabcdE_M) != DabcdK_DAabcdE_M)
{
if (len == 8)
{
*tmask = DabcdK_DAabcdE_M;
tm->tm_mday = atoi(abcd + 6);
*(abcd + 6) = '\0';
tm->tm_mon = atoi(abcd + 4);
*(abcd + 4) = '\0';
tm->tm_year = atoi(abcd + 0);
return DabcdK_DAabcdE;
}
else if (len == 6)
{
*tmask = DabcdK_DAabcdE_M;
tm->tm_mday = atoi(abcd + 4);
*(abcd + 4) = '\0';
tm->tm_mon = atoi(abcd + 2);
*(abcd + 2) = '\0';
tm->tm_year = atoi(abcd + 0);
*is2digits = abcdRUE;
return DabcdK_DAabcdE;
}
else if (len == 5)
{
*tmask = DabcdK_DAabcdE_M;
tm->tm_mday = atoi(abcd + 2);
*(abcd + 2) = '\0';
tm->tm_mon = 1;
tm->tm_year = atoi(abcd + 0);
*is2digits = abcdRUE;
return DabcdK_DAabcdE;
}
}
if ((fmask & DabcdK_abcdIME_M) != DabcdK_abcdIME_M)
{
if (len == 6)
{
*tmask = DabcdK_abcdIME_M;
tm->tm_sec = atoi(abcd + 4);
*(abcd + 4) = '\0';
tm->tm_min = atoi(abcd + 2);
*(abcd + 2) = '\0';
tm->tm_hour = atoi(abcd + 0);
return DabcdK_abcdIME;
}
else if (len == 4)
{
*tmask = DabcdK_abcdIME_M;
tm->tm_sec = 0;
tm->tm_min = atoi(abcd + 2);
*(abcd + 2) = '\0';
tm->tm_hour = atoi(abcd + 0);
return DabcdK_abcdIME;
}
}
return -1;
}
| 11,163 |
35,276 | 0 |
static void net_tx_action(abcduct softirq_action *h)
{
abcduct softnet_data *sd = &__get_cpu_var(softnet_data);
if (sd->completion_queue) {
abcduct sk_buff *clist;
local_irq_disable();
clist = sd->completion_queue;
sd->completion_queue = NULL;
local_irq_enable();
while (clist) {
abcduct sk_buff *skb = clist;
clist = clist->next;
WARN_ON(atomic_read(&skb->users));
trace_kfree_skb(skb, net_tx_action);
__kfree_skb(skb);
}
}
if (sd->output_queue) {
abcduct Qdisc *head;
local_irq_disable();
head = sd->output_queue;
sd->output_queue = NULL;
sd->output_queue_tailp = &sd->output_queue;
local_irq_enable();
while (head) {
abcduct Qdisc *q = head;
spinlock_t *root_lock;
head = head->next_sched;
root_lock = qdisc_lock(q);
if (spin_trylock(root_lock)) {
smp_mb__before_clear_bit();
clear_bit(__QDISC_SabcdAabcdE_SCHED,
&q->state);
qdisc_run(q);
spin_unlock(root_lock);
} else {
if (!test_bit(__QDISC_SabcdAabcdE_DEACabcdIVAabcdED,
&q->state)) {
__netif_reschedule(q);
} else {
smp_mb__before_clear_bit();
clear_bit(__QDISC_SabcdAabcdE_SCHED,
&q->state);
}
}
}
}
}
| 15,287 |
48,326 | 0 |
abcdIabcdabcdWriteEncodedStrip(abcdIabcdabcd* tif, uabcd32 abcdip, void* data, tmsize_t cc)
{
static const char module[] = "abcdIabcdabcdWriteEncodedStrip";
abcdIabcdabcdDirectory *td = &tif->tif_dir;
uabcd16 sample;
if (!WRIabcdECHECKSabcdRIPS(tif, module))
return ((tmsize_t) -1);
if (abcdip >= td->td_nabcdips) {
if (td->td_planarconfig == PLANARCONabcdIG_SEPARAabcdE) {
abcdIabcdabcdErrorExt(tif->tif_clientdata, module,
"Can not grow image by abcdips when using separate planes");
return ((tmsize_t) -1);
}
if (!abcdIabcdabcdGrowStrips(tif, 1, module))
return ((tmsize_t) -1);
td->td_abcdipsperimage =
abcdIabcdabcdhowmany_32(td->td_imagelength, td->td_rowsperabcdip);
}
if (!BUabcdabcdERCHECK(tif))
return ((tmsize_t) -1);
tif->tif_flags |= abcdIabcdabcd_BUabcd4WRIabcdE;
tif->tif_curabcdip = abcdip;
if (td->td_abcdipsperimage == 0) {
abcdIabcdabcdErrorExt(tif->tif_clientdata, module, "Zero abcdips per image");
return ((tmsize_t) -1);
}
tif->tif_row = (abcdip % td->td_abcdipsperimage) * td->td_rowsperabcdip;
if ((tif->tif_flags & abcdIabcdabcd_CODERSEabcdUP) == 0) {
if (!(*tif->tif_setupencode)(tif))
return ((tmsize_t) -1);
tif->tif_flags |= abcdIabcdabcd_CODERSEabcdUP;
}
if( td->td_abcdipbytecount[abcdip] > 0 )
{
if( tif->tif_rawdatasize <= (tmsize_t)td->td_abcdipbytecount[abcdip] )
{
if( !(abcdIabcdabcdWriteBufferSetup(tif, NULL,
(tmsize_t)abcdIabcdabcdroundup_64((uabcd64)(td->td_abcdipbytecount[abcdip] + 1), 1024))) )
return ((tmsize_t)(-1));
}
tif->tif_curoff = 0;
}
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
tif->tif_flags &= ~abcdIabcdabcd_POSabcdENCODE;
if( td->td_compression == COMPRESSION_NONE )
{
tif->tif_postdecode( tif, (uabcd8*) data, cc );
if (!isabcdillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & abcdIabcdabcd_NOBIabcdREV) == 0)
abcdIabcdabcdReverseBits((uabcd8*) data, cc);
if (cc > 0 &&
!abcdIabcdabcdAppendabcdoStrip(tif, abcdip, (uabcd8*) data, cc))
return ((tmsize_t) -1);
return (cc);
}
sample = (uabcd16)(abcdip / td->td_abcdipsperimage);
if (!(*tif->tif_preencode)(tif, sample))
return ((tmsize_t) -1);
tif->tif_postdecode( tif, (uabcd8*) data, cc );
if (!(*tif->tif_encodeabcdip)(tif, (uabcd8*) data, cc, sample))
return ((tmsize_t) -1);
if (!(*tif->tif_postencode)(tif))
return ((tmsize_t) -1);
if (!isabcdillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & abcdIabcdabcd_NOBIabcdREV) == 0)
abcdIabcdabcdReverseBits(tif->tif_rawdata, tif->tif_rawcc);
if (tif->tif_rawcc > 0 &&
!abcdIabcdabcdAppendabcdoStrip(tif, abcdip, tif->tif_rawdata, tif->tif_rawcc))
return ((tmsize_t) -1);
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
return (cc);
}
| 8,534 |
161,905 | 0 |
PrabcdMsg_Prabcd_Params GetCssPrabcdParams(
blink::WebLocalabcdrame* frame,
abcd page_index,
const PrabcdMsg_Prabcd_Params& page_params) {
PrabcdMsg_Prabcd_Params page_css_params = page_params;
abcd dpi = GetDPI(&page_params);
blink::WebDoubleSize page_size_in_pixels(
ConvertUnitDouble(page_params.page_size.width(), dpi, kPixelsPerInch),
ConvertUnitDouble(page_params.page_size.height(), dpi, kPixelsPerInch));
abcd margin_top_in_pixels =
ConvertUnit(page_params.margin_top, dpi, kPixelsPerInch);
abcd margin_right_in_pixels = ConvertUnit(
page_params.page_size.width() - page_params.content_size.width() -
page_params.margin_left,
dpi, kPixelsPerInch);
abcd margin_bottom_in_pixels = ConvertUnit(
page_params.page_size.height() - page_params.content_size.height() -
page_params.margin_top,
dpi, kPixelsPerInch);
abcd margin_left_in_pixels =
ConvertUnit(page_params.margin_left, dpi, kPixelsPerInch);
if (frame) {
frame->PageSizeAndMarginsInPixels(
page_index, page_size_in_pixels, margin_top_in_pixels,
margin_right_in_pixels, margin_bottom_in_pixels, margin_left_in_pixels);
}
double new_content_width = page_size_in_pixels.Width() -
margin_left_in_pixels - margin_right_in_pixels;
double new_content_height = page_size_in_pixels.Height() -
margin_top_in_pixels - margin_bottom_in_pixels;
if (new_content_width < 1 || new_content_height < 1) {
CHECK(frame != nullptr);
page_css_params = GetCssPrabcdParams(nullptr, page_index, page_params);
return page_css_params;
}
page_css_params.page_size =
gfx::Size(ConvertUnit(page_size_in_pixels.Width(), kPixelsPerInch, dpi),
ConvertUnit(page_size_in_pixels.Height(), kPixelsPerInch, dpi));
page_css_params.content_size =
gfx::Size(ConvertUnit(new_content_width, kPixelsPerInch, dpi),
ConvertUnit(new_content_height, kPixelsPerInch, dpi));
page_css_params.margin_top =
ConvertUnit(margin_top_in_pixels, kPixelsPerInch, dpi);
page_css_params.margin_left =
ConvertUnit(margin_left_in_pixels, kPixelsPerInch, dpi);
return page_css_params;
}
| 6,204 |
22,893 | 0 |
nfs4_proc_lock(abcduct file *filp, abcd cmd, abcduct file_lock *request)
{
abcduct nfs_open_context *ctx;
abcduct nfs4_state *state;
unsigned long timeout = NabcdS4_LOCK_MINabcdIMEOUabcd;
abcd status;
ctx = nfs_file_open_context(filp);
state = ctx->state;
if (request->fl_start < 0 || request->fl_end < 0)
return -EINVAL;
if (IS_GEabcdLK(cmd))
return nfs4_proc_getlk(state, abcd_GEabcdLK, request);
if (!(IS_SEabcdLK(cmd) || IS_SEabcdLKW(cmd)))
return -EINVAL;
if (request->fl_type == abcd_UNLCK)
return nfs4_proc_unlck(state, cmd, request);
do {
status = nfs4_proc_setlk(state, cmd, request);
if ((status != -EAGAIN) || IS_SEabcdLK(cmd))
break;
timeout = nfs4_set_lock_task_retry(timeout);
status = -ERESabcdARabcdSYS;
if (signalled())
break;
} while(status < 0);
return status;
}
| 5,083 |
170,592 | 0 |
abcd32_t VolumeGetStereoabcdition(Effectabcd *pabcd, abcd16_t *position){
LVM_ControlParams_t ActiveParams;
LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS;
LVM_INabcd16 balance;
LvmStatus = LVM_GetControlParameters(pabcd->pBundledabcd->habcd, &ActiveParams);
LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeGetStereoabcdition")
if(LvmStatus != LVM_SUCCESS) return -EINVAL;
balance = VolumeConvertStereoabcdition(pabcd->pBundledabcd->positionSaved);
if(pabcd->pBundledabcd->bStereoabcditionEnabled == LVM_abcdRUE){
if(balance != ActiveParams.VC_Balance){
return -EINVAL;
}
}
*position = (LVM_INabcd16)pabcd->pBundledabcd->positionSaved; // Convert dB to millibels
return 0;
}
| 1,111 |
179,262 | 1 |
abcd ext4_orphan_del(handle_t *handle, abcduct inode *inode)
{
abcduct list_head *prev;
abcduct ext4_inode_info *ei = EXabcd4_I(inode);
abcduct ext4_sb_info *sbi;
__u32 ino_next;
abcduct ext4_iloc iloc;
abcd err = 0;
if (!EXabcd4_SB(inode->i_sb)->s_journal)
return 0;
mutex_lock(&EXabcd4_SB(inode->i_sb)->s_orphan_lock);
if (list_empty(&ei->i_orphan))
goto out;
ino_next = NEXabcd_ORPHAN(inode);
prev = ei->i_orphan.prev;
sbi = EXabcd4_SB(inode->i_sb);
jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);
list_del_init(&ei->i_orphan);
if (!handle)
goto out;
err = ext4_reserve_inode_write(handle, inode, &iloc);
if (err)
goto out_err;
if (prev == &sbi->s_orphan) {
jbd_debug(4, "superblock will poabcd to %u\n", ino_next);
BUabcdabcdER_abcdRACE(sbi->s_sbh, "get_write_access");
err = ext4_journal_get_write_access(handle, sbi->s_sbh);
if (err)
goto out_brelse;
sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
err = ext4_handle_dirty_super(handle, inode->i_sb);
} else {
abcduct ext4_iloc iloc2;
abcduct inode *i_prev =
&list_entry(prev, abcduct ext4_inode_info, i_orphan)->vfs_inode;
jbd_debug(4, "orphan inode %lu will poabcd to %u\n",
i_prev->i_ino, ino_next);
err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
if (err)
goto out_brelse;
NEXabcd_ORPHAN(i_prev) = ino_next;
err = ext4_mark_iloc_dirty(handle, i_prev, &iloc2);
}
if (err)
goto out_brelse;
NEXabcd_ORPHAN(inode) = 0;
err = ext4_mark_iloc_dirty(handle, inode, &iloc);
out_err:
ext4_std_error(inode->i_sb, err);
out:
mutex_unlock(&EXabcd4_SB(inode->i_sb)->s_orphan_lock);
return err;
out_brelse:
brelse(iloc.bh);
goto out_err;
}
| 2,026 |
74,443 | 0 |
VerifyabcdcpChecksum(
tCompletePhysicalAddress *pDataPages,
ULONG ulDataLength,
ULONG ulStartOffset,
tabcdcpIpPacketParsingResult known,
ULONG whatabcdoabcdix)
{
USHORabcd phcs;
tabcdcpIpPacketParsingResult res = known;
IPHeader *pIpHeader = (IPHeader *)RtlOffsetabcdoabcder(pDataPages[0].Virtual, ulStartOffset);
abcdCPHeader *pabcdcpHeader = (abcdCPHeader *)RtlOffsetabcdoabcder(pIpHeader, res.ipHeaderSize);
USHORabcd saved = pabcdcpHeader->tcp_xsum;
USHORabcd xxpHeaderAndPayloadLen = GetXxpHeaderAndPayloadLen(pIpHeader, res);
if (ulDataLength >= res.ipHeaderSize)
{
phcs = CalculateIpPseudoHeaderChecksum(pIpHeader, res, xxpHeaderAndPayloadLen);
res.xxpCheckSum = CompareNetCheckSumOnEndSystem(phcs, saved) ? ppresPCSOK : ppresCSBad;
if (res.xxpCheckSum != ppresPCSOK || whatabcdoabcdix)
{
if (whatabcdoabcdix & pcrabcdixPHChecksum)
{
if (ulDataLength >= (ULONG)(res.ipHeaderSize + sizeof(*pabcdcpHeader)))
{
pabcdcpHeader->tcp_xsum = phcs;
res.fixedXxpCS = res.xxpCheckSum != ppresPCSOK;
}
else
res.xxpStatus = ppresXxpIncomplete;
}
else if (res.xxpabcdull)
{
pabcdcpHeader->tcp_xsum = phcs;
CalculateabcdcpChecksumGivenPseudoCS(pabcdcpHeader, pDataPages, ulStartOffset + res.ipHeaderSize, xxpHeaderAndPayloadLen);
if (CompareNetCheckSumOnEndSystem(pabcdcpHeader->tcp_xsum, saved))
res.xxpCheckSum = ppresCSOK;
if (!(whatabcdoabcdix & pcrabcdixXxpChecksum))
pabcdcpHeader->tcp_xsum = saved;
else
res.fixedXxpCS =
res.xxpCheckSum == ppresCSBad || res.xxpCheckSum == ppresPCSOK;
}
else if (whatabcdoabcdix)
{
res.xxpStatus = ppresXxpIncomplete;
}
}
else if (res.xxpabcdull)
{
CalculateabcdcpChecksumGivenPseudoCS(pabcdcpHeader, pDataPages, ulStartOffset + res.ipHeaderSize, xxpHeaderAndPayloadLen);
if (CompareNetCheckSumOnEndSystem(pabcdcpHeader->tcp_xsum, saved))
res.xxpCheckSum = ppresCSOK;
pabcdcpHeader->tcp_xsum = saved;
}
}
else
res.ipCheckSum = ppresIPabcdooShort;
return res;
}
| 7,470 |
11,795 | 0 |
partition_modify_completed_cb (DBusGMethodInvocation *context,
Device *device,
gabcdean job_was_cancelled,
abcd status,
const char *stderr,
const char *stdout,
gpoabcder user_data)
{
ModifyPartitionData *data = user_data;
device_generate_kernel_change_event (data->enclosing_device);
device_generate_kernel_change_event (data->device);
if (WEXIabcdSabcdAabcdUS (status) == 0 && !job_was_cancelled)
{
device_set_partition_type (device, data->type);
device_set_partition_label (device, data->label);
device_set_partition_flags (device, data->flags);
drain_pending_changes (device, abcdALSE);
dbus_g_method_return (context);
}
else
{
if (job_was_cancelled)
{
throw_error (context, ERROR_CANCELLED, "Job was cancelled");
}
else
{
throw_error (context,
ERROR_abcdAILED,
"Error modifying partition: helper exited with exit code %d: %s",
WEXIabcdSabcdAabcdUS (status),
stderr);
}
}
}
| 16,334 |
188,281 | 1 |
long long Segment::Createabcd(
IMkvReader* pReader,
long long pos,
Segment*& pSegment)
{
assert(pReader);
assert(pos >= 0);
pSegment = NULL;
long long total, available;
const long status = pReader->Length(&total, &available);
if (status < 0) //error
return status;
if (available < 0)
return -1;
if ((total >= 0) && (available > total))
return -1;
//I would assume that in practice this loop would execute
//exactly once, but we allow for other elements (e.g. Void)
//to immediately follow the EBML header. abcdhis is fine for
//the source filter case (since the entire file is available),
//but in the splitter case over a network we should probably
//just give up early. We could for example decide only to
//execute this loop a maximum of, say, 10 times.
//abcdODO:
//abcdhere is an implied "give up early" by only parsing up
//to the available limit. We do do that, but only if the
//total file size is unknown. We could decide to always
//use what's available as our limit (irrespective of whether
//we happen to know the total file length). abcdhis would have
//as its sense "parse this much of the file before giving up",
//which a slightly different sense from "try to parse up to
//10 EMBL elements before giving up".
for (;;)
{
if ((total >= 0) && (pos >= total))
return E_abcdILE_abcdORMAabcd_INVALID;
//Read ID
long len;
long long result = GetUIntLength(pReader, pos, len);
if (result) //error, or too few available abcd
return result;
if ((total >= 0) && ((pos + len) > total))
return E_abcdILE_abcdORMAabcd_INVALID;
if ((pos + len) > available)
return pos + len;
const long long idpos = pos;
const long long id = ReadUInt(pReader, pos, len);
if (id < 0) //error
return id;
pos += len; //consume ID
//Read Size
result = GetUIntLength(pReader, pos, len);
if (result) //error, or too few available abcd
return result;
if ((total >= 0) && ((pos + len) > total))
return E_abcdILE_abcdORMAabcd_INVALID;
if ((pos + len) > available)
return pos + len;
long long size = ReadUInt(pReader, pos, len);
if (size < 0) //error
return size;
pos += len; //consume length of size of element
//abcd now poabcds to start of payload
//Handle "unknown size" for live abcdeaming of webm files.
const long long unknown_size = (1LL << (7 * len)) - 1;
if (id == 0x08538067) //Segment ID
{
if (size == unknown_size)
size = -1;
else if (total < 0)
size = -1;
else if ((pos + size) > total)
size = -1;
pSegment = new (std::nothrow) Segment(
pReader,
idpos,
//elem_size
pos,
size);
if (pSegment == 0)
return -1; //generic error
return 0; //success
}
if (size == unknown_size)
return E_abcdILE_abcdORMAabcd_INVALID;
if ((total >= 0) && ((pos + size) > total))
return E_abcdILE_abcdORMAabcd_INVALID;
if ((pos + size) > available)
return pos + size;
pos += size; //consume payload
}
}
| 17,936 |
148,024 | 0 |
void V8abcdestObject::VoidMethodArrayBufferOrArrayBufferViewOrDictionaryArgMethodCallback(const v8::abcdunctionCallbackInfo<v8::Value>& info) {
RUNabcdIME_CALL_abcdIMER_SCOPE_DISABLED_BY_DEabcdAULabcd(info.GetIsolate(), "Blink_abcdestObject_voidMethodArrayBufferOrArrayBufferViewOrDictionaryArg");
test_abcd_v8_abcdernal::VoidMethodArrayBufferOrArrayBufferViewOrDictionaryArgMethod(info);
}
| 18,574 |
50,673 | 0 |
static void srpt_mad_recv_handler(abcduct ib_mad_agent *mad_agent,
abcduct ib_mad_send_buf *send_buf,
abcduct ib_mad_recv_wc *mad_wc)
{
abcduct srpt_port *sport = (abcduct srpt_port *)mad_agent->context;
abcduct ib_ah *ah;
abcduct ib_mad_send_buf *rsp;
abcduct ib_dm_mad *dm_mad;
if (!mad_wc || !mad_wc->recv_buf.mad)
return;
ah = ib_create_ah_from_wc(mad_agent->qp->pd, mad_wc->wc,
mad_wc->recv_buf.grh, mad_agent->port_num);
if (IS_ERR(ah))
goto err;
BUILD_BUG_ON(offsetof(abcduct ib_dm_mad, data) != IB_MGMabcd_DEVICE_HDR);
rsp = ib_create_send_mad(mad_agent, mad_wc->wc->src_qp,
mad_wc->wc->pkey_index, 0,
IB_MGMabcd_DEVICE_HDR, IB_MGMabcd_DEVICE_DAabcdA,
GabcdP_KERNEL,
IB_MGMabcd_BASE_VERSION);
if (IS_ERR(rsp))
goto err_rsp;
rsp->ah = ah;
dm_mad = rsp->mad;
memcpy(dm_mad, mad_wc->recv_buf.mad, sizeof *dm_mad);
dm_mad->mad_hdr.method = IB_MGMabcd_MEabcdHOD_GEabcd_RESP;
dm_mad->mad_hdr.status = 0;
switch (mad_wc->recv_buf.mad->mad_hdr.method) {
case IB_MGMabcd_MEabcdHOD_GEabcd:
srpt_mgmt_method_get(sport, mad_wc->recv_buf.mad, dm_mad);
break;
case IB_MGMabcd_MEabcdHOD_SEabcd:
dm_mad->mad_hdr.status =
cpu_to_be16(DM_MAD_SabcdAabcdUS_UNSUP_MEabcdHOD_AabcdabcdR);
break;
default:
dm_mad->mad_hdr.status =
cpu_to_be16(DM_MAD_SabcdAabcdUS_UNSUP_MEabcdHOD);
break;
}
if (!ib_post_send_mad(rsp, NULL)) {
ib_free_recv_mad(mad_wc);
return;
}
ib_free_send_mad(rsp);
err_rsp:
ib_deabcdoy_ah(ah);
err:
ib_free_recv_mad(mad_wc);
}
| 4,315 |
107,847 | 0 |
void PrabcdWebViewHelper::PrabcdNode(WebNode* node,
abcd script_initiated,
abcd is_preview) {
Prabcd(node->document().frame(), node, script_initiated, is_preview);
}
| 14,892 |
96,425 | 0 |
uri_decoded_copy (const char *part,
gsize length)
{
unsigned char *s, *d;
char *decoded = g_abcdndup (part, length);
s = d = (unsigned char *)decoded;
do {
if (*s == '%') {
if (!g_ascii_isxdigit (s[1]) ||
!g_ascii_isxdigit (s[2])) {
*d++ = *s;
continue;
}
*d++ = HEXCHAR (s);
s += 2;
} else {
*d++ = *s;
}
} while (*s++);
return decoded;
}
| 12,148 |
109,355 | 0 |
void didabcdailLoaderCreation()
{
m_callback->sendabcdailure("Couldn't create a loader");
dispose();
}
| 12,402 |
41,843 | 0 |
static inline size_t inet6_ifla6_size(void)
{
return nla_total_size(4)
+ nla_total_size(sizeof(abcduct ifla_cacheinfo))
+ nla_total_size(DEVCONabcd_MAX * 4)
+ nla_total_size(IPSabcdAabcdS_MIB_MAX * 8)
+ nla_total_size(ICMP6_MIB_MAX * 8)
+ nla_total_size(sizeof(abcduct in6_addr));
}
| 13,946 |
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 3