| code,repo_name,path,language,license,size |
| "/* { dg-do compile } */ |
| /* { dg-options ""-mavx512f -O2 -masm=att"" } */ |
| /* { dg-final { scan-assembler-times ""vmovss\[ \\t\]+\\(%\[a-z0-9,]*\\), %xmm\[0-9\]+\{%k\[1-7\]\}(?:\n|\[ \\t\]+#)"" 1 } } */ |
| /* { dg-final { scan-assembler-times ""vmovss\[ \\t\]+\\(%\[a-z0-9,]*\\), %xmm\[0-9\]+\{%k\[1-7\]\}\{z\}(?:\n|\[ \\t\]+#)"" 1 } } */ |
| /* { dg-final { scan-assembler-times ""vmovss\[ \\t\]+%xmm\[0-9\]+, %xmm\[0-9\]+, %xmm\[0-9\]+\{%k\[1-7\]\}(?:\n|\[ \\t\]+#)"" 1 } } */ |
| /* { dg-final { scan-assembler-times ""vmovss\[ \\t\]+%xmm\[0-9\]+, %xmm\[0-9\]+, %xmm\[0-9\]+\{%k\[1-7\]\}\{z\}(?:\n|\[ \\t\]+#)"" 1 } } */ |
| /* { dg-final { scan-assembler-times ""vmovss\[ \\t\]+%xmm\[0-9\]+, \\(%\[a-z0-9,]*\\)\{%k\[1-7\]\}(?:\n|\[ \\t\]+#)"" 1 } } */ |
|
|
| #include <immintrin.h> |
|
|
| volatile __m128 x1, x2, x3; |
| volatile __mmask8 m; |
| float *volatile p; |
|
|
| void extern |
| avx512f_test (void) |
| { |
| x1 = _mm_mask_load_ss (x1, m, p); |
| x1 = _mm_maskz_load_ss (m, p); |
| x1 = _mm_mask_move_ss (x1, m, x2, x3); |
| x1 = _mm_maskz_move_ss (m, x2, x3); |
| _mm_mask_store_ss (p, m, x1); |
| } |
| ",Gurgel100/gcc,gcc/testsuite/gcc.target/i386/avx512f-vmovss-1.c,C,gpl-2.0,1037 |
| "from virtTrinity import picker |
| from virtTrinity.providers.virsh_cmd import data |
| from virtTrinity.providers.virsh_cmd.utils import virsh |
| from virtTrinity.providers.virsh_cmd.picker.command import CmdPicker |
|
|
|
|
| class OptSetPicker(picker.PickerBase): |
| depends_on = CmdPicker |
| data_type = data.VirshOptSet() |
|
|
| types = { |
| ""positive"": { |
| ""patterns"": None, |
| ""data_type"": data.OptSet(), |
| }, |
| ""miss_dep"": { |
| ""patterns"": r""command '.*' requires .* option"", |
| ""data_type"": data.MissingDepOptSet(), |
| }, |
| ""other"": { |
| ""patterns"": [ |
| r""command '.*' doesn't support option --.*"", |
| # r""command or command group '.*' doesn't exist"", |
| ] |
| }, |
| } |
|
|
| def prerequisite(self): |
| return self.test.cmd in virsh.commands |
|
|
| def apply(self, result): |
| self.test.options = result |
| ",Hao-Liu/virt-trinity,virtTrinity/providers/virsh_cmd/picker/optset.py,Python,gpl-2.0,913 |
| "package com.suscipio_solutions.consecro_mud.Abilities.Spells; |
| import java.util.LinkedList; |
| import java.util.Vector; |
|
|
| import com.suscipio_solutions.consecro_mud.Abilities.interfaces.Ability; |
| import com.suscipio_solutions.consecro_mud.Common.interfaces.CMMsg; |
| import com.suscipio_solutions.consecro_mud.Items.interfaces.Item; |
| import com.suscipio_solutions.consecro_mud.Items.interfaces.Wearable; |
| import com.suscipio_solutions.consecro_mud.Locales.interfaces.Room; |
| import com.suscipio_solutions.consecro_mud.MOBS.interfaces.MOB; |
| import com.suscipio_solutions.consecro_mud.core.CMClass; |
| import com.suscipio_solutions.consecro_mud.core.CMLib; |
| import com.suscipio_solutions.consecro_mud.core.CMStrings; |
| import com.suscipio_solutions.consecro_mud.core.interfaces.Environmental; |
| import com.suscipio_solutions.consecro_mud.core.interfaces.Physical; |
|
|
|
|
| @SuppressWarnings(""rawtypes"") |
| public class Spell_SpyingStone extends Spell |
| { |
| @Override public String ID() { return ""Spell_SpyingStone""; } |
| private final static String localizedName = CMLib.lang().L(""Spying Stone""); |
| @Override public String name() { return localizedName; } |
| private final static String localizedStaticDisplay = CMLib.lang().L(""(Spying Stone)""); |
| @Override public String displayText() { return localizedStaticDisplay; } |
| @Override protected int canAffectCode(){return CAN_ITEMS;} |
| @Override protected int canTargetCode(){return Ability.CAN_ITEMS;} |
| @Override public int classificationCode(){return Ability.ACODE_SPELL|Ability.DOMAIN_DIVINATION;} |
| @Override public int abstractQuality(){ return Ability.QUALITY_INDIFFERENT;} |
|
|
| protected LinkedList<String> msgs=new LinkedList<String>(); |
|
|
| @Override |
| public void executeMsg(final Environmental myHost, final CMMsg msg) |
| { |
| super.executeMsg(myHost, msg); |
| if((msg.targetMinor()==CMMsg.TYP_SPEAK) |
| &&((msg.source()==invoker()) |
| ||((invoker()!=null) && msg.source().Name().equalsIgnoreCase(invoker().Name()))) |
| &&(msg.target()==affected) |
| &&(msg.sourceMessage().toUpperCase().indexOf(""SPEAK"")>=0)) |
| { |
| final Room room=CMLib.map().roomLocation(affected); |
| if(room!=null) |
| { |
| final StringBuilder str=new StringBuilder(""""); |
| for(final String m : msgs) |
| str.append(m).append(""\n\r""); |
| if(str.length()==0) str.append(L(""Nothing!"")); |
| room.showHappens(CMMsg.MSG_SPEAK, affected,L(""^S<S-NAME> grow(s) a mouth and say(s) '^N@x1^S'^N"",str.toString())); |
| msgs.clear(); |
| } |
| } |
| else |
| if((msg.othersCode()!=CMMsg.NO_EFFECT) |
| &&(msg.othersMessage()!=null) |
| &&(msg.othersMessage().length()>0)) |
| msgs.add(CMLib.coffeeFilter().fullOutFilter(null, null, msg.source(), msg.target(), msg.tool(), CMStrings.removeColors(msg.othersMessage()), false)); |
| } |
|
|
| @Override |
| public boolean invoke(MOB mob, Vector commands, Physical givenTarget, boolean auto, int asLevel) |
| { |
| final Physical target=getTarget(mob,mob.location(),givenTarget,commands,Wearable.FILTER_ANY); |
| if(target==null) return false; |
|
|
| if(!(target instanceof Item)) |
| { |
| mob.tell(L(""You can't cast this spell on that."")); |
| return false; |
| } |
| |
| if(target.fetchEffect(this.ID())!=null) |
| { |
| mob.tell(L(""@x1 is already a spying stone!"",target.name(mob))); |
| return false; |
| } |
| |
| if(!super.invoke(mob,commands,givenTarget,auto,asLevel)) |
| return false; |
| |
| final boolean success=proficiencyCheck(mob,0,auto); |
| |
| if(success) |
| { |
| final CMMsg msg=CMClass.getMsg(mob,target,this,verbalCastCode(mob,target,auto),auto?"""":L(""^S<S-NAME> point(s) <S-HIS-HER> finger at <T-NAMESELF>, incanting.^?"")); |
| if(mob.location().okMessage(mob,msg)) |
| { |
| mob.location().send(mob,msg); |
| beneficialAffect(mob,target,asLevel,0); |
| mob.location().show(mob,target,CMMsg.MSG_OK_VISUAL,L(""<T-NAME> open(s) a pair of strange eyes, which become transluscent."")); |
| } |
| } |
| else |
| beneficialWordsFizzle(mob,target,L(""<S-NAME> point(s) at <T-NAMESELF>, incanting, but nothing happens."")); |
| |
| |
| // return whether it worked |
| return success; |
| } |
| } |
| ",ConsecroMUD/ConsecroMUD,com/suscipio_solutions/consecro_mud/Abilities/Spells/Spell_SpyingStone.java,Java,apache-2.0,3919 |
| "# -*- encoding: utf-8 -*- |
| ''' |
| HubbleStack Nebula-to-Splunk returner |
|
|
| Deliver HubbleStack Nebula query data into Splunk using the HTTP |
| event collector. Required config/pillar settings: |
|
|
| .. code-block:: yaml |
|
|
| hubblestack: |
| returner: |
| splunk: |
| - token: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX |
| indexer: splunk-indexer.domain.tld |
| index: hubble |
| sourcetype_nebula: hubble_osquery |
|
|
| You can also add a `custom_fields` argument which is a list of keys to add to |
| events with using the results of config.get(<custom_field>). These new keys |
| will be prefixed with 'custom_' to prevent conflicts. The values of these keys |
| should be strings or lists (will be sent as CSV string), do not choose grains |
| or pillar values with complex values or they will be skipped. |
|
|
| Additionally, you can define a fallback_indexer which will be used if a default |
| gateway is not defined. |
|
|
| .. code-block:: yaml |
|
|
| hubblestack: |
| returner: |
| splunk: |
| - token: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX |
| indexer: splunk-indexer.domain.tld |
| index: hubble |
| sourcetype_nebula: hubble_osquery |
| fallback_indexer: splunk-indexer.loc.domain.tld |
| custom_fields: |
| - site |
| - product_group |
| ''' |
| import socket |
| |
| # Imports for http event forwarder |
| import requests |
| import json |
| import time |
| from datetime import datetime |
| from hubblestack.hec import http_event_collector, get_splunk_options, make_hec_args |
| |
| import logging |
| |
| _max_content_bytes = 100000 |
| http_event_collector_debug = False |
| RETRY = False |
| |
| log = logging.getLogger(__name__) |
| |
| |
| def returner(ret): |
| try: |
| opts_list = get_splunk_options( sourcetype_nebula='hubble_osquery', |
| add_query_to_sourcetype=True, _nick={'sourcetype_nebula': 'sourcetype'}) |
| |
| for opts in opts_list: |
| logging.debug('Options: %s' % json.dumps(opts)) |
| custom_fields = opts['custom_fields'] |
| |
| # Set up the fields to be extracted at index time. The field values must be strings. |
| # Note that these fields will also still be available in the event data |
| index_extracted_fields = [] |
| try: |
| index_extracted_fields.extend(__opts__.get('splunk_index_extracted_fields', [])) |
| except TypeError: |
| pass |
| |
| # Set up the collector |
| args, kwargs = make_hec_args(opts) |
| hec = http_event_collector(*args, **kwargs) |
| |
| # st = 'salt:hubble:nova' |
| data = ret['return'] |
| minion_id = ret['id'] |
| jid = ret['jid'] |
| global RETRY |
| RETRY = ret['retry'] |
| master = __grains__['master'] |
| fqdn = __grains__['fqdn'] |
| # Sometimes fqdn is blank. If it is, replace it with minion_id |
| fqdn = fqdn if fqdn else minion_id |
| try: |
| fqdn_ip4 = __grains__.get('local_ip4') |
| if not fqdn_ip4: |
| fqdn_ip4 = __grains__['fqdn_ip4'][0] |
| except IndexError: |
| try: |
| fqdn_ip4 = __grains__['ipv4'][0] |
| except IndexError: |
| raise Exception('No ipv4 grains found. Is net-tools installed?') |
| if fqdn_ip4.startswith('127.'): |
| for ip4_addr in __grains__['ipv4']: |
| if ip4_addr and not ip4_addr.startswith('127.'): |
| fqdn_ip4 = ip4_addr |
| break |
| local_fqdn = __grains__.get('local_fqdn', __grains__['fqdn']) |
| |
| # Sometimes fqdn reports a value of localhost. If that happens, try another method. |
| bad_fqdns = ['localhost', 'localhost.localdomain', 'localhost6.localdomain6'] |
| if fqdn in bad_fqdns: |
| new_fqdn = socket.gethostname() |
| if '.' not in new_fqdn or new_fqdn in bad_fqdns: |
| new_fqdn = fqdn_ip4 |
| fqdn = new_fqdn |
| |
| # Get cloud details |
| cloud_details = __grains__.get('cloud_details', {}) |
| |
| if not data: |
| return |
| else: |
| for query in data: |
| for query_name, query_results in query.iteritems(): |
| if 'data' not in query_results: |
| query_results['data'] = [{'error': 'result missing'}] |
| for query_result in query_results['data']: |
| event = {} |
| payload = {} |
| event.update(query_result) |
| event.update({'query': query_name}) |
| event.update({'job_id': jid}) |
| event.update({'master': master}) |
| event.update({'minion_id': minion_id}) |
| event.update({'dest_host': fqdn}) |
| event.update({'dest_ip': fqdn_ip4}) |
| event.update({'dest_fqdn': local_fqdn}) |
| event.update({'system_uuid': __grains__.get('system_uuid')}) |
| |
| event.update(cloud_details) |
| |
| for custom_field in custom_fields: |
| custom_field_name = 'custom_' + custom_field |
| custom_field_value = __salt__['config.get'](custom_field, '') |
| if isinstance(custom_field_value, (str, unicode)): |
| event.update({custom_field_name: custom_field_value}) |
| elif isinstance(custom_field_value, list): |
| custom_field_value = ','.join(custom_field_value) |
| event.update({custom_field_name: custom_field_value}) |
| |
| payload.update({'host': fqdn}) |
| payload.update({'index': opts['index']}) |
| if opts['add_query_to_sourcetype']: |
| payload.update({'sourcetype': ""%s_%s"" % (opts['sourcetype'], query_name)}) |
| else: |
| payload.update({'sourcetype': opts['sourcetype']}) |
| |
| # Remove any empty fields from the event payload |
| remove_keys = [k for k in event if event[k] == """"] |
| for k in remove_keys: |
| del event[k] |
| |
| payload.update({'event': event}) |
| |
| # Potentially add metadata fields: |
| fields = {} |
| for item in index_extracted_fields: |
| if item in payload['event'] and not isinstance(payload['event'][item], (list, dict, tuple)): |
| fields[""meta_%s"" % item] = str(payload['event'][item]) |
| if fields: |
| payload.update({'fields': fields}) |
| |
| # If the osquery query includes a field called 'time' it will be checked. |
| # If it's within the last year, it will be used as the eventtime. |
| event_time = query_result.get('time', '') |
| try: |
| if (datetime.fromtimestamp(time.time()) - datetime.fromtimestamp(float(event_time))).days > 365: |
| event_time = '' |
| except Exception: |
| event_time = '' |
| finally: |
| hec.batchEvent(payload, eventtime=event_time) |
|
|
| hec.flushBatch() |
| except Exception: |
| log.exception('Error ocurred in splunk_nebula_return') |
| return |
| ",basepi/hubble,hubblestack/extmods/returners/splunk_nebula_return.py,Python,apache-2.0,7889 |
| "// Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
|
|
| #ifndef CHROME_BROWSER_UI_VIEWS_TAB_ICON_VIEW_MODEL_H_ |
| #define CHROME_BROWSER_UI_VIEWS_TAB_ICON_VIEW_MODEL_H_ |
|
|
| namespace ui { |
| class ImageModel; |
| } // namespace ui |
|
|
| // Classes implement this interface to provide state for the TabIconView. |
| class TabIconViewModel { |
| public: |
| // Returns true if the TabIconView should show a loading animation. |
| virtual bool ShouldTabIconViewAnimate() const = 0; |
|
|
| // Returns the favicon to display in the icon view |
| virtual ui::ImageModel GetFaviconForTabIconView() = 0; |
|
|
| protected: |
| virtual ~TabIconViewModel() {} |
| }; |
|
|
| #endif // CHROME_BROWSER_UI_VIEWS_TAB_ICON_VIEW_MODEL_H_ |
| ",ric2b/Vivaldi-browser,chromium/chrome/browser/ui/views/tab_icon_view_model.h,C,bsd-3-clause,784 |
| "// |
| // HealthKit.h |
| // HealthKit |
| // |
| // Copyright (c) 2013-2014 Apple Inc. All rights reserved. |
| // |
|
|
| #import <HealthKit/HKActivitySummary.h> |
| #import <HealthKit/HKActivitySummaryQuery.h> |
| #import <HealthKit/HKAnchoredObjectQuery.h> |
| #import <HealthKit/HKCategorySample.h> |
| #import <HealthKit/HKCorrelation.h> |
| #import <HealthKit/HKCorrelationQuery.h> |
| #import <HealthKit/HKDefines.h> |
| #import <HealthKit/HKDeletedObject.h> |
| #import <HealthKit/HKDevice.h> |
| #import <HealthKit/HKHealthStore.h> |
| #import <HealthKit/HKMetadata.h> |
| #import <HealthKit/HKObject.h> |
| #import <HealthKit/HKObjectType.h> |
| #import <HealthKit/HKObserverQuery.h> |
| #import <HealthKit/HKQuantity.h> |
| #import <HealthKit/HKQuantitySample.h> |
| #import <HealthKit/HKQuery.h> |
| #import <HealthKit/HKSample.h> |
| #import <HealthKit/HKSampleQuery.h> |
| #import <HealthKit/HKSource.h> |
| #import <HealthKit/HKSourceQuery.h> |
| #import <HealthKit/HKSourceRevision.h> |
| #import <HealthKit/HKStatistics.h> |
| #import <HealthKit/HKStatisticsCollectionQuery.h> |
| #import <HealthKit/HKStatisticsQuery.h> |
| #import <HealthKit/HKTypeIdentifiers.h> |
| #import <HealthKit/HKUnit.h> |
| #import <HealthKit/HKWorkout.h> |
| #import <HealthKit/HKWorkoutSession.h> |
| ",rweichler/cylinder,deps/iPhoneOS9.3.sdk/System/Library/Frameworks/HealthKit.framework/Headers/HealthKit.h,C,mit,1159 |
| |
