unique_id
int64 13
189k
| target
int64 0
1
| code
stringlengths 20
241k
| __index_level_0__
int64 0
18.9k
|
|---|---|---|---|
30,013 | 0 | static void br_multicast_group_expired(unsigned long data)
{
struct net_bridge_mdb_entry *mp = (void *)data;
struct net_bridge *br = mp->br;
struct net_bridge_mdb_htable *mdb;
spin_lock(&br->multicast_lock);
if (!netif_running(br->dev) || timer_pending(&mp->timer))
goto out;
mp->mglist = false;
if (mp->ports)
goto out;
mdb = mlock_dereference(br->mdb, br);
hlist_del_rcu(&mp->hlist[mdb->ver]);
mdb->size--;
call_rcu_bh(&mp->rcu, br_multicast_free_group);
out:
spin_unlock(&br->multicast_lock);
}
| 4,000 |
130,106 | 0 | MasterPreferences::MasterPreferences(const base::CommandLine& cmd_line)
: distribution_(NULL),
preferences_read_from_file_(false),
chrome_(true),
multi_install_(false) {
InitializeFromCommandLine(cmd_line);
}
| 4,001 |
47,825 | 0 | static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
{
static unsigned int pow2_sizes[] = {
1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30
};
return snd_interval_list(hw_param_interval(params, rule->var),
ARRAY_SIZE(pow2_sizes), pow2_sizes, 0);
}
| 4,002 |
118,136 | 0 | WebContentsAndroid::GetJavaObject() {
return base::android::ScopedJavaLocalRef<jobject>(obj_);
}
| 4,003 |
45,331 | 0 | static noinline void copy_for_split(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct btrfs_path *path,
struct extent_buffer *l,
struct extent_buffer *right,
int slot, int mid, int nritems)
{
int data_copy_size;
int rt_data_off;
int i;
struct btrfs_disk_key disk_key;
struct btrfs_map_token token;
btrfs_init_map_token(&token);
nritems = nritems - mid;
btrfs_set_header_nritems(right, nritems);
data_copy_size = btrfs_item_end_nr(l, mid) - leaf_data_end(root, l);
copy_extent_buffer(right, l, btrfs_item_nr_offset(0),
btrfs_item_nr_offset(mid),
nritems * sizeof(struct btrfs_item));
copy_extent_buffer(right, l,
btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) -
data_copy_size, btrfs_leaf_data(l) +
leaf_data_end(root, l), data_copy_size);
rt_data_off = BTRFS_LEAF_DATA_SIZE(root) -
btrfs_item_end_nr(l, mid);
for (i = 0; i < nritems; i++) {
struct btrfs_item *item = btrfs_item_nr(i);
u32 ioff;
ioff = btrfs_token_item_offset(right, item, &token);
btrfs_set_token_item_offset(right, item,
ioff + rt_data_off, &token);
}
btrfs_set_header_nritems(l, mid);
btrfs_item_key(right, &disk_key, 0);
insert_ptr(trans, root, path, &disk_key, right->start,
path->slots[1] + 1, 1);
btrfs_mark_buffer_dirty(right);
btrfs_mark_buffer_dirty(l);
BUG_ON(path->slots[0] != slot);
if (mid <= slot) {
btrfs_tree_unlock(path->nodes[0]);
free_extent_buffer(path->nodes[0]);
path->nodes[0] = right;
path->slots[0] -= mid;
path->slots[1] += 1;
} else {
btrfs_tree_unlock(right);
free_extent_buffer(right);
}
BUG_ON(path->slots[0] < 0);
}
| 4,004 |
1,323 | 0 | void DynamicMetadataProvider::unlock()
{
m_lock->unlock();
}
| 4,005 |
30,061 | 0 | static void vhost_net_zerocopy_done_signal(struct kref *kref)
{
struct vhost_net_ubuf_ref *ubufs;
ubufs = container_of(kref, struct vhost_net_ubuf_ref, kref);
wake_up(&ubufs->wait);
}
| 4,006 |
116,501 | 0 | bool AttachDebuggerFunction::RunImpl() {
if (!InitTabContents())
return false;
std::string version;
EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &version));
if (!webkit_glue::IsInspectorProtocolVersionSupported(version)) {
error_ = ExtensionErrorUtils::FormatErrorMessage(
keys::kProtocolVersionNotSupportedError,
version);
return false;
}
DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
contents_->GetRenderViewHost());
DevToolsClientHost* client_host = DevToolsManager::GetInstance()->
GetDevToolsClientHostFor(agent);
if (client_host != NULL) {
error_ = ExtensionErrorUtils::FormatErrorMessage(
keys::kAlreadyAttachedError,
base::IntToString(tab_id_));
return false;
}
new ExtensionDevToolsClientHost(contents_,
GetExtension()->id(),
GetExtension()->name(),
tab_id_);
SendResponse(true);
return true;
}
| 4,007 |
164,356 | 0 | ExtensionFunction::ResponseAction TabsSetZoomFunction::Run() {
std::unique_ptr<tabs::SetZoom::Params> params(
tabs::SetZoom::Params::Create(*args_));
EXTENSION_FUNCTION_VALIDATE(params);
int tab_id = params->tab_id ? *params->tab_id : -1;
std::string error;
WebContents* web_contents =
GetTabsAPIDefaultWebContents(this, tab_id, &error);
if (!web_contents)
return RespondNow(Error(error));
GURL url(web_contents->GetVisibleURL());
if (extension()->permissions_data()->IsRestrictedUrl(url, &error))
return RespondNow(Error(error));
ZoomController* zoom_controller =
ZoomController::FromWebContents(web_contents);
double zoom_level = params->zoom_factor > 0
? content::ZoomFactorToZoomLevel(params->zoom_factor)
: zoom_controller->GetDefaultZoomLevel();
scoped_refptr<ExtensionZoomRequestClient> client(
new ExtensionZoomRequestClient(extension()));
if (!zoom_controller->SetZoomLevelByClient(zoom_level, client)) {
return RespondNow(Error(tabs_constants::kCannotZoomDisabledTabError));
}
return RespondNow(NoArguments());
}
| 4,008 |
81,195 | 0 | void __tasklet_hi_schedule(struct tasklet_struct *t)
{
__tasklet_schedule_common(t, &tasklet_hi_vec,
HI_SOFTIRQ);
}
| 4,009 |
28,142 | 0 | static int hadamard8_intra8x8_c(/*MpegEncContext*/ void *s, uint8_t *src, uint8_t *dummy, int stride, int h){
int i;
int temp[64];
int sum=0;
av_assert2(h==8);
for(i=0; i<8; i++){
BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0],src[stride*i+1]);
BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2],src[stride*i+3]);
BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4],src[stride*i+5]);
BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6],src[stride*i+7]);
BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
}
for(i=0; i<8; i++){
BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
sum +=
BUTTERFLYA(temp[8*0+i], temp[8*4+i])
+BUTTERFLYA(temp[8*1+i], temp[8*5+i])
+BUTTERFLYA(temp[8*2+i], temp[8*6+i])
+BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
}
sum -= FFABS(temp[8*0] + temp[8*4]); // -mean
return sum;
}
| 4,010 |
10,739 | 0 | static inline void xhci_dma_write_u32s(XHCIState *xhci, dma_addr_t addr,
uint32_t *buf, size_t len)
{
int i;
uint32_t tmp[len / sizeof(uint32_t)];
assert((len % sizeof(uint32_t)) == 0);
for (i = 0; i < (len / sizeof(uint32_t)); i++) {
tmp[i] = cpu_to_le32(buf[i]);
}
pci_dma_write(PCI_DEVICE(xhci), addr, tmp, len);
}
| 4,011 |
61,136 | 0 | scan_file (GFile *file,
SourceInfo *source_info,
CommonJob *job,
GHashTable *scanned)
{
GFileInfo *info;
GError *error;
GQueue *dirs;
GFile *dir;
char *primary;
char *secondary;
char *details;
int response;
dirs = g_queue_new ();
retry:
error = NULL;
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_SIZE,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
job->cancellable,
&error);
if (info)
{
g_autofree char *file_uri = NULL;
file_uri = g_file_get_uri (file);
if (!g_hash_table_contains (scanned, file_uri))
{
g_hash_table_add (scanned, g_strdup (file_uri));
count_file (info, job, source_info);
/* trashing operation doesn't recurse */
if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY &&
source_info->op != OP_KIND_TRASH)
{
g_queue_push_head (dirs, g_object_ref (file));
}
}
g_object_unref (info);
}
else if (job->skip_all_error)
{
g_error_free (error);
skip_file (job, file);
}
else if (IS_IO_ERROR (error, CANCELLED))
{
g_error_free (error);
}
else
{
primary = get_scan_primary (source_info->op);
details = NULL;
if (IS_IO_ERROR (error, PERMISSION_DENIED))
{
secondary = f (_("The file “%B” cannot be handled because you do not have "
"permissions to read it."), file);
}
else
{
secondary = f (_("There was an error getting information about “%B”."), file);
details = error->message;
}
/* set show_all to TRUE here, as we don't know how many
* files we'll end up processing yet.
*/
response = run_warning (job,
primary,
secondary,
details,
TRUE,
CANCEL, SKIP_ALL, SKIP, RETRY,
NULL);
g_error_free (error);
if (response == 0 || response == GTK_RESPONSE_DELETE_EVENT)
{
abort_job (job);
}
else if (response == 1 || response == 2)
{
if (response == 1)
{
job->skip_all_error = TRUE;
}
skip_file (job, file);
}
else if (response == 3)
{
goto retry;
}
else
{
g_assert_not_reached ();
}
}
while (!job_aborted (job) &&
(dir = g_queue_pop_head (dirs)) != NULL)
{
scan_dir (dir, source_info, job, dirs, scanned);
g_object_unref (dir);
}
/* Free all from queue if we exited early */
g_queue_foreach (dirs, (GFunc) g_object_unref, NULL);
g_queue_free (dirs);
}
| 4,012 |
151,420 | 0 | ContentSettingsClient* FrameFetchContext::GetContentSettingsClient() const {
if (IsDetached())
return nullptr;
return GetFrame()->GetContentSettingsClient();
}
| 4,013 |
69,344 | 0 | static int aesni_ccm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const unsigned char *iv, int enc)
{
EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
if (!iv && !key)
return 1;
if (key) {
aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
&cctx->ks.ks);
CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
&cctx->ks, (block128_f) aesni_encrypt);
cctx->str = enc ? (ccm128_f) aesni_ccm64_encrypt_blocks :
(ccm128_f) aesni_ccm64_decrypt_blocks;
cctx->key_set = 1;
}
if (iv) {
memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 15 - cctx->L);
cctx->iv_set = 1;
}
return 1;
}
| 4,014 |
64,946 | 0 | static IW_INLINE void put_raw_sample_16(struct iw_context *ctx, double s,
int x, int y, int channel)
{
size_t z;
unsigned short tmpui16;
tmpui16 = (unsigned short)(0.5+s);
z = y*ctx->img2.bpr + (ctx->img2_numchannels*x + channel)*2;
ctx->img2.pixels[z+0] = (iw_byte)(tmpui16>>8);
ctx->img2.pixels[z+1] = (iw_byte)(tmpui16&0xff);
}
| 4,015 |
144,352 | 0 | void ExtensionInstallPrompt::ConfirmInstall(
Delegate* delegate,
const Extension* extension,
const ShowDialogCallback& show_dialog_callback) {
DCHECK(ui_loop_ == base::MessageLoop::current());
extension_ = extension;
delegate_ = delegate;
prompt_ = new Prompt(INSTALL_PROMPT);
show_dialog_callback_ = show_dialog_callback;
if (extension->is_theme()) {
if (extension->from_webstore() ||
extensions::FeatureSwitch::easy_off_store_install()->IsEnabled()) {
delegate->InstallUIProceed();
return;
}
}
LoadImageIfNeeded();
}
| 4,016 |
64,139 | 0 | static int _server_handle_c(libgdbr_t *g, int (*cmd_cb) (void*, const char*, char*, size_t), void *core_ptr) {
char message[64];
if (send_ack (g) < 0) {
return -1;
}
if (g->data_len > 1) {
return send_msg (g, "E01");
}
if (cmd_cb (core_ptr, "dc", NULL, 0) < 0) {
send_msg (g, "E01");
return -1;
}
snprintf (message, sizeof (message) - 1, "T05thread:%x;", cmd_cb (core_ptr, "dptr", NULL, 0));
return send_msg (g, message);
}
| 4,017 |
155,763 | 0 | v8::Local<v8::Value> SerializedScriptValue::deserialize(MessagePortArray* messagePorts)
{
return deserialize(v8::Isolate::GetCurrent(), messagePorts, 0);
}
| 4,018 |
113,887 | 0 | void HTMLDocumentParser::insert(const SegmentedString& source)
{
if (isStopped())
return;
RefPtr<HTMLDocumentParser> protect(this);
SegmentedString excludedLineNumberSource(source);
excludedLineNumberSource.setExcludeLineNumbers();
m_input.insertAtCurrentInsertionPoint(excludedLineNumberSource);
pumpTokenizerIfPossible(ForceSynchronous);
if (isWaitingForScripts()) {
if (!m_insertionPreloadScanner)
m_insertionPreloadScanner = adoptPtr(new HTMLPreloadScanner(document(), m_options));
m_insertionPreloadScanner->appendToEnd(source);
m_insertionPreloadScanner->scan();
}
endIfDelayed();
}
| 4,019 |
50,143 | 0 | ZEND_MM_BINS_INFO(_ZEND_BIN_ALLOCATOR, x, y)
ZEND_API void* ZEND_FASTCALL _emalloc_large(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
{
ZEND_MM_CUSTOM_ALLOCATOR(size);
return zend_mm_alloc_large(AG(mm_heap), size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
}
| 4,020 |
22,663 | 0 | wait_for_completion_timeout(struct completion *x, unsigned long timeout)
{
return wait_for_common(x, timeout, TASK_UNINTERRUPTIBLE);
}
| 4,021 |
83,299 | 0 | uint8 CSoundFile::GetBestMidiChannel(CHANNELINDEX nChn) const
{
if(nChn >= MAX_CHANNELS)
{
return 0;
}
const ModInstrument *ins = m_PlayState.Chn[nChn].pModInstrument;
if(ins != nullptr)
{
if(ins->nMidiChannel == MidiMappedChannel)
{
return (m_PlayState.Chn[nChn].nMasterChn ? (m_PlayState.Chn[nChn].nMasterChn - 1) : nChn) % 16;
} else if(ins->HasValidMIDIChannel())
{
return (ins->nMidiChannel - 1) & 0x0F;
}
}
return 0;
}
| 4,022 |
20,321 | 0 | static int hardware_enable_all(void)
{
int r = 0;
raw_spin_lock(&kvm_lock);
kvm_usage_count++;
if (kvm_usage_count == 1) {
atomic_set(&hardware_enable_failed, 0);
on_each_cpu(hardware_enable_nolock, NULL, 1);
if (atomic_read(&hardware_enable_failed)) {
hardware_disable_all_nolock();
r = -EBUSY;
}
}
raw_spin_unlock(&kvm_lock);
return r;
}
| 4,023 |
148,347 | 0 | void WebContentsImpl::DidGetRedirectForResourceRequest(
const ResourceRedirectDetails& details) {
for (auto& observer : observers_)
observer.DidGetRedirectForResourceRequest(details);
NotificationService::current()->Notify(
NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
Source<WebContents>(this),
Details<const ResourceRedirectDetails>(&details));
}
| 4,024 |
22,009 | 0 | raptor_rdfxml_end_element_grammar(raptor_parser *rdf_parser,
raptor_rdfxml_element *element)
{
raptor_rdfxml_parser *rdf_xml_parser;
raptor_state state;
int finished;
raptor_xml_element* xml_element = element->xml_element;
raptor_qname* el_qname;
const unsigned char *el_name;
int element_in_rdf_ns;
raptor_uri* element_name_uri;
rdf_xml_parser = (raptor_rdfxml_parser*)rdf_parser->context;
el_qname = raptor_xml_element_get_name(xml_element);
el_name = el_qname->local_name;
element_in_rdf_ns= (el_qname->nspace && el_qname->nspace->is_rdf_ms);
element_name_uri = el_qname->uri;
state = element->state;
#ifdef RAPTOR_DEBUG_VERBOSE
RAPTOR_DEBUG2("Starting in state %s\n", raptor_rdfxml_state_as_string(state));
#endif
finished= 0;
while(!finished) {
switch(state) {
case RAPTOR_STATE_SKIPPING:
finished = 1;
break;
case RAPTOR_STATE_UNKNOWN:
finished = 1;
break;
case RAPTOR_STATE_NODE_ELEMENT_LIST:
if(element_in_rdf_ns &&
raptor_uri_equals(element_name_uri,
RAPTOR_RDF_RDF_URI(rdf_parser->world))) {
/* end of RDF - boo hoo */
state = RAPTOR_STATE_UNKNOWN;
finished = 1;
break;
}
/* When scanning, another element ending is outside the RDF
* world so this can happen without further work
*/
if(RAPTOR_OPTIONS_GET_NUMERIC(rdf_parser, RAPTOR_OPTION_SCANNING)) {
state = RAPTOR_STATE_UNKNOWN;
finished = 1;
break;
}
/* otherwise found some junk after RDF content in an RDF-only
* document (probably never get here since this would be
* a mismatched XML tag and cause an error earlier)
*/
raptor_rdfxml_update_document_locator(rdf_parser);
raptor_parser_warning(rdf_parser,
"Element '%s' ended, expected end of RDF element",
el_name);
state = RAPTOR_STATE_UNKNOWN;
finished = 1;
break;
case RAPTOR_STATE_DESCRIPTION:
case RAPTOR_STATE_NODE_ELEMENT:
case RAPTOR_STATE_PARSETYPE_RESOURCE:
/* If there is a parent element containing this element and
* the parent isn't a description, has an identifier,
* create the statement between this node using parent property
* (Need to check for identifier so that top-level typed nodes
* don't get connect to <rdf:RDF> parent element)
*/
if(state == RAPTOR_STATE_NODE_ELEMENT &&
element->parent && element->parent->subject) {
raptor_rdfxml_generate_statement(rdf_parser,
element->parent->subject,
element_name_uri,
element->subject,
NULL,
element);
} else if(state == RAPTOR_STATE_PARSETYPE_RESOURCE &&
element->parent && element->parent->subject) {
/* Handle rdf:li as the rdf:parseType="resource" property */
if(element_in_rdf_ns &&
raptor_uri_equals(element_name_uri,
RAPTOR_RDF_li_URI(rdf_parser->world))) {
raptor_uri* ordinal_predicate_uri;
element->parent->last_ordinal++;
ordinal_predicate_uri = raptor_new_uri_from_rdf_ordinal(rdf_parser->world, element->parent->last_ordinal);
raptor_rdfxml_generate_statement(rdf_parser,
element->parent->subject,
ordinal_predicate_uri,
element->subject,
element->reified,
element->parent);
raptor_free_uri(ordinal_predicate_uri);
} else {
raptor_rdfxml_generate_statement(rdf_parser,
element->parent->subject,
element_name_uri,
element->subject,
element->reified,
element->parent);
}
}
finished = 1;
break;
case RAPTOR_STATE_PARSETYPE_COLLECTION:
finished = 1;
break;
case RAPTOR_STATE_PARSETYPE_OTHER:
/* FALLTHROUGH */
case RAPTOR_STATE_PARSETYPE_LITERAL:
element->parent->content_type = RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_XML_LITERAL;
raptor_xml_writer_end_element(rdf_xml_parser->xml_writer, xml_element);
finished = 1;
break;
case RAPTOR_STATE_PROPERTYELT:
case RAPTOR_STATE_MEMBER_PROPERTYELT:
/* A property element
* http://www.w3.org/TR/rdf-syntax-grammar/#propertyElt
*
* Literal content part is handled here.
* The element content is handled in the internal states
* Empty content is checked here.
*/
if(element->content_type == RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_PROPERTY_CONTENT) {
if(xml_element->content_cdata_seen)
element->content_type = RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_LITERAL;
else if(xml_element->content_element_seen)
element->content_type = RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_PROPERTIES;
else {
/* Empty Literal */
element->content_type = RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_LITERAL;
}
}
/* Handle terminating a rdf:parseType="Collection" list */
if(element->child_content_type == RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_COLLECTION ||
element->child_content_type == RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_DAML_COLLECTION) {
raptor_term* nil_term;
if(element->child_content_type == RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_DAML_COLLECTION) {
raptor_uri* nil_uri = RAPTOR_DAML_nil_URI(rdf_xml_parser);
nil_term = raptor_new_term_from_uri(rdf_parser->world, nil_uri);
} else {
nil_term = raptor_term_copy(RAPTOR_RDF_nil_term(rdf_parser->world));
}
if(!element->tail_id) {
/* If No List: set object of statement to rdf:nil */
element->object = raptor_term_copy(nil_term);
} else {
raptor_uri* rest_uri = NULL;
raptor_term* tail_id_term;
if(element->child_content_type == RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_DAML_COLLECTION)
rest_uri = RAPTOR_DAML_rest_URI(rdf_xml_parser);
else
rest_uri = RAPTOR_RDF_rest_URI(rdf_parser->world);
tail_id_term = raptor_new_term_from_blank(rdf_parser->world,
element->tail_id);
/* terminate the list */
raptor_rdfxml_generate_statement(rdf_parser,
tail_id_term,
rest_uri,
nil_term,
NULL,
NULL);
raptor_free_term(tail_id_term);
}
raptor_free_term(nil_term);
} /* end rdf:parseType="Collection" termination */
#ifdef RAPTOR_DEBUG_VERBOSE
RAPTOR_DEBUG3("Content type %s (%d)\n",
raptor_rdfxml_element_content_type_as_string(element->content_type),
element->content_type);
#endif
switch(element->content_type) {
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_RESOURCE:
if(raptor_rdfxml_element_has_property_attributes(element) &&
element->child_state == RAPTOR_STATE_DESCRIPTION) {
raptor_parser_error(rdf_parser,
"Property element '%s' has both property attributes and a node element content",
el_name);
state = RAPTOR_STATE_SKIPPING;
element->child_state = RAPTOR_STATE_SKIPPING;
break;
}
if(!element->object) {
if(element->rdf_attr[RDF_NS_resource]) {
raptor_uri* resource_uri;
resource_uri = raptor_new_uri_relative_to_base(rdf_parser->world,
raptor_rdfxml_inscope_base_uri(rdf_parser),
(const unsigned char*)element->rdf_attr[RDF_NS_resource]);
if(!resource_uri)
goto oom;
element->object = raptor_new_term_from_uri(rdf_parser->world,
resource_uri);
raptor_free_uri(resource_uri);
RAPTOR_FREE(char*, element->rdf_attr[RDF_NS_resource]);
element->rdf_attr[RDF_NS_resource] = NULL;
if(!element->object)
goto oom;
element->content_type = RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_RESOURCE;
} else if(element->rdf_attr[RDF_NS_nodeID]) {
unsigned char* resource_id;
resource_id = raptor_world_internal_generate_id(rdf_parser->world,
(unsigned char*)element->rdf_attr[RDF_NS_nodeID]);
if(!resource_id)
goto oom;
element->object = raptor_new_term_from_blank(rdf_parser->world,
resource_id);
RAPTOR_FREE(char*, resource_id);
element->rdf_attr[RDF_NS_nodeID] = NULL;
if(!element->object)
goto oom;
element->content_type = RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_RESOURCE;
if(!raptor_valid_xml_ID(rdf_parser,
element->object->value.blank.string)) {
raptor_parser_error(rdf_parser, "Illegal rdf:nodeID value '%s'", (const char*)element->object->value.blank.string);
state = RAPTOR_STATE_SKIPPING;
element->child_state = RAPTOR_STATE_SKIPPING;
break;
}
} else {
unsigned char* resource_id;
resource_id = raptor_world_generate_bnodeid(rdf_parser->world);
if(!resource_id)
goto oom;
element->object = raptor_new_term_from_blank(rdf_parser->world,
resource_id);
RAPTOR_FREE(char*, resource_id);
if(!element->object)
goto oom;
element->content_type = RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_RESOURCE;
}
if(raptor_rdfxml_process_property_attributes(rdf_parser, element,
element->parent,
element->object))
goto oom;
}
/* We know object is a resource, so delete any unsignficant
* whitespace so that FALLTHROUGH code below finds the object.
*/
if(xml_element->content_cdata_length) {
raptor_free_stringbuffer(xml_element->content_cdata_sb);
xml_element->content_cdata_sb = NULL;
xml_element->content_cdata_length = 0;
}
/* FALLTHROUGH */
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_LITERAL:
if(element->content_type == RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_LITERAL) {
if(RAPTOR_OPTIONS_GET_NUMERIC(rdf_parser, RAPTOR_OPTION_ALLOW_BAGID)) {
/* Only an empty literal can have a rdf:bagID */
if(element->bag) {
if(xml_element->content_cdata_length > 0) {
raptor_parser_error(rdf_parser,
"rdf:bagID is forbidden on a literal property element '%s'.",
el_name);
/* prevent this being used later either */
element->rdf_attr[RDF_NS_bagID] = NULL;
} else {
raptor_rdfxml_generate_statement(rdf_parser,
element->bag,
RAPTOR_RDF_type_URI(rdf_parser->world),
RAPTOR_RDF_Bag_term(rdf_parser->world),
NULL,
NULL);
}
}
} /* if rdf:bagID */
/* If there is empty literal content with properties
* generate a node to hang properties off
*/
if(raptor_rdfxml_element_has_property_attributes(element) &&
xml_element->content_cdata_length > 0) {
raptor_parser_error(rdf_parser,
"Literal property element '%s' has property attributes",
el_name);
state = RAPTOR_STATE_SKIPPING;
element->child_state = RAPTOR_STATE_SKIPPING;
break;
}
if(element->content_type == RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_LITERAL &&
raptor_rdfxml_element_has_property_attributes(element) &&
!element->object) {
unsigned char* object_id;
object_id = raptor_world_generate_bnodeid(rdf_parser->world);
if(!object_id)
goto oom;
element->object = raptor_new_term_from_blank(rdf_parser->world,
object_id);
RAPTOR_FREE(char*, object_id);
if(!element->object)
goto oom;
element->content_type = RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_RESOURCE;
}
if(raptor_rdfxml_process_property_attributes(rdf_parser, element,
element,
element->object))
goto oom;
}
/* just be friendly to older compilers and don't declare
* variables in the middle of a block
*/
if(1) {
raptor_uri *predicate_uri = NULL;
int predicate_ordinal = -1;
raptor_term* object_term = NULL;
if(state == RAPTOR_STATE_MEMBER_PROPERTYELT) {
predicate_ordinal = ++element->parent->last_ordinal;
predicate_uri = raptor_new_uri_from_rdf_ordinal(rdf_parser->world,
predicate_ordinal);
} else {
predicate_uri = element_name_uri;
}
if(element->content_type == RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_LITERAL) {
unsigned char* literal = NULL;
raptor_uri* literal_datatype;
unsigned char* literal_language = NULL;
/* an empty stringbuffer - empty CDATA - is OK */
if(raptor_stringbuffer_length(xml_element->content_cdata_sb)) {
literal = raptor_stringbuffer_as_string(xml_element->content_cdata_sb);
if(!literal)
goto oom;
}
literal_datatype = element->object_literal_datatype;
if(!literal_datatype)
literal_language = (unsigned char*)raptor_sax2_inscope_xml_language(rdf_xml_parser->sax2);
if(!literal_datatype && literal &&
!raptor_unicode_check_utf8_nfc_string(literal,
xml_element->content_cdata_length,
NULL)) {
const char *message;
message = "Property element '%s' has a string not in Unicode Normal Form C: %s";
raptor_rdfxml_update_document_locator(rdf_parser);
if(RAPTOR_OPTIONS_GET_NUMERIC(rdf_parser, RAPTOR_OPTION_NON_NFC_FATAL))
raptor_parser_error(rdf_parser, message, el_name, literal);
else
raptor_parser_warning(rdf_parser, message, el_name, literal);
}
object_term = raptor_new_term_from_literal(rdf_parser->world,
literal,
literal_datatype,
literal_language);
} else {
object_term = raptor_term_copy(element->object);
}
raptor_rdfxml_generate_statement(rdf_parser,
element->parent->subject,
predicate_uri,
object_term,
element->reified,
element->parent);
if(predicate_ordinal >= 0)
raptor_free_uri(predicate_uri);
raptor_free_term(object_term);
}
break;
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_PRESERVED:
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_XML_LITERAL:
{
unsigned char *buffer;
size_t length;
raptor_term* xmlliteral_term = NULL;
if(rdf_xml_parser->xml_writer) {
raptor_xml_writer_flush(rdf_xml_parser->xml_writer);
raptor_free_iostream(rdf_xml_parser->iostream);
rdf_xml_parser->iostream = NULL;
buffer = (unsigned char*)rdf_xml_parser->xml_content;
length = rdf_xml_parser->xml_content_length;
} else {
buffer = raptor_stringbuffer_as_string(xml_element->content_cdata_sb);
length = xml_element->content_cdata_length;
}
if(!raptor_unicode_check_utf8_nfc_string(buffer, length, NULL)) {
const char *message;
message = "Property element '%s' has XML literal content not in Unicode Normal Form C: %s";
raptor_rdfxml_update_document_locator(rdf_parser);
if(RAPTOR_OPTIONS_GET_NUMERIC(rdf_parser, RAPTOR_OPTION_NON_NFC_FATAL))
raptor_parser_error(rdf_parser, message, el_name, buffer);
else
raptor_parser_warning(rdf_parser, message, el_name, buffer);
}
xmlliteral_term = raptor_new_term_from_literal(rdf_parser->world,
buffer,
RAPTOR_RDF_XMLLiteral_URI(rdf_parser->world),
NULL);
if(state == RAPTOR_STATE_MEMBER_PROPERTYELT) {
raptor_uri* predicate_uri;
element->parent->last_ordinal++;
predicate_uri = raptor_new_uri_from_rdf_ordinal(rdf_parser->world, element->parent->last_ordinal);
raptor_rdfxml_generate_statement(rdf_parser,
element->parent->subject,
predicate_uri,
xmlliteral_term,
element->reified,
element->parent);
raptor_free_uri(predicate_uri);
} else {
raptor_rdfxml_generate_statement(rdf_parser,
element->parent->subject,
element_name_uri,
xmlliteral_term,
element->reified,
element->parent);
}
raptor_free_term(xmlliteral_term);
/* Finish the xml writer iostream for parseType="Literal" */
if(rdf_xml_parser->xml_writer) {
raptor_free_xml_writer(rdf_xml_parser->xml_writer);
RAPTOR_FREE(char*, rdf_xml_parser->xml_content);
rdf_xml_parser->xml_content = NULL;
rdf_xml_parser->xml_content_length = 0;
}
}
break;
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_COLLECTION:
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_DAML_COLLECTION:
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_NODES:
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_PROPERTIES:
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_PROPERTY_CONTENT:
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_UNKNOWN:
case RAPTOR_RDFXML_ELEMENT_CONTENT_TYPE_LAST:
default:
raptor_parser_fatal_error(rdf_parser,
"%s: Internal error in state RAPTOR_STATE_PROPERTYELT - got unexpected content type %s (%d)",
__func__,
raptor_rdfxml_element_content_type_as_string(element->content_type),
element->content_type);
} /* end switch */
finished = 1;
break;
case RAPTOR_STATE_INVALID:
default:
raptor_parser_fatal_error(rdf_parser,
"%s: Internal error - unexpected parser state %d - %s",
__func__,
state,
raptor_rdfxml_state_as_string(state));
finished = 1;
} /* end switch */
if(state != element->state) {
element->state = state;
#ifdef RAPTOR_DEBUG_VERBOSE
RAPTOR_DEBUG3("Moved to state %d - %s\n", state,
raptor_rdfxml_state_as_string(state));
#endif
}
} /* end while */
#ifdef RAPTOR_DEBUG_VERBOSE
RAPTOR_DEBUG2("Ending in state %s\n", raptor_rdfxml_state_as_string(state));
#endif
return;
oom:
raptor_parser_fatal_error(rdf_parser, "Out of memory, skipping");
element->state = RAPTOR_STATE_SKIPPING;
}
| 4,025 |
12,406 | 0 | SPL_METHOD(SplObjectStorage, count)
{
spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
return;
}
RETURN_LONG(zend_hash_num_elements(&intern->storage));
} /* }}} */
/* {{{ proto void SplObjectStorage::rewind()
| 4,026 |
73,083 | 0 | BGD_DECLARE(void) gdImageSetBrush (gdImagePtr im, gdImagePtr brush)
{
int i;
im->brush = brush;
if ((!im->trueColor) && (!im->brush->trueColor)) {
for (i = 0; (i < gdImageColorsTotal (brush)); i++) {
int index;
index = gdImageColorResolveAlpha (im,
gdImageRed (brush, i),
gdImageGreen (brush, i),
gdImageBlue (brush, i),
gdImageAlpha (brush, i));
im->brushColorMap[i] = index;
}
}
}
| 4,027 |
137,753 | 0 | HeadlessWebContentsImpl* HeadlessWebContentsImpl::From(
HeadlessBrowser* browser,
content::WebContents* contents) {
return HeadlessWebContentsImpl::From(
browser->GetWebContentsForDevToolsAgentHostId(
content::DevToolsAgentHost::GetOrCreateFor(contents)->GetId()));
}
| 4,028 |
181,897 | 1 | int mif_validate(jas_stream_t *in)
{
uchar buf[MIF_MAGICLEN];
uint_fast32_t magic;
int i;
int n;
assert(JAS_STREAM_MAXPUTBACK >= MIF_MAGICLEN);
/* Read the validation data (i.e., the data used for detecting
the format). */
if ((n = jas_stream_read(in, buf, MIF_MAGICLEN)) < 0) {
return -1;
}
/* Put the validation data back onto the stream, so that the
stream position will not be changed. */
for (i = n - 1; i >= 0; --i) {
if (jas_stream_ungetc(in, buf[i]) == EOF) {
return -1;
}
}
/* Was enough data read? */
if (n < MIF_MAGICLEN) {
return -1;
}
/* Compute the signature value. */
magic = (JAS_CAST(uint_fast32_t, buf[0]) << 24) |
(JAS_CAST(uint_fast32_t, buf[1]) << 16) |
(JAS_CAST(uint_fast32_t, buf[2]) << 8) |
buf[3];
/* Ensure that the signature is correct for this format. */
if (magic != MIF_MAGIC) {
return -1;
}
return 0;
}
| 4,029 |
21,833 | 0 | register_address_increment(struct x86_emulate_ctxt *ctxt, unsigned long *reg, int inc)
{
if (ctxt->ad_bytes == sizeof(unsigned long))
*reg += inc;
else
*reg = (*reg & ~ad_mask(ctxt)) | ((*reg + inc) & ad_mask(ctxt));
}
| 4,030 |
117,037 | 0 | BaseSessionService::BaseSessionService(SessionType type,
Profile* profile,
const FilePath& path)
: profile_(profile),
path_(path),
ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
pending_reset_(false),
commands_since_reset_(0),
save_post_data_(false) {
if (profile) {
DCHECK(!profile->IsOffTheRecord());
const CommandLine* command_line = CommandLine::ForCurrentProcess();
save_post_data_ =
!command_line->HasSwitch(switches::kDisableRestoreSessionState);
}
backend_ = new SessionBackend(type,
profile_ ? profile_->GetPath() : path_);
DCHECK(backend_.get());
if (!RunningInProduction()) {
backend_->Init();
}
}
| 4,031 |
85,400 | 0 | static struct sit_entry_set *grab_sit_entry_set(void)
{
struct sit_entry_set *ses =
f2fs_kmem_cache_alloc(sit_entry_set_slab, GFP_NOFS);
ses->entry_cnt = 0;
INIT_LIST_HEAD(&ses->set_list);
return ses;
}
| 4,032 |
183,385 | 1 | static void prefetch_dec(void)
{
prefetch_table((const void *)&dec_tables, sizeof(dec_tables));
}
| 4,033 |
173,496 | 0 | OMX_ERRORTYPE omx_vdec::set_buffer_req(vdec_allocatorproperty *buffer_prop)
{
OMX_ERRORTYPE eRet = OMX_ErrorNone;
unsigned buf_size = 0;
struct v4l2_format fmt;
struct v4l2_requestbuffers bufreq;
int ret;
DEBUG_PRINT_LOW("SetBufReq IN: ActCnt(%d) Size(%u)",
buffer_prop->actualcount, (unsigned int)buffer_prop->buffer_size);
buf_size = (buffer_prop->buffer_size + buffer_prop->alignment - 1)&(~(buffer_prop->alignment - 1));
if (buf_size != buffer_prop->buffer_size) {
DEBUG_PRINT_ERROR("Buffer size alignment error: Requested(%u) Required(%d)",
(unsigned int)buffer_prop->buffer_size, buf_size);
eRet = OMX_ErrorBadParameter;
} else {
memset(&fmt, 0x0, sizeof(struct v4l2_format));
fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height;
fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width;
if (buffer_prop->buffer_type == VDEC_BUFFER_TYPE_INPUT) {
fmt.type =V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
fmt.fmt.pix_mp.pixelformat = output_capability;
fmt.fmt.pix_mp.plane_fmt[0].sizeimage = buf_size;
} else if (buffer_prop->buffer_type == VDEC_BUFFER_TYPE_OUTPUT) {
fmt.type =V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
fmt.fmt.pix_mp.pixelformat = capture_capability;
} else {
eRet = OMX_ErrorBadParameter;
}
ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt);
if (ret) {
/*TODO: How to handle this case */
DEBUG_PRINT_ERROR("Setting buffer requirements (format) failed %d", ret);
eRet = OMX_ErrorInsufficientResources;
}
bufreq.memory = V4L2_MEMORY_USERPTR;
bufreq.count = buffer_prop->actualcount;
if (buffer_prop->buffer_type == VDEC_BUFFER_TYPE_INPUT) {
bufreq.type=V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
} else if (buffer_prop->buffer_type == VDEC_BUFFER_TYPE_OUTPUT) {
bufreq.type=V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
} else {
eRet = OMX_ErrorBadParameter;
}
if (eRet==OMX_ErrorNone) {
ret = ioctl(drv_ctx.video_driver_fd,VIDIOC_REQBUFS, &bufreq);
}
if (ret) {
DEBUG_PRINT_ERROR("Setting buffer requirements (reqbufs) failed %d", ret);
/*TODO: How to handle this case */
eRet = OMX_ErrorInsufficientResources;
} else if (bufreq.count < buffer_prop->actualcount) {
DEBUG_PRINT_ERROR("Driver refused to change the number of buffers"
" on v4l2 port %d to %d (prefers %d)", bufreq.type,
buffer_prop->actualcount, bufreq.count);
eRet = OMX_ErrorInsufficientResources;
} else {
if (!client_buffers.update_buffer_req()) {
DEBUG_PRINT_ERROR("Setting c2D buffer requirements failed");
eRet = OMX_ErrorInsufficientResources;
}
}
}
return eRet;
}
| 4,034 |
18,817 | 0 | struct cipso_v4_doi *cipso_v4_doi_getdef(u32 doi)
{
struct cipso_v4_doi *doi_def;
rcu_read_lock();
doi_def = cipso_v4_doi_search(doi);
if (doi_def == NULL)
goto doi_getdef_return;
if (!atomic_inc_not_zero(&doi_def->refcount))
doi_def = NULL;
doi_getdef_return:
rcu_read_unlock();
return doi_def;
}
| 4,035 |
118,730 | 0 | String HTMLDocument::dir()
{
HTMLElement* b = body();
if (!b)
return String();
return b->getAttribute(dirAttr);
}
| 4,036 |
105,177 | 0 | ElementShadow* ShadowRoot::owner() const
{
if (host())
return host()->shadow();
return 0;
}
| 4,037 |
35,570 | 0 | static bool emulator_io_port_access_allowed(struct x86_emulate_ctxt *ctxt,
u16 port, u16 len)
{
const struct x86_emulate_ops *ops = ctxt->ops;
struct desc_struct tr_seg;
u32 base3;
int r;
u16 tr, io_bitmap_ptr, perm, bit_idx = port & 0x7;
unsigned mask = (1 << len) - 1;
unsigned long base;
ops->get_segment(ctxt, &tr, &tr_seg, &base3, VCPU_SREG_TR);
if (!tr_seg.p)
return false;
if (desc_limit_scaled(&tr_seg) < 103)
return false;
base = get_desc_base(&tr_seg);
#ifdef CONFIG_X86_64
base |= ((u64)base3) << 32;
#endif
r = ops->read_std(ctxt, base + 102, &io_bitmap_ptr, 2, NULL);
if (r != X86EMUL_CONTINUE)
return false;
if (io_bitmap_ptr + port/8 > desc_limit_scaled(&tr_seg))
return false;
r = ops->read_std(ctxt, base + io_bitmap_ptr + port/8, &perm, 2, NULL);
if (r != X86EMUL_CONTINUE)
return false;
if ((perm >> bit_idx) & mask)
return false;
return true;
}
| 4,038 |
120,301 | 0 | void FolderHeaderView::OnPaint(gfx::Canvas* canvas) {
views::View::OnPaint(canvas);
gfx::Rect rect(GetContentsBounds());
if (rect.IsEmpty() || !folder_name_visible_)
return;
rect.set_x((rect.width() - kBottomSeparatorWidth) / 2 + rect.x());
rect.set_y(rect.y() + rect.height() - kBottomSeparatorHeight);
rect.set_width(kBottomSeparatorWidth);
rect.set_height(kBottomSeparatorHeight);
canvas->FillRect(rect, kTopSeparatorColor);
}
| 4,039 |
102,833 | 0 | void OutdatedPluginInfoBarDelegate::InfoBarDismissed() {
UserMetrics::RecordAction(
UserMetricsAction("OutdatedPluginInfobar.Dismissed"));
}
| 4,040 |
125,220 | 0 | void RenderMessageFilter::OnOpenChannelToPpapiBroker(int routing_id,
int request_id,
const FilePath& path) {
plugin_service_->OpenChannelToPpapiBroker(
render_process_id_,
path,
new OpenChannelToPpapiBrokerCallback(this, routing_id, request_id));
}
| 4,041 |
34,708 | 0 | static int br_nf_dev_queue_xmit(struct sk_buff *skb)
{
return br_dev_queue_push_xmit(skb);
}
| 4,042 |
163,754 | 0 | void DelegatedFrameHost::BeginFrameSubscription(
std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
frame_subscriber_ = std::move(subscriber);
}
| 4,043 |
110,694 | 0 | bool TextureManager::ValidForTarget(
GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth) {
GLsizei max_size = MaxSizeForTarget(target);
return level >= 0 &&
width >= 0 &&
height >= 0 &&
depth >= 0 &&
level < MaxLevelsForTarget(target) &&
width <= max_size &&
height <= max_size &&
depth <= max_size &&
(level == 0 || feature_info_->feature_flags().npot_ok ||
(!GLES2Util::IsNPOT(width) &&
!GLES2Util::IsNPOT(height) &&
!GLES2Util::IsNPOT(depth))) &&
(target != GL_TEXTURE_CUBE_MAP || (width == height && depth == 1)) &&
(target != GL_TEXTURE_2D || (depth == 1));
}
| 4,044 |
141,648 | 0 | V8Console::CommandLineAPIScope::CommandLineAPIScope(v8::Local<v8::Context> context, v8::Local<v8::Object> commandLineAPI, v8::Local<v8::Object> global)
: m_context(context)
, m_commandLineAPI(commandLineAPI)
, m_global(global)
, m_installedMethods(v8::Set::New(context->GetIsolate()))
, m_cleanup(false)
{
v8::Local<v8::Array> names;
if (!m_commandLineAPI->GetOwnPropertyNames(context).ToLocal(&names))
return;
v8::Local<v8::External> externalThis = v8::External::New(context->GetIsolate(), this);
for (size_t i = 0; i < names->Length(); ++i) {
v8::Local<v8::Value> name;
if (!names->Get(context, i).ToLocal(&name) || !name->IsName())
continue;
if (m_global->Has(context, name).FromMaybe(true))
continue;
if (!m_installedMethods->Add(context, name).ToLocal(&m_installedMethods))
continue;
if (!m_global->SetAccessor(context, v8::Local<v8::Name>::Cast(name), CommandLineAPIScope::accessorGetterCallback,
CommandLineAPIScope::accessorSetterCallback, externalThis,
v8::DEFAULT, v8::DontEnum).FromMaybe(false)) {
bool removed = m_installedMethods->Delete(context, name).FromMaybe(false);
DCHECK(removed);
continue;
}
}
}
| 4,045 |
132,902 | 0 | void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
}
| 4,046 |
39,280 | 0 | int security_load_policy(void *data, size_t len)
{
struct policydb *oldpolicydb, *newpolicydb;
struct sidtab oldsidtab, newsidtab;
struct selinux_mapping *oldmap, *map = NULL;
struct convert_context_args args;
u32 seqno;
u16 map_size;
int rc = 0;
struct policy_file file = { data, len }, *fp = &file;
oldpolicydb = kzalloc(2 * sizeof(*oldpolicydb), GFP_KERNEL);
if (!oldpolicydb) {
rc = -ENOMEM;
goto out;
}
newpolicydb = oldpolicydb + 1;
if (!ss_initialized) {
avtab_cache_init();
rc = policydb_read(&policydb, fp);
if (rc) {
avtab_cache_destroy();
goto out;
}
policydb.len = len;
rc = selinux_set_mapping(&policydb, secclass_map,
¤t_mapping,
¤t_mapping_size);
if (rc) {
policydb_destroy(&policydb);
avtab_cache_destroy();
goto out;
}
rc = policydb_load_isids(&policydb, &sidtab);
if (rc) {
policydb_destroy(&policydb);
avtab_cache_destroy();
goto out;
}
security_load_policycaps();
ss_initialized = 1;
seqno = ++latest_granting;
selinux_complete_init();
avc_ss_reset(seqno);
selnl_notify_policyload(seqno);
selinux_status_update_policyload(seqno);
selinux_netlbl_cache_invalidate();
selinux_xfrm_notify_policyload();
goto out;
}
#if 0
sidtab_hash_eval(&sidtab, "sids");
#endif
rc = policydb_read(newpolicydb, fp);
if (rc)
goto out;
newpolicydb->len = len;
/* If switching between different policy types, log MLS status */
if (policydb.mls_enabled && !newpolicydb->mls_enabled)
printk(KERN_INFO "SELinux: Disabling MLS support...\n");
else if (!policydb.mls_enabled && newpolicydb->mls_enabled)
printk(KERN_INFO "SELinux: Enabling MLS support...\n");
rc = policydb_load_isids(newpolicydb, &newsidtab);
if (rc) {
printk(KERN_ERR "SELinux: unable to load the initial SIDs\n");
policydb_destroy(newpolicydb);
goto out;
}
rc = selinux_set_mapping(newpolicydb, secclass_map, &map, &map_size);
if (rc)
goto err;
rc = security_preserve_bools(newpolicydb);
if (rc) {
printk(KERN_ERR "SELinux: unable to preserve booleans\n");
goto err;
}
/* Clone the SID table. */
sidtab_shutdown(&sidtab);
rc = sidtab_map(&sidtab, clone_sid, &newsidtab);
if (rc)
goto err;
/*
* Convert the internal representations of contexts
* in the new SID table.
*/
args.oldp = &policydb;
args.newp = newpolicydb;
rc = sidtab_map(&newsidtab, convert_context, &args);
if (rc) {
printk(KERN_ERR "SELinux: unable to convert the internal"
" representation of contexts in the new SID"
" table\n");
goto err;
}
/* Save the old policydb and SID table to free later. */
memcpy(oldpolicydb, &policydb, sizeof(policydb));
sidtab_set(&oldsidtab, &sidtab);
/* Install the new policydb and SID table. */
write_lock_irq(&policy_rwlock);
memcpy(&policydb, newpolicydb, sizeof(policydb));
sidtab_set(&sidtab, &newsidtab);
security_load_policycaps();
oldmap = current_mapping;
current_mapping = map;
current_mapping_size = map_size;
seqno = ++latest_granting;
write_unlock_irq(&policy_rwlock);
/* Free the old policydb and SID table. */
policydb_destroy(oldpolicydb);
sidtab_destroy(&oldsidtab);
kfree(oldmap);
avc_ss_reset(seqno);
selnl_notify_policyload(seqno);
selinux_status_update_policyload(seqno);
selinux_netlbl_cache_invalidate();
selinux_xfrm_notify_policyload();
rc = 0;
goto out;
err:
kfree(map);
sidtab_destroy(&newsidtab);
policydb_destroy(newpolicydb);
out:
kfree(oldpolicydb);
return rc;
}
| 4,047 |
11,737 | 0 | linux_lvm2_lv_stop_completed_cb (DBusGMethodInvocation *context,
Device *device,
gboolean job_was_cancelled,
int status,
const char *stderr,
const char *stdout,
gpointer user_data)
{
if (WEXITSTATUS (status) == 0 && !job_was_cancelled)
{
dbus_g_method_return (context);
}
else
{
if (job_was_cancelled)
{
throw_error (context, ERROR_CANCELLED, "Job was cancelled");
}
else
{
throw_error (context,
ERROR_FAILED,
"Error stopping LVM2 Logical Volume: lvchange exited with exit code %d: %s",
WEXITSTATUS (status),
stderr);
}
}
}
| 4,048 |
169,459 | 0 | void NetworkChangeNotifierMac::Forwarder::Init() {
net_config_watcher_->SetInitialConnectionType();
}
| 4,049 |
12,798 | 0 | SSL_SESSION *SSL_get1_session(SSL *ssl)
/* variant of SSL_get_session: caller really gets something */
{
SSL_SESSION *sess;
/*
* Need to lock this all up rather than just use CRYPTO_add so that
* somebody doesn't free ssl->session between when we check it's non-null
* and when we up the reference count.
*/
CRYPTO_w_lock(CRYPTO_LOCK_SSL_SESSION);
sess = ssl->session;
if (sess)
sess->references++;
CRYPTO_w_unlock(CRYPTO_LOCK_SSL_SESSION);
return (sess);
}
| 4,050 |
130,688 | 0 | static void conditionalAttr3AttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)
{
ExceptionState exceptionState(ExceptionState::SetterContext, "conditionalAttr3", "TestObject", info.Holder(), info.GetIsolate());
TestObject* imp = V8TestObject::toNative(info.Holder());
V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), exceptionState);
imp->setConditionalAttr3(cppValue);
}
| 4,051 |
2,105 | 0 | static void red_channel_client_on_output(void *opaque, int n)
{
RedChannelClient *rcc = opaque;
stat_inc_counter(rcc->channel->out_bytes_counter, n);
}
| 4,052 |
147,984 | 0 | static void UnsignedLongLongAttributeAttributeSetter(
v8::Local<v8::Value> v8_value, const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate();
ALLOW_UNUSED_LOCAL(isolate);
v8::Local<v8::Object> holder = info.Holder();
ALLOW_UNUSED_LOCAL(holder);
TestObject* impl = V8TestObject::ToImpl(holder);
ExceptionState exception_state(isolate, ExceptionState::kSetterContext, "TestObject", "unsignedLongLongAttribute");
uint64_t cpp_value = NativeValueTraits<IDLUnsignedLongLong>::NativeValue(info.GetIsolate(), v8_value, exception_state);
if (exception_state.HadException())
return;
impl->setUnsignedLongLongAttribute(cpp_value);
}
| 4,053 |
64,751 | 0 | static int dns_packet_read_type_window(DnsPacket *p, Bitmap **types, size_t *start) {
uint8_t window;
uint8_t length;
const uint8_t *bitmap;
uint8_t bit = 0;
unsigned i;
bool found = false;
_cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder;
int r;
assert(p);
assert(types);
INIT_REWINDER(rewinder, p);
r = bitmap_ensure_allocated(types);
if (r < 0)
return r;
r = dns_packet_read_uint8(p, &window, NULL);
if (r < 0)
return r;
r = dns_packet_read_uint8(p, &length, NULL);
if (r < 0)
return r;
if (length == 0 || length > 32)
return -EBADMSG;
r = dns_packet_read(p, length, (const void **)&bitmap, NULL);
if (r < 0)
return r;
for (i = 0; i < length; i++) {
uint8_t bitmask = 1 << 7;
if (!bitmap[i]) {
found = false;
bit += 8;
continue;
}
found = true;
while (bitmask) {
if (bitmap[i] & bitmask) {
uint16_t n;
n = (uint16_t) window << 8 | (uint16_t) bit;
/* Ignore pseudo-types. see RFC4034 section 4.1.2 */
if (dns_type_is_pseudo(n))
continue;
r = bitmap_set(*types, n);
if (r < 0)
return r;
}
bit++;
bitmask >>= 1;
}
}
if (!found)
return -EBADMSG;
if (start)
*start = rewinder.saved_rindex;
CANCEL_REWINDER(rewinder);
return 0;
}
| 4,054 |
72,284 | 0 | get_hostkey_public_by_type(int type, int nid, struct ssh *ssh)
{
return get_hostkey_by_type(type, nid, 0, ssh);
}
| 4,055 |
14,125 | 0 | findVisual (ScreenPtr pScreen, VisualID vid)
{
VisualPtr pVisual;
int v;
for (v = 0; v < pScreen->numVisuals; v++)
{
pVisual = pScreen->visuals + v;
if (pVisual->vid == vid)
return pVisual;
}
return 0;
}
| 4,056 |
148,937 | 0 | static int Reinsert(
Rtree *pRtree,
RtreeNode *pNode,
RtreeCell *pCell,
int iHeight
){
int *aOrder;
int *aSpare;
RtreeCell *aCell;
RtreeDValue *aDistance;
int nCell;
RtreeDValue aCenterCoord[RTREE_MAX_DIMENSIONS];
int iDim;
int ii;
int rc = SQLITE_OK;
int n;
memset(aCenterCoord, 0, sizeof(RtreeDValue)*RTREE_MAX_DIMENSIONS);
nCell = NCELL(pNode)+1;
n = (nCell+1)&(~1);
/* Allocate the buffers used by this operation. The allocation is
** relinquished before this function returns.
*/
aCell = (RtreeCell *)sqlite3_malloc(n * (
sizeof(RtreeCell) + /* aCell array */
sizeof(int) + /* aOrder array */
sizeof(int) + /* aSpare array */
sizeof(RtreeDValue) /* aDistance array */
));
if( !aCell ){
return SQLITE_NOMEM;
}
aOrder = (int *)&aCell[n];
aSpare = (int *)&aOrder[n];
aDistance = (RtreeDValue *)&aSpare[n];
for(ii=0; ii<nCell; ii++){
if( ii==(nCell-1) ){
memcpy(&aCell[ii], pCell, sizeof(RtreeCell));
}else{
nodeGetCell(pRtree, pNode, ii, &aCell[ii]);
}
aOrder[ii] = ii;
for(iDim=0; iDim<pRtree->nDim; iDim++){
aCenterCoord[iDim] += DCOORD(aCell[ii].aCoord[iDim*2]);
aCenterCoord[iDim] += DCOORD(aCell[ii].aCoord[iDim*2+1]);
}
}
for(iDim=0; iDim<pRtree->nDim; iDim++){
aCenterCoord[iDim] = (aCenterCoord[iDim]/(nCell*(RtreeDValue)2));
}
for(ii=0; ii<nCell; ii++){
aDistance[ii] = RTREE_ZERO;
for(iDim=0; iDim<pRtree->nDim; iDim++){
RtreeDValue coord = (DCOORD(aCell[ii].aCoord[iDim*2+1]) -
DCOORD(aCell[ii].aCoord[iDim*2]));
aDistance[ii] += (coord-aCenterCoord[iDim])*(coord-aCenterCoord[iDim]);
}
}
SortByDistance(aOrder, nCell, aDistance, aSpare);
nodeZero(pRtree, pNode);
for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){
RtreeCell *p = &aCell[aOrder[ii]];
nodeInsertCell(pRtree, pNode, p);
if( p->iRowid==pCell->iRowid ){
if( iHeight==0 ){
rc = rowidWrite(pRtree, p->iRowid, pNode->iNode);
}else{
rc = parentWrite(pRtree, p->iRowid, pNode->iNode);
}
}
}
if( rc==SQLITE_OK ){
rc = fixBoundingBox(pRtree, pNode);
}
for(; rc==SQLITE_OK && ii<nCell; ii++){
/* Find a node to store this cell in. pNode->iNode currently contains
** the height of the sub-tree headed by the cell.
*/
RtreeNode *pInsert;
RtreeCell *p = &aCell[aOrder[ii]];
rc = ChooseLeaf(pRtree, p, iHeight, &pInsert);
if( rc==SQLITE_OK ){
int rc2;
rc = rtreeInsertCell(pRtree, pInsert, p, iHeight);
rc2 = nodeRelease(pRtree, pInsert);
if( rc==SQLITE_OK ){
rc = rc2;
}
}
}
sqlite3_free(aCell);
return rc;
}
| 4,057 |
97,296 | 0 | static void ignorableWhitespaceHandler(void*, const xmlChar*, int)
{
}
| 4,058 |
38,886 | 0 | dist_ps(PG_FUNCTION_ARGS)
{
Point *pt = PG_GETARG_POINT_P(0);
LSEG *lseg = PG_GETARG_LSEG_P(1);
PG_RETURN_FLOAT8(dist_ps_internal(pt, lseg));
}
| 4,059 |
84,354 | 0 | static TEMPO ConvertTempo(uint16 ciaSpeed)
{
return TEMPO((125.0 * 3546.0) / ciaSpeed);
}
| 4,060 |
73,572 | 0 | static size_t PSDPackbitsEncodeImage(Image *image,const size_t length,
const unsigned char *pixels,unsigned char *compact_pixels,
ExceptionInfo *exception)
{
int
count;
register ssize_t
i,
j;
register unsigned char
*q;
unsigned char
*packbits;
/*
Compress pixels with Packbits encoding.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(pixels != (unsigned char *) NULL);
packbits=(unsigned char *) AcquireQuantumMemory(128UL,sizeof(*packbits));
if (packbits == (unsigned char *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
q=compact_pixels;
for (i=(ssize_t) length; i != 0; )
{
switch (i)
{
case 1:
{
i--;
*q++=(unsigned char) 0;
*q++=(*pixels);
break;
}
case 2:
{
i-=2;
*q++=(unsigned char) 1;
*q++=(*pixels);
*q++=pixels[1];
break;
}
case 3:
{
i-=3;
if ((*pixels == *(pixels+1)) && (*(pixels+1) == *(pixels+2)))
{
*q++=(unsigned char) ((256-3)+1);
*q++=(*pixels);
break;
}
*q++=(unsigned char) 2;
*q++=(*pixels);
*q++=pixels[1];
*q++=pixels[2];
break;
}
default:
{
if ((*pixels == *(pixels+1)) && (*(pixels+1) == *(pixels+2)))
{
/*
Packed run.
*/
count=3;
while (((ssize_t) count < i) && (*pixels == *(pixels+count)))
{
count++;
if (count >= 127)
break;
}
i-=count;
*q++=(unsigned char) ((256-count)+1);
*q++=(*pixels);
pixels+=count;
break;
}
/*
Literal run.
*/
count=0;
while ((*(pixels+count) != *(pixels+count+1)) ||
(*(pixels+count+1) != *(pixels+count+2)))
{
packbits[count+1]=pixels[count];
count++;
if (((ssize_t) count >= (i-3)) || (count >= 127))
break;
}
i-=count;
*packbits=(unsigned char) (count-1);
for (j=0; j <= (ssize_t) count; j++)
*q++=packbits[j];
pixels+=count;
break;
}
}
}
*q++=(unsigned char) 128; /* EOD marker */
packbits=(unsigned char *) RelinquishMagickMemory(packbits);
return((size_t) (q-compact_pixels));
}
| 4,061 |
6,156 | 0 | int tls12_get_sigid(const EVP_PKEY *pk)
{
return tls12_find_id(pk->type, tls12_sig,
sizeof(tls12_sig) / sizeof(tls12_lookup));
}
| 4,062 |
50,866 | 0 | set_date_time_null(unsigned char *p)
{
memset(p, '0', 16);
p[16] = 0;
}
| 4,063 |
28,622 | 0 | int qeth_realloc_buffer_pool(struct qeth_card *card, int bufcnt)
{
QETH_CARD_TEXT(card, 2, "realcbp");
if ((card->state != CARD_STATE_DOWN) &&
(card->state != CARD_STATE_RECOVER))
return -EPERM;
/* TODO: steel/add buffers from/to a running card's buffer pool (?) */
qeth_clear_working_pool_list(card);
qeth_free_buffer_pool(card);
card->qdio.in_buf_pool.buf_count = bufcnt;
card->qdio.init_pool.buf_count = bufcnt;
return qeth_alloc_buffer_pool(card);
}
| 4,064 |
30,958 | 0 | static void ptrace_unfreeze_traced(struct task_struct *task)
{
if (task->state != __TASK_TRACED)
return;
WARN_ON(!task->ptrace || task->parent != current);
spin_lock_irq(&task->sighand->siglock);
if (__fatal_signal_pending(task))
wake_up_state(task, __TASK_TRACED);
else
task->state = TASK_TRACED;
spin_unlock_irq(&task->sighand->siglock);
}
| 4,065 |
176,565 | 0 | xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
void *ioctx, xmlCharEncoding enc) {
xmlParserCtxtPtr ctxt;
xmlParserInputPtr inputStream;
xmlParserInputBufferPtr buf;
if (ioread == NULL) return(NULL);
buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
if (buf == NULL) {
if (ioclose != NULL)
ioclose(ioctx);
return (NULL);
}
ctxt = xmlNewParserCtxt();
if (ctxt == NULL) {
xmlFreeParserInputBuffer(buf);
return(NULL);
}
if (sax != NULL) {
#ifdef LIBXML_SAX1_ENABLED
if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
#endif /* LIBXML_SAX1_ENABLED */
xmlFree(ctxt->sax);
ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
if (ctxt->sax == NULL) {
xmlErrMemory(ctxt, NULL);
xmlFreeParserCtxt(ctxt);
return(NULL);
}
memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
if (sax->initialized == XML_SAX2_MAGIC)
memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
else
memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
if (user_data != NULL)
ctxt->userData = user_data;
}
inputStream = xmlNewIOInputStream(ctxt, buf, enc);
if (inputStream == NULL) {
xmlFreeParserCtxt(ctxt);
return(NULL);
}
inputPush(ctxt, inputStream);
return(ctxt);
}
| 4,066 |
136,966 | 0 | void HTMLInputElement::SetNonDirtyValue(const String& new_value) {
setValue(new_value);
has_dirty_value_ = false;
}
| 4,067 |
8,031 | 0 | static void vnc_listen_regular_read(void *opaque)
{
vnc_listen_read(opaque, false);
}
| 4,068 |
10,374 | 0 | user_local_get_uid (User *user)
{
return user->uid;
}
| 4,069 |
81,601 | 0 | static int regex_match_glob(char *str, struct regex *r, int len __maybe_unused)
{
if (glob_match(r->pattern, str))
return 1;
return 0;
}
| 4,070 |
174,171 | 0 | status_t OMX::updateGraphicBufferInMeta(
node_id node, OMX_U32 port_index,
const sp<GraphicBuffer> &graphicBuffer, buffer_id buffer) {
return findInstance(node)->updateGraphicBufferInMeta(
port_index, graphicBuffer, buffer);
}
| 4,071 |
186,502 | 1 | error::Error GLES2DecoderPassthroughImpl::DoEndQueryEXT(GLenum target,
uint32_t submit_count) {
if (IsEmulatedQueryTarget(target)) {
auto active_query_iter = active_queries_.find(target);
if (active_query_iter == active_queries_.end()) {
InsertError(GL_INVALID_OPERATION, "No active query on target.");
return error::kNoError;
}
if (target == GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM &&
!pending_read_pixels_.empty()) {
GLuint query_service_id = active_query_iter->second.service_id;
pending_read_pixels_.back().waiting_async_pack_queries.insert(
query_service_id);
}
} else {
CheckErrorCallbackState();
api()->glEndQueryFn(target);
if (CheckErrorCallbackState()) {
return error::kNoError;
}
}
DCHECK(active_queries_.find(target) != active_queries_.end());
ActiveQuery active_query = std::move(active_queries_[target]);
active_queries_.erase(target);
PendingQuery pending_query;
pending_query.target = target;
pending_query.service_id = active_query.service_id;
pending_query.shm = std::move(active_query.shm);
pending_query.sync = active_query.sync;
pending_query.submit_count = submit_count;
switch (target) {
case GL_COMMANDS_COMPLETED_CHROMIUM:
pending_query.commands_completed_fence = gl::GLFence::Create();
break;
case GL_READBACK_SHADOW_COPIES_UPDATED_CHROMIUM:
pending_query.buffer_shadow_update_fence = gl::GLFence::Create();
pending_query.buffer_shadow_updates = std::move(buffer_shadow_updates_);
buffer_shadow_updates_.clear();
break;
default:
break;
}
pending_queries_.push_back(std::move(pending_query));
return ProcessQueries(false);
}
| 4,072 |
46,161 | 0 | long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
{
struct open_flags op;
int fd = build_open_flags(flags, mode, &op);
struct filename *tmp;
if (fd)
return fd;
tmp = getname(filename);
if (IS_ERR(tmp))
return PTR_ERR(tmp);
fd = get_unused_fd_flags(flags);
if (fd >= 0) {
struct file *f = do_filp_open(dfd, tmp, &op);
if (IS_ERR(f)) {
put_unused_fd(fd);
fd = PTR_ERR(f);
} else {
fsnotify_open(f);
fd_install(fd, f);
}
}
putname(tmp);
return fd;
}
| 4,073 |
1,143 | 0 | GfxPattern::~GfxPattern() {
}
| 4,074 |
73,830 | 0 | static size_t parse_mb_loc(unsigned *wc, const char *ptr, const char *end)
{
wchar_t wchar;
size_t consumed = 0;
#if defined(HAVE_MBRTOWC)
mbstate_t ps;
memset(&ps, 0, sizeof(ps));
consumed = mbrtowc(&wchar, ptr, end - ptr, &ps);
#elif defined(HAVE_MBTOWC)
consumed = mbtowc(&wchar, ptr, end - ptr);
#endif
if (!consumed || consumed == (size_t) -1) {
return 0;
}
if (wc) {
*wc = wchar;
}
return consumed;
}
| 4,075 |
55,205 | 0 | static void powermate_pulse_led(struct powermate_device *pm, int static_brightness, int pulse_speed,
int pulse_table, int pulse_asleep, int pulse_awake)
{
unsigned long flags;
if (pulse_speed < 0)
pulse_speed = 0;
if (pulse_table < 0)
pulse_table = 0;
if (pulse_speed > 510)
pulse_speed = 510;
if (pulse_table > 2)
pulse_table = 2;
pulse_asleep = !!pulse_asleep;
pulse_awake = !!pulse_awake;
spin_lock_irqsave(&pm->lock, flags);
/* mark state updates which are required */
if (static_brightness != pm->static_brightness) {
pm->static_brightness = static_brightness;
pm->requires_update |= UPDATE_STATIC_BRIGHTNESS;
}
if (pulse_asleep != pm->pulse_asleep) {
pm->pulse_asleep = pulse_asleep;
pm->requires_update |= (UPDATE_PULSE_ASLEEP | UPDATE_STATIC_BRIGHTNESS);
}
if (pulse_awake != pm->pulse_awake) {
pm->pulse_awake = pulse_awake;
pm->requires_update |= (UPDATE_PULSE_AWAKE | UPDATE_STATIC_BRIGHTNESS);
}
if (pulse_speed != pm->pulse_speed || pulse_table != pm->pulse_table) {
pm->pulse_speed = pulse_speed;
pm->pulse_table = pulse_table;
pm->requires_update |= UPDATE_PULSE_MODE;
}
powermate_sync_state(pm);
spin_unlock_irqrestore(&pm->lock, flags);
}
| 4,076 |
7,292 | 0 | hook_fd_set (fd_set *read_fds, fd_set *write_fds, fd_set *exception_fds)
{
struct t_hook *ptr_hook;
int max_fd;
max_fd = 0;
for (ptr_hook = weechat_hooks[HOOK_TYPE_FD]; ptr_hook;
ptr_hook = ptr_hook->next_hook)
{
if (!ptr_hook->deleted)
{
/* skip invalid file descriptors */
if ((fcntl (HOOK_FD(ptr_hook,fd), F_GETFD) == -1)
&& (errno == EBADF))
{
if (HOOK_FD(ptr_hook, error) == 0)
{
HOOK_FD(ptr_hook, error) = errno;
gui_chat_printf (NULL,
_("%sError: bad file descriptor (%d) "
"used in hook_fd"),
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
HOOK_FD(ptr_hook, fd));
}
}
else
{
if (HOOK_FD(ptr_hook, flags) & HOOK_FD_FLAG_READ)
{
FD_SET (HOOK_FD(ptr_hook, fd), read_fds);
if (HOOK_FD(ptr_hook, fd) > max_fd)
max_fd = HOOK_FD(ptr_hook, fd);
}
if (HOOK_FD(ptr_hook, flags) & HOOK_FD_FLAG_WRITE)
{
FD_SET (HOOK_FD(ptr_hook, fd), write_fds);
if (HOOK_FD(ptr_hook, fd) > max_fd)
max_fd = HOOK_FD(ptr_hook, fd);
}
if (HOOK_FD(ptr_hook, flags) & HOOK_FD_FLAG_EXCEPTION)
{
FD_SET (HOOK_FD(ptr_hook, fd), exception_fds);
if (HOOK_FD(ptr_hook, fd) > max_fd)
max_fd = HOOK_FD(ptr_hook, fd);
}
}
}
}
return max_fd;
}
| 4,077 |
137,217 | 0 | int Textfield::GetTextInputFlags() const {
return text_input_flags_;
}
| 4,078 |
152,379 | 0 | void RenderFrameImpl::Initialize() {
is_main_frame_ = !frame_->Parent();
GetLocalRootRenderWidget()->RegisterRenderFrame(this);
RenderFrameImpl* parent_frame =
RenderFrameImpl::FromWebFrame(frame_->Parent());
if (parent_frame) {
previews_state_ = parent_frame->GetPreviewsState();
effective_connection_type_ = parent_frame->GetEffectiveConnectionType();
}
bool is_tracing_rail = false;
bool is_tracing_navigation = false;
TRACE_EVENT_CATEGORY_GROUP_ENABLED("navigation", &is_tracing_navigation);
TRACE_EVENT_CATEGORY_GROUP_ENABLED("rail", &is_tracing_rail);
if (is_tracing_rail || is_tracing_navigation) {
int parent_id = RenderFrame::GetRoutingIdForWebFrame(frame_->Parent());
TRACE_EVENT2("navigation,rail", "RenderFrameImpl::Initialize",
"id", routing_id_,
"parent", parent_id);
}
if (auto* thread = RenderThreadImpl::current()) {
if (auto* controller = thread->low_memory_mode_controller())
controller->OnFrameCreated(IsMainFrame());
}
#if BUILDFLAG(ENABLE_PLUGINS)
new PepperBrowserConnection(this);
#endif
RegisterMojoInterfaces();
GetContentClient()->renderer()->RenderFrameCreated(this);
if (auto* factory = AudioOutputIPCFactory::get())
factory->RegisterRemoteFactory(GetRoutingID(), GetRemoteInterfaces());
AudioRendererSinkCache::ObserveFrame(this);
const base::CommandLine& command_line =
*base::CommandLine::ForCurrentProcess();
if (command_line.HasSwitch(switches::kDomAutomationController))
enabled_bindings_ |= BINDINGS_POLICY_DOM_AUTOMATION;
if (command_line.HasSwitch(switches::kStatsCollectionController))
enabled_bindings_ |= BINDINGS_POLICY_STATS_COLLECTION;
if (base::FeatureList::IsEnabled(network::features::kNetworkService))
frame_request_blocker_ = base::MakeRefCounted<FrameRequestBlocker>();
RenderThread::Get()->AddRoute(routing_id_, this);
}
| 4,079 |
40,602 | 0 | static void __packet_set_status(struct packet_sock *po, void *frame, int status)
{
union tpacket_uhdr h;
h.raw = frame;
switch (po->tp_version) {
case TPACKET_V1:
h.h1->tp_status = status;
flush_dcache_page(pgv_to_page(&h.h1->tp_status));
break;
case TPACKET_V2:
h.h2->tp_status = status;
flush_dcache_page(pgv_to_page(&h.h2->tp_status));
break;
case TPACKET_V3:
default:
WARN(1, "TPACKET version not supported.\n");
BUG();
}
smp_wmb();
}
| 4,080 |
112,466 | 0 | void Document::fullScreenRendererDestroyed()
{
m_fullScreenRenderer = 0;
if (page())
page()->chrome()->client()->fullScreenRendererChanged(0);
}
| 4,081 |
48,398 | 0 | tsize_t t2p_write_pdf_xobject_stream_filter(ttile_t tile, T2P* t2p, TIFF* output){
tsize_t written=0;
char buffer[32];
int buflen=0;
if(t2p->pdf_compression==T2P_COMPRESS_NONE){
return(written);
}
written += t2pWriteFile(output, (tdata_t) "/Filter ", 8);
switch(t2p->pdf_compression){
#ifdef CCITT_SUPPORT
case T2P_COMPRESS_G4:
written += t2pWriteFile(output, (tdata_t) "/CCITTFaxDecode ", 16);
written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
written += t2pWriteFile(output, (tdata_t) "<< /K -1 ", 9);
if(tile==0){
written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
buflen=snprintf(buffer, sizeof(buffer), "%lu",
(unsigned long)t2p->tiff_width);
check_snprintf_ret(t2p, buflen, buffer);
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
buflen=snprintf(buffer, sizeof(buffer), "%lu",
(unsigned long)t2p->tiff_length);
check_snprintf_ret(t2p, buflen, buffer);
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
} else {
if(t2p_tile_is_right_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)==0){
written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
buflen=snprintf(buffer, sizeof(buffer), "%lu",
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilewidth);
check_snprintf_ret(t2p, buflen, buffer);
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
} else {
written += t2pWriteFile(output, (tdata_t) "/Columns ", 9);
buflen=snprintf(buffer, sizeof(buffer), "%lu",
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilewidth);
check_snprintf_ret(t2p, buflen, buffer);
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
}
if(t2p_tile_is_bottom_edge(t2p->tiff_tiles[t2p->pdf_page], tile-1)==0){
written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
buflen=snprintf(buffer, sizeof(buffer), "%lu",
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_tilelength);
check_snprintf_ret(t2p, buflen, buffer);
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
} else {
written += t2pWriteFile(output, (tdata_t) " /Rows ", 7);
buflen=snprintf(buffer, sizeof(buffer), "%lu",
(unsigned long)t2p->tiff_tiles[t2p->pdf_page].tiles_edgetilelength);
check_snprintf_ret(t2p, buflen, buffer);
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
}
}
if(t2p->pdf_switchdecode == 0){
written += t2pWriteFile(output, (tdata_t) " /BlackIs1 true ", 16);
}
written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
break;
#endif
#ifdef JPEG_SUPPORT
case T2P_COMPRESS_JPEG:
written += t2pWriteFile(output, (tdata_t) "/DCTDecode ", 11);
if(t2p->tiff_photometric != PHOTOMETRIC_YCBCR) {
written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
written += t2pWriteFile(output, (tdata_t) "<< /ColorTransform 1 >>\n", 24);
}
break;
#endif
#ifdef ZIP_SUPPORT
case T2P_COMPRESS_ZIP:
written += t2pWriteFile(output, (tdata_t) "/FlateDecode ", 13);
if(t2p->pdf_compressionquality%100){
written += t2pWriteFile(output, (tdata_t) "/DecodeParms ", 13);
written += t2pWriteFile(output, (tdata_t) "<< /Predictor ", 14);
buflen=snprintf(buffer, sizeof(buffer), "%u", t2p->pdf_compressionquality%100);
check_snprintf_ret(t2p, buflen, buffer);
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
written += t2pWriteFile(output, (tdata_t) " /Columns ", 10);
buflen = snprintf(buffer, sizeof(buffer), "%lu",
(unsigned long)t2p->tiff_width);
check_snprintf_ret(t2p, buflen, buffer);
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
written += t2pWriteFile(output, (tdata_t) " /Colors ", 9);
buflen=snprintf(buffer, sizeof(buffer), "%u", t2p->tiff_samplesperpixel);
check_snprintf_ret(t2p, buflen, buffer);
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
written += t2pWriteFile(output, (tdata_t) " /BitsPerComponent ", 19);
buflen=snprintf(buffer, sizeof(buffer), "%u", t2p->tiff_bitspersample);
check_snprintf_ret(t2p, buflen, buffer);
written += t2pWriteFile(output, (tdata_t) buffer, buflen);
written += t2pWriteFile(output, (tdata_t) ">>\n", 3);
}
break;
#endif
default:
break;
}
return(written);
}
| 4,082 |
101,434 | 0 | virtual void TearDown() {
session_.reset();
context_.reset();
}
| 4,083 |
102,349 | 0 | string16 PolicyStatusInfo::GetSourceTypeString(
PolicySourceType source_type) {
static const char* strings[] = { "user", "device", "undefined" };
DCHECK(static_cast<size_t>(source_type) < arraysize(strings));
return ASCIIToUTF16(strings[source_type]);
}
| 4,084 |
26,020 | 0 | static struct perf_callchain_entry *perf_callchain(struct pt_regs *regs)
{
int rctx;
struct perf_callchain_entry *entry;
entry = get_callchain_entry(&rctx);
if (rctx == -1)
return NULL;
if (!entry)
goto exit_put;
entry->nr = 0;
if (!user_mode(regs)) {
perf_callchain_store(entry, PERF_CONTEXT_KERNEL);
perf_callchain_kernel(entry, regs);
if (current->mm)
regs = task_pt_regs(current);
else
regs = NULL;
}
if (regs) {
perf_callchain_store(entry, PERF_CONTEXT_USER);
perf_callchain_user(entry, regs);
}
exit_put:
put_callchain_entry(rctx);
return entry;
}
| 4,085 |
152,732 | 0 | virtual std::unique_ptr<HistogramBase> HeapAlloc(const BucketRanges* ranges) {
return WrapUnique(new Histogram(name_, minimum_, maximum_, ranges));
}
| 4,086 |
46,298 | 0 | ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
struct file *file = iocb->ki_filp;
struct inode *inode = file_inode(iocb->ki_filp);
struct mutex *aio_mutex = NULL;
struct blk_plug plug;
int o_direct = file->f_flags & O_DIRECT;
int overwrite = 0;
size_t length = iov_iter_count(from);
ssize_t ret;
loff_t pos = iocb->ki_pos;
/*
* Unaligned direct AIO must be serialized; see comment above
* In the case of O_APPEND, assume that we must always serialize
*/
if (o_direct &&
ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
!is_sync_kiocb(iocb) &&
(file->f_flags & O_APPEND ||
ext4_unaligned_aio(inode, from, pos))) {
aio_mutex = ext4_aio_mutex(inode);
mutex_lock(aio_mutex);
ext4_unwritten_wait(inode);
}
mutex_lock(&inode->i_mutex);
if (file->f_flags & O_APPEND)
iocb->ki_pos = pos = i_size_read(inode);
/*
* If we have encountered a bitmap-format file, the size limit
* is smaller than s_maxbytes, which is for extent-mapped files.
*/
if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
if ((pos > sbi->s_bitmap_maxbytes) ||
(pos == sbi->s_bitmap_maxbytes && length > 0)) {
mutex_unlock(&inode->i_mutex);
ret = -EFBIG;
goto errout;
}
if (pos + length > sbi->s_bitmap_maxbytes)
iov_iter_truncate(from, sbi->s_bitmap_maxbytes - pos);
}
if (o_direct) {
blk_start_plug(&plug);
iocb->private = &overwrite;
/* check whether we do a DIO overwrite or not */
if (ext4_should_dioread_nolock(inode) && !aio_mutex &&
!file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
struct ext4_map_blocks map;
unsigned int blkbits = inode->i_blkbits;
int err, len;
map.m_lblk = pos >> blkbits;
map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits)
- map.m_lblk;
len = map.m_len;
err = ext4_map_blocks(NULL, inode, &map, 0);
/*
* 'err==len' means that all of blocks has
* been preallocated no matter they are
* initialized or not. For excluding
* unwritten extents, we need to check
* m_flags. There are two conditions that
* indicate for initialized extents. 1) If we
* hit extent cache, EXT4_MAP_MAPPED flag is
* returned; 2) If we do a real lookup,
* non-flags are returned. So we should check
* these two conditions.
*/
if (err == len && (map.m_flags & EXT4_MAP_MAPPED))
overwrite = 1;
}
}
ret = __generic_file_write_iter(iocb, from);
mutex_unlock(&inode->i_mutex);
if (ret > 0) {
ssize_t err;
err = generic_write_sync(file, iocb->ki_pos - ret, ret);
if (err < 0)
ret = err;
}
if (o_direct)
blk_finish_plug(&plug);
errout:
if (aio_mutex)
mutex_unlock(aio_mutex);
return ret;
}
| 4,087 |
159,891 | 0 | void TopSitesImpl::OnNavigationCommitted(const GURL& url) {
DCHECK(thread_checker_.CalledOnValidThread());
if (!loaded_)
return;
if (can_add_url_to_history_.Run(url))
ScheduleUpdateTimer();
}
| 4,088 |
161,232 | 0 | void DevToolsSession::SetBrowserOnly(bool browser_only) {
browser_only_ = browser_only;
dispatcher_->setFallThroughForNotFound(!browser_only);
}
| 4,089 |
164,609 | 0 | std::tuple<scoped_refptr<IndexedDBDatabase>, Status> IndexedDBDatabase::Create(
const base::string16& name,
scoped_refptr<IndexedDBBackingStore> backing_store,
scoped_refptr<IndexedDBFactory> factory,
std::unique_ptr<IndexedDBMetadataCoding> metadata_coding,
const Identifier& unique_identifier,
ScopesLockManager* transaction_lock_manager) {
scoped_refptr<IndexedDBDatabase> database =
IndexedDBClassFactory::Get()->CreateIndexedDBDatabase(
name, backing_store, factory, std::move(metadata_coding),
unique_identifier, transaction_lock_manager);
Status s = database->OpenInternal();
if (!s.ok())
database = nullptr;
return std::tie(database, s);
}
| 4,090 |
164,722 | 0 | WebInputElement GetInputElementById(const WebString& id) {
return GetMainFrame()
->GetDocument()
.GetElementById(id)
.To<WebInputElement>();
}
| 4,091 |
100,506 | 0 | Cache::LRUList* Cache::lruListFor(CachedResource* resource)
{
unsigned accessCount = max(resource->accessCount(), 1U);
unsigned queueIndex = fastLog2(resource->size() / accessCount);
#ifndef NDEBUG
resource->m_lruIndex = queueIndex;
#endif
if (m_allResources.size() <= queueIndex)
m_allResources.grow(queueIndex + 1);
return &m_allResources[queueIndex];
}
| 4,092 |
162,707 | 0 | static inline CanvasImageSource* ToImageSourceInternal(
const CanvasImageSourceUnion& value,
ExceptionState& exception_state) {
if (value.IsCSSImageValue()) {
if (RuntimeEnabledFeatures::CSSPaintAPIEnabled())
return value.GetAsCSSImageValue();
exception_state.ThrowTypeError("CSSImageValue is not yet supported");
return nullptr;
}
if (value.IsHTMLImageElement())
return value.GetAsHTMLImageElement();
if (value.IsHTMLVideoElement()) {
HTMLVideoElement* video = value.GetAsHTMLVideoElement();
video->VideoWillBeDrawnToCanvas();
return video;
}
if (value.IsSVGImageElement())
return value.GetAsSVGImageElement();
if (value.IsHTMLCanvasElement())
return value.GetAsHTMLCanvasElement();
if (value.IsImageBitmap()) {
if (static_cast<ImageBitmap*>(value.GetAsImageBitmap())->IsNeutered()) {
exception_state.ThrowDOMException(
kInvalidStateError, String::Format("The image source is detached"));
return nullptr;
}
return value.GetAsImageBitmap();
}
if (value.IsOffscreenCanvas()) {
if (static_cast<OffscreenCanvas*>(value.GetAsOffscreenCanvas())
->IsNeutered()) {
exception_state.ThrowDOMException(
kInvalidStateError, String::Format("The image source is detached"));
return nullptr;
}
return value.GetAsOffscreenCanvas();
}
NOTREACHED();
return nullptr;
}
| 4,093 |
143,215 | 0 | bool Document::isSecureContext(String& errorMessage, const SecureContextCheck privilegeContextCheck) const
{
if (isSecureContextImpl(privilegeContextCheck))
return true;
errorMessage = SecurityOrigin::isPotentiallyTrustworthyErrorMessage();
return false;
}
| 4,094 |
161,183 | 0 | MediaStreamType video_type() const { return video_type_; }
| 4,095 |
133,953 | 0 | void AppListSyncableService::AddOrUpdateFromSyncItem(AppListItem* app_item) {
if (app_item->id() == kOemFolderId)
return;
SyncItem* sync_item = FindSyncItem(app_item->id());
if (sync_item) {
UpdateAppItemFromSyncItem(sync_item, app_item);
return;
}
CreateSyncItemFromAppItem(app_item);
}
| 4,096 |
73,983 | 0 | parity_next (int parity)
{
switch(parity) {
case P_NONE:
parity = P_EVEN;
break;
case P_EVEN:
parity = P_ODD;
break;
case P_ODD:
parity = P_NONE;
break;
default:
parity = P_NONE;
break;
}
return parity;
}
| 4,097 |
18,340 | 0 | create_window () {
GtkWidget* window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
gtk_widget_set_name (window, "Uzbl browser");
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy_cb), NULL);
g_signal_connect (G_OBJECT (window), "configure-event", G_CALLBACK (configure_event_cb), NULL);
return window;
}
| 4,098 |
6,979 | 0 | tt_cmap6_get_info( TT_CMap cmap,
TT_CMapInfo *cmap_info )
{
FT_Byte* p = cmap->data + 4;
cmap_info->format = 6;
cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
return FT_Err_Ok;
}
| 4,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.