blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a0f1a645f4328ff4a9bd0926adea76cd868c00c2 | fcd4bce0080771389b4a69338ed6443153942183 | /src/imageops.h | c9aec60ce20a49ccb5ddeb53642c788950737b60 | [
"MIT",
"LGPL-2.1-only",
"MPL-1.1",
"LicenseRef-scancode-mame",
"GPL-1.0-or-later",
"Zlib",
"GPL-2.0-only",
"LGPL-2.1-or-later",
"MPL-2.0",
"CC-PDDC",
"LicenseRef-scancode-public-domain",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-brian-gladman-3-clause",
"BSD-3-Clause"... | permissive | wulfebw/retro | d4fcf9229b257b3c495f54b1aeb3ea36004ae4aa | dad4b509e99e729e39a2f27e9ee4120e3b607f58 | refs/heads/master | 2022-10-23T07:17:55.320585 | 2020-06-12T01:38:06 | 2020-06-12T01:38:06 | 260,832,205 | 8 | 1 | MIT | 2020-06-12T01:38:08 | 2020-05-03T05:06:17 | C | UTF-8 | C++ | false | false | 823 | h | #pragma once
#include <cstdint>
#include <cstddef>
namespace Retro {
class Image {
public:
enum class Format {
RGB565,
RGB888,
RGBX888,
G8
};
Image() {}
Image(Format, const void* in, size_t w, size_t h, size_t stride);
Image(Format, void* in, size_t w, size_t h, size_t stride);
Image(const Image&) = default;
void copyTo(Image* other);
void halveTo(Image* other);
void halveToInterlace(Image* other, const Image* old);
void quarterTo(Image* other);
void quarterToInterlace(Image* other, const Image* old);
void divideTo(int divisor, Image* other);
void divideToInterlace(int divisor, Image* other, const Image* old);
private:
void copyDirectlyTo(Image* other);
const void* m_constBuffer = nullptr;
void* m_buffer = nullptr;
size_t m_w;
size_t m_h;
size_t m_stride;
Format m_format;
};
}
| [
"vickipfau@openai.com"
] | vickipfau@openai.com |
c0b770df8b2382ebe28958eff58d367f4c84df04 | ddd4f8d705b12f840d05671bad90a54a1f81d286 | /TCG-LoginServer/NetCore/IHandler.h | d2ab31af604fb964713934f479efb945262dfa5c | [] | no_license | codesafe/TCG-LibUV-Server | bfaa51dc3f57b02ce3656cc3d53cb4656685a53f | b8380b49bf434595a2fb29672439cff13ee82ac9 | refs/heads/master | 2020-08-02T05:25:17.194164 | 2019-10-02T09:48:01 | 2019-10-02T09:48:01 | 211,247,807 | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 1,564 | h | #ifndef HANDLER
#define HANDLER
#include "../Predef.h"
class Session;
class DataBuff;
/*
class IDataBuffer
{
public:
virtual INT32 GetRef() = 0;
virtual BOOL AddRef() = 0;
virtual BOOL Release() = 0;
virtual CHAR* GetData() = 0;
virtual UINT32 GetTotalLenth() = 0;
virtual VOID SetTotalLenth(UINT32 nPos) = 0;
virtual UINT32 GetBodyLenth() = 0;
virtual CHAR* GetBuffer() = 0;
virtual UINT32 GetBufferSize() = 0;
virtual UINT32 CopyFrom(IDataBuffer* pSrcBuffer) = 0;
virtual UINT32 CopyTo(CHAR* pDestBuf, UINT32 dwDestLen) = 0;
};
*/
struct NetPacket
{
NetPacket(UINT64 _sessid = 0, DataBuff* _buffer = NULL, UINT32 _msgid = 0)
{
sessionID = _sessid;
dataBuffer = _buffer;
msgID = _msgid;
}
UINT32 msgID;
UINT64 sessionID;
DataBuff* dataBuffer;
};
/*
// ¼ö½ÅµÈ packet hadle func callback
struct IPacketHandler
{
virtual BOOL onDataHandle(IDataBuffer* pDataBuffer, Session* session) = 0;
virtual BOOL onCloseConnect(Session* session) = 0;
virtual BOOL onNewConnect(Session* session) = 0;
};
struct IPacketDispatcher
{
virtual BOOL dispatchPacket(NetPacket* pNetPacket) = 0;
// virtual BOOL onSecondTimer() = 0;
virtual BOOL onCloseConnect(Session* session) = 0;
virtual BOOL onNewConnect(Session* session) = 0;
};
*/
struct ICallbackHandler
{
virtual BOOL dispatchPacket(NetPacket* packet) = 0;
virtual BOOL onRecvData(DataBuff* dataBuffer, Session* session) = 0;
virtual BOOL onCloseSession(Session* session) = 0;
virtual BOOL onNewSession(Session* session) = 0;
};
#endif
| [
"codesafe@gmail.com"
] | codesafe@gmail.com |
5764a60635efb4b5cb31f66600a23b1e09eb3140 | 2842ca2e1493b03cc2cf54814bc6ab2bf113122a | /solutions/euler11.cpp | df1b036aa4a44d9857c64999806e04c11dc55fd5 | [] | no_license | hwXYZ12/Project-Euler-Cplusplus | 54239a3eb6b0e80a99aa34ffc19bd8d557d40035 | 045d63d06fb6f3f72e850ed0d0596d5f08755375 | refs/heads/master | 2021-01-15T11:29:58.729603 | 2017-08-07T21:08:17 | 2017-08-07T21:08:17 | 99,620,596 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,320 | cpp | // project euler problem 11 - euler11.cpp
// https://projecteuler.net/problem=11 for problem statement
#include <iostream>;
#include <fstream>;
#include <algorithm>;
typedef long long INT;
const char * INPUT_PATH = "euler11input.txt";
const int GRID_SIZE = 20;
const int PROD_SIZE = 4;
int main()
{
using std::ifstream;
// read in a 20x20 grid of numbers
ifstream in;
in.open(INPUT_PATH);
INT data[GRID_SIZE][GRID_SIZE];
int t, col, row;
t = col = row = 0;
while (!in.eof())
{
in >> t;
data[col][row] = t;
++col;
if (col >= GRID_SIZE)
{
++row;
col = 0;
}
}
/* We have 4 directions in our grid
of data that we are interested in:
diagonal left, diagonal right, vertical
and horizontal. We are tasked with finding
the largest product of 4 adjacent values
in any of the 4 directions.*/
INT maxProd = 0, temp = 1;
// compute largest of products in the
// horizontal direction
col = row = 0;
while (row < GRID_SIZE)
{
temp = 1;
for (int i = 0; i < PROD_SIZE; ++i)
{
temp *= data[col+i][row];
}
if (temp >= maxProd)
maxProd = temp;
++col;
if (col >= GRID_SIZE - PROD_SIZE)
{
col = 0;
++row;
}
}
// compute largest of products in the
// vertical direction
col = row = 0;
while (col < GRID_SIZE)
{
temp = 1;
for (int i = 0; i < PROD_SIZE; ++i)
{
temp *= data[col][row+i];
}
if (temp >= maxProd)
maxProd = temp;
++row;
if (row >= GRID_SIZE - PROD_SIZE)
{
row = 0;
++col;
}
}
// compute largest of products in the
// right diagonal direction
col = row = 0;
while (row < GRID_SIZE - PROD_SIZE)
{
temp = 1;
for (int i = 0; i < PROD_SIZE; ++i)
{
temp *= data[col + i][row+i];
}
if (temp >= maxProd)
maxProd = temp;
++col;
if (col >= GRID_SIZE - PROD_SIZE)
{
col = 0;
++row;
}
}
// compute largest of products in the
// left diagonal direction
col = PROD_SIZE - 1;
row = 0;
while (row < GRID_SIZE - PROD_SIZE)
{
temp = 1;
for (int i = 0; i < PROD_SIZE; ++i)
{
temp *= data[col - i][row + i];
}
if (temp >= maxProd)
maxProd = temp;
++col;
if (col >= GRID_SIZE)
{
col = PROD_SIZE - 1;
++row;
}
}
std::cout << "The largest product: " << maxProd;
std::cout << std::endl;
std::cout << "Press ENTER to exit.";
std::cin.get();
return 0;
} | [
"wpolenz@live.com"
] | wpolenz@live.com |
393f686c2462a6644e9df50e7f6af229327d42fc | 3ff1fe3888e34cd3576d91319bf0f08ca955940f | /tcbr/src/v20220217/model/StorageInfo.cpp | 3be25971a9fcc33a9cf7d5753259405d5452fcd8 | [
"Apache-2.0"
] | permissive | TencentCloud/tencentcloud-sdk-cpp | 9f5df8220eaaf72f7eaee07b2ede94f89313651f | 42a76b812b81d1b52ec6a217fafc8faa135e06ca | refs/heads/master | 2023-08-30T03:22:45.269556 | 2023-08-30T00:45:39 | 2023-08-30T00:45:39 | 188,991,963 | 55 | 37 | Apache-2.0 | 2023-08-17T03:13:20 | 2019-05-28T08:56:08 | C++ | UTF-8 | C++ | false | false | 4,852 | cpp | /*
* Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <tencentcloud/tcbr/v20220217/model/StorageInfo.h>
using TencentCloud::CoreInternalOutcome;
using namespace TencentCloud::Tcbr::V20220217::Model;
using namespace std;
StorageInfo::StorageInfo() :
m_regionHasBeenSet(false),
m_bucketHasBeenSet(false),
m_cdnDomainHasBeenSet(false),
m_appIdHasBeenSet(false)
{
}
CoreInternalOutcome StorageInfo::Deserialize(const rapidjson::Value &value)
{
string requestId = "";
if (value.HasMember("Region") && !value["Region"].IsNull())
{
if (!value["Region"].IsString())
{
return CoreInternalOutcome(Core::Error("response `StorageInfo.Region` IsString=false incorrectly").SetRequestId(requestId));
}
m_region = string(value["Region"].GetString());
m_regionHasBeenSet = true;
}
if (value.HasMember("Bucket") && !value["Bucket"].IsNull())
{
if (!value["Bucket"].IsString())
{
return CoreInternalOutcome(Core::Error("response `StorageInfo.Bucket` IsString=false incorrectly").SetRequestId(requestId));
}
m_bucket = string(value["Bucket"].GetString());
m_bucketHasBeenSet = true;
}
if (value.HasMember("CdnDomain") && !value["CdnDomain"].IsNull())
{
if (!value["CdnDomain"].IsString())
{
return CoreInternalOutcome(Core::Error("response `StorageInfo.CdnDomain` IsString=false incorrectly").SetRequestId(requestId));
}
m_cdnDomain = string(value["CdnDomain"].GetString());
m_cdnDomainHasBeenSet = true;
}
if (value.HasMember("AppId") && !value["AppId"].IsNull())
{
if (!value["AppId"].IsString())
{
return CoreInternalOutcome(Core::Error("response `StorageInfo.AppId` IsString=false incorrectly").SetRequestId(requestId));
}
m_appId = string(value["AppId"].GetString());
m_appIdHasBeenSet = true;
}
return CoreInternalOutcome(true);
}
void StorageInfo::ToJsonObject(rapidjson::Value &value, rapidjson::Document::AllocatorType& allocator) const
{
if (m_regionHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "Region";
iKey.SetString(key.c_str(), allocator);
value.AddMember(iKey, rapidjson::Value(m_region.c_str(), allocator).Move(), allocator);
}
if (m_bucketHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "Bucket";
iKey.SetString(key.c_str(), allocator);
value.AddMember(iKey, rapidjson::Value(m_bucket.c_str(), allocator).Move(), allocator);
}
if (m_cdnDomainHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "CdnDomain";
iKey.SetString(key.c_str(), allocator);
value.AddMember(iKey, rapidjson::Value(m_cdnDomain.c_str(), allocator).Move(), allocator);
}
if (m_appIdHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "AppId";
iKey.SetString(key.c_str(), allocator);
value.AddMember(iKey, rapidjson::Value(m_appId.c_str(), allocator).Move(), allocator);
}
}
string StorageInfo::GetRegion() const
{
return m_region;
}
void StorageInfo::SetRegion(const string& _region)
{
m_region = _region;
m_regionHasBeenSet = true;
}
bool StorageInfo::RegionHasBeenSet() const
{
return m_regionHasBeenSet;
}
string StorageInfo::GetBucket() const
{
return m_bucket;
}
void StorageInfo::SetBucket(const string& _bucket)
{
m_bucket = _bucket;
m_bucketHasBeenSet = true;
}
bool StorageInfo::BucketHasBeenSet() const
{
return m_bucketHasBeenSet;
}
string StorageInfo::GetCdnDomain() const
{
return m_cdnDomain;
}
void StorageInfo::SetCdnDomain(const string& _cdnDomain)
{
m_cdnDomain = _cdnDomain;
m_cdnDomainHasBeenSet = true;
}
bool StorageInfo::CdnDomainHasBeenSet() const
{
return m_cdnDomainHasBeenSet;
}
string StorageInfo::GetAppId() const
{
return m_appId;
}
void StorageInfo::SetAppId(const string& _appId)
{
m_appId = _appId;
m_appIdHasBeenSet = true;
}
bool StorageInfo::AppIdHasBeenSet() const
{
return m_appIdHasBeenSet;
}
| [
"tencentcloudapi@tencent.com"
] | tencentcloudapi@tencent.com |
ad4220676c67c032c09420433146edaba7493ff0 | 0aadbab091314463991d4dbc3ba5a616576861a4 | /Etc/mergesort.cpp | da60d585e68105b7fe253a12003e47a10d02057d | [] | no_license | SilverFloo/Code | cdc0c6fdf8650d25a4b30ed4aaf577523021945a | 45a75e2dd42e2bb551f330ddbeee8d25b841f2b0 | refs/heads/master | 2022-12-15T10:04:19.562501 | 2020-09-02T14:34:54 | 2020-09-02T14:34:54 | 264,585,867 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 698 | cpp | #include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
using namespace std;
void merge(int* l, int* r){
if (r - l <= 1) return;
auto m = l + (r - l) / 2;
merge(l, m);
merge(m, r);
std::vector<int> ans;
int *pl = l, *pr = m;
while(pl != m and pr != r){
ans.push_back(*pl < *pr ? *pl++ : *pr++);
}
while (pl != m) ans.push_back(*pl++);
while (pr != r) ans.push_back(*pr++);
if(r == std::copy(ans.begin(), ans.end(), l));
else exit(1);
}
int main(){
int n;
int ar[100];
cin >> n;
for (int i = 0; i != n; ++i) cin >> ar[i];
merge(ar, ar + n);
for (int i = 0; i != n; ++i) cout << ar[i] << ' ';
}
| [
"aapimrak@gmail.com"
] | aapimrak@gmail.com |
5e68d6de1bd1b512de51365b9b8272d6a9ca04e5 | ddd475df9583604eff3881b33e2cd1d79224a10a | /IVS_Demo/IVSAlarmPage.cpp | 67bf09b531fbd29488941f7a0d192d595874453b | [] | no_license | RayAndAmanda/-eSDK_IVS_API_Demo_V2.1.00.100_CPP | 5cfdbb50234845f7385c5636192f0cb05e56c464 | 54dab2a003241795c037c2d7a4a80da8ef6eca72 | refs/heads/master | 2022-08-28T14:17:45.093370 | 2022-08-04T02:33:13 | 2022-08-04T02:33:13 | 162,942,430 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 19,113 | cpp | // IVSAlarmPage.cpp : implementation file
//
#include "stdafx.h"
#include "afxdialogex.h"
#include "IVS_Demo.h"
#include "IVSAlarmPage.h"
#include "IVSSDKSheet.h"
// CIVSAlarmPage dialog
IMPLEMENT_DYNAMIC(CIVSAlarmPage, CPropertyPage)
CIVSAlarmPage::CIVSAlarmPage()
: CPropertyPage(CIVSAlarmPage::IDD)
, m_strMaxLevel(_T("100"))
, m_strMinLevel(_T("1"))
{
}
CIVSAlarmPage::~CIVSAlarmPage()
{
ClearDeviceList();
}
void CIVSAlarmPage::DoDataExchange(CDataExchange* pDX)
{
CPropertyPage::DoDataExchange(pDX);
DDX_Control(pDX, IDC_LIST_ALARM, m_listAlarm);
DDX_Control(pDX, IDC_TREE_ALARM_DEVICE, m_treeAlarmDevice);
DDX_Control(pDX, IDC_SLIDER_MIN_LEVEL, m_SliderMin);
DDX_Control(pDX, IDC_SLIDER_MAX_LEVEL, m_SliderMax);
DDX_Text(pDX, IDC_STATIC_MAX_VALUE, m_strMaxLevel);
DDX_Text(pDX, IDC_STATIC_MIN_VALUE, m_strMinLevel);
DDX_Control(pDX, IDC_CHECK__MOVE_DECTION, m_CheckMoveDection);
DDX_Control(pDX, IDC_CHECK_SHIELD, m_CheckShield);
DDX_Control(pDX, IDC_CHECK_NO_SIGNAL, m_CheckNoSignal);
DDX_Control(pDX, IDC_CHECK_SHAKE, m_CheckShake);
DDX_Control(pDX, IDC_CHECK_FACE_RECOGNITION, m_CheckRecognition);
DDX_Control(pDX, IDC_CHECK_BY_ALARM_TYPE, m_CheckByAlarmType);
DDX_Control(pDX, IDC_CHECK_BY_ALARM_LEVEL, m_CheckByAlarmLevel);
DDX_Control(pDX, IDC_CHECK_SUBSCRIBE_ALL, m_CheckSubscribeAll);
DDX_Control(pDX, IDC_CHECK_INTRUSION, m_CheckIntrusion);
DDX_Control(pDX, IDC_STATIC_SUBSCRIBE_ALARM, m_GrpSubscribe);
DDX_Control(pDX, IDC_STATIC_ALARM_REPORT, m_GrpAlarmReport);
DDX_Control(pDX, IDC_STATIC_MIN_LEVEL, m_LabMinLevel);
DDX_Control(pDX, IDC_STATIC_MAX_LEVEL, m_LabMaxLevel);
DDX_Control(pDX, IDC_BUTTON_SUBSCRIBE_ALARM, m_BtnSubscribe);
}
BEGIN_MESSAGE_MAP(CIVSAlarmPage, CPropertyPage)
ON_MESSAGE(WM_UPDATEALARMLIST, &CIVSAlarmPage::OnUpdateAlarmList)
ON_BN_CLICKED(IDC_BUTTON_SUBSCRIBE_ALARM, &CIVSAlarmPage::OnBnClickedButtonSubscribeAlarm)
ON_MESSAGE(WM_UPDATEDEVICELIST, &CIVSAlarmPage::OnUpdateDeviceList)
ON_NOTIFY(NM_DBLCLK, IDC_TREE_ALARM_DEVICE, &CIVSAlarmPage::OnNMDblclkTreeAlarmDevice)
ON_WM_HSCROLL()
ON_BN_CLICKED(IDC_CHECK_BY_ALARM_TYPE, &CIVSAlarmPage::OnBnClickedCheckByAlarmType)
ON_BN_CLICKED(IDC_CHECK_BY_ALARM_LEVEL, &CIVSAlarmPage::OnBnClickedCheckByAlarmLevel)
ON_BN_CLICKED(IDC_CHECK_SUBSCRIBE_ALL, &CIVSAlarmPage::OnBnClickedCheckSubscribeAll)
END_MESSAGE_MAP()
// CIVSAlarmPage message handlers
BOOL CIVSAlarmPage::OnInitDialog()
{
CPropertyPage::OnInitDialog();
// TODO: Add extra initialization here
eSDK::CLanguage* pLang = m_pSheet->m_pLang;
//设置告警列表属性
m_listAlarm.ModifyStyle(0, LVS_REPORT);
m_listAlarm.SetExtendedStyle(m_listAlarm.GetExtendedStyle() | LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT);
m_listAlarm.InsertColumn(0, pLang->GetString(GET_STRING_PARAM(IDS_LAB_ALARMLEVEL)));//告警级别
m_listAlarm.InsertColumn(1, pLang->GetString(GET_STRING_PARAM(IDS_LAB_ALARMSOURCE)));//告警源
m_listAlarm.InsertColumn(2, pLang->GetString(GET_STRING_PARAM(IDS_LAB_ALARMEVENTID)));//告警事件ID
m_listAlarm.InsertColumn(3, pLang->GetString(GET_STRING_PARAM(IDS_LAB_ALARMSTATUS)));//告警状态
m_listAlarm.InsertColumn(4, pLang->GetString(GET_STRING_PARAM(IDS_LAB_OCCURTIME)));//发生时间
m_listAlarm.InsertColumn(5, pLang->GetString(GET_STRING_PARAM(IDS_LAB_DESCRIPTION)));//告警描述
m_listAlarm.SetColumnWidth(0, 65);
m_listAlarm.SetColumnWidth(1, 55);
m_listAlarm.SetColumnWidth(2, 75);
m_listAlarm.SetColumnWidth(3, 65);
m_listAlarm.SetColumnWidth(4, 130);
m_listAlarm.SetColumnWidth(5, 150);
m_treeAlarmDevice.ModifyStyle(0, TVS_LINESATROOT|TVS_HASBUTTONS|TVS_HASLINES|TVS_CHECKBOXES);
m_hItemRoot = m_treeAlarmDevice.InsertItem(pLang->GetString(GET_STRING_PARAM(IDS_LAB_ALARMDEVTREE)));
//设置滑竿属性
m_SliderMin.SetRange(1, 100);
m_SliderMin.SetTicFreq(10);
m_SliderMin.SetLineSize(10);
m_SliderMin.SetPageSize(10);
m_SliderMin.SetPos(1);
m_SliderMax.SetRange(1, 100);
m_SliderMax.SetTicFreq(10);
m_SliderMax.SetLineSize(10);
m_SliderMax.SetPageSize(10);
m_SliderMax.SetPos(100);
m_CheckByAlarmType.SetCheck(FALSE);
m_CheckByAlarmLevel.SetCheck(FALSE);
m_CheckSubscribeAll.SetCheck(TRUE);//默认订阅方式设为订阅所有
m_SliderMin.EnableWindow(FALSE);
m_SliderMax.EnableWindow(FALSE);
EnableAlarmTypeCheckbox(FALSE);
//设置标签、按钮显示名称
m_CheckMoveDection.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_MOVEDETECTION)));
m_CheckShield.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_SHIELD)));
m_CheckNoSignal.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_NOSIGNAL)));
m_CheckShake.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_SHAKE)));
m_CheckRecognition.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_FACERECOGNITION)));
m_CheckIntrusion.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_INTRUSION)));
m_CheckByAlarmType.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_BYALARMTYPE)));
m_CheckByAlarmLevel.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_BYALARMLEVEL)));
m_CheckSubscribeAll.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_BYALL)));
m_GrpSubscribe.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_SUBSCRIBE)));
m_GrpAlarmReport.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_ALARMREPORT)));
m_LabMinLevel.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_MIN)));
m_LabMaxLevel.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_LAB_MAX)));
m_BtnSubscribe.SetWindowText(pLang->GetString(GET_STRING_PARAM(IDS_BTN_SUBSCRIBE)));
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
//设置属性对话框
void CIVSAlarmPage::SetSheet(CIVSSDKSheet* pSheet)
{
m_pSheet = pSheet;
}
void CIVSAlarmPage::EnableAlarmTypeCheckbox(BOOL bCheck)
{
m_CheckMoveDection.EnableWindow(bCheck);
m_CheckShield.EnableWindow(bCheck);
m_CheckNoSignal.EnableWindow(bCheck);
m_CheckShake.EnableWindow(bCheck);
m_CheckRecognition.EnableWindow(bCheck);
m_CheckIntrusion.EnableWindow(bCheck);
}
void CIVSAlarmPage::OnBnClickedCheckByAlarmType()
{
// TODO: Add your control notification handler code here
if (TRUE == m_CheckByAlarmType.GetCheck())
{
//“按告警类型”被勾选
EnableAlarmTypeCheckbox(TRUE);
m_CheckByAlarmLevel.SetCheck(FALSE);
m_SliderMin.EnableWindow(FALSE);
m_SliderMax.EnableWindow(FALSE);
m_CheckSubscribeAll.SetCheck(FALSE);
}
else
{
EnableAlarmTypeCheckbox(FALSE);
}
}
void CIVSAlarmPage::OnBnClickedCheckByAlarmLevel()
{
// TODO: Add your control notification handler code here
if (TRUE == m_CheckByAlarmLevel.GetCheck())
{
//“按告警级别”被勾选
m_SliderMin.EnableWindow(TRUE);
m_SliderMax.EnableWindow(TRUE);
m_CheckByAlarmType.SetCheck(FALSE);
EnableAlarmTypeCheckbox(FALSE);
m_CheckSubscribeAll.SetCheck(FALSE);
}
else
{
m_SliderMin.EnableWindow(FALSE);
m_SliderMax.EnableWindow(FALSE);
}
}
void CIVSAlarmPage::OnBnClickedCheckSubscribeAll()
{
// TODO: Add your control notification handler code here
if (TRUE == m_CheckSubscribeAll.GetCheck())
{
//“订阅所有”被勾选
m_CheckByAlarmType.SetCheck(FALSE);
EnableAlarmTypeCheckbox(FALSE);
m_CheckByAlarmLevel.SetCheck(FALSE);
m_SliderMin.EnableWindow(FALSE);
m_SliderMax.EnableWindow(FALSE);
}
}
//双击设备列表目录树节点
void CIVSAlarmPage::OnNMDblclkTreeAlarmDevice(NMHDR *pNMHDR, LRESULT *pResult)
{
// TODO: Add your control notification handler code here
*pResult = 0;
HTREEITEM hItem = m_treeAlarmDevice.GetSelectedItem();
CHECK_POINTER_VOID(hItem)
if (m_hItemRoot == hItem)
{
PostMessage(WM_UPDATEDEVICELIST);//双击根节点时，更新设备列表
}
}
//刷新设备列表
afx_msg LRESULT CIVSAlarmPage::OnUpdateDeviceList(WPARAM wParam, LPARAM lParam)
{
//获取摄像机列表
const IVS_UINT32 uiReqNum = 1000;//查询数量
IVS_UINT32 uiRsqBufSize = sizeof(IVS_CAMERA_BRIEF_INFO_LIST) + (uiReqNum-1) * sizeof(IVS_CAMERA_BRIEF_INFO);//所需内存大小
IVS_CAMERA_BRIEF_INFO_LIST* pCameraInfoList = reinterpret_cast<IVS_CAMERA_BRIEF_INFO_LIST*>(new IVS_CHAR[uiRsqBufSize]);//分配内存
CHECK_POINTER(pCameraInfoList, 0);
memset(pCameraInfoList,0,uiRsqBufSize);
IVS_INDEX_RANGE IndexRange = {1, uiReqNum};//索引范围
IVS_INT32 iRet = IVS_SDK_GetDeviceList(m_pSheet->GetSessionID(), DEVICE_TYPE_CAMERA, &IndexRange, pCameraInfoList, uiRsqBufSize);//获取设备列表
if (IVS_SUCCEED == iRet)
{
//获取设备列表成功，保存
IVS_UINT32 uiNum = (pCameraInfoList->stIndexRange.uiToIndex - pCameraInfoList->stIndexRange.uiFromIndex) + 1;
uiNum = (uiNum > pCameraInfoList->uiTotal) ? pCameraInfoList->uiTotal : uiNum;//实际返回的设备个数
ClearDeviceList();
for (IVS_UINT32 i=0; i<uiNum; i++)
{
IVS_CAMERA_BRIEF_INFO *pDevInfo = new IVS_CAMERA_BRIEF_INFO;
CHECK_POINTER(pDevInfo, 0);
memset(pDevInfo,0,sizeof(IVS_CAMERA_BRIEF_INFO));
memcpy(pDevInfo, &(pCameraInfoList->stCameraBriefInfo[i]), sizeof(IVS_CAMERA_BRIEF_INFO));
m_DeviceList.push_back(pDevInfo);
}
}
delete[] pCameraInfoList;//释放内存
pCameraInfoList = NULL;
ShowDeviceList();//显示设备列表
CHECK_POINTER(m_pSheet, 0);
m_pSheet->ShowTitleMsg(iRet, GET_STRING_PARAM(IDS_GETDEVLIST_OK), GET_STRING_PARAM(IDS_GETDEVLISR_FAIL));
return 0;
}
//清空设备列表
void CIVSAlarmPage::ClearDeviceList()
{
std::list<IVS_CAMERA_BRIEF_INFO*>::iterator iter = m_DeviceList.begin();
std::list<IVS_CAMERA_BRIEF_INFO*>::iterator iterEnd = m_DeviceList.end();
for (; iter != iterEnd; iter++)
{
delete[] *iter;
}
m_DeviceList.clear();
m_DeviceItemMap.clear();
}
//显示设备列表
void CIVSAlarmPage::ShowDeviceList()
{
m_treeAlarmDevice.DeleteAllItems();//删除所有节点
m_hItemRoot = m_treeAlarmDevice.InsertItem(m_pSheet->m_pLang->GetString(GET_STRING_PARAM(IDS_LAB_ALARMDEVTREE)));//添加根节点
std::list<IVS_CAMERA_BRIEF_INFO*>::iterator iter = m_DeviceList.begin();
std::list<IVS_CAMERA_BRIEF_INFO*>::iterator iterEnd = m_DeviceList.end();
for (; iter != iterEnd; iter++)
{
TVINSERTSTRUCT tvStruct;
tvStruct.hParent = m_hItemRoot;
tvStruct.hInsertAfter = NULL;
tvStruct.item.mask = TVIF_TEXT|TVIF_PARAM;
CString strTmp;
strTmp.Format("%-6s", (*iter)->cName);
tvStruct.item.pszText = strTmp.GetBuffer();
strTmp.ReleaseBuffer();
HTREEITEM hItemSub = m_treeAlarmDevice.InsertItem(&tvStruct);//添加子节点
m_treeAlarmDevice.SetItemData(hItemSub, (DWORD_PTR)(*iter));//绑定数据到子节点
m_DeviceItemMap[hItemSub] = *iter;
}
m_treeAlarmDevice.Expand(m_hItemRoot, TVE_EXPAND);//展开目录树
}
//获取订阅信息
CString CIVSAlarmPage::GetSubscribeInfo()
{
CString strSubscribeInfo = "";
std::map<HTREEITEM, IVS_CAMERA_BRIEF_INFO*>::iterator iter = m_DeviceItemMap.begin();
std::map<HTREEITEM, IVS_CAMERA_BRIEF_INFO*>::iterator iterEnd = m_DeviceItemMap.end();
for (; iter != iterEnd; iter++)
{
if (TRUE == m_treeAlarmDevice.GetCheck(iter->first))
{
//当前设备被选中,为其添加订阅
CString strSourceCode = iter->second->cCode;
IVS_INT32 uiPos = strSourceCode.Find("#");
if (-1 != uiPos)
{
//告警源编码
strSourceCode.Delete(uiPos, strSourceCode.GetLength()-uiPos);
}
if (TRUE == m_CheckSubscribeAll.GetCheck())
{
//订阅所有
strSubscribeInfo += "<SubscribeInfo>";
strSubscribeInfo += "<AlarmInCode>" + strSourceCode + "</AlarmInCode>";
strSubscribeInfo += "<SubscribeType>1</SubscribeType>";//1-所有 2-按告警类型 3-按告警级别
strSubscribeInfo += "</SubscribeInfo>";
}
else if (TRUE == m_CheckByAlarmLevel.GetCheck())
{
//按告警级别
strSubscribeInfo += "<SubscribeInfo>";
strSubscribeInfo += "<AlarmInCode>" + strSourceCode + "</AlarmInCode>";
strSubscribeInfo += "<SubscribeType>3</SubscribeType>";//1-所有 2-按告警类型 3-按告警级别
strSubscribeInfo += "<AlarmLevelValueMin>" + m_strMinLevel + "</AlarmLevelValueMin>";
strSubscribeInfo += "<AlarmLevelValueMax>" + m_strMaxLevel + "</AlarmLevelValueMax>";
strSubscribeInfo += "</SubscribeInfo>";
}
else if (TRUE == m_CheckByAlarmType.GetCheck())
{
//按告警类型
strSubscribeInfo += "<SubscribeInfo>";
strSubscribeInfo += "<AlarmInCode>" + strSourceCode + "</AlarmInCode>";
strSubscribeInfo += "<SubscribeType>2</SubscribeType>";//1-所有 2-按告警类型 3-按告警级别
strSubscribeInfo += "<AlarmTypeList>";
strSubscribeInfo += (TRUE == m_CheckMoveDection.GetCheck()) ? "<AlarmType>ALARM_TYPE_MOVE_DECTION</AlarmType>" : "";//移动侦测告警
strSubscribeInfo += (TRUE == m_CheckShield.GetCheck()) ? "<AlarmType>ALARM_SHIELD</AlarmType>" : "";//视频遮挡告警
strSubscribeInfo += (TRUE == m_CheckNoSignal.GetCheck()) ? "<AlarmType>ALARM_NO_SIGNAL</AlarmType>" : "";//视频丢失告警
strSubscribeInfo += (TRUE == m_CheckShake.GetCheck()) ? "<AlarmType>ALARM_MAU_VQD_SHAKE</AlarmType>" : "";//视频抖动告警
strSubscribeInfo += (TRUE == m_CheckRecognition.GetCheck()) ? "<AlarmType>ALARM_FACE_RECOGNITION</AlarmType>" : "";//人脸识别告警
strSubscribeInfo += (TRUE == m_CheckIntrusion.GetCheck()) ? "<AlarmType>ALARM_INTRUSION</AlarmType>" : "";//入侵告警
strSubscribeInfo += "</AlarmTypeList>";
strSubscribeInfo += "</SubscribeInfo>";
}
else
{
//未选择订阅类型，则默认订阅所有
strSubscribeInfo += "<SubscribeInfo>";
strSubscribeInfo += "<AlarmInCode>" + strSourceCode + "</AlarmInCode>";
strSubscribeInfo += "<SubscribeType>1</SubscribeType>";//1-所有 2-按告警类型 3-按告警级别
strSubscribeInfo += "</SubscribeInfo>";
m_CheckSubscribeAll.SetCheck(TRUE);
}
}
}
return strSubscribeInfo;
}
//滑竿滑动，实时显示告警级别
void CIVSAlarmPage::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default
m_strMinLevel.Format(_T("%d"), m_SliderMin.GetPos());
m_strMaxLevel.Format(_T("%d"), m_SliderMax.GetPos());
UpdateData(FALSE);
CPropertyPage::OnHScroll(nSBCode, nPos, pScrollBar);
}
//告警订阅
void CIVSAlarmPage::OnBnClickedButtonSubscribeAlarm()
{
// TODO: Add your control notification handler code here
//获取用户ID
IVS_UINT32 uiUserID = 0;
CString strUserId = "";
IVS_INT32 iRet = IVS_SDK_GetUserID(m_pSheet->GetSessionID(), &uiUserID);
if (IVS_SUCCEED == iRet)
{
strUserId.Format("%d", uiUserID);
}
else
{
CString strTitle(_T("IVS Demo "));
strTitle.Append(m_pSheet->m_pLang->GetString(GET_STRING_PARAM(IDS_GETUSERIDFAIL)));
//m_pSheet->SetWindowText(strTitle);//标题栏提示获取用户ID失败
return;
}
CString strDomainCode = m_DeviceList.empty() ? "" : m_DeviceList.front()->cCode;
IVS_INT32 uiPos = strDomainCode.Find("#");
if (-1 != uiPos)
{
//域编码
strDomainCode.Delete(0, uiPos+1);
}
uiPos = -1;
CString strAlarmInCode = m_DeviceList.empty() ? "" : m_DeviceList.front()->cCode; //告警源编码
uiPos = strAlarmInCode.Find("#");
if (-1 != uiPos)
{
strAlarmInCode.Delete(uiPos, strAlarmInCode.GetLength());
}
//xml格式订阅请求
CString strReqXml = "";
strReqXml += "<Content>";
strReqXml += "<DomainCode>" + strDomainCode + "</DomainCode>";
strReqXml += "<Subscribe>";
strReqXml += "<SubscriberInfo>";
strReqXml += "<Subscriber>1</Subscriber>";//1-本域用户 2-外域用户
strReqXml += "<SubscriberID>"+strUserId+"</SubscriberID>";
strReqXml += "</SubscriberInfo>";
strReqXml += "<AddSubscribeList>";
strReqXml += "<SubscribeInfo>";
strReqXml += "<AlarmInCode>" + strAlarmInCode + "</AlarmInCode>";
strReqXml += "<SubscribeType>1</SubscribeType>";
strReqXml += "<AlarmLevelValueMin>1</AlarmLevelValueMin>";
strReqXml += "<AlarmLevelValueMax>100</AlarmLevelValueMax>";
strReqXml += "<AlarmTypeList/>";
strReqXml += "<DevDomainCode>" + strDomainCode + "</DevDomainCode>";
strReqXml += "</SubscribeInfo>";
strReqXml += "</AddSubscribeList>";
strReqXml += "<DelSubscribeList/>";
strReqXml += "</Subscribe>";
strReqXml += "</Content>";
iRet = IVS_SDK_SubscribeAlarm(m_pSheet->GetSessionID(), strReqXml);
m_pSheet->ShowTitleMsg(iRet, GET_STRING_PARAM(IDS_SUBSCRIBE_OK), GET_STRING_PARAM(IDS_SUBSCRIBE_FAIL));
}
//UTC时间转UTC+8时间
static CString UTCToUTC8(CString strUTCTime)
{
CString strUTC8Time = "";
const IVS_UINT32 uiTimeLength = 14;
if (uiTimeLength != strUTCTime.GetLength())//时间长度为14字节
{
strUTC8Time = "Time Format Error";
}
else
{
strUTC8Time.Append(strUTCTime.Left(4));//年
strUTCTime.Delete(0, 4);
strUTC8Time.Append("-");
strUTC8Time.Append(strUTCTime.Left(2));//月
strUTCTime.Delete(0, 2);
strUTC8Time.Append("-");
strUTC8Time.Append(strUTCTime.Left(2));//日
strUTCTime.Delete(0, 2);
strUTC8Time.Append(" ");
CString strHour = strUTCTime.Left(2);
IVS_UINT32 iHour = atoi(strHour) + 8;//加8小时
strHour.Format(_T("%d"), iHour);
strUTC8Time.Append(strHour);//时
strUTCTime.Delete(0, 2);
strUTC8Time.Append(":");
strUTC8Time.Append(strUTCTime.Left(2));//分
strUTCTime.Delete(0, 2);
strUTC8Time.Append(":");
strUTC8Time.Append(strUTCTime.Left(2));//秒
}
return strUTC8Time;
}
//刷新告警列表
afx_msg LRESULT CIVSAlarmPage::OnUpdateAlarmList(WPARAM wParam, LPARAM lParam)
{
IVS_ALARM_NOTIFY* pAlarmInfo = reinterpret_cast<IVS_ALARM_NOTIFY*>(lParam);//lParam在调用处保证非空
static IVS_UINT32 uiCnt = 0;
CString strAlarmLevel = "";
CString strAlarmEventID = "";
CString strAlarmStatus = "";
strAlarmLevel.Format("%d", pAlarmInfo->uiAlarmLevelValue);
strAlarmEventID.Format("%d", pAlarmInfo->ullAlarmEventID);
strAlarmStatus.Format("%d", pAlarmInfo->uiAlarmStatus);
m_listAlarm.InsertItem(uiCnt, strAlarmLevel);//告警级别
m_listAlarm.SetItemText(uiCnt, 1, pAlarmInfo->cAlarmInName);//告警源
m_listAlarm.SetItemText(uiCnt, 2, strAlarmEventID);//告警事件ID
m_listAlarm.SetItemText(uiCnt, 3, strAlarmStatus);//告警状态
m_listAlarm.SetItemText(uiCnt, 4, UTCToUTC8(pAlarmInfo->cOccurTime));//发生时间，SDK上报的时间是UTC标准时间，北京时间是UTC+8
m_listAlarm.SetItemText(uiCnt, 5, pAlarmInfo->cAlarmDesc);//描述信息
uiCnt++;
delete pAlarmInfo;
pAlarmInfo = NULL;
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
6ef963556bc38fdff943610ff162858d020ccb4e | efcc9ecde592f2db0e5de4ff9737176a422d00e3 | /Src/Modules/Update/Src/CheckForUpdateDialog.h | 50bd49a3bd590c1b2ff4c0a686892c924b0a22e8 | [] | no_license | xujin961129/Kits | 86b7373e4367b641d0a8ffcdc316a6cf52df6456 | 315f3070b1f9e227e4395ca7865eb3b7ff3afe66 | refs/heads/master | 2020-07-11T03:48:57.557781 | 2019-08-26T09:13:39 | 2019-08-26T09:13:39 | 204,438,592 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,026 | h | /**
* @copybrief Copyright © 2018, WuHai all rights reserve.
* @author wuhai
* @em wuhai1024@outlook.com
* @date The file is created on Dec. 29, 2018 by wuhai.
* @brief The device info.
* @version
* 20181229 --v1.0.0 create the file.
*/
#ifndef CHECKFORUPDATEDIALOG_H
#define CHECKFORUPDATEDIALOG_H
#include <QLabel>
#include <QDialog>
#include <QPushButton>
#include <QProgressBar>
class HttpAnalyzer;
namespace Ui {
class CheckForUpdateDialog;
}
class CheckForUpdateDialog:public QDialog
{
Q_OBJECT
public:
CheckForUpdateDialog(HttpAnalyzer* httpAnalyzer);
~CheckForUpdateDialog();
void checkForUpdate();
private:
Ui::CheckForUpdateDialog* ui = nullptr;
QPushButton* cancelBt = nullptr;
HttpAnalyzer* analyzer = nullptr;
QLabel* infoLabel = nullptr;
QProgressBar* progressBar = nullptr;
private slots:
void cancel();
void showErrorDialog(QString errStr);
void noNewVersion();
signals:
void cancelChecking();
};
#endif
| [
"xujin961129.@163.com"
] | xujin961129.@163.com |
408cee75e2f7a87e02a28dbbc230cd7e8f6843b2 | 12a09d5f747bdf1e52b129f3c95dd544fdc86f41 | /src/car.h | efdf15a362431bc15ca8cb7738046bf2b5f3e619 | [] | no_license | akyryl/game | d33035554d8ad7eb33f2bfb5a9eb8aca51d2bc82 | 3ac12a5879fa40da257cd234542c046ca93df0f0 | refs/heads/master | 2016-09-05T10:37:46.561716 | 2013-01-29T20:16:41 | 2013-01-29T20:16:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 267 | h | #ifndef __CAR_H__
#define __CAR_H__
#include "carRenderObject.h"
class Car
{
CarRenderObject *m_pDrawingObject;
public:
Car();
~Car();
CarRenderObject *getDrawingObject() const;
void stepLeft();
void stepRight();
};
#endif // __CAR_H__
| [
"akyryl@localhost.localdomain"
] | akyryl@localhost.localdomain |
5f54078d5f7bd6e5b7c2383f3bd0f3dc2c9688a1 | cf1bc90582b3b9fe939650979e9319aaa19936e9 | /src/paging/PageTableManager.cc | f5e37e5fffd7e1867ee1a067aceeb7b319a8bffd | [] | no_license | RGFTheCoder/kernel | a224e065ca0e620dc7ecb222231fd02e038fd2eb | f5485c20bea97d801bd5a213dd36aa8cc0eacd87 | refs/heads/main | 2023-02-16T07:37:15.798141 | 2021-01-10T07:32:46 | 2021-01-10T07:32:46 | 328,304,858 | 1 | 0 | null | 2021-01-10T04:44:32 | 2021-01-10T04:44:31 | null | UTF-8 | C++ | false | false | 1,663 | cc | #include <paging/PageTableManager.hh>
#include <paging/PageMapIndexer.hh>
#include <paging/PageFrameAllocator.hh>
#include <types/ints.hh>
#include <Memory.hh>
void PageTableManager::MapMemory(void *virtualMemory, void *physicalMemory)
{
PageMapIndexer indexer{(u64)virtualMemory};
PageDirectoryEntry PDE;
PDE = PML4->entries[indexer.PDP_i];
PageTable *PDP;
if (!PDE.GetFlag(PT_FLAG::present))
{
PDP = (PageTable *)globalAllocator.requestPage();
memset(PDP, 0, 0x1000);
PDE.SetAddress(((u64)PDP >> 12));
PDE.SetFlag(PT_FLAG::present, true);
PDE.SetFlag(PT_FLAG::readWrite, true);
PML4->entries[indexer.PDP_i] = PDE;
}
else
{
PDP = (PageTable *)((u64)PDE.GetAddress() << 12);
}
PDE = PDP->entries[indexer.PD_i];
PageTable *PD;
if (!PDE.GetFlag(PT_FLAG::present))
{
PD = (PageTable *)globalAllocator.requestPage();
memset(PD, 0, 0x1000);
PDE.SetAddress(((u64)PD >> 12));
PDE.SetFlag(PT_FLAG::present, true);
PDE.SetFlag(PT_FLAG::readWrite, true);
PDP->entries[indexer.PD_i] = PDE;
}
else
{
PD = (PageTable *)((u64)PDE.GetAddress() << 12);
}
PDE = PD->entries[indexer.PT_i];
PageTable *PT;
if (!PDE.GetFlag(PT_FLAG::present))
{
PT = (PageTable *)globalAllocator.requestPage();
memset(PT, 0, 0x1000);
PDE.SetAddress(((u64)PT >> 12));
PDE.SetFlag(PT_FLAG::present, true);
PDE.SetFlag(PT_FLAG::readWrite, true);
PD->entries[indexer.PT_i] = PDE;
}
else
{
PT = (PageTable *)((u64)PDE.GetAddress() << 12);
}
PDE = PT->entries[indexer.P_i];
PDE.SetAddress(((u64)physicalMemory >> 12));
PDE.SetFlag(PT_FLAG::present, true);
PDE.SetFlag(PT_FLAG::readWrite, true);
PT->entries[indexer.P_i] = PDE;
} | [
"recdeclec.ceo@gmail.com"
] | recdeclec.ceo@gmail.com |
276cfdaa0442b8ce146fa01aefff5450bdd94391 | e86e5c93668cd38a523dcec1eab9198e51974d3a | /VeritasEngine_Windows/TextureResourceLoaderImpl.cpp | 160f271177dd1db137062757a7ccfc14abf3514e | [
"MIT"
] | permissive | webfinesse/veritas-engine | cf41544f9f2380d34807b3e9925eaa43ff5f36a4 | de771f2dcaa1a58550d07500e33e50940e3f5e58 | refs/heads/master | 2021-01-11T01:49:47.815527 | 2018-01-07T23:41:18 | 2018-01-07T23:41:18 | 70,659,805 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,132 | cpp | #include <memory>
#include "TextureResourceLoaderImpl.h"
#include "WindowsUtil.h"
#include "DirectXState.h"
#include "DDSTextureLoader/DDSTextureLoader.h"
#include "DirectXTextureData.h"
#include "../VeritasEngine/ResourceData.h"
VeritasEngine::TextureResourceLoaderImpl::TextureResourceLoaderImpl(std::shared_ptr<DirectXState> dxState)
: m_dxState{ std::move(dxState) }
{
}
void VeritasEngine::TextureResourceLoaderImpl::Load(std::istream& data, ResourceData& handle) const
{
data.seekg(0, std::ios::end);
const auto length = static_cast<size_t>(data.tellg());
data.seekg(0, std::ios::beg);
std::unique_ptr<uint8_t[]> img(new uint8_t[length]);
data.read(reinterpret_cast<char*>(img.get()), length);
ComPtr<ID3D11Resource> texture;
ComPtr<ID3D11ShaderResourceView> textureView;
DirectX::DDS_ALPHA_MODE mode;
HHR(DirectX::CreateDDSTextureFromMemory(m_dxState->Device.Get(), m_dxState->Context.Get(), img.get(), length, texture.GetAddressOf(), textureView.GetAddressOf(), 0, &mode), "Failed to load texture");
handle.SetData(DirectXTextureData{ texture, textureView });
}
| [
"webfinesse@gmail.com"
] | webfinesse@gmail.com |
1b81d14026247e1e865612c87faef889380ac7a3 | a033338aeb547f3c3d4d5a0fc0cec86966a3fdb1 | /Juego1D/Game/Engine/GameObjects/Components/Derived/CollisionComponent.cpp | 65051e9126bc34e5d6e6e77487738c058dc559a0 | [] | no_license | sergiodrm/Juego1D | fb9b10af35bafd9d5c46ef5cde725c5e4c278725 | f74d5767b25aab46cc6e7fbaf1e60e88e380202d | refs/heads/master | 2023-02-24T08:20:01.732997 | 2021-01-28T19:09:26 | 2021-01-28T19:09:26 | 332,168,065 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,159 | cpp | #include "CollisionComponent.h"
#include "TransformComponent.h"
#include "MovementComponent.h"
#include "GameObjects/GameObject.h"
#include "World/World.h"
CCollisionComponent::CCollisionComponent()
: m_eTypeToIgnore(CGameObject::EGameObjectTypes::Invalid) {}
void CCollisionComponent::Update(float _fDeltaTime)
{
// Comprobar que el game object esta dentro de los limites de la escena.
// Unicamente se comprueba para game objects de tipo bala.
if (GetOwner()->IsType(CGameObject::EGameObjectTypes::Bullet))
{
CTransformComponent* pTransformComponent = GetOwner()->GetComponent<CTransformComponent>();
// Obtener la informacion de los limites por el gestor de entidades que contiene la escena.
if (pTransformComponent->GetPosition() <= 0 || pTransformComponent->GetPosition() >= static_cast<int>(CWorld::GetInstance().GetScene().GetSize()))
{
// En caso de que el game object llegue a los limites, se introduce en la cola para desactivacion.
CWorld::GetInstance().DeactiveGameObject(*GetOwner());
}
}
}
bool CCollisionComponent::Collides(CGameObject& _rOther) const
{
if (_rOther.IsType(m_eTypeToIgnore))
return false;
// Obtener los componentes Transform de cada componente para comprobar la posicion y determinar si hay colision o no.
CTransformComponent* pMyTransform = GetOwner()->GetComponent<CTransformComponent>();
CTransformComponent* pOtherTransform = _rOther.GetComponent<CTransformComponent>();
int iMyDirection = GetOwner()->GetComponent<CMovementComponent>()->GetMovementDirection();
/**
* Comprobar tanto la posicion actual como la siguiente (en la direccion de movimiento)
* para evitar que se crucen los game objects si estan en posiciones contiguas.
*/
bool bHasCollided = pMyTransform->GetPosition() == pOtherTransform->GetPosition() ||
pMyTransform->GetPosition() + iMyDirection == pOtherTransform->GetPosition();
return bHasCollided;
}
CGameObject::EGameObjectTypes CCollisionComponent::GetTypeToIgnore() const
{
return m_eTypeToIgnore;
}
void CCollisionComponent::SetTypeToIgnore(CGameObject::EGameObjectTypes _eType)
{
m_eTypeToIgnore = _eType;
}
| [
"sergiojg.drm@gmail.com"
] | sergiojg.drm@gmail.com |
bd91c86aefb7b78dbf9f80d2d6e5a03275c5df81 | d4235fb113bcbf4adef8467e1db716b169c0640f | /src/snark/libsnark/gadgetlib1/gadgets/hashes/hash_io.hpp | 93ae4e3735b1cb4659a140dea8a74750cd30523d | [
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | phabulu/litecoinz | c0d1b0eb8d8564e7d1d9cf0665b2b2e4bfa8fb87 | f27d3e157811c8ae19bc7165d613f4d4b8ef9523 | refs/heads/master | 2020-03-06T18:55:25.439682 | 2018-03-17T15:04:55 | 2018-03-17T15:04:55 | 127,016,647 | 1 | 0 | MIT | 2018-03-27T16:37:06 | 2018-03-27T16:37:05 | null | UTF-8 | C++ | false | false | 2,152 | hpp | /**
*****************************************************************************
* @author This file is part of libsnark, developed by SCIPR Lab
* and contributors (see AUTHORS).
* @copyright MIT license (see LICENSE file)
*****************************************************************************/
#ifndef HASH_IO_HPP_
#define HASH_IO_HPP_
#include <cstddef>
#include <vector>
#include "gadgetlib1/gadgets/basic_gadgets.hpp"
namespace libsnark {
template<typename FieldT>
class digest_variable : public gadget<FieldT> {
public:
uint64_t digest_size;
pb_variable_array<FieldT> bits;
digest_variable<FieldT>(protoboard<FieldT> &pb,
const uint64_t digest_size,
const std::string &annotation_prefix);
digest_variable<FieldT>(protoboard<FieldT> &pb,
const uint64_t digest_size,
const pb_variable_array<FieldT> &partial_bits,
const pb_variable<FieldT> &padding,
const std::string &annotation_prefix);
void generate_r1cs_constraints();
void generate_r1cs_witness(const bit_vector& contents);
bit_vector get_digest() const;
};
template<typename FieldT>
class block_variable : public gadget<FieldT> {
public:
uint64_t block_size;
pb_variable_array<FieldT> bits;
block_variable(protoboard<FieldT> &pb,
const uint64_t block_size,
const std::string &annotation_prefix);
block_variable(protoboard<FieldT> &pb,
const std::vector<pb_variable_array<FieldT> > &parts,
const std::string &annotation_prefix);
block_variable(protoboard<FieldT> &pb,
const digest_variable<FieldT> &left,
const digest_variable<FieldT> &right,
const std::string &annotation_prefix);
void generate_r1cs_constraints();
void generate_r1cs_witness(const bit_vector& contents);
bit_vector get_block() const;
};
} // libsnark
#include "gadgetlib1/gadgets/hashes/hash_io.tcc"
#endif // HASH_IO_HPP_
| [
"team@litecoinz.info"
] | team@litecoinz.info |
83f7963209b43913c96ad5a41a68ca945547adf3 | c0caed81b5b3e1498cbca4c1627513c456908e38 | /src/protocols/wum/WorkUnitBase.fwd.hh | 210808a9c73c0bcc0c1af4df45ce5d7fffbd9d80 | [] | no_license | malaifa/source | 5b34ac0a4e7777265b291fc824da8837ecc3ee84 | fc0af245885de0fb82e0a1144422796a6674aeae | refs/heads/master | 2021-01-19T22:10:22.942155 | 2017-04-19T14:13:07 | 2017-04-19T14:13:07 | 88,761,668 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,722 | hh | // -*- mode:c++;tab-width:2;indent-tabs-mode:t;show-trailing-whitespace:t;rm-trailing-spaces:t -*-
// vi: set ts=2 noet:
//
// (c) Copyright Rosetta Commons Member Institutions.
// (c) This file is part of the Rosetta software suite and is made available under license.
// (c) The Rosetta software is developed by the contributing members of the Rosetta Commons.
// (c) For more information, see http://www.rosettacommons.org. Questions about this can be
// (c) addressed to University of Washington UW TechTransfer, email: license@u.washington.edu.
/// @file protocols/loops/WorkUnitBase.fwd.hh
/// @brief WorkUnitBase base classes
/// @author Mike Tyka
#ifndef INCLUDED_protocols_wum_WorkUnitBase_fwd_hh
#define INCLUDED_protocols_wum_WorkUnitBase_fwd_hh
#include <utility/pointer/owning_ptr.hh>
namespace protocols {
namespace wum {
class WorkUnitBase;
typedef utility::pointer::shared_ptr< WorkUnitBase > WorkUnitBaseOP;
typedef utility::pointer::shared_ptr< WorkUnitBase const > WorkUnitBaseCOP;
class WorkUnit_Wait;
typedef utility::pointer::shared_ptr< WorkUnit_Wait > WorkUnit_WaitOP;
typedef utility::pointer::shared_ptr< WorkUnit_Wait const > WorkUnit_WaitCOP;
class WorkUnit_SilentStructStore;
typedef utility::pointer::shared_ptr< WorkUnit_SilentStructStore > WorkUnit_SilentStructStoreOP;
typedef utility::pointer::shared_ptr< WorkUnit_SilentStructStore const > WorkUnit_SilentStructStoreCOP;
class WorkUnit_MoverWrapper;
typedef utility::pointer::shared_ptr< WorkUnit_MoverWrapper > WorkUnit_MoverWrapperOP;
typedef utility::pointer::shared_ptr< WorkUnit_MoverWrapper const > WorkUnit_MoverWrapperCOP;
} //namespace loops
} //namespace protocols
#endif //INCLUDED_protocols_WorkUnitBase_FWD_HH
| [
"malaifa@yahoo.com"
] | malaifa@yahoo.com |
3a150246fa2532feb23bfe333b5476f6f954c690 | b6bad48fbff4264a2b670b6776f5c0c19c937f54 | /src/agaliarept/analyze_JPEG_item_Base.h | 7fe17cd5fb108d37c82b2d9ec9144372645d0db5 | [
"MIT"
] | permissive | solomon-qwe/agalia | a39343720896545116cb121f6f8e63f4007fbfba | 811655f37e1b875cce53f18da6f4df4fe64e39b4 | refs/heads/master | 2022-08-26T22:59:53.721412 | 2022-08-07T14:14:20 | 2022-08-07T14:18:58 | 90,438,465 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,058 | h | #pragma once
#include "container_JPEG.h"
#include "jpeg_def.h"
#include "byteswap.h"
namespace analyze_JPEG
{
class item_Base : public _agaliaItemBase
{
public:
enum item_type
{
unknown,
marker_segment,
jfif, // APP0
exif, // APP1
xmp, // APP1
icc_profile, // APP2
ducky, // APP12
photoshop, // APP13
adobe, // APP14
};
item_Base(const container_JPEG* image, uint64_t offset, uint64_t size, item_type type);
virtual ~item_Base();
virtual HRESULT getChildItem(uint32_t sibling, agaliaItem** child) const override;
virtual HRESULT getAsocImage(const agaliaContainer** imageAsoc) const override {
*imageAsoc = this->image;
return S_OK;
}
virtual HRESULT getColumnValue(uint32_t column, agaliaString** str) const;
virtual HRESULT getAdditionalInfoCount(uint32_t* row) const;
virtual HRESULT getAdditionalInfoValue(uint32_t row, agaliaString** str) const;
static const GUID guid_jpeg;
protected:
item_type data_type = unknown;
const container_JPEG* image = nullptr;
};
}
| [
"solomon-qwe@users.noreply.github.com"
] | solomon-qwe@users.noreply.github.com |
bc1fc49254b7b592d4bebf79d1c54e7eaba68f5c | cba54fda668bdbadbfe04130b17d2f703a53971c | /sr2/src/core/Element.cpp | 6a598e2ed36424c4ea6f98203eef71f1d9a54636 | [] | no_license | Nightwind0/stonering | 85af318ad90c6698bc424c86a031481cb6d67ee0 | f6c31db3840bfdc3d9a5da7f66aed9186615a2c9 | refs/heads/master | 2021-01-17T18:45:07.301920 | 2018-08-29T20:19:56 | 2018-08-29T20:19:56 | 65,499,984 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,472 | cpp | #include <ClanLib/core.h>
#include "Element.h"
#include "IApplication.h"
#include <algorithm>
using StoneRing::IApplication;
using StoneRing::LevelFactory;
using StoneRing::Element;
/*const Element::ElementCreationEntry Element::g_pElementCreationEntries[] =
{
{"itemRef", &IApplication::getLevelFactory, &LevelFactory::createItemRef},
{"tile", &IApplication::getLevelFactory, &LevelFactory::createTile},
{"condition", &IApplication::getLevelFactory, &LevelFactory::createCondition}
}
*/
uint Element::get_required_uint(const std::string &attrname, clan::DomNamedNodeMap attributes)
{
if( has_attribute ( attrname, attributes ) )
{
return get_uint ( attrname, attributes);
}
else
{
throw XMLException("Missing attribute " + attrname + " on " + get_element_name() );
}
}
int Element:: get_required_int(const std::string &attrname, clan::DomNamedNodeMap attributes)
{
if( has_attribute ( attrname, attributes ) )
{
return get_int ( attrname, attributes);
}
else
{
throw XMLException("Missing attribute " + attrname + " on " + get_element_name() );
}
}
float Element::get_required_float(const std::string &attrname, clan::DomNamedNodeMap attributes )
{
if( has_attribute ( attrname, attributes ) )
{
return get_float ( attrname, attributes);
}
else
{
throw XMLException("Missing attribute " + attrname + " on " + get_element_name() );
}
}
std::string Element::get_required_string (const std::string &attrname, clan::DomNamedNodeMap attributes )
{
if( has_attribute ( attrname, attributes ) )
{
return get_string ( attrname, attributes);
}
else
{
throw XMLException("Missing attribute '" + attrname + "' on " + get_element_name() );
}
return "";
}
bool Element::get_required_bool (const std::string &attrname, clan::DomNamedNodeMap attributes )
{
if( has_attribute ( attrname, attributes ) )
{
return get_bool ( attrname, attributes );
}
else
{
throw XMLException("Missing attribute " + attrname + " on " + get_element_name() );
}
return false;
}
bool Element::get_bool ( const std::string &attrname, clan::DomNamedNodeMap attributes)
{
std::string str = get_string ( attrname, attributes);
if(str == "true") return true;
else if (str == "false") return false;
else throw clan::Exception("Boolean value for " + attrname + " must be 'true' or 'false'.");
return false;
}
bool Element::get_implied_bool ( const std::string &attrname, clan::DomNamedNodeMap attributes, bool defaultValue)
{
if(has_attribute(attrname, attributes))
{
return get_bool ( attrname, attributes);
}
else return defaultValue;
}
int Element::get_implied_int( const std::string &attrname, clan::DomNamedNodeMap attributes, int defaultValue)
{
if(has_attribute(attrname, attributes))
{
return get_int(attrname, attributes );
}
else return defaultValue;
}
std::string Element::get_implied_string( const std::string &attrname, clan::DomNamedNodeMap attributes, const std::string &defaultValue)
{
if(has_attribute(attrname,attributes))
{
return get_string(attrname,attributes);
}
else return defaultValue;
}
float Element::get_implied_float(const std::string &attrname, clan::DomNamedNodeMap attributes, float defaultValue)
{
if(has_attribute(attrname,attributes))
{
return get_float(attrname,attributes);
}
else return defaultValue;
}
bool Element::has_attribute( const std::string &attrname, clan::DomNamedNodeMap attributes )
{
return ! attributes.get_named_item(attrname).is_null();
}
uint Element::get_uint(const std::string &attrname, clan::DomNamedNodeMap attributes)
{
return atoi(attributes.get_named_item(attrname).get_node_value().c_str());
}
int Element::get_int(const std::string &attrname, clan::DomNamedNodeMap attributes)
{
return atoi(attributes.get_named_item(attrname).get_node_value().c_str());
}
float Element::get_float(const std::string &attrname, clan::DomNamedNodeMap attributes )
{
return atof(attributes.get_named_item(attrname).get_node_value().c_str());
}
std::string Element::get_string (const std::string &attrname, clan::DomNamedNodeMap attributes )
{
return attributes.get_named_item(attrname).get_node_value();
}
#ifndef NDEBUG
std::string Element::get_element_name() const
{
return m_element_name;
}
#endif
void Element::Load(clan::DomElement domElement)
{
IFactory* pFactory = IApplication::GetInstance()->GetElementFactory();
clan::DomNamedNodeMap attributes = domElement.get_attributes();
load_attributes(attributes);
clan::DomNode childNode = domElement.get_first_child(); //.to_element();
clan::DomElement child;
if(childNode.is_text())
{
clan::DomText text = childNode.to_text();
handle_text(text.get_node_value());
}
if(childNode.is_cdata_section())
{
clan::DomCDATASection text = childNode.to_cdata_section();
handle_text(text.get_node_value());
}
child = childNode.to_element();
while(!child.is_null())
{
std::string element_name = child.get_node_name();
Element * pElement = NULL;
pElement = pFactory->createElement(element_name);
#ifndef NDEBUG
pElement->SetElementName(element_name);
#endif
try {
pElement->Load( child );
}catch(XMLException& e){
#ifndef NDEBUG
e.push_error(element_name + ": " + pElement->GetDebugId());
#else
e.push_error(element_name);
#endif
throw e;
}
if(!handle_element(pElement->WhichElement(), pElement ))
{
// They didn't handle it. So lets get rid of it
std::cout << "Unhandled element " << element_name << " found" << std::endl;
delete pElement;
}
if(child.get_next_sibling().is_text())
std::cout << "Found Text" << std::endl;
child = child.get_next_sibling().to_element();
}
#if 0
if(pDomElement->is_text())
{
clan::DomCDATASection cdata = pDomElement->to_text();
#ifndef NDEBUG
if(!cdata.is_null())
{
std::string theText = cdata.substring_data(0,text.get_length());
std::cout << '\'' << theText << '\'' << std::endl;
}
#endif
handleText ( cdata.substring_data(0,cdata.length()) );
}
#endif
load_finished();
}
| [
"nightwind@1a319a91-200f-0410-9ca8-f36a151797b4"
] | nightwind@1a319a91-200f-0410-9ca8-f36a151797b4 |
251b83daeef32bb43d64778543d220444f4d0e8a | 243b10891fb389f408a48c8f17215464ff7def49 | /_Engine/Inc/Object/Actor/tile_actor.h | a0496816c0c50f924b05d32001c931d69f89774c | [] | no_license | kwangminy27/K-Diablo-II-Expansion | 4b3eb4146331995410f77494337e8e61f76f73cb | 9a2adcf915a59871df50848da7db531dcba38979 | refs/heads/master | 2020-04-11T05:50:12.683927 | 2019-01-02T12:44:27 | 2019-01-02T12:44:27 | 161,561,348 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 958 | h | #pragma once
#include "actor.h"
namespace K
{
class K_ENGINE_DLL TileActor final : public Actor
{
friend class ObjectManager;
public:
virtual void Initialize() override;
virtual APTR Clone() const override;
virtual void Serialize(InputMemoryStream& _imstream) override;
virtual void Serialize(OutputMemoryStream& _omstream) override;
Vector2 const& LT() const;
Vector2 const& RB() const;
TILE_OPTION option() const;
TAG actor_tag() const;
void set_LT(Vector2 const& _LT);
void set_RB(Vector2 const& _RB);
void set_option(TILE_OPTION _option);
void set_actor_tag(TAG const& _tag);
private:
TileActor() = default;
TileActor(TileActor const& _other);
TileActor(TileActor&& _other) noexcept;
TileActor& operator=(TileActor const&) = delete;
TileActor& operator=(TileActor&&) noexcept = default;
virtual void _Finalize() override;
Vector2 LT_;
Vector2 RB_;
TILE_OPTION option_{};
TAG actor_tag_{};
};
}
| [
"kwangminy27@outlook.com"
] | kwangminy27@outlook.com |
3ae1c44dbb0abd32d309b8d02f77498132dae67e | b9b36c53e012acb7f73b539cba0eb89310437905 | /src/AbsEncoder.h | 0ca1356244f16e66ef48ec662e926d94f34c6ec1 | [] | no_license | newdavidl/Team-3341-Stronghold | 3b1e2c1f7b88738074c6bf6f45fa32a2aeac3902 | 7ecc2c321447f4fdad5aa92cff14ba94fc2b1a80 | refs/heads/master | 2021-01-10T07:08:37.958701 | 2016-02-06T22:58:58 | 2016-02-06T22:58:58 | 50,240,215 | 0 | 0 | null | 2016-01-25T02:49:16 | 2016-01-23T13:47:23 | C++ | UTF-8 | C++ | false | false | 326 | h | #ifndef AbsEncoder_H
#define AbsEncoder_H
#include "WPILib.h"
class AbsEncoder
{
private:
// It's desirable that everything possible under private except
// for methods that implement subsystem capabilities
SPI *myAbsEncoder;
short input;
public:
AbsEncoder();
void InitDefaultCommand();
short getInput();
};
#endif
| [
"newdavidl@gmail.com"
] | newdavidl@gmail.com |
0a69ce9339d78e5818559fff0c011a30057ae7cd | cf71bad94e4e7a579c2c87bbf1a21bfaea068368 | /build-Bejeweled-Desktop_Qt_5_9_0_MinGW_32bit-Debug/ui_crankdlg.h | 9dac38eb5ffe076965dbcc0a98f4ba0e4414b892 | [] | no_license | Paitesanshi/Data-Structure-Project | 50d64178ad94d7cca73fd49761890ca861cfb930 | b442da81d4d45da58e1b6a1c30b8fd5ee54a7a56 | refs/heads/master | 2022-10-20T11:07:51.583717 | 2020-06-11T15:28:54 | 2020-06-11T15:28:54 | 264,111,608 | 1 | 4 | null | 2020-05-26T14:08:22 | 2020-05-15T06:13:44 | Makefile | UTF-8 | C++ | false | false | 8,208 | h | /********************************************************************************
** Form generated from reading UI file 'crankdlg.ui'
**
** Created by: Qt User Interface Compiler version 5.9.0
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/
#ifndef UI_CRANKDLG_H
#define UI_CRANKDLG_H
#include <QtCore/QVariant>
#include <QtWidgets/QAction>
#include <QtWidgets/QApplication>
#include <QtWidgets/QButtonGroup>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QLabel>
#include <QtWidgets/QTableWidget>
#include <QtWidgets/QWidget>
QT_BEGIN_NAMESPACE
class Ui_CRankDlg
{
public:
QLabel *label;
QTableWidget *tableWidget;
void setupUi(QWidget *CRankDlg)
{
if (CRankDlg->objectName().isEmpty())
CRankDlg->setObjectName(QStringLiteral("CRankDlg"));
CRankDlg->resize(450, 424);
label = new QLabel(CRankDlg);
label->setObjectName(QStringLiteral("label"));
label->setGeometry(QRect(190, 10, 101, 31));
QFont font;
font.setFamily(QStringLiteral("AcadEref"));
font.setPointSize(16);
label->setFont(font);
label->setLayoutDirection(Qt::LeftToRight);
label->setAlignment(Qt::AlignCenter);
tableWidget = new QTableWidget(CRankDlg);
if (tableWidget->columnCount() < 4)
tableWidget->setColumnCount(4);
QTableWidgetItem *__qtablewidgetitem = new QTableWidgetItem();
tableWidget->setHorizontalHeaderItem(0, __qtablewidgetitem);
QTableWidgetItem *__qtablewidgetitem1 = new QTableWidgetItem();
tableWidget->setHorizontalHeaderItem(1, __qtablewidgetitem1);
QTableWidgetItem *__qtablewidgetitem2 = new QTableWidgetItem();
tableWidget->setHorizontalHeaderItem(2, __qtablewidgetitem2);
QTableWidgetItem *__qtablewidgetitem3 = new QTableWidgetItem();
tableWidget->setHorizontalHeaderItem(3, __qtablewidgetitem3);
if (tableWidget->rowCount() < 10)
tableWidget->setRowCount(10);
QTableWidgetItem *__qtablewidgetitem4 = new QTableWidgetItem();
tableWidget->setVerticalHeaderItem(0, __qtablewidgetitem4);
QTableWidgetItem *__qtablewidgetitem5 = new QTableWidgetItem();
tableWidget->setVerticalHeaderItem(1, __qtablewidgetitem5);
QTableWidgetItem *__qtablewidgetitem6 = new QTableWidgetItem();
tableWidget->setVerticalHeaderItem(2, __qtablewidgetitem6);
QTableWidgetItem *__qtablewidgetitem7 = new QTableWidgetItem();
tableWidget->setVerticalHeaderItem(3, __qtablewidgetitem7);
QTableWidgetItem *__qtablewidgetitem8 = new QTableWidgetItem();
tableWidget->setVerticalHeaderItem(4, __qtablewidgetitem8);
QTableWidgetItem *__qtablewidgetitem9 = new QTableWidgetItem();
tableWidget->setVerticalHeaderItem(5, __qtablewidgetitem9);
QTableWidgetItem *__qtablewidgetitem10 = new QTableWidgetItem();
tableWidget->setVerticalHeaderItem(6, __qtablewidgetitem10);
QTableWidgetItem *__qtablewidgetitem11 = new QTableWidgetItem();
tableWidget->setVerticalHeaderItem(7, __qtablewidgetitem11);
QTableWidgetItem *__qtablewidgetitem12 = new QTableWidgetItem();
tableWidget->setVerticalHeaderItem(8, __qtablewidgetitem12);
QTableWidgetItem *__qtablewidgetitem13 = new QTableWidgetItem();
tableWidget->setVerticalHeaderItem(9, __qtablewidgetitem13);
QTableWidgetItem *__qtablewidgetitem14 = new QTableWidgetItem();
tableWidget->setItem(0, 0, __qtablewidgetitem14);
QTableWidgetItem *__qtablewidgetitem15 = new QTableWidgetItem();
tableWidget->setItem(1, 0, __qtablewidgetitem15);
QTableWidgetItem *__qtablewidgetitem16 = new QTableWidgetItem();
tableWidget->setItem(2, 0, __qtablewidgetitem16);
QTableWidgetItem *__qtablewidgetitem17 = new QTableWidgetItem();
tableWidget->setItem(3, 0, __qtablewidgetitem17);
QTableWidgetItem *__qtablewidgetitem18 = new QTableWidgetItem();
tableWidget->setItem(4, 0, __qtablewidgetitem18);
QTableWidgetItem *__qtablewidgetitem19 = new QTableWidgetItem();
tableWidget->setItem(5, 0, __qtablewidgetitem19);
QTableWidgetItem *__qtablewidgetitem20 = new QTableWidgetItem();
tableWidget->setItem(6, 0, __qtablewidgetitem20);
QTableWidgetItem *__qtablewidgetitem21 = new QTableWidgetItem();
tableWidget->setItem(7, 0, __qtablewidgetitem21);
QTableWidgetItem *__qtablewidgetitem22 = new QTableWidgetItem();
tableWidget->setItem(8, 0, __qtablewidgetitem22);
QTableWidgetItem *__qtablewidgetitem23 = new QTableWidgetItem();
tableWidget->setItem(9, 0, __qtablewidgetitem23);
tableWidget->setObjectName(QStringLiteral("tableWidget"));
tableWidget->setGeometry(QRect(20, 60, 411, 341));
tableWidget->setRowCount(10);
tableWidget->setColumnCount(4);
retranslateUi(CRankDlg);
QMetaObject::connectSlotsByName(CRankDlg);
} // setupUi
void retranslateUi(QWidget *CRankDlg)
{
CRankDlg->setWindowTitle(QApplication::translate("CRankDlg", "Form", Q_NULLPTR));
label->setText(QApplication::translate("CRankDlg", "\346\216\222\350\241\214\346\246\234", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem = tableWidget->horizontalHeaderItem(0);
___qtablewidgetitem->setText(QApplication::translate("CRankDlg", "\346\216\222\345\220\215", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem1 = tableWidget->horizontalHeaderItem(1);
___qtablewidgetitem1->setText(QApplication::translate("CRankDlg", "\347\216\251\345\256\266", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem2 = tableWidget->horizontalHeaderItem(2);
___qtablewidgetitem2->setText(QApplication::translate("CRankDlg", "\345\211\251\344\275\231\346\227\266\351\227\264", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem3 = tableWidget->horizontalHeaderItem(3);
___qtablewidgetitem3->setText(QApplication::translate("CRankDlg", "\345\210\206\346\225\260", Q_NULLPTR));
const bool __sortingEnabled = tableWidget->isSortingEnabled();
tableWidget->setSortingEnabled(false);
QTableWidgetItem *___qtablewidgetitem4 = tableWidget->item(0, 0);
___qtablewidgetitem4->setText(QApplication::translate("CRankDlg", "1", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem5 = tableWidget->item(1, 0);
___qtablewidgetitem5->setText(QApplication::translate("CRankDlg", "2", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem6 = tableWidget->item(2, 0);
___qtablewidgetitem6->setText(QApplication::translate("CRankDlg", "3", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem7 = tableWidget->item(3, 0);
___qtablewidgetitem7->setText(QApplication::translate("CRankDlg", "4", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem8 = tableWidget->item(4, 0);
___qtablewidgetitem8->setText(QApplication::translate("CRankDlg", "5", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem9 = tableWidget->item(5, 0);
___qtablewidgetitem9->setText(QApplication::translate("CRankDlg", "6", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem10 = tableWidget->item(6, 0);
___qtablewidgetitem10->setText(QApplication::translate("CRankDlg", "7", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem11 = tableWidget->item(7, 0);
___qtablewidgetitem11->setText(QApplication::translate("CRankDlg", "8", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem12 = tableWidget->item(8, 0);
___qtablewidgetitem12->setText(QApplication::translate("CRankDlg", "9", Q_NULLPTR));
QTableWidgetItem *___qtablewidgetitem13 = tableWidget->item(9, 0);
___qtablewidgetitem13->setText(QApplication::translate("CRankDlg", "10", Q_NULLPTR));
tableWidget->setSortingEnabled(__sortingEnabled);
} // retranslateUi
};
namespace Ui {
class CRankDlg: public Ui_CRankDlg {};
} // namespace Ui
QT_END_NAMESPACE
#endif // UI_CRANKDLG_H
| [
"13520782708@139.com"
] | 13520782708@139.com |
57e5d35369b5cd46becd31cf92af6d8fc689a4e1 | 2a13524e497dd4ea97b634252f770b23eb3b031e | /Chat/ChatClient/ChatClient.h | c030f50955774671f546a65a4f8ecc4371350e7c | [] | no_license | thaobktin/NetworkProgrammingCpp | 10a7370fbf6ebb2a8e542814f55fa387fde8bdab | e4fd64feaac4c885796a8b4d150079f5f8598aa2 | refs/heads/master | 2021-01-23T00:01:40.701745 | 2017-09-05T03:02:55 | 2017-09-05T03:02:55 | 102,426,911 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,319 | h | // ChatClient.h : main header file for the CHATCLIENT application
//
#if !defined(AFX_CHATCLIENT_H__F820FDDE_E4D5_4AA1_A677_72512AFC748F__INCLUDED_)
#define AFX_CHATCLIENT_H__F820FDDE_E4D5_4AA1_A677_72512AFC748F__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#ifndef __AFXWIN_H__
#error include 'stdafx.h' before including this file for PCH
#endif
#include "resource.h" // main symbols
/////////////////////////////////////////////////////////////////////////////
// CChatClientApp:
// See ChatClient.cpp for the implementation of this class
//
class CChatClientApp : public CWinApp
{
public:
CChatClientApp();
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CChatClientApp)
public:
virtual BOOL InitInstance();
//}}AFX_VIRTUAL
// Implementation
//{{AFX_MSG(CChatClientApp)
// NOTE - the ClassWizard will add and remove member functions here.
// DO NOT EDIT what you see in these blocks of generated code !
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_CHATCLIENT_H__F820FDDE_E4D5_4AA1_A677_72512AFC748F__INCLUDED_)
| [
"thaobktin@gmail.com"
] | thaobktin@gmail.com |
2409a17ad679f7ab4dcfa91fc1ae0352b83efc30 | 2780081bb046866b1449519cbe4dd78fbbf0719e | /XUL.framework/Versions/2.0/include/nsITextScroll.h | f5cf6c835bf29026bdeb682c96a392a5563bb33d | [] | no_license | edisonlee55/gluezilla-mac | d8b6535d2b36fc900eff837009372f033484a63f | 45d559edad7b5191430e139629d2aee918aa6654 | refs/heads/master | 2022-09-23T19:57:18.853517 | 2020-06-03T03:57:37 | 2020-06-03T03:57:37 | 267,499,676 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,559 | h | /*
* DO NOT EDIT. THIS FILE IS GENERATED FROM /builds/slave/rel-2.0-xr-osx64-bld/build/docshell/base/nsITextScroll.idl
*/
#ifndef __gen_nsITextScroll_h__
#define __gen_nsITextScroll_h__
#ifndef __gen_nsISupports_h__
#include "nsISupports.h"
#endif
/* For IDL files that don't want to include root IDL files. */
#ifndef NS_NO_VTABLE
#define NS_NO_VTABLE
#endif
/* starting interface: nsITextScroll */
#define NS_ITEXTSCROLL_IID_STR "067b28a0-877f-11d3-af7e-00a024ffc08c"
#define NS_ITEXTSCROLL_IID \
{0x067b28a0, 0x877f, 0x11d3, \
{ 0xaf, 0x7e, 0x00, 0xa0, 0x24, 0xff, 0xc0, 0x8c }}
/**
* The nsITextScroll is an interface that can be implemented by a control that
* supports text scrolling.
*/
class NS_NO_VTABLE NS_SCRIPTABLE nsITextScroll : public nsISupports {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_ITEXTSCROLL_IID)
/**
* Scroll the view up or down by aNumLines lines. positive
* values move down in the view. Prevents scrolling off the
* end of the view.
* @param numLines number of lines to scroll the view by
*/
/* void scrollByLines (in long numLines); */
NS_SCRIPTABLE NS_IMETHOD ScrollByLines(PRInt32 numLines) = 0;
/**
* Scroll the view up or down by numPages pages. a page
* is considered to be the amount displayed by the clip view.
* positive values move down in the view. Prevents scrolling
* off the end of the view.
* @param numPages number of pages to scroll the view by
*/
/* void scrollByPages (in long numPages); */
NS_SCRIPTABLE NS_IMETHOD ScrollByPages(PRInt32 numPages) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsITextScroll, NS_ITEXTSCROLL_IID)
/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSITEXTSCROLL \
NS_SCRIPTABLE NS_IMETHOD ScrollByLines(PRInt32 numLines); \
NS_SCRIPTABLE NS_IMETHOD ScrollByPages(PRInt32 numPages);
/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSITEXTSCROLL(_to) \
NS_SCRIPTABLE NS_IMETHOD ScrollByLines(PRInt32 numLines) { return _to ScrollByLines(numLines); } \
NS_SCRIPTABLE NS_IMETHOD ScrollByPages(PRInt32 numPages) { return _to ScrollByPages(numPages); }
/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSITEXTSCROLL(_to) \
NS_SCRIPTABLE NS_IMETHOD ScrollByLines(PRInt32 numLines) { return !_to ? NS_ERROR_NULL_POINTER : _to->ScrollByLines(numLines); } \
NS_SCRIPTABLE NS_IMETHOD ScrollByPages(PRInt32 numPages) { return !_to ? NS_ERROR_NULL_POINTER : _to->ScrollByPages(numPages); }
#if 0
/* Use the code below as a template for the implementation class for this interface. */
/* Header file */
class nsTextScroll : public nsITextScroll
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSITEXTSCROLL
nsTextScroll();
private:
~nsTextScroll();
protected:
/* additional members */
};
/* Implementation file */
NS_IMPL_ISUPPORTS1(nsTextScroll, nsITextScroll)
nsTextScroll::nsTextScroll()
{
/* member initializers and constructor code */
}
nsTextScroll::~nsTextScroll()
{
/* destructor code */
}
/* void scrollByLines (in long numLines); */
NS_IMETHODIMP nsTextScroll::ScrollByLines(PRInt32 numLines)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void scrollByPages (in long numPages); */
NS_IMETHODIMP nsTextScroll::ScrollByPages(PRInt32 numPages)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* End of implementation class template. */
#endif
#endif /* __gen_nsITextScroll_h__ */
| [
"edisonlee@edisonlee55.com"
] | edisonlee@edisonlee55.com |
3aa1e9f7c583dc262b62025d9596a669f47a8770 | ba86279dd568979d29b7f3b92840dfb6bc1f3ba0 | /TankWar1_9/tank.cpp | 8a72c5838b012263c6f6935b4a40439f3e8c8529 | [] | no_license | ChenYilei2016/MyTankWar | 5e690ea6e9defc3bc579b18c1b8c69dd816e51df | 6ce8495bf8587fa74f4ab9d259e3e11297c14f0b | refs/heads/master | 2020-03-27T05:23:01.420150 | 2019-01-01T05:14:34 | 2019-01-01T05:14:34 | 146,014,430 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,007 | cpp | #include "tank.h"
Tank::Tank(int x, int y, bool GOOD, QObject *parent) : QObject(parent)
{
this->x = x;
this->y = y;
oldX = x;
oldY = y;
this->good = GOOD;
tc = static_cast<TankClient *>(parent);
pt = new Pt(x,y,this);
pt->setDir(D);
srand(time(0));
}
void Tank::draw( QPainter &paint) //坦克的画法
{
if(!live)
return ;
if( 0 ==this->oneTankID %2)
{
paint.setBrush(QBrush(QColor(255,0,0)));
}
else
{
paint.setBrush(QBrush(QColor(0,0,255)));
}
//服务器给的唯一ID
paint.drawText(this->x-TANK_WIDTH/2,this->y-TANK_HEIGHT/2-1,"id:"+QString::number(oneTankID) );
//当前的x，y然后画个椭圆
paint.drawEllipse(QPoint(x,y),15,15);
pt->draw(paint);
move();
}
void Tank::keypress(QKeyEvent *event)
{
if(event->isAutoRepeat())
return ;
const int key = event->key();
if( key== Qt::Key_Up)
{
bU = true;
LocalDecided();
}
else if(key == Qt::Key_Down)
{
bD = true;
LocalDecided();
}
else if(key == Qt::Key_Left)
{
bL = true;
LocalDecided();
}
else if(key == Qt::Key_Right)
{
bR = true;
LocalDecided();
}
//if(bU || bD || bL || bR) IsPress = true;
}
void Tank::keyrelease(QKeyEvent *e)
{
if(e->isAutoRepeat())
return ;
const int key = e->key();
switch(key)
{
case Qt::Key_Up:
bU = false;
LocalDecided();
break;
case Qt::Key_Down:
bD = false;
LocalDecided();
break;
case Qt::Key_Left:
bL = false;
LocalDecided();
break;
case Qt::Key_Right:
bR = false;
LocalDecided();
break;
case Qt::Key_W: //w 发射炮弹
fire();
break;
default:
break;
}
//if(!bU &&!bD &&!bL && !bR) IsPress = false;
}
void Tank::move()
{
oldX = x;
oldY = y;
switch(dir)
{
case L:
x -=XSPEED;
break;
case LU:
x-= XSPEED;
y-= YSPEED;
break;
case U:
y-= YSPEED;
break;
case RU:
x+= XSPEED;
y-= YSPEED;
break;
case R:
x+= XSPEED;
break;
case RD:
x+= XSPEED;
y+= YSPEED;
break;
case D:
y+= YSPEED;
break;
case LD:
x-= XSPEED;
y+= YSPEED;
break;
case STOP:
break;
}
// if(!good)
// {
// if(0 == step)
// {
// dir = Direction(rand()%8);
// step = rand()%15+3;
// }
// if( 0 ==step % 10)
// {
// this->fire();
// }
// step--;
// }
//移动炮筒
pt->move(x,y,dir);
if(x<15)x=15;
if(y<15)y=15;
if(x+TANK_WIDTH/2>GAME_WIDTH) x = GAME_WIDTH-TANK_WIDTH/2;
if(y+TANK_HEIGHT/2>GAME_HEIGHT) y = GAME_HEIGHT-TANK_HEIGHT/2;
}
void Tank::stay()
{
this->x = oldX;
this->y = oldY;
}
void Tank::fire()
{
if(!this->getLive())
return ;
Missile * m = new Missile(this->getOneTankID(),x,y,pt->getDir(),tc,this);
m->setGood(this->good);
tc->missiles.push_back(m);
if(tc->netclient != NULL && tc->netclient->IsConnected() )
{
MissileNewMsg msg(m); //发送一个子弹产生的消息
tc->sendMsg(&msg);
}
return ;
}
QRect Tank::getRect()
{
return QRect(x-TANK_WIDTH/2,y-TANK_HEIGHT/2,TANK_WIDTH,TANK_HEIGHT);
}
void Tank::LocalDecided()
{
oldDir = this->getDir();
if(bL && !bU && ! bR && !bD)
{
dir = L;
}
else if(bL && bU && ! bR && !bD)
{
dir = LU;
}
else if(!bL && bU && ! bR && !bD)
{
dir = U;
}
else if(!bL && bU && bR && !bD)
{
dir = RU;
}
else if(!bL && !bU && bR && !bD)
{
dir = R;
}
else if(!bL && !bU && bR && bD)
{
dir = RD;
}
else if(!bL && !bU && ! bR && bD)
{
dir = D;
}
else if( bL && !bU && ! bR && bD)
{
dir = LD;
}
else if(!bL && !bU && ! bR && !bD)
{
dir = STOP;
}
//改变方向的时候 发送一个消息
if(tc->netclient != NULL)
{
if(oldDir != this->dir)
{
if(tc->netclient->IsConnected()&& this->getLive())
{
TankMoveMsg msg(this->oneTankID,this->dir,this->x,this->y);
tc->sendMsg(&msg);
}
}
}
}
Direction Tank::getDir() const
{
return dir;
}
void Tank::setDir(const Direction &value)
{
dir = value;
}
int Tank::getY() const
{
return y;
}
void Tank::setY(int value)
{
y = value;
}
int Tank::getX() const
{
return x;
}
void Tank::setX(int value)
{
x = value;
}
int Tank::getOneTankID() const
{
return oneTankID;
}
void Tank::setOneTankID(int value)
{
oneTankID = value;
}
bool Tank::getGood() const
{
return good;
}
void Tank::setGood(bool value)
{
good = value;
}
bool Tank::hitWall(Wall *wall)
{
if(!this->live)return false;
if(wall->getRect().intersects(this->getRect()) )
{
this->stay();
//this->dir =(Direction)(rand()%8);
return true;
}
return false;
}
bool Tank::hitTanks(QList<Tank *> tanks)
{
QList<Tank*>::iterator ite = tanks.begin();
for(auto & ite : tanks )
{
Tank * t= ite;
if(t->getRect().intersects(this->getRect()) && t!= this)
{
t->stay();
this->stay();
return true;
}
}
return false;
}
bool Tank::getLive() const
{
return live;
}
void Tank::setLive(bool value)
{
live = value;
}
| [
"705029004@qq.com"
] | 705029004@qq.com |
b5607014080a779088054b58b7fd3102cfec8b39 | 7590c1811a3a46442a7ee8ffd909c1bf6189cc84 | /chat_item/regdialog.cpp | de54b62510d4d9e36278e6b00548f6177d362ddb | [] | no_license | xmmgit/qt_chat | b3b2740f5105671b8b024a4233ced2f72436da62 | 216674a9ec0d9501a71c6954bcf18eba76bdcdec | refs/heads/master | 2021-04-03T04:58:51.400331 | 2018-03-13T08:21:35 | 2018-03-13T08:21:35 | 125,014,559 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,767 | cpp | #include "regdialog.h"
#include "ui_regdialog.h"
#include<QShowEvent>
#include<QMessageBox>
#include <QObject>
regDialog::regDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::regDialog)
{
ui->setupUi(this);
}
regDialog::~regDialog()
{
delete ui;
}
void regDialog::showEvent(QShowEvent * event )
{
if(event->type()==QEvent::Show)
{
sock.connectToHost("192.168.9.119",9999);
char choicelog[20]="reg";
//发送登录识别
sock.write(choicelog);
ui->regb->setEnabled(false);
}
connect(&sock,SIGNAL(readyRead()),this,SLOT(onSockReadyRead()));
connect(ui->rpassword,SIGNAL(editingFinished()),this,SLOT(onfoces()));
connect(ui->name,SIGNAL(editingFinished()),this,SLOT(onnamefoces()));
}
void regDialog::on_regb_clicked()
{
int nsex;
QString sex;
QString name=ui->name->text();
QString password=ui->password->text();
QString rpassword=ui->rpassword->text();
nsex=ui->mb->isChecked();
if(nsex==1)
{
sex=QString::fromUtf8("男");
}
else
{
sex=QString::fromUtf8("女");
}
QString bir=ui->bir->text();
QString mail=ui->mail->text();
QString addr=ui->addr->text();
QString usermsg=name+QString(":")+password+QString(":")+rpassword+QString(":")+sex+QString(":")+bir+QString(":")+mail+
QString(":")+addr;
sock.write(usermsg.toUtf8());
}
void regDialog::on_backb_clicked()
{
close();
}
void regDialog::onSockReadyRead()
{
QString reply(sock.readAll().data());
qDebug()<<reply;
if(reply=="yes")
{
QPalette npa;
npa.setColor(QPalette::WindowText,Qt::red);
ui->nametip->setPalette(npa);
QPalette gpa;
gpa.setColor(QPalette::WindowText,Qt::green);
ui->nametip->setPalette(gpa);
if(ui->name->text()=="")
{
ui->nametip->setText(QString::fromUtf8("昵称NULL！！！"));
ui->regb->setEnabled(false);
ui->nametip->setPalette(npa);
}
else
{
ui->nametip->setText(QString::fromUtf8("昵称可用"));
flag=1;
if(pflag==1)
ui->regb->setEnabled(true);
}
}
else if(reply=="no")
{
ui->nametip->setText(QString::fromUtf8("昵称已存在！！！"));
QPalette pa;
pa.setColor(QPalette::WindowText,Qt::red);
ui->nametip->setPalette(pa);
ui->regb->setEnabled(false);
flag=0;
}
else if(reply=="0")
{
QMessageBox::information(this,QString::fromUtf8("提示"),QString::fromUtf8("注册成功"));
ui->regb->setEnabled(false);
}
else if(reply=="1")
{
QMessageBox::critical(this,QString::fromUtf8("提示"),QString::fromUtf8("注册失败！！"));
}
}
void regDialog::onnamefoces()
{
QString name=QString("name:")+ui->name->text();
sock.write(name.toUtf8());
}
void regDialog::onfoces()
{
if(ui->password->text()!=ui->rpassword->text())
{
ui->rpastip->setText(QString::fromUtf8("两次密码不一致"));
QPalette pa;
pa.setColor(QPalette::WindowText,Qt::red);
ui->rpastip->setPalette(pa);
ui->regb->setEnabled(false);
pflag=0;
}
else
{
if((ui->password->text()!=""))
{
ui->rpastip->setText(QString::fromUtf8("密码可用"));
QPalette pa;
pa.setColor(QPalette::WindowText,Qt::green);
ui->rpastip->setPalette(pa);
if(flag==1)
{
ui->regb->setEnabled(true);
}
pflag=1;
}
}
}
| [
"609527336@qq.com"
] | 609527336@qq.com |
3db260972f32a4492a207a7edc948d1b505dc2ed | dd4d0f2589130357cfaa7e8c82acd6d3157ca882 | /project1/accumSim.cpp | 0d2e03d494b7dca8685a815a27723edd55a84c9b | [] | no_license | MichaelRJones/Auburn-Schoolwork | 25b59ea51d3bbd5dc22afee1ee51017d7f8dbecf | 193c15cdc4d0396a6679843839967515cd191e43 | refs/heads/master | 2021-01-21T10:12:49.178267 | 2015-06-24T03:54:28 | 2015-06-24T03:54:28 | 37,958,941 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,693 | cpp | #include <iostream>
#include <string>
#include <cstdint>
#include <sstream>
#include <fstream>
#include <cstring>
using namespace std;
typedef uint32_t mem_addr;
typedef int32_t mem_word;
typedef int32_t reg_word;
/*
* Author: Kyle Taylor
* Date: 9/9/14
*/
class Memory {
public:
mem_word read(mem_addr address);
void write(mem_addr address, mem_word item);
bool load();
int convert(char* input);
//0 because we are not using an operating system
static const mem_addr OP_BASE_ADDR = 0x20000000;
static const mem_addr DATA_BASE_ADDR = 0x20000118; //280, no space between op code and data
static const mem_addr DATA_OFFSET = 0x00000118;
static const mem_addr MEMORY_LEN = 0x000001A4; //420, the size of our main memory
private:
//40bit memory per instruction, first 8 bits is op code, next 32 bits is data address
//140 instructions, 140 places for data values
//ex mainMemory[0] = first op code at address 0x20000000, mainMemory[1] is first data address
mem_word mainMemory[420];
};
class Accumulator {
public:
int main();
private:
reg_word mRegister;
};
//Program Execution
int main() {
Accumulator accumulator;
return accumulator.main();
}
//Accumulator switch case
int Accumulator::main() {
Memory memory;
bool keepControl = true;
string anyKey;
//Make sure the memory loads correctly
if (!memory.load()) {
return 1;
}
mem_word instruction;
mem_addr pc = memory.OP_BASE_ADDR;
//pc cannot get into the data segment
while (keepControl && pc < (memory.DATA_BASE_ADDR - 1)) {
instruction = memory.read(pc);
mem_addr dataAddr = memory.read(pc + 1);
switch (instruction) {
//Load X
case 0x01:
mRegister = memory.read(dataAddr);
break;
//Store X
case 0x0A:
memory.write(dataAddr, mRegister);
break;
//Add X
case 0x10:
mRegister += memory.read(dataAddr);
break;
//MULT X
case 0xA0:
mRegister *= memory.read(dataAddr);
break;
//End
case 0xAA:
keepControl = false;
break;
}
pc += 2;
}
cout << "Register equals: " << mRegister << endl;
exit(0); //Problems with return statement
}
// Convert from string to hexadecimal - from Stack Overflow
int Memory::convert(char* input) {
char *p;
int uv=0;
uv=strtoul(input, &p, 16);
return uv;
}
// End code from Stack Overflow
//Load, Read, and Write Memory
mem_word Memory::read(mem_addr address) {
address -= 0x20000000;
return mainMemory[address];
}
void Memory::write(mem_addr address, mem_word item) {
address -= 0x20000000;
mainMemory[address] = item;
}
bool Memory::load() {
stringstream ss;
ifstream fileStream;
string filename;
string line;
int mode;
//Get file name
cout << "Enter file name: ";
cin >> filename;
cout << endl;
fileStream.open(filename);
//Make sure file opens correctly
if (!fileStream.is_open()) {
cout << "Error opening file..." << endl << "Ending program";
return false;
}
mem_addr instructionAddr = OP_BASE_ADDR;
mem_addr dataAddr;
mem_word instruction;
//Read in all file lines
while (getline(fileStream, line)) {
//Keep track of what we are reading in
if (line.substr(0, 5) == ".text") {
//We are reading in instructions
mode = 0;
}
else if (line.substr(0, 5) == ".data") {
//We are reading in data
mode = 1;
}
//TEXT
else if (mode == 0) {
//make sure it is in the instruction base range
if (instructionAddr < (DATA_BASE_ADDR - 1) && instructionAddr >= OP_BASE_ADDR) {
char* text;
strcpy(text, line.substr(2, 2).c_str());
instruction = convert(text);
write(instructionAddr, instruction);
//Not all text will be followed by a data address
if (line.length() > 4) {
strcpy(text, line.substr(4, 8).c_str());
dataAddr = convert(text);
write(instructionAddr + 1, dataAddr + DATA_OFFSET);
}
}
else {
cout << "Instruction out of range\n";
}
instructionAddr += 2;
}
//DATA
else if (mode == 1) {
char* text;
mem_word data;
string debug = line.substr(2, 8);
strcpy(text, line.substr(2, 8).c_str());
dataAddr = convert(text);
dataAddr += DATA_OFFSET;
//make sure data is in the data base range
if (dataAddr >= DATA_BASE_ADDR && dataAddr < (DATA_BASE_ADDR + MEMORY_LEN)) {
strcpy(text, line.substr(10, 8).c_str());
data = convert(text);
write(dataAddr, data);
}
else {
cout << "Instruction out of range\n";
}
}
}
fileStream.close();
return true;
}
| [
"michaelrjones6@gmail.com"
] | michaelrjones6@gmail.com |
dce43cc4ac8c90e9612b98432171b411e9244971 | a3f704871b974c69fddec501e8d0d5c607f2a898 | /E23-schuif-potmeter/schuif-potmeter.ino | 043a35f42a63fdfe9185f9adabf075cc712b37cb | [] | no_license | robert190879/Arduino-Beginners-NL | b2f9aa8c9ea2a6aef3ed2e966b2ab3af581aac48 | ed370a755e935eaaca122fde3cad181455162961 | refs/heads/master | 2023-04-05T16:02:58.660585 | 2021-04-17T05:13:26 | 2021-04-17T05:13:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 992 | ino | /*
* Bas on Tech - Schuif potmeter
* Deze les is onderdeel van de lessen op https://arduino-lessen.nl
*
* (c) Copyright 2019 - Bas van Dijk / Bas on Tech
* Deze code en inhoud van de lessen mag zonder schriftelijke toestemming
* niet voor commerciele doeleinden worden gebruikt
*
* YouTube: https://www.youtube.com/c/BasOnTechNL
* Facebook: https://www.facebook.com/BasOnTechChannel
* Instagram: https://www.instagram.com/BasOnTech
* Twitter: https://twitter.com/BasOnTech
*
*/
int potmeterPin = A0; // Schuif potmeter pin op A0
int potmeterVal = 0; // Waarde van potmeter
void setup() {
Serial.begin(9600); // Stel de seriële monitor in
}
// Herhaal oneindig
void loop() {
potmeterVal = analogRead(potmeterPin); // Lees de analoge waarde van de Schuif potmeter
Serial.println(potmeterVal); // Toon de waarde in de seriële monitor
delay(100); // Pauzeer 100ms
}
| [
"info@basontech.com"
] | info@basontech.com |
656b00dab1cbf87067c3c5a78e9d2e0b518af0fe | 656d1cdc9b4a61305c3468c739fcaf52ed7b368f | /jni/test/test_map.cpp | 48cc569a6c96ebfe26f56d1d13b932031e547d91 | [] | no_license | arikwex/maslab-sim-2015 | 2a35a47ddc8077bcf7cb78222c2498fc052d5ed4 | a70e107b431f67c2f7041ce7ed40d720d6a0844e | refs/heads/master | 2021-01-10T21:57:40.250266 | 2015-01-30T17:18:43 | 2015-01-30T17:18:43 | 29,835,280 | 0 | 1 | null | 2015-01-30T05:23:23 | 2015-01-25T22:57:45 | C++ | UTF-8 | C++ | false | false | 533 | cpp | #include "map.h"
#include "gtest/gtest.h"
TEST(MapTest, TestWallRaster) {
Map m({Wall(5.0, 5.0, 10.0, 10.0)}, {}, RobotPose(1, 2, PI));
EXPECT_EQ(Map::NONE, m.getMapElement(0.0, 0.0));
EXPECT_EQ(Map::NONE, m.getMapElement(5.5, 5.0));
EXPECT_EQ(Map::WALL, m.getMapElement(5.0, 5.0));
EXPECT_EQ(Map::WALL, m.getMapElement(10.0, 10.0));
EXPECT_EQ(Map::WALL, m.getMapElement(7.0, 7.0));
EXPECT_DOUBLE_EQ(1, m.getInitPose().x);
EXPECT_DOUBLE_EQ(2, m.getInitPose().y);
EXPECT_DOUBLE_EQ(PI, m.getInitPose().theta);
}
| [
"gurtej@mit.edu"
] | gurtej@mit.edu |
c0ba2049bde8273a84c68011881bdd825488cf4e | 21e35ad8479abc12793471b7fc18f0962c675a8f | /cpp/console/utf8Reader/code/src/SuperBinaryDisplayUtil.h | 5791883da49603a82eefd795b449594b3ccae47b | [] | no_license | EdisoNewtong/Vector | a16cdda585e4706c4d096562846c2186243a914c | 07ea562e13b74d784bc02f419fa5cbd3f7ab2a88 | refs/heads/master | 2023-08-18T20:08:27.552592 | 2023-06-27T16:15:50 | 2023-06-27T16:16:34 | 82,069,585 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,106 | h | #ifndef SUPER_BINARY_DISPLAY_UTIL_H
#define SUPER_BINARY_DISPLAY_UTIL_H
#include <fstream>
#include <string>
#include <utility>
#include <sstream>
#include <vector>
#include <list>
using namespace std;
namespace SuperBinaryDisplayUtil
{
struct SpecialAnsiChar
{
char ch;
unsigned int ansi_code;
string hexCodeStr;
string displayStr;
string displayStr2;
};
// '\t', '\n', '\v', '\f', '\r',
// ch , ansi_code , hexStrCode, displayStr, displayStr2
const SpecialAnsiChar G_CHAR_TAB = { '\t', static_cast<unsigned int>('\t'), string("09"), string("\\t"), string("\\t") }; // \t = 9
const SpecialAnsiChar G_CHAR_GN = { '\n', static_cast<unsigned int>('\n'), string("0A"), string("\\n"), string("<LF>") }; // \t = 10 = <LF>
const SpecialAnsiChar G_CHAR_GR = { '\r', static_cast<unsigned int>('\r'), string("0D"), string("\\r"), string("<CR>") }; // \r = 13 = <CR>
//
// not very Common Ansi
//
const SpecialAnsiChar G_CHAR_VTAB = { '\v', static_cast<unsigned int>('\v'), string("0B"), string("\\v"), string("\\v") }; // \r = 13 = <CR>
// 0000 1100 014 12 0x0C FF (NP form feed, new page) 换页键
const SpecialAnsiChar G_CHAR_GNP = { '\f', static_cast<unsigned int>('\f'), string("0C"), string("\\f"), string("\\f") }; // \r = 13 = <CR>
const int SPECIAL_CHAR_CNT = 3;
const int EOF_TYPE_CNT = 3;
const size_t SIZE_BOM = 3;
const unsigned int utf8_Bom_tag[SIZE_BOM] = { 0xEF, 0xBB, 0xBF }; // ==> U+FEFF
const unsigned int FULL_BITS = 0xFF;
const size_t UTF8_FULL_LEN = 4;
const unsigned int multiBytesStartTag[UTF8_FULL_LEN] = {
// lead byte for 3 conditions ( 2-bytes / 3-bytes / 4-bytes )
0x06, // 110X,XXXX -> tag >> 5 = 0000,0110 = 0x06 // 2 bytes
0x0E, // 1110,XXXX -> tag >> 4 = 0000,1110 = 0x0E // 3 bytes
0x1E, // 1111,0XXX -> tag >> 3 = 0001,1110 = 0x1E // 4 bytes
// next bytes
0x02 // 10XX,XXXX -> tag >> 6 = 0000,0010 = 0x02 // the bytes after the leader bytes must be like the following style 10XX,XXXX
};
// ??? a multi-bytes character will always occupy 1/2 space ?? that's a question
const int C_N_WIDTH_4_MULTI_BYTES_CHARACTER_1 = 1;
const int C_N_WIDTH_4_MULTI_BYTES_CHARACTER_2 = 2;
const int C_N_WIDTH_4_MULTI_BYTES_CHARACTER_USED = C_N_WIDTH_4_MULTI_BYTES_CHARACTER_1;
const bool SHOULD_LOG_OPEN_FAILED = true;
const bool SHOULD_LOG_EMPTY_FILE = false;
// ###########################################################################
// ###########################################################################
// ###########################################################################
// ###########################################################################
// ###########################################################################
struct SingleCharacter
{
protected:
SingleCharacter();
public:
virtual ~SingleCharacter();
static SingleCharacter* generate_ASCII_Character(char ch, int row, int col, int eofFlag);
static SingleCharacter* generate_MultiBytes_Character(const string& displayCharacter, unsigned int unicode32, int row, int col);
////////////////////////////////////////////////////////////////////////////////////////////////////////
// Field Parts
//
char ansi_char;
char binary_charAry[UTF8_FULL_LEN];
string display_str;
string utf8HexAry[UTF8_FULL_LEN];
unsigned short nBytes; // 1 or 2 or 3 or 4
unsigned int unicode32;
string unicode32_str;
int nRow;
int nCol;
int nEOF_Flag;
int reserverd_flag; // = 0
};
struct FileInfo
{
enum E_ENDLINE_MODE {
E_UNKNOWN_ENDLINE = 0,
E_UNIX = 1, E_LINUX = 1, // \n Unix and Linux , with the same EOF End-Of-Line
E_WIN = 2, // \r\n
E_MAC = 3, // \r
E_HYBRID = 4,
};
FileInfo();
virtual ~FileInfo();
// Member Data
string filename;
bool isValid;
bool isBomFile;
bool isBinary;
int bytesCount;
int characterCount;
int lineCnt; // 行数
int hybridLineNo; // 多重 EOF，初次被确定的那一行
E_ENDLINE_MODE endlineMode;
int firstBinaryByte_Idx;
int firstBinaryByte_Row;
int firstBinaryByte_Col;
vector<string*> rawHexVec;
// line Display Vector , int stored the lineNo
list< pair<list<SingleCharacter*>*, int> > lineVec;
// new added quote-string
list< pair<string,int> > quoteStringList;
};
bool isCanInputChar(const char& ch);
unsigned int char2HexCode(const char& ch, string* displayHexCode = nullptr);
int getDecimalBits(int num);
//
// very very old version , 1 byte after another
//
bool readFile_V0(const string& filename, FileInfo& fInfo);
// do <NOT> skip any letter , scan from the file's begin to the end of the file
//----------------------------------------------------------------------------------------------------
// when the parser meet multi-bytes character , it will try to judge how many bytes can make a character
// and read subsequence n bytes all together
//----------------------------------------------------------------------------------------------------
bool readFile_V1(const string& filename, FileInfo& fInfo);
// stop scanning bytes after a certain bytes has been treat as binary flag
bool readFileRapidly(const string& filename, FileInfo& fInfo);
// new Added
bool readCpp_File(const string& filename, FileInfo& fInfo);
void printFileInfo(const FileInfo& fileInfo, string& retStr, bool needPrintToConsole = false);
} // end namespace SuperBinaryDisplayUtil
#endif
| [
"edisonewtong@163.com"
] | edisonewtong@163.com |
5ddc7d39190a9e3f275705de7dac3eaa0d72d1e6 | fa1defefd03c28049d7c65a22f353260c890106d | /Validation/0/k.abl | d12f063368e947c06a9fd98fef7c9bb89d1606ea | [] | no_license | sushobhansen/Wind-Study | 41715a8401538ef415943787c6c06016d25b4640 | 8cf722c63fccbb2d9c34244acbf0ec3b19a347a7 | refs/heads/master | 2020-12-01T00:28:21.439056 | 2019-12-27T21:54:07 | 2019-12-27T21:54:07 | 230,521,738 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,903 | abl | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 5.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format binary;
class volScalarField;
location "0";
object k;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
kInlet 4.7e-3;
internalField uniform $kInlet;
boundaryField
{
roads1
{
type kqRWallFunction;
value uniform $kInlet;
}
roads3
{
type kqRWallFunction;
value uniform $kInlet;
}
roads2
{
type kqRWallFunction;
value uniform $kInlet;
}
south
{
type zeroGradient;
}
west
{
type atmBoundaryLayerInletK;
value uniform $kInlet;
#include "includes/ABLConditions";
}
walls
{
type kqRWallFunction;
value uniform $kInlet;
}
east
{
type zeroGradient;
}
roofs
{
type kqRWallFunction;
value uniform $kInlet;
}
north
{
type zeroGradient;
}
atmosphere
{
type symmetry;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //
| [
"icecoolsushobhan@gmail.com"
] | icecoolsushobhan@gmail.com |
1e94072b9e440aaffe4d9f440317a5c60dc28880 | 05b80fcc656682e8c9c90f9b511bd4d6457c387e | /src/runtime/optimizer/OptimizerActivator.cpp | 7e81263e6d3b860d3018a32881e336c9ae529b6b | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | osbornjd/exatn | cc34349830f5c4343b8f5f757ea8572e073a73f2 | c17fae68878b62b7f28d77b7d0779a1a8cbbada8 | refs/heads/master | 2020-06-23T00:23:59.812828 | 2019-07-18T20:28:05 | 2019-07-18T20:28:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 473 | cpp |
#include "cppmicroservices/BundleActivator.h"
#include "cppmicroservices/BundleContext.h"
#include <memory>
#include <set>
using namespace cppmicroservices;
namespace {
/**
*/
class US_ABI_LOCAL OptimizerActivator : public BundleActivator {
public:
OptimizerActivator() {}
/**
*/
void Start(BundleContext context) {
}
/**
*/
void Stop(BundleContext /*context*/) {}
};
} // namespace
CPPMICROSERVICES_EXPORT_BUNDLE_ACTIVATOR(OptimizerActivator) | [
"mccaskeyaj@ornl.gov"
] | mccaskeyaj@ornl.gov |
b4172250e18e4ceb675875285822806cfbcffd5d | 7ed17d60f2c1ebd24383fa416ccc5481b386ceb8 | /search/hashsearch/main.cpp | e8482794535d10d8f43695fd5b670cc209753e1c | [] | no_license | taokong1017/train | 781c02c99fb50e578ac17266103a9aba55be3666 | 6784bacd8ed9b9ff2118802ba332fafdb94c4458 | refs/heads/master | 2023-03-22T21:28:39.212320 | 2021-03-03T13:45:27 | 2021-03-03T13:45:27 | 262,312,027 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,810 | cpp | #include <iostream>
#include <vector>
#include <tuple>
using namespace std;
template<typename T>
using HashTable= vector<vector<T>>;
template<typename T>
size_t hashValue(const T& data, size_t module)
{
return ((3*data)%module);
}
template<typename T>
void insertHashTable(HashTable<T>& table, const T& data)
{
size_t index = hashValue<T>(data, table.size());
if (index >= table.size()) {
return;
}
table[index].push_back(data);
}
template<typename T>
HashTable<T> loadHashTable(const vector<T>& data, float factor)
{
HashTable<T> table;
if (data.empty() || factor <= 0 || factor >= 1){
return table;
}
size_t dataSize = data.size();
size_t tableSize = dataSize/factor;
for(size_t i = 0; i < tableSize; i++) {
vector<T> list;
table.emplace_back(list);
}
for(const auto& e : data) {
insertHashTable<T>(table, e);
}
return table;
}
template<typename T>
pair<int, int> searchHashTable(const HashTable<T>& table, const T& target)
{
pair<int, int> result(-1, -1);
size_t index_first = hashValue<T>(target, table.size());
size_t index_second(0);
for(const auto& data : table[index_first]) {
if (data == target) {
result.first = index_first;
result.second = index_second;
return result;
}
index_second++;
}
return result;
}
int main(int argc, char** argv)
{
vector<int> data {1, 2, 3, 4, 7, 7, 8, 3, 5};
int target = 7;
HashTable<int> table = loadHashTable<int>(data, 0.7);
pair<int, int> result = searchHashTable<int>(table, target);
std::cout << "first: " << result.first << ", second: " << result.second << std::endl;
return 0;
} | [
"wang_song1017@163.com"
] | wang_song1017@163.com |
399b7404f70c7e5e0f69363edca352ff626e799b | 7188c98e04cd9c48942195b7f0f22e4717efb674 | /components/feed/core/v2/feed_network_impl.cc | 433500e7ba0f06e50606f56b0ee065393086f3eb | [
"BSD-3-Clause"
] | permissive | tornodo/chromium | 1aa8fda7e9f506ddf26d69cd74fcf0e9e6595e39 | 1d748d142bde525249a816b1d9179cd9b9fa6419 | refs/heads/master | 2022-11-30T12:17:02.909786 | 2020-08-01T03:40:02 | 2020-08-01T03:40:02 | 197,871,448 | 0 | 0 | BSD-3-Clause | 2020-08-01T03:40:03 | 2019-07-20T02:53:57 | null | UTF-8 | C++ | false | false | 19,249 | cc | // Copyright 2020 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.
#include "components/feed/core/v2/feed_network_impl.h"
#include <memory>
#include <utility>
#include "base/base64url.h"
#include "base/bind.h"
#include "base/containers/flat_set.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/time/tick_clock.h"
#include "base/time/time.h"
#include "components/feed/core/common/pref_names.h"
#include "components/feed/core/proto/v2/wire/action_request.pb.h"
#include "components/feed/core/proto/v2/wire/feed_action_response.pb.h"
#include "components/feed/core/proto/v2/wire/feed_query.pb.h"
#include "components/feed/core/proto/v2/wire/request.pb.h"
#include "components/feed/core/proto/v2/wire/response.pb.h"
#include "components/feed/core/v2/metrics_reporter.h"
#include "components/prefs/pref_service.h"
#include "components/signin/public/identity_manager/access_token_info.h"
#include "components/signin/public/identity_manager/identity_manager.h"
#include "components/signin/public/identity_manager/primary_account_access_token_fetcher.h"
#include "components/signin/public/identity_manager/scope_set.h"
#include "components/variations/net/variations_http_headers.h"
#include "net/base/load_flags.h"
#include "net/base/url_util.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_status_code.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "services/network/public/cpp/resource_request.h"
#include "services/network/public/cpp/resource_request_body.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "services/network/public/cpp/simple_url_loader.h"
#include "third_party/protobuf/src/google/protobuf/io/coded_stream.h"
#include "third_party/zlib/google/compression_utils.h"
namespace feed {
namespace {
constexpr char kApplicationXProtobuf[] = "application/x-protobuf";
constexpr base::TimeDelta kNetworkTimeout = base::TimeDelta::FromSeconds(30);
constexpr char kUploadActionUrl[] =
"https://discover-pa.googleapis.com/v1/actions:upload";
signin::ScopeSet GetAuthScopes() {
return {"https://www.googleapis.com/auth/googlenow"};
}
GURL GetFeedQueryURL(feedwire::FeedQuery::RequestReason reason) {
// Add URLs for Bling when it is supported.
switch (reason) {
case feedwire::FeedQuery::SCHEDULED_REFRESH:
case feedwire::FeedQuery::IN_PLACE_UPDATE:
return GURL(
"https://www.google.com/httpservice/noretry/TrellisClankService/"
"FeedQuery");
case feedwire::FeedQuery::NEXT_PAGE_SCROLL:
return GURL(
"https://www.google.com/httpservice/retry/TrellisClankService/"
"NextPageQuery");
case feedwire::FeedQuery::MANUAL_REFRESH:
return GURL(
"https://www.google.com/httpservice/retry/TrellisClankService/"
"FeedQuery");
default:
return GURL();
}
}
GURL GetUrlWithoutQuery(const GURL& url) {
GURL::Replacements replacements;
replacements.ClearQuery();
return url.ReplaceComponents(replacements);
}
using RawResponse = FeedNetworkImpl::RawResponse;
} // namespace
struct FeedNetworkImpl::RawResponse {
// HTTP response body.
std::string response_bytes;
NetworkResponseInfo response_info;
};
namespace {
template <typename RESULT, NetworkRequestType REQUEST_TYPE>
void ParseAndForwardResponse(base::OnceCallback<void(RESULT)> result_callback,
RawResponse raw_response) {
MetricsReporter::NetworkRequestComplete(
REQUEST_TYPE, raw_response.response_info.status_code);
RESULT result;
result.response_info = raw_response.response_info;
if (result.response_info.status_code == 200) {
auto response_message = std::make_unique<typename decltype(
result.response_body)::element_type>();
::google::protobuf::io::CodedInputStream input_stream(
reinterpret_cast<const uint8_t*>(raw_response.response_bytes.data()),
raw_response.response_bytes.size());
// The first few bytes of the body are a varint containing the size of the
// message. We need to skip over them.
int message_size;
input_stream.ReadVarintSizeAsInt(&message_size);
if (response_message->ParseFromCodedStream(&input_stream)) {
result.response_body = std::move(response_message);
}
}
std::move(result_callback).Run(std::move(result));
}
void AddMothershipPayloadQueryParams(const std::string& payload,
const std::string& language_tag,
GURL& url) {
url = net::AppendQueryParameter(url, "reqpld", payload);
url = net::AppendQueryParameter(url, "fmt", "bin");
if (!language_tag.empty())
url = net::AppendQueryParameter(url, "hl", language_tag);
}
// Compresses and attaches |request_body| for upload if it's not empty.
// Returns the compressed size of the request.
int PopulateRequestBody(const std::string& request_body,
network::SimpleURLLoader* loader) {
if (request_body.empty())
return 0;
std::string compressed_request_body;
compression::GzipCompress(request_body, &compressed_request_body);
loader->AttachStringForUpload(compressed_request_body, kApplicationXProtobuf);
return compressed_request_body.size();
}
} // namespace
// Each NetworkFetch instance represents a single "logical" fetch that ends by
// calling the associated callback. Network fetches will actually attempt two
// fetches if there is a signed in user; the first to retrieve an access token,
// and the second to the specified url.
class FeedNetworkImpl::NetworkFetch {
public:
NetworkFetch(const GURL& url,
const std::string& request_type,
std::string request_body,
signin::IdentityManager* identity_manager,
network::SharedURLLoaderFactory* loader_factory,
const std::string& api_key,
const base::TickClock* tick_clock,
PrefService* pref_service)
: url_(url),
request_type_(request_type),
request_body_(std::move(request_body)),
identity_manager_(identity_manager),
loader_factory_(loader_factory),
api_key_(api_key),
tick_clock_(tick_clock),
entire_send_start_ticks_(tick_clock_->NowTicks()),
pref_service_(pref_service) {
// Apply the host override (from snippets-internals).
std::string host_override =
pref_service_->GetString(feed::prefs::kHostOverrideHost);
if (!host_override.empty()) {
GURL override_host_url(host_override);
if (override_host_url.is_valid()) {
GURL::Replacements replacements;
replacements.SetSchemeStr(override_host_url.scheme_piece());
replacements.SetHostStr(override_host_url.host_piece());
replacements.SetPortStr(override_host_url.port_piece());
url_ = url_.ReplaceComponents(replacements);
host_overridden_ = true;
}
}
}
~NetworkFetch() = default;
NetworkFetch(const NetworkFetch&) = delete;
NetworkFetch& operator=(const NetworkFetch&) = delete;
void Start(base::OnceCallback<void(RawResponse)> done_callback) {
done_callback_ = std::move(done_callback);
if (!identity_manager_->HasPrimaryAccount()) {
StartLoader();
return;
}
StartAccessTokenFetch();
}
private:
void StartAccessTokenFetch() {
// It's safe to pass base::Unretained(this) since deleting the token fetcher
// will prevent the callback from being completed.
token_fetcher_ = std::make_unique<signin::PrimaryAccountAccessTokenFetcher>(
"feed", identity_manager_, GetAuthScopes(),
base::BindOnce(&NetworkFetch::AccessTokenFetchFinished,
base::Unretained(this), tick_clock_->NowTicks()),
signin::PrimaryAccountAccessTokenFetcher::Mode::kWaitUntilAvailable);
}
void AccessTokenFetchFinished(base::TimeTicks token_start_ticks,
GoogleServiceAuthError error,
signin::AccessTokenInfo access_token_info) {
UMA_HISTOGRAM_ENUMERATION(
"ContentSuggestions.Feed.Network.TokenFetchStatus", error.state(),
GoogleServiceAuthError::NUM_STATES);
base::TimeDelta token_duration =
tick_clock_->NowTicks() - token_start_ticks;
UMA_HISTOGRAM_MEDIUM_TIMES("ContentSuggestions.Feed.Network.TokenDuration",
token_duration);
access_token_ = access_token_info.token;
StartLoader();
}
void StartLoader() {
loader_only_start_ticks_ = tick_clock_->NowTicks();
simple_loader_ = MakeLoader();
simple_loader_->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
loader_factory_, base::BindOnce(&NetworkFetch::OnSimpleLoaderComplete,
base::Unretained(this)));
}
std::unique_ptr<network::SimpleURLLoader> MakeLoader() {
// TODO(pnoland): Add data use measurement once it's supported for simple
// url loader.
net::NetworkTrafficAnnotationTag traffic_annotation =
net::DefineNetworkTrafficAnnotation("interest_feedv2_send", R"(
semantics {
sender: "Feed Library"
description: "Chrome can show content suggestions (e.g. articles) "
"in the form of a feed. For signed-in users, these may be "
"personalized based on interest signals in the user's account."
trigger: "Triggered periodically in the background, or upon "
"explicit user request."
data: "The locale of the device and data describing the suggested "
"content that the user interacted with. For signed-in users "
"the request is authenticated. "
destination: GOOGLE_OWNED_SERVICE
}
policy {
cookies_allowed: YES
cookies_store: "user"
setting: "This can be disabled from the New Tab Page by collapsing "
"the articles section."
chrome_policy {
NTPContentSuggestionsEnabled {
policy_options {mode: MANDATORY}
NTPContentSuggestionsEnabled: false
}
}
})");
GURL url(url_);
if (access_token_.empty() && !api_key_.empty())
url = net::AppendQueryParameter(url_, "key", api_key_);
auto resource_request = std::make_unique<network::ResourceRequest>();
resource_request->url = url;
resource_request->load_flags = net::LOAD_BYPASS_CACHE;
resource_request->credentials_mode = network::mojom::CredentialsMode::kOmit;
resource_request->method = request_type_;
// Include credentials ONLY if the user has overridden the feed host through
// the internals page. This allows for some authentication workflows we need
// for testing.
if (host_overridden_) {
resource_request->credentials_mode =
network::mojom::CredentialsMode::kInclude;
resource_request->site_for_cookies = net::SiteForCookies::FromUrl(url);
}
SetRequestHeaders(!request_body_.empty(), *resource_request);
DVLOG(1) << "Feed Request url=" << url;
DVLOG(1) << "Feed Request headers=" << resource_request->headers.ToString();
auto simple_loader = network::SimpleURLLoader::Create(
std::move(resource_request), traffic_annotation);
simple_loader->SetAllowHttpErrorResults(true);
simple_loader->SetTimeoutDuration(kNetworkTimeout);
const int compressed_size =
PopulateRequestBody(request_body_, simple_loader.get());
UMA_HISTOGRAM_COUNTS_1M(
"ContentSuggestions.Feed.Network.RequestSizeKB.Compressed",
compressed_size / 1024);
return simple_loader;
}
void SetRequestHeaders(bool has_request_body,
network::ResourceRequest& request) const {
if (has_request_body) {
request.headers.SetHeader(net::HttpRequestHeaders::kContentType,
kApplicationXProtobuf);
request.headers.SetHeader("Content-Encoding", "gzip");
}
variations::SignedIn signed_in_status = variations::SignedIn::kNo;
if (!access_token_.empty()) {
request.headers.SetHeader(net::HttpRequestHeaders::kAuthorization,
"Bearer " + access_token_);
signed_in_status = variations::SignedIn::kYes;
}
// Add X-Client-Data header with experiment IDs from field trials.
variations::AppendVariationsHeader(url_, variations::InIncognito::kNo,
signed_in_status, &request);
}
void OnSimpleLoaderComplete(std::unique_ptr<std::string> response) {
NetworkResponseInfo response_info;
response_info.status_code = simple_loader_->NetError();
response_info.fetch_duration =
tick_clock_->NowTicks() - entire_send_start_ticks_;
response_info.fetch_time = base::Time::Now();
response_info.base_request_url = GetUrlWithoutQuery(url_);
// If overriding the feed host, try to grab the Bless nonce. This is
// strictly informational, and only displayed in snippets-internals.
if (host_overridden_ && simple_loader_->ResponseInfo()) {
size_t iter = 0;
std::string value;
while (simple_loader_->ResponseInfo()->headers->EnumerateHeader(
&iter, "www-authenticate", &value)) {
size_t pos = value.find("nonce=\"");
if (pos != std::string::npos) {
std::string nonce = value.substr(pos + 7, 16);
if (nonce.size() == 16) {
response_info.bless_nonce = nonce;
break;
}
}
}
}
std::string response_body;
if (response) {
response_info.status_code =
simple_loader_->ResponseInfo()->headers->response_code();
response_info.response_body_bytes = response->size();
response_body = std::move(*response);
if (response_info.status_code == net::HTTP_UNAUTHORIZED) {
CoreAccountId account_id = identity_manager_->GetPrimaryAccountId();
if (!account_id.empty()) {
identity_manager_->RemoveAccessTokenFromCache(
account_id, GetAuthScopes(), access_token_);
}
}
}
UMA_HISTOGRAM_MEDIUM_TIMES("ContentSuggestions.Feed.Network.Duration",
response_info.fetch_duration);
base::TimeDelta loader_only_duration =
tick_clock_->NowTicks() - loader_only_start_ticks_;
// This histogram purposefully matches name and bucket size used in
// RemoteSuggestionsFetcherImpl.
UMA_HISTOGRAM_TIMES("NewTabPage.Snippets.FetchTime", loader_only_duration);
// The below is true even if there is a protocol error, so this will
// record response size as long as the request completed.
if (response_info.status_code >= 200) {
UMA_HISTOGRAM_COUNTS_1M("ContentSuggestions.Feed.Network.ResponseSizeKB",
static_cast<int>(response_body.size() / 1024));
}
RawResponse raw_response;
raw_response.response_info = std::move(response_info);
raw_response.response_bytes = std::move(response_body);
std::move(done_callback_).Run(std::move(raw_response));
}
private:
GURL url_;
const std::string request_type_;
std::string access_token_;
const std::string request_body_;
signin::IdentityManager* const identity_manager_;
std::unique_ptr<signin::PrimaryAccountAccessTokenFetcher> token_fetcher_;
std::unique_ptr<network::SimpleURLLoader> simple_loader_;
base::OnceCallback<void(RawResponse)> done_callback_;
network::SharedURLLoaderFactory* loader_factory_;
const std::string api_key_;
const base::TickClock* tick_clock_;
// Set when the NetworkFetch is constructed, before token and article fetch.
const base::TimeTicks entire_send_start_ticks_;
// Should be set right before the article fetch, and after the token fetch if
// there is one.
base::TimeTicks loader_only_start_ticks_;
PrefService* pref_service_;
bool host_overridden_ = false;
};
FeedNetworkImpl::FeedNetworkImpl(
Delegate* delegate,
signin::IdentityManager* identity_manager,
const std::string& api_key,
scoped_refptr<network::SharedURLLoaderFactory> loader_factory,
const base::TickClock* tick_clock,
PrefService* pref_service)
: delegate_(delegate),
identity_manager_(identity_manager),
api_key_(api_key),
loader_factory_(loader_factory),
tick_clock_(tick_clock),
pref_service_(pref_service) {}
FeedNetworkImpl::~FeedNetworkImpl() = default;
void FeedNetworkImpl::SendQueryRequest(
const feedwire::Request& request,
base::OnceCallback<void(QueryRequestResult)> callback) {
std::string binary_proto;
request.SerializeToString(&binary_proto);
std::string base64proto;
base::Base64UrlEncode(
binary_proto, base::Base64UrlEncodePolicy::INCLUDE_PADDING, &base64proto);
// TODO(harringtond): Decide how we want to override these URLs for testing.
// Should probably add a command-line flag.
GURL url = GetFeedQueryURL(request.feed_request().feed_query().reason());
if (url.is_empty())
return std::move(callback).Run({});
AddMothershipPayloadQueryParams(base64proto, delegate_->GetLanguageTag(),
url);
Send(url, "GET", /*request_body=*/{},
base::BindOnce(&ParseAndForwardResponse<QueryRequestResult,
NetworkRequestType::kFeedQuery>,
std::move(callback)));
}
void FeedNetworkImpl::SendActionRequest(
const feedwire::FeedActionRequest& request,
base::OnceCallback<void(ActionRequestResult)> callback) {
std::string binary_proto;
request.SerializeToString(&binary_proto);
Send(GURL(kUploadActionUrl), "POST", std::move(binary_proto),
base::BindOnce(
&ParseAndForwardResponse<ActionRequestResult,
NetworkRequestType::kUploadActions>,
std::move(callback)));
}
void FeedNetworkImpl::CancelRequests() {
pending_requests_.clear();
}
void FeedNetworkImpl::Send(const GURL& url,
const std::string& request_type,
std::string request_body,
base::OnceCallback<void(RawResponse)> callback) {
auto fetch = std::make_unique<NetworkFetch>(
url, request_type, std::move(request_body), identity_manager_,
loader_factory_.get(), api_key_, tick_clock_, pref_service_);
NetworkFetch* fetch_unowned = fetch.get();
pending_requests_.emplace(std::move(fetch));
// It's safe to pass base::Unretained(this) since deleting the network fetch
// will prevent the callback from being completed.
fetch_unowned->Start(base::BindOnce(&FeedNetworkImpl::SendComplete,
base::Unretained(this), fetch_unowned,
std::move(callback)));
}
void FeedNetworkImpl::SendComplete(
NetworkFetch* fetch,
base::OnceCallback<void(RawResponse)> callback,
RawResponse raw_response) {
DCHECK_EQ(1UL, pending_requests_.count(fetch));
pending_requests_.erase(fetch);
std::move(callback).Run(std::move(raw_response));
}
} // namespace feed
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
2196b6204d5f18b5e221aa3befa3986ee98d6688 | 1e27e7d97e49e144a87461be71fe9d8f8868d834 | /Competitie_Sportiva/categoriedao.h | 07296a1b8751fb1ecef99a252aa6c3b3848a1665 | [] | no_license | Nionutlucian/DatabaseProject-Sport-Competition | 5c59dff3b4e27957e45bc2119e61aaa0644465a2 | e8b8dc300f26e8f7b6c03022a55f88eee2f92221 | refs/heads/master | 2021-05-09T15:32:23.804978 | 2018-01-30T23:44:06 | 2018-01-30T23:44:06 | 119,094,415 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 321 | h | #ifndef CATEGORIEDAO_H
#define CATEGORIEDAO_H
#include"categorie.h"
#include"mainwindow.h"
#include<QString>
#include<QSqlDatabase>
#include <QSqlQuery>
class categoriedao
{
public:
categoriedao();
bool addCategorie(categorie c);
private:
MainWindow *mw;
QSqlDatabase m_db;
};
#endif // CATEGORIEDAO_H
| [
"nicolescuionutluci@gmail.com"
] | nicolescuionutluci@gmail.com |
6a0e89d40bb2aa92301bd5b2b2b0d92e3a99abea | 07c43092ac87907bdaeecff136b125b4f77182c2 | /third_party/LLVM/lib/Target/X86/X86GenFastISel.inc | 71ac967c8ff88bd815b2b4f2789df38fd10dc8a3 | [
"NCSA",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | ddrmax/swiftshader-ex | 9cd436f2a0e8bc9e0966de148e5a60f974c4b144 | 2d975b5090e778857143c09c21aa24255f41e598 | refs/heads/master | 2021-04-27T15:14:22.444686 | 2018-03-15T10:12:49 | 2018-03-15T10:12:49 | 122,465,205 | 7 | 0 | Apache-2.0 | 2018-03-15T10:12:50 | 2018-02-22T10:40:03 | C++ | UTF-8 | C++ | false | false | 199,572 | inc | //===- TableGen'erated file -------------------------------------*- C++ -*-===//
//
// "Fast" Instruction Selector for the X86 target
//
// Automatically generated file, do not edit!
//
//===----------------------------------------------------------------------===//
// FastEmit Immediate Predicate functions.
static bool Predicate_i64immSExt32(int64_t Imm) {
return Imm == (int32_t)Imm;
}
// FastEmit functions for ISD::ANY_EXTEND.
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MOVZX32rr8, X86::GR32RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MOVZX64rr8, X86::GR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_r(X86::MOVZX64rr16, X86::GR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_ANY_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_ANY_EXTEND_MVT_i8_r(RetVT, Op0, Op0IsKill);
case MVT::i16: return FastEmit_ISD_ANY_EXTEND_MVT_i16_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::BITCAST.
unsigned FastEmit_ISD_BITCAST_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVDI2SSrr, X86::FR32RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::MOVDI2SSrr, X86::FR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_BITCAST_MVT_i64_MVT_f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOV64toSDrr, X86::FR64RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::MOV64toSDrr, X86::FR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_BITCAST_MVT_i64_MVT_x86mmx_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0, Op0IsKill);
if ((Subtarget->hasMMX())) {
return FastEmitInst_r(X86::MMX_MOVD64rrv164, X86::VR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_BITCAST_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::f64: return FastEmit_ISD_BITCAST_MVT_i64_MVT_f64_r(Op0, Op0IsKill);
case MVT::x86mmx: return FastEmit_ISD_BITCAST_MVT_i64_MVT_x86mmx_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_BITCAST_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVSS2DIrr, X86::GR32RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::MOVSS2DIrr, X86::GR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_BITCAST_MVT_f64_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVSDto64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::MOVSDto64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_BITCAST_MVT_f64_MVT_x86mmx_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MMX_MOVFR642Qrr, X86::VR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_BITCAST_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i64: return FastEmit_ISD_BITCAST_MVT_f64_MVT_i64_r(Op0, Op0IsKill);
case MVT::x86mmx: return FastEmit_ISD_BITCAST_MVT_f64_MVT_x86mmx_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_BITCAST_MVT_x86mmx_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
if ((Subtarget->hasMMX())) {
return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_BITCAST_MVT_x86mmx_MVT_f64_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MMX_MOVQ2FR64rr, X86::FR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_BITCAST_MVT_x86mmx_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i64: return FastEmit_ISD_BITCAST_MVT_x86mmx_MVT_i64_r(Op0, Op0IsKill);
case MVT::f64: return FastEmit_ISD_BITCAST_MVT_x86mmx_MVT_f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_BITCAST_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_BITCAST_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_BITCAST_MVT_i64_r(RetVT, Op0, Op0IsKill);
case MVT::f32: return FastEmit_ISD_BITCAST_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return FastEmit_ISD_BITCAST_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::x86mmx: return FastEmit_ISD_BITCAST_MVT_x86mmx_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::BRIND.
unsigned FastEmit_ISD_BRIND_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((!Subtarget->is64Bit())) {
return FastEmitInst_r(X86::JMP32r, X86::GR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_BRIND_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((Subtarget->is64Bit())) {
return FastEmitInst_r(X86::JMP64r, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_BRIND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_BRIND_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_BRIND_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::BSWAP.
unsigned FastEmit_ISD_BSWAP_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_r(X86::BSWAP32r, X86::GR32RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_BSWAP_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_r(X86::BSWAP64r, X86::GR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_BSWAP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_BSWAP_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_BSWAP_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::CTLZ.
unsigned FastEmit_ISD_CTLZ_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
if ((Subtarget->hasLZCNT())) {
return FastEmitInst_r(X86::LZCNT16rr, X86::GR16RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_CTLZ_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasLZCNT())) {
return FastEmitInst_r(X86::LZCNT32rr, X86::GR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_CTLZ_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasLZCNT())) {
return FastEmitInst_r(X86::LZCNT64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_CTLZ_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return FastEmit_ISD_CTLZ_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return FastEmit_ISD_CTLZ_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_CTLZ_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::CTPOP.
unsigned FastEmit_ISD_CTPOP_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
if ((Subtarget->hasPOPCNT())) {
return FastEmitInst_r(X86::POPCNT16rr, X86::GR16RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_CTPOP_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasPOPCNT())) {
return FastEmitInst_r(X86::POPCNT32rr, X86::GR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_CTPOP_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasPOPCNT())) {
return FastEmitInst_r(X86::POPCNT64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_CTPOP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return FastEmit_ISD_CTPOP_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return FastEmit_ISD_CTPOP_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_CTPOP_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::CTTZ.
unsigned FastEmit_ISD_CTTZ_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
if ((Subtarget->hasBMI())) {
return FastEmitInst_r(X86::TZCNT16rr, X86::GR16RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_CTTZ_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasBMI())) {
return FastEmitInst_r(X86::TZCNT32rr, X86::GR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_CTTZ_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasBMI())) {
return FastEmitInst_r(X86::TZCNT64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_CTTZ_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return FastEmit_ISD_CTTZ_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return FastEmit_ISD_CTTZ_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_CTTZ_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FABS.
unsigned FastEmit_ISD_FABS_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasXMM())) {
return FastEmitInst_r(X86::ABS_Fp32, X86::RFP32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FABS_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasXMMInt())) {
return FastEmitInst_r(X86::ABS_Fp64, X86::RFP64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FABS_MVT_f80_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return FastEmitInst_r(X86::ABS_Fp80, X86::RFP80RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_FABS_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FABS_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return FastEmit_ISD_FABS_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::f80: return FastEmit_ISD_FABS_MVT_f80_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FCOS.
unsigned FastEmit_ISD_FCOS_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasXMM())) {
return FastEmitInst_r(X86::COS_Fp32, X86::RFP32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FCOS_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasXMMInt())) {
return FastEmitInst_r(X86::COS_Fp64, X86::RFP64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FCOS_MVT_f80_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return FastEmitInst_r(X86::COS_Fp80, X86::RFP80RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_FCOS_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FCOS_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return FastEmit_ISD_FCOS_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::f80: return FastEmit_ISD_FCOS_MVT_f80_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FNEG.
unsigned FastEmit_ISD_FNEG_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasXMM())) {
return FastEmitInst_r(X86::CHS_Fp32, X86::RFP32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FNEG_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasXMMInt())) {
return FastEmitInst_r(X86::CHS_Fp64, X86::RFP64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FNEG_MVT_f80_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return FastEmitInst_r(X86::CHS_Fp80, X86::RFP80RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_FNEG_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FNEG_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return FastEmit_ISD_FNEG_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::f80: return FastEmit_ISD_FNEG_MVT_f80_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FP_EXTEND.
unsigned FastEmit_ISD_FP_EXTEND_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::CVTSS2SDrr, X86::FR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FP_EXTEND_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
return FastEmitInst_r(X86::VCVTPS2PDYrr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_FP_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FP_EXTEND_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return FastEmit_ISD_FP_EXTEND_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FP_ROUND.
unsigned FastEmit_ISD_FP_ROUND_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::CVTSD2SSrr, X86::FR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FP_ROUND_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
return FastEmitInst_r(X86::VCVTPD2PSYrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_FP_ROUND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f64: return FastEmit_ISD_FP_ROUND_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return FastEmit_ISD_FP_ROUND_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FP_TO_SINT.
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VCVTTSS2SIrr, X86::GR32RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_r(X86::CVTTSS2SIrr, X86::GR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VCVTTSS2SI64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_r(X86::CVTTSS2SI64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VCVTTSD2SIrr, X86::GR32RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::CVTTSD2SIrr, X86::GR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VCVTTSD2SI64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::CVTTSD2SI64rr, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VCVTTPS2DQrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::CVTTPS2DQrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FP_TO_SINT_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VCVTTPS2DQYrr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FP_TO_SINT_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
return FastEmitInst_r(X86::VCVTPD2DQYrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_FP_TO_SINT_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FP_TO_SINT_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return FastEmit_ISD_FP_TO_SINT_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return FastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return FastEmit_ISD_FP_TO_SINT_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return FastEmit_ISD_FP_TO_SINT_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FSIN.
unsigned FastEmit_ISD_FSIN_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasXMM())) {
return FastEmitInst_r(X86::SIN_Fp32, X86::RFP32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSIN_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasXMMInt())) {
return FastEmitInst_r(X86::SIN_Fp64, X86::RFP64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSIN_MVT_f80_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return FastEmitInst_r(X86::SIN_Fp80, X86::RFP80RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_FSIN_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FSIN_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return FastEmit_ISD_FSIN_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::f80: return FastEmit_ISD_FSIN_MVT_f80_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FSQRT.
unsigned FastEmit_ISD_FSQRT_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasXMM())) {
return FastEmitInst_r(X86::SQRT_Fp32, X86::RFP32RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_r(X86::SQRTSSr, X86::FR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSQRT_MVT_f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasXMMInt())) {
return FastEmitInst_r(X86::SQRT_Fp64, X86::RFP64RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::SQRTSDr, X86::FR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSQRT_MVT_f80_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return FastEmitInst_r(X86::SQRT_Fp80, X86::RFP80RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_FSQRT_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VSQRTPSr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_r(X86::SQRTPSr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSQRT_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VSQRTPSYr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSQRT_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VSQRTPDr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::SQRTPDr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSQRT_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VSQRTPDYr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSQRT_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FSQRT_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::f64: return FastEmit_ISD_FSQRT_MVT_f64_r(RetVT, Op0, Op0IsKill);
case MVT::f80: return FastEmit_ISD_FSQRT_MVT_f80_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return FastEmit_ISD_FSQRT_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return FastEmit_ISD_FSQRT_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return FastEmit_ISD_FSQRT_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return FastEmit_ISD_FSQRT_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SCALAR_TO_VECTOR.
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v4i32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVDI2PDIrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::MOVDI2PDIrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_x86mmx_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasMMX())) {
return FastEmitInst_r(X86::MMX_MOVD64rr, X86::VR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4i32: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v4i32_r(Op0, Op0IsKill);
case MVT::x86mmx: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_x86mmx_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOV64toPQIrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::MOV64toPQIrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SIGN_EXTEND.
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MOVSX32rr8, X86::GR32RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MOVSX64rr8, X86::GR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MOVSX32rr16, X86::GR32RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MOVSX64rr16, X86::GR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_r(X86::MOVSX64rr32, X86::GR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_SIGN_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_r(RetVT, Op0, Op0IsKill);
case MVT::i16: return FastEmit_ISD_SIGN_EXTEND_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return FastEmit_ISD_SIGN_EXTEND_MVT_i32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SINT_TO_FP.
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE1())) {
return FastEmitInst_r(X86::CVTSI2SSrr, X86::FR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::CVTSI2SDrr, X86::FR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(Op0, Op0IsKill);
case MVT::f64: return FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE1())) {
return FastEmitInst_r(X86::CVTSI2SS64rr, X86::FR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f64_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::CVTSI2SD64rr, X86::FR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f32_r(Op0, Op0IsKill);
case MVT::f64: return FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_SINT_TO_FP_MVT_v4i32_MVT_v4f32_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::Int_VCVTDQ2PSrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::Int_CVTDQ2PSrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SINT_TO_FP_MVT_v4i32_MVT_v4f64_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::VCVTDQ2PDYrr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::v4f32: return FastEmit_ISD_SINT_TO_FP_MVT_v4i32_MVT_v4f32_r(Op0, Op0IsKill);
case MVT::v4f64: return FastEmit_ISD_SINT_TO_FP_MVT_v4i32_MVT_v4f64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_SINT_TO_FP_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VCVTDQ2PSYrr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SINT_TO_FP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_SINT_TO_FP_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_SINT_TO_FP_MVT_i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4i32: return FastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return FastEmit_ISD_SINT_TO_FP_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::TRUNCATE.
unsigned FastEmit_ISD_TRUNCATE_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
if ((Subtarget->is64Bit())) {
return FastEmitInst_extractsubreg(RetVT, Op0, Op0IsKill, X86::sub_8bit);
}
return 0;
}
unsigned FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i8_r(unsigned Op0, bool Op0IsKill) {
if ((Subtarget->is64Bit())) {
return FastEmitInst_extractsubreg(MVT::i8, Op0, Op0IsKill, X86::sub_8bit);
}
return 0;
}
unsigned FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i16_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_extractsubreg(MVT::i16, Op0, Op0IsKill, X86::sub_16bit);
}
unsigned FastEmit_ISD_TRUNCATE_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i8_r(Op0, Op0IsKill);
case MVT::i16: return FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i16_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i8_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_extractsubreg(MVT::i8, Op0, Op0IsKill, X86::sub_8bit);
}
unsigned FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i16_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_extractsubreg(MVT::i16, Op0, Op0IsKill, X86::sub_16bit);
}
unsigned FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_extractsubreg(MVT::i32, Op0, Op0IsKill, X86::sub_32bit);
}
unsigned FastEmit_ISD_TRUNCATE_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i8_r(Op0, Op0IsKill);
case MVT::i16: return FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i16_r(Op0, Op0IsKill);
case MVT::i32: return FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i32_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_TRUNCATE_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return FastEmit_ISD_TRUNCATE_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return FastEmit_ISD_TRUNCATE_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_TRUNCATE_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::ZERO_EXTEND.
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MOVZX32rr8, X86::GR32RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MOVZX64rr8, X86::GR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i32_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MOVZX32rr16, X86::GR32RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i64_r(unsigned Op0, bool Op0IsKill) {
return FastEmitInst_r(X86::MOVZX64rr16, X86::GR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i16_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (RetVT.SimpleTy) {
case MVT::i32: return FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i32_r(Op0, Op0IsKill);
case MVT::i64: return FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i64_r(Op0, Op0IsKill);
default: return 0;
}
}
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_r(X86::MOVZX64rr32, X86::GR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_ZERO_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_r(RetVT, Op0, Op0IsKill);
case MVT::i16: return FastEmit_ISD_ZERO_EXTEND_MVT_i16_r(RetVT, Op0, Op0IsKill);
case MVT::i32: return FastEmit_ISD_ZERO_EXTEND_MVT_i32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::CALL.
unsigned FastEmit_X86ISD_CALL_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((!Subtarget->is64Bit())) {
return FastEmitInst_r(X86::CALL32r, X86::GR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_CALL_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((Subtarget->is64Bit()) && (!Subtarget->isTargetWin64())) {
return FastEmitInst_r(X86::CALL64r, X86::GR64RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->isTargetWin64())) {
return FastEmitInst_r(X86::WINCALL64r, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_CALL_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return FastEmit_X86ISD_CALL_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_X86ISD_CALL_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::EH_RETURN.
unsigned FastEmit_X86ISD_EH_RETURN_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
return FastEmitInst_r(X86::EH_RETURN, X86::GR32RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_X86ISD_EH_RETURN_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
return FastEmitInst_r(X86::EH_RETURN64, X86::GR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_X86ISD_EH_RETURN_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return FastEmit_X86ISD_EH_RETURN_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_X86ISD_EH_RETURN_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FRCP.
unsigned FastEmit_X86ISD_FRCP_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1())) {
return FastEmitInst_r(X86::RCPSSr, X86::FR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FRCP_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VRCPPSr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_r(X86::RCPPSr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FRCP_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VRCPPSYr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FRCP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_X86ISD_FRCP_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return FastEmit_X86ISD_FRCP_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return FastEmit_X86ISD_FRCP_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FRSQRT.
unsigned FastEmit_X86ISD_FRSQRT_MVT_f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasSSE1())) {
return FastEmitInst_r(X86::RSQRTSSr, X86::FR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FRSQRT_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VRSQRTPSr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_r(X86::RSQRTPSr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FRSQRT_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VRSQRTPSYr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FRSQRT_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_X86ISD_FRSQRT_MVT_f32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return FastEmit_X86ISD_FRSQRT_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return FastEmit_X86ISD_FRSQRT_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MEMBARRIER.
unsigned FastEmit_X86ISD_MEMBARRIER_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((Subtarget->is64Bit())) {
return FastEmitInst_r(X86::Int_MemBarrierNoSSE64, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MEMBARRIER_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i64: return FastEmit_X86ISD_MEMBARRIER_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MMX_MOVD2W.
unsigned FastEmit_X86ISD_MMX_MOVD2W_MVT_x86mmx_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasMMX())) {
return FastEmitInst_r(X86::MMX_MOVD64grr, X86::GR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MMX_MOVD2W_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::x86mmx: return FastEmit_X86ISD_MMX_MOVD2W_MVT_x86mmx_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MMX_MOVW2D.
unsigned FastEmit_X86ISD_MMX_MOVW2D_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::x86mmx)
return 0;
if ((Subtarget->hasMMX())) {
return FastEmitInst_r(X86::MMX_MOVD64rr, X86::VR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MMX_MOVW2D_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return FastEmit_X86ISD_MMX_MOVW2D_MVT_i32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVDDUP.
unsigned FastEmit_X86ISD_MOVDDUP_MVT_v4i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVDDUPYrr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVDDUP_MVT_v4f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVDDUPYrr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVDDUP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i64: return FastEmit_X86ISD_MOVDDUP_MVT_v4i64_r(RetVT, Op0, Op0IsKill);
case MVT::v4f64: return FastEmit_X86ISD_MOVDDUP_MVT_v4f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVDQ2Q.
unsigned FastEmit_X86ISD_MOVDQ2Q_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::x86mmx)
return 0;
return FastEmitInst_r(X86::MMX_MOVDQ2Qrr, X86::VR64RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_X86ISD_MOVDQ2Q_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i64: return FastEmit_X86ISD_MOVDQ2Q_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVQ2DQ.
unsigned FastEmit_X86ISD_MOVQ2DQ_MVT_x86mmx_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
return FastEmitInst_r(X86::MMX_MOVQ2DQrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_X86ISD_MOVQ2DQ_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::x86mmx: return FastEmit_X86ISD_MOVQ2DQ_MVT_x86mmx_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVSHDUP.
unsigned FastEmit_X86ISD_MOVSHDUP_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVSHDUPrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE3())) {
return FastEmitInst_r(X86::MOVSHDUPrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVSHDUP_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVSHDUPYrr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVSHDUP_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVSHDUPrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE3())) {
return FastEmitInst_r(X86::MOVSHDUPrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVSHDUP_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVSHDUPYrr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVSHDUP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_MOVSHDUP_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return FastEmit_X86ISD_MOVSHDUP_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return FastEmit_X86ISD_MOVSHDUP_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return FastEmit_X86ISD_MOVSHDUP_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVSLDUP.
unsigned FastEmit_X86ISD_MOVSLDUP_MVT_v4i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVSLDUPrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE3())) {
return FastEmitInst_r(X86::MOVSLDUPrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVSLDUP_MVT_v8i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVSLDUPYrr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVSLDUP_MVT_v4f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVSLDUPrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE3())) {
return FastEmitInst_r(X86::MOVSLDUPrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVSLDUP_MVT_v8f32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVSLDUPYrr, X86::VR256RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVSLDUP_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_MOVSLDUP_MVT_v4i32_r(RetVT, Op0, Op0IsKill);
case MVT::v8i32: return FastEmit_X86ISD_MOVSLDUP_MVT_v8i32_r(RetVT, Op0, Op0IsKill);
case MVT::v4f32: return FastEmit_X86ISD_MOVSLDUP_MVT_v4f32_r(RetVT, Op0, Op0IsKill);
case MVT::v8f32: return FastEmit_X86ISD_MOVSLDUP_MVT_v8f32_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::SEG_ALLOCA.
unsigned FastEmit_X86ISD_SEG_ALLOCA_MVT_i32_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((!Subtarget->is64Bit())) {
return FastEmitInst_r(X86::SEG_ALLOCA_32, X86::GR32RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_SEG_ALLOCA_MVT_i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->is64Bit())) {
return FastEmitInst_r(X86::SEG_ALLOCA_64, X86::GR64RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_SEG_ALLOCA_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::i32: return FastEmit_X86ISD_SEG_ALLOCA_MVT_i32_r(RetVT, Op0, Op0IsKill);
case MVT::i64: return FastEmit_X86ISD_SEG_ALLOCA_MVT_i64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VZEXT_MOVL.
unsigned FastEmit_X86ISD_VZEXT_MOVL_MVT_v2i64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVZPQILo2PQIrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::MOVZPQILo2PQIrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_VZEXT_MOVL_MVT_v2f64_r(MVT RetVT, unsigned Op0, bool Op0IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_r(X86::VMOVZPQILo2PQIrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_r(X86::MOVZPQILo2PQIrr, X86::VR128RegisterClass, Op0, Op0IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_VZEXT_MOVL_r(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i64: return FastEmit_X86ISD_VZEXT_MOVL_MVT_v2i64_r(RetVT, Op0, Op0IsKill);
case MVT::v2f64: return FastEmit_X86ISD_VZEXT_MOVL_MVT_v2f64_r(RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned FastEmit_r(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill) {
switch (Opcode) {
case ISD::ANY_EXTEND: return FastEmit_ISD_ANY_EXTEND_r(VT, RetVT, Op0, Op0IsKill);
case ISD::BITCAST: return FastEmit_ISD_BITCAST_r(VT, RetVT, Op0, Op0IsKill);
case ISD::BRIND: return FastEmit_ISD_BRIND_r(VT, RetVT, Op0, Op0IsKill);
case ISD::BSWAP: return FastEmit_ISD_BSWAP_r(VT, RetVT, Op0, Op0IsKill);
case ISD::CTLZ: return FastEmit_ISD_CTLZ_r(VT, RetVT, Op0, Op0IsKill);
case ISD::CTPOP: return FastEmit_ISD_CTPOP_r(VT, RetVT, Op0, Op0IsKill);
case ISD::CTTZ: return FastEmit_ISD_CTTZ_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FABS: return FastEmit_ISD_FABS_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FCOS: return FastEmit_ISD_FCOS_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FNEG: return FastEmit_ISD_FNEG_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FP_EXTEND: return FastEmit_ISD_FP_EXTEND_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FP_ROUND: return FastEmit_ISD_FP_ROUND_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FP_TO_SINT: return FastEmit_ISD_FP_TO_SINT_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FSIN: return FastEmit_ISD_FSIN_r(VT, RetVT, Op0, Op0IsKill);
case ISD::FSQRT: return FastEmit_ISD_FSQRT_r(VT, RetVT, Op0, Op0IsKill);
case ISD::SCALAR_TO_VECTOR: return FastEmit_ISD_SCALAR_TO_VECTOR_r(VT, RetVT, Op0, Op0IsKill);
case ISD::SIGN_EXTEND: return FastEmit_ISD_SIGN_EXTEND_r(VT, RetVT, Op0, Op0IsKill);
case ISD::SINT_TO_FP: return FastEmit_ISD_SINT_TO_FP_r(VT, RetVT, Op0, Op0IsKill);
case ISD::TRUNCATE: return FastEmit_ISD_TRUNCATE_r(VT, RetVT, Op0, Op0IsKill);
case ISD::ZERO_EXTEND: return FastEmit_ISD_ZERO_EXTEND_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::CALL: return FastEmit_X86ISD_CALL_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::EH_RETURN: return FastEmit_X86ISD_EH_RETURN_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::FRCP: return FastEmit_X86ISD_FRCP_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::FRSQRT: return FastEmit_X86ISD_FRSQRT_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MEMBARRIER: return FastEmit_X86ISD_MEMBARRIER_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MMX_MOVD2W: return FastEmit_X86ISD_MMX_MOVD2W_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MMX_MOVW2D: return FastEmit_X86ISD_MMX_MOVW2D_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MOVDDUP: return FastEmit_X86ISD_MOVDDUP_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MOVDQ2Q: return FastEmit_X86ISD_MOVDQ2Q_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MOVQ2DQ: return FastEmit_X86ISD_MOVQ2DQ_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MOVSHDUP: return FastEmit_X86ISD_MOVSHDUP_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::MOVSLDUP: return FastEmit_X86ISD_MOVSLDUP_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::SEG_ALLOCA: return FastEmit_X86ISD_SEG_ALLOCA_r(VT, RetVT, Op0, Op0IsKill);
case X86ISD::VZEXT_MOVL: return FastEmit_X86ISD_VZEXT_MOVL_r(VT, RetVT, Op0, Op0IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::ADD.
unsigned FastEmit_ISD_ADD_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_rr(X86::ADD8rr, X86::GR8RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_ADD_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_rr(X86::ADD16rr, X86::GR16RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_ADD_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::ADD32rr, X86::GR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_ADD_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_rr(X86::ADD64rr, X86::GR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_ADD_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPADDBrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PADDBrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_ADD_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPADDWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PADDWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_ADD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPADDDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PADDDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_ADD_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPADDQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PADDQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_ADD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_ADD_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return FastEmit_ISD_ADD_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return FastEmit_ISD_ADD_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return FastEmit_ISD_ADD_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i8: return FastEmit_ISD_ADD_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return FastEmit_ISD_ADD_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return FastEmit_ISD_ADD_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return FastEmit_ISD_ADD_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::AND.
unsigned FastEmit_ISD_AND_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_rr(X86::AND8rr, X86::GR8RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_AND_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_rr(X86::AND16rr, X86::GR16RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_AND_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::AND32rr, X86::GR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_AND_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_rr(X86::AND64rr, X86::GR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_AND_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPANDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::ANDPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PANDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_AND_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VANDPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_AND_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_AND_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return FastEmit_ISD_AND_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return FastEmit_ISD_AND_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return FastEmit_ISD_AND_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return FastEmit_ISD_AND_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return FastEmit_ISD_AND_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FADD.
unsigned FastEmit_ISD_FADD_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasXMM())) {
return FastEmitInst_rr(X86::ADD_Fp32, X86::RFP32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VADDSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::ADDSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FADD_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasXMMInt())) {
return FastEmitInst_rr(X86::ADD_Fp64, X86::RFP64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VADDSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::ADDSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FADD_MVT_f80_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return FastEmitInst_rr(X86::ADD_Fp80, X86::RFP80RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_FADD_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VADDPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::ADDPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FADD_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VADDPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FADD_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VADDPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::ADDPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FADD_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VADDPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FADD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FADD_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return FastEmit_ISD_FADD_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f80: return FastEmit_ISD_FADD_MVT_f80_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return FastEmit_ISD_FADD_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_ISD_FADD_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_ISD_FADD_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_ISD_FADD_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FDIV.
unsigned FastEmit_ISD_FDIV_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasXMM())) {
return FastEmitInst_rr(X86::DIV_Fp32, X86::RFP32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VDIVSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::DIVSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FDIV_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasXMMInt())) {
return FastEmitInst_rr(X86::DIV_Fp64, X86::RFP64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VDIVSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::DIVSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FDIV_MVT_f80_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return FastEmitInst_rr(X86::DIV_Fp80, X86::RFP80RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_FDIV_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VDIVPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::DIVPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FDIV_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VDIVPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FDIV_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VDIVPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::DIVPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FDIV_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VDIVPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FDIV_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FDIV_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return FastEmit_ISD_FDIV_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f80: return FastEmit_ISD_FDIV_MVT_f80_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return FastEmit_ISD_FDIV_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_ISD_FDIV_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_ISD_FDIV_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_ISD_FDIV_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FMUL.
unsigned FastEmit_ISD_FMUL_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasXMM())) {
return FastEmitInst_rr(X86::MUL_Fp32, X86::RFP32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMULSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MULSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FMUL_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasXMMInt())) {
return FastEmitInst_rr(X86::MUL_Fp64, X86::RFP64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMULSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::MULSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FMUL_MVT_f80_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return FastEmitInst_rr(X86::MUL_Fp80, X86::RFP80RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_FMUL_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMULPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MULPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FMUL_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMULPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FMUL_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMULPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::MULPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FMUL_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMULPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FMUL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FMUL_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return FastEmit_ISD_FMUL_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f80: return FastEmit_ISD_FMUL_MVT_f80_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return FastEmit_ISD_FMUL_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_ISD_FMUL_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_ISD_FMUL_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_ISD_FMUL_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::FSUB.
unsigned FastEmit_ISD_FSUB_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((!Subtarget->hasXMM())) {
return FastEmitInst_rr(X86::SUB_Fp32, X86::RFP32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VSUBSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::SUBSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSUB_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((!Subtarget->hasXMMInt())) {
return FastEmitInst_rr(X86::SUB_Fp64, X86::RFP64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VSUBSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::SUBSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSUB_MVT_f80_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f80)
return 0;
return FastEmitInst_rr(X86::SUB_Fp80, X86::RFP80RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_FSUB_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VSUBPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::SUBPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSUB_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VSUBPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSUB_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VSUBPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::SUBPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSUB_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VSUBPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_FSUB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_ISD_FSUB_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return FastEmit_ISD_FSUB_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f80: return FastEmit_ISD_FSUB_MVT_f80_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return FastEmit_ISD_FSUB_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_ISD_FSUB_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_ISD_FSUB_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_ISD_FSUB_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::MUL.
unsigned FastEmit_ISD_MUL_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), X86::AL).addReg(Op0);
return FastEmitInst_r(X86::MUL8r, X86::GR8RegisterClass, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_MUL_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_rr(X86::IMUL16rr, X86::GR16RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_MUL_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::IMUL32rr, X86::GR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_MUL_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_rr(X86::IMUL64rr, X86::GR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_MUL_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPMULLWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PMULLWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_MUL_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPMULLDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41())) {
return FastEmitInst_rr(X86::PMULLDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_MUL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_MUL_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return FastEmit_ISD_MUL_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return FastEmit_ISD_MUL_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return FastEmit_ISD_MUL_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return FastEmit_ISD_MUL_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return FastEmit_ISD_MUL_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::OR.
unsigned FastEmit_ISD_OR_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_rr(X86::OR8rr, X86::GR8RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_OR_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_rr(X86::OR16rr, X86::GR16RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_OR_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::OR32rr, X86::GR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_OR_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_rr(X86::OR64rr, X86::GR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_OR_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPORrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::ORPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PORrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_OR_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VORPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_OR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_OR_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return FastEmit_ISD_OR_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return FastEmit_ISD_OR_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return FastEmit_ISD_OR_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return FastEmit_ISD_OR_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return FastEmit_ISD_OR_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::ROTL.
unsigned FastEmit_ISD_ROTL_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), X86::CL).addReg(Op1);
return FastEmitInst_r(X86::ROL8rCL, X86::GR8RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_ROTL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_ROTL_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::ROTR.
unsigned FastEmit_ISD_ROTR_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), X86::CL).addReg(Op1);
return FastEmitInst_r(X86::ROR8rCL, X86::GR8RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_ROTR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_ROTR_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SHL.
unsigned FastEmit_ISD_SHL_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), X86::CL).addReg(Op1);
return FastEmitInst_r(X86::SHL8rCL, X86::GR8RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_SHL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_SHL_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SRA.
unsigned FastEmit_ISD_SRA_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), X86::CL).addReg(Op1);
return FastEmitInst_r(X86::SAR8rCL, X86::GR8RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_SRA_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_SRA_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SRL.
unsigned FastEmit_ISD_SRL_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DL, TII.get(TargetOpcode::COPY), X86::CL).addReg(Op1);
return FastEmitInst_r(X86::SHR8rCL, X86::GR8RegisterClass, Op0, Op0IsKill);
}
unsigned FastEmit_ISD_SRL_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_SRL_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::SUB.
unsigned FastEmit_ISD_SUB_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_rr(X86::SUB8rr, X86::GR8RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_SUB_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_rr(X86::SUB16rr, X86::GR16RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_SUB_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::SUB32rr, X86::GR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_SUB_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_rr(X86::SUB64rr, X86::GR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_SUB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPSUBBrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PSUBBrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SUB_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPSUBWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PSUBWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SUB_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPSUBDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PSUBDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SUB_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPSUBQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PSUBQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_SUB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_SUB_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return FastEmit_ISD_SUB_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return FastEmit_ISD_SUB_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return FastEmit_ISD_SUB_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v16i8: return FastEmit_ISD_SUB_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8i16: return FastEmit_ISD_SUB_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i32: return FastEmit_ISD_SUB_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return FastEmit_ISD_SUB_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for ISD::XOR.
unsigned FastEmit_ISD_XOR_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_rr(X86::XOR8rr, X86::GR8RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_XOR_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_rr(X86::XOR16rr, X86::GR16RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_XOR_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::XOR32rr, X86::GR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_XOR_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_rr(X86::XOR64rr, X86::GR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_ISD_XOR_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPXORrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::XORPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PXORrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_XOR_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VXORPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_ISD_XOR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_XOR_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return FastEmit_ISD_XOR_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return FastEmit_ISD_XOR_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return FastEmit_ISD_XOR_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return FastEmit_ISD_XOR_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return FastEmit_ISD_XOR_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::ANDNP.
unsigned FastEmit_X86ISD_ANDNP_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPANDNrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::ANDNPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_ANDNP_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VANDNPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_ANDNP_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i64: return FastEmit_X86ISD_ANDNP_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4i64: return FastEmit_X86ISD_ANDNP_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::BT.
unsigned FastEmit_X86ISD_BT_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::BT16rr, X86::GR16RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_X86ISD_BT_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::BT32rr, X86::GR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_X86ISD_BT_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::BT64rr, X86::GR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_X86ISD_BT_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i16: return FastEmit_X86ISD_BT_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return FastEmit_X86ISD_BT_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return FastEmit_X86ISD_BT_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMP.
unsigned FastEmit_X86ISD_CMP_MVT_i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::CMP8rr, X86::GR8RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_X86ISD_CMP_MVT_i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::CMP16rr, X86::GR16RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_X86ISD_CMP_MVT_i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::CMP32rr, X86::GR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_X86ISD_CMP_MVT_i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::CMP64rr, X86::GR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_X86ISD_CMP_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((!Subtarget->hasXMM())) {
return FastEmitInst_rr(X86::UCOM_FpIr32, X86::RFP32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUCOMISSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::UCOMISSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_CMP_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((!Subtarget->hasXMMInt())) {
return FastEmitInst_rr(X86::UCOM_FpIr64, X86::RFP64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUCOMISDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::UCOMISDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_CMP_MVT_f80_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rr(X86::UCOM_FpIr80, X86::RFP80RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
unsigned FastEmit_X86ISD_CMP_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_X86ISD_CMP_MVT_i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i16: return FastEmit_X86ISD_CMP_MVT_i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i32: return FastEmit_X86ISD_CMP_MVT_i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::i64: return FastEmit_X86ISD_CMP_MVT_i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f32: return FastEmit_X86ISD_CMP_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return FastEmit_X86ISD_CMP_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f80: return FastEmit_X86ISD_CMP_MVT_f80_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::COMI.
unsigned FastEmit_X86ISD_COMI_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::Int_VCOMISSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::Int_COMISSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_COMI_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::Int_VCOMISDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::Int_COMISDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_COMI_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return FastEmit_X86ISD_COMI_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_X86ISD_COMI_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FAND.
unsigned FastEmit_X86ISD_FAND_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VFsANDPSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::FsANDPSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FAND_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VFsANDPDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::FsANDPDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FAND_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_X86ISD_FAND_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return FastEmit_X86ISD_FAND_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FHADD.
unsigned FastEmit_X86ISD_FHADD_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VHADDPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE3())) {
return FastEmitInst_rr(X86::HADDPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FHADD_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VHADDPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FHADD_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VHADDPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE3())) {
return FastEmitInst_rr(X86::HADDPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FHADD_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VHADDPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FHADD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return FastEmit_X86ISD_FHADD_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_X86ISD_FHADD_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_X86ISD_FHADD_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_X86ISD_FHADD_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FHSUB.
unsigned FastEmit_X86ISD_FHSUB_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VHSUBPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE3())) {
return FastEmitInst_rr(X86::HSUBPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FHSUB_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VHSUBPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FHSUB_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VHSUBPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE3())) {
return FastEmitInst_rr(X86::HSUBPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FHSUB_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VHSUBPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FHSUB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return FastEmit_X86ISD_FHSUB_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_X86ISD_FHSUB_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_X86ISD_FHSUB_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_X86ISD_FHSUB_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FMAX.
unsigned FastEmit_X86ISD_FMAX_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMAXSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MAXSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMAX_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMAXSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::MAXSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMAX_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMAXPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MAXPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMAX_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMAXPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMAX_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMAXPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::MAXPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMAX_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMAXPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMAX_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_X86ISD_FMAX_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return FastEmit_X86ISD_FMAX_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return FastEmit_X86ISD_FMAX_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_X86ISD_FMAX_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_X86ISD_FMAX_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_X86ISD_FMAX_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FMIN.
unsigned FastEmit_X86ISD_FMIN_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMINSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MINSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMIN_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMINSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::MINSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMIN_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMINPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MINPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMIN_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMINPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMIN_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMINPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::MINPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMIN_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMINPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FMIN_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_X86ISD_FMIN_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return FastEmit_X86ISD_FMIN_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return FastEmit_X86ISD_FMIN_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_X86ISD_FMIN_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_X86ISD_FMIN_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_X86ISD_FMIN_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FOR.
unsigned FastEmit_X86ISD_FOR_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VFsORPSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::FsORPSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FOR_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VFsORPDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::FsORPDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FOR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_X86ISD_FOR_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return FastEmit_X86ISD_FOR_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::FXOR.
unsigned FastEmit_X86ISD_FXOR_MVT_f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VFsXORPSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::FsXORPSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FXOR_MVT_f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VFsXORPDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::FsXORPDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_FXOR_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_X86ISD_FXOR_MVT_f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::f64: return FastEmit_X86ISD_FXOR_MVT_f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVHLPS.
unsigned FastEmit_X86ISD_MOVHLPS_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMOVHLPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MOVHLPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVHLPS_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMOVHLPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MOVHLPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVHLPS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_MOVHLPS_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return FastEmit_X86ISD_MOVHLPS_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::MOVLHPS.
unsigned FastEmit_X86ISD_MOVLHPS_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMOVLHPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MOVLHPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVLHPS_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMOVLHPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MOVLHPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVLHPS_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VMOVLHPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::MOVLHPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_MOVLHPS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_MOVLHPS_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2i64: return FastEmit_X86ISD_MOVLHPS_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return FastEmit_X86ISD_MOVLHPS_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPEQB.
unsigned FastEmit_X86ISD_PCMPEQB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPCMPEQBrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PCMPEQBrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PCMPEQB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return FastEmit_X86ISD_PCMPEQB_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPEQD.
unsigned FastEmit_X86ISD_PCMPEQD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPCMPEQDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PCMPEQDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PCMPEQD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_PCMPEQD_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPEQQ.
unsigned FastEmit_X86ISD_PCMPEQQ_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
return FastEmitInst_rr(X86::PCMPEQQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPCMPEQQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PCMPEQQ_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i64: return FastEmit_X86ISD_PCMPEQQ_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPEQW.
unsigned FastEmit_X86ISD_PCMPEQW_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPCMPEQWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PCMPEQWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PCMPEQW_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return FastEmit_X86ISD_PCMPEQW_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPGTB.
unsigned FastEmit_X86ISD_PCMPGTB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPCMPGTBrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PCMPGTBrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PCMPGTB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return FastEmit_X86ISD_PCMPGTB_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPGTD.
unsigned FastEmit_X86ISD_PCMPGTD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPCMPGTDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PCMPGTDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PCMPGTD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_PCMPGTD_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPGTQ.
unsigned FastEmit_X86ISD_PCMPGTQ_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
return FastEmitInst_rr(X86::PCMPGTQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPCMPGTQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PCMPGTQ_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i64: return FastEmit_X86ISD_PCMPGTQ_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PCMPGTW.
unsigned FastEmit_X86ISD_PCMPGTW_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPCMPGTWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PCMPGTWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PCMPGTW_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return FastEmit_X86ISD_PCMPGTW_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSHUFB.
unsigned FastEmit_X86ISD_PSHUFB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPSHUFBrr128, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSSE3())) {
return FastEmitInst_rr(X86::PSHUFBrr128, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PSHUFB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return FastEmit_X86ISD_PSHUFB_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSIGNB.
unsigned FastEmit_X86ISD_PSIGNB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPSIGNBrr128, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSSE3())) {
return FastEmitInst_rr(X86::PSIGNBrr128, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PSIGNB_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return FastEmit_X86ISD_PSIGNB_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSIGND.
unsigned FastEmit_X86ISD_PSIGND_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPSIGNDrr128, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSSE3())) {
return FastEmitInst_rr(X86::PSIGNDrr128, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PSIGND_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_PSIGND_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSIGNW.
unsigned FastEmit_X86ISD_PSIGNW_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPSIGNWrr128, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSSE3())) {
return FastEmitInst_rr(X86::PSIGNWrr128, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PSIGNW_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return FastEmit_X86ISD_PSIGNW_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PTEST.
unsigned FastEmit_X86ISD_PTEST_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPTESTYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PTEST_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPTESTrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE41())) {
return FastEmitInst_rr(X86::PTESTrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PTEST_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i64: return FastEmit_X86ISD_PTEST_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f32: return FastEmit_X86ISD_PTEST_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PUNPCKHBW.
unsigned FastEmit_X86ISD_PUNPCKHBW_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPUNPCKHBWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PUNPCKHBWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PUNPCKHBW_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return FastEmit_X86ISD_PUNPCKHBW_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PUNPCKHDQ.
unsigned FastEmit_X86ISD_PUNPCKHDQ_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPUNPCKHDQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PUNPCKHDQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PUNPCKHDQ_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_PUNPCKHDQ_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PUNPCKHQDQ.
unsigned FastEmit_X86ISD_PUNPCKHQDQ_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPUNPCKHQDQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PUNPCKHQDQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PUNPCKHQDQ_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i64: return FastEmit_X86ISD_PUNPCKHQDQ_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PUNPCKHWD.
unsigned FastEmit_X86ISD_PUNPCKHWD_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPUNPCKHWDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PUNPCKHWDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PUNPCKHWD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return FastEmit_X86ISD_PUNPCKHWD_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PUNPCKLBW.
unsigned FastEmit_X86ISD_PUNPCKLBW_MVT_v16i8_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v16i8)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPUNPCKLBWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PUNPCKLBWrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PUNPCKLBW_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v16i8: return FastEmit_X86ISD_PUNPCKLBW_MVT_v16i8_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PUNPCKLDQ.
unsigned FastEmit_X86ISD_PUNPCKLDQ_MVT_v4i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPUNPCKLDQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PUNPCKLDQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PUNPCKLDQ_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_PUNPCKLDQ_MVT_v4i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PUNPCKLQDQ.
unsigned FastEmit_X86ISD_PUNPCKLQDQ_MVT_v2i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPUNPCKLQDQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PUNPCKLQDQrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PUNPCKLQDQ_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v2i64: return FastEmit_X86ISD_PUNPCKLQDQ_MVT_v2i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::PUNPCKLWD.
unsigned FastEmit_X86ISD_PUNPCKLWD_MVT_v8i16_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VPUNPCKLWDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::PUNPCKLWDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_PUNPCKLWD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i16: return FastEmit_X86ISD_PUNPCKLWD_MVT_v8i16_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::TESTP.
unsigned FastEmit_X86ISD_TESTP_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VTESTPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_TESTP_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VTESTPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_TESTP_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VTESTPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_TESTP_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VTESTPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_TESTP_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return FastEmit_X86ISD_TESTP_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_X86ISD_TESTP_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_X86ISD_TESTP_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_X86ISD_TESTP_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::UCOMI.
unsigned FastEmit_X86ISD_UCOMI_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::Int_VUCOMISSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::Int_UCOMISSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_UCOMI_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::Int_VUCOMISDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::Int_UCOMISDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_UCOMI_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return FastEmit_X86ISD_UCOMI_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v2f64: return FastEmit_X86ISD_UCOMI_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::UNPCKHPD.
unsigned FastEmit_X86ISD_UNPCKHPD_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKHPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::UNPCKHPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_UNPCKHPD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v2f64: return FastEmit_X86ISD_UNPCKHPD_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::UNPCKHPS.
unsigned FastEmit_X86ISD_UNPCKHPS_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKHPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::UNPCKHPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_UNPCKHPS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return FastEmit_X86ISD_UNPCKHPS_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::UNPCKLPD.
unsigned FastEmit_X86ISD_UNPCKLPD_MVT_v2f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKLPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rr(X86::UNPCKLPDrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_UNPCKLPD_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v2f64: return FastEmit_X86ISD_UNPCKLPD_MVT_v2f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::UNPCKLPS.
unsigned FastEmit_X86ISD_UNPCKLPS_MVT_v4f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKLPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rr(X86::UNPCKLPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_UNPCKLPS_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4f32: return FastEmit_X86ISD_UNPCKLPS_MVT_v4f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VUNPCKHPDY.
unsigned FastEmit_X86ISD_VUNPCKHPDY_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKHPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_VUNPCKHPDY_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKHPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_VUNPCKHPDY_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i64: return FastEmit_X86ISD_VUNPCKHPDY_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_X86ISD_VUNPCKHPDY_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VUNPCKHPSY.
unsigned FastEmit_X86ISD_VUNPCKHPSY_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKHPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_VUNPCKHPSY_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKHPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_VUNPCKHPSY_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i32: return FastEmit_X86ISD_VUNPCKHPSY_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_X86ISD_VUNPCKHPSY_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VUNPCKLPDY.
unsigned FastEmit_X86ISD_VUNPCKLPDY_MVT_v4i64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKLPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_VUNPCKLPDY_MVT_v4f64_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKLPDYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_VUNPCKLPDY_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v4i64: return FastEmit_X86ISD_VUNPCKLPDY_MVT_v4i64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v4f64: return FastEmit_X86ISD_VUNPCKLPDY_MVT_v4f64_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::VUNPCKLPSY.
unsigned FastEmit_X86ISD_VUNPCKLPSY_MVT_v8i32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKLPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_VUNPCKLPSY_MVT_v8f32_rr(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rr(X86::VUNPCKLPSYrr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill);
}
return 0;
}
unsigned FastEmit_X86ISD_VUNPCKLPSY_rr(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (VT.SimpleTy) {
case MVT::v8i32: return FastEmit_X86ISD_VUNPCKLPSY_MVT_v8i32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case MVT::v8f32: return FastEmit_X86ISD_VUNPCKLPSY_MVT_v8f32_rr(RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned FastEmit_rr(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill) {
switch (Opcode) {
case ISD::ADD: return FastEmit_ISD_ADD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::AND: return FastEmit_ISD_AND_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::FADD: return FastEmit_ISD_FADD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::FDIV: return FastEmit_ISD_FDIV_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::FMUL: return FastEmit_ISD_FMUL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::FSUB: return FastEmit_ISD_FSUB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::MUL: return FastEmit_ISD_MUL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::OR: return FastEmit_ISD_OR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::ROTL: return FastEmit_ISD_ROTL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::ROTR: return FastEmit_ISD_ROTR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::SHL: return FastEmit_ISD_SHL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::SRA: return FastEmit_ISD_SRA_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::SRL: return FastEmit_ISD_SRL_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::SUB: return FastEmit_ISD_SUB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case ISD::XOR: return FastEmit_ISD_XOR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::ANDNP: return FastEmit_X86ISD_ANDNP_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::BT: return FastEmit_X86ISD_BT_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::CMP: return FastEmit_X86ISD_CMP_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::COMI: return FastEmit_X86ISD_COMI_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FAND: return FastEmit_X86ISD_FAND_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FHADD: return FastEmit_X86ISD_FHADD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FHSUB: return FastEmit_X86ISD_FHSUB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FMAX: return FastEmit_X86ISD_FMAX_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FMIN: return FastEmit_X86ISD_FMIN_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FOR: return FastEmit_X86ISD_FOR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::FXOR: return FastEmit_X86ISD_FXOR_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::MOVHLPS: return FastEmit_X86ISD_MOVHLPS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::MOVLHPS: return FastEmit_X86ISD_MOVLHPS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPEQB: return FastEmit_X86ISD_PCMPEQB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPEQD: return FastEmit_X86ISD_PCMPEQD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPEQQ: return FastEmit_X86ISD_PCMPEQQ_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPEQW: return FastEmit_X86ISD_PCMPEQW_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPGTB: return FastEmit_X86ISD_PCMPGTB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPGTD: return FastEmit_X86ISD_PCMPGTD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPGTQ: return FastEmit_X86ISD_PCMPGTQ_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PCMPGTW: return FastEmit_X86ISD_PCMPGTW_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PSHUFB: return FastEmit_X86ISD_PSHUFB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PSIGNB: return FastEmit_X86ISD_PSIGNB_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PSIGND: return FastEmit_X86ISD_PSIGND_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PSIGNW: return FastEmit_X86ISD_PSIGNW_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PTEST: return FastEmit_X86ISD_PTEST_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PUNPCKHBW: return FastEmit_X86ISD_PUNPCKHBW_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PUNPCKHDQ: return FastEmit_X86ISD_PUNPCKHDQ_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PUNPCKHQDQ: return FastEmit_X86ISD_PUNPCKHQDQ_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PUNPCKHWD: return FastEmit_X86ISD_PUNPCKHWD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PUNPCKLBW: return FastEmit_X86ISD_PUNPCKLBW_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PUNPCKLDQ: return FastEmit_X86ISD_PUNPCKLDQ_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PUNPCKLQDQ: return FastEmit_X86ISD_PUNPCKLQDQ_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::PUNPCKLWD: return FastEmit_X86ISD_PUNPCKLWD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::TESTP: return FastEmit_X86ISD_TESTP_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::UCOMI: return FastEmit_X86ISD_UCOMI_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::UNPCKHPD: return FastEmit_X86ISD_UNPCKHPD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::UNPCKHPS: return FastEmit_X86ISD_UNPCKHPS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::UNPCKLPD: return FastEmit_X86ISD_UNPCKLPD_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::UNPCKLPS: return FastEmit_X86ISD_UNPCKLPS_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::VUNPCKHPDY: return FastEmit_X86ISD_VUNPCKHPDY_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::VUNPCKHPSY: return FastEmit_X86ISD_VUNPCKHPSY_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::VUNPCKLPDY: return FastEmit_X86ISD_VUNPCKLPDY_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
case X86ISD::VUNPCKLPSY: return FastEmit_X86ISD_VUNPCKLPSY_rr(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMPPD.
unsigned FastEmit_X86ISD_CMPPD_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VCMPPDrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rri(X86::CMPPDrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_CMPPD_MVT_v4f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VCMPPDYrri, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_CMPPD_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v2f64: return FastEmit_X86ISD_CMPPD_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f64: return FastEmit_X86ISD_CMPPD_MVT_v4f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMPPS.
unsigned FastEmit_X86ISD_CMPPS_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VCMPPSrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rri(X86::CMPPSrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_CMPPS_MVT_v8f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VCMPPSYrri, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_CMPPS_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4f32: return FastEmit_X86ISD_CMPPS_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f32: return FastEmit_X86ISD_CMPPS_MVT_v8f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::FSETCCsd.
unsigned FastEmit_X86ISD_FSETCCsd_MVT_f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VCMPSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rri(X86::CMPSDrr, X86::FR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_FSETCCsd_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::f64: return FastEmit_X86ISD_FSETCCsd_MVT_f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::FSETCCss.
unsigned FastEmit_X86ISD_FSETCCss_MVT_f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VCMPSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rri(X86::CMPSSrr, X86::FR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_FSETCCss_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::f32: return FastEmit_X86ISD_FSETCCss_MVT_f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::INSERTPS.
unsigned FastEmit_X86ISD_INSERTPS_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VINSERTPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasSSE41())) {
return FastEmitInst_rri(X86::INSERTPSrr, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_INSERTPS_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4f32: return FastEmit_X86ISD_INSERTPS_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::SHLD.
unsigned FastEmit_X86ISD_SHLD_MVT_i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_rri(X86::SHLD16rri8, X86::GR16RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_SHLD_MVT_i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rri(X86::SHLD32rri8, X86::GR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_SHLD_MVT_i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_rri(X86::SHLD64rri8, X86::GR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_SHLD_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::i16: return FastEmit_X86ISD_SHLD_MVT_i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::i32: return FastEmit_X86ISD_SHLD_MVT_i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::i64: return FastEmit_X86ISD_SHLD_MVT_i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::SHRD.
unsigned FastEmit_X86ISD_SHRD_MVT_i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_rri(X86::SHRD16rri8, X86::GR16RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_SHRD_MVT_i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_rri(X86::SHRD32rri8, X86::GR32RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_SHRD_MVT_i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_rri(X86::SHRD64rri8, X86::GR64RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_SHRD_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::i16: return FastEmit_X86ISD_SHRD_MVT_i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::i32: return FastEmit_X86ISD_SHRD_MVT_i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::i64: return FastEmit_X86ISD_SHRD_MVT_i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::SHUFPD.
unsigned FastEmit_X86ISD_SHUFPD_MVT_v2i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VSHUFPDrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rri(X86::SHUFPDrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_SHUFPD_MVT_v4i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VSHUFPDYrri, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_SHUFPD_MVT_v2f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v2f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VSHUFPDrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_rri(X86::SHUFPDrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_SHUFPD_MVT_v4f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VSHUFPDYrri, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_SHUFPD_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v2i64: return FastEmit_X86ISD_SHUFPD_MVT_v2i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i64: return FastEmit_X86ISD_SHUFPD_MVT_v4i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v2f64: return FastEmit_X86ISD_SHUFPD_MVT_v2f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f64: return FastEmit_X86ISD_SHUFPD_MVT_v4f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::SHUFPS.
unsigned FastEmit_X86ISD_SHUFPS_MVT_v4i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VSHUFPSrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rri(X86::SHUFPSrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_SHUFPS_MVT_v8i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VSHUFPSYrri, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_SHUFPS_MVT_v4f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VSHUFPSrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
if ((Subtarget->hasSSE1())) {
return FastEmitInst_rri(X86::SHUFPSrri, X86::VR128RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_SHUFPS_MVT_v8f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_rri(X86::VSHUFPSYrri, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
return 0;
}
unsigned FastEmit_X86ISD_SHUFPS_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_SHUFPS_MVT_v4i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i32: return FastEmit_X86ISD_SHUFPS_MVT_v8i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f32: return FastEmit_X86ISD_SHUFPS_MVT_v4f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f32: return FastEmit_X86ISD_SHUFPS_MVT_v8f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for X86ISD::VPERM2F128.
unsigned FastEmit_X86ISD_VPERM2F128_MVT_v32i8_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v32i8)
return 0;
return FastEmitInst_rri(X86::VPERM2F128rr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_VPERM2F128_MVT_v16i16_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v16i16)
return 0;
return FastEmitInst_rri(X86::VPERM2F128rr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_VPERM2F128_MVT_v8i32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
return FastEmitInst_rri(X86::VPERM2F128rr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_VPERM2F128_MVT_v4i64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
return FastEmitInst_rri(X86::VPERM2F128rr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_VPERM2F128_MVT_v8f32_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
return FastEmitInst_rri(X86::VPERM2F128rr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_VPERM2F128_MVT_v4f64_rri(MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
return FastEmitInst_rri(X86::VPERM2F128rr, X86::VR256RegisterClass, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
}
unsigned FastEmit_X86ISD_VPERM2F128_rri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::v32i8: return FastEmit_X86ISD_VPERM2F128_MVT_v32i8_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v16i16: return FastEmit_X86ISD_VPERM2F128_MVT_v16i16_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8i32: return FastEmit_X86ISD_VPERM2F128_MVT_v8i32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4i64: return FastEmit_X86ISD_VPERM2F128_MVT_v4i64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v8f32: return FastEmit_X86ISD_VPERM2F128_MVT_v8f32_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case MVT::v4f64: return FastEmit_X86ISD_VPERM2F128_MVT_v4f64_rri(RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned FastEmit_rri(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, unsigned Op1, bool Op1IsKill, uint64_t imm2) {
switch (Opcode) {
case X86ISD::CMPPD: return FastEmit_X86ISD_CMPPD_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::CMPPS: return FastEmit_X86ISD_CMPPS_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::FSETCCsd: return FastEmit_X86ISD_FSETCCsd_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::FSETCCss: return FastEmit_X86ISD_FSETCCss_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::INSERTPS: return FastEmit_X86ISD_INSERTPS_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::SHLD: return FastEmit_X86ISD_SHLD_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::SHRD: return FastEmit_X86ISD_SHRD_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::SHUFPD: return FastEmit_X86ISD_SHUFPD_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::SHUFPS: return FastEmit_X86ISD_SHUFPS_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
case X86ISD::VPERM2F128: return FastEmit_X86ISD_VPERM2F128_rri(VT, RetVT, Op0, Op0IsKill, Op1, Op1IsKill, imm2);
default: return 0;
}
}
// FastEmit functions for ISD::ADD.
unsigned FastEmit_ISD_ADD_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_ri(X86::ADD8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ADD_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::ADD16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ADD_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::ADD32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ADD_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_ADD_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_ISD_ADD_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_ADD_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::AND.
unsigned FastEmit_ISD_AND_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_ri(X86::AND8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_AND_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::AND16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_AND_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::AND32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_AND_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_AND_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_ISD_AND_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_AND_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::EXTRACT_VECTOR_ELT.
unsigned FastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v4i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_ri(X86::VPEXTRDrr, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE41())) {
return FastEmitInst_ri(X86::PEXTRDrr, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned FastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v2i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_ri(X86::VPEXTRQrr, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE41())) {
return FastEmitInst_ri(X86::PEXTRQrr, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned FastEmit_ISD_EXTRACT_VECTOR_ELT_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v4i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v2i64: return FastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v2i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::MUL.
unsigned FastEmit_ISD_MUL_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::IMUL16rri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_MUL_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::IMUL32rri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_MUL_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i16: return FastEmit_ISD_MUL_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_MUL_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::OR.
unsigned FastEmit_ISD_OR_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_ri(X86::OR8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_OR_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::OR16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_OR_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::OR32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_OR_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_OR_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_ISD_OR_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_OR_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::ROTL.
unsigned FastEmit_ISD_ROTL_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_ri(X86::ROL8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ROTL_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::ROL16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ROTL_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::ROL32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ROTL_MVT_i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::ROL64ri, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ROTL_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_ROTL_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_ISD_ROTL_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_ROTL_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i64: return FastEmit_ISD_ROTL_MVT_i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::ROTR.
unsigned FastEmit_ISD_ROTR_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_ri(X86::ROR8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ROTR_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::ROR16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ROTR_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::ROR32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ROTR_MVT_i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::ROR64ri, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ROTR_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_ROTR_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_ISD_ROTR_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_ROTR_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i64: return FastEmit_ISD_ROTR_MVT_i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SHL.
unsigned FastEmit_ISD_SHL_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_ri(X86::SHL8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SHL_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::SHL16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SHL_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::SHL32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SHL_MVT_i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::SHL64ri, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SHL_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_SHL_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_ISD_SHL_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_SHL_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i64: return FastEmit_ISD_SHL_MVT_i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SRA.
unsigned FastEmit_ISD_SRA_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_ri(X86::SAR8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SRA_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::SAR16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SRA_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::SAR32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SRA_MVT_i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::SAR64ri, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SRA_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_SRA_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_ISD_SRA_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_SRA_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i64: return FastEmit_ISD_SRA_MVT_i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SRL.
unsigned FastEmit_ISD_SRL_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_ri(X86::SHR8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SRL_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::SHR16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SRL_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::SHR32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SRL_MVT_i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::SHR64ri, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SRL_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_SRL_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_ISD_SRL_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_SRL_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i64: return FastEmit_ISD_SRL_MVT_i64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SUB.
unsigned FastEmit_ISD_SUB_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_ri(X86::SUB8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SUB_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::SUB16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SUB_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::SUB32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SUB_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_SUB_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_ISD_SUB_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_SUB_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::XOR.
unsigned FastEmit_ISD_XOR_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_ri(X86::XOR8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_XOR_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_ri(X86::XOR16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_XOR_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::XOR32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_XOR_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_XOR_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_ISD_XOR_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_ISD_XOR_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMP.
unsigned FastEmit_X86ISD_CMP_MVT_i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::CMP8ri, X86::GR8RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_X86ISD_CMP_MVT_i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::CMP16ri, X86::GR16RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_X86ISD_CMP_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::CMP32ri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_X86ISD_CMP_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_X86ISD_CMP_MVT_i8_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i16: return FastEmit_X86ISD_CMP_MVT_i16_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::i32: return FastEmit_X86ISD_CMP_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::PEXTRB.
unsigned FastEmit_X86ISD_PEXTRB_MVT_v16i8_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_ri(X86::VPEXTRBrr, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE41())) {
return FastEmitInst_ri(X86::PEXTRBrr, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned FastEmit_X86ISD_PEXTRB_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v16i8: return FastEmit_X86ISD_PEXTRB_MVT_v16i8_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::PEXTRW.
unsigned FastEmit_X86ISD_PEXTRW_MVT_v8i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_ri(X86::VPEXTRWri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_ri(X86::PEXTRWri, X86::GR32RegisterClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned FastEmit_X86ISD_PEXTRW_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i16: return FastEmit_X86ISD_PEXTRW_MVT_v8i16_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSHUFD.
unsigned FastEmit_X86ISD_PSHUFD_MVT_v4i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_ri(X86::VPSHUFDri, X86::VR128RegisterClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_ri(X86::PSHUFDri, X86::VR128RegisterClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned FastEmit_X86ISD_PSHUFD_MVT_v4f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4f32)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_ri(X86::VPSHUFDri, X86::VR128RegisterClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_ri(X86::PSHUFDri, X86::VR128RegisterClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned FastEmit_X86ISD_PSHUFD_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v4i32: return FastEmit_X86ISD_PSHUFD_MVT_v4i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4f32: return FastEmit_X86ISD_PSHUFD_MVT_v4f32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSHUFHW.
unsigned FastEmit_X86ISD_PSHUFHW_MVT_v8i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_ri(X86::VPSHUFHWri, X86::VR128RegisterClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_ri(X86::PSHUFHWri, X86::VR128RegisterClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned FastEmit_X86ISD_PSHUFHW_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i16: return FastEmit_X86ISD_PSHUFHW_MVT_v8i16_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::PSHUFLW.
unsigned FastEmit_X86ISD_PSHUFLW_MVT_v8i16_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i16)
return 0;
if ((Subtarget->hasAVX())) {
return FastEmitInst_ri(X86::VPSHUFLWri, X86::VR128RegisterClass, Op0, Op0IsKill, imm1);
}
if ((Subtarget->hasSSE2())) {
return FastEmitInst_ri(X86::PSHUFLWri, X86::VR128RegisterClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned FastEmit_X86ISD_PSHUFLW_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i16: return FastEmit_X86ISD_PSHUFLW_MVT_v8i16_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::TC_RETURN.
unsigned FastEmit_X86ISD_TC_RETURN_MVT_i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
if ((!Subtarget->is64Bit())) {
return FastEmitInst_ri(X86::TCRETURNri, X86::GR32_TCRegisterClass, Op0, Op0IsKill, imm1);
}
return 0;
}
unsigned FastEmit_X86ISD_TC_RETURN_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i32: return FastEmit_X86ISD_TC_RETURN_MVT_i32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VPERMILPDY.
unsigned FastEmit_X86ISD_VPERMILPDY_MVT_v4i64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4i64)
return 0;
return FastEmitInst_ri(X86::VPERMILPDYri, X86::VR256RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_X86ISD_VPERMILPDY_MVT_v4f64_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v4f64)
return 0;
return FastEmitInst_ri(X86::VPERMILPDYri, X86::VR256RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_X86ISD_VPERMILPDY_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v4i64: return FastEmit_X86ISD_VPERMILPDY_MVT_v4i64_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v4f64: return FastEmit_X86ISD_VPERMILPDY_MVT_v4f64_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VPERMILPSY.
unsigned FastEmit_X86ISD_VPERMILPSY_MVT_v8i32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8i32)
return 0;
return FastEmitInst_ri(X86::VPERMILPSYri, X86::VR256RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_X86ISD_VPERMILPSY_MVT_v8f32_ri(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::v8f32)
return 0;
return FastEmitInst_ri(X86::VPERMILPSYri, X86::VR256RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_X86ISD_VPERMILPSY_ri(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::v8i32: return FastEmit_X86ISD_VPERMILPSY_MVT_v8i32_ri(RetVT, Op0, Op0IsKill, imm1);
case MVT::v8f32: return FastEmit_X86ISD_VPERMILPSY_MVT_v8f32_ri(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned FastEmit_ri(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (VT == MVT::i64 && Predicate_i64immSExt32(imm1))
if (unsigned Reg = FastEmit_ri_Predicate_i64immSExt32(VT, RetVT, Opcode, Op0, Op0IsKill, imm1))
return Reg;
switch (Opcode) {
case ISD::ADD: return FastEmit_ISD_ADD_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::AND: return FastEmit_ISD_AND_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::EXTRACT_VECTOR_ELT: return FastEmit_ISD_EXTRACT_VECTOR_ELT_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::MUL: return FastEmit_ISD_MUL_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::OR: return FastEmit_ISD_OR_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::ROTL: return FastEmit_ISD_ROTL_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::ROTR: return FastEmit_ISD_ROTR_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SHL: return FastEmit_ISD_SHL_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SRA: return FastEmit_ISD_SRA_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SRL: return FastEmit_ISD_SRL_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SUB: return FastEmit_ISD_SUB_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::XOR: return FastEmit_ISD_XOR_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::CMP: return FastEmit_X86ISD_CMP_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::PEXTRB: return FastEmit_X86ISD_PEXTRB_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::PEXTRW: return FastEmit_X86ISD_PEXTRW_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::PSHUFD: return FastEmit_X86ISD_PSHUFD_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::PSHUFHW: return FastEmit_X86ISD_PSHUFHW_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::PSHUFLW: return FastEmit_X86ISD_PSHUFLW_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::TC_RETURN: return FastEmit_X86ISD_TC_RETURN_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::VPERMILPDY: return FastEmit_X86ISD_VPERMILPDY_ri(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::VPERMILPSY: return FastEmit_X86ISD_VPERMILPSY_ri(VT, RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::VASTART_SAVE_XMM_REGS.
unsigned FastEmit_X86ISD_VASTART_SAVE_XMM_REGS_MVT_i8_rii(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1, uint64_t imm2) {
if (RetVT.SimpleTy != MVT::isVoid)
return 0;
return FastEmitInst_rii(X86::VASTART_SAVE_XMM_REGS, X86::GR8RegisterClass, Op0, Op0IsKill, imm1, imm2);
}
unsigned FastEmit_X86ISD_VASTART_SAVE_XMM_REGS_rii(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1, uint64_t imm2) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_X86ISD_VASTART_SAVE_XMM_REGS_MVT_i8_rii(RetVT, Op0, Op0IsKill, imm1, imm2);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned FastEmit_rii(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, uint64_t imm1, uint64_t imm2) {
switch (Opcode) {
case X86ISD::VASTART_SAVE_XMM_REGS: return FastEmit_X86ISD_VASTART_SAVE_XMM_REGS_rii(VT, RetVT, Op0, Op0IsKill, imm1, imm2);
default: return 0;
}
}
// FastEmit functions for ISD::ADD.
unsigned FastEmit_ISD_ADD_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::ADD64ri32, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_ADD_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return FastEmit_ISD_ADD_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::AND.
unsigned FastEmit_ISD_AND_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::AND64ri32, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_AND_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return FastEmit_ISD_AND_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::MUL.
unsigned FastEmit_ISD_MUL_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::IMUL64rri32, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_MUL_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return FastEmit_ISD_MUL_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::OR.
unsigned FastEmit_ISD_OR_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::OR64ri32, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_OR_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return FastEmit_ISD_OR_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::SUB.
unsigned FastEmit_ISD_SUB_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::SUB64ri32, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_SUB_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return FastEmit_ISD_SUB_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::XOR.
unsigned FastEmit_ISD_XOR_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_ri(X86::XOR64ri32, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_ISD_XOR_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return FastEmit_ISD_XOR_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for X86ISD::CMP.
unsigned FastEmit_X86ISD_CMP_MVT_i64_ri_Predicate_i64immSExt32(MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_ri(X86::CMP64ri32, X86::GR64RegisterClass, Op0, Op0IsKill, imm1);
}
unsigned FastEmit_X86ISD_CMP_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (VT.SimpleTy) {
case MVT::i64: return FastEmit_X86ISD_CMP_MVT_i64_ri_Predicate_i64immSExt32(RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned FastEmit_ri_Predicate_i64immSExt32(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, bool Op0IsKill, uint64_t imm1) {
switch (Opcode) {
case ISD::ADD: return FastEmit_ISD_ADD_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::AND: return FastEmit_ISD_AND_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::MUL: return FastEmit_ISD_MUL_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::OR: return FastEmit_ISD_OR_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::SUB: return FastEmit_ISD_SUB_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case ISD::XOR: return FastEmit_ISD_XOR_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
case X86ISD::CMP: return FastEmit_X86ISD_CMP_ri_Predicate_i64immSExt32(VT, RetVT, Op0, Op0IsKill, imm1);
default: return 0;
}
}
// FastEmit functions for ISD::Constant.
unsigned FastEmit_ISD_Constant_MVT_i8_i(MVT RetVT, uint64_t imm0) {
if (RetVT.SimpleTy != MVT::i8)
return 0;
return FastEmitInst_i(X86::MOV8ri, X86::GR8RegisterClass, imm0);
}
unsigned FastEmit_ISD_Constant_MVT_i16_i(MVT RetVT, uint64_t imm0) {
if (RetVT.SimpleTy != MVT::i16)
return 0;
return FastEmitInst_i(X86::MOV16ri, X86::GR16RegisterClass, imm0);
}
unsigned FastEmit_ISD_Constant_MVT_i32_i(MVT RetVT, uint64_t imm0) {
if (RetVT.SimpleTy != MVT::i32)
return 0;
return FastEmitInst_i(X86::MOV32ri, X86::GR32RegisterClass, imm0);
}
unsigned FastEmit_ISD_Constant_MVT_i64_i(MVT RetVT, uint64_t imm0) {
if (RetVT.SimpleTy != MVT::i64)
return 0;
return FastEmitInst_i(X86::MOV64ri, X86::GR64RegisterClass, imm0);
}
unsigned FastEmit_ISD_Constant_i(MVT VT, MVT RetVT, uint64_t imm0) {
switch (VT.SimpleTy) {
case MVT::i8: return FastEmit_ISD_Constant_MVT_i8_i(RetVT, imm0);
case MVT::i16: return FastEmit_ISD_Constant_MVT_i16_i(RetVT, imm0);
case MVT::i32: return FastEmit_ISD_Constant_MVT_i32_i(RetVT, imm0);
case MVT::i64: return FastEmit_ISD_Constant_MVT_i64_i(RetVT, imm0);
default: return 0;
}
}
// Top-level FastEmit function.
unsigned FastEmit_i(MVT VT, MVT RetVT, unsigned Opcode, uint64_t imm0) {
switch (Opcode) {
case ISD::Constant: return FastEmit_ISD_Constant_i(VT, RetVT, imm0);
default: return 0;
}
}
| [
"capn@google.com"
] | capn@google.com |
d3ed63431b13e7760723b862f4d1ab66bba53e50 | ca9d59c1c57ae2807fe79093c5e6aec3d6d0b00b | /workbench/src/imagenet_perf.cpp | 1971b019da85a60ba53183375b43340301c15616 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | BeatWolf/dll | 39eac00d9abdb6287c462eea15efb8398b428f03 | ae7061e1593228b9114ab0846220c7bf700288bc | refs/heads/master | 2021-01-07T05:25:57.513380 | 2020-02-19T11:00:22 | 2020-02-19T11:00:22 | 241,591,119 | 1 | 0 | MIT | 2020-02-19T10:16:13 | 2020-02-19T10:16:13 | null | UTF-8 | C++ | false | false | 5,165 | cpp | //=======================================================================
// Copyright (c) 2014-2017 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
// http://opensource.org/licenses/MIT)
//=======================================================================
#include <deque>
#define ETL_COUNTERS
#include "dll/neural/conv_layer.hpp"
#include "dll/neural/conv_same_layer.hpp"
#include "dll/neural/dense_layer.hpp"
#include "dll/pooling/mp_layer.hpp"
#include "dll/test.hpp"
#include "dll/dbn.hpp"
#include "mnist/mnist_reader.hpp"
#include "mnist/mnist_utils.hpp"
#include "cifar/cifar10_reader.hpp"
namespace {
void first_ex(){
// First experiment : Conv -> Conv -> Dense -> Dense
// Current training speed on frigg:
// ~100 seconds (mkl, default options)
constexpr size_t N = 4096;
constexpr size_t B = 128;
std::vector<etl::fast_dyn_matrix<float, 3, 254, 254>> training_images;
std::vector<size_t> training_labels;
training_images.reserve(N);
training_labels.reserve(N);
for(size_t i = 0; i < N; ++i){
training_images.emplace_back();
training_labels.push_back(i % 1000);
training_images.back() = etl::normal_generator();
}
auto n = training_images.size();
std::cout << n << " samples to test" << std::endl;
// Clean slate
etl::reset_counters();
dll::reset_timers();
using dbn_t = dll::dbn_desc<
dll::dbn_layers<
dll::conv_layer_desc<3, 254, 254, 10, 3, 3>::layer_t,
dll::mp_2d_layer_desc<10, 252, 252, 2, 2>::layer_t,
dll::conv_layer_desc<10, 126, 126, 10, 3, 3>::layer_t,
dll::mp_2d_layer_desc<10, 124, 124, 2, 2>::layer_t,
dll::conv_layer_desc<10, 62, 62, 10, 3, 3>::layer_t,
dll::mp_2d_layer_desc<10, 60, 60, 2, 2>::layer_t,
dll::conv_layer_desc<10, 30, 30, 10, 3, 3>::layer_t,
dll::mp_2d_layer_desc<10, 28, 28, 2, 2>::layer_t,
dll::conv_layer_desc<10, 14, 14, 10, 3, 3>::layer_t,
dll::mp_2d_layer_desc<10, 12, 12, 2, 2>::layer_t,
dll::dense_layer_desc<10 * 6 * 6, 500>::layer_t,
dll::dense_layer_desc<500, 1000, dll::activation<dll::function::SOFTMAX>>::layer_t>,
dll::updater<dll::updater_type::MOMENTUM>, dll::batch_mode, dll::verbose, dll::big_batch_size<5>, dll::batch_size<B>, dll::trainer<dll::sgd_trainer>>::dbn_t;
auto net = std::make_unique<dbn_t>();
// Train the network for performance sake
net->display();
net->fine_tune(training_images, training_labels, 1);
std::cout << "DLL Timers" << std::endl;
dll::dump_timers_one();
std::cout << "ETL Counters" << std::endl;
etl::dump_counters();
}
void second_ex(){
// Second experiment : Conv -> Conv -> Dense -> Dense
// Current training speed on frigg:
// ~185 seconds (mkl, default options)
constexpr size_t N = 4096;
constexpr size_t B = 128;
std::vector<etl::fast_dyn_matrix<float, 3, 256, 256>> training_images;
std::vector<size_t> training_labels;
training_images.reserve(N);
training_labels.reserve(N);
for(size_t i = 0; i < N; ++i){
training_images.emplace_back();
training_labels.push_back(i % 1000);
training_images.back() = etl::normal_generator();
}
auto n = training_images.size();
std::cout << n << " samples to test" << std::endl;
// Clean slate
etl::reset_counters();
dll::reset_timers();
using dbn_t = dll::dbn_desc<
dll::dbn_layers<
dll::conv_same_desc<3, 256, 256, 16, 3, 3>::layer_t,
dll::mp_2d_layer_desc<16, 256, 256, 2, 2>::layer_t,
dll::conv_same_desc<16, 128, 128, 16, 3, 3>::layer_t,
dll::mp_2d_layer_desc<16, 128, 128, 2, 2>::layer_t,
dll::conv_same_desc<16, 64, 64, 32, 3, 3>::layer_t,
dll::mp_2d_layer_desc<32, 64, 64, 2, 2>::layer_t,
dll::conv_same_desc<32, 32, 32, 32, 3, 3>::layer_t,
dll::mp_2d_layer_desc<32, 32, 32, 2, 2>::layer_t,
dll::conv_same_desc<32, 16, 16, 32, 3, 3>::layer_t,
dll::mp_2d_layer_desc<32, 16, 16, 2, 2>::layer_t,
dll::dense_layer_desc<32 * 8 * 8, 2048>::layer_t,
dll::dense_layer_desc<2048, 1000, dll::activation<dll::function::SOFTMAX>>::layer_t>,
dll::updater<dll::updater_type::MOMENTUM>, dll::verbose, dll::batch_mode, dll::big_batch_size<5>, dll::batch_size<B>, dll::trainer<dll::sgd_trainer>>::dbn_t;
auto net = std::make_unique<dbn_t>();
// Train the network for performance sake
net->display();
net->fine_tune(training_images, training_labels, 1);
std::cout << "DLL Timers" << std::endl;
dll::dump_timers_one();
std::cout << "ETL Counters" << std::endl;
etl::dump_counters();
}
} // end of anonymous namespace
int main(int argc, char* argv []) {
if(argc == 1){
first_ex();
return 0;
}
std::string select(argv[1]);
if(select == "A"){
first_ex();
} else if(select == "B"){
second_ex();
}
return 0;
}
| [
"baptiste.wicht@gmail.com"
] | baptiste.wicht@gmail.com |
66de7540843934d152da04d509f5e85f5d481272 | f92f7594bcabce3e880b3d8d1da10f64cd3b9349 | /net/dns/dns_config_service_linux.cc | 64dc9b73f421031b2c83310fa6a985f1e975db39 | [
"BSD-3-Clause"
] | permissive | adetaylor/chromium | b3250dec67356929ab2480780e2ea09225f230c5 | ee65bed7ef1ef9e88fd1dd0332e26a1ef0f098f1 | refs/heads/main | 2023-03-29T00:48:58.542282 | 2021-04-07T03:39:17 | 2021-04-07T03:39:17 | 355,406,122 | 0 | 0 | BSD-3-Clause | 2021-04-07T03:57:22 | 2021-04-07T03:57:22 | null | UTF-8 | C++ | false | false | 8,397 | cc | // Copyright 2021 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.
#include "net/dns/dns_config_service_linux.h"
#include <netinet/in.h>
#include <resolv.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include "base/bind.h"
#include "base/callback.h"
#include "base/check.h"
#include "base/files/file_path.h"
#include "base/files/file_path_watcher.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/scoped_refptr.h"
#include "base/optional.h"
#include "base/sequence_checker.h"
#include "base/threading/scoped_blocking_call.h"
#include "base/time/time.h"
#include "net/base/ip_endpoint.h"
#include "net/dns/dns_config.h"
#include "net/dns/serial_worker.h"
namespace net {
namespace internal {
namespace {
const base::FilePath::CharType kFilePathHosts[] =
FILE_PATH_LITERAL("/etc/hosts");
#ifndef _PATH_RESCONF // Normally defined in <resolv.h>
#define _PATH_RESCONF "/etc/resolv.conf"
#endif
const base::FilePath::CharType kFilePathConfig[] =
FILE_PATH_LITERAL(_PATH_RESCONF);
class DnsConfigWatcher {
public:
using CallbackType = base::RepeatingCallback<void(bool succeeded)>;
bool Watch(const CallbackType& callback) {
callback_ = callback;
return watcher_.Watch(base::FilePath(kFilePathConfig),
base::FilePathWatcher::Type::kNonRecursive,
base::BindRepeating(&DnsConfigWatcher::OnCallback,
base::Unretained(this)));
}
private:
void OnCallback(const base::FilePath& path, bool error) {
callback_.Run(!error);
}
base::FilePathWatcher watcher_;
CallbackType callback_;
};
base::Optional<DnsConfig> ReadDnsConfig() {
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
base::Optional<DnsConfig> dns_config;
struct __res_state res;
memset(&res, 0, sizeof(res));
if (res_ninit(&res) == 0)
dns_config = ConvertResStateToDnsConfig(res);
res_nclose(&res);
if (!dns_config.has_value())
return dns_config;
// Override |fallback_period| value to match default setting on Windows.
dns_config->fallback_period = kDnsDefaultFallbackPeriod;
return dns_config;
}
} // namespace
class DnsConfigServiceLinux::Watcher : public DnsConfigService::Watcher {
public:
explicit Watcher(DnsConfigServiceLinux& service)
: DnsConfigService::Watcher(service) {}
~Watcher() override = default;
Watcher(const Watcher&) = delete;
Watcher& operator=(const Watcher&) = delete;
bool Watch() override {
CheckOnCorrectSequence();
bool success = true;
if (!config_watcher_.Watch(base::BindRepeating(&Watcher::OnConfigChanged,
base::Unretained(this)))) {
LOG(ERROR) << "DNS config watch failed to start.";
success = false;
}
if (!hosts_watcher_.Watch(
base::FilePath(kFilePathHosts),
base::FilePathWatcher::Type::kNonRecursive,
base::BindRepeating(&Watcher::OnHostsFilePathWatcherChange,
base::Unretained(this)))) {
LOG(ERROR) << "DNS hosts watch failed to start.";
success = false;
}
return success;
}
private:
void OnHostsFilePathWatcherChange(const base::FilePath& path, bool error) {
OnHostsChanged(!error);
}
DnsConfigWatcher config_watcher_;
base::FilePathWatcher hosts_watcher_;
};
// A SerialWorker that uses libresolv to initialize res_state and converts
// it to DnsConfig.
class DnsConfigServiceLinux::ConfigReader : public SerialWorker {
public:
explicit ConfigReader(DnsConfigServiceLinux& service) : service_(&service) {
// Allow execution on another thread; nothing thread-specific about
// constructor.
DETACH_FROM_SEQUENCE(sequence_checker_);
}
ConfigReader(const ConfigReader&) = delete;
ConfigReader& operator=(const ConfigReader&) = delete;
void DoWork() override { dns_config_ = ReadDnsConfig(); }
void OnWorkFinished() override {
DCHECK(!IsCancelled());
if (dns_config_.has_value()) {
service_->OnConfigRead(std::move(dns_config_).value());
} else {
LOG(WARNING) << "Failed to read DnsConfig.";
}
}
private:
~ConfigReader() override = default;
// Raw pointer to owning DnsConfigService. This must never be accessed inside
// DoWork(), since service may be destroyed while SerialWorker is running
// on worker thread.
DnsConfigServiceLinux* const service_;
// Written in DoWork, read in OnWorkFinished, no locking necessary.
base::Optional<DnsConfig> dns_config_;
};
DnsConfigServiceLinux::DnsConfigServiceLinux()
: DnsConfigService(kFilePathHosts) {
// Allow constructing on one thread and living on another.
DETACH_FROM_SEQUENCE(sequence_checker_);
}
DnsConfigServiceLinux::~DnsConfigServiceLinux() {
if (config_reader_)
config_reader_->Cancel();
}
void DnsConfigServiceLinux::ReadConfigNow() {
config_reader_->WorkNow();
}
bool DnsConfigServiceLinux::StartWatching() {
CreateReader();
watcher_ = std::make_unique<Watcher>(*this);
return watcher_->Watch();
}
void DnsConfigServiceLinux::CreateReader() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(!config_reader_);
config_reader_ = base::MakeRefCounted<ConfigReader>(*this);
}
base::Optional<DnsConfig> ConvertResStateToDnsConfig(
const struct __res_state& res) {
DnsConfig dns_config;
dns_config.unhandled_options = false;
if (!(res.options & RES_INIT))
return base::nullopt;
static_assert(std::extent<decltype(res.nsaddr_list)>() >= MAXNS &&
std::extent<decltype(res._u._ext.nsaddrs)>() >= MAXNS,
"incompatible libresolv res_state");
DCHECK_LE(res.nscount, MAXNS);
// Initially, glibc stores IPv6 in |_ext.nsaddrs| and IPv4 in |nsaddr_list|.
// In res_send.c:res_nsend, it merges |nsaddr_list| into |nsaddrs|,
// but we have to combine the two arrays ourselves.
for (int i = 0; i < res.nscount; ++i) {
IPEndPoint ipe;
const struct sockaddr* addr = nullptr;
size_t addr_len = 0;
if (res.nsaddr_list[i].sin_family) { // The indicator used by res_nsend.
addr = reinterpret_cast<const struct sockaddr*>(&res.nsaddr_list[i]);
addr_len = sizeof res.nsaddr_list[i];
} else if (res._u._ext.nsaddrs[i]) {
addr = reinterpret_cast<const struct sockaddr*>(res._u._ext.nsaddrs[i]);
addr_len = sizeof *res._u._ext.nsaddrs[i];
} else {
return base::nullopt;
}
if (!ipe.FromSockAddr(addr, addr_len))
return base::nullopt;
dns_config.nameservers.push_back(ipe);
}
dns_config.search.clear();
for (int i = 0; (i < MAXDNSRCH) && res.dnsrch[i]; ++i) {
dns_config.search.emplace_back(res.dnsrch[i]);
}
dns_config.ndots = res.ndots;
dns_config.fallback_period = base::TimeDelta::FromSeconds(res.retrans);
dns_config.attempts = res.retry;
#if defined(RES_ROTATE)
dns_config.rotate = res.options & RES_ROTATE;
#endif
#if !defined(RES_USE_DNSSEC)
// Some versions of libresolv don't have support for the DO bit. In this
// case, we proceed without it.
static const int RES_USE_DNSSEC = 0;
#endif
// The current implementation assumes these options are set. They normally
// cannot be overwritten by /etc/resolv.conf
const unsigned kRequiredOptions = RES_RECURSE | RES_DEFNAMES | RES_DNSRCH;
if ((res.options & kRequiredOptions) != kRequiredOptions) {
dns_config.unhandled_options = true;
return dns_config;
}
const unsigned kUnhandledOptions = RES_USEVC | RES_IGNTC | RES_USE_DNSSEC;
if (res.options & kUnhandledOptions) {
dns_config.unhandled_options = true;
return dns_config;
}
if (dns_config.nameservers.empty())
return base::nullopt;
// If any name server is 0.0.0.0, assume the configuration is invalid.
for (const IPEndPoint& nameserver : dns_config.nameservers) {
if (nameserver.address().IsZero())
return base::nullopt;
}
return dns_config;
}
} // namespace internal
// static
std::unique_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
return std::make_unique<internal::DnsConfigServiceLinux>();
}
} // namespace net
| [
"chromium-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | chromium-scoped@luci-project-accounts.iam.gserviceaccount.com |
9b04e034082ed0450850256a5661653501c06bdd | 496559527fd9afbb22598c1a45450a46e8bceb4f | /Codeforces/Div2/666/d.cpp | 2aabd5bd36b28596794bef256aaa3540c7ccadca | [] | no_license | ujjawalpabreja99/codeforces | 50343193ea6be84a66611c4e5252a8a5df37a3f0 | 204ab9278885b441213fc4d967109528f227b2e7 | refs/heads/main | 2023-01-29T02:46:18.547747 | 2020-12-15T16:44:51 | 2020-12-15T16:44:51 | 301,606,298 | 1 | 8 | null | 2020-12-15T16:44:52 | 2020-10-06T03:43:30 | C++ | UTF-8 | C++ | false | false | 2,426 | cpp | /*
Ujjawal Pabreja [cuber_coder]
*/
#include <bits/stdc++.h>
#include <functional>
using namespace std;
#define speed_cubing ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ll long long
#define ld long double
#define rep(i,a) for(ll i = 0 ; i < a ; i++)
#define repe(i,a,b) for(ll i = a ; i < b ; i++)
#define bac(i,a) for(ll i = a ; i >= 0 ; i--)
#define bace(i,a,b) for(ll i = a ; i >= b ; i--)
#define pb push_back
#define in insert
#define ff first
#define ss second
#define setbit(x) __builtin_popcountll(x)
#define init(c,a) memset(c,a,sizeof(c))
#define all(c) c.begin(),c.end()
#define sz(c) (ll)c.size()
#define lb lower_bound
#define ub upper_bound
#define maxe *max_element
#define mine *min_element
#define rev reverse
#define endl "\n"
#define debug(x) cout << #x << " : " << x << endl;
const ll inf = 1e18;
const ll mod = 1e9 + 7;
const ll MOD = 998244353;
const ll MAX = 2e5 + 1;
inline ll add(ll a,ll b) {return ((a % mod) + (b % mod)) % mod;}
inline ll sub(ll a,ll b) {return ((a % mod) - (b % mod) + mod) % mod;}
inline ll mul(ll a,ll b) {return ((a % mod) * (b % mod)) % mod;}
ll pwr(ll x,ll n){
if(n == 0){
return 1;
}
if(n&1){
return mul(x, pwr(mul(x, x), (n - 1) / 2));
} else {
return pwr(mul(x, x), n / 2);
}
}
ll modInv(ll n){
return pwr(n, mod - 2);
}
ll gcd(ll a,ll b) {
if(b == 0) {
return a;
}
return gcd(b, a % b);
}
// ====== Useful functions end ======
// ====== Global Variables begin ======
// ====== Global Variables end ======
void speed_solve(){
ll n;
cin >> n;
ll a[n], tot = 0;
rep(i,n){
cin >> a[i];
tot += a[i];
}
if(n == 1) {
cout << "T" << endl;
return;
}
if(tot < 2 * maxe(a,a + n)) {
cout << "T" << endl;
} else {
cout << (tot & 1 ? "T" : "HL") << endl;
}
}
int main(){
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
speed_cubing;
ll test_cases = 1;
cin >> test_cases;
rep(i,test_cases){
// cout << "Case #" << i + 1 << ": ";
speed_solve();
}
return 0;
} | [
"ujjawalpabreja@Ujjawals-MacBook-Pro.local"
] | ujjawalpabreja@Ujjawals-MacBook-Pro.local |
4b5aa0900a9861d674f5a77d7f708895d7c1c6e5 | 70cdbcfc93a380a64587e182003b61c522ec7adc | /memoria.cpp | 974af3c2758a0206715d7c018a312af7ccd4feb5 | [] | no_license | kitpinho/first-fit | 385da8dcc94620efc7ae6db83885c003771fc5af | f1a9246b292b939bbad0a25feb1ef59037324051 | refs/heads/master | 2021-01-22T02:39:40.248118 | 2014-06-04T23:07:50 | 2014-06-04T23:07:50 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,199 | cpp | #include "memoria.h"
#include "bloco.h"
#include "controleProcesso.h"
Memoria::Memoria()
{
memoria.clear();
ControleProcesso pr();
Bloco bl(100);
memoria.push_back(bl);
}
//Insere um novo bloco no vetor 'memoria'
void Memoria::insertBloco(Bloco _bloco)
{
memoria.push_back(_bloco);
}
//Remove do vetor 'memoria' o bloco na posição 'index'
void Memoria::removeBloco(int index)
{
memoria.erase(memoria.begin()+index);
}
//Divide o um bloco ( que estava livre ) alocando um bloco 'novo' e criando um novo bloco livre do tamanho do espaço não usado pelo bloco recém alocado
void Memoria::splitBloco(int index_vitima, Bloco novo )
{
memoria[index_vitima].size = memoria[index_vitima].size - novo.size;
ControleProcesso empty;
Bloco livre(empty,memoria[index_vitima].size - novo.size);
std::vector<Bloco>::iterator it;
it = memoria.begin()+index_vitima;
memoria.insert(it,novo);
}
void Memoria::mergeBloco(int index_bl1, int index_bl2)
{
ControleProcesso empty;
Bloco livre(empty, memoria[index_bl1].size + memoria[index_bl2].size);
removeBloco(index_bl1);
removeBloco(index_bl2);
std::vector<Bloco>::iterator it;
it = memoria.begin()+index_bl1;
memoria.insert(it,livre);
} | [
"kitpinho@hotmail.com"
] | kitpinho@hotmail.com |
369bab26e5aac6264c075e2f0d7d299f3f8abca0 | ad80c85f09a98b1bfc47191c0e99f3d4559b10d4 | /code/src/nemesis/nodenode_cmds.cc | c2caadc754ceb3c9f6fc5d7147a8f55c328616f7 | [] | no_license | DSPNerd/m-nebula | 76a4578f5504f6902e054ddd365b42672024de6d | 52a32902773c10cf1c6bc3dabefd2fd1587d83b3 | refs/heads/master | 2021-12-07T18:23:07.272880 | 2009-07-07T09:47:09 | 2009-07-07T09:47:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 41,402 | cc | #define N_IMPLEMENTS nOdeNode
//==============================================================================
// subdir/nOdeNode_init.cc
// author: Your Name
// (C) 2000 Radon Labs GmbH
//------------------------------------------------------------------------------
// includes
#include "kernel/npersistserver.h"
#include "nemesis/nodenode.h"
#include "nemesis/node_physics.h"
#include "nemesis/node_collideobject.h"
// global declarations
static void n_getrelpointvel(void *, nCmd*);
static void n_getrelpointpos(void *, nCmd*);
static void n_gettorque(void *, nCmd*);
static void n_getforce(void *, nCmd*);
// Setters
static void n_addforce(void *, nCmd *);
static void n_addtorque(void *, nCmd *);
static void n_addforceatrelpos(void *, nCmd*);
static void n_addforceatpos(void *, nCmd*);
static void n_addrelforceatpos(void *, nCmd*);
static void n_setfiniterotationmode(void *, nCmd*);
static void n_setfiniterotationaxis(void *, nCmd*);
// Getters
static void n_getforce(void *, nCmd*);
static void n_gettorque(void *, nCmd*);
static void n_getrelpointpos(void *, nCmd*);
static void n_getrelpointvel(void *, nCmd*);
static void n_getfiniterotationmode(void *, nCmd*);
static void n_getfiniterotationaxis(void *, nCmd*);
static void n_getnumjoints(void *, nCmd*);
static void n_getjoint(void *, nCmd*);
static void n_setvisualize(void*, nCmd*);
static void n_setcollisionclass(void*, nCmd*);
static void n_connectwithball(void*, nCmd*);
static void n_connectfixed(void*, nCmd*);
static void n_connectwithhinge(void*, nCmd*);
static void n_connectwithhinge2(void*, nCmd*);
static void n_connectwithslider(void*, nCmd*);
static void n_setshapestyle(void *, nCmd *);
static void n_setradius(void *, nCmd *);
static void n_setheight(void *, nCmd *);
static void n_setbox(void *, nCmd *);
static void n_makesphere(void *, nCmd *);
static void n_makecylinder(void *, nCmd *);
static void n_makebox(void *, nCmd *);
static void n_makeplane(void *, nCmd *);
static void n_usecollision(void *, nCmd *);
static void n_usephysics(void *, nCmd *);
static void n_setcontactparam(void *, nCmd *);
static void n_getcontactparam(void *, nCmd *);
static void n_setcollisionlink(void *, nCmd *);
static void n_setcollisionfile(void *, nCmd *);
static void n_maketrilist(void *, nCmd *);
struct str2param {
const char *str;
nOdePhysics::nOdeTypes param;
};
static struct str2param str2param_table[] =
{
{ "sphere", nOdePhysics::ODE_SPHERE },
{ "cylinder", nOdePhysics::ODE_CYLINDER },
{ "plane", nOdePhysics::ODE_PLANE },
{ "box", nOdePhysics::ODE_BOX },
{ "trilist", nOdePhysics::ODE_TRILIST },
{ NULL, nOdePhysics::ODE_UNKNOWN }
};
static nOdePhysics::nOdeTypes str2param( const char *str )
{
int i=0;
struct str2param *p = NULL;
while ( p = &(str2param_table[i++]), p->str )
{
if ( strcmp( p->str, str ) == 0 )
return p->param;
}
return nOdePhysics::ODE_UNKNOWN;
};
static const char *param2str( nOdePhysics::nOdeTypes type )
{
int i=0;
struct str2param *p = NULL;
while ( p = &(str2param_table[i++]), p->str )
{
if (type == p->param)
return p->str;
}
return NULL;
};
struct str2param2 {
const char *str;
int param;
};
static struct str2param2 str2param_table2[] =
{
{ "mu", dCParamMu },
{ "mu2", dCParamMu2 },
{ "bounce", dCParamBounce },
{ "bouncevel", dCParamBounceVel },
{ "softerp", dCParamSoftErp },
{ "softcfm", dCParamSoftCfm },
{ "motion1", dCParamMotion1 },
{ "motion2", dCParamMotion2 },
{ "slip1", dCParamSlip1 },
{ "slip2", dCParamSlip2 },
{ NULL, -1 }
};
static int str2param2( const char *str )
{
int i=0;
struct str2param *p = NULL;
while ( p = &(str2param_table[i++]), p->str )
{
if ( strcmp( p->str, str ) == 0 )
return p->param;
}
return -1;
}
struct str2param3 {
const char *str;
int param;
};
static struct str2param3 str2param3_table[] =
{
{ "lowstop", dParamLoStop },
{ "highstop", dParamHiStop },
{ "velocity", dParamVel },
{ "maxforce", dParamFMax },
{ "fudgefactor", dParamFudgeFactor },
{ "bounce", dParamBounce },
{ "stoperp", dParamStopERP },
{ "stopcfm", dParamStopCFM },
{ "suspensionerp", dParamSuspensionERP },
{ "suspensioncfm", dParamSuspensionCFM },
{ "lowstop2", dParamLoStop2 },
{ "highstop2", dParamHiStop2 },
{ "velocity2", dParamVel2 },
{ "maxforce2", dParamFMax2 },
{ "fudgefactor2", dParamFudgeFactor2 },
{ "bounce2", dParamBounce2 },
{ "stoperp2", dParamStopERP2 },
{ "stopcfm2", dParamStopCFM2 },
{ "suspensionerp2", dParamSuspensionERP2 },
{ "suspensioncfm2", dParamSuspensionCFM2 },
{ NULL, -1 }
};
static int str2param3( const char *str )
{
int i=0;
struct str2param *p = NULL;
while ( p = &(str2param_table[i++]), p->str )
{
if ( strcmp( p->str, str ) == 0 )
return p->param;
}
return -1;
}
//==============================================================================
// CLASS
// nOdeNode
// SUPERCLASS
// nsuperclassname
// INCLUDE
// subdir/nOdeNode.h
// INFO
// Yeah right.. Where's the better documentation? (see methods below)
//------------------------------------------------------------------------------
void
n_initcmds(nClass *cl)
{
cl->BeginCmds();
cl->AddCmd("v_setvisualize_b", 'SMNO', n_setvisualize);
cl->AddCmd("v_setcollisionclass_s", 'SCOC', n_setcollisionclass);
// Hand-build a collision shape
cl->AddCmd("v_setshapetyle_s", 'SCOA', n_setshapestyle);
cl->AddCmd("v_setradius_f", 'SCOB', n_setradius);
cl->AddCmd("v_setheight_f", 'SCOD', n_setheight);
cl->AddCmd("v_setbox_ffffff", 'SCOE', n_setbox);
cl->AddCmd("v_setcollisionlink_ss", 'SCLK', n_setcollisionlink);
cl->AddCmd("v_setcollisionfile_ss", 'SCLF', n_setcollisionfile);
// Use built-in shapes
cl->AddCmd("v_makesphere_f", 'SCOG', n_makesphere);
cl->AddCmd("v_makecylinder_ff", 'SCOH', n_makecylinder);
cl->AddCmd("v_makebox_ffffff", 'SCOI', n_makebox);
cl->AddCmd("v_makeplane_ffff", 'SCOJ', n_makeplane);
cl->AddCmd("v_maketrilist_s", 'SCTL', n_maketrilist);
// To collide or not to collide
cl->AddCmd("v_usecollision_b", 'SCOK', n_usecollision);
// To physics or not to physics
cl->AddCmd("v_usephysics_b", 'SCOL', n_usephysics);
// Set this object's surface params (See ODE docs)
cl->AddCmd("v_setcontactparam_sf", 'SCPR', n_setcontactparam);
cl->AddCmd("f_getcontactparam_s", 'GCPR', n_getcontactparam);
// Add some forces and axes to the system
cl->AddCmd("v_addforce_fff", 'ADDF', n_addforce);
cl->AddCmd("v_addtorque_fff", 'ADDT', n_addtorque);
cl->AddCmd("v_addforceatpos_ffffff", 'AFAP', n_addforceatpos);
cl->AddCmd("v_addforceatrelpos_ffffff", 'AFRP', n_addforceatrelpos);
cl->AddCmd("v_addrelforceatpos_ffffff", 'ARFP', n_addrelforceatpos);
cl->AddCmd("v_setfiniterotationmode_i",'SFRM', n_setfiniterotationmode);
cl->AddCmd("v_setfiniterotationaxis_fff",'SFRA', n_setfiniterotationaxis);
// Get the data back out of the system
cl->AddCmd("fff_getforce_v", 'GETF', n_getforce);
cl->AddCmd("fff_gettorque_v", 'GTOQ', n_gettorque);
cl->AddCmd("fff_getrelpointpos_v", 'GRPP', n_getrelpointpos);
cl->AddCmd("fff_getrelpointvel_v", 'GRPV', n_getrelpointvel);
cl->AddCmd("i_getfiniterotationmode_v",'GFRM', n_getfiniterotationmode);
cl->AddCmd("fff_getfiniterotationaxis_v",'GFRA', n_getfiniterotationaxis);
cl->AddCmd("i_getnumjoints_v",'GNJO', n_getnumjoints);
cl->AddCmd("i_getjoints_i",'GJOI', n_getjoint);
// cl->AddCmd("v_connectwithmotor_ssfff", 'CHIN', n_connectwithslider );
cl->AddCmd("s_connectwithslider_sfff", 'CSLI', n_connectwithslider );
cl->AddCmd("s_connectwithhinge2_sfffffffff", 'CHIN', n_connectwithhinge2 );
cl->AddCmd("s_connectwithhinge_sffffff", 'CHGE', n_connectwithhinge );
cl->AddCmd("s_connectwithball_sfff", 'CBAL', n_connectwithball );
cl->AddCmd("s_connectfixed_s", 'CFIX', n_connectfixed );
cl->EndCmds();
}
//------------------------------------------------------------------------------
/**
@cmd
connectwithhinge
@input
s ( other nodenode ),
f ( anchor x value )
f ( anchor y value )
f ( anchor z value )
f ( axis x value )
f ( axis y value )
f ( axis z value )
@output
s The name of the joint created (use this to set parameters)
@info
Connect this odenode with another odenode via a ODE
HINGE joint. See ODE docs for more details
*/
static void n_connectwithhinge(void* vpObj, nCmd* pCmd)
{
nOdeNode* pSelf = static_cast<nOdeNode*>(vpObj);
const char* other = pCmd->In()->GetS();
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
float x2 = pCmd->In()->GetF();
float y2 = pCmd->In()->GetF();
float z2 = pCmd->In()->GetF();
pCmd->Out()->SetS(pSelf->connectWithHingeJoint( other, &vector3(x,y,z), &vector3(x2,y2,z2)));
}
//------------------------------------------------------------------------------
/**
@cmd
connectwithhinge2
@input
s ( other nodenode ),
f ( anchor x value )
f ( anchor y value )
f ( anchor z value )
f ( axis x value )
f ( axis y value )
f ( axis z value )
f ( axis2 x value )
f ( axis2 y value )
f ( axis2 z value )
@output
s The name of the joint created
@info
Connect this odenode with another odenode via a ODE
HINGE joint. See ODE docs for more details
*/
static void n_connectwithhinge2(void* vpObj, nCmd* pCmd)
{
nOdeNode* pSelf = static_cast<nOdeNode*>(vpObj);
const char* other = pCmd->In()->GetS();
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
float ax = pCmd->In()->GetF();
float ay = pCmd->In()->GetF();
float az = pCmd->In()->GetF();
float ax2 = pCmd->In()->GetF();
float ay2 = pCmd->In()->GetF();
float az2 = pCmd->In()->GetF();
pCmd->Out()->SetS(pSelf->connectWithHinge2Joint( other, &vector3(x,y,z), &vector3(ax,ay,az), &vector3(ax2,ay2,az2)));
}
//------------------------------------------------------------------------------
/**
@cmd
connectwithball
@input
s ( other nodenode ),
f ( anchor x value )
f ( anchor y value )
f ( anchor z value )
@output
s name of the joint created
@info
Connect this odenode with another odenode via a ODE
BALL joint. See ODE docs for more details
*/
static void n_connectwithball(void* vpObj, nCmd* pCmd)
{
nOdeNode* pSelf = static_cast<nOdeNode*>(vpObj);
const char* other = pCmd->In()->GetS();
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
pCmd->Out()->SetS(pSelf->connectWithBallJoint( other, &vector3(x,y,z)));
}
//------------------------------------------------------------------------------
/**
@cmd
connectwithslider
@input
s ( other nodenode ),
f ( axis x value )
f ( axis y value )
f ( axis z value )
@output
s Name of the joint
@info
Connect this odenode with another odenode via a ODE
SLIDER joint. See ODE docs for more details
*/
static void n_connectwithslider(void* vpObj, nCmd* pCmd)
{
nOdeNode* pSelf = static_cast<nOdeNode*>(vpObj);
const char* other = pCmd->In()->GetS();
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
pCmd->Out()->SetS(pSelf->connectWithSliderJoint( other,&vector3(x,y,z)));
}
//------------------------------------------------------------------------------
/**
@cmd
connectfixed
@input
s ( other nodenode ),
f ( anchor x value )
f ( anchor y value )
f ( anchor z value )
f ( axis x value )
f ( axis y value )
f ( axis z value )
@output
s The name of the joint created
@info
Connect this odenode with another odenode via a ODE
FIXED (immovable) joint. See ODE docs for more details
*/
static void n_connectfixed(void* vpObj, nCmd* pCmd)
{
nOdeNode* pSelf = static_cast<nOdeNode*>(vpObj);
pCmd->Out()->SetS(pSelf->connectWithFixedJoint( pCmd->In()->GetS()));
}
//------------------------------------------------------------------------------
/**
@cmd
setcontactparam
@input
s ( parameter ), f ( value )
@output
v
@info
set optional surface parameters for contacts resulting
from collisions in the space.
see ODE documentation for complete descriptions.
valid parameters are:
mu
mu2
bounce
bouncevel
softerp
softcfm
motion1
motion2
slip1
slip2
*/
static
void
n_setcontactparam(void* slf, nCmd* cmd)
{
nOdeNode* self = static_cast<nOdeNode*>(slf);
const char* strParam = cmd->In()->GetS();
float value = cmd->In()->GetF();
((nOdeCollideObject *)self->getCollideObject())->SetContactParam( str2param2( strParam ), value );
}
//------------------------------------------------------------------------------
/**
@cmd
getcontactparam
@input
s ( parameter )
@output
f ( value )
@info
get value of an optional parameter for contacts
resulting from collisions in the space.
see setcontactparam for valid parameters.
*/
static
void
n_getcontactparam(void* slf, nCmd* cmd)
{
nOdeNode* self = static_cast<nOdeNode*>(slf);
const char* strParam = cmd->In()->GetS();
float value = 0.0;
value = ((nOdeCollideObject *)self->getCollideObject())->GetContactParam(str2param2( strParam ) );
cmd->Out()->SetF( value );
}
//==============================================================================
// CMD
// setmeshnode
// INPUT
// s
// OUTPUT
// v
// INFO
// Sets the visual nMeshNode to use for this object at render time
//------------------------------------------------------------------------------
static
void
n_setvisualize(void* vpObj, nCmd* pCmd)
{
nOdeNode* pSelf = static_cast<nOdeNode*>(vpObj);
pSelf->setVisualize( pCmd->In()->GetB() );
}
//==============================================================================
// CMD
// setcollisionclass
// INPUT
// s
// OUTPUT
// v
// INFO
// Sets the class of collisions -- see Startup for list
//------------------------------------------------------------------------------
static
void
n_setcollisionclass(void* vpObj, nCmd* pCmd)
{
nOdeNode* pSelf = static_cast<nOdeNode*>(vpObj);
pSelf->setCollisionClass( pCmd->In()->GetS() );
}
//------------------------------------------------------------------------------
// 2000.mm.dd your name created
//------------------------------------------------------------------------------
bool
nOdeNode::SaveCmds(nPersistServer* ps)
{
if (nVisNode::SaveCmds(ps))
{
nCmd* pCmd = 0;
if ((pCmd = ps->GetCmd(this, 'SMNO')))
{
ps->PutCmd(pCmd);
}
if ((pCmd = ps->GetCmd(this, 'SCOC')))
{
ps->PutCmd(pCmd);
}
if ((pCmd = ps->GetCmd(this, 'CVAL')))
{
ps->PutCmd(pCmd);
}
if ((pCmd = ps->GetCmd(this, 'CFIX')))
{
ps->PutCmd(pCmd);
}
return true;
}
else
{
return false;
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Manually set the shape of this collision object. This
// shape will then need to have it's radius and possibly
// its height and other parameters tweaked
//
// This must be called before Attach() / Compute() is reached.
// so be sure to fully initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_setshapestyle( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
nOdePhysics::nOdeTypes shape = (nOdePhysics::nOdeTypes) str2param(pCmd->In()->GetS());
pSelf->setBoundingShapeStyle( shape );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Manually set the radius of this collision object.
//
// This must be called before Attach() / Compute() is reached,
// as this is where the shape is fully realized o be sure to fully
// initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_setradius( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
float radius = pCmd->In()->GetF();
pSelf->setRadius( radius );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Manually set the height of this collision object. (Cylinders only)
//
// This must be called before Attach() / Compute() is reached,
// as this is where the shape is fully realized o be sure to fully
// initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_setheight( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
float height = pCmd->In()->GetF();
pSelf->setHeight( height );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Manually set the min/max bounding box of this collision object.
//
// INPUT:
// fff - The min x/y/z of the bounding box
// fff - The max x/y/z of the bounding box
//
// This must be called before Attach() / Compute() is reached,
// as this is where the shape is fully realized o be sure to fully
// initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_setbox( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
float minx = pCmd->In()->GetF();
float miny = pCmd->In()->GetF();
float minz = pCmd->In()->GetF();
float maxx = pCmd->In()->GetF();
float maxy = pCmd->In()->GetF();
float maxz = pCmd->In()->GetF();
bbox3 box;
box.vmin.set( minx, miny, minz );
box.vmax.set( maxx, maxy, maxz );
pSelf->setBoundingBox( &box );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Automatically sense the values this collision object will need,
// given the nVisNode pointer, and the shape style passed in.
//
// INPUT:
// s - The name of the nVisNode to link to
// s - The shape to syle after (sphere, box, cylinder, plane)
//
// This must be called before Attach() / Compute() is reached,
// as this is where the shape is fully realized o be sure to fully
// initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_setcollisionlink( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
const char* linkTo = pCmd->In()->GetS();
nOdePhysics::nOdeTypes shape = str2param( pCmd->In()->GetS() );
nClass *visClass = pSelf->pKernelServer->FindClass("nvisnode");
nRoot *test = pSelf->pKernelServer->Lookup( linkTo );
if (test->IsA( visClass ))
pSelf->setCollisionLink( (nVisNode*)test, shape );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Automatically sense the values this collision object will need,
// given the .N3D filename pointer, and the shape style passed in.
//
// INPUT:
// s - The name of the .N3D file to link to
// s - The shape to style after (sphere, box, cylinder, plane)
//
// This must be called before Attach() / Compute() is reached,
// as this is where the shape is fully realized o be sure to fully
// initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_setcollisionfile( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
const char* linkTo = pCmd->In()->GetS();
nOdePhysics::nOdeTypes shape = str2param( pCmd->In()->GetS() );
pSelf->setCollisionFile( linkTo, shape );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Automatically create a sphere with the given radius.
// No other methods need to be called once this is called.
//
// This must be called before Attach() / Compute() is reached,
// as this is where the shape is fully realized o be sure to fully
// initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_makesphere( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
float radius = pCmd->In()->GetF();
pSelf->MakeSphere( radius );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Automatically create a cylinder with the given radius/height.
// No other methods need to be called once this is called.
//
// This must be called before Attach() / Compute() is reached,
// as this is where the shape is fully realized so be sure to fully
// initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_makecylinder( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
float radius = pCmd->In()->GetF();
float height = pCmd->In()->GetF();
pSelf->MakeCylinder( radius, height );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Automatically create a box with the given min/max values.
// No other methods need to be called once this is called.
//
// This must be called before Attach() / Compute() is reached,
// as this is where the shape is fully realized so be sure to fully
// initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_makebox( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
float minx = pCmd->In()->GetF();
float miny = pCmd->In()->GetF();
float minz = pCmd->In()->GetF();
float maxx = pCmd->In()->GetF();
float maxy = pCmd->In()->GetF();
float maxz = pCmd->In()->GetF();
pSelf->MakeBox( minx, miny, minz, maxx, maxy, maxz );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Automatically create a plane with the given radius on the given axis.
// No other methods need to be called once this is called.
//
// INPUT:
// f - the 'a' vector of the plane equation
// f - the 'b' vector of the plane equation
// f - the 'c' vector of the plane equation
// f - the 'd' vector of the plane equation
//
// From ODE docs:
// Create a plane geometry object of the given parameters The plane equation is
// a*x+b*y+c*z = d
//
// The plane's normal vector is (a,b,c), and it must have length 1. Unlike other
// geometry objects, planes disregard their assigned position and rotation, i.e.
// the parameters are always in global coordinates. In other words it is assumed
// that the plane is always part of the static environment and not tied to any
// movable object.
//
// This must be called before Attach() / Compute() is reached,
// as this is where the shape is fully realized so be sure to fully
// initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_makeplane( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
float a = pCmd->In()->GetF();
float b = pCmd->In()->GetF();
float c = pCmd->In()->GetF();
float d = pCmd->In()->GetF();
pSelf->MakePlane( a, b, c, d);
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Automatically create a plane with the given radius on the given axis.
// No other methods need to be called once this is called.
//
// INPUT:
// f - the 'a' vector of the plane equation
// f - the 'b' vector of the plane equation
// f - the 'c' vector of the plane equation
// f - the 'd' vector of the plane equation
//
// From ODE docs:
// Create a plane geometry object of the given parameters The plane equation is
// a*x+b*y+c*z = d
//
// The plane's normal vector is (a,b,c), and it must have length 1. Unlike other
// geometry objects, planes disregard their assigned position and rotation, i.e.
// the parameters are always in global coordinates. In other words it is assumed
// that the plane is always part of the static environment and not tied to any
// movable object.
//
// This must be called before Attach() / Compute() is reached,
// as this is where the shape is fully realized so be sure to fully
// initialize the object in one pass.
//------------------------------------------------------------------------------
static void n_maketrilist( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
const char *a = pCmd->In()->GetS();
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Add a force to this object represented by a vector3
//
// INPUT:
// f - the 'x' vector of the force
// f - the 'y' vector of the force
// f - the 'z' vector of the force
//
// From ODE docs:
// 3.4. Force accumulators
//
// Between each integrator step the user can call functions to apply
// forces to the rigid body. These forces are added to "force accumulators"
// in the rigid body object. When the next integrator step happens, the sum
// of all the applied forces will be used to push the body around. The forces
// accumulators are set to zero after each integrator step.
//
//------------------------------------------------------------------------------
static void n_addforce( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
pSelf->addForce( &vector3(x,y,z) );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Add a torque to this object represented by a vector3
//
// INPUT:
// f - the 'x' vector of the torque
// f - the 'y' vector of the torque
// f - the 'z' vector of the torque
//
// From ODE docs:
// 3.4. Force accumulators
//
// Between each integrator step the user can call functions to apply
// forces to the rigid body. These forces are added to "force accumulators"
// in the rigid body object. When the next integrator step happens, the sum
// of all the applied forces will be used to push the body around. The forces
// accumulators are set to zero after each integrator step.
//
//------------------------------------------------------------------------------
static void n_addtorque( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
pSelf->addTorque( &vector3(x,y,z) );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Toggle this object's collidability. If false, It will still be effected by
// gravity, just not as a collide target anymore.
//
// // TODO: Implement this
//
//------------------------------------------------------------------------------
static void n_usecollision( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Toggle this object's phyiscs. If false, It will still be effected by
// collisions, just not modified by gravity anymore.
//
//------------------------------------------------------------------------------
static void n_usephysics( void* pObj, nCmd* pCmd )
{
nOdeNode *pSelf = static_cast<nOdeNode*>(pObj);
pSelf->SetPhysicsable( !pCmd->In()->GetB() );
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Add a force to this object represented by a vector3
//
// INPUT:
// f - the 'x' vector of the force
// f - the 'y' vector of the force
// f - the 'z' vector of the force
//
// f - the 'x' vector of the position
// f - the 'y' vector of the position
// f - the 'z' vector of the position
//
// From ODE docs:
// 3.4. Force accumulators
//
// Between each integrator step the user can call functions to apply
// forces to the rigid body. These forces are added to "force accumulators"
// in the rigid body object. When the next integrator step happens, the sum
// of all the applied forces will be used to push the body around. The forces
// accumulators are set to zero after each integrator step.
//
//------------------------------------------------------------------------------
static void n_addforceatpos(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
float px = pCmd->In()->GetF();
float py = pCmd->In()->GetF();
float pz = pCmd->In()->GetF();
nOdeCollideObject *co = pSelf->getCollideObject();
if (co)
{
co->addForceAtPos( &vector3( x, y, z), &vector3(px, py, pz)) ;
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Add a force to this object represented by a vector3
//
// INPUT:
// f - the 'x' vector of the force
// f - the 'y' vector of the force
// f - the 'z' vector of the force
//
// f - the 'x' vector of the position
// f - the 'y' vector of the position
// f - the 'z' vector of the position
//
// From ODE docs:
// 3.4. Force accumulators
//
// Between each integrator step the user can call functions to apply
// forces to the rigid body. These forces are added to "force accumulators"
// in the rigid body object. When the next integrator step happens, the sum
// of all the applied forces will be used to push the body around. The forces
// accumulators are set to zero after each integrator step.
//
//------------------------------------------------------------------------------
static void n_addforceatrelpos(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
float px = pCmd->In()->GetF();
float py = pCmd->In()->GetF();
float pz = pCmd->In()->GetF();
nOdeCollideObject *co = pSelf->getCollideObject();
if (co)
{
co->addForceAtRelPos( &vector3( x, y, z), &vector3(px, py, pz)) ;
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Add a force to this object represented by a vector3
//
// INPUT:
// f - the 'x' vector of the relative force
// f - the 'y' vector of the relative force
// f - the 'z' vector of the relative force
//
// f - the 'x' vector of the position
// f - the 'y' vector of the position
// f - the 'z' vector of the position
//
// From ODE docs:
// 3.4. Force accumulators
//
// Between each integrator step the user can call functions to apply
// forces to the rigid body. These forces are added to "force accumulators"
// in the rigid body object. When the next integrator step happens, the sum
// of all the applied forces will be used to push the body around. The forces
// accumulators are set to zero after each integrator step.
//
//------------------------------------------------------------------------------
static void n_addrelforceatpos(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
float px = pCmd->In()->GetF();
float py = pCmd->In()->GetF();
float pz = pCmd->In()->GetF();
nOdeCollideObject *co = pSelf->getCollideObject();
if (co)
{
co->addRelForceAtPos( &vector3( x, y, z), &vector3(px, py, pz)) ;
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Set the finite rotation mode for this object
//
// INPUT:
//
// i - the mode of rotation
//
// From ODE docs:
// This function controls the way a body's orientation is
// updated at each time step. The mode argument can be:
// 0: An ``infitesimal'' orientation update is used.
// This is fast to compute, but it can occasionally cause
// inaccuracies for bodies that are rotating at high speed,
// especially when those bodies are joined to other bodies.
// This is the default for every new body that is created.
// 1: A ``finite'' orientation update is used. This is more costly
// to compute, but will be more accurate for high speed rotations.
// Note however that high speed rotations can result in many types
// of error in a simulation, and this mode will only fix one of
// those sources of error.
//
//------------------------------------------------------------------------------
static void n_setfiniterotationmode(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
int mode = pCmd->In()->GetI();
nOdeCollideObject *co = pSelf->getCollideObject();
if (co)
{
co->setFiniteRotationMode( mode );
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// Set the finite rotation mode for this object
//
// INPUT:
//
// i - the mode of rotation
//
// From ODE docs:
// This sets the finite rotation axis for a body.
// This is axis only has meaning when the finite rotation mode is set
// (see setFiniteRotationMode()).
//
// If this axis is zero (0,0,0), full finite rotations are performed on
// the body.
//
// If this axis is nonzero, the body is rotated by performing a partial
// finite rotation along the axis direction followed by an infitesimal
// rotation along an orthogonal direction.
//
// This can be useful to alleviate certain sources of error caused by
// quickly spinning bodies. For example, if a car wheel is rotating at
// high speed you can call this function with the wheel's hinge axis as
// the argument to try and improve its behavior.
//
//------------------------------------------------------------------------------
static void n_setfiniterotationaxis(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
nOdeCollideObject *co = pSelf->getCollideObject();
if (co)
{
co->setFiniteRotationAxis( &vector3(x, y, z) );
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
//------------------------------------------------------------------------------
static void n_getforce(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
nOdeCollideObject *co = pSelf->getCollideObject();
if (co)
{
vector3 force(co->getForce());
pCmd->Out()->SetF( force.x );
pCmd->Out()->SetF( force.y );
pCmd->Out()->SetF( force.z );
} else {
pCmd->Out()->SetF( 0.0f );
pCmd->Out()->SetF( 0.0f );
pCmd->Out()->SetF( 0.0f );
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
//------------------------------------------------------------------------------
static void n_gettorque(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
nOdeCollideObject *co = pSelf->getCollideObject();
if (co)
{
vector3 torque(co->getTorque());
pCmd->Out()->SetF( torque.x );
pCmd->Out()->SetF( torque.y );
pCmd->Out()->SetF( torque.z );
} else {
pCmd->Out()->SetF( 0.0f );
pCmd->Out()->SetF( 0.0f );
pCmd->Out()->SetF( 0.0f );
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
//------------------------------------------------------------------------------
static void n_getrelpointpos(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
nOdeCollideObject *co = pSelf->getCollideObject();
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
if (co)
{
vector3 pos(co->getRelPointPos( &vector3( x, y, z) ));
pCmd->Out()->SetF( pos.x );
pCmd->Out()->SetF( pos.y );
pCmd->Out()->SetF( pos.z );
} else {
pCmd->Out()->SetF( 0.0f );
pCmd->Out()->SetF( 0.0f );
pCmd->Out()->SetF( 0.0f );
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
//------------------------------------------------------------------------------
static void n_getrelpointvel(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
nOdeCollideObject *co = pSelf->getCollideObject();
float x = pCmd->In()->GetF();
float y = pCmd->In()->GetF();
float z = pCmd->In()->GetF();
if (co)
{
vector3 vel(co->getRelPointVel( &vector3( x, y, z) ));
pCmd->Out()->SetF( vel.x );
pCmd->Out()->SetF( vel.y );
pCmd->Out()->SetF( vel.z );
} else {
pCmd->Out()->SetF( 0.0f );
pCmd->Out()->SetF( 0.0f );
pCmd->Out()->SetF( 0.0f );
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
//------------------------------------------------------------------------------
static void n_getfiniterotationmode(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
nOdeCollideObject *co = pSelf->getCollideObject();
if (co)
{
int mode = co->getFiniteRotationMode();
pCmd->Out()->SetI( mode );
} else {
pCmd->Out()->SetI( -1 );
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
//------------------------------------------------------------------------------
static void n_getfiniterotationaxis(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
nOdeCollideObject *co = pSelf->getCollideObject();
if (co)
{
vector3 axis( co->getFiniteRotationAxis() );
pCmd->Out()->SetF( axis.x );
pCmd->Out()->SetF( axis.y );
pCmd->Out()->SetF( axis.z );
} else {
pCmd->Out()->SetF( 0.0f );
pCmd->Out()->SetF( 0.0f );
pCmd->Out()->SetF( 0.0f );
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
//------------------------------------------------------------------------------
static void n_getnumjoints(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
nOdeCollideObject *co = pSelf->getCollideObject();
if (co)
{
int num = co->getNumJoints();
pCmd->Out()->SetI( num );
} else {
pCmd->Out()->SetI( 0 );
}
}
//------------------------------------------------------------------------------
// 2002.02.06 whitegold created
//
// TODO: Passing a struct?
//------------------------------------------------------------------------------
static void n_getjoint(void * pObj, nCmd* pCmd)
{
nOdeNode *pSelf = static_cast<nOdeNode *>(pObj);
nOdeCollideObject *co = pSelf->getCollideObject();
int index = pCmd->In()->GetI();
if (0)
{
//co->getJoint( index );
//pCmd->Out()->SetI( num );
} else {
pCmd->Out()->SetI( -1 );
}
}
| [
"plushe@411252de-2431-11de-b186-ef1da62b6547"
] | plushe@411252de-2431-11de-b186-ef1da62b6547 |
5f1f94c76dc4262a665a8ed6c35827e2ae57ca3a | 51f6e63555b4fda6a620fb42952c5c1fa6eac706 | /components/autofill/core/browser/payments/payments_util.cc | ee230cb56361fc01002786263bba1ab641405b99 | [
"BSD-3-Clause"
] | permissive | heanglightman/chromium | 6f74026b428317a28cbb1226d20d1116ed54dd2b | f561f3e0174135fcc555aad31f4adb845977b8bd | refs/heads/master | 2023-02-25T08:18:13.731198 | 2019-03-25T16:19:12 | 2019-03-25T16:19:12 | 177,623,917 | 1 | 0 | NOASSERTION | 2019-03-25T16:27:22 | 2019-03-25T16:27:22 | null | UTF-8 | C++ | false | false | 1,747 | cc | // Copyright 2018 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.
#include "components/autofill/core/browser/payments/payments_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_piece.h"
#include "components/autofill/core/browser/autofill_metrics.h"
#include "components/autofill/core/browser/payments/payments_customer_data.h"
#include "components/autofill/core/browser/personal_data_manager.h"
namespace autofill {
namespace payments {
int64_t GetBillingCustomerId(PersonalDataManager* personal_data_manager,
bool should_log_validity) {
DCHECK(personal_data_manager);
// Get billing customer ID from the synced PaymentsCustomerData.
PaymentsCustomerData* customer_data =
personal_data_manager->GetPaymentsCustomerData();
if (customer_data && !customer_data->customer_id.empty()) {
int64_t billing_customer_id = 0;
if (base::StringToInt64(base::StringPiece(customer_data->customer_id),
&billing_customer_id)) {
if (should_log_validity) {
AutofillMetrics::LogPaymentsCustomerDataBillingIdStatus(
AutofillMetrics::BillingIdStatus::VALID);
}
return billing_customer_id;
} else {
if (should_log_validity) {
AutofillMetrics::LogPaymentsCustomerDataBillingIdStatus(
AutofillMetrics::BillingIdStatus::PARSE_ERROR);
}
}
} else {
if (should_log_validity) {
AutofillMetrics::LogPaymentsCustomerDataBillingIdStatus(
AutofillMetrics::BillingIdStatus::MISSING);
}
}
return 0;
}
} // namespace payments
} // namespace autofill
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
1a86e9a8eb4fc38fba9f5561c45d5fc9c213d803 | 81f6419ea475836b1f1b24bcd2de77a316bc46a1 | /GFG must do questions/Building binary tree.cpp | 192a10aa43c6774a24efd9c46e27d742ed15bd93 | [] | no_license | Pramodjais517/competitive-coding | f4e0f6f238d98c0a39f8a9c940265f886ce70cb3 | 2a8ad013246f2db72a4dd53771090d931ab406cb | refs/heads/master | 2023-02-25T12:09:47.382076 | 2021-01-28T06:57:26 | 2021-01-28T06:57:26 | 208,445,032 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,355 | cpp | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rs reserve
#define pb push_back
#define ff first
#define ss second
#define mp make_pair
#define fi(i,s,e,inc) for(auto i=s;i<e;i+=inc)
#define fie(i,s,e,inc) for(auto i=s;i<=e;i+=inc)
#define fd(i,s,e,dec) for(auto i=s;i>e;i-=dec)
#define fde(i,s,e,dec) for(auto i=s;i>=e;i-=dec)
#define itr(i,ar) for(auto i=ar.begin();i!=ar.end();i++)
#define mod 1000000007
class Node{
public:
int data;
Node* left,*right;
Node(int a)
{
data = a;
left = NULL;
right = NULL;
}
};
Node* build_tree(int a[],int l, int r)
{
if(r<l)
return NULL;
int mid = l + (r-l) / 2;
Node* node = new Node(a[mid]);
node->left = build_tree(a,l,mid-1);
node->right = build_tree(a,mid+1,r);
return node;
}
void print_tree(Node* root)
{
queue<Node*> q;
q.push(root);
q.push(NULL);
while(!q.empty())
{
Node* curr = q.front();
q.pop();
if(curr == NULL)
{
cout<<"\n";
if(!q.empty())
q.push(NULL);
}
else
{
cout<<curr->data<<" ";
if(curr->left != NULL)
q.push(curr->left);
if(curr->right != NULL)
q.push(curr->right);
}
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin>>n;
int a[n];
fi(i,0,n,1)
cin>>a[i];
Node* root = build_tree(a,0,n-1);
print_tree(root);
return 0;
}
| [
"pramodjaiswal517@gmail.com"
] | pramodjaiswal517@gmail.com |
02ba632e85257c5b5ce042046b23fcc3fb4edef5 | a5a640cb7c2a47b7b82a8e560f88c5a224903525 | /server/server/ODsocket.h | 51aeac833934211da3ef0246a54752c81523e551 | [] | no_license | Crasader/Archer_battle | 70d51da8914a8d453384a731bc9ef5b70cf181db | 78b3f57a25c6b0008b66d1039d586ea3d798015b | refs/heads/master | 2020-11-29T03:47:00.867503 | 2019-06-16T02:16:37 | 2019-06-16T02:16:37 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 814 | h | #pragma once
#include<winsock.h>
#include<string>
typedef int socklen_t;
//#include<iostram>
using namespace std;
class ODsocket
{
public:
ODsocket(SOCKET sock = INVALID_SOCKET);//构造函数
int SocketID;
bool Create(int AF, int type, int protocal = 0);
bool Connect(const string &ip, unsigned short port);
bool Bind(unsigned short port);
bool Listen(int backlog = 5);
bool Accept(ODsocket &s, char *fromip = NULL);
int Send(char * buffer, int len, int flag = 0);
int Recv(char *buffer, int len, int flag = 0);
int Close();
int GetError();
static int Init();
static int Clean();
static bool DnsParse(const char *domain, char * ip);//DNS解析
ODsocket& operator=(SOCKET s);//重载ODsocket等号运算符
operator SOCKET();
SOCKET m_sock;//ODsocket内包含的Socket对象
};
| [
"2206475938@qq.com"
] | 2206475938@qq.com |
dbcdfd9363a14c3df10efdc7f305dc378bf160bf | 4f8f944062e3841892c19e5baef16a50ffd88834 | /srm517/ColorfulBoard.cpp | 379953357da3155d4c3f2ccff4cf3458d6ee6e33 | [] | no_license | triplekiller/mytopcoder | 2e56628c8cf185f7737a5b7d010f510e3945c2f8 | 09d9a3b0aee24ee2fab2fce089fd6a6c13b81d6d | refs/heads/master | 2021-01-17T12:34:59.386276 | 2013-08-10T03:19:44 | 2013-08-10T03:19:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,226 | cpp | class ColorfulBoard {
public:
int theMin(vector <string>);
};
char a[55][55];
int mm[110][110];
int doIt(vector<string> board){
int n,m;
n=board.size();
m=board[0].size();
res=100000000;
for (int color=0;color<n;color++) {
int cur=m;
int ok=1;
memset(mm,0,sizeof(mm));
for (int i=0;i<n;i++) {
char c=' ';
for (int j=0;j<m;j++) {
if (board[i][j]!=board[color][j]) {
if (c==' ') {
c=board[i][j];
} else if(c!=' ' && c!=board[i][j]){
ok=0;
break;
}
mm[i][j+n]=1;
}
}
if(c!=' ') {
cur++;
for(int j=0;j<m;j++) {
if(board[i][j]!=c) {
mm[j+n][i]=1;
}
}
}
}
if (!ok) {
break;
}
for(int k=0;k<n+m;k++) {
for(int i=0;i<n+m;i++) {
for(int j=0;j<n+m;j++) {
mm[i][j]=mm[i][k]|mm[k][j];
}
}
}
bool cycle=false;
for(int i=0;i<n+m;i++) {
if(mm[i][i]==1) {
cycle=true;
break;
}
}
if(cycle) {
continue;
}
res=min(res,cur);
}
return res;
}
int ColorfulBoard::theMin(vector<string> board) {
} | [
"yinyinbigdata@gmail.com"
] | yinyinbigdata@gmail.com |
1fd59104c445c259858fb57721dc61ff80e09e73 | 15e71d56deba4504f55c433b823043efd57e915c | /SingleLepton2011/scripts/Hootilities.h | 05d03b8be786b5b993cdab1cd16bab6ca9648580 | [] | no_license | hooberman/UserCode | 3404f24a40d3c499632d31cb8b7b592a734b8a4f | 21c149b84f0064a533c2b092c30f4c412716f300 | refs/heads/master | 2021-01-15T16:16:01.389885 | 2013-06-26T01:28:29 | 2013-06-26T01:28:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 951 | h | #ifndef HOOTILITIES
#define HOOTILITIES
#include "TChain.h"
#include "TLegend.h"
#include "TCut.h"
#include <vector>
void compareDataMC( vector<TChain*> chmc , vector<char*> labels , TChain* chdata , char* var ,
TCut sel , TCut weight , int nbins , float xmin , float xmax , char* xtitle ,
bool overlayData = true , bool residual = false, bool drawLegend = true , bool log = false , char* flavor = "all" );
void printYields( vector<TChain*> chmc , vector<char*> labels , TChain* chdata , TCut sel , TCut weight , bool latex = false );
void initSymbols(bool);
void printLine(bool);
void deleteHistos();
TLegend *getLegend( vector<TChain*> chmc , vector<char*> labels , bool overlayData,
float x1 = 0.55, float y1 = 0.55 , float x2 = 0.95, float y2 = 0.94 );
char* pm;
char* delim;
char* delimstart;
char* delimend;
char* e;
char* m;
int width1;
int width2;
int linelength;
#endif
| [
""
] | |
015d87593807ea5787b8d52a5e504965f11b64b4 | 45b922b56ac0523655eb6cf2885627271798cc88 | /hw7/bst.h | 036e0c28fab11dfa6e04694494255478e381a350 | [] | no_license | timhang/Projects-in-C- | 0f4a049b64de41765565536f326f0b45b13d034a | 45f6cff8a9d3ead7d32486fcd72f93ee55ae6653 | refs/heads/master | 2020-04-22T12:38:09.927172 | 2019-02-12T19:39:29 | 2019-02-12T19:39:29 | 170,378,976 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,604 | h | #ifndef BST_H
#define BST_H
#include <iostream>
#include <exception>
#include <cstdlib>
#include <utility>
/**
* A templated class for a Node in a search tree. The getters for parent/left/right are virtual so that they
* can be overridden for future kinds of search trees, such as Red Black trees, Splay trees, and AVL trees.
*/
template <typename Key, typename Value>
class Node
{
public:
Node(const Key& key, const Value& value, Node<Key, Value>* parent);
virtual ~Node();
const std::pair<const Key, Value>& getItem() const;
std::pair<const Key, Value>& getItem();
const Key& getKey() const;
const Value& getValue() const;
Value& getValue();
virtual Node<Key, Value>* getParent() const;
virtual Node<Key, Value>* getLeft() const;
virtual Node<Key, Value>* getRight() const;
int getHeight() const;
void setParent(Node<Key, Value>* parent);
void setLeft(Node<Key, Value>* left);
void setRight(Node<Key, Value>* right);
void setValue(const Value &value);
void setHeight(int height);
protected:
std::pair<const Key, Value> mItem;
Node<Key, Value>* mParent;
Node<Key, Value>* mLeft;
Node<Key, Value>* mRight;
int mHeight;
};
/*
-----------------------------------------
Begin implementations for the Node class.
-----------------------------------------
*/
/**
* Explicit constructor for a node.
*/
template<typename Key, typename Value>
Node<Key, Value>::Node(const Key& key, const Value& value, Node<Key, Value>* parent)
: mItem(key, value)
, mParent(parent)
, mLeft(NULL)
, mRight(NULL)
, mHeight(1)
{
}
/**
* Destructor, which does not need to do anything since the pointers inside of a node
* are only used as references to existing nodes. The nodes pointed to by parent/left/right
* are freed within the clear() helper method in the BinarySearchTree.
*/
template<typename Key, typename Value>
Node<Key, Value>::~Node()
{
}
/**
* A const getter for the item.
*/
template<typename Key, typename Value>
const std::pair<const Key, Value>& Node<Key, Value>::getItem() const
{
return mItem;
}
/**
* A non-const getter for the item.
*/
template<typename Key, typename Value>
std::pair<const Key, Value>& Node<Key, Value>::getItem()
{
return mItem;
}
/**
* A const getter for the key.
*/
template<typename Key, typename Value>
const Key& Node<Key, Value>::getKey() const
{
return mItem.first;
}
/**
* A const getter for the value.
*/
template<typename Key, typename Value>
const Value& Node<Key, Value>::getValue() const
{
return mItem.second;
}
/**
* A non-const getter for the value.
*/
template<typename Key, typename Value>
Value& Node<Key, Value>::getValue()
{
return mItem.second;
}
/**
* An implementation of the virtual function for retreiving the parent.
*/
template<typename Key, typename Value>
Node<Key, Value>* Node<Key, Value>::getParent() const
{
return mParent;
}
/**
* An implementation of the virtual function for retreiving the left child.
*/
template<typename Key, typename Value>
Node<Key, Value>* Node<Key, Value>::getLeft() const
{
return mLeft;
}
/**
* An implementation of the virtual function for retreiving the right child.
*/
template<typename Key, typename Value>
Node<Key, Value>* Node<Key, Value>::getRight() const
{
return mRight;
}
/**
* A const getter for the height.
*/
template<typename Key, typename Value>
int Node<Key, Value>::getHeight() const
{
return mHeight;
}
/**
* A setter for setting the parent of a node.
*/
template<typename Key, typename Value>
void Node<Key, Value>::setParent(Node<Key, Value>* parent)
{
mParent = parent;
}
/**
* A setter for setting the left child of a node.
*/
template<typename Key, typename Value>
void Node<Key, Value>::setLeft(Node<Key, Value>* left)
{
mLeft = left;
}
/**
* A setter for setting the right child of a node.
*/
template<typename Key, typename Value>
void Node<Key, Value>::setRight(Node<Key, Value>* right)
{
mRight = right;
}
/**
* A setter for the value of a node.
*/
template<typename Key, typename Value>
void Node<Key, Value>::setValue(const Value& value)
{
mItem.second = value;
}
/**
* A setter for the height of a node.
*/
template<typename Key, typename Value>
void Node<Key, Value>::setHeight(int height)
{
mHeight = height;
}
/*
---------------------------------------
End implementations for the Node class.
---------------------------------------
*/
/**
* A templated unbalanced binary search tree.
*/
template <typename Key, typename Value>
class BinarySearchTree
{
public:
BinarySearchTree(); //TODO
virtual ~BinarySearchTree(); //TODO
int height(); //TODO
bool isBalanced(); //TODO
virtual void insert(const std::pair<const Key, Value>& keyValuePair); //TODO
virtual void remove(const Key& key); //TODO
void clear(); //TODO
void print() const;
public:
/**
* An internal iterator class for traversing the contents of the BST.
*/
class iterator
{
public:
iterator(Node<Key,Value>* ptr);
iterator();
std::pair<const Key, Value>& operator*();
std::pair<const Key, Value>* operator->();
bool operator==(const iterator& rhs) const;
bool operator!=(const iterator& rhs) const;
iterator& operator=(const iterator& rhs);
iterator& operator++();
protected:
Node<Key, Value>* mCurrent;
};
public:
iterator begin();
iterator end();
iterator find(const Key& key) const;
protected:
Node<Key, Value>* internalFind(const Key& key) const; //TODO
Node<Key, Value>* getSmallestNode() const; //TODO
void printRoot (Node<Key, Value>* root) const;
protected:
Node<Key, Value>* mRoot;
private:
int heightHelper(Node<Key,Value>* root);
int balanceHelper(Node<Key,Value>* root, bool& result);
Node<Key,Value>* insertHelper(Node<Key,Value>* node,
const std::pair<const Key, Value>& keyValuePair);
void clearHelper(Node<Key,Value>* node);
Node<Key,Value>* removeHelper(Node<Key,Value>* node, const Key& key);
Node<Key,Value>* minHelper(Node<Key,Value>* node) const;
Node<Key, Value>* maxHelper(Node<Key,Value>* node) const;
};
/*
---------------------------------------------------------------
Begin implementations for the BinarySearchTree::iterator class.
---------------------------------------------------------------
*/
/**
* Explicit constructor that initializes an iterator with a given node pointer.
*/
template<typename Key, typename Value>
BinarySearchTree<Key, Value>::iterator::iterator(Node<Key,Value>* ptr)
: mCurrent(ptr)
{
}
/**
* A default constructor that initializes the iterator to NULL.
*/
template<typename Key, typename Value>
BinarySearchTree<Key, Value>::iterator::iterator()
: mCurrent(NULL)
{
}
/**
* Provides access to the item.
*/
template<typename Key, typename Value>
std::pair<const Key, Value>& BinarySearchTree<Key, Value>::iterator::operator*()
{
return mCurrent->getItem();
}
/**
* Provides access to the address of the item.
*/
template<typename Key, typename Value>
std::pair<const Key, Value>* BinarySearchTree<Key, Value>::iterator::operator->()
{
return &(mCurrent->getItem());
}
/**
* Checks if 'this' iterator's internals have the same value
* as 'rhs'
*/
template<typename Key, typename Value>
bool BinarySearchTree<Key, Value>::iterator::operator==(const BinarySearchTree<Key, Value>::iterator& rhs) const
{
return this->mCurrent == rhs.mCurrent;
}
/**
* Checks if 'this' iterator's internals have a different value
* as 'rhs'
*/
template<typename Key, typename Value>
bool BinarySearchTree<Key, Value>::iterator::operator!=(const BinarySearchTree<Key, Value>::iterator& rhs) const
{
return this->mCurrent != rhs.mCurrent;
}
/**
* Sets one iterator equal to another iterator.
*/
template<typename Key, typename Value>
typename BinarySearchTree<Key, Value>::iterator &BinarySearchTree<Key, Value>::iterator::operator=(const BinarySearchTree<Key, Value>::iterator& rhs)
{
this->mCurrent = rhs.mCurrent;
return *this;
}
/**
* Advances the iterator's location using an in-order traversal.
*/
template<typename Key, typename Value>
typename BinarySearchTree<Key, Value>::iterator& BinarySearchTree<Key, Value>::iterator::operator++()
{
if(mCurrent->getRight() != NULL)
{
mCurrent = mCurrent->getRight();
while(mCurrent->getLeft() != NULL)
{
mCurrent = mCurrent->getLeft();
}
}
else if(mCurrent->getRight() == NULL)
{
Node<Key, Value>* parent = mCurrent->getParent();
while(parent != NULL && mCurrent == parent->getRight())
{
mCurrent = parent;
parent = parent->getParent();
}
mCurrent = parent;
}
return *this;
}
/*
-------------------------------------------------------------
End implementations for the BinarySearchTree::iterator class.
-------------------------------------------------------------
*/
/*
-----------------------------------------------------
Begin implementations for the BinarySearchTree class.
-----------------------------------------------------
*/
/**
* Default constructor for a BinarySearchTree, which sets the root to NULL.
*/
template<typename Key, typename Value>
BinarySearchTree<Key, Value>::BinarySearchTree()
{
// TODO
mRoot = NULL;
}
template<typename Key, typename Value>
BinarySearchTree<Key, Value>::~BinarySearchTree()
{
// TODO
clear();
}
template<typename Key, typename Value>
void BinarySearchTree<Key, Value>::print() const
{
printRoot(mRoot);
std::cout << "\n";
}
/**
* Returns an iterator to the "smallest" item in the tree
*/
template<typename Key, typename Value>
typename BinarySearchTree<Key, Value>::iterator BinarySearchTree<Key, Value>::begin()
{
BinarySearchTree<Key, Value>::iterator begin(getSmallestNode());
return begin;
}
/**
* Returns an iterator whose value means INVALID
*/
template<typename Key, typename Value>
typename BinarySearchTree<Key, Value>::iterator BinarySearchTree<Key, Value>::end()
{
BinarySearchTree<Key, Value>::iterator end(NULL);
return end;
}
/**
* Returns an iterator to the item with the given key, k
* or the end iterator if k does not exist in the tree
*/
template<typename Key, typename Value>
typename BinarySearchTree<Key, Value>::iterator BinarySearchTree<Key, Value>::find(const Key& key) const
{
Node<Key, Value>* curr = internalFind(key);
BinarySearchTree<Key, Value>::iterator it(curr);
return it;
}
/**
* An method to return the height of the BST.
*/
//recursive helper function to find height
template<typename Key, typename Value>
int BinarySearchTree<Key, Value>::heightHelper(Node<Key,Value>* root){
if (root==NULL){
return 0;
}
int left = heightHelper(root->getLeft());
int right = heightHelper(root->getRight());
return std::max(left,right)+1;
}
template<typename Key, typename Value>
int BinarySearchTree<Key, Value>::height()
{
// TODO
int result;
result = heightHelper(mRoot);
return result;
}
/**
* An method to checks if the BST is balanced. This method returns true if and only if the BST is balanced.
*/
template<typename Key, typename Value>
bool BinarySearchTree<Key, Value>::isBalanced()
{
// TODO
bool result = true;
balanceHelper(mRoot,result);
return result;
}
//Recursive helper function to check balance
template<typename Key, typename Value>
int BinarySearchTree<Key, Value>::balanceHelper(Node<Key,Value>* root, bool& result){
if(root==NULL){return 0;}
int left = balanceHelper(root->getLeft(),result);
int right = balanceHelper(root->getRight(),result);
if(std::abs(left-right)>1)
return false;
return std::max(left,right)+1;
}
/**
* An insert method to insert into a Binary Search Tree. The tree will not remain balanced when
* inserting.
*/
template<typename Key, typename Value>
void BinarySearchTree<Key, Value>::insert(const std::pair<const Key, Value>& keyValuePair)
{
// TODO
mRoot = insertHelper(mRoot,keyValuePair);
}
template<typename Key, typename Value>
Node<Key,Value>* BinarySearchTree<Key,Value>::insertHelper(Node<Key,Value>* node,
const std::pair<const Key, Value>& keyValuePair){
// TODO
// Feel free to modify any return values or parameters.
// You can also choose to do your work in insert() instead.
if(node==NULL){
Node<Key,Value>* temp_node = new Node<Key,Value>(keyValuePair.first,
keyValuePair.second,NULL);
//return temp_node;
node = temp_node;
}
else if(keyValuePair.first < node->getKey()){
node->setLeft(insertHelper(node->getLeft(),keyValuePair));
}
else if(keyValuePair.first > node->getKey())
node->setRight(insertHelper(node->getRight(),keyValuePair));
//return new Item<T>();
//if value in the tree then don't add, if not then add
return node;
}
/**
* An remove method to remove a specific key from a Binary Search Tree. The tree may not remain balanced after
* removal.
*/
template<typename Key, typename Value>
Node<Key, Value>* BinarySearchTree<Key, Value>::maxHelper(Node<Key,Value>* node) const
{
// TODO
Node<Key,Value>* curr = node;
/* loop down to find the right most leaf */
while (curr->getRight() != NULL)
curr = curr->getRight();
return curr;
}
template<typename Key, typename Value>
Node<Key,Value>* BinarySearchTree<Key,Value>::removeHelper(Node<Key,Value>* root,const Key& key)
{
// base case
if (root == NULL) return root;
// If the key to be deleted is smaller than the root's key,
if (key < root->getKey())
root->setLeft(removeHelper(root->getLeft(), key));
// If the key to be deleted is greater than the root's key,
else if (key > root->getKey())
root->setRight(removeHelper(root->getRight(), key));
// if key is same as root's key, then This is the node
// to be deleted
else
{
// node with only one child or no child
if (root->getLeft() == NULL)
{
Node<Key,Value>* temp = root->getRight();
delete root;
return temp;
}
else if (root->getRight() == NULL)
{
Node<Key,Value> *temp = root->getLeft();
delete root;
return temp;
}
// node with two children: Get the inorder successor (smallest
// in the right subtree)
else{
Node<Key,Value>* temp = maxHelper(root->getLeft());
// Copy the inorder predecessor's content to this node
//root->setKey(temp->getKey());
root->setLeft(removeHelper(root->getLeft(), temp->getKey()));
}
}
return root;
}
template<typename Key, typename Value>
void BinarySearchTree<Key, Value>::remove(const Key& key)
{
// TODO
removeHelper(mRoot,key);
}
/**
* A method to remove all contents of the tree and reset the values in the tree
* for use again.
*/
template<typename Key, typename Value>
void BinarySearchTree<Key, Value>::clearHelper(Node<Key,Value>* node)
{
if (node == NULL) return;
/* first delete both subtrees */
clearHelper(node->getLeft());
clearHelper(node->getRight());
/* then delete the node */
delete node;
}
template<typename Key, typename Value>
void BinarySearchTree<Key, Value>::clear()
{
// TODO
clearHelper(mRoot);
//delete mRoot;
}
/**
* A helper function to find the smallest node in the tree.
*/
template<typename Key, typename Value>
Node<Key, Value>* BinarySearchTree<Key, Value>::minHelper(Node<Key,Value>* node) const
{
// TODO
Node<Key,Value>* curr = node;
/* loop down to find the leftmost leaf */
while (curr->getLeft() != NULL)
curr = curr->getLeft();
return curr;
}
template<typename Key, typename Value>
Node<Key, Value>* BinarySearchTree<Key, Value>::getSmallestNode() const
{
// TODO
Node<Key,Value>* result = minHelper(mRoot);
return result;
}
/**
* Helper function to find a node with given key, k and
* return a pointer to it or NULL if no item with that key
* exists
*/
template<typename Key, typename Value>
Node<Key, Value>* BinarySearchTree<Key, Value>::internalFind(const Key& key) const
{
// TODO
Node<Key,Value>* curr = mRoot;
while(curr!=NULL){
if(key==curr->getKey()){
return curr;
}
if(key < curr->getKey())
curr = curr->getLeft();
else
curr = curr->getRight();
}
return curr;
}
/**
* Helper function to print the tree's contents
*/
template<typename Key, typename Value>
void BinarySearchTree<Key, Value>::printRoot (Node<Key, Value>* root) const
{
if (root != NULL)
{
std::cout << "[";
printRoot (root->getLeft());
std::cout << " (" << root->getKey() << ", " << root->getValue() << ") ";
printRoot (root->getRight());
std::cout << "]";
}
}
/*
---------------------------------------------------
End implementations for the BinarySearchTree class.
---------------------------------------------------
*/
#endif
| [
"weihangz@usc.edu"
] | weihangz@usc.edu |
20896a69a27b9c4fcf5a098923640bafa55757d4 | 95caaab452ee711095c21b726ab7b8fdfb1398c7 | /project4/inc/ddk/softehciif.h | c3a6e3df37ce2b13fb356babfe0833767a96c7e1 | [] | no_license | derfsubterfuge/CSE451 | 496cdee60d1c4328d53f17f5e05c8fe7f62639e2 | eed11316894489f77888a8a28d8ebfd1e0c70033 | refs/heads/master | 2020-04-11T10:38:11.810400 | 2013-03-06T10:23:05 | 2013-03-06T10:23:05 | 7,844,971 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 39,095 | h |
/* this ALWAYS GENERATED file contains the definitions for the interfaces */
/* File created by MIDL compiler version 7.00.0499 */
/* Compiler settings for softehciif.idl:
Oicf, W1, Zp8, env=Win32 (32b run)
protocol : dce , ms_ext, c_ext, robust
error checks: allocation ref bounds_check enum stub_data
VC __declspec() decoration level:
__declspec(uuid()), __declspec(selectany), __declspec(novtable)
DECLSPEC_UUID(), MIDL_INTERFACE()
*/
//@@MIDL_FILE_HEADING( )
#pragma warning( disable: 4049 ) /* more than 64k source lines */
/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 500
#endif
/* verify that the <rpcsal.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCSAL_H_VERSION__
#define __REQUIRED_RPCSAL_H_VERSION__ 100
#endif
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif // __RPCNDR_H_VERSION__
#ifndef __softehciif_h__
#define __softehciif_h__
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif
/* Forward Declarations */
#ifndef __ISoftEHCI_FWD_DEFINED__
#define __ISoftEHCI_FWD_DEFINED__
typedef interface ISoftEHCI ISoftEHCI;
#endif /* __ISoftEHCI_FWD_DEFINED__ */
#ifndef __SoftEHCI_FWD_DEFINED__
#define __SoftEHCI_FWD_DEFINED__
#ifdef __cplusplus
typedef class SoftEHCI SoftEHCI;
#else
typedef struct SoftEHCI SoftEHCI;
#endif /* __cplusplus */
#endif /* __SoftEHCI_FWD_DEFINED__ */
#ifndef __ISoftEHCICtrlr_FWD_DEFINED__
#define __ISoftEHCICtrlr_FWD_DEFINED__
typedef interface ISoftEHCICtrlr ISoftEHCICtrlr;
#endif /* __ISoftEHCICtrlr_FWD_DEFINED__ */
#ifndef __SoftEHCICtrlr_FWD_DEFINED__
#define __SoftEHCICtrlr_FWD_DEFINED__
#ifdef __cplusplus
typedef class SoftEHCICtrlr SoftEHCICtrlr;
#else
typedef struct SoftEHCICtrlr SoftEHCICtrlr;
#endif /* __cplusplus */
#endif /* __SoftEHCICtrlr_FWD_DEFINED__ */
#ifndef __ISoftEHCIRootHubPorts_FWD_DEFINED__
#define __ISoftEHCIRootHubPorts_FWD_DEFINED__
typedef interface ISoftEHCIRootHubPorts ISoftEHCIRootHubPorts;
#endif /* __ISoftEHCIRootHubPorts_FWD_DEFINED__ */
#ifndef __SoftEHCIRootHubPorts_FWD_DEFINED__
#define __SoftEHCIRootHubPorts_FWD_DEFINED__
#ifdef __cplusplus
typedef class SoftEHCIRootHubPorts SoftEHCIRootHubPorts;
#else
typedef struct SoftEHCIRootHubPorts SoftEHCIRootHubPorts;
#endif /* __cplusplus */
#endif /* __SoftEHCIRootHubPorts_FWD_DEFINED__ */
#ifndef __ISoftEHCIRootHubPort_FWD_DEFINED__
#define __ISoftEHCIRootHubPort_FWD_DEFINED__
typedef interface ISoftEHCIRootHubPort ISoftEHCIRootHubPort;
#endif /* __ISoftEHCIRootHubPort_FWD_DEFINED__ */
#ifndef __SoftEHCIRootHubPort_FWD_DEFINED__
#define __SoftEHCIRootHubPort_FWD_DEFINED__
#ifdef __cplusplus
typedef class SoftEHCIRootHubPort SoftEHCIRootHubPort;
#else
typedef struct SoftEHCIRootHubPort SoftEHCIRootHubPort;
#endif /* __cplusplus */
#endif /* __SoftEHCIRootHubPort_FWD_DEFINED__ */
#ifdef __cplusplus
extern "C"{
#endif
#ifndef __SoftEHCI_LIBRARY_DEFINED__
#define __SoftEHCI_LIBRARY_DEFINED__
/* library SoftEHCI */
/* [helpstringcontext][helpcontext][helpstring][version][lcid][uuid] */
typedef /* [helpstringcontext][helpcontext][helpstring][uuid] */ DECLSPEC_UUID("01647E9C-2B10-4620-BE92-758093F3C31A")
enum EHCIRootHubIndicator
{ EHCIRootHubOff = 0,
EHCIRootHubAmber = 1,
EHCIRootHubGreen = 2,
EHCIRootHubUndefined = 3
} EHCIRootHubIndicator;
EXTERN_C const IID LIBID_SoftEHCI;
#ifndef __ISoftEHCI_INTERFACE_DEFINED__
#define __ISoftEHCI_INTERFACE_DEFINED__
/* interface ISoftEHCI */
/* [object][helpstring][hidden][nonextensible][oleautomation][dual][uuid] */
EXTERN_C const IID IID_ISoftEHCI;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("E99BC1D0-088B-4bd2-AE94-6DA3F2861FA2")
ISoftEHCI : public IDispatch
{
public:
};
#else /* C style interface */
typedef struct ISoftEHCIVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ISoftEHCI * This,
/* [in] */ __RPC__in REFIID riid,
/* [iid_is][out] */
__RPC__deref_out void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ISoftEHCI * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ISoftEHCI * This);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )(
ISoftEHCI * This,
/* [out] */ __RPC__out UINT *pctinfo);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
ISoftEHCI * This,
/* [in] */ UINT iTInfo,
/* [in] */ LCID lcid,
/* [out] */ __RPC__deref_out_opt ITypeInfo **ppTInfo);
HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )(
ISoftEHCI * This,
/* [in] */ __RPC__in REFIID riid,
/* [size_is][in] */ __RPC__in_ecount_full(cNames) LPOLESTR *rgszNames,
/* [range][in] */ UINT cNames,
/* [in] */ LCID lcid,
/* [size_is][out] */ __RPC__out_ecount_full(cNames) DISPID *rgDispId);
/* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )(
ISoftEHCI * This,
/* [in] */ DISPID dispIdMember,
/* [in] */ REFIID riid,
/* [in] */ LCID lcid,
/* [in] */ WORD wFlags,
/* [out][in] */ DISPPARAMS *pDispParams,
/* [out] */ VARIANT *pVarResult,
/* [out] */ EXCEPINFO *pExcepInfo,
/* [out] */ UINT *puArgErr);
END_INTERFACE
} ISoftEHCIVtbl;
interface ISoftEHCI
{
CONST_VTBL struct ISoftEHCIVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ISoftEHCI_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ISoftEHCI_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ISoftEHCI_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ISoftEHCI_GetTypeInfoCount(This,pctinfo) \
( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) )
#define ISoftEHCI_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \
( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) )
#define ISoftEHCI_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \
( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) )
#define ISoftEHCI_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \
( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ISoftEHCI_INTERFACE_DEFINED__ */
EXTERN_C const CLSID CLSID_SoftEHCI;
#ifdef __cplusplus
class DECLSPEC_UUID("3676BB7A-1618-4bfc-855C-63C92FD54ACD")
SoftEHCI;
#endif
#ifndef __ISoftEHCICtrlr_INTERFACE_DEFINED__
#define __ISoftEHCICtrlr_INTERFACE_DEFINED__
/* interface ISoftEHCICtrlr */
/* [helpstringcontext][helpcontext][helpstring][object][hidden][nonextensible][oleautomation][dual][uuid] */
EXTERN_C const IID IID_ISoftEHCICtrlr;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("16017C34-A2BA-480B-8DE8-CD08756AD1F8")
ISoftEHCICtrlr : public IDispatch
{
public:
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Ports(
/* [retval][out] */ __RPC__deref_out_opt SoftEHCIRootHubPorts **ppPorts) = 0;
};
#else /* C style interface */
typedef struct ISoftEHCICtrlrVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ISoftEHCICtrlr * This,
/* [in] */ __RPC__in REFIID riid,
/* [iid_is][out] */
__RPC__deref_out void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ISoftEHCICtrlr * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ISoftEHCICtrlr * This);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )(
ISoftEHCICtrlr * This,
/* [out] */ __RPC__out UINT *pctinfo);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
ISoftEHCICtrlr * This,
/* [in] */ UINT iTInfo,
/* [in] */ LCID lcid,
/* [out] */ __RPC__deref_out_opt ITypeInfo **ppTInfo);
HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )(
ISoftEHCICtrlr * This,
/* [in] */ __RPC__in REFIID riid,
/* [size_is][in] */ __RPC__in_ecount_full(cNames) LPOLESTR *rgszNames,
/* [range][in] */ UINT cNames,
/* [in] */ LCID lcid,
/* [size_is][out] */ __RPC__out_ecount_full(cNames) DISPID *rgDispId);
/* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )(
ISoftEHCICtrlr * This,
/* [in] */ DISPID dispIdMember,
/* [in] */ REFIID riid,
/* [in] */ LCID lcid,
/* [in] */ WORD wFlags,
/* [out][in] */ DISPPARAMS *pDispParams,
/* [out] */ VARIANT *pVarResult,
/* [out] */ EXCEPINFO *pExcepInfo,
/* [out] */ UINT *puArgErr);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Ports )(
ISoftEHCICtrlr * This,
/* [retval][out] */ __RPC__deref_out_opt SoftEHCIRootHubPorts **ppPorts);
END_INTERFACE
} ISoftEHCICtrlrVtbl;
interface ISoftEHCICtrlr
{
CONST_VTBL struct ISoftEHCICtrlrVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ISoftEHCICtrlr_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ISoftEHCICtrlr_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ISoftEHCICtrlr_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ISoftEHCICtrlr_GetTypeInfoCount(This,pctinfo) \
( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) )
#define ISoftEHCICtrlr_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \
( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) )
#define ISoftEHCICtrlr_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \
( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) )
#define ISoftEHCICtrlr_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \
( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) )
#define ISoftEHCICtrlr_get_Ports(This,ppPorts) \
( (This)->lpVtbl -> get_Ports(This,ppPorts) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ISoftEHCICtrlr_INTERFACE_DEFINED__ */
EXTERN_C const CLSID CLSID_SoftEHCICtrlr;
#ifdef __cplusplus
class DECLSPEC_UUID("C2B7819E-632F-4ADD-A450-62E6F324DC70")
SoftEHCICtrlr;
#endif
#ifndef __ISoftEHCIRootHubPorts_INTERFACE_DEFINED__
#define __ISoftEHCIRootHubPorts_INTERFACE_DEFINED__
/* interface ISoftEHCIRootHubPorts */
/* [helpstringcontext][helpcontext][helpstring][object][hidden][nonextensible][oleautomation][dual][uuid] */
EXTERN_C const IID IID_ISoftEHCIRootHubPorts;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("8202B252-20C9-47A1-9448-B8621D985CA1")
ISoftEHCIRootHubPorts : public IDispatch
{
public:
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Count(
/* [retval][out] */ __RPC__out long *plCount) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Item(
/* [in] */ VARIANT Index,
/* [retval][out] */ __RPC__deref_out_opt SoftEHCIRootHubPort **ppSoftEHCIRootHubPort) = 0;
virtual /* [hidden][propget][id] */ HRESULT __stdcall get__NewEnum(
/* [retval][out] */ __RPC__deref_out_opt IUnknown **ppunkEnum) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT __stdcall Add(
/* [in] */ __RPC__in SoftEHCIRootHubPort *ppSoftEHCIRootHubPort,
/* [optional][in] */ VARIANT Index) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT __stdcall Remove(
/* [in] */ VARIANT Index) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT __stdcall Clear( void) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT __stdcall Lock( void) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT __stdcall Unlock( void) = 0;
};
#else /* C style interface */
typedef struct ISoftEHCIRootHubPortsVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ISoftEHCIRootHubPorts * This,
/* [in] */ __RPC__in REFIID riid,
/* [iid_is][out] */
__RPC__deref_out void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ISoftEHCIRootHubPorts * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ISoftEHCIRootHubPorts * This);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )(
ISoftEHCIRootHubPorts * This,
/* [out] */ __RPC__out UINT *pctinfo);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
ISoftEHCIRootHubPorts * This,
/* [in] */ UINT iTInfo,
/* [in] */ LCID lcid,
/* [out] */ __RPC__deref_out_opt ITypeInfo **ppTInfo);
HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )(
ISoftEHCIRootHubPorts * This,
/* [in] */ __RPC__in REFIID riid,
/* [size_is][in] */ __RPC__in_ecount_full(cNames) LPOLESTR *rgszNames,
/* [range][in] */ UINT cNames,
/* [in] */ LCID lcid,
/* [size_is][out] */ __RPC__out_ecount_full(cNames) DISPID *rgDispId);
/* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )(
ISoftEHCIRootHubPorts * This,
/* [in] */ DISPID dispIdMember,
/* [in] */ REFIID riid,
/* [in] */ LCID lcid,
/* [in] */ WORD wFlags,
/* [out][in] */ DISPPARAMS *pDispParams,
/* [out] */ VARIANT *pVarResult,
/* [out] */ EXCEPINFO *pExcepInfo,
/* [out] */ UINT *puArgErr);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Count )(
ISoftEHCIRootHubPorts * This,
/* [retval][out] */ __RPC__out long *plCount);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Item )(
ISoftEHCIRootHubPorts * This,
/* [in] */ VARIANT Index,
/* [retval][out] */ __RPC__deref_out_opt SoftEHCIRootHubPort **ppSoftEHCIRootHubPort);
/* [hidden][propget][id] */ HRESULT ( __stdcall *get__NewEnum )(
ISoftEHCIRootHubPorts * This,
/* [retval][out] */ __RPC__deref_out_opt IUnknown **ppunkEnum);
/* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT ( __stdcall *Add )(
ISoftEHCIRootHubPorts * This,
/* [in] */ __RPC__in SoftEHCIRootHubPort *ppSoftEHCIRootHubPort,
/* [optional][in] */ VARIANT Index);
/* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT ( __stdcall *Remove )(
ISoftEHCIRootHubPorts * This,
/* [in] */ VARIANT Index);
/* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT ( __stdcall *Clear )(
ISoftEHCIRootHubPorts * This);
/* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT ( __stdcall *Lock )(
ISoftEHCIRootHubPorts * This);
/* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT ( __stdcall *Unlock )(
ISoftEHCIRootHubPorts * This);
END_INTERFACE
} ISoftEHCIRootHubPortsVtbl;
interface ISoftEHCIRootHubPorts
{
CONST_VTBL struct ISoftEHCIRootHubPortsVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ISoftEHCIRootHubPorts_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ISoftEHCIRootHubPorts_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ISoftEHCIRootHubPorts_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ISoftEHCIRootHubPorts_GetTypeInfoCount(This,pctinfo) \
( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) )
#define ISoftEHCIRootHubPorts_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \
( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) )
#define ISoftEHCIRootHubPorts_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \
( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) )
#define ISoftEHCIRootHubPorts_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \
( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) )
#define ISoftEHCIRootHubPorts_get_Count(This,plCount) \
( (This)->lpVtbl -> get_Count(This,plCount) )
#define ISoftEHCIRootHubPorts_get_Item(This,Index,ppSoftEHCIRootHubPort) \
( (This)->lpVtbl -> get_Item(This,Index,ppSoftEHCIRootHubPort) )
#define ISoftEHCIRootHubPorts_get__NewEnum(This,ppunkEnum) \
( (This)->lpVtbl -> get__NewEnum(This,ppunkEnum) )
#define ISoftEHCIRootHubPorts_Add(This,ppSoftEHCIRootHubPort,Index) \
( (This)->lpVtbl -> Add(This,ppSoftEHCIRootHubPort,Index) )
#define ISoftEHCIRootHubPorts_Remove(This,Index) \
( (This)->lpVtbl -> Remove(This,Index) )
#define ISoftEHCIRootHubPorts_Clear(This) \
( (This)->lpVtbl -> Clear(This) )
#define ISoftEHCIRootHubPorts_Lock(This) \
( (This)->lpVtbl -> Lock(This) )
#define ISoftEHCIRootHubPorts_Unlock(This) \
( (This)->lpVtbl -> Unlock(This) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ISoftEHCIRootHubPorts_INTERFACE_DEFINED__ */
EXTERN_C const CLSID CLSID_SoftEHCIRootHubPorts;
#ifdef __cplusplus
class DECLSPEC_UUID("00DC66FB-A2E1-4BF9-9E6C-C3A1A60130EC")
SoftEHCIRootHubPorts;
#endif
#ifndef __ISoftEHCIRootHubPort_INTERFACE_DEFINED__
#define __ISoftEHCIRootHubPort_INTERFACE_DEFINED__
/* interface ISoftEHCIRootHubPort */
/* [helpstringcontext][helpcontext][helpstring][object][hidden][nonextensible][oleautomation][dual][uuid] */
EXTERN_C const IID IID_ISoftEHCIRootHubPort;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("9A80EBED-8173-4417-9830-405EF2F0167A")
ISoftEHCIRootHubPort : public IDispatch
{
public:
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_WakeOnOverCurrentEnable(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarWake) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_WakeOnDisconnectEnable(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarWake) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_WakeOnConnectEnable(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarWake) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_TestCtrl(
/* [retval][out] */ __RPC__out BYTE *pbTestCtrl) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Indicator(
/* [retval][out] */ __RPC__out EHCIRootHubIndicator *pIndicator) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Owner(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarOwner) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Power(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarPower) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT __stdcall put_Power(
/* [in] */ VARIANT_BOOL fvarPower) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_LineStatus(
/* [retval][out] */ __RPC__out BYTE *pbLineStatus) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT __stdcall put_LineStatus(
/* [in] */ BYTE bLineStatus) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Reset(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarReset) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Suspend(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarSuspend) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT __stdcall put_Suspend(
/* [in] */ VARIANT_BOOL fvarSuspend) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_ForcePortResume(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarForcePortResume) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT __stdcall put_ForcePortResume(
/* [in] */ VARIANT_BOOL fvarForcePortResume) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_OverCurrentChange(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarOverCurrentChange) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT __stdcall put_OverCurrentChange(
/* [in] */ VARIANT_BOOL fvarOverCurrentChange) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_OverCurrent(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarOverCurrent) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT __stdcall put_OverCurrent(
/* [in] */ VARIANT_BOOL fvarOverCurrent) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_EnableChange(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarEnableChange) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT __stdcall put_EnableChange(
/* [in] */ VARIANT_BOOL fvarEnableChange) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Enabled(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarEnabled) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT __stdcall put_Enabled(
/* [in] */ VARIANT_BOOL fvarEnabled) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_ConnectStatusChange(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarConnectStatusChange) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT __stdcall put_ConnectStatusChange(
/* [in] */ VARIANT_BOOL fvarConnectStatusChange) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_CurrentConnectStatus(
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarStatus) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Status(
/* [retval][out] */ __RPC__out long *plStatus) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT __stdcall get_Device(
/* [retval][out] */ __RPC__deref_out_opt /* external definition not present */ DSFDevice **ppDSFDevice) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT __stdcall HotPlug(
/* [in] */ __RPC__in /* external definition not present */ SoftUSBDevice *pDSFDevice) = 0;
virtual /* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT __stdcall Unplug( void) = 0;
};
#else /* C style interface */
typedef struct ISoftEHCIRootHubPortVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ISoftEHCIRootHubPort * This,
/* [in] */ __RPC__in REFIID riid,
/* [iid_is][out] */
__RPC__deref_out void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ISoftEHCIRootHubPort * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ISoftEHCIRootHubPort * This);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )(
ISoftEHCIRootHubPort * This,
/* [out] */ __RPC__out UINT *pctinfo);
HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
ISoftEHCIRootHubPort * This,
/* [in] */ UINT iTInfo,
/* [in] */ LCID lcid,
/* [out] */ __RPC__deref_out_opt ITypeInfo **ppTInfo);
HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )(
ISoftEHCIRootHubPort * This,
/* [in] */ __RPC__in REFIID riid,
/* [size_is][in] */ __RPC__in_ecount_full(cNames) LPOLESTR *rgszNames,
/* [range][in] */ UINT cNames,
/* [in] */ LCID lcid,
/* [size_is][out] */ __RPC__out_ecount_full(cNames) DISPID *rgDispId);
/* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )(
ISoftEHCIRootHubPort * This,
/* [in] */ DISPID dispIdMember,
/* [in] */ REFIID riid,
/* [in] */ LCID lcid,
/* [in] */ WORD wFlags,
/* [out][in] */ DISPPARAMS *pDispParams,
/* [out] */ VARIANT *pVarResult,
/* [out] */ EXCEPINFO *pExcepInfo,
/* [out] */ UINT *puArgErr);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_WakeOnOverCurrentEnable )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarWake);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_WakeOnDisconnectEnable )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarWake);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_WakeOnConnectEnable )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarWake);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_TestCtrl )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out BYTE *pbTestCtrl);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Indicator )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out EHCIRootHubIndicator *pIndicator);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Owner )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarOwner);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Power )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarPower);
/* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT ( __stdcall *put_Power )(
ISoftEHCIRootHubPort * This,
/* [in] */ VARIANT_BOOL fvarPower);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_LineStatus )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out BYTE *pbLineStatus);
/* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT ( __stdcall *put_LineStatus )(
ISoftEHCIRootHubPort * This,
/* [in] */ BYTE bLineStatus);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Reset )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarReset);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Suspend )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarSuspend);
/* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT ( __stdcall *put_Suspend )(
ISoftEHCIRootHubPort * This,
/* [in] */ VARIANT_BOOL fvarSuspend);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_ForcePortResume )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarForcePortResume);
/* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT ( __stdcall *put_ForcePortResume )(
ISoftEHCIRootHubPort * This,
/* [in] */ VARIANT_BOOL fvarForcePortResume);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_OverCurrentChange )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarOverCurrentChange);
/* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT ( __stdcall *put_OverCurrentChange )(
ISoftEHCIRootHubPort * This,
/* [in] */ VARIANT_BOOL fvarOverCurrentChange);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_OverCurrent )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarOverCurrent);
/* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT ( __stdcall *put_OverCurrent )(
ISoftEHCIRootHubPort * This,
/* [in] */ VARIANT_BOOL fvarOverCurrent);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_EnableChange )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarEnableChange);
/* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT ( __stdcall *put_EnableChange )(
ISoftEHCIRootHubPort * This,
/* [in] */ VARIANT_BOOL fvarEnableChange);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Enabled )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarEnabled);
/* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT ( __stdcall *put_Enabled )(
ISoftEHCIRootHubPort * This,
/* [in] */ VARIANT_BOOL fvarEnabled);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_ConnectStatusChange )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarConnectStatusChange);
/* [helpstringcontext][helpcontext][helpstring][propput][id] */ HRESULT ( __stdcall *put_ConnectStatusChange )(
ISoftEHCIRootHubPort * This,
/* [in] */ VARIANT_BOOL fvarConnectStatusChange);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_CurrentConnectStatus )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out VARIANT_BOOL *pfvarStatus);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Status )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__out long *plStatus);
/* [helpstringcontext][helpcontext][helpstring][propget][id] */ HRESULT ( __stdcall *get_Device )(
ISoftEHCIRootHubPort * This,
/* [retval][out] */ __RPC__deref_out_opt /* external definition not present */ DSFDevice **ppDSFDevice);
/* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT ( __stdcall *HotPlug )(
ISoftEHCIRootHubPort * This,
/* [in] */ __RPC__in /* external definition not present */ SoftUSBDevice *pDSFDevice);
/* [helpstringcontext][helpcontext][helpstring][id] */ HRESULT ( __stdcall *Unplug )(
ISoftEHCIRootHubPort * This);
END_INTERFACE
} ISoftEHCIRootHubPortVtbl;
interface ISoftEHCIRootHubPort
{
CONST_VTBL struct ISoftEHCIRootHubPortVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ISoftEHCIRootHubPort_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ISoftEHCIRootHubPort_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ISoftEHCIRootHubPort_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ISoftEHCIRootHubPort_GetTypeInfoCount(This,pctinfo) \
( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) )
#define ISoftEHCIRootHubPort_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \
( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) )
#define ISoftEHCIRootHubPort_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \
( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) )
#define ISoftEHCIRootHubPort_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \
( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) )
#define ISoftEHCIRootHubPort_get_WakeOnOverCurrentEnable(This,pfvarWake) \
( (This)->lpVtbl -> get_WakeOnOverCurrentEnable(This,pfvarWake) )
#define ISoftEHCIRootHubPort_get_WakeOnDisconnectEnable(This,pfvarWake) \
( (This)->lpVtbl -> get_WakeOnDisconnectEnable(This,pfvarWake) )
#define ISoftEHCIRootHubPort_get_WakeOnConnectEnable(This,pfvarWake) \
( (This)->lpVtbl -> get_WakeOnConnectEnable(This,pfvarWake) )
#define ISoftEHCIRootHubPort_get_TestCtrl(This,pbTestCtrl) \
( (This)->lpVtbl -> get_TestCtrl(This,pbTestCtrl) )
#define ISoftEHCIRootHubPort_get_Indicator(This,pIndicator) \
( (This)->lpVtbl -> get_Indicator(This,pIndicator) )
#define ISoftEHCIRootHubPort_get_Owner(This,pfvarOwner) \
( (This)->lpVtbl -> get_Owner(This,pfvarOwner) )
#define ISoftEHCIRootHubPort_get_Power(This,pfvarPower) \
( (This)->lpVtbl -> get_Power(This,pfvarPower) )
#define ISoftEHCIRootHubPort_put_Power(This,fvarPower) \
( (This)->lpVtbl -> put_Power(This,fvarPower) )
#define ISoftEHCIRootHubPort_get_LineStatus(This,pbLineStatus) \
( (This)->lpVtbl -> get_LineStatus(This,pbLineStatus) )
#define ISoftEHCIRootHubPort_put_LineStatus(This,bLineStatus) \
( (This)->lpVtbl -> put_LineStatus(This,bLineStatus) )
#define ISoftEHCIRootHubPort_get_Reset(This,pfvarReset) \
( (This)->lpVtbl -> get_Reset(This,pfvarReset) )
#define ISoftEHCIRootHubPort_get_Suspend(This,pfvarSuspend) \
( (This)->lpVtbl -> get_Suspend(This,pfvarSuspend) )
#define ISoftEHCIRootHubPort_put_Suspend(This,fvarSuspend) \
( (This)->lpVtbl -> put_Suspend(This,fvarSuspend) )
#define ISoftEHCIRootHubPort_get_ForcePortResume(This,pfvarForcePortResume) \
( (This)->lpVtbl -> get_ForcePortResume(This,pfvarForcePortResume) )
#define ISoftEHCIRootHubPort_put_ForcePortResume(This,fvarForcePortResume) \
( (This)->lpVtbl -> put_ForcePortResume(This,fvarForcePortResume) )
#define ISoftEHCIRootHubPort_get_OverCurrentChange(This,pfvarOverCurrentChange) \
( (This)->lpVtbl -> get_OverCurrentChange(This,pfvarOverCurrentChange) )
#define ISoftEHCIRootHubPort_put_OverCurrentChange(This,fvarOverCurrentChange) \
( (This)->lpVtbl -> put_OverCurrentChange(This,fvarOverCurrentChange) )
#define ISoftEHCIRootHubPort_get_OverCurrent(This,pfvarOverCurrent) \
( (This)->lpVtbl -> get_OverCurrent(This,pfvarOverCurrent) )
#define ISoftEHCIRootHubPort_put_OverCurrent(This,fvarOverCurrent) \
( (This)->lpVtbl -> put_OverCurrent(This,fvarOverCurrent) )
#define ISoftEHCIRootHubPort_get_EnableChange(This,pfvarEnableChange) \
( (This)->lpVtbl -> get_EnableChange(This,pfvarEnableChange) )
#define ISoftEHCIRootHubPort_put_EnableChange(This,fvarEnableChange) \
( (This)->lpVtbl -> put_EnableChange(This,fvarEnableChange) )
#define ISoftEHCIRootHubPort_get_Enabled(This,pfvarEnabled) \
( (This)->lpVtbl -> get_Enabled(This,pfvarEnabled) )
#define ISoftEHCIRootHubPort_put_Enabled(This,fvarEnabled) \
( (This)->lpVtbl -> put_Enabled(This,fvarEnabled) )
#define ISoftEHCIRootHubPort_get_ConnectStatusChange(This,pfvarConnectStatusChange) \
( (This)->lpVtbl -> get_ConnectStatusChange(This,pfvarConnectStatusChange) )
#define ISoftEHCIRootHubPort_put_ConnectStatusChange(This,fvarConnectStatusChange) \
( (This)->lpVtbl -> put_ConnectStatusChange(This,fvarConnectStatusChange) )
#define ISoftEHCIRootHubPort_get_CurrentConnectStatus(This,pfvarStatus) \
( (This)->lpVtbl -> get_CurrentConnectStatus(This,pfvarStatus) )
#define ISoftEHCIRootHubPort_get_Status(This,plStatus) \
( (This)->lpVtbl -> get_Status(This,plStatus) )
#define ISoftEHCIRootHubPort_get_Device(This,ppDSFDevice) \
( (This)->lpVtbl -> get_Device(This,ppDSFDevice) )
#define ISoftEHCIRootHubPort_HotPlug(This,pDSFDevice) \
( (This)->lpVtbl -> HotPlug(This,pDSFDevice) )
#define ISoftEHCIRootHubPort_Unplug(This) \
( (This)->lpVtbl -> Unplug(This) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ISoftEHCIRootHubPort_INTERFACE_DEFINED__ */
EXTERN_C const CLSID CLSID_SoftEHCIRootHubPort;
#ifdef __cplusplus
class DECLSPEC_UUID("6FD5902A-DC5A-4AB4-B9B0-B44D70930C9B")
SoftEHCIRootHubPort;
#endif
#endif /* __SoftEHCI_LIBRARY_DEFINED__ */
/* Additional Prototypes for ALL interfaces */
/* end of Additional Prototypes */
#ifdef __cplusplus
}
#endif
#endif
| [
"tolth@tolth-HP.(none)"
] | tolth@tolth-HP.(none) |
c1d4d0c9f8e659ef7ecd41c4dfac4d04913f4f07 | 9e7ad483c200103985868a13e19d7d6758527927 | /SpaceShipCaptaincpp.cpp | e07db088592aa249bbffa7a9d54aee283506b5fa | [] | no_license | smithj16/GameObject | 7cb5a1cebb7b6138071e543c88ab1efa6f110d91 | d1085197b62697bedd17f5b0f31772a27aeadaff | refs/heads/master | 2020-08-02T16:16:42.579420 | 2019-09-28T01:18:45 | 2019-09-28T01:18:45 | 211,425,508 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 957 | cpp | #include "SpaceShipCaptain.h"
SpaceShipCaptain::SpaceShipCaptain()
:SpaceShipCaptain(0, 0, 0, 0)
{
//empty
}
SpaceShipCaptain::SpaceShipCaptain(double position, double speed, string name, double rested)
: GameObject(position, speed),
Name(name),
Rested(rested)
{
//empty
}
string SpaceShipCaptain::getName()
{
return Name;
}
void SpaceShipCaptain::setName(string name)
{
Name = name;
}
double SpaceShipCaptain::getRested()
{
return Rested;
}
void SpaceShipCaptain::setRested(double value)
{
Rested = value;
}
void SpaceShipCaptain::Update()
{
xPosition += Speed;
if (Rested >= 0 && Rested <= 100)
{
--Rested;
}
}
void SpaceShipCaptain::Print()
{
std::cout << "The name is: " << Name << std::endl;
std::cout << "The position is: " << xPosition << std::endl;
std::cout << "The speed is: " << Speed << std::endl;
std::cout << "The battle readiness is: " << Rested << std::endl;
} | [
"noreply@github.com"
] | noreply@github.com |
face6aaa567fb7db2bd4a69f0529c6884cd3e0cb | a7d578f15bc05f393df32861c0f726e83359c174 | /include/grpc_cb/impl/proto_utils.h | 191038ddd42b0af7b777da2c86e66150a48c4cbc | [
"Apache-2.0"
] | permissive | wendysuly/grpc_cb | e5209fc75fc7008e3300f7eb5da24f83f561367c | 7fa807f6e961ca568bd7e0309b0979e9721c9fa8 | refs/heads/master | 2021-06-22T06:23:59.280411 | 2017-08-14T08:20:04 | 2017-08-14T08:20:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 810 | h | #ifndef GRPC_CB_IMPL_PROTO_UTILS_H
#define GRPC_CB_IMPL_PROTO_UTILS_H
#include <grpc_cb/support/protobuf_fwd.h> // for Message
struct grpc_byte_buffer;
namespace grpc_cb {
class Status;
namespace Proto {
// Serialize the msg into a buffer created inside the function. The caller
// should destroy the returned buffer when done with it. If serialization fails,
// false is returned and buffer is left unchanged.
Status Serialize(const ::google::protobuf::Message& msg,
grpc_byte_buffer** buffer);
// The caller keeps ownership of buffer and msg.
// max_msg_size <= 0 means no limit.
Status Deserialize(grpc_byte_buffer* buffer, ::google::protobuf::Message* msg,
int max_msg_size);
} // namespace Proto
} // namespace grpc_cb
#endif // GRPC_CB_IMPL_PROTO_UTILS_H
| [
"jinq0123@163.com"
] | jinq0123@163.com |
2a5c4ccdcaf11bbfe4760a2b8dfa033382eb6bf5 | 38a6046ba22ea84d2728a1f37d6113674b9c9456 | /c_look_disk_scheduling.cpp | dc07d255f1c4da1d0e2ae5c1a1fb91b64cefe6f4 | [] | no_license | ruchika2ar/Operating-Systems-Algorithms | 7da2fe8272d21f898b25cc75858e457f79ac221b | 7e5fa41d6a2a3d0bd2cfc732f5c27525b5b61836 | refs/heads/master | 2021-05-18T04:35:15.096485 | 2020-03-29T19:25:58 | 2020-03-29T19:25:58 | 251,110,386 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,676 | cpp | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
cout << "Enter queue: ";
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int start;
cout << "Enter starting position of head: ";
cin >> start;
cout << endl;
int head_movement = 0;
cout << "Order of I/O requests serviced: ";
// Assuming the head is moving towards track 0;
while (v.size() > 0) {
bool exists = false;
int min = -1;
for (int i = 0; i < v.size(); i++) {
if (v[i] > start) {
if (min == -1 || v[i] < v[min]) {
min = i;
exists = true;
}
}
}
if(!exists) break;
cout << v[min] << " ";
head_movement += v[min] - start;
start = v[min];
v.erase(v.begin() + min);
}
int minimum = v[0];
for(int i = 0; i < v.size(); i++) {
if(v[i] < minimum) minimum = v[i];
}
head_movement += start - minimum;
start = minimum;
while (v.size() > 0) {
bool exists = false;
int min = -1;
for (int i = 0; i < v.size(); i++) {
if (v[i] > start) {
if (min == -1 || v[i] < v[min]) {
min = i;
exists = true;
}
}
}
if(!exists) break;
cout << v[min] << " ";
head_movement += v[min] - start;
start = v[min];
v.erase(v.begin() + min);
}
cout << endl << "Total number of head movements : " << head_movement << endl;
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
d0bca0c0bdaa376c2fdbcdd5eeb65d5c3c6f4284 | 369d31fdeea04e46b561061859716e7a63966ae1 | /nodes/angular_tracker/src/angular_tracker.cpp | 9d163ed8e310f63f2725b27db5539a25d5275a3e | [] | no_license | Matszs/project-robotica-team-6 | 964d9b429bce55baa69391245776cd1049729a91 | 1dcd409a33d7f23cbd6b88d321ecb66a8e53af73 | refs/heads/master | 2021-05-09T13:30:52.396728 | 2018-01-04T12:57:50 | 2018-01-04T12:57:50 | 119,036,290 | 1 | 0 | null | 2018-01-26T10:03:55 | 2018-01-26T10:03:55 | null | UTF-8 | C++ | false | false | 1,125 | cpp | #include <ros/ros.h>
#include <message_filters/sync_policies/approximate_time.h>
#include <message_filters/time_synchronizer.h>
#include <message_filters/subscriber.h>
#include <geometry_msgs/Twist.h>
#include <vision/TrackedPosition.h>
#include <cstdio>
using namespace std;
ros::Publisher driver;
void trackedCallback(const vision::TrackedPositionConstPtr& msg) {
ROS_INFO("x: [%f], y: [%f], z: [%f], ", -msg->x * 2, -msg->y, -msg->z);
double rotation = -msg->x * 2;
geometry_msgs::Twist driveObj;
driveObj.angular.z = rotation;
if(rotation < 1 && rotation > -1) {
double filter = msg->z;
if(filter > 4)
filter = 4;
driveObj.linear.x = filter / 10;
}
driver.publish(driveObj);
}
int main(int argc, char **argv) {
ROS_INFO("Starting the node");
ros::init(argc, argv, "angular_tracker");
ROS_INFO("ros::init done");
ros::NodeHandle n;
ros::Subscriber sub = n.subscribe("/vision/tracked_position", 100, trackedCallback);
driver = n.advertise<geometry_msgs::Twist>("/mobile_base/commands/velocity", 100);
ros::spin();
ROS_INFO("Exiting the node");
return 0;
}
| [
"mats@kepsi.nl"
] | mats@kepsi.nl |
be47eaea967783f2a3f6f813196a29fbb598e1aa | 0f95719c10b19d418872f96feb7bc9025e77ea9c | /MFCApplication3/MFCApplication3.cpp | afa80f451d570479664fc6b93c9a786db7dc17b2 | [] | no_license | tommyhl/MatchingProgramV2 | 7ccae117d81ca083bf14bfe266f59601b67504c6 | b8343223ea13bbab81d5b95bc01d3aae3e0a086f | refs/heads/master | 2016-09-13T00:27:23.134465 | 2016-04-26T19:45:39 | 2016-04-26T19:45:39 | 56,986,076 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,899 | cpp |
// MFCApplication3.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include "MFCApplication3.h"
#include "MFCApplication3Dlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
// CMFCApplication3App
BEGIN_MESSAGE_MAP(CMFCApplication3App, CWinApp)
ON_COMMAND(ID_HELP, &CWinApp::OnHelp)
END_MESSAGE_MAP()
// CMFCApplication3App construction
CMFCApplication3App::CMFCApplication3App()
{
// support Restart Manager
m_dwRestartManagerSupportFlags = AFX_RESTART_MANAGER_SUPPORT_RESTART;
// TODO: add construction code here,
// Place all significant initialization in InitInstance
}
// The one and only CMFCApplication3App object
CMFCApplication3App theApp;
// CMFCApplication3App initialization
BOOL CMFCApplication3App::InitInstance()
{
// InitCommonControlsEx() is required on Windows XP if an application
// manifest specifies use of ComCtl32.dll version 6 or later to enable
// visual styles. Otherwise, any window creation will fail.
INITCOMMONCONTROLSEX InitCtrls;
InitCtrls.dwSize = sizeof(InitCtrls);
// Set this to include all the common control classes you want to use
// in your application.
InitCtrls.dwICC = ICC_WIN95_CLASSES;
InitCommonControlsEx(&InitCtrls);
CWinApp::InitInstance();
// Create the shell manager, in case the dialog contains
// any shell tree view or shell list view controls.
CShellManager *pShellManager = new CShellManager;
// Activate "Windows Native" visual manager for enabling themes in MFC controls
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need
// Change the registry key under which our settings are stored
// TODO: You should modify this string to be something appropriate
// such as the name of your company or organization
SetRegistryKey(_T("Local AppWizard-Generated Applications"));
CMFCApplication3Dlg dlg;
m_pMainWnd = &dlg;
INT_PTR nResponse = dlg.DoModal();
if (nResponse == IDOK)
{
// TODO: Place code here to handle when the dialog is
// dismissed with OK
}
else if (nResponse == IDCANCEL)
{
// TODO: Place code here to handle when the dialog is
// dismissed with Cancel
}
else if (nResponse == -1)
{
TRACE(traceAppMsg, 0, "Warning: dialog creation failed, so application is terminating unexpectedly.\n");
TRACE(traceAppMsg, 0, "Warning: if you are using MFC controls on the dialog, you cannot #define _AFX_NO_MFC_CONTROLS_IN_DIALOGS.\n");
}
// Delete the shell manager created above.
if (pShellManager != NULL)
{
delete pShellManager;
}
// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}
| [
"tommylie91@gmail.com"
] | tommylie91@gmail.com |
ac5ca80b48a67566d652b51ee2518356ee370eb5 | 5c6194e025346e672d8d6d760d782eed0e61bb7d | /developer/VSSDK/VisualStudioIntegration/Common/Source/CPP/VSL/MockInterfaces/VSLMockIComThreadingInfo.h | 0d2971cccadd31c6ceb6759ebccbece3a9ddbfaa | [
"MIT"
] | permissive | liushouhuo/windows | 888c4d9f8ae37ff60dd959eaf15879b8afdb161f | 9e211d0cd5cacbd62c9c6ac764a6731985d60e26 | refs/heads/master | 2021-09-03T06:34:51.320672 | 2018-01-06T12:48:51 | 2018-01-06T12:48:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,254 | h | /***************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
This code is licensed under the Visual Studio SDK license terms.
THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
This code is a part of the Visual Studio Library.
***************************************************************************/
#ifndef ICOMTHREADINGINFO_H_10C49CA1_2F46_11D3_A504_00C04F5E0BA5
#define ICOMTHREADINGINFO_H_10C49CA1_2F46_11D3_A504_00C04F5E0BA5
#if _MSC_VER > 1000
#pragma once
#endif
#include "ObjIdl.h"
#pragma warning(push)
#pragma warning(disable : 4510) // default constructor could not be generated
#pragma warning(disable : 4610) // can never be instantiated - user defined constructor required
#pragma warning(disable : 4512) // assignment operator could not be generated
#pragma warning(disable : 6011) // Dereferencing NULL pointer (a NULL derference is just another kind of failure for a unit test
namespace VSL
{
class IComThreadingInfoNotImpl :
public IComThreadingInfo
{
VSL_DECLARE_NONINSTANTIABLE_BASE_CLASS(IComThreadingInfoNotImpl)
public:
typedef IComThreadingInfo Interface;
STDMETHOD(GetCurrentApartmentType)(
/*[out]*/ APTTYPE* /*pAptType*/)VSL_STDMETHOD_NOTIMPL
STDMETHOD(GetCurrentThreadType)(
/*[out]*/ THDTYPE* /*pThreadType*/)VSL_STDMETHOD_NOTIMPL
STDMETHOD(GetCurrentLogicalThreadId)(
/*[out]*/ GUID* /*pguidLogicalThreadId*/)VSL_STDMETHOD_NOTIMPL
STDMETHOD(SetCurrentLogicalThreadId)(
/*[in]*/ REFGUID /*rguid*/)VSL_STDMETHOD_NOTIMPL
};
class IComThreadingInfoMockImpl :
public IComThreadingInfo,
public MockBase
{
VSL_DECLARE_NONINSTANTIABLE_BASE_CLASS(IComThreadingInfoMockImpl)
public:
VSL_DEFINE_MOCK_CLASS_TYPDEFS(IComThreadingInfoMockImpl)
typedef IComThreadingInfo Interface;
struct GetCurrentApartmentTypeValidValues
{
/*[out]*/ APTTYPE* pAptType;
HRESULT retValue;
};
STDMETHOD(GetCurrentApartmentType)(
/*[out]*/ APTTYPE* pAptType)
{
VSL_DEFINE_MOCK_METHOD(GetCurrentApartmentType)
VSL_SET_VALIDVALUE(pAptType);
VSL_RETURN_VALIDVALUES();
}
struct GetCurrentThreadTypeValidValues
{
/*[out]*/ THDTYPE* pThreadType;
HRESULT retValue;
};
STDMETHOD(GetCurrentThreadType)(
/*[out]*/ THDTYPE* pThreadType)
{
VSL_DEFINE_MOCK_METHOD(GetCurrentThreadType)
VSL_SET_VALIDVALUE(pThreadType);
VSL_RETURN_VALIDVALUES();
}
struct GetCurrentLogicalThreadIdValidValues
{
/*[out]*/ GUID* pguidLogicalThreadId;
HRESULT retValue;
};
STDMETHOD(GetCurrentLogicalThreadId)(
/*[out]*/ GUID* pguidLogicalThreadId)
{
VSL_DEFINE_MOCK_METHOD(GetCurrentLogicalThreadId)
VSL_SET_VALIDVALUE(pguidLogicalThreadId);
VSL_RETURN_VALIDVALUES();
}
struct SetCurrentLogicalThreadIdValidValues
{
/*[in]*/ REFGUID rguid;
HRESULT retValue;
};
STDMETHOD(SetCurrentLogicalThreadId)(
/*[in]*/ REFGUID rguid)
{
VSL_DEFINE_MOCK_METHOD(SetCurrentLogicalThreadId)
VSL_CHECK_VALIDVALUE(rguid);
VSL_RETURN_VALIDVALUES();
}
};
} // namespace VSL
#pragma warning(pop)
#endif // ICOMTHREADINGINFO_H_10C49CA1_2F46_11D3_A504_00C04F5E0BA5
| [
"jdm7dv@gmail.com"
] | jdm7dv@gmail.com |
4d9435d995d22064427f3e4dbe5b09773771a6f5 | dae907db0cf43b427fd1a456b338be3910fc5f90 | /X76165_en_Sawtooth_sequences.cpp | b4dcfe0a8b013bb741332ae46a888f8b3bc56a12 | [] | no_license | FranciOrtiz/jutge_problems | 4c5c273ada09f20088b08287356bbb967a642e45 | a838f6ad8995cf57ae6f11cc6beeb3f13fa7e55d | refs/heads/master | 2022-12-23T20:33:43.775974 | 2020-09-24T09:49:10 | 2020-09-24T09:49:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 357 | cpp | #include <bits/stdc++.h>
using namespace std;
bool is_sawtooth() {
int a, b;
if (!(cin >> a >> b)) return true;
bool inc = a > b;
for(;cin >> a; inc^=1, b = a)
if (inc and a <= b) return false;
else if (!inc and b <= a) return false;
return true;
}
int main () {
cout << (is_sawtooth()? "yes" : "no") << endl;
}
| [
"abone9999@gmail.com"
] | abone9999@gmail.com |
04fbfc933660f964e503f0f77f2850ddc7ac0ce2 | 8dde35ad5b8d6fdfa446cb1c0b845f61b02c00bf | /Fraction.hpp | 62c93bd100534441743f737638969ea29859bcb9 | [] | no_license | ronengi/Math_educator | e7f8a1f8acd63d332e2357e10627f3b6c2ed810f | ed7a52d9b792d614e6638bd27c2ed462cfc1457b | refs/heads/master | 2020-03-15T22:28:53.070193 | 2018-05-07T19:33:46 | 2018-05-07T19:33:46 | 132,374,171 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,867 | hpp | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/*
* File: Fraction.hpp
* Author: Ronen Gilead-Raz <ronengi@gmail.com>
*
* Created on May 6, 2018, 1:15 PM
*/
#ifndef FRACTION_HPP
#define FRACTION_HPP
#include <iostream>
#include <iomanip>
#include <stdexcept>
#include <numeric>
#include <sstream>
using namespace std;
class Fraction {
public:
Fraction(); // default constructor
Fraction(int nn);
Fraction(int nn, int dd);
Fraction(const Fraction& other); // copy constructor
Fraction& operator+=(const Fraction& other);
Fraction& operator-=(const Fraction& other);
Fraction& operator*=(const Fraction& other);
Fraction& operator/=(const Fraction& other);
Fraction operator+(const Fraction& other) const;
Fraction operator-(const Fraction& other) const;
Fraction operator*(const Fraction& other) const;
Fraction operator/(const Fraction& other) const;
bool operator==(const Fraction& other) const;
bool operator!=(const Fraction& other) const;
bool operator>(const Fraction& other) const;
bool operator<(const Fraction& other) const;
int get_numerator() const;
int get_denominator() const;
void set_numerator(int nn);
void set_denominator(int dd);
void reduce();
private:
int numerator; // the sign of the whole fraction is here
int denominator; // always positive
};
Fraction reciprocal(const Fraction& fr);
Fraction negative(const Fraction& fr);
string mixed(const Fraction& fr);
string expanded(const Fraction& fr, int new_denominator);
ostream& operator<<(ostream& os, const Fraction& fr);
istream& operator>>(istream& is, Fraction& fr);
#endif /* FRACTION_HPP */
| [
"ronengi@gmail.com"
] | ronengi@gmail.com |
27c2885e9cd9cc4506f27af61b0163a4f2dc3e30 | b2e21c4578ec8816220ab8af904e15b7cc31fd7e | /UPDATEIT.cpp | 9310bd7f1fe51f9888841cb4885fc0612980ff3c | [] | no_license | vkthakur/spoj | 70968b8ecd67208e33dd7d666a69047eb71b7e26 | 1731c05624a1eaed0fec3d84c31b4b2aaaea11b5 | refs/heads/master | 2016-09-10T01:10:34.977541 | 2015-01-19T20:18:33 | 2015-01-19T20:18:33 | 28,721,879 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,090 | cpp | #include <iostream>
#include <stdio.h>
#include <math.h>
#include <utility>
#include <algorithm>
#include <set>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <stdlib.h>
using namespace std;
long long int tree[10001],maxval;
long long int read(long long int idx)
{
long long int sum=0;
while(idx > 0) {
sum+=tree[idx];
idx-=(idx & -idx);
}
return sum;
}
void update(long long int idx,long long int val)
{
while(idx <=maxval) {
tree[idx]+=val;
idx+=(idx & -idx);
}
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
long long int i,n,q,u,indx1,indx2;
long long int val;
for(i=0;i<=10000;i++) tree[i]=0;
scanf("%lld%lld",&n,&u);
maxval=n;
for(i=0;i<u;i++)
{
scanf("%lld%lld%lld",&indx1,&indx2,&val);
update(indx1+1,val);
if(indx2 < n) update(indx2+2,(-1)*val);
}
scanf("%lld",&q);
while(q--)
{
long long int index;
long long int element;
scanf("%lld",&index);
element=read(index+1);
printf("%lld\n",element);
}
}
return 0;
} | [
"me.vivekkrthakur@gmail.com"
] | me.vivekkrthakur@gmail.com |
6c8bb098c1f147bf5be796b1ddaa47a6f15c70db | c4a4d0fd7973885dfa39568cca2fa0fb1c7ac04d | /FaceSwap/FaceSwap/FSImageUtils.hpp | bf0fc77ccfa3705198bf0b366fd20e6222c995b5 | [
"MIT"
] | permissive | devilcoder/FaceSwap-iOS | ad9d88fbe86caa3a49752668bab0baf36c98e504 | f465f2641d48297ddbde837394696a3d0ca5869a | refs/heads/master | 2022-11-23T23:41:56.773753 | 2020-07-31T11:54:35 | 2020-07-31T11:54:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,246 | hpp | //
// FSImageUtils.h
// FaceSwap
//
// Created by Alexander Karlsson on 2016-12-31.
// Copyright © 2016-2020 Alexander Karlsson. All rights reserved.
//
#ifndef FSImageUtils_hpp
#define FSImageUtils_hpp
#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
#import <CoreGraphics/CoreGraphics.h>
#import "opencv2/core.hpp"
@interface FSImageUtils : NSObject
{
cv::Mat mat1, mat2;
std::vector<cv::Point2f> landmarks1, landmarks2;
}
enum class SwapStatus{
OK,
NOK
};
/**
@brief Swaps faces of two selfie images. (Public)
The face in img1 will be pasted over img2's face.
@param FSStatus [out] return status
@return an UIImage with face swap result.
*/
-(UIImage*)swapFaces :(SwapStatus&)FSStatus;
/**
@brief Sets image 1.
@param img [in] Image 1.
*/
-(void)setImg1:(UIImage*) img;
/**
@brief Sets the secondary image.
@param img [in] image 2.
*/
-(void)setImg2:(UIImage*) img;
/**
@brief Sets the landmarks for image 1.
@param landmarks [in] Facial landmarks for image 1.
*/
-(void)setLandmarks1:(NSArray*) landmarks;
/**
@brief Sets the landmarks for image 2.
@param landmarks [in] Facial landmarks for image 2.
*/
-(void)setLandmarks2:(NSArray*) landmarks;
@end
#endif /* FSImageUtils_hpp */
| [
"st.alexander85@gmail.com"
] | st.alexander85@gmail.com |
04c55a076cc6ece4a536f3606a143d80caf42bf9 | 45851e25f270c2acae0939e3b57dd55954b3f0d9 | /WORLD/simple_objects.h | 3a8f7506c9e34f37a71d7a03ed29cdc21481d369 | [] | no_license | eliotuci/epuck_aggregation | fdbc083e6af6e187bd7c01c3afa61434b9dc7fce | 7bd91fe0d14a9c05b9515225f6ebf31b42150dd5 | refs/heads/master | 2021-01-11T14:10:07.577927 | 2017-06-21T10:14:59 | 2017-06-21T10:14:59 | 94,988,496 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,726 | h | #ifndef _SIMPLE_OBJECTS_
#define _SIMPLE_OBJECTS_
#include "world_entity.h"
using namespace std;
class SIMPLE_Objects : public World_Entity {
protected:
//vector <double> pos;
//vector <double> rot;
//vector <double> dim;
double angle;
btQuaternion rotation;
//int type_id;
static const int robot_slices = 20;
private:
public:
int object_id;
bool removed;
vector <double> start_pos;
btDynamicsWorld* world;
btRigidBody* body[2];
SIMPLE_Objects(btDynamicsWorld* world);
virtual ~SIMPLE_Objects(){}
void set_mass (double _mass);
void set_size (double _length);
void set_pos ( const vector <double> &_pos );
void set_rot ( const vector <double> &_rot );
void remove_object( void );
void add_object( void );
const vector <double> get_pos ( void );//{ return pos;}
const vector <double> get_rot ( void );//{ return rot;}
inline const vector <double> get_dim ( void ){ return dim;}
inline double get_mass ( void ){ return mass;}
inline bool is_removed ( void ){ return removed;}
inline void set_removed ( bool flag ) { removed = flag;}
inline const vector <double> get_colour ( void ){ return colour;}
virtual void reset_pos( void ) = 0;
// inline const int get_type_id ( void ){ return type_id;}
#ifdef _GRAPHICS_
virtual void render ( ) = 0;
#endif
};
/* ------------------------------------------------------------ */
class SIMPLE_Plane : public SIMPLE_Objects {
public:
SIMPLE_Plane(btDynamicsWorld* world );
void addPlane();
void reset_pos(){}
#ifdef _GRAPHICS_
void render ( );
#endif
};
/* ------------------------------------------------------------ */
class SIMPLE_Brick : public SIMPLE_Objects {
public:
SIMPLE_Brick( int ind, const vector <double> & data, btDynamicsWorld* world );
void reset_pos();
#ifdef _GRAPHICS_
void render ( );
#endif
};
/* ------------------------------------------------------------ */
class SIMPLE_Cylinder : public SIMPLE_Objects {
public:
SIMPLE_Cylinder(int ind, const vector <double> & data , btDynamicsWorld *world);
void reset_pos( void );
#ifdef _GRAPHICS_
void render ( );
#endif
};
/* ------------------------------------------------------------ */
class SIMPLE_Sphere : public SIMPLE_Objects {
public:
SIMPLE_Sphere( int ind, const vector <double> & data, btDynamicsWorld* world);
void reset_pos( void );
#ifdef _GRAPHICS_
void render ( );
#endif
};
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
#endif
| [
"noreply@github.com"
] | noreply@github.com |
335383e5c0ef81e53ef3bfad7114db24490d1b59 | c9796a20cf56aa01ecbc2ff3985703b17bfb51fe | /leetcode2/SuperWashingMachines/a.cpp | dba274942d52eedbc0df8153a64db76c738c72cf | [] | no_license | iamslash/learntocode | a62329710d36b21f8025961c0ad9b333c10e973a | 63faf361cd4eefe0f6f1e50c49ea22577a75ea74 | refs/heads/master | 2023-08-31T08:20:08.608771 | 2023-08-31T00:05:06 | 2023-08-31T00:05:06 | 52,074,001 | 7 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 571 | cpp | /* Copyright (C) 2020 by iamslash */
#include <cstdio>
#include <vector>
#include <numeric>
#include <cmath>
using namespace std;
// 12ms 100.00% 13.3MB 31.36%
// linear traversal
// O(N) O(1)
class Solution {
public:
int findMinMoves(vector<int>& M) {
int n = M.size();
int total = accumulate(M.begin(), M.end(), 0);
if (total % n != 0)
return -1;
int avg = total / n;
int ans = 0, sum = 0;
for (int m : M) {
sum += m - avg;
ans = max(ans, max(abs(sum), m - avg));
}
return ans;
}
};
| [
"iamslash@gmail.com"
] | iamslash@gmail.com |
8744f14bed40690db689db14e1b398dcb1b57679 | 82089585986bfd5611f46629f2d326dc2b85b943 | /Source/CppSpaceInvadors/MyPlayerController.h | b25b491ea89a6ccbcb97f5f29f25a6f9eb980b98 | [] | no_license | jonny2027/SpaceInvadorsUnrealEngine4 | 3a4ea06b8cdf11a16c0be0b215a345a682f9eb1c | 48061b24d2b935378b8602533ce379940714de8c | refs/heads/master | 2021-01-16T18:59:40.553947 | 2016-01-08T02:20:45 | 2016-01-08T02:20:45 | 49,428,752 | 1 | 1 | null | 2016-01-11T13:40:28 | 2016-01-11T13:40:28 | null | UTF-8 | C++ | false | false | 348 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "GameFramework/PlayerController.h"
#include "MyPlayerController.generated.h"
/**
*
*/
UCLASS()
class CPPSPACEINVADORS_API AMyPlayerController : public APlayerController
{
GENERATED_BODY()
public:
AMyPlayerController();
AActor* Cam;
};
| [
"djyeats@gmail.com"
] | djyeats@gmail.com |
2cc7a51d866916b7dab86b053a62cab46d463d0b | ad31a1c599310d66ca7dfad86614561f303d9fda | /taxoperatoroverloading.cc | ff623b71c8ee4e723070a10096ac9470c7eed6fc | [] | no_license | shreybose/C- | cf42e802f6a2bf8c0a896693df1430ecee33bf32 | 19a64357c1f3213131dd62daac68c4e97b5f7c80 | refs/heads/master | 2023-01-03T11:56:07.186969 | 2020-11-02T19:38:24 | 2020-11-02T19:38:24 | 298,381,024 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 750 | cc | // Copyright 2020 Shreya Bose
#include <inc/tax.h>
using std::istream;
using std::string;
Tax::Tax(const std::string& code, double percent) {
if (percent > 0)
percentage = percent;
new_code = code;
}
// accessors
const std::string& Tax::code() const {
return new_code;
}
double Tax::percent() const {
return percentage;
}
// mutators
void Tax::percent(double new_percent) {
if (new_percent > 0)
percentage = new_percent;
}
double Tax::Calculate(double amount) const {
return amount = amount * percentage/100;
}
std::ostream& Tax::Extract(std::ostream* out) const {
*out << new_code << ":" << percentage;
return *out;
}
std::istream& Tax::Insert(std::istream* in) {
*in >> new_code;
*in >> percentage;
return *in;
}
| [
"noreply@github.com"
] | noreply@github.com |
efb7f14942a7fda9580cd0e5b4bf551e4ecf423e | 8637c397daa1f082216579c1c220781ded98830a | /benchmarking/dilithium/main.cpp | 9d8d8e0c737eeb19e53bbd905721252d2b82fe33 | [] | no_license | jameshoweee/falcon-fpu | 3a36dd63f3f3c495773b91427117f21d9a19f337 | 26785477be9b987f9170690f3e1519b8070ba22c | refs/heads/main | 2023-05-21T01:16:55.510137 | 2021-06-03T10:46:03 | 2021-06-03T10:46:03 | 339,133,355 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,274 | cpp | #include <string>
#include <stdlib.h>
#include "mbed.h"
#include "stm32f7xx_hal.h"
extern "C" {
#include "dilithium-pqm4/api.h"
#include "dilithium-pqm4/config.h"
#include "dilithium-pqm4/keccakf1600.h"
#include "dilithium-pqm4/ntt.h"
#include "dilithium-pqm4/packing.h"
#include "dilithium-pqm4/params.h"
#include "dilithium-pqm4/pointwise_mont.h"
#include "dilithium-pqm4/poly.h"
#include "dilithium-pqm4/polyvec.h"
#include "dilithium-pqm4/randombytes.h"
#include "dilithium-pqm4/reduce.h"
#include "dilithium-pqm4/rounding.h"
#include "dilithium-pqm4/sign.h"
#include "dilithium-pqm4/symmetric.h"
#include "dilithium-pqm4/vector.h"
}
//------------------------------------
// Hyperterminal configuration
// 115200 bauds, 8-bit data, no parity
//------------------------------------
Serial pc(SERIAL_TX, SERIAL_RX, 115200);
DigitalOut myled(LED1);
Timer timer;
int randombytes(uint8_t *obuf, size_t len)
{
static uint32_t fibo_a = 0xDEADBEEF, fibo_b = 0x01234567;
size_t i;
for (i = 0; i < len; i++) {
fibo_a += fibo_b;
fibo_b += fibo_a;
obuf[i] = (fibo_a >> 24) ^ (fibo_b >> 16);
}
return 0;
}
int main()
{
#define BENCHMARK_ROUND 50
uint64_t start, stop, delta, min, max;
int us, cnt;
long double average_us, average_clk, avclk_old, var, std_err, ddelta;
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))
#define CALC_RESET { \
start = stop = 0; \
delta = 0; \
ddelta = 0; \
var = 0; \
average_clk = 0; \
average_us = 0; \
avclk_old = 0; \
min = 9999999999;\
max = 0; \
timer.reset(); \
cnt = 1; \
}
#define CALC_START { \
timer.reset(); \
timer.start(); \
start = DWT->CYCCNT; \
}
#define CALC_STOP { \
stop = DWT->CYCCNT; \
us = timer.read_us(); \
avclk_old = average_clk; \
delta = stop - start; \
ddelta = (long double) delta; \
average_clk += ((ddelta-average_clk)/cnt);\
var += ((ddelta-average_clk)*(ddelta-avclk_old));\
var /= cnt; \
average_us += (long double)(us-average_us)/cnt;\
min = MIN(delta,min); \
max = MAX(delta,max); \
cnt += 1; \
}
#define CALC_AVG { \
std_err = sqrt(var/cnt); \
}
#define timer_read_ms(x) chrono::duration_cast<chrono::milliseconds>((x).elapsed_time()).count()
//set so that cycle counter can be read from DWT->CYCCNT
CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
DWT->LAR = 0xC5ACCE55;
DWT->CYCCNT = 0;
DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
int ret_val = 0;
/*
* Dilithium Round 3 code using pqm4 as it's faster than pqclean.
* change Dilithium's parameters in config.h to either 2, 3, or 5.
* ret_val outputs 0 if functions work as expected.
* comment code out below to switch between Falcon and Dilithium.
*/
#define MLEN 59
size_t mlen, smlen;
uint8_t pk[CRYPTO_PUBLICKEYBYTES] = {0};
uint8_t sk[CRYPTO_SECRETKEYBYTES] = {0};
uint8_t m[MLEN + CRYPTO_BYTES];
uint8_t m2[MLEN + CRYPTO_BYTES];
uint8_t sm[MLEN + CRYPTO_BYTES];
randombytes(m, MLEN);
fflush(stdout);
pc.printf("----------------------\n\r");
pc.printf("| Starting Dilithium |\n\r");
pc.printf("----------------------\n\r");
pc.printf("------------------------\n\r");
pc.printf("| Doing Key Generation |\n\r");
pc.printf("------------------------\n\r");
CALC_RESET
for (size_t r=0; r<BENCHMARK_ROUND; r++) {
DWT->CYCCNT = 0;
CALC_START
ret_val = crypto_sign_keypair(pk, sk);
CALC_STOP
}
CALC_AVG
pc.printf("Avg clock cycles: %.0Lf\n\r", average_clk);
pc.printf("Min clock cycles: %lld\n\r", min);
pc.printf("Max clock cycles: %lld\n\r", max);
pc.printf("Std dev of clock cycles: %.1Lf\n\r", (sqrt(var)));
pc.printf("Std err of clock cycles: %.1Lf\n\r", (std_err));
pc.printf("Avg time in millisecs: %.1Lf\n\r", average_us/1000);
pc.printf("-----------------\n\r");
pc.printf("| Doing Signing |\n\r");
pc.printf("-----------------\n\r");
CALC_RESET
for (size_t r=0; r<BENCHMARK_ROUND; r++) {
DWT->CYCCNT = 0;
randombytes(m, MLEN);
CALC_START
ret_val = crypto_sign(sm, &smlen, m, MLEN, sk);
CALC_STOP
}
CALC_AVG
pc.printf("Avg clock cycles: %.0Lf\n\r", average_clk);
pc.printf("Min clock cycles: %lld\n\r", min);
pc.printf("Max clock cycles: %lld\n\r", max);
pc.printf("Std dev of clock cycles: %.1Lf\n\r", (sqrt(var)));
pc.printf("Std err of clock cycles: %.1Lf\n\r", (std_err));
pc.printf("Avg time in millisecs: %.1Lf\n\r", average_us/1000);
pc.printf("------------------------\n\r");
pc.printf("| Doing Signing (open) |\n\r");
pc.printf("------------------------\n\r");
CALC_RESET
for (size_t r=0; r<BENCHMARK_ROUND; r++) {
DWT->CYCCNT = 0;
CALC_START
ret_val = crypto_sign_open(m2, &mlen, sm, smlen, pk);
CALC_STOP
}
CALC_AVG
pc.printf("Avg clock cycles: %.0Lf\n\r", average_clk);
pc.printf("Min clock cycles: %lld\n\r", min);
pc.printf("Max clock cycles: %lld\n\r", max);
pc.printf("Std dev of clock cycles: %.1Lf\n\r", (sqrt(var)));
pc.printf("Std err of clock cycles: %.1Lf\n\r", (std_err));
pc.printf("Avg time in millisecs: %.1Lf\n\r", average_us/1000);
pc.printf("-------------------\n\r");
pc.printf("| Doing Verifying |\n\r");
pc.printf("-------------------\n\r");
CALC_RESET
for (size_t r=0; r<BENCHMARK_ROUND; r++) {
DWT->CYCCNT = 0;
CALC_START
ret_val = crypto_sign_verify(sm, CRYPTO_BYTES, m, MLEN, pk);
CALC_STOP
}
CALC_AVG
pc.printf("Avg clock cycles: %.0Lf\n\r", average_clk);
pc.printf("Min clock cycles: %lld\n\r", min);
pc.printf("Max clock cycles: %lld\n\r", max);
pc.printf("Std dev of clock cycles: %.1Lf\n\r", (sqrt(var)));
pc.printf("Std err of clock cycles: %.1Lf\n\r", (std_err));
pc.printf("Avg time in millisecs: %.1Lf\n\r", average_us/1000);
pc.printf("----------------------\n\r");
pc.printf("| Dilithium Finished |\n\r");
pc.printf("----------------------\n\r");
fflush(stdout);
pc.printf("Scheme fail if nonzero: %d\n\r", ret_val);
}
| [
"jameshoweee@gmail.com"
] | jameshoweee@gmail.com |
62e2cbcded3b55064a562f312d505bea55c50995 | c9b93f511c05284121ab4c6c2533464d361a04f6 | /perceptron/rand.h | 3a9c43b4d38dcca21f90f3a3abbc15ecd8c7a771 | [] | no_license | brasm94/oldschool | 7af43b76c41747151eda7a146d4f4fad64e3955a | 0125ef2eaf881f6e6b1c1a7c4e8f040f729c491e | refs/heads/master | 2023-01-22T17:20:54.243082 | 2020-01-10T00:32:39 | 2020-01-10T00:32:39 | 232,930,824 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,810 | h | // ----------------------------------------------------------------
// The contents of this file are distributed under the CC0 license.
// See http://creativecommons.org/publicdomain/zero/1.0/
// ----------------------------------------------------------------
#ifndef RAND_H
#define RAND_H
#include <vector>
typedef unsigned long long int uint64;
// This is a 64-bit pseudo-random number generator. This class is superior
// to the standard C rand() method because it is faster, it is consistent
// across platforms, it makes bigger random numbers, and it can draw from
// several useful distributions. The only methods you will use in CS478 are
// setSeed, next, uniform, and normal. I just left the other methods here
// for completeness.
class Rand
{
protected:
uint64 m_a;
uint64 m_b;
public:
Rand(uint64 seed);
~Rand();
// Sets the seed
void setSeed(uint64 seed);
// Returns an unsigned pseudo-random 64-bit value
uint64 next()
{
m_a = 0x141F2B69ull * (m_a & 0x3ffffffffull) + (m_a >> 32);
m_b = 0xC2785A6Bull * (m_b & 0x3ffffffffull) + (m_b >> 32);
return m_a ^ m_b;
}
// Returns a pseudo-random uint from a discrete uniform
// distribution in the range 0 to range-1 (inclusive).
// (This method guarantees the result will be drawn from
// a uniform distribution, whereas doing "next() % range"
// does not guarantee a truly uniform distribution.)
uint64 next(uint64 range);
// Returns a random value from a beta distribution
double beta(double alpha, double beta);
// Returns a random value from a binomial distribution
int binomial(int n, double p);
// Returns a random value from a categorical distribution
// with the specified vector of category probabilities.
int categorical(std::vector<double>& probabilities);
// Returns a random value from a standard Cauchy distribution
double cauchy();
// Returns a random value from a chi-squared distribution
double chiSquare(double t);
// Returns a random vector from a dirichlet distribution with the
// specified parameters and dimensionality. (Both pOutVec and
// pParams should be an array of dims values.)
void dirichlet(double* pOutVec, const double* pParams, int dims);
// Returns a random value from a standard exponential distribution.
// (To convert it to a random value from an arbitrary exponential
// distribution, just divide the value this returns by the
// rate (usually lambda), or if you use the scale parameterization,
// just multiply the value this returns by the scale (usually beta)).
double exponential();
// Returns a random value from an f-distribution
double f(double t, double u);
// Returns a random value from a gamma distribution with beta=theta=1.
// To convert to a value from an arbitrary gamma distribution,
// just divide the value this returns by beta (or use alpha=k, and
// multiply the value this returns by theta).
double gamma(double alpha);
// Returns a random value from a geometric distribution with support
// for {0, 1, 2, ...}.
int geometric(double p);
// Returns a random value from a standard logistic distribution. To
// convert to a random value from an arbitrary logistic distribution,
// just multiply the value this returns by the scale (or divide by
// the steepness), and then add the mean.
double logistic();
// Returns a random value from a log-Normal distribution
double logNormal(double mean, double dev);
// Returns a random value from a standard normal distribution. (To
// convert it to a random value from an arbitrary normal distribution,
// just multiply the value this returns by the deviation (usually
// lowercase-sigma), then add the mean (usually mu).)
double normal();
// Returns a random value from a Poisson distribution
int poisson(double mu);
// Returns a random value from a soft-impulse distribution with support
// from 0 to 1. (The cdf of the soft-impulse distribution is the soft-step
// function: (1/(pow(1/x-1,s)+1)). The mean is always at 0.5, where
// the probability-density is s.
double softImpulse(double s);
// Returns a random point on the surface of a dims-dimensional unit sphere
void spherical(double* pOutVec, int dims);
// Returns a random point within the volume of a dims-dimensional unit sphere
void spherical_volume(double* pOutVec, int dims);
// Returns a random point uniformly distributed within a unit cube
void cubical(double* pOutVec, int dims);
// Returns a random value from Student's t-distribution
double student(double t);
// Returns a pseudo-random double from 0 (inclusive)
// to 1 (exclusive). This uses 52 random bits for the
// mantissa, and discards the extra 12 random bits.
double uniform();
// Returns a random value from a Weibull distribution with lambda=1.
double weibull(double gamma);
};
#endif // __GRAND_H__
| [
"brian.rasmussen55@gmail.com"
] | brian.rasmussen55@gmail.com |
ad79cd033696f50305abcf6a99aed2e2709177dd | bb8dfd19165f349d87d3b558050bc377d4da6449 | /配套光盘/习题/0x6B 图论 总结与练习/太鼓达人/CH6B18／BZOJ3033 太鼓达人.cpp | b0166d311c5e065440ab713107e2fec7543d2b28 | [] | no_license | lydrainbowcat/tedukuri | 4c3358e2e4d7f8e07152a79981535f0ead3372e7 | b0471bb0bcf6216a45b818d6be2288e23a02347c | refs/heads/master | 2023-08-17T14:02:02.847399 | 2023-08-07T23:25:35 | 2023-08-07T23:25:35 | 125,682,894 | 2,222 | 706 | null | 2023-08-07T23:25:37 | 2018-03-18T01:24:42 | Roff | UTF-8 | C++ | false | false | 603 | cpp | //Author:XuHt
#include <cstdio>
#include <iostream>
using namespace std;
const int N = 10006;
int p[20], n, t;
bool v[N], ans[N];
bool dfs(int x, int k) {
if (v[x]) return 0;
if (k == t) return 1;
ans[k] = x & 1;
v[x] = 1;
if (dfs((x << 1) & (t - 1), k + 1)) return 1;
if (dfs((x << 1 | 1) & (t - 1), k + 1)) return 1;
v[x] = 0;
return 0;
}
int main() {
p[0] = 1;
for (int i = 1; i < 20; i++) p[i] = p[i-1] << 1;
cin >> n;
cout << (t = p[n]) << ' ';
dfs(0, 1);
for (int i = 1; i < n; i++) putchar('0');
for (int i = 1; i <= t - n + 1; i++) printf("%d", ans[i]);
puts("");
return 0;
}
| [
"hyqjlyd@qq.com"
] | hyqjlyd@qq.com |
cc794225c3d5b9cbf986dfffd6e1927f7862b276 | dc9e18984183e628d580056841b56b4d24d2436c | /Textbook/Inheritance02.cpp | b170369788108f3c149f337e8f4cd23ed82528ec | [] | no_license | YangNayoung/C- | 0096ad0cefaaefffba82d5167ab595dd9377883c | e604620feda1d7aebe5e133f2d17a64950fb6743 | refs/heads/master | 2022-07-28T13:39:39.096552 | 2020-05-14T10:36:01 | 2020-05-14T10:36:01 | 257,483,555 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 676 | cpp | #include <iostream>
using namespace std;
class BaseData {
public: // 누구나 접근 가능
BaseData() { cout << "BaseData()" << endl; }
int GetData() { return m_nData; }
void SetData(int nParam) { m_nData = nParam; }
protected: // 파생 클래스만 접근 가능
void PrintData() { cout << "BaseData::PrintData()" << " "; }
private: // 접근 불가능
int m_nData = 0;
};
class DerivedData : public BaseData {
public:
DerivedData() { cout << "DerivedData()" << " "; }
void TestFunc() {
PrintData();
SetData(5);
cout << BaseData::GetData() << endl;
}
};
void main() {
DerivedData data;
data.SetData(10);
cout << data.GetData() << endl;
data.TestFunc();
} | [
"s2018s32@e-mirim.hs.kr"
] | s2018s32@e-mirim.hs.kr |
5a4e66e6f857471acb10795a7e912775f1a3af45 | b8392ef868ef43367b5d54d7296e76692dda3a39 | /Design pattern/factory/工厂模式/factoryMode/factoryMode/factoryMode.cpp | c83f0ce8c145390022d8c0362e716c5ba2c40850 | [] | no_license | zxycele/MyRepository | 571b037cf82bc505524909634f7cdf9fd6672104 | d7557dcc84faf335a20a8bdc8f2ba392805b0d4b | refs/heads/master | 2021-05-03T19:10:18.933708 | 2016-11-22T11:42:36 | 2016-11-22T11:42:36 | 71,976,266 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 453 | cpp | // factoryMode.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "FactoryCoreA.h"
#include "FactoryCoreB.h"
#include "SingleCoreA.h"
#include "FactoryCoreB.h"
int _tmain(int argc, _TCHAR* argv[])
{
CFactoryCoreA *mFactoryCoreA = new CFactoryCoreA();
CSingleCore * mSingleCoreA= mFactoryCoreA->createSingleCore();
mSingleCoreA->show();
delete mSingleCoreA;
delete mFactoryCoreA;
getchar();
return 0;
}
| [
"474081209@qq.com"
] | 474081209@qq.com |
fbf1fe4f39368c6fc5b158334b8a21e71f5ee2fb | dd3564f348bf84fd341a7845d419fde6c98dcb1e | /BaekJoon Online Judge/C++/Step19-Binary Search/2805.cpp | 64393c6beef3761fbcd72798b6cf565c8c50d617 | [] | no_license | YebinKim/Algorithm-Study | af01526b9ad866c573eae194767d11e163d9f329 | 63f994fdf3bc549c5ed159f2fd6a47de4b849442 | refs/heads/main | 2023-05-25T19:22:44.139820 | 2023-05-11T12:03:08 | 2023-05-11T12:03:08 | 204,962,764 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 967 | cpp | //
// 2805.cpp
// Step19-Binary Search
//
// Created by 김예빈 on 2019. 9. 29..
// Copyright © 2019년 김예빈. All rights reserved.
//
#include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
cin.tie(NULL);
ios::sync_with_stdio(false);
int n, m;
long long result = 0, mid, left = 0, right = 0, sum;
cin >> n >> m;
int arr[n];
for(int i = 0; i < n; i++) {
cin >> arr[i];
if(right < arr[i])
right = arr[i];
}
while(left <= right) {
mid = (left + right) / 2;
sum = 0;
for(int i = 0; i < n; i++)
if(mid < arr[i])
sum += arr[i] - mid;
if(sum >= m){
if(result < mid)
result = mid;
left = mid + 1;
} else {
right = mid - 1;
}
}
cout << result;
return 0;
}
| [
"yb2316@naver.com"
] | yb2316@naver.com |
8a1286445d149bb6415a3552a0afbbe153637e58 | abb2bdc836b04ecca1aebcf46afece213c2d3592 | /CPP_QT/Time_test/Src/main.cpp | 59ccf671b59dd80385ea3aa227f6ea05a0c26afb | [] | no_license | XwAdmin/CodeTest | 3d4d7944eca687d94fcfda7f53be6ae89f84a0a6 | 77880881296a7b9c1f81b2203a72292bd543cb24 | refs/heads/master | 2022-03-08T10:52:06.594869 | 2019-11-15T09:12:32 | 2019-11-15T09:12:32 | 190,144,911 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 173 | cpp | #include <QApplication>
#include "form.h"
int main ( int argc, char **argv )
{
QApplication app( argc, argv );
Form form;
form.show();
return app.exec();
}
| [
"1220366326@qq.com"
] | 1220366326@qq.com |
1dd2d68ddb316f5b9952a0580aeb5a69023ce175 | 4780d22cc6726c3b8856d961031fcba614d64cd8 | /include/ShaderManager.h | 583e3f7ec92b1da1fb6fed704ed72fb93a055f7d | [] | no_license | kobapotch/OpenGLLearning | 113ac6e17eb389be7e233f186c46b1b9214c2638 | 05da7c41f06b2aba353f320065e97f506f4fcb32 | refs/heads/master | 2016-09-05T18:04:15.635140 | 2015-06-04T08:12:57 | 2015-06-04T08:12:57 | 33,104,980 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 431 | h | #ifndef _SHADERMANAGER_INCLUDED
#define _SHADERMANAGER_INCLUDED
#include <GLFW/glfw3.h>
class ShaderManager{
private:
GLuint vertexShaderID;
GLuint fragmentShaderID;
// リンクしたシェーダーのID
GLuint programID;
void compileShader(const char*, GLuint&);
public:
void compileVertexShader(const char*);
void compileFragmentShader(const char*);
GLuint linkShader();
};
#endif
| [
"kobapotch@kobayashitakuya-no-MacBook-Pro.local"
] | kobapotch@kobayashitakuya-no-MacBook-Pro.local |
101da9df5e8f2767d67500acbaf6c24796f776b1 | dc433b22bd676a3eba982a904227cf47ebabe101 | /01-scanners/lexer.hh | cb500cbbd627816aa36199d07e8ac405ec8ee887 | [] | no_license | VladimirVolodya/CompilersCourse | 0b69155f91e3301a90a4533059889fae7bac3e50 | 055d1404c0c2a37cd5106b95f73c856e02612750 | refs/heads/master | 2023-03-10T06:41:50.138766 | 2021-02-22T18:46:57 | 2021-02-22T18:46:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 311 | hh | #pragma once
#if ! defined(yyFlexLexerOnce)
#include <FlexLexer.h>
#endif
#undef YY_DECL
#define YY_DECL int Lexer::ScanToken()
// ScanToken is function that calls Scanner; It returns int values, we will use enums!
class Lexer: public yyFlexLexer {
public:
virtual ~Lexer() {}
virtual int ScanToken();
};
| [
"akhtyamovpavel@gmail.com"
] | akhtyamovpavel@gmail.com |
3960003eadfee618e1772674221e78870ca34793 | f642bef457a17554209b0cedad21de984000e03d | /AD/LifeBonus.cpp | 39e88bb463469c5c90c9540b72701659d09bfd09 | [
"MIT"
] | permissive | simonNaveau/AsteroidsDestruction | b1d8ba5e3034fa6325724e62656833f13490d098 | 2f0e0f1e620f3328b54ed96dc1b5aebbc381fa59 | refs/heads/master | 2020-09-08T09:11:18.754340 | 2019-12-16T08:22:36 | 2019-12-16T08:22:36 | 221,088,495 | 1 | 0 | MIT | 2019-12-12T10:59:06 | 2019-11-11T23:26:06 | C++ | UTF-8 | C++ | false | false | 835 | cpp | #include "LifeBonus.h"
#include "Game.h"
extern Game *game; //there
LifeBonus::LifeBonus(int lchange, qreal xParentCoordinate, qreal yParentCoordinate, QGraphicsItem *parent)
: ObstacleItem(0, 0, 0, xParentCoordinate, yParentCoordinate, parent), LifeChanger(lchange) {
animationTimer = new QTimer();
setPixmap(QPixmap(":/images/bonus0.png"));
animationCount = 0;
setPos(xParentCoordinate, yParentCoordinate);
getTimer()->stop();
connect(animationTimer, SIGNAL(timeout()), this, SLOT(animation()));
animationTimer->start(70);
}
LifeBonus::~LifeBonus() {
delete animationTimer;
}
void LifeBonus::animation() {
animationCount++;
if (animationCount >= 4) animationCount = 0;
QString image = QString(":/images/Bonus/bonus%1.png").arg(animationCount);
setPixmap(QPixmap(image));
}
| [
"loic.travaille@gmail.com"
] | loic.travaille@gmail.com |
03c1d3e6765f66bf87e3699ffb626e84303af5d8 | e298082b9650874e1442065e6980d3e2f0fa9a83 | /src/qt/editaddressdialog.cpp | 7cc3839c37d1234ab94582b88831e405b49b9807 | [
"MIT"
] | permissive | pascalcoinclassic/pascalcoinclassic | b9ceead263bc290f195c1a5fac3527b8298a1e43 | 9828f512ded050d0f0d6e85830bd41d2c89e29b4 | refs/heads/master | 2021-07-04T15:45:38.203559 | 2017-09-26T00:43:45 | 2017-09-26T00:43:45 | 104,816,925 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,740 | cpp | #include "editaddressdialog.h"
#include "ui_editaddressdialog.h"
#include "addresstablemodel.h"
#include "guiutil.h"
#include <QDataWidgetMapper>
#include <QMessageBox>
EditAddressDialog::EditAddressDialog(Mode mode, QWidget *parent) :
QDialog(parent),
ui(new Ui::EditAddressDialog), mapper(0), mode(mode), model(0)
{
ui->setupUi(this);
GUIUtil::setupAddressWidget(ui->addressEdit, this);
switch(mode)
{
case NewReceivingAddress:
setWindowTitle(tr("New receiving address"));
ui->addressEdit->setEnabled(false);
break;
case NewSendingAddress:
setWindowTitle(tr("New sending address"));
break;
case EditReceivingAddress:
setWindowTitle(tr("Edit receiving address"));
ui->addressEdit->setEnabled(false);
break;
case EditSendingAddress:
setWindowTitle(tr("Edit sending address"));
break;
}
mapper = new QDataWidgetMapper(this);
mapper->setSubmitPolicy(QDataWidgetMapper::ManualSubmit);
}
EditAddressDialog::~EditAddressDialog()
{
delete ui;
}
void EditAddressDialog::setModel(AddressTableModel *model)
{
this->model = model;
if(!model)
return;
mapper->setModel(model);
mapper->addMapping(ui->labelEdit, AddressTableModel::Label);
mapper->addMapping(ui->addressEdit, AddressTableModel::Address);
}
void EditAddressDialog::loadRow(int row)
{
mapper->setCurrentIndex(row);
}
bool EditAddressDialog::saveCurrentRow()
{
if(!model)
return false;
switch(mode)
{
case NewReceivingAddress:
case NewSendingAddress:
address = model->addRow(
mode == NewSendingAddress ? AddressTableModel::Send : AddressTableModel::Receive,
ui->labelEdit->text(),
ui->addressEdit->text());
break;
case EditReceivingAddress:
case EditSendingAddress:
if(mapper->submit())
{
address = ui->addressEdit->text();
}
break;
}
return !address.isEmpty();
}
void EditAddressDialog::accept()
{
if(!model)
return;
if(!saveCurrentRow())
{
switch(model->getEditStatus())
{
case AddressTableModel::OK:
// Failed with unknown reason. Just reject.
break;
case AddressTableModel::NO_CHANGES:
// No changes were made during edit operation. Just reject.
break;
case AddressTableModel::INVALID_ADDRESS:
QMessageBox::warning(this, windowTitle(),
tr("The entered address \"%1\" is not a valid pascalcoinclassic address.").arg(ui->addressEdit->text()),
QMessageBox::Ok, QMessageBox::Ok);
break;
case AddressTableModel::DUPLICATE_ADDRESS:
QMessageBox::warning(this, windowTitle(),
tr("The entered address \"%1\" is already in the address book.").arg(ui->addressEdit->text()),
QMessageBox::Ok, QMessageBox::Ok);
break;
case AddressTableModel::WALLET_UNLOCK_FAILURE:
QMessageBox::critical(this, windowTitle(),
tr("Could not unlock wallet."),
QMessageBox::Ok, QMessageBox::Ok);
break;
case AddressTableModel::KEY_GENERATION_FAILURE:
QMessageBox::critical(this, windowTitle(),
tr("New key generation failed."),
QMessageBox::Ok, QMessageBox::Ok);
break;
}
return;
}
QDialog::accept();
}
QString EditAddressDialog::getAddress() const
{
return address;
}
void EditAddressDialog::setAddress(const QString &address)
{
this->address = address;
ui->addressEdit->setText(address);
}
| [
"pascalcoinclassic@gmx.com"
] | pascalcoinclassic@gmx.com |
080dabb32c1a16656f0c60f7d53a008557a5c9a5 | 617d4e8112bc7f71aecf1c44f4fdbc01adb7ecfd | /libs/OpenMesh3.0/include/OpenMesh/Tools/Subdivider/Uniform/Sqrt3T.hh | 964a27ebdde8a6998e47dd817961d2c78a0bd878 | [] | no_license | Zhengjun-Du/PoissonDeformation | fc20ebbd43fe32b8056b5397d5030c1d72ff79ac | adff9041f8e031b9077163c6aa794e356354cd70 | refs/heads/master | 2022-03-18T10:33:10.662977 | 2022-03-03T01:44:24 | 2022-03-03T01:44:24 | 230,398,204 | 42 | 6 | null | null | null | null | UTF-8 | C++ | false | false | 17,748 | hh | /*===========================================================================*\
* *
* OpenMesh *
* Copyright (C) 2001-2014 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
* *
* OpenMesh is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
* published by the Free Software Foundation, either version 3 of *
* the License, or (at your option) any later version with the *
* following exceptions: *
* *
* If other files instantiate templates or use macros *
* or inline functions from this file, or you compile this file and *
* link it with other files to produce an executable, this file does *
* not by itself cause the resulting executable to be covered by the *
* GNU Lesser General Public License. This exception does not however *
* invalidate any other reasons why the executable file might be *
* covered by the GNU Lesser General Public License. *
* *
* OpenMesh is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU LesserGeneral Public *
* License along with OpenMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
/*===========================================================================*\
* *
* $Revision: 990 $ *
* $Date: 2014-02-05 10:01:07 +0100 (Mi, 05 Feb 2014) $ *
* *
\*===========================================================================*/
/** \file Sqrt3T.hh
*/
//=============================================================================
//
// CLASS Sqrt3T
//
//=============================================================================
#ifndef OPENMESH_SUBDIVIDER_UNIFORM_SQRT3T_HH
#define OPENMESH_SUBDIVIDER_UNIFORM_SQRT3T_HH
//== INCLUDES =================================================================
#include <OpenMesh/Core/Mesh/Handles.hh>
#include <OpenMesh/Core/System/config.hh>
#include <OpenMesh/Tools/Subdivider/Uniform/SubdividerT.hh>
#if defined(_DEBUG) || defined(DEBUG)
// Makes life lot easier, when playing/messing around with low-level topology
// changing methods of OpenMesh
# include <OpenMesh/Tools/Utils/MeshCheckerT.hh>
# define ASSERT_CONSISTENCY( T, m ) \
assert(OpenMesh::Utils::MeshCheckerT<T>(m).check())
#else
# define ASSERT_CONSISTENCY( T, m )
#endif
// -------------------- STL
#include <vector>
#if defined(OM_CC_MIPS)
# include <math.h>
#else
# include <cmath>
#endif
//== NAMESPACE ================================================================
namespace OpenMesh { // BEGIN_NS_OPENMESH
namespace Subdivider { // BEGIN_NS_DECIMATER
namespace Uniform { // BEGIN_NS_DECIMATER
//== CLASS DEFINITION =========================================================
/** %Uniform Sqrt3 subdivision algorithm
*
* Implementation as described in
*
* L. Kobbelt, <a href="http://www-i8.informatik.rwth-aachen.de/publications/downloads/sqrt3.pdf">"Sqrt(3) subdivision"</a>, Proceedings of SIGGRAPH 2000.
*/
template <typename MeshType, typename RealType = float>
class Sqrt3T : public SubdividerT< MeshType, RealType >
{
public:
typedef RealType real_t;
typedef MeshType mesh_t;
typedef SubdividerT< mesh_t, real_t > parent_t;
typedef std::pair< real_t, real_t > weight_t;
typedef std::vector< std::pair<real_t,real_t> > weights_t;
public:
Sqrt3T(void) : parent_t(), _1over3( real_t(1.0/3.0) ), _1over27( real_t(1.0/27.0) )
{ init_weights(); }
Sqrt3T(MeshType &_m) : parent_t(_m), _1over3( real_t(1.0/3.0) ), _1over27( real_t(1.0/27.0) )
{ init_weights(); }
virtual ~Sqrt3T() {}
public:
const char *name() const { return "Uniform Sqrt3"; }
/// Pre-compute weights
void init_weights(size_t _max_valence=50)
{
weights_.resize(_max_valence);
std::generate(weights_.begin(), weights_.end(), compute_weight());
}
protected:
bool prepare( MeshType& _m )
{
_m.request_edge_status();
_m.add_property( vp_pos_ );
_m.add_property( ep_nv_ );
_m.add_property( mp_gen_ );
_m.property( mp_gen_ ) = 0;
return _m.has_edge_status() && vp_pos_.is_valid()
&& ep_nv_.is_valid() && mp_gen_.is_valid();
}
bool cleanup( MeshType& _m )
{
_m.release_edge_status();
_m.remove_property( vp_pos_ );
_m.remove_property( ep_nv_ );
_m.remove_property( mp_gen_ );
return true;
}
bool subdivide( MeshType& _m, size_t _n , const bool _update_points = true)
{
///TODO:Implement fixed positions
typename MeshType::VertexIter vit;
typename MeshType::VertexVertexIter vvit;
typename MeshType::EdgeIter eit;
typename MeshType::FaceIter fit;
typename MeshType::FaceVertexIter fvit;
typename MeshType::VertexHandle vh;
typename MeshType::HalfedgeHandle heh;
typename MeshType::Point pos(0,0,0), zero(0,0,0);
size_t &gen = _m.property( mp_gen_ );
for (size_t l=0; l<_n; ++l)
{
// tag existing edges
for (eit=_m.edges_begin(); eit != _m.edges_end();++eit)
{
_m.status( *eit ).set_tagged( true );
if ( (gen%2) && _m.is_boundary(*eit) )
compute_new_boundary_points( _m, *eit ); // *) creates new vertices
}
// do relaxation of old vertices, but store new pos in property vp_pos_
for (vit=_m.vertices_begin(); vit!=_m.vertices_end(); ++vit)
{
if ( _m.is_boundary(*vit) )
{
if ( gen%2 )
{
heh = _m.halfedge_handle(*vit);
if (heh.is_valid()) // skip isolated newly inserted vertices *)
{
typename OpenMesh::HalfedgeHandle
prev_heh = _m.prev_halfedge_handle(heh);
assert( _m.is_boundary(heh ) );
assert( _m.is_boundary(prev_heh) );
pos = _m.point(_m.to_vertex_handle(heh));
pos += _m.point(_m.from_vertex_handle(prev_heh));
pos *= real_t(4.0);
pos += real_t(19.0) * _m.point( *vit );
pos *= _1over27;
_m.property( vp_pos_, *vit ) = pos;
}
}
else
_m.property( vp_pos_, *vit ) = _m.point( *vit );
}
else
{
size_t valence=0;
pos = zero;
for ( vvit = _m.vv_iter(*vit); vvit.is_valid(); ++vvit)
{
pos += _m.point( *vvit );
++valence;
}
pos *= weights_[ valence ].second;
pos += weights_[ valence ].first * _m.point(*vit);
_m.property( vp_pos_, *vit ) = pos;
}
}
// insert new vertices, but store pos in vp_pos_
typename MeshType::FaceIter fend = _m.faces_end();
for (fit = _m.faces_begin();fit != fend; ++fit)
{
if ( (gen%2) && _m.is_boundary(*fit))
{
boundary_split( _m, *fit );
}
else
{
fvit = _m.fv_iter( *fit );
pos = _m.point( *fvit);
pos += _m.point(*(++fvit));
pos += _m.point(*(++fvit));
pos *= _1over3;
vh = _m.add_vertex( zero );
_m.property( vp_pos_, vh ) = pos;
_m.split( *fit, vh );
}
}
// commit new positions (now iterating over all vertices)
for (vit=_m.vertices_begin();vit != _m.vertices_end(); ++vit)
_m.set_point(*vit, _m.property( vp_pos_, *vit ) );
// flip old edges
for (eit=_m.edges_begin(); eit != _m.edges_end(); ++eit)
if ( _m.status( *eit ).tagged() && !_m.is_boundary( *eit ) )
_m.flip(*eit);
// Now we have an consistent mesh!
ASSERT_CONSISTENCY( MeshType, _m );
// increase generation by one
++gen;
}
return true;
}
private:
/// Helper functor to compute weights for sqrt(3)-subdivision
/// \internal
struct compute_weight
{
compute_weight() : valence(-1) { }
weight_t operator() (void)
{
#if !defined(OM_CC_MIPS)
using std::cos;
#endif
if (++valence)
{
real_t alpha = real_t( (4.0-2.0*cos(2.0*M_PI / real_t(valence)) )/9.0 );
return weight_t( real_t(1)-alpha, alpha/real_t(valence) );
}
return weight_t(real_t(0.0), real_t(0.0) );
}
int valence;
};
private:
// Pre-compute location of new boundary points for odd generations
// and store them in the edge property ep_nv_;
void compute_new_boundary_points( MeshType& _m,
const typename MeshType::EdgeHandle& _eh)
{
assert( _m.is_boundary(_eh) );
typename MeshType::HalfedgeHandle heh;
typename MeshType::VertexHandle vh1, vh2, vh3, vh4, vhl, vhr;
typename MeshType::Point zero(0,0,0), P1, P2, P3, P4;
/*
// *---------*---------*
// / \ / \ / \
// / \ / \ / \
// / \ / \ / \
// / \ / \ / \
// *---------*--#---#--*---------*
//
// ^ ^ ^ ^ ^ ^
// P1 P2 pl pr P3 P4
*/
// get halfedge pointing from P3 to P2 (outer boundary halfedge)
heh = _m.halfedge_handle(_eh,
_m.is_boundary(_m.halfedge_handle(_eh,1)));
assert( _m.is_boundary( _m.next_halfedge_handle( heh ) ) );
assert( _m.is_boundary( _m.prev_halfedge_handle( heh ) ) );
vh1 = _m.to_vertex_handle( _m.next_halfedge_handle( heh ) );
vh2 = _m.to_vertex_handle( heh );
vh3 = _m.from_vertex_handle( heh );
vh4 = _m.from_vertex_handle( _m.prev_halfedge_handle( heh ));
P1 = _m.point(vh1);
P2 = _m.point(vh2);
P3 = _m.point(vh3);
P4 = _m.point(vh4);
vhl = _m.add_vertex(zero);
vhr = _m.add_vertex(zero);
_m.property(vp_pos_, vhl ) = (P1 + real_t(16.0f) * P2 + real_t(10.0f) * P3) * _1over27;
_m.property(vp_pos_, vhr ) = ( real_t(10.0f) * P2 + real_t(16.0f) * P3 + P4) * _1over27;
_m.property(ep_nv_, _eh).first = vhl;
_m.property(ep_nv_, _eh).second = vhr;
}
void boundary_split( MeshType& _m, const typename MeshType::FaceHandle& _fh )
{
assert( _m.is_boundary(_fh) );
typename MeshType::VertexHandle vhl, vhr;
typename MeshType::FaceEdgeIter fe_it;
typename MeshType::HalfedgeHandle heh;
// find boundary edge
for( fe_it=_m.fe_iter( _fh ); fe_it.is_valid() && !_m.is_boundary( *fe_it ); ++fe_it ) {};
// use precomputed, already inserted but not linked vertices
vhl = _m.property(ep_nv_, *fe_it).first;
vhr = _m.property(ep_nv_, *fe_it).second;
/*
// *---------*---------*
// / \ / \ / \
// / \ / \ / \
// / \ / \ / \
// / \ / \ / \
// *---------*--#---#--*---------*
//
// ^ ^ ^ ^ ^ ^
// P1 P2 pl pr P3 P4
*/
// get halfedge pointing from P2 to P3 (inner boundary halfedge)
heh = _m.halfedge_handle(*fe_it,
_m.is_boundary(_m.halfedge_handle(*fe_it,0)));
typename MeshType::HalfedgeHandle pl_P3;
// split P2->P3 (heh) in P2->pl (heh) and pl->P3
boundary_split( _m, heh, vhl ); // split edge
pl_P3 = _m.next_halfedge_handle( heh ); // store next halfedge handle
boundary_split( _m, heh ); // split face
// split pl->P3 in pl->pr and pr->P3
boundary_split( _m, pl_P3, vhr );
boundary_split( _m, pl_P3 );
assert( _m.is_boundary( vhl ) && _m.halfedge_handle(vhl).is_valid() );
assert( _m.is_boundary( vhr ) && _m.halfedge_handle(vhr).is_valid() );
}
void boundary_split(MeshType& _m,
const typename MeshType::HalfedgeHandle& _heh,
const typename MeshType::VertexHandle& _vh)
{
assert( _m.is_boundary( _m.edge_handle(_heh) ) );
typename MeshType::HalfedgeHandle
heh(_heh),
opp_heh( _m.opposite_halfedge_handle(_heh) ),
new_heh, opp_new_heh;
typename MeshType::VertexHandle to_vh(_m.to_vertex_handle(heh));
typename MeshType::HalfedgeHandle t_heh;
/*
* P5
* *
* /|\
* / \
* / \
* / \
* / \
* /_ heh new \
* *-----\*-----\*\-----*
* ^ ^ t_heh
* _vh to_vh
*
* P1 P2 P3 P4
*/
// Re-Setting Handles
// find halfedge point from P4 to P3
for(t_heh = heh;
_m.next_halfedge_handle(t_heh) != opp_heh;
t_heh = _m.opposite_halfedge_handle(_m.next_halfedge_handle(t_heh)))
{}
assert( _m.is_boundary( t_heh ) );
new_heh = _m.new_edge( _vh, to_vh );
opp_new_heh = _m.opposite_halfedge_handle(new_heh);
// update halfedge connectivity
_m.set_next_halfedge_handle(t_heh, opp_new_heh); // P4-P3 -> P3-P2
// P2-P3 -> P3-P5
_m.set_next_halfedge_handle(new_heh, _m.next_halfedge_handle(heh));
_m.set_next_halfedge_handle(heh, new_heh); // P1-P2 -> P2-P3
_m.set_next_halfedge_handle(opp_new_heh, opp_heh); // P3-P2 -> P2-P1
// both opposite halfedges point to same face
_m.set_face_handle(opp_new_heh, _m.face_handle(opp_heh));
// let heh finally point to new inserted vertex
_m.set_vertex_handle(heh, _vh);
// let heh and new_heh point to same face
_m.set_face_handle(new_heh, _m.face_handle(heh));
// let opp_new_heh be the new outgoing halfedge for to_vh
// (replaces for opp_heh)
_m.set_halfedge_handle( to_vh, opp_new_heh );
// let opp_heh be the outgoing halfedge for _vh
_m.set_halfedge_handle( _vh, opp_heh );
}
void boundary_split( MeshType& _m,
const typename MeshType::HalfedgeHandle& _heh)
{
assert( _m.is_boundary( _m.opposite_halfedge_handle( _heh ) ) );
typename MeshType::HalfedgeHandle
heh(_heh),
n_heh(_m.next_halfedge_handle(heh));
typename MeshType::VertexHandle
to_vh(_m.to_vertex_handle(heh));
typename MeshType::HalfedgeHandle
heh2(_m.new_edge(to_vh,
_m.to_vertex_handle(_m.next_halfedge_handle(n_heh)))),
heh3(_m.opposite_halfedge_handle(heh2));
typename MeshType::FaceHandle
new_fh(_m.new_face()),
fh(_m.face_handle(heh));
// Relink (half)edges
#define set_next_heh set_next_halfedge_handle
#define next_heh next_halfedge_handle
_m.set_face_handle(heh, new_fh);
_m.set_face_handle(heh2, new_fh);
_m.set_next_heh(heh2, _m.next_heh(_m.next_heh(n_heh)));
_m.set_next_heh(heh, heh2);
_m.set_face_handle( _m.next_heh(heh2), new_fh);
// _m.set_face_handle( _m.next_heh(_m.next_heh(heh2)), new_fh);
_m.set_next_heh(heh3, n_heh);
_m.set_next_heh(_m.next_halfedge_handle(n_heh), heh3);
_m.set_face_handle(heh3, fh);
// _m.set_face_handle(n_heh, fh);
_m.set_halfedge_handle( fh, n_heh);
_m.set_halfedge_handle(new_fh, heh);
#undef set_next_halfedge_handle
#undef next_halfedge_handle
}
private:
weights_t weights_;
OpenMesh::VPropHandleT< typename MeshType::Point > vp_pos_;
OpenMesh::EPropHandleT< std::pair< typename MeshType::VertexHandle,
typename MeshType::VertexHandle> > ep_nv_;
OpenMesh::MPropHandleT< size_t > mp_gen_;
const real_t _1over3;
const real_t _1over27;
};
//=============================================================================
} // END_NS_UNIFORM
} // END_NS_SUBDIVIDER
} // END_NS_OPENMESH
//=============================================================================
#endif // OPENMESH_SUBDIVIDER_UNIFORM_SQRT3T_HH
//=============================================================================
| [
"duzjqhu@aliyun.com"
] | duzjqhu@aliyun.com |
2722fb0d620f836e502dd47ec2fac1ff74c3e39f | db6903560e8c816b85b9adec3187f688f8e40289 | /VisualUltimate/WindowsSDKs/vc7/Include/math.h | 14f829052b7e1caba1fc3409c4a47e8989a13d2b | [] | no_license | QianNangong/VC6Ultimate | 846a4e610859fab5c9d8fb73fa5c9321e7a2a65e | 0c74cf644fbdd38018c8d94c9ea9f8b72782ef7c | refs/heads/master | 2022-05-05T17:49:52.120385 | 2019-03-07T14:46:51 | 2019-03-07T14:46:51 | 147,986,727 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 20,702 | h | /***
*math.h - definitions and declarations for math library
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*
*Purpose:
* This file contains constant definitions and external subroutine
* declarations for the math subroutine library.
* [ANSI/System V]
*
* [Public]
*
****/
#if _MSC_VER > 1000
#pragma once
#endif
#ifndef _INC_MATH
#define _INC_MATH
#if !defined(_WIN32)
#error ERROR: Only Win32 target supported!
#endif
#ifdef _MSC_VER
/*
* Currently, all MS C compilers for Win32 platforms default to 8 byte
* alignment.
*/
#pragma pack(push,8)
#endif /* _MSC_VER */
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __assembler /* Protect from assembler */
/* Define _CRTIMP */
#ifndef _CRTIMP
#ifdef _DLL
#define _CRTIMP __declspec(dllimport)
#else /* ndef _DLL */
#define _CRTIMP
#endif /* _DLL */
#endif /* _CRTIMP */
/* Define __cdecl for non-Microsoft compilers */
#if ( !defined(_MSC_VER) && !defined(__cdecl) )
#define __cdecl
#endif
/* Definition of _exception struct - this struct is passed to the matherr
* routine when a floating point exception is detected
*/
#ifndef _EXCEPTION_DEFINED
struct _exception {
int type; /* exception type - see below */
char *name; /* name of function where error occured */
double arg1; /* first argument to function */
double arg2; /* second argument (if any) to function */
double retval; /* value to be returned by function */
} ;
#define _EXCEPTION_DEFINED
#endif
/* Definition of a _complex struct to be used by those who use cabs and
* want type checking on their argument
*/
#ifndef _COMPLEX_DEFINED
struct _complex {
double x,y; /* real and imaginary parts */
} ;
#if !__STDC__ && !defined (__cplusplus)
/* Non-ANSI name for compatibility */
#define complex _complex
#endif
#define _COMPLEX_DEFINED
#endif
#endif /* __assembler */
/* Constant definitions for the exception type passed in the _exception struct
*/
#define _DOMAIN 1 /* argument domain error */
#define _SING 2 /* argument singularity */
#define _OVERFLOW 3 /* overflow range error */
#define _UNDERFLOW 4 /* underflow range error */
#define _TLOSS 5 /* total loss of precision */
#define _PLOSS 6 /* partial loss of precision */
#define EDOM 33
#define ERANGE 34
/* Definitions of _HUGE and HUGE_VAL - respectively the XENIX and ANSI names
* for a value returned in case of error by a number of the floating point
* math routines
*/
#ifndef __assembler /* Protect from assembler */
_CRTIMP extern double _HUGE;
#endif /* __assembler */
#define HUGE_VAL _HUGE
#ifdef _USE_MATH_DEFINES
/* Define _USE_MATH_DEFINES before including math.h to expose these macro
* definitions for common math constants. These are placed under an #ifdef
* since these commonly-defined names are not part of the C/C++ standards.
*/
/* Definitions of useful mathematical constants
* M_E - e
* M_LOG2E - log2(e)
* M_LOG10E - log10(e)
* M_LN2 - ln(2)
* M_LN10 - ln(10)
* M_PI - pi
* M_PI_2 - pi/2
* M_PI_4 - pi/4
* M_1_PI - 1/pi
* M_2_PI - 2/pi
* M_2_SQRTPI - 2/sqrt(pi)
* M_SQRT2 - sqrt(2)
* M_SQRT1_2 - 1/sqrt(2)
*/
#define M_E 2.71828182845904523536
#define M_LOG2E 1.44269504088896340736
#define M_LOG10E 0.434294481903251827651
#define M_LN2 0.693147180559945309417
#define M_LN10 2.30258509299404568402
#define M_PI 3.14159265358979323846
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.785398163397448309616
#define M_1_PI 0.318309886183790671538
#define M_2_PI 0.636619772367581343076
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2 1.41421356237309504880
#define M_SQRT1_2 0.707106781186547524401
#endif /* _USE_MATH_DEFINES */
/* Function prototypes */
#if !defined(__assembler) /* Protect from assembler */
#if defined(_M_MRX000)
_CRTIMP int __cdecl abs(int);
_CRTIMP double __cdecl acos(double);
_CRTIMP double __cdecl asin(double);
_CRTIMP double __cdecl atan(double);
_CRTIMP double __cdecl atan2(double, double);
_CRTIMP double __cdecl cos(double);
_CRTIMP double __cdecl cosh(double);
_CRTIMP double __cdecl exp(double);
_CRTIMP double __cdecl fabs(double);
_CRTIMP double __cdecl fmod(double, double);
_CRTIMP long __cdecl labs(long);
_CRTIMP double __cdecl log(double);
_CRTIMP double __cdecl log10(double);
_CRTIMP double __cdecl pow(double, double);
_CRTIMP double __cdecl sin(double);
_CRTIMP double __cdecl sinh(double);
_CRTIMP double __cdecl tan(double);
_CRTIMP double __cdecl tanh(double);
_CRTIMP double __cdecl sqrt(double);
#else
int __cdecl abs(int);
double __cdecl acos(double);
double __cdecl asin(double);
double __cdecl atan(double);
double __cdecl atan2(double, double);
double __cdecl cos(double);
double __cdecl cosh(double);
double __cdecl exp(double);
double __cdecl fabs(double);
double __cdecl fmod(double, double);
long __cdecl labs(long);
double __cdecl log(double);
double __cdecl log10(double);
double __cdecl pow(double, double);
double __cdecl sin(double);
double __cdecl sinh(double);
double __cdecl tan(double);
double __cdecl tanh(double);
double __cdecl sqrt(double);
#endif
_CRTIMP double __cdecl atof(const char *);
_CRTIMP double __cdecl _cabs(struct _complex);
#if defined(_M_ALPHA)
double __cdecl ceil(double);
double __cdecl floor(double);
#else
_CRTIMP double __cdecl ceil(double);
_CRTIMP double __cdecl floor(double);
#endif
_CRTIMP double __cdecl frexp(double, int *);
_CRTIMP double __cdecl _hypot(double, double);
_CRTIMP double __cdecl _j0(double);
_CRTIMP double __cdecl _j1(double);
_CRTIMP double __cdecl _jn(int, double);
_CRTIMP double __cdecl ldexp(double, int);
int __cdecl _matherr(struct _exception *);
_CRTIMP double __cdecl modf(double, double *);
_CRTIMP double __cdecl _y0(double);
_CRTIMP double __cdecl _y1(double);
_CRTIMP double __cdecl _yn(int, double);
#if defined(_M_IX86)
_CRTIMP int __cdecl _set_SSE2_enable(int);
#endif
#if defined(_M_MRX000)
/* MIPS fast prototypes for float */
/* ANSI C, 4.5 Mathematics */
/* 4.5.2 Trigonometric functions */
_CRTIMP float __cdecl acosf( float );
_CRTIMP float __cdecl asinf( float );
_CRTIMP float __cdecl atanf( float );
_CRTIMP float __cdecl atan2f( float , float );
_CRTIMP float __cdecl cosf( float );
_CRTIMP float __cdecl sinf( float );
_CRTIMP float __cdecl tanf( float );
/* 4.5.3 Hyperbolic functions */
_CRTIMP float __cdecl coshf( float );
_CRTIMP float __cdecl sinhf( float );
_CRTIMP float __cdecl tanhf( float );
/* 4.5.4 Exponential and logarithmic functions */
_CRTIMP float __cdecl expf( float );
_CRTIMP float __cdecl logf( float );
_CRTIMP float __cdecl log10f( float );
_CRTIMP float __cdecl modff( float , float* );
/* 4.5.5 Power functions */
_CRTIMP float __cdecl powf( float , float );
float __cdecl sqrtf( float );
/* 4.5.6 Nearest integer, absolute value, and remainder functions */
float __cdecl ceilf( float );
float __cdecl fabsf( float );
float __cdecl floorf( float );
_CRTIMP float __cdecl fmodf( float , float );
_CRTIMP float __cdecl hypotf(float, float);
#endif /* _M_MRX000 */
#if defined(_M_ALPHA)
/* ALPHA fast prototypes for float */
/* ANSI C, 4.5 Mathematics */
/* 4.5.2 Trigonometric functions */
float __cdecl acosf( float );
float __cdecl asinf( float );
float __cdecl atanf( float );
float __cdecl atan2f( float , float );
float __cdecl cosf( float );
float __cdecl sinf( float );
float __cdecl tanf( float );
/* 4.5.3 Hyperbolic functions */
float __cdecl coshf( float );
float __cdecl sinhf( float );
float __cdecl tanhf( float );
/* 4.5.4 Exponential and logarithmic functions */
float __cdecl expf( float );
float __cdecl logf( float );
float __cdecl log10f( float );
_CRTIMP float __cdecl modff( float , float* );
/* 4.5.5 Power functions */
float __cdecl powf( float , float );
float __cdecl sqrtf( float );
/* 4.5.6 Nearest integer, absolute value, and remainder functions */
float __cdecl ceilf( float );
float __cdecl fabsf( float );
float __cdecl floorf( float );
float __cdecl fmodf( float , float );
_CRTIMP float __cdecl _hypotf(float, float);
#endif /* _M_ALPHA */
#if defined(_M_IA64)
/* ANSI C, 4.5 Mathematics */
/* 4.5.2 Trigonometric functions */
float __cdecl acosf( float );
float __cdecl asinf( float );
float __cdecl atanf( float );
float __cdecl atan2f( float , float );
float __cdecl cosf( float );
float __cdecl sinf( float );
float __cdecl tanf( float );
/* 4.5.3 Hyperbolic functions */
float __cdecl coshf( float );
float __cdecl sinhf( float );
float __cdecl tanhf( float );
/* 4.5.4 Exponential and logarithmic functions */
float __cdecl expf( float );
float __cdecl logf( float );
float __cdecl log10f( float );
float __cdecl modff( float , float* );
/* 4.5.5 Power functions */
float __cdecl powf( float , float );
float __cdecl sqrtf( float );
/* 4.5.6 Nearest integer, absolute value, and remainder functions */
float __cdecl ceilf( float );
float __cdecl fabsf( float );
float __cdecl floorf( float );
float __cdecl fmodf( float , float );
float __cdecl hypotf(float, float);
#endif /* _M_IA64 */
/* Macros defining long double functions to be their double counterparts
* (long double is synonymous with double in this implementation).
*/
#ifndef __cplusplus
#define acosl(x) ((long double)acos((double)(x)))
#define asinl(x) ((long double)asin((double)(x)))
#define atanl(x) ((long double)atan((double)(x)))
#define atan2l(x,y) ((long double)atan2((double)(x), (double)(y)))
#define _cabsl _cabs
#define ceill(x) ((long double)ceil((double)(x)))
#define cosl(x) ((long double)cos((double)(x)))
#define coshl(x) ((long double)cosh((double)(x)))
#define expl(x) ((long double)exp((double)(x)))
#define fabsl(x) ((long double)fabs((double)(x)))
#define floorl(x) ((long double)floor((double)(x)))
#define fmodl(x,y) ((long double)fmod((double)(x), (double)(y)))
#define frexpl(x,y) ((long double)frexp((double)(x), (y)))
#define _hypotl(x,y) ((long double)_hypot((double)(x), (double)(y)))
#define ldexpl(x,y) ((long double)ldexp((double)(x), (y)))
#define logl(x) ((long double)log((double)(x)))
#define log10l(x) ((long double)log10((double)(x)))
#define _matherrl _matherr
#define modfl(x,y) ((long double)modf((double)(x), (double *)(y)))
#define powl(x,y) ((long double)pow((double)(x), (double)(y)))
#define sinl(x) ((long double)sin((double)(x)))
#define sinhl(x) ((long double)sinh((double)(x)))
#define sqrtl(x) ((long double)sqrt((double)(x)))
#define tanl(x) ((long double)tan((double)(x)))
#define tanhl(x) ((long double)tanh((double)(x)))
#else /* __cplusplus */
inline long double acosl(long double _X)
{return (acos((double)_X)); }
inline long double asinl(long double _X)
{return (asin((double)_X)); }
inline long double atanl(long double _X)
{return (atan((double)_X)); }
inline long double atan2l(long double _X, long double _Y)
{return (atan2((double)_X, (double)_Y)); }
inline long double ceill(long double _X)
{return (ceil((double)_X)); }
inline long double cosl(long double _X)
{return (cos((double)_X)); }
inline long double coshl(long double _X)
{return (cosh((double)_X)); }
inline long double expl(long double _X)
{return (exp((double)_X)); }
inline long double fabsl(long double _X)
{return (fabs((double)_X)); }
inline long double floorl(long double _X)
{return (floor((double)_X)); }
inline long double fmodl(long double _X, long double _Y)
{return (fmod((double)_X, (double)_Y)); }
inline long double frexpl(long double _X, int *_Y)
{return (frexp((double)_X, _Y)); }
inline long double ldexpl(long double _X, int _Y)
{return (ldexp((double)_X, _Y)); }
inline long double logl(long double _X)
{return (log((double)_X)); }
inline long double log10l(long double _X)
{return (log10((double)_X)); }
inline long double modfl(long double _X, long double *_Y)
{double _Di, _Df = modf((double)_X, &_Di);
*_Y = (long double)_Di;
return (_Df); }
inline long double powl(long double _X, long double _Y)
{return (pow((double)_X, (double)_Y)); }
inline long double sinl(long double _X)
{return (sin((double)_X)); }
inline long double sinhl(long double _X)
{return (sinh((double)_X)); }
inline long double sqrtl(long double _X)
{return (sqrt((double)_X)); }
inline long double tanl(long double _X)
{return (tan((double)_X)); }
inline long double tanhl(long double _X)
{return (tanh((double)_X)); }
inline float frexpf(float _X, int *_Y)
{return ((float)frexp((double)_X, _Y)); }
inline float ldexpf(float _X, int _Y)
{return ((float)ldexp((double)_X, _Y)); }
#if !defined(_M_MRX000) && !defined(_M_ALPHA) && !defined(_M_IA64)
inline float acosf(float _X)
{return ((float)acos((double)_X)); }
inline float asinf(float _X)
{return ((float)asin((double)_X)); }
inline float atanf(float _X)
{return ((float)atan((double)_X)); }
inline float atan2f(float _X, float _Y)
{return ((float)atan2((double)_X, (double)_Y)); }
inline float ceilf(float _X)
{return ((float)ceil((double)_X)); }
inline float cosf(float _X)
{return ((float)cos((double)_X)); }
inline float coshf(float _X)
{return ((float)cosh((double)_X)); }
inline float expf(float _X)
{return ((float)exp((double)_X)); }
inline float fabsf(float _X)
{return ((float)fabs((double)_X)); }
inline float floorf(float _X)
{return ((float)floor((double)_X)); }
inline float fmodf(float _X, float _Y)
{return ((float)fmod((double)_X, (double)_Y)); }
inline float logf(float _X)
{return ((float)log((double)_X)); }
inline float log10f(float _X)
{return ((float)log10((double)_X)); }
inline float modff(float _X, float *_Y)
{ double _Di, _Df = modf((double)_X, &_Di);
*_Y = (float)_Di;
return ((float)_Df); }
inline float powf(float _X, float _Y)
{return ((float)pow((double)_X, (double)_Y)); }
inline float sinf(float _X)
{return ((float)sin((double)_X)); }
inline float sinhf(float _X)
{return ((float)sinh((double)_X)); }
inline float sqrtf(float _X)
{return ((float)sqrt((double)_X)); }
inline float tanf(float _X)
{return ((float)tan((double)_X)); }
inline float tanhf(float _X)
{return ((float)tanh((double)_X)); }
#endif /* !defined(_M_MRX000) && !defined(_M_ALPHA) && !defined(_M_IA64) */
#endif /* __cplusplus */
#endif /* __assembler */
#if !__STDC__
/* Non-ANSI names for compatibility */
#define DOMAIN _DOMAIN
#define SING _SING
#define OVERFLOW _OVERFLOW
#define UNDERFLOW _UNDERFLOW
#define TLOSS _TLOSS
#define PLOSS _PLOSS
#define matherr _matherr
#ifndef __assembler /* Protect from assembler */
_CRTIMP extern double HUGE;
_CRTIMP double __cdecl cabs(struct _complex);
_CRTIMP double __cdecl hypot(double, double);
_CRTIMP double __cdecl j0(double);
_CRTIMP double __cdecl j1(double);
_CRTIMP double __cdecl jn(int, double);
int __cdecl matherr(struct _exception *);
_CRTIMP double __cdecl y0(double);
_CRTIMP double __cdecl y1(double);
_CRTIMP double __cdecl yn(int, double);
#endif /* __assembler */
#endif /* __STDC__ */
#ifdef __cplusplus
}
extern "C++" {
template<class _Ty> inline
_Ty _Pow_int(_Ty _X, int _Y)
{unsigned int _N;
if (_Y >= 0)
_N = _Y;
else
_N = -_Y;
for (_Ty _Z = _Ty(1); ; _X *= _X)
{if ((_N & 1) != 0)
_Z *= _X;
if ((_N >>= 1) == 0)
return (_Y < 0 ? _Ty(1) / _Z : _Z); }}
inline long __cdecl abs(long _X)
{return (labs(_X)); }
inline double __cdecl abs(double _X)
{return (fabs(_X)); }
inline double __cdecl pow(double _X, int _Y)
{return (_Pow_int(_X, _Y)); }
inline double __cdecl pow(int _X, int _Y)
{return (_Pow_int(_X, _Y)); }
inline float __cdecl abs(float _X)
{return (fabsf(_X)); }
inline float __cdecl acos(float _X)
{return (acosf(_X)); }
inline float __cdecl asin(float _X)
{return (asinf(_X)); }
inline float __cdecl atan(float _X)
{return (atanf(_X)); }
inline float __cdecl atan2(float _Y, float _X)
{return (atan2f(_Y, _X)); }
inline float __cdecl ceil(float _X)
{return (ceilf(_X)); }
inline float __cdecl cos(float _X)
{return (cosf(_X)); }
inline float __cdecl cosh(float _X)
{return (coshf(_X)); }
inline float __cdecl exp(float _X)
{return (expf(_X)); }
inline float __cdecl fabs(float _X)
{return (fabsf(_X)); }
inline float __cdecl floor(float _X)
{return (floorf(_X)); }
inline float __cdecl fmod(float _X, float _Y)
{return (fmodf(_X, _Y)); }
inline float __cdecl frexp(float _X, int * _Y)
{return (frexpf(_X, _Y)); }
inline float __cdecl ldexp(float _X, int _Y)
{return (ldexpf(_X, _Y)); }
inline float __cdecl log(float _X)
{return (logf(_X)); }
inline float __cdecl log10(float _X)
{return (log10f(_X)); }
inline float __cdecl modf(float _X, float * _Y)
{return (modff(_X, _Y)); }
inline float __cdecl pow(float _X, float _Y)
{return (powf(_X, _Y)); }
inline float __cdecl pow(float _X, int _Y)
{return (_Pow_int(_X, _Y)); }
inline float __cdecl sin(float _X)
{return (sinf(_X)); }
inline float __cdecl sinh(float _X)
{return (sinhf(_X)); }
inline float __cdecl sqrt(float _X)
{return (sqrtf(_X)); }
inline float __cdecl tan(float _X)
{return (tanf(_X)); }
inline float __cdecl tanh(float _X)
{return (tanhf(_X)); }
inline long double __cdecl abs(long double _X)
{return (fabsl(_X)); }
inline long double __cdecl acos(long double _X)
{return (acosl(_X)); }
inline long double __cdecl asin(long double _X)
{return (asinl(_X)); }
inline long double __cdecl atan(long double _X)
{return (atanl(_X)); }
inline long double __cdecl atan2(long double _Y, long double _X)
{return (atan2l(_Y, _X)); }
inline long double __cdecl ceil(long double _X)
{return (ceill(_X)); }
inline long double __cdecl cos(long double _X)
{return (cosl(_X)); }
inline long double __cdecl cosh(long double _X)
{return (coshl(_X)); }
inline long double __cdecl exp(long double _X)
{return (expl(_X)); }
inline long double __cdecl fabs(long double _X)
{return (fabsl(_X)); }
inline long double __cdecl floor(long double _X)
{return (floorl(_X)); }
inline long double __cdecl fmod(long double _X, long double _Y)
{return (fmodl(_X, _Y)); }
inline long double __cdecl frexp(long double _X, int * _Y)
{return (frexpl(_X, _Y)); }
inline long double __cdecl ldexp(long double _X, int _Y)
{return (ldexpl(_X, _Y)); }
inline long double __cdecl log(long double _X)
{return (logl(_X)); }
inline long double __cdecl log10(long double _X)
{return (log10l(_X)); }
inline long double __cdecl modf(long double _X, long double * _Y)
{return (modfl(_X, _Y)); }
inline long double __cdecl pow(long double _X, long double _Y)
{return (powl(_X, _Y)); }
inline long double __cdecl pow(long double _X, int _Y)
{return (_Pow_int(_X, _Y)); }
inline long double __cdecl sin(long double _X)
{return (sinl(_X)); }
inline long double __cdecl sinh(long double _X)
{return (sinhl(_X)); }
inline long double __cdecl sqrt(long double _X)
{return (sqrtl(_X)); }
inline long double __cdecl tan(long double _X)
{return (tanl(_X)); }
inline long double __cdecl tanh(long double _X)
{return (tanhl(_X)); }
}
#endif /* __cplusplus */
#ifdef _MSC_VER
#pragma pack(pop)
#endif /* _MSC_VER */
#endif /* _INC_MATH */
| [
"vc6@ultim.pw"
] | vc6@ultim.pw |
1c6e4cbbef8412412d343afd7cc0b33a9275ed50 | a35b30a7c345a988e15d376a4ff5c389a6e8b23a | /boost/numeric/ublas/traits.hpp | 1cc19c775feb0354eb0a5376a6b570a026e7f362 | [] | no_license | huahang/thirdparty | 55d4cc1c8a34eff1805ba90fcbe6b99eb59a7f0b | 07a5d64111a55dda631b7e8d34878ca5e5de05ab | refs/heads/master | 2021-01-15T14:29:26.968553 | 2014-02-06T07:35:22 | 2014-02-06T07:35:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 66 | hpp | #include "thirdparty/boost_1_55_0/boost/numeric/ublas/traits.hpp"
| [
"liuhuahang@xiaomi.com"
] | liuhuahang@xiaomi.com |
4325b745fea3ddf258bca95d844922d64b84f4f2 | 777a75e6ed0934c193aece9de4421f8d8db01aac | /src/Providers/UNIXProviders/PacketFilterCondition/UNIX_PacketFilterCondition_TRU64.hxx | 72a97c32a6b086cf9a006d9bd1f4496110c6e7a7 | [
"MIT"
] | permissive | brunolauze/openpegasus-providers-old | 20fc13958016e35dc4d87f93d1999db0eae9010a | b00f1aad575bae144b8538bf57ba5fd5582a4ec7 | refs/heads/master | 2021-01-01T20:05:44.559362 | 2014-04-30T17:50:06 | 2014-04-30T17:50:06 | 19,132,738 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 138 | hxx | #ifdef PEGASUS_OS_TRU64
#ifndef __UNIX_PACKETFILTERCONDITION_PRIVATE_H
#define __UNIX_PACKETFILTERCONDITION_PRIVATE_H
#endif
#endif
| [
"brunolauze@msn.com"
] | brunolauze@msn.com |
6af3cbcf2feffca7d00b2c27eb39503d31a40ba4 | 0596b46b7358a38016ab0c7d07916620e3b4cdb0 | /Test/src/Basic_checking/TestKVStoreImpl_Async_Basic.cpp | 5dca630f45895bf6909d931f8f3783fbc76c3806 | [] | no_license | JashDave/MTP_New | b942badc77b3acb3c983592698322f90ddbe1ce8 | b47ae48b8aa33f8e5d55fbb43115b7a97aa7a54e | refs/heads/master | 2021-01-24T01:29:58.769014 | 2017-06-16T13:14:21 | 2017-06-16T13:14:21 | 68,596,251 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,821 | cpp | /*
g++ -std=c++11 TestKVStoreImpl_Async_Basic.cpp -lkvstore_v2 -lboost_serialization -pthread -lkvs_redis_v2
*/
// #define CONF string("10.129.28.44:8091")
// #define CONF string("10.129.28.141:7003")
#define TABLE string("TestTable123")
// #define JDEBUG
#include "../jutils.h"
#include <iostream>
#include <cassert>
#include <kvstore/KVStoreHeader_v2.h>
using namespace std;
using namespace kvstore;
// void successfullGetCallBack(KVData<string> r){
// cout<<"DP:"<<" file:"<<__FILE__<<" line:"<<__LINE__<<endl;
// }
void successfullGetCallBack(void *data,KVData<string> r){
// cout<<"DP:"<<" file:"<<__FILE__<<" line:"<<__LINE__<<endl;
jAssert(r.ierr!=0, cout<<" Error in get(1):"<<r.serr<<" called from line "<<*((int*)data)<<endl;)
jAssert(r.value!="One", cout<<"Incorrect value from get(1) got:"<<r.value<<" called from line "<<*((int*)data)<<endl;)
TRACE(cout<<"successfull get :"<<r.value<<endl;)
}
void unsuccessfullGetCallBack(void *data,KVData<string> r){
// cout<<"DP:"<<" file:"<<__FILE__<<" line:"<<__LINE__<<endl;
jAssert(r.ierr==0, cout<<" Error in unsuccessfull get(1) got:"<<r.value<<" called from line "<<*((int*)data)<<endl;)
TRACE(cout<<"unsuccessfull get."<<endl;)
}
void successfullCallBack(void *data,KVData<string> r){
jAssert(r.ierr!=0, cout<<"Serr:"<<r.serr<<" called from line "<<*((int*)data)<<endl;)
TRACE(cout<<"successfull callback."<<endl;)
}
void unsuccessfullCallBack(void *data,KVData<string> r){
jAssert(r.ierr==0, cout<<"Error in unsuccessfull del called from line "<<*((int*)data)<<endl;)
TRACE(cout<<"unsuccessfull callback."<<endl;)
}
int main(){
KVData<string> r;
/* Create connection */
KVStore<int,string> ks;
IS_REACHABLE
bool succ = ks.bind(CONF,TABLE);
jAssert(!succ,cout<<"Connection error"<<endl;);
/* Check successfull put */
IS_REACHABLE
int line_no1 = __LINE__; ks.async_put(1,"One",successfullCallBack,&line_no1);
// sleep(1); /*wait for callbacks to complete*/
/* Check successfull get */
IS_REACHABLE
// int line_no2 = __LINE__; ks.async_get(1,successfullGetCallBack);
int line_no2 = __LINE__; ks.async_get(1,successfullGetCallBack,&line_no2);
// sleep(1); /*wait for callbacks to complete*/
/* Check successfull del */
IS_REACHABLE
int line_no3 = __LINE__; ks.async_del(1,successfullCallBack,&line_no3);
// sleep(1); /*wait for callbacks to complete*/
/* Check unsuccessfull get */
IS_REACHABLE
int line_no4 = __LINE__; ks.async_get(1,unsuccessfullGetCallBack,&line_no4);
// sleep(1); /*wait for callbacks to complete*/
/* Check unsuccessfull del */
IS_REACHABLE
int line_no5 = __LINE__; ks.async_del(1,unsuccessfullCallBack,&line_no5);
sleep(5); /*wait for callbacks to complete*/
cout<<"All testcases passed successfully for "<<__FILE__<<"."<<endl;
return 0;
}
| [
"jashdave23@gmail.com"
] | jashdave23@gmail.com |
a38302e9a27fc024190d2872ed698cb6c5685211 | d0acccde673fe3df1bb8e02fe58aeb661d6367a2 | /Even or Odd.cpp | 79c648990627be689f001c89d0cc27abff670659 | [] | no_license | MihirDichwalkar/Myrepository | 7064c4f4e97e5608cca35dfad6c978cbeaf11af2 | 160756afc09a57c3c676d34c109402d9e5d266a9 | refs/heads/master | 2022-12-22T14:05:41.301753 | 2020-09-24T09:27:24 | 2020-09-24T09:27:24 | 292,536,168 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 333 | cpp | #include <iostream>
#include <string>
using namespace std;
int main()
{
int n = 0;
int tab = 0;
cout<<"Enter the number = ";
cin>>n;
if(n%2 == 0){
cout<<"The number "<<n<<" is a Even Number.\n";
}
else{
cout<<"The number "<<n<<" is a Odd Number.\n";
}
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
6b92c1ade60ebca00a893e07f580881cfaaba046 | 1d928c3f90d4a0a9a3919a804597aa0a4aab19a3 | /c++/rocksdb/2016/8/sharded_cache.cc | b02e5b5dbfa055d60d3acb79e747d2d78e5656f7 | [] | no_license | rosoareslv/SED99 | d8b2ff5811e7f0ffc59be066a5a0349a92cbb845 | a062c118f12b93172e31e8ca115ce3f871b64461 | refs/heads/main | 2023-02-22T21:59:02.703005 | 2021-01-28T19:40:51 | 2021-01-28T19:40:51 | 306,497,459 | 1 | 1 | null | 2020-11-24T20:56:18 | 2020-10-23T01:18:07 | null | UTF-8 | C++ | false | false | 3,661 | cc | // Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree. An additional grant
// of patent rights can be found in the PATENTS file in the same directory.
//
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.
#include "util/sharded_cache.h"
#include "util/mutexlock.h"
namespace rocksdb {
ShardedCache::ShardedCache(size_t capacity, int num_shard_bits,
bool strict_capacity_limit)
: num_shard_bits_(num_shard_bits),
capacity_(capacity),
strict_capacity_limit_(strict_capacity_limit),
last_id_(1) {}
void ShardedCache::SetCapacity(size_t capacity) {
int num_shards = 1 << num_shard_bits_;
const size_t per_shard = (capacity + (num_shards - 1)) / num_shards;
MutexLock l(&capacity_mutex_);
for (int s = 0; s < num_shards; s++) {
GetShard(s)->SetCapacity(per_shard);
}
capacity_ = capacity;
}
void ShardedCache::SetStrictCapacityLimit(bool strict_capacity_limit) {
int num_shards = 1 << num_shard_bits_;
MutexLock l(&capacity_mutex_);
for (int s = 0; s < num_shards; s++) {
GetShard(s)->SetStrictCapacityLimit(strict_capacity_limit);
}
strict_capacity_limit_ = strict_capacity_limit;
}
Status ShardedCache::Insert(const Slice& key, void* value, size_t charge,
void (*deleter)(const Slice& key, void* value),
Handle** handle, Priority priority) {
uint32_t hash = HashSlice(key);
return GetShard(Shard(hash))
->Insert(key, hash, value, charge, deleter, handle, priority);
}
Cache::Handle* ShardedCache::Lookup(const Slice& key) {
uint32_t hash = HashSlice(key);
return GetShard(Shard(hash))->Lookup(key, hash);
}
void ShardedCache::Release(Handle* handle) {
uint32_t hash = GetHash(handle);
GetShard(Shard(hash))->Release(handle);
}
void ShardedCache::Erase(const Slice& key) {
uint32_t hash = HashSlice(key);
GetShard(Shard(hash))->Erase(key, hash);
}
uint64_t ShardedCache::NewId() {
return last_id_.fetch_add(1, std::memory_order_relaxed);
}
size_t ShardedCache::GetCapacity() const {
MutexLock l(&capacity_mutex_);
return capacity_;
}
bool ShardedCache::HasStrictCapacityLimit() const {
MutexLock l(&capacity_mutex_);
return strict_capacity_limit_;
}
size_t ShardedCache::GetUsage() const {
// We will not lock the cache when getting the usage from shards.
int num_shards = 1 << num_shard_bits_;
size_t usage = 0;
for (int s = 0; s < num_shards; s++) {
usage += GetShard(s)->GetUsage();
}
return usage;
}
size_t ShardedCache::GetUsage(Handle* handle) const {
return GetCharge(handle);
}
size_t ShardedCache::GetPinnedUsage() const {
// We will not lock the cache when getting the usage from shards.
int num_shards = 1 << num_shard_bits_;
size_t usage = 0;
for (int s = 0; s < num_shards; s++) {
usage += GetShard(s)->GetPinnedUsage();
}
return usage;
}
void ShardedCache::ApplyToAllCacheEntries(void (*callback)(void*, size_t),
bool thread_safe) {
int num_shards = 1 << num_shard_bits_;
for (int s = 0; s < num_shards; s++) {
GetShard(s)->ApplyToAllCacheEntries(callback, thread_safe);
}
}
void ShardedCache::EraseUnRefEntries() {
int num_shards = 1 << num_shard_bits_;
for (int s = 0; s < num_shards; s++) {
GetShard(s)->EraseUnRefEntries();
}
}
} // namespace rocksdb
| [
"rodrigosoaresilva@gmail.com"
] | rodrigosoaresilva@gmail.com |
a9fee0f0cd9922cacf3641cdbd4043263863b41d | 23ed1b706ccf7bfa4d550a4cccdad9a8665b0f2c | /FrameWork73/EffectFactory.h | 9f21a49b9e0295362ca11163be8aa016613b1d74 | [] | no_license | codnsj81/BastionCopy | 7440cfeb3984faed0ee421dd93c1d24bc27d9475 | 0cf4a8e8bfa2729b8bb61e151dcef65da6e46eed | refs/heads/master | 2020-08-05T14:27:25.083493 | 2019-10-03T12:57:56 | 2019-10-03T12:57:56 | 212,577,656 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 366 | h | #pragma once
#include "PlayerHit.h"
class CGameObject;
template<typename T>
class CEffectFactory abstract
{
public:
static CGameObject* CreateEffect(void)
{
CGameObject* pEffect = new CPlayerHit;
CBridge* pBridge = new T;
dynamic_cast<CPlayerHit*>(pEffect)->SetBridge(pBridge);
pEffect->Initialize();
pBridge->Initialize();
return pEffect;
}
};
| [
"codnsj81@naver.com"
] | codnsj81@naver.com |
e6af2bf80fc090e2cb0f428352f36d1c86235d63 | ccbf6c8092b2254a53d28f5b25ba8969f2dd086c | /LuoGu/level2/2-18_dp_moretips/P1052.cpp | d098f0606a9bdc1208319701423e91b3ade77965 | [] | no_license | wangbb13/wangbb13.github.io | 4c2ebfc03383bbaa1cf7485bbcc8c655cca5d2bb | 5ffefdb5fe15563b9e3e8fea1484d9312d19d377 | refs/heads/master | 2020-05-20T12:53:31.217109 | 2019-11-07T06:31:14 | 2019-11-07T06:31:14 | 38,562,000 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,264 | cpp | /**
* Description: cross river
* Input : L \n S T M \n pos
* L: the length of birdge
* [S, T]: jump interval
* M: # stones
* Output: the minimum number of stones on which the frog must jump
* Time/Space Limit: 1s/128MB
*/
#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
using namespace std;
int main() {
int L, S, T, M;
cin >> L >> S >> T >> M;
vector<int> stones(M + 2);
for (int i = 1; i <= M; ++i)
cin >> stones[i];
stones[0] = 0;
stones[M + 1] = L;
M += 2;
sort(stones.begin(), stones.end());
int stone_p = 0;
while (stone_p < M && stones[stone_p] < S) stone_p++;
vector<int> minsteps(T, M + 1);
for (int i = S; i <= T; ++i) {
minsteps[i - 1] = 0;
if (stone_p < M && stones[stone_p] == i) {
minsteps[i - 1] = 1;
stone_p++;
}
}
int step_size = T - S + 1;
int start_p = 0;
int stop_p = T - 1;
int ptr = 0;
// to accelerate
vector<int> shadow(T);
std::copy(minsteps.begin(), minsteps.end(), shadow.begin());
int counter = 0;
int min_gap = 2 * T;
for (int i = T + 1; i < L; ) {
int min_val = M + 1;
ptr = start_p;
for (int j = 0; j < step_size; ++j) {
min_val = min(min_val, minsteps[ptr]);
ptr = (ptr + 1) % T;
}
stop_p = start_p;
start_p = (start_p + 1) % T;
int extra = 0;
if (stone_p < M && i == stones[stone_p]) {
stone_p++;
extra++;
}
if (min_val >= M + 1) {
minsteps[stop_p] = M + 1;
} else {
minsteps[stop_p] = min_val + extra;
}
// cout << i << " " << min_val << " " << extra << " " << minsteps[stop_p] << endl;
counter++;
if (counter == T) {
if (stones[stone_p] - stones[stone_p - 1] > min_gap &&
i - stones[stone_p - 1] > min_gap) {
bool flag = true;
for (int x = 0; x < T; ++x) {
if (shadow[x] != minsteps[x]) {
flag = false;
break;
}
}
if (flag) {
// cout << "Jump from " << i;
i += T * ((stones[stone_p] - 1 - i) / T) + 1;
// cout << " to " << i << endl;
} else {
++i;
}
} else {
++i;
}
counter = 0;
std::copy(minsteps.begin(), minsteps.end(), shadow.begin());
} else {
++i;
}
}
int ans = M + 1;
for (int i = 0; i < T; ++i)
ans = min(ans, minsteps[i]);
cout << ans << endl;
return 0;
}
| [
"18800160527@163.com"
] | 18800160527@163.com |
d10d47b7a8b0b0158205e820660239ba35bbc3ae | cf9c4f10e2db6508a4784eb56d63c87000047e78 | /src/LevScene/LevSceneRenderAttribute.cpp | a8502b20d3a3cecaaab1b97c4e90b589cab4962d | [
"MIT"
] | permissive | wakare/Leviathan | 86f578bebb0b9100920d981ef6c67672a241b94b | 8a488f014d6235c5c6e6422c9f53c82635b7ebf7 | refs/heads/master | 2021-06-26T17:25:28.927589 | 2020-10-11T15:12:53 | 2020-10-11T15:12:53 | 151,736,145 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 285 | cpp | #include "LevSceneRenderAttribute.h"
#include "LevNumericalUniform.h"
namespace Leviathan
{
namespace Scene
{
LevSceneRenderAttribute::LevSceneRenderAttribute()
: LevSceneObjectAttribute(ELSOAT_RENDER)
{
}
LevSceneRenderAttribute::~LevSceneRenderAttribute()
{
}
}
} | [
"wakarenokaze@gmail.com"
] | wakarenokaze@gmail.com |
aa3e24dba485f68a55dcfe0d10fc65b62ce4c330 | 7e791eccdc4d41ba225a90b3918ba48e356fdd78 | /chromium/src/chrome/browser/extensions/extension_service_unittest.cc | bdeb43d6e6b3fa5ed9b5c2c45901a253b25c6158 | [
"BSD-3-Clause"
] | permissive | WiViClass/cef-3.2623 | 4e22b763a75e90d10ebf9aa3ea9a48a3d9ccd885 | 17fe881e9e481ef368d9f26e903e00a6b7bdc018 | refs/heads/master | 2021-01-25T04:38:14.941623 | 2017-06-09T07:37:43 | 2017-06-09T07:37:43 | 93,824,379 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 243,141 | cc | // Copyright (c) 2013 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.
#include "chrome/browser/extensions/extension_service.h"
#include <stddef.h>
#include <stdint.h>
#include <algorithm>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "base/at_exit.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/json/json_file_value_serializer.h"
#include "base/json/json_reader.h"
#include "base/json/json_string_value_serializer.h"
#include "base/location.h"
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/prefs/scoped_user_pref_update.h"
#include "base/single_thread_task_runner.h"
#include "base/stl_util.h"
#include "base/strings/pattern.h"
#include "base/strings/string16.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/thread_task_runner_handle.h"
#include "base/version.h"
#include "build/build_config.h"
#include "chrome/browser/after_startup_task_utils.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/extensions/blacklist.h"
#include "chrome/browser/extensions/chrome_app_sorting.h"
#include "chrome/browser/extensions/component_loader.h"
#include "chrome/browser/extensions/crx_installer.h"
#include "chrome/browser/extensions/default_apps.h"
#include "chrome/browser/extensions/extension_creator.h"
#include "chrome/browser/extensions/extension_error_reporter.h"
#include "chrome/browser/extensions/extension_error_ui.h"
#include "chrome/browser/extensions/extension_management_test_util.h"
#include "chrome/browser/extensions/extension_service_test_base.h"
#include "chrome/browser/extensions/extension_service_test_with_install.h"
#include "chrome/browser/extensions/extension_special_storage_policy.h"
#include "chrome/browser/extensions/extension_util.h"
#include "chrome/browser/extensions/external_install_error.h"
#include "chrome/browser/extensions/external_install_manager.h"
#include "chrome/browser/extensions/external_policy_loader.h"
#include "chrome/browser/extensions/external_pref_loader.h"
#include "chrome/browser/extensions/external_provider_impl.h"
#include "chrome/browser/extensions/fake_safe_browsing_database_manager.h"
#include "chrome/browser/extensions/installed_loader.h"
#include "chrome/browser/extensions/pack_extension_job.h"
#include "chrome/browser/extensions/pending_extension_info.h"
#include "chrome/browser/extensions/pending_extension_manager.h"
#include "chrome/browser/extensions/permissions_updater.h"
#include "chrome/browser/extensions/test_blacklist.h"
#include "chrome/browser/extensions/test_extension_system.h"
#include "chrome/browser/extensions/unpacked_installer.h"
#include "chrome/browser/extensions/updater/extension_updater.h"
#include "chrome/browser/policy/profile_policy_connector.h"
#include "chrome/browser/policy/profile_policy_connector_factory.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/extensions/api/plugins/plugins_handler.h"
#include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
#include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/url_constants.h"
#include "chrome/test/base/scoped_browser_locale.h"
#include "chrome/test/base/testing_profile.h"
#include "components/crx_file/id_util.h"
#include "components/pref_registry/pref_registry_syncable.h"
#include "components/syncable_prefs/pref_service_syncable.h"
#include "components/syncable_prefs/testing_pref_service_syncable.h"
#include "content/public/browser/dom_storage_context.h"
#include "content/public/browser/gpu_data_manager.h"
#include "content/public/browser/indexed_db_context.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/plugin_service.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/storage_partition.h"
#include "content/public/common/content_constants.h"
#include "content/public/test/test_browser_thread_bundle.h"
#include "content/public/test/test_utils.h"
#include "extensions/browser/extension_dialog_auto_confirm.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/extension_registry.h"
#include "extensions/browser/extension_system.h"
#include "extensions/browser/external_provider_interface.h"
#include "extensions/browser/install_flag.h"
#include "extensions/browser/management_policy.h"
#include "extensions/browser/test_extension_registry_observer.h"
#include "extensions/browser/test_management_policy.h"
#include "extensions/browser/uninstall_reason.h"
#include "extensions/common/constants.h"
#include "extensions/common/extension.h"
#include "extensions/common/extension_builder.h"
#include "extensions/common/extension_l10n_util.h"
#include "extensions/common/extension_resource.h"
#include "extensions/common/manifest_constants.h"
#include "extensions/common/manifest_handlers/background_info.h"
#include "extensions/common/manifest_handlers/permissions_parser.h"
#include "extensions/common/manifest_url_handlers.h"
#include "extensions/common/permissions/permission_set.h"
#include "extensions/common/permissions/permissions_data.h"
#include "extensions/common/switches.h"
#include "extensions/common/url_pattern.h"
#include "extensions/common/value_builder.h"
#include "gpu/config/gpu_info.h"
#include "grit/browser_resources.h"
#include "grit/generated_resources.h"
#include "net/cookies/canonical_cookie.h"
#include "net/cookies/cookie_monster.h"
#include "net/cookies/cookie_options.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h"
#include "storage/browser/database/database_tracker.h"
#include "storage/browser/quota/quota_manager.h"
#include "storage/common/database/database_identifier.h"
#include "sync/api/string_ordinal.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/resource/material_design/material_design_controller.h"
#include "url/gurl.h"
#if defined(OS_CHROMEOS)
#include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
#include "chrome/browser/chromeos/settings/cros_settings.h"
#include "chrome/browser/chromeos/settings/device_settings_service.h"
#endif
// The blacklist tests rely on the safe-browsing database.
#if defined(SAFE_BROWSING_DB_LOCAL)
#define ENABLE_BLACKLIST_TESTS
#endif
using content::BrowserContext;
using content::BrowserThread;
using content::DOMStorageContext;
using content::IndexedDBContext;
using content::PluginService;
using extensions::APIPermission;
using extensions::APIPermissionSet;
using extensions::AppSorting;
using extensions::Blacklist;
using extensions::CrxInstaller;
using extensions::Extension;
using extensions::ExtensionCreator;
using extensions::ExtensionPrefs;
using extensions::ExtensionRegistry;
using extensions::ExtensionResource;
using extensions::ExtensionSystem;
using extensions::ExternalInstallError;
using extensions::FakeSafeBrowsingDatabaseManager;
using extensions::FeatureSwitch;
using extensions::Manifest;
using extensions::PermissionSet;
using extensions::TestExtensionSystem;
using extensions::UnloadedExtensionInfo;
using extensions::URLPatternSet;
namespace keys = extensions::manifest_keys;
namespace {
// Extension ids used during testing.
const char good0[] = "behllobkkfkfnphdnhnkndlbkcpglgmj";
const char good1[] = "hpiknbiabeeppbpihjehijgoemciehgk";
const char good2[] = "bjafgdebaacbbbecmhlhpofkepfkgcpa";
const char all_zero[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
const char good2048[] = "nmgjhmhbleinmjpbdhgajfjkbijcmgbh";
const char good_crx[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
const char minimal_platform_app_crx[] = "jjeoclcdfjddkdjokiejckgcildcflpp";
const char hosted_app[] = "kbmnembihfiondgfjekmnmcbddelicoi";
const char page_action[] = "obcimlgaoabeegjmmpldobjndiealpln";
const char theme_crx[] = "iamefpfkojoapidjnbafmgkgncegbkad";
const char theme2_crx[] = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
const char permissions_crx[] = "eagpmdpfmaekmmcejjbmjoecnejeiiin";
const char updates_from_webstore[] = "akjooamlhcgeopfifcmlggaebeocgokj";
const char permissions_blocklist[] = "noffkehfcaggllbcojjbopcmlhcnhcdn";
static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
int schemes = URLPattern::SCHEME_ALL;
extent->AddPattern(URLPattern(schemes, pattern));
}
base::FilePath GetTemporaryFile() {
base::FilePath temp_file;
CHECK(base::CreateTemporaryFile(&temp_file));
return temp_file;
}
bool WaitForCountNotificationsCallback(int *count) {
return --(*count) == 0;
}
bool HasExternalInstallErrors(ExtensionService* service) {
return !service->external_install_manager()->GetErrorsForTesting().empty();
}
bool HasExternalInstallBubble(ExtensionService* service) {
std::vector<ExternalInstallError*> errors =
service->external_install_manager()->GetErrorsForTesting();
auto found = std::find_if(
errors.begin(), errors.end(),
[](const ExternalInstallError* error) {
return error->alert_type() == ExternalInstallError::BUBBLE_ALERT;
});
return found != errors.end();
}
} // namespace
class MockExtensionProvider : public extensions::ExternalProviderInterface {
public:
MockExtensionProvider(
VisitorInterface* visitor,
Manifest::Location location)
: location_(location), visitor_(visitor), visit_count_(0) {
}
~MockExtensionProvider() override {}
void UpdateOrAddExtension(const std::string& id,
const std::string& version,
const base::FilePath& path) {
extension_map_[id] = std::make_pair(version, path);
}
void RemoveExtension(const std::string& id) {
extension_map_.erase(id);
}
// ExternalProvider implementation:
void VisitRegisteredExtension() override {
visit_count_++;
for (DataMap::const_iterator i = extension_map_.begin();
i != extension_map_.end(); ++i) {
Version version(i->second.first);
visitor_->OnExternalExtensionFileFound(
i->first, &version, i->second.second, location_,
Extension::NO_FLAGS, false, false);
}
visitor_->OnExternalProviderReady(this);
}
bool HasExtension(const std::string& id) const override {
return extension_map_.find(id) != extension_map_.end();
}
bool GetExtensionDetails(const std::string& id,
Manifest::Location* location,
scoped_ptr<Version>* version) const override {
DataMap::const_iterator it = extension_map_.find(id);
if (it == extension_map_.end())
return false;
if (version)
version->reset(new Version(it->second.first));
if (location)
*location = location_;
return true;
}
bool IsReady() const override { return true; }
void ServiceShutdown() override {}
int visit_count() const { return visit_count_; }
void set_visit_count(int visit_count) {
visit_count_ = visit_count;
}
private:
typedef std::map< std::string, std::pair<std::string, base::FilePath> >
DataMap;
DataMap extension_map_;
Manifest::Location location_;
VisitorInterface* visitor_;
// visit_count_ tracks the number of calls to VisitRegisteredExtension().
// Mutable because it must be incremented on each call to
// VisitRegisteredExtension(), which must be a const method to inherit
// from the class being mocked.
mutable int visit_count_;
DISALLOW_COPY_AND_ASSIGN(MockExtensionProvider);
};
class MockProviderVisitor
: public extensions::ExternalProviderInterface::VisitorInterface {
public:
// The provider will return |fake_base_path| from
// GetBaseCrxFilePath(). User can test the behavior with
// and without an empty path using this parameter.
explicit MockProviderVisitor(base::FilePath fake_base_path)
: ids_found_(0),
fake_base_path_(fake_base_path),
expected_creation_flags_(Extension::NO_FLAGS) {
profile_.reset(new TestingProfile);
}
MockProviderVisitor(base::FilePath fake_base_path,
int expected_creation_flags)
: ids_found_(0),
fake_base_path_(fake_base_path),
expected_creation_flags_(expected_creation_flags) {
profile_.reset(new TestingProfile);
}
int Visit(const std::string& json_data) {
// Give the test json file to the provider for parsing.
provider_.reset(new extensions::ExternalProviderImpl(
this,
new extensions::ExternalTestingLoader(json_data, fake_base_path_),
profile_.get(),
Manifest::EXTERNAL_PREF,
Manifest::EXTERNAL_PREF_DOWNLOAD,
Extension::NO_FLAGS));
// We also parse the file into a dictionary to compare what we get back
// from the provider.
JSONStringValueDeserializer deserializer(json_data);
scoped_ptr<base::Value> json_value = deserializer.Deserialize(NULL, NULL);
if (!json_value || !json_value->IsType(base::Value::TYPE_DICTIONARY)) {
NOTREACHED() << "Unable to deserialize json data";
return -1;
} else {
prefs_ = base::DictionaryValue::From(std::move(json_value));
}
// Reset our counter.
ids_found_ = 0;
// Ask the provider to look up all extensions and return them.
provider_->VisitRegisteredExtension();
return ids_found_;
}
bool OnExternalExtensionFileFound(const std::string& id,
const Version* version,
const base::FilePath& path,
Manifest::Location unused,
int creation_flags,
bool mark_acknowledged,
bool install_immediately) override {
EXPECT_EQ(expected_creation_flags_, creation_flags);
++ids_found_;
base::DictionaryValue* pref;
// This tests is to make sure that the provider only notifies us of the
// values we gave it. So if the id we doesn't exist in our internal
// dictionary then something is wrong.
EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
<< "Got back ID (" << id.c_str() << ") we weren't expecting";
EXPECT_TRUE(path.IsAbsolute());
if (!fake_base_path_.empty())
EXPECT_TRUE(fake_base_path_.IsParent(path));
if (pref) {
EXPECT_TRUE(provider_->HasExtension(id));
// Ask provider if the extension we got back is registered.
Manifest::Location location = Manifest::INVALID_LOCATION;
scoped_ptr<Version> v1;
base::FilePath crx_path;
EXPECT_TRUE(provider_->GetExtensionDetails(id, NULL, &v1));
EXPECT_STREQ(version->GetString().c_str(), v1->GetString().c_str());
scoped_ptr<Version> v2;
EXPECT_TRUE(provider_->GetExtensionDetails(id, &location, &v2));
EXPECT_STREQ(version->GetString().c_str(), v1->GetString().c_str());
EXPECT_STREQ(version->GetString().c_str(), v2->GetString().c_str());
EXPECT_EQ(Manifest::EXTERNAL_PREF, location);
// Remove it so we won't count it ever again.
prefs_->Remove(id, NULL);
}
return true;
}
bool OnExternalExtensionUpdateUrlFound(const std::string& id,
const std::string& install_parameter,
const GURL& update_url,
Manifest::Location location,
int creation_flags,
bool mark_acknowledged) override {
++ids_found_;
base::DictionaryValue* pref;
// This tests is to make sure that the provider only notifies us of the
// values we gave it. So if the id we doesn't exist in our internal
// dictionary then something is wrong.
EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
<< L"Got back ID (" << id.c_str() << ") we weren't expecting";
EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location);
if (pref) {
EXPECT_TRUE(provider_->HasExtension(id));
// External extensions with update URLs do not have versions.
scoped_ptr<Version> v1;
Manifest::Location location1 = Manifest::INVALID_LOCATION;
EXPECT_TRUE(provider_->GetExtensionDetails(id, &location1, &v1));
EXPECT_FALSE(v1.get());
EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location1);
std::string parsed_install_parameter;
pref->GetString("install_parameter", &parsed_install_parameter);
EXPECT_EQ(parsed_install_parameter, install_parameter);
// Remove it so we won't count it again.
prefs_->Remove(id, NULL);
}
return true;
}
void OnExternalProviderReady(
const extensions::ExternalProviderInterface* provider) override {
EXPECT_EQ(provider, provider_.get());
EXPECT_TRUE(provider->IsReady());
}
Profile* profile() { return profile_.get(); }
private:
int ids_found_;
base::FilePath fake_base_path_;
int expected_creation_flags_;
scoped_ptr<extensions::ExternalProviderImpl> provider_;
scoped_ptr<base::DictionaryValue> prefs_;
scoped_ptr<TestingProfile> profile_;
DISALLOW_COPY_AND_ASSIGN(MockProviderVisitor);
};
class ExtensionServiceTest
: public extensions::ExtensionServiceTestWithInstall {
public:
ExtensionServiceTest() {
// The extension subsystem posts logging tasks to be done after
// browser startup. There's no StartupObserver as there normally
// would be since we're in a unit test, so we have to explicitly
// note tasks should be processed.
AfterStartupTaskUtils::SetBrowserStartupIsCompleteForTesting();
}
void AddMockExternalProvider(
extensions::ExternalProviderInterface* provider) {
service()->AddProviderForTesting(provider);
}
protected:
// Paths to some of the fake extensions.
base::FilePath good1_path() {
return data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII(good1)
.AppendASCII("2");
}
base::FilePath good2_path() {
return data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII(good2)
.AppendASCII("1.0");
}
void TestExternalProvider(MockExtensionProvider* provider,
Manifest::Location location);
void BlackListWebGL() {
static const std::string json_blacklist =
"{\n"
" \"name\": \"gpu blacklist\",\n"
" \"version\": \"1.0\",\n"
" \"entries\": [\n"
" {\n"
" \"id\": 1,\n"
" \"features\": [\"webgl\"]\n"
" }\n"
" ]\n"
"}";
gpu::GPUInfo gpu_info;
content::GpuDataManager::GetInstance()->InitializeForTesting(
json_blacklist, gpu_info);
}
// Grants all optional permissions stated in manifest to active permission
// set for extension |id|.
void GrantAllOptionalPermissions(const std::string& id) {
const Extension* extension = service()->GetInstalledExtension(id);
const PermissionSet& all_optional_permissions =
extensions::PermissionsParser::GetOptionalPermissions(extension);
extensions::PermissionsUpdater perms_updater(profile());
perms_updater.AddPermissions(extension, all_optional_permissions);
}
testing::AssertionResult IsBlocked(const std::string& id) {
scoped_ptr<extensions::ExtensionSet> all_unblocked_extensions =
registry()->GenerateInstalledExtensionsSet(
ExtensionRegistry::EVERYTHING & ~ExtensionRegistry::BLOCKED);
if (all_unblocked_extensions.get()->Contains(id))
return testing::AssertionFailure() << id << " is still unblocked!";
if (!registry()->blocked_extensions().Contains(id))
return testing::AssertionFailure() << id << " is not blocked!";
return testing::AssertionSuccess();
}
// Helper method to test that an extension moves through being blocked and
// unblocked as appropriate for its type.
void AssertExtensionBlocksAndUnblocks(
bool should_block, const std::string extension_id) {
// Assume we start in an unblocked state.
EXPECT_FALSE(IsBlocked(extension_id));
// Block the extensions.
service()->BlockAllExtensions();
base::RunLoop().RunUntilIdle();
if (should_block)
ASSERT_TRUE(IsBlocked(extension_id));
else
ASSERT_FALSE(IsBlocked(extension_id));
service()->UnblockAllExtensions();
base::RunLoop().RunUntilIdle();
ASSERT_FALSE(IsBlocked(extension_id));
}
bool IsPrefExist(const std::string& extension_id,
const std::string& pref_path) {
const base::DictionaryValue* dict =
profile()->GetPrefs()->GetDictionary("extensions.settings");
if (dict == NULL) return false;
const base::DictionaryValue* pref = NULL;
if (!dict->GetDictionary(extension_id, &pref)) {
return false;
}
if (pref == NULL) {
return false;
}
bool val;
if (!pref->GetBoolean(pref_path, &val)) {
return false;
}
return true;
}
void SetPref(const std::string& extension_id,
const std::string& pref_path,
base::Value* value,
const std::string& msg) {
DictionaryPrefUpdate update(profile()->GetPrefs(), "extensions.settings");
base::DictionaryValue* dict = update.Get();
ASSERT_TRUE(dict != NULL) << msg;
base::DictionaryValue* pref = NULL;
ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
EXPECT_TRUE(pref != NULL) << msg;
pref->Set(pref_path, value);
}
void SetPrefInteg(const std::string& extension_id,
const std::string& pref_path,
int value) {
std::string msg = " while setting: ";
msg += extension_id;
msg += " ";
msg += pref_path;
msg += " = ";
msg += base::IntToString(value);
SetPref(extension_id, pref_path, new base::FundamentalValue(value), msg);
}
void SetPrefBool(const std::string& extension_id,
const std::string& pref_path,
bool value) {
std::string msg = " while setting: ";
msg += extension_id + " " + pref_path;
msg += " = ";
msg += (value ? "true" : "false");
SetPref(extension_id, pref_path, new base::FundamentalValue(value), msg);
}
void ClearPref(const std::string& extension_id,
const std::string& pref_path) {
std::string msg = " while clearing: ";
msg += extension_id + " " + pref_path;
DictionaryPrefUpdate update(profile()->GetPrefs(), "extensions.settings");
base::DictionaryValue* dict = update.Get();
ASSERT_TRUE(dict != NULL) << msg;
base::DictionaryValue* pref = NULL;
ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
EXPECT_TRUE(pref != NULL) << msg;
pref->Remove(pref_path, NULL);
}
void SetPrefStringSet(const std::string& extension_id,
const std::string& pref_path,
const std::set<std::string>& value) {
std::string msg = " while setting: ";
msg += extension_id + " " + pref_path;
base::ListValue* list_value = new base::ListValue();
for (std::set<std::string>::const_iterator iter = value.begin();
iter != value.end(); ++iter)
list_value->Append(new base::StringValue(*iter));
SetPref(extension_id, pref_path, list_value, msg);
}
void InitPluginService() {
#if defined(ENABLE_PLUGINS)
PluginService::GetInstance()->Init();
#endif
}
void InitializeEmptyExtensionServiceWithTestingPrefs() {
ExtensionServiceTestBase::ExtensionServiceInitParams params =
CreateDefaultInitParams();
params.pref_file = base::FilePath();
InitializeExtensionService(params);
}
extensions::ManagementPolicy* GetManagementPolicy() {
return ExtensionSystem::Get(browser_context())->management_policy();
}
ExternalInstallError* GetError(const std::string& extension_id) {
std::vector<ExternalInstallError*> errors =
service_->external_install_manager()->GetErrorsForTesting();
auto found = std::find_if(
errors.begin(), errors.end(),
[&extension_id](const ExternalInstallError* error) {
return error->extension_id() == extension_id;
});
return found == errors.end() ? nullptr : *found;
}
typedef extensions::ExtensionManagementPrefUpdater<
syncable_prefs::TestingPrefServiceSyncable> ManagementPrefUpdater;
};
// Receives notifications from a PackExtensionJob, indicating either that
// packing succeeded or that there was some error.
class PackExtensionTestClient : public extensions::PackExtensionJob::Client {
public:
PackExtensionTestClient(const base::FilePath& expected_crx_path,
const base::FilePath& expected_private_key_path);
void OnPackSuccess(const base::FilePath& crx_path,
const base::FilePath& private_key_path) override;
void OnPackFailure(const std::string& error_message,
ExtensionCreator::ErrorType type) override;
private:
const base::FilePath expected_crx_path_;
const base::FilePath expected_private_key_path_;
DISALLOW_COPY_AND_ASSIGN(PackExtensionTestClient);
};
PackExtensionTestClient::PackExtensionTestClient(
const base::FilePath& expected_crx_path,
const base::FilePath& expected_private_key_path)
: expected_crx_path_(expected_crx_path),
expected_private_key_path_(expected_private_key_path) {}
// If packing succeeded, we make sure that the package names match our
// expectations.
void PackExtensionTestClient::OnPackSuccess(
const base::FilePath& crx_path,
const base::FilePath& private_key_path) {
// We got the notification and processed it; we don't expect any further tasks
// to be posted to the current thread, so we should stop blocking and continue
// on with the rest of the test.
// This call to |Quit()| matches the call to |Run()| in the
// |PackPunctuatedExtension| test.
base::MessageLoop::current()->QuitWhenIdle();
EXPECT_EQ(expected_crx_path_.value(), crx_path.value());
EXPECT_EQ(expected_private_key_path_.value(), private_key_path.value());
ASSERT_TRUE(base::PathExists(private_key_path));
}
// The tests are designed so that we never expect to see a packing error.
void PackExtensionTestClient::OnPackFailure(const std::string& error_message,
ExtensionCreator::ErrorType type) {
if (type == ExtensionCreator::kCRXExists)
FAIL() << "Packing should not fail.";
else
FAIL() << "Existing CRX should have been overwritten.";
}
// Test loading good extensions from the profile directory.
TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectorySuccess) {
InitPluginService();
InitializeGoodInstalledExtensionService();
service()->Init();
uint32_t expected_num_extensions = 3u;
ASSERT_EQ(expected_num_extensions, loaded_.size());
EXPECT_EQ(std::string(good0), loaded_[0]->id());
EXPECT_EQ(std::string("My extension 1"),
loaded_[0]->name());
EXPECT_EQ(std::string("The first extension that I made."),
loaded_[0]->description());
EXPECT_EQ(Manifest::INTERNAL, loaded_[0]->location());
EXPECT_TRUE(service()->GetExtensionById(loaded_[0]->id(), false));
EXPECT_EQ(expected_num_extensions, registry()->enabled_extensions().size());
ValidatePrefKeyCount(3);
ValidateIntegerPref(good0, "state", Extension::ENABLED);
ValidateIntegerPref(good0, "location", Manifest::INTERNAL);
ValidateIntegerPref(good1, "state", Extension::ENABLED);
ValidateIntegerPref(good1, "location", Manifest::INTERNAL);
ValidateIntegerPref(good2, "state", Extension::ENABLED);
ValidateIntegerPref(good2, "location", Manifest::INTERNAL);
URLPatternSet expected_patterns;
AddPattern(&expected_patterns, "file:///*");
AddPattern(&expected_patterns, "http://*.google.com/*");
AddPattern(&expected_patterns, "https://*.google.com/*");
const Extension* extension = loaded_[0].get();
const extensions::UserScriptList& scripts =
extensions::ContentScriptsInfo::GetContentScripts(extension);
ASSERT_EQ(2u, scripts.size());
EXPECT_EQ(expected_patterns, scripts[0].url_patterns());
EXPECT_EQ(2u, scripts[0].js_scripts().size());
ExtensionResource resource00(extension->id(),
scripts[0].js_scripts()[0].extension_root(),
scripts[0].js_scripts()[0].relative_path());
base::FilePath expected_path =
base::MakeAbsoluteFilePath(extension->path().AppendASCII("script1.js"));
EXPECT_TRUE(resource00.ComparePathWithDefault(expected_path));
ExtensionResource resource01(extension->id(),
scripts[0].js_scripts()[1].extension_root(),
scripts[0].js_scripts()[1].relative_path());
expected_path =
base::MakeAbsoluteFilePath(extension->path().AppendASCII("script2.js"));
EXPECT_TRUE(resource01.ComparePathWithDefault(expected_path));
EXPECT_TRUE(!extensions::PluginInfo::HasPlugins(extension));
EXPECT_EQ(1u, scripts[1].url_patterns().patterns().size());
EXPECT_EQ("http://*.news.com/*",
scripts[1].url_patterns().begin()->GetAsString());
ExtensionResource resource10(extension->id(),
scripts[1].js_scripts()[0].extension_root(),
scripts[1].js_scripts()[0].relative_path());
expected_path =
extension->path().AppendASCII("js_files").AppendASCII("script3.js");
expected_path = base::MakeAbsoluteFilePath(expected_path);
EXPECT_TRUE(resource10.ComparePathWithDefault(expected_path));
expected_patterns.ClearPatterns();
AddPattern(&expected_patterns, "http://*.google.com/*");
AddPattern(&expected_patterns, "https://*.google.com/*");
EXPECT_EQ(
expected_patterns,
extension->permissions_data()->active_permissions().explicit_hosts());
EXPECT_EQ(std::string(good1), loaded_[1]->id());
EXPECT_EQ(std::string("My extension 2"), loaded_[1]->name());
EXPECT_EQ(std::string(), loaded_[1]->description());
EXPECT_EQ(loaded_[1]->GetResourceURL("background.html"),
extensions::BackgroundInfo::GetBackgroundURL(loaded_[1].get()));
EXPECT_EQ(0u,
extensions::ContentScriptsInfo::GetContentScripts(loaded_[1].get())
.size());
// We don't parse the plugins section on Chrome OS.
#if defined(OS_CHROMEOS)
EXPECT_TRUE(!extensions::PluginInfo::HasPlugins(loaded_[1].get()));
#else
ASSERT_TRUE(extensions::PluginInfo::HasPlugins(loaded_[1].get()));
const std::vector<extensions::PluginInfo>* plugins =
extensions::PluginInfo::GetPlugins(loaded_[1].get());
ASSERT_TRUE(plugins);
ASSERT_EQ(2u, plugins->size());
EXPECT_EQ(loaded_[1]->path().AppendASCII("content_plugin.dll").value(),
plugins->at(0).path.value());
EXPECT_TRUE(plugins->at(0).is_public);
EXPECT_EQ(loaded_[1]->path().AppendASCII("extension_plugin.dll").value(),
plugins->at(1).path.value());
EXPECT_FALSE(plugins->at(1).is_public);
#endif
EXPECT_EQ(Manifest::INTERNAL, loaded_[1]->location());
int index = expected_num_extensions - 1;
EXPECT_EQ(std::string(good2), loaded_[index]->id());
EXPECT_EQ(std::string("My extension 3"), loaded_[index]->name());
EXPECT_EQ(std::string(), loaded_[index]->description());
EXPECT_EQ(0u,
extensions::ContentScriptsInfo::GetContentScripts(
loaded_[index].get()).size());
EXPECT_EQ(Manifest::INTERNAL, loaded_[index]->location());
}
// Test loading bad extensions from the profile directory.
TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectoryFail) {
// Initialize the test dir with a bad Preferences/extensions.
base::FilePath source_install_dir =
data_dir().AppendASCII("bad").AppendASCII("Extensions");
base::FilePath pref_path =
source_install_dir.DirName().Append(chrome::kPreferencesFilename);
InitializeInstalledExtensionService(pref_path, source_install_dir);
service()->Init();
ASSERT_EQ(4u, GetErrors().size());
ASSERT_EQ(0u, loaded_.size());
EXPECT_TRUE(base::MatchPattern(base::UTF16ToUTF8(GetErrors()[0]),
l10n_util::GetStringUTF8(IDS_EXTENSIONS_LOAD_ERROR_MESSAGE) + " *. " +
extensions::manifest_errors::kManifestUnreadable)) <<
base::UTF16ToUTF8(GetErrors()[0]);
EXPECT_TRUE(base::MatchPattern(base::UTF16ToUTF8(GetErrors()[1]),
l10n_util::GetStringUTF8(IDS_EXTENSIONS_LOAD_ERROR_MESSAGE) + " *. " +
extensions::manifest_errors::kManifestUnreadable)) <<
base::UTF16ToUTF8(GetErrors()[1]);
EXPECT_TRUE(base::MatchPattern(base::UTF16ToUTF8(GetErrors()[2]),
l10n_util::GetStringUTF8(IDS_EXTENSIONS_LOAD_ERROR_MESSAGE) + " *. " +
extensions::manifest_errors::kMissingFile)) <<
base::UTF16ToUTF8(GetErrors()[2]);
EXPECT_TRUE(base::MatchPattern(base::UTF16ToUTF8(GetErrors()[3]),
l10n_util::GetStringUTF8(IDS_EXTENSIONS_LOAD_ERROR_MESSAGE) + " *. " +
extensions::manifest_errors::kManifestUnreadable)) <<
base::UTF16ToUTF8(GetErrors()[3]);
}
// Test various cases for delayed install because of missing imports.
TEST_F(ExtensionServiceTest, PendingImports) {
InitPluginService();
base::FilePath source_install_dir =
data_dir().AppendASCII("pending_updates_with_imports").AppendASCII(
"Extensions");
base::FilePath pref_path =
source_install_dir.DirName().Append(chrome::kPreferencesFilename);
InitializeInstalledExtensionService(pref_path, source_install_dir);
// Verify there are no pending extensions initially.
EXPECT_FALSE(service()->pending_extension_manager()->HasPendingExtensions());
service()->Init();
// Wait for GarbageCollectExtensions task to complete.
base::RunLoop().RunUntilIdle();
// These extensions are used by the extensions we test below, they must be
// installed.
EXPECT_TRUE(base::PathExists(extensions_install_dir().AppendASCII(
"bjafgdebaacbbbecmhlhpofkepfkgcpa/1.0")));
EXPECT_TRUE(base::PathExists(extensions_install_dir().AppendASCII(
"hpiknbiabeeppbpihjehijgoemciehgk/2")));
// Each of these extensions should have been rejected because of dependencies
// that cannot be satisfied.
ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
EXPECT_FALSE(
prefs->GetDelayedInstallInfo("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
EXPECT_FALSE(
prefs->GetInstalledExtensionInfo("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
EXPECT_FALSE(
prefs->GetDelayedInstallInfo("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
EXPECT_FALSE(
prefs->GetInstalledExtensionInfo("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
EXPECT_FALSE(
prefs->GetDelayedInstallInfo("cccccccccccccccccccccccccccccccc"));
EXPECT_FALSE(
prefs->GetInstalledExtensionInfo("cccccccccccccccccccccccccccccccc"));
// Make sure the import started for the extension with a dependency.
EXPECT_TRUE(
prefs->GetDelayedInstallInfo("behllobkkfkfnphdnhnkndlbkcpglgmj"));
EXPECT_EQ(ExtensionPrefs::DELAY_REASON_WAIT_FOR_IMPORTS,
prefs->GetDelayedInstallReason("behllobkkfkfnphdnhnkndlbkcpglgmj"));
EXPECT_FALSE(base::PathExists(extensions_install_dir().AppendASCII(
"behllobkkfkfnphdnhnkndlbkcpglgmj/1.0.0.0")));
EXPECT_TRUE(service()->pending_extension_manager()->HasPendingExtensions());
std::string pending_id("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee");
EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(pending_id));
// Remove it because we are not testing the pending extension manager's
// ability to download and install extensions.
EXPECT_TRUE(service()->pending_extension_manager()->Remove(pending_id));
}
// Test installing extensions. This test tries to install few extensions using
// crx files. If you need to change those crx files, feel free to repackage
// them, throw away the key used and change the id's above.
TEST_F(ExtensionServiceTest, InstallExtension) {
InitializeEmptyExtensionService();
// Extensions not enabled.
service()->set_extensions_enabled(false);
base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_FAILED);
service()->set_extensions_enabled(true);
ValidatePrefKeyCount(0);
// A simple extension that should install without error.
path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
// TODO(erikkay): verify the contents of the installed extension.
int pref_count = 0;
ValidatePrefKeyCount(++pref_count);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
// An extension with page actions.
path = data_dir().AppendASCII("page_action.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ValidateIntegerPref(page_action, "state", Extension::ENABLED);
ValidateIntegerPref(page_action, "location", Manifest::INTERNAL);
// Bad signature.
path = data_dir().AppendASCII("bad_signature.crx");
InstallCRX(path, INSTALL_FAILED);
ValidatePrefKeyCount(pref_count);
// 0-length extension file.
path = data_dir().AppendASCII("not_an_extension.crx");
InstallCRX(path, INSTALL_FAILED);
ValidatePrefKeyCount(pref_count);
// Bad magic number.
path = data_dir().AppendASCII("bad_magic.crx");
InstallCRX(path, INSTALL_FAILED);
ValidatePrefKeyCount(pref_count);
// Packed extensions may have folders or files that have underscores.
// This will only cause a warning, rather than a fatal error.
path = data_dir().AppendASCII("bad_underscore.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
// A test for an extension with a 2048-bit public key.
path = data_dir().AppendASCII("good2048.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ValidateIntegerPref(good2048, "state", Extension::ENABLED);
ValidateIntegerPref(good2048, "location", Manifest::INTERNAL);
// TODO(erikkay): add more tests for many of the failure cases.
// TODO(erikkay): add tests for upgrade cases.
}
struct MockExtensionRegistryObserver
: public extensions::ExtensionRegistryObserver {
void OnExtensionWillBeInstalled(content::BrowserContext* browser_context,
const Extension* extension,
bool is_update,
const std::string& old_name) override {
last_extension_installed = extension->id();
}
void OnExtensionUninstalled(content::BrowserContext* browser_context,
const Extension* extension,
extensions::UninstallReason reason) override {
last_extension_uninstalled = extension->id();
}
std::string last_extension_installed;
std::string last_extension_uninstalled;
};
// Test that correct notifications are sent to ExtensionRegistryObserver on
// extension install and uninstall.
TEST_F(ExtensionServiceTest, InstallObserverNotified) {
InitializeEmptyExtensionService();
extensions::ExtensionRegistry* registry(
extensions::ExtensionRegistry::Get(profile()));
MockExtensionRegistryObserver observer;
registry->AddObserver(&observer);
// A simple extension that should install without error.
ASSERT_TRUE(observer.last_extension_installed.empty());
base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
ASSERT_EQ(good_crx, observer.last_extension_installed);
// Uninstall the extension.
ASSERT_TRUE(observer.last_extension_uninstalled.empty());
UninstallExtension(good_crx, false);
ASSERT_EQ(good_crx, observer.last_extension_uninstalled);
registry->RemoveObserver(&observer);
}
// Tests that flags passed to OnExternalExtensionFileFound() make it to the
// extension object.
TEST_F(ExtensionServiceTest, InstallingExternalExtensionWithFlags) {
const char kPrefFromBookmark[] = "from_bookmark";
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
service()->set_extensions_enabled(true);
// Register and install an external extension.
Version version("1.0.0.0");
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
if (service()->OnExternalExtensionFileFound(
good_crx,
&version,
path,
Manifest::EXTERNAL_PREF,
Extension::FROM_BOOKMARK,
false /* mark_acknowledged */,
false /* install_immediately */)) {
observer.Wait();
}
const Extension* extension = service()->GetExtensionById(good_crx, false);
ASSERT_TRUE(extension);
ASSERT_TRUE(extension->from_bookmark());
ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
// Upgrade to version 2.0, the flag should be preserved.
path = data_dir().AppendASCII("good2.crx");
UpdateExtension(good_crx, path, ENABLED);
ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
extension = service()->GetExtensionById(good_crx, false);
ASSERT_TRUE(extension);
ASSERT_TRUE(extension->from_bookmark());
}
// Test the handling of Extension::EXTERNAL_EXTENSION_UNINSTALLED
TEST_F(ExtensionServiceTest, UninstallingExternalExtensions) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
service()->set_extensions_enabled(true);
// Install an external extension.
Version version("1.0.0.0");
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
if (service()->OnExternalExtensionFileFound(good_crx,
&version,
path,
Manifest::EXTERNAL_PREF,
Extension::NO_FLAGS,
false,
false)) {
observer.Wait();
}
ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
// Uninstall it and check that its killbit gets set.
UninstallExtension(good_crx, false);
ValidateIntegerPref(good_crx, "state",
Extension::EXTERNAL_EXTENSION_UNINSTALLED);
// Try to re-install it externally. This should fail because of the killbit.
service()->OnExternalExtensionFileFound(good_crx,
&version,
path,
Manifest::EXTERNAL_PREF,
Extension::NO_FLAGS,
false,
false);
base::RunLoop().RunUntilIdle();
ASSERT_TRUE(NULL == service()->GetExtensionById(good_crx, false));
ValidateIntegerPref(good_crx, "state",
Extension::EXTERNAL_EXTENSION_UNINSTALLED);
version = Version("1.0.0.1");
// Repeat the same thing with a newer version of the extension.
path = data_dir().AppendASCII("good2.crx");
service()->OnExternalExtensionFileFound(good_crx,
&version,
path,
Manifest::EXTERNAL_PREF,
Extension::NO_FLAGS,
false,
false);
base::RunLoop().RunUntilIdle();
ASSERT_TRUE(NULL == service()->GetExtensionById(good_crx, false));
ValidateIntegerPref(good_crx, "state",
Extension::EXTERNAL_EXTENSION_UNINSTALLED);
// Try adding the same extension from an external update URL.
ASSERT_FALSE(service()->pending_extension_manager()->AddFromExternalUpdateUrl(
good_crx,
std::string(),
GURL("http:://fake.update/url"),
Manifest::EXTERNAL_PREF_DOWNLOAD,
Extension::NO_FLAGS,
false));
ASSERT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
}
// Test that uninstalling an external extension does not crash when
// the extension could not be loaded.
// This extension shown in preferences file requires an experimental permission.
// It could not be loaded without such permission.
TEST_F(ExtensionServiceTest, UninstallingNotLoadedExtension) {
base::FilePath source_install_dir =
data_dir().AppendASCII("good").AppendASCII("Extensions");
// The preference contains an external extension
// that requires 'experimental' permission.
base::FilePath pref_path = source_install_dir
.DirName()
.AppendASCII("PreferencesExperimental");
// Aforementioned extension will not be loaded if
// there is no '--enable-experimental-extension-apis' command line flag.
InitializeInstalledExtensionService(pref_path, source_install_dir);
service()->Init();
// Check and try to uninstall it.
// If we don't check whether the extension is loaded before we uninstall it
// in CheckExternalUninstall, a crash will happen here because we will get or
// dereference a NULL pointer (extension) inside UninstallExtension.
MockExtensionProvider provider(NULL, Manifest::EXTERNAL_REGISTRY);
service()->OnExternalProviderReady(&provider);
}
// Test that external extensions with incorrect IDs are not installed.
TEST_F(ExtensionServiceTest, FailOnWrongId) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
service()->set_extensions_enabled(true);
Version version("1.0.0.0");
const std::string wrong_id = all_zero;
const std::string correct_id = good_crx;
ASSERT_NE(correct_id, wrong_id);
// Install an external extension with an ID from the external
// source that is not equal to the ID in the extension manifest.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->OnExternalExtensionFileFound(wrong_id,
&version,
path,
Manifest::EXTERNAL_PREF,
Extension::NO_FLAGS,
false,
false);
observer.Wait();
ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
// Try again with the right ID. Expect success.
content::WindowedNotificationObserver observer2(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
if (service()->OnExternalExtensionFileFound(correct_id,
&version,
path,
Manifest::EXTERNAL_PREF,
Extension::NO_FLAGS,
false,
false)) {
observer2.Wait();
}
ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
}
// Test that external extensions with incorrect versions are not installed.
TEST_F(ExtensionServiceTest, FailOnWrongVersion) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
service()->set_extensions_enabled(true);
// Install an external extension with a version from the external
// source that is not equal to the version in the extension manifest.
Version wrong_version("1.2.3.4");
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->OnExternalExtensionFileFound(good_crx,
&wrong_version,
path,
Manifest::EXTERNAL_PREF,
Extension::NO_FLAGS,
false,
false);
observer.Wait();
ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
// Try again with the right version. Expect success.
service()->pending_extension_manager()->Remove(good_crx);
Version correct_version("1.0.0.0");
content::WindowedNotificationObserver observer2(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
if (service()->OnExternalExtensionFileFound(good_crx,
&correct_version,
path,
Manifest::EXTERNAL_PREF,
Extension::NO_FLAGS,
false,
false)) {
observer2.Wait();
}
ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
}
// Install a user script (they get converted automatically to an extension)
TEST_F(ExtensionServiceTest, InstallUserScript) {
// The details of script conversion are tested elsewhere, this just tests
// integration with ExtensionService.
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("user_script_basic.user.js");
ASSERT_TRUE(base::PathExists(path));
scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(service()));
installer->set_allow_silent_install(true);
installer->InstallUserScript(
path,
GURL("http://www.aaronboodman.com/scripts/user_script_basic.user.js"));
base::RunLoop().RunUntilIdle();
std::vector<base::string16> errors = GetErrors();
EXPECT_TRUE(installed_) << "Nothing was installed.";
EXPECT_FALSE(was_update_) << path.value();
ASSERT_EQ(1u, loaded_.size()) << "Nothing was loaded.";
EXPECT_EQ(0u, errors.size())
<< "There were errors: "
<< base::JoinString(errors, base::ASCIIToUTF16(","));
EXPECT_TRUE(service()->GetExtensionById(loaded_[0]->id(), false))
<< path.value();
installed_ = NULL;
was_update_ = false;
loaded_.clear();
ExtensionErrorReporter::GetInstance()->ClearErrors();
}
// Extensions don't install during shutdown.
TEST_F(ExtensionServiceTest, InstallExtensionDuringShutdown) {
InitializeEmptyExtensionService();
// Simulate shutdown.
service()->set_browser_terminating_for_test(true);
base::FilePath path = data_dir().AppendASCII("good.crx");
scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(service()));
installer->set_allow_silent_install(true);
installer->InstallCrx(path);
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(installed_) << "Extension installed during shutdown.";
ASSERT_EQ(0u, loaded_.size()) << "Extension loaded during shutdown.";
}
// This tests that the granted permissions preferences are correctly set when
// installing an extension.
TEST_F(ExtensionServiceTest, GrantedPermissions) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("permissions");
base::FilePath pem_path = path.AppendASCII("unknown.pem");
path = path.AppendASCII("unknown");
ASSERT_TRUE(base::PathExists(pem_path));
ASSERT_TRUE(base::PathExists(path));
ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
APIPermissionSet expected_api_perms;
URLPatternSet expected_host_perms;
// Make sure there aren't any granted permissions before the
// extension is installed.
EXPECT_FALSE(prefs->GetGrantedPermissions(permissions_crx).get());
const Extension* extension = PackAndInstallCRX(path, pem_path, INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(permissions_crx, extension->id());
// Verify that the valid API permissions have been recognized.
expected_api_perms.insert(APIPermission::kTab);
AddPattern(&expected_host_perms, "http://*.google.com/*");
AddPattern(&expected_host_perms, "https://*.google.com/*");
AddPattern(&expected_host_perms, "http://*.google.com.hk/*");
AddPattern(&expected_host_perms, "http://www.example.com/*");
scoped_ptr<const PermissionSet> known_perms =
prefs->GetGrantedPermissions(extension->id());
EXPECT_TRUE(known_perms.get());
EXPECT_FALSE(known_perms->IsEmpty());
EXPECT_EQ(expected_api_perms, known_perms->apis());
EXPECT_FALSE(known_perms->HasEffectiveFullAccess());
EXPECT_EQ(expected_host_perms, known_perms->effective_hosts());
}
#if !defined(OS_CHROMEOS)
// This tests that the granted permissions preferences are correctly set for
// default apps.
TEST_F(ExtensionServiceTest, DefaultAppsGrantedPermissions) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("permissions");
base::FilePath pem_path = path.AppendASCII("unknown.pem");
path = path.AppendASCII("unknown");
ASSERT_TRUE(base::PathExists(pem_path));
ASSERT_TRUE(base::PathExists(path));
ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
APIPermissionSet expected_api_perms;
URLPatternSet expected_host_perms;
// Make sure there aren't any granted permissions before the
// extension is installed.
EXPECT_FALSE(prefs->GetGrantedPermissions(permissions_crx).get());
const Extension* extension = PackAndInstallCRX(
path, pem_path, INSTALL_NEW, Extension::WAS_INSTALLED_BY_DEFAULT);
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(permissions_crx, extension->id());
// Verify that the valid API permissions have been recognized.
expected_api_perms.insert(APIPermission::kTab);
scoped_ptr<const PermissionSet> known_perms =
prefs->GetGrantedPermissions(extension->id());
EXPECT_TRUE(known_perms.get());
EXPECT_FALSE(known_perms->IsEmpty());
EXPECT_EQ(expected_api_perms, known_perms->apis());
EXPECT_FALSE(known_perms->HasEffectiveFullAccess());
}
#endif
#if !defined(OS_POSIX) || defined(OS_MACOSX)
// Tests that the granted permissions full_access bit gets set correctly when
// an extension contains an NPAPI plugin.
// Only run this on platforms that support NPAPI plugins.
TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
InitPluginService();
InitializeEmptyExtensionService();
ASSERT_TRUE(base::PathExists(good1_path()));
const Extension* extension = PackAndInstallCRX(good1_path(), INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
scoped_ptr<const PermissionSet> permissions =
prefs->GetGrantedPermissions(extension->id());
EXPECT_FALSE(permissions->IsEmpty());
EXPECT_TRUE(permissions->HasEffectiveFullAccess());
EXPECT_FALSE(permissions->apis().empty());
EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
// Full access implies full host access too...
EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
}
#endif
// Tests that the extension is disabled when permissions are missing from
// the extension's granted permissions preferences. (This simulates updating
// the browser to a version which recognizes more permissions).
TEST_F(ExtensionServiceTest, GrantedAPIAndHostPermissions) {
InitializeEmptyExtensionService();
base::FilePath path =
data_dir().AppendASCII("permissions").AppendASCII("unknown");
ASSERT_TRUE(base::PathExists(path));
const Extension* extension = PackAndInstallCRX(path, INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
std::string extension_id = extension->id();
ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
APIPermissionSet expected_api_permissions;
URLPatternSet expected_host_permissions;
expected_api_permissions.insert(APIPermission::kTab);
AddPattern(&expected_host_permissions, "http://*.google.com/*");
AddPattern(&expected_host_permissions, "https://*.google.com/*");
AddPattern(&expected_host_permissions, "http://*.google.com.hk/*");
AddPattern(&expected_host_permissions, "http://www.example.com/*");
std::set<std::string> host_permissions;
// Test that the extension is disabled when an API permission is missing from
// the extension's granted api permissions preference. (This simulates
// updating the browser to a version which recognizes a new API permission).
SetPref(extension_id, "granted_permissions.api",
new base::ListValue(), "granted_permissions.api");
service()->ReloadExtensionsForTest();
EXPECT_EQ(1u, registry()->disabled_extensions().size());
extension = registry()->disabled_extensions().begin()->get();
ASSERT_TRUE(prefs->IsExtensionDisabled(extension_id));
ASSERT_FALSE(service()->IsExtensionEnabled(extension_id));
ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
// Now grant and re-enable the extension, making sure the prefs are updated.
service()->GrantPermissionsAndEnableExtension(extension);
ASSERT_FALSE(prefs->IsExtensionDisabled(extension_id));
ASSERT_TRUE(service()->IsExtensionEnabled(extension_id));
ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
scoped_ptr<const PermissionSet> current_perms =
prefs->GetGrantedPermissions(extension_id);
ASSERT_TRUE(current_perms.get());
ASSERT_FALSE(current_perms->IsEmpty());
ASSERT_FALSE(current_perms->HasEffectiveFullAccess());
ASSERT_EQ(expected_api_permissions, current_perms->apis());
ASSERT_EQ(expected_host_permissions, current_perms->effective_hosts());
// Tests that the extension is disabled when a host permission is missing from
// the extension's granted host permissions preference. (This simulates
// updating the browser to a version which recognizes additional host
// permissions).
host_permissions.clear();
current_perms = NULL;
host_permissions.insert("http://*.google.com/*");
host_permissions.insert("https://*.google.com/*");
host_permissions.insert("http://*.google.com.hk/*");
base::ListValue* api_permissions = new base::ListValue();
api_permissions->Append(
new base::StringValue("tabs"));
SetPref(extension_id, "granted_permissions.api",
api_permissions, "granted_permissions.api");
SetPrefStringSet(
extension_id, "granted_permissions.scriptable_host", host_permissions);
service()->ReloadExtensionsForTest();
EXPECT_EQ(1u, registry()->disabled_extensions().size());
extension = registry()->disabled_extensions().begin()->get();
ASSERT_TRUE(prefs->IsExtensionDisabled(extension_id));
ASSERT_FALSE(service()->IsExtensionEnabled(extension_id));
ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
// Now grant and re-enable the extension, making sure the prefs are updated.
service()->GrantPermissionsAndEnableExtension(extension);
ASSERT_TRUE(service()->IsExtensionEnabled(extension_id));
ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
current_perms = prefs->GetGrantedPermissions(extension_id);
ASSERT_TRUE(current_perms.get());
ASSERT_FALSE(current_perms->IsEmpty());
ASSERT_FALSE(current_perms->HasEffectiveFullAccess());
ASSERT_EQ(expected_api_permissions, current_perms->apis());
ASSERT_EQ(expected_host_permissions, current_perms->effective_hosts());
}
// Test Packaging and installing an extension.
TEST_F(ExtensionServiceTest, PackExtension) {
InitializeEmptyExtensionService();
base::FilePath input_directory =
data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
.AppendASCII("1.0.0.0");
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
base::FilePath output_directory = temp_dir.path();
base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
base::FilePath privkey_path(output_directory.AppendASCII("privkey.pem"));
scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
ASSERT_TRUE(creator->Run(input_directory, crx_path, base::FilePath(),
privkey_path, ExtensionCreator::kNoRunFlags));
ASSERT_TRUE(base::PathExists(crx_path));
ASSERT_TRUE(base::PathExists(privkey_path));
// Repeat the run with the pem file gone, and no special flags
// Should refuse to overwrite the existing crx.
base::DeleteFile(privkey_path, false);
ASSERT_FALSE(creator->Run(input_directory, crx_path, base::FilePath(),
privkey_path, ExtensionCreator::kNoRunFlags));
// OK, now try it with a flag to overwrite existing crx. Should work.
ASSERT_TRUE(creator->Run(input_directory, crx_path, base::FilePath(),
privkey_path, ExtensionCreator::kOverwriteCRX));
// Repeat the run allowing existing crx, but the existing pem is still
// an error. Should fail.
ASSERT_FALSE(creator->Run(input_directory, crx_path, base::FilePath(),
privkey_path, ExtensionCreator::kOverwriteCRX));
ASSERT_TRUE(base::PathExists(privkey_path));
InstallCRX(crx_path, INSTALL_NEW);
// Try packing with invalid paths.
creator.reset(new ExtensionCreator());
ASSERT_FALSE(
creator->Run(base::FilePath(), base::FilePath(), base::FilePath(),
base::FilePath(), ExtensionCreator::kOverwriteCRX));
// Try packing an empty directory. Should fail because an empty directory is
// not a valid extension.
base::ScopedTempDir temp_dir2;
ASSERT_TRUE(temp_dir2.CreateUniqueTempDir());
creator.reset(new ExtensionCreator());
ASSERT_FALSE(creator->Run(temp_dir2.path(), crx_path, privkey_path,
base::FilePath(), ExtensionCreator::kOverwriteCRX));
// Try packing with an invalid manifest.
std::string invalid_manifest_content = "I am not a manifest.";
ASSERT_TRUE(base::WriteFile(
temp_dir2.path().Append(extensions::kManifestFilename),
invalid_manifest_content.c_str(), invalid_manifest_content.size()));
creator.reset(new ExtensionCreator());
ASSERT_FALSE(creator->Run(temp_dir2.path(), crx_path, privkey_path,
base::FilePath(), ExtensionCreator::kOverwriteCRX));
// Try packing with a private key that is a valid key, but invalid for the
// extension.
base::FilePath bad_private_key_dir =
data_dir().AppendASCII("bad_private_key");
crx_path = output_directory.AppendASCII("bad_private_key.crx");
privkey_path = data_dir().AppendASCII("bad_private_key.pem");
ASSERT_FALSE(creator->Run(bad_private_key_dir, crx_path, base::FilePath(),
privkey_path, ExtensionCreator::kOverwriteCRX));
}
// Test Packaging and installing an extension whose name contains punctuation.
TEST_F(ExtensionServiceTest, PackPunctuatedExtension) {
InitializeEmptyExtensionService();
base::FilePath input_directory = data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII(good0)
.AppendASCII("1.0.0.0");
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
// Extension names containing punctuation, and the expected names for the
// packed extensions.
const base::FilePath punctuated_names[] = {
base::FilePath(FILE_PATH_LITERAL("this.extensions.name.has.periods")),
base::FilePath(FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod")),
base::FilePath(FILE_PATH_LITERAL("thisextensionhasaslashinitsname/")).
NormalizePathSeparators(),
};
const base::FilePath expected_crx_names[] = {
base::FilePath(FILE_PATH_LITERAL("this.extensions.name.has.periods.crx")),
base::FilePath(
FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod.crx")),
base::FilePath(FILE_PATH_LITERAL("thisextensionhasaslashinitsname.crx")),
};
const base::FilePath expected_private_key_names[] = {
base::FilePath(FILE_PATH_LITERAL("this.extensions.name.has.periods.pem")),
base::FilePath(
FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod.pem")),
base::FilePath(FILE_PATH_LITERAL("thisextensionhasaslashinitsname.pem")),
};
for (size_t i = 0; i < arraysize(punctuated_names); ++i) {
SCOPED_TRACE(punctuated_names[i].value().c_str());
base::FilePath output_dir = temp_dir.path().Append(punctuated_names[i]);
// Copy the extension into the output directory, as PackExtensionJob doesn't
// let us choose where to output the packed extension.
ASSERT_TRUE(base::CopyDirectory(input_directory, output_dir, true));
base::FilePath expected_crx_path =
temp_dir.path().Append(expected_crx_names[i]);
base::FilePath expected_private_key_path =
temp_dir.path().Append(expected_private_key_names[i]);
PackExtensionTestClient pack_client(expected_crx_path,
expected_private_key_path);
scoped_refptr<extensions::PackExtensionJob> packer(
new extensions::PackExtensionJob(&pack_client, output_dir,
base::FilePath(),
ExtensionCreator::kOverwriteCRX));
packer->Start();
// The packer will post a notification task to the current thread's message
// loop when it is finished. We manually run the loop here so that we
// block and catch the notification; otherwise, the process would exit.
// This call to |Run()| is matched by a call to |Quit()| in the
// |PackExtensionTestClient|'s notification handling code.
base::MessageLoop::current()->Run();
if (HasFatalFailure())
return;
InstallCRX(expected_crx_path, INSTALL_NEW);
}
}
TEST_F(ExtensionServiceTest, PackExtensionContainingKeyFails) {
InitializeEmptyExtensionService();
base::ScopedTempDir extension_temp_dir;
ASSERT_TRUE(extension_temp_dir.CreateUniqueTempDir());
base::FilePath input_directory = extension_temp_dir.path().AppendASCII("ext");
ASSERT_TRUE(
base::CopyDirectory(data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
.AppendASCII("1.0.0.0"),
input_directory,
/*recursive=*/true));
base::ScopedTempDir output_temp_dir;
ASSERT_TRUE(output_temp_dir.CreateUniqueTempDir());
base::FilePath output_directory = output_temp_dir.path();
base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
base::FilePath privkey_path(output_directory.AppendASCII("privkey.pem"));
// Pack the extension once to get a private key.
scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
ASSERT_TRUE(creator->Run(input_directory, crx_path, base::FilePath(),
privkey_path, ExtensionCreator::kNoRunFlags))
<< creator->error_message();
ASSERT_TRUE(base::PathExists(crx_path));
ASSERT_TRUE(base::PathExists(privkey_path));
base::DeleteFile(crx_path, false);
// Move the pem file into the extension.
base::Move(privkey_path,
input_directory.AppendASCII("privkey.pem"));
// This pack should fail because of the contained private key.
EXPECT_FALSE(creator->Run(input_directory, crx_path, base::FilePath(),
privkey_path, ExtensionCreator::kNoRunFlags));
EXPECT_THAT(creator->error_message(),
testing::ContainsRegex(
"extension includes the key file.*privkey.pem"));
}
// Test Packaging and installing an extension using an openssl generated key.
// The openssl is generated with the following:
// > openssl genrsa -out privkey.pem 1024
// > openssl pkcs8 -topk8 -nocrypt -in privkey.pem -out privkey_asn1.pem
// The privkey.pem is a PrivateKey, and the pcks8 -topk8 creates a
// PrivateKeyInfo ASN.1 structure, we our RSAPrivateKey expects.
TEST_F(ExtensionServiceTest, PackExtensionOpenSSLKey) {
InitializeEmptyExtensionService();
base::FilePath input_directory =
data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
.AppendASCII("1.0.0.0");
base::FilePath privkey_path(
data_dir().AppendASCII("openssl_privkey_asn1.pem"));
ASSERT_TRUE(base::PathExists(privkey_path));
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
base::FilePath output_directory = temp_dir.path();
base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
ASSERT_TRUE(creator->Run(input_directory, crx_path, privkey_path,
base::FilePath(), ExtensionCreator::kOverwriteCRX));
InstallCRX(crx_path, INSTALL_NEW);
}
#if defined(THREAD_SANITIZER)
// Flaky under Tsan. http://crbug.com/377702
#define MAYBE_InstallTheme DISABLED_InstallTheme
#else
#define MAYBE_InstallTheme InstallTheme
#endif
TEST_F(ExtensionServiceTest, MAYBE_InstallTheme) {
InitializeEmptyExtensionService();
service()->Init();
// A theme.
base::FilePath path = data_dir().AppendASCII("theme.crx");
InstallCRX(path, INSTALL_NEW);
int pref_count = 0;
ValidatePrefKeyCount(++pref_count);
ValidateIntegerPref(theme_crx, "state", Extension::ENABLED);
ValidateIntegerPref(theme_crx, "location", Manifest::INTERNAL);
// A theme when extensions are disabled. Themes can be installed, even when
// extensions are disabled.
service()->set_extensions_enabled(false);
path = data_dir().AppendASCII("theme2.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ValidateIntegerPref(theme2_crx, "state", Extension::ENABLED);
ValidateIntegerPref(theme2_crx, "location", Manifest::INTERNAL);
// A theme with extension elements. Themes cannot have extension elements,
// so any such elements (like content scripts) should be ignored.
service()->set_extensions_enabled(true);
{
path = data_dir().AppendASCII("theme_with_extension.crx");
const Extension* extension = InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ASSERT_TRUE(extension);
EXPECT_TRUE(extension->is_theme());
EXPECT_EQ(
0u,
extensions::ContentScriptsInfo::GetContentScripts(extension).size());
}
// A theme with image resources missing (misspelt path).
path = data_dir().AppendASCII("theme_missing_image.crx");
InstallCRX(path, INSTALL_FAILED);
ValidatePrefKeyCount(pref_count);
}
TEST_F(ExtensionServiceTest, LoadLocalizedTheme) {
// Load.
InitializeEmptyExtensionService();
service()->Init();
base::FilePath extension_path = data_dir().AppendASCII("theme_i18n");
extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
const Extension* theme = registry()->enabled_extensions().begin()->get();
EXPECT_EQ("name", theme->name());
EXPECT_EQ("description", theme->description());
// Cleanup the "Cached Theme.pak" file (or "Cached Theme Material Design.pak"
// when Material Design is enabled). Ideally, this would be installed in a
// temporary directory, but it automatically installs to the extension's
// directory, and we don't want to copy the whole extension for a unittest.
base::FilePath theme_file = extension_path.Append(
ui::MaterialDesignController::IsModeMaterial()
? chrome::kThemePackMaterialDesignFilename
: chrome::kThemePackFilename);
ASSERT_TRUE(base::PathExists(theme_file));
ASSERT_TRUE(base::DeleteFile(theme_file, false)); // Not recursive.
}
#if defined(OS_POSIX)
TEST_F(ExtensionServiceTest, UnpackedExtensionMayContainSymlinkedFiles) {
base::FilePath source_data_dir =
data_dir().AppendASCII("unpacked").AppendASCII("symlinks_allowed");
// Paths to test data files.
base::FilePath source_manifest = source_data_dir.AppendASCII("manifest.json");
ASSERT_TRUE(base::PathExists(source_manifest));
base::FilePath source_icon = source_data_dir.AppendASCII("icon.png");
ASSERT_TRUE(base::PathExists(source_icon));
// Set up the temporary extension directory.
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
base::FilePath extension_path = temp.path();
base::FilePath manifest = extension_path.Append(
extensions::kManifestFilename);
base::FilePath icon_symlink = extension_path.AppendASCII("icon.png");
base::CopyFile(source_manifest, manifest);
base::CreateSymbolicLink(source_icon, icon_symlink);
// Load extension.
InitializeEmptyExtensionService();
extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(GetErrors().empty());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
}
#endif
TEST_F(ExtensionServiceTest, UnpackedExtensionMayNotHaveUnderscore) {
InitializeEmptyExtensionService();
base::FilePath extension_path = data_dir().AppendASCII("underscore_name");
extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, GetErrors().size());
EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
TEST_F(ExtensionServiceTest, InstallLocalizedTheme) {
InitializeEmptyExtensionService();
service()->Init();
base::FilePath theme_path = data_dir().AppendASCII("theme_i18n");
const Extension* theme = PackAndInstallCRX(theme_path, INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ("name", theme->name());
EXPECT_EQ("description", theme->description());
}
TEST_F(ExtensionServiceTest, InstallApps) {
InitializeEmptyExtensionService();
// An empty app.
const Extension* app =
PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
int pref_count = 0;
ValidatePrefKeyCount(++pref_count);
ASSERT_EQ(1u, registry()->enabled_extensions().size());
ValidateIntegerPref(app->id(), "state", Extension::ENABLED);
ValidateIntegerPref(app->id(), "location", Manifest::INTERNAL);
// Another app with non-overlapping extent. Should succeed.
PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
// A third app whose extent overlaps the first. Should fail.
PackAndInstallCRX(data_dir().AppendASCII("app3"), INSTALL_FAILED);
ValidatePrefKeyCount(pref_count);
}
// Tests that file access is OFF by default.
TEST_F(ExtensionServiceTest, DefaultFileAccess) {
InitializeEmptyExtensionService();
const Extension* extension = PackAndInstallCRX(
data_dir().AppendASCII("permissions").AppendASCII("files"), INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_FALSE(
ExtensionPrefs::Get(profile())->AllowFileAccess(extension->id()));
}
TEST_F(ExtensionServiceTest, UpdateApps) {
InitializeEmptyExtensionService();
base::FilePath extensions_path = data_dir().AppendASCII("app_update");
// First install v1 of a hosted app.
const Extension* extension =
InstallCRX(extensions_path.AppendASCII("v1.crx"), INSTALL_NEW);
ASSERT_EQ(1u, registry()->enabled_extensions().size());
std::string id = extension->id();
ASSERT_EQ(std::string("1"), extension->version()->GetString());
// Now try updating to v2.
UpdateExtension(id,
extensions_path.AppendASCII("v2.crx"),
ENABLED);
ASSERT_EQ(std::string("2"),
service()->GetExtensionById(id, false)->version()->GetString());
}
// Verifies that the NTP page and launch ordinals are kept when updating apps.
TEST_F(ExtensionServiceTest, UpdateAppsRetainOrdinals) {
InitializeEmptyExtensionService();
AppSorting* sorting = ExtensionSystem::Get(profile())->app_sorting();
base::FilePath extensions_path = data_dir().AppendASCII("app_update");
// First install v1 of a hosted app.
const Extension* extension =
InstallCRX(extensions_path.AppendASCII("v1.crx"), INSTALL_NEW);
ASSERT_EQ(1u, registry()->enabled_extensions().size());
std::string id = extension->id();
ASSERT_EQ(std::string("1"), extension->version()->GetString());
// Modify the ordinals so we can distinguish them from the defaults.
syncer::StringOrdinal new_page_ordinal =
sorting->GetPageOrdinal(id).CreateAfter();
syncer::StringOrdinal new_launch_ordinal =
sorting->GetAppLaunchOrdinal(id).CreateBefore();
sorting->SetPageOrdinal(id, new_page_ordinal);
sorting->SetAppLaunchOrdinal(id, new_launch_ordinal);
// Now try updating to v2.
UpdateExtension(id, extensions_path.AppendASCII("v2.crx"), ENABLED);
ASSERT_EQ(std::string("2"),
service()->GetExtensionById(id, false)->version()->GetString());
// Verify that the ordinals match.
ASSERT_TRUE(new_page_ordinal.Equals(sorting->GetPageOrdinal(id)));
ASSERT_TRUE(new_launch_ordinal.Equals(sorting->GetAppLaunchOrdinal(id)));
}
// Ensures that the CWS has properly initialized ordinals.
TEST_F(ExtensionServiceTest, EnsureCWSOrdinalsInitialized) {
InitializeEmptyExtensionService();
service()->component_loader()->Add(
IDR_WEBSTORE_MANIFEST, base::FilePath(FILE_PATH_LITERAL("web_store")));
service()->Init();
AppSorting* sorting = ExtensionSystem::Get(profile())->app_sorting();
EXPECT_TRUE(
sorting->GetPageOrdinal(extensions::kWebStoreAppId).IsValid());
EXPECT_TRUE(
sorting->GetAppLaunchOrdinal(extensions::kWebStoreAppId).IsValid());
}
TEST_F(ExtensionServiceTest, InstallAppsWithUnlimitedStorage) {
InitializeEmptyExtensionService();
EXPECT_TRUE(registry()->enabled_extensions().is_empty());
int pref_count = 0;
// Install app1 with unlimited storage.
const Extension* extension =
PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ASSERT_EQ(1u, registry()->enabled_extensions().size());
const std::string id1 = extension->id();
EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
APIPermission::kUnlimitedStorage));
EXPECT_TRUE(extension->web_extent().MatchesURL(
extensions::AppLaunchInfo::GetFullLaunchURL(extension)));
const GURL origin1(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
origin1));
// Install app2 from the same origin with unlimited storage.
extension = PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ASSERT_EQ(2u, registry()->enabled_extensions().size());
const std::string id2 = extension->id();
EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
APIPermission::kUnlimitedStorage));
EXPECT_TRUE(extension->web_extent().MatchesURL(
extensions::AppLaunchInfo::GetFullLaunchURL(extension)));
const GURL origin2(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
EXPECT_EQ(origin1, origin2);
EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
origin2));
// Uninstall one of them, unlimited storage should still be granted
// to the origin.
UninstallExtension(id1, false);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
origin1));
// Uninstall the other, unlimited storage should be revoked.
UninstallExtension(id2, false);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_FALSE(
profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
origin2));
}
TEST_F(ExtensionServiceTest, InstallAppsAndCheckStorageProtection) {
InitializeEmptyExtensionService();
EXPECT_TRUE(registry()->enabled_extensions().is_empty());
int pref_count = 0;
const Extension* extension =
PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(extension->is_app());
const std::string id1 = extension->id();
const GURL origin1(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
origin1));
// App 4 has a different origin (maps.google.com).
extension = PackAndInstallCRX(data_dir().AppendASCII("app4"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ASSERT_EQ(2u, registry()->enabled_extensions().size());
const std::string id2 = extension->id();
const GURL origin2(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
ASSERT_NE(origin1, origin2);
EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
origin2));
UninstallExtension(id1, false);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
UninstallExtension(id2, false);
EXPECT_TRUE(registry()->enabled_extensions().is_empty());
EXPECT_FALSE(
profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
origin1));
EXPECT_FALSE(
profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
origin2));
}
// Test that when an extension version is reinstalled, nothing happens.
TEST_F(ExtensionServiceTest, Reinstall) {
InitializeEmptyExtensionService();
// A simple extension that should install without error.
base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(1);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
// Reinstall the same version, it should overwrite the previous one.
InstallCRX(path, INSTALL_UPDATED);
ValidatePrefKeyCount(1);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
}
// Test that we can determine if extensions came from the
// Chrome web store.
TEST_F(ExtensionServiceTest, FromWebStore) {
InitializeEmptyExtensionService();
// A simple extension that should install without error.
base::FilePath path = data_dir().AppendASCII("good.crx");
// Not from web store.
const Extension* extension = InstallCRX(path, INSTALL_NEW);
std::string id = extension->id();
ValidatePrefKeyCount(1);
ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", false));
ASSERT_FALSE(extension->from_webstore());
// Test install from web store.
InstallCRXFromWebStore(path, INSTALL_UPDATED); // From web store.
ValidatePrefKeyCount(1);
ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", true));
// Reload so extension gets reinitialized with new value.
service()->ReloadExtensionsForTest();
extension = service()->GetExtensionById(id, false);
ASSERT_TRUE(extension->from_webstore());
// Upgrade to version 2.0
path = data_dir().AppendASCII("good2.crx");
UpdateExtension(good_crx, path, ENABLED);
ValidatePrefKeyCount(1);
ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", true));
}
// Test upgrading a signed extension.
TEST_F(ExtensionServiceTest, UpgradeSignedGood) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* extension = InstallCRX(path, INSTALL_NEW);
std::string id = extension->id();
ASSERT_EQ("1.0.0.0", extension->version()->GetString());
ASSERT_EQ(0u, GetErrors().size());
// Upgrade to version 1.0.0.1.
// Also test that the extension's old and new title are correctly retrieved.
path = data_dir().AppendASCII("good2.crx");
InstallCRX(path, INSTALL_UPDATED, Extension::NO_FLAGS, "My extension 1");
extension = service()->GetExtensionById(id, false);
ASSERT_EQ("1.0.0.1", extension->version()->GetString());
ASSERT_EQ("My updated extension 1", extension->name());
ASSERT_EQ(0u, GetErrors().size());
}
// Test upgrading a signed extension with a bad signature.
TEST_F(ExtensionServiceTest, UpgradeSignedBad) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
// Try upgrading with a bad signature. This should fail during the unpack,
// because the key will not match the signature.
path = data_dir().AppendASCII("bad_signature.crx");
InstallCRX(path, INSTALL_FAILED);
}
// Test a normal update via the UpdateExtension API
TEST_F(ExtensionServiceTest, UpdateExtension) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ("1.0.0.0", good->VersionString());
ASSERT_EQ(good_crx, good->id());
path = data_dir().AppendASCII("good2.crx");
UpdateExtension(good_crx, path, ENABLED);
ASSERT_EQ(
"1.0.0.1",
service()->GetExtensionById(good_crx, false)->version()->GetString());
}
// Extensions should not be updated during browser shutdown.
TEST_F(ExtensionServiceTest, UpdateExtensionDuringShutdown) {
InitializeEmptyExtensionService();
// Install an extension.
base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ(good_crx, good->id());
// Simulate shutdown.
service()->set_browser_terminating_for_test(true);
// Update should fail and extension should not be updated.
path = data_dir().AppendASCII("good2.crx");
bool updated = service()->UpdateExtension(
extensions::CRXFileInfo(good_crx, path), true, NULL);
ASSERT_FALSE(updated);
ASSERT_EQ(
"1.0.0.0",
service()->GetExtensionById(good_crx, false)->version()->GetString());
}
// Test updating a not-already-installed extension - this should fail
TEST_F(ExtensionServiceTest, UpdateNotInstalledExtension) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
UpdateExtension(good_crx, path, UPDATED);
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, registry()->enabled_extensions().size());
ASSERT_FALSE(installed_);
ASSERT_EQ(0u, loaded_.size());
}
// Makes sure you can't downgrade an extension via UpdateExtension
TEST_F(ExtensionServiceTest, UpdateWillNotDowngrade) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good2.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ("1.0.0.1", good->VersionString());
ASSERT_EQ(good_crx, good->id());
// Change path from good2.crx -> good.crx
path = data_dir().AppendASCII("good.crx");
UpdateExtension(good_crx, path, FAILED);
ASSERT_EQ(
"1.0.0.1",
service()->GetExtensionById(good_crx, false)->version()->GetString());
}
// Make sure calling update with an identical version does nothing
TEST_F(ExtensionServiceTest, UpdateToSameVersionIsNoop) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ(good_crx, good->id());
UpdateExtension(good_crx, path, FAILED_SILENTLY);
}
// Tests that updating an extension does not clobber old state.
TEST_F(ExtensionServiceTest, UpdateExtensionPreservesState) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ("1.0.0.0", good->VersionString());
ASSERT_EQ(good_crx, good->id());
// Disable it and allow it to run in incognito. These settings should carry
// over to the updated version.
service()->DisableExtension(good->id(), Extension::DISABLE_USER_ACTION);
extensions::util::SetIsIncognitoEnabled(good->id(), profile(), true);
path = data_dir().AppendASCII("good2.crx");
UpdateExtension(good_crx, path, INSTALLED);
ASSERT_EQ(1u, registry()->disabled_extensions().size());
const Extension* good2 = service()->GetExtensionById(good_crx, true);
ASSERT_EQ("1.0.0.1", good2->version()->GetString());
EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good2->id(), profile()));
EXPECT_EQ(Extension::DISABLE_USER_ACTION,
ExtensionPrefs::Get(profile())->GetDisableReasons(good2->id()));
}
// Tests that updating preserves extension location.
TEST_F(ExtensionServiceTest, UpdateExtensionPreservesLocation) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good =
InstallCRXWithLocation(path, Manifest::EXTERNAL_PREF, INSTALL_NEW);
ASSERT_EQ("1.0.0.0", good->VersionString());
ASSERT_EQ(good_crx, good->id());
path = data_dir().AppendASCII("good2.crx");
UpdateExtension(good_crx, path, ENABLED);
const Extension* good2 = service()->GetExtensionById(good_crx, false);
ASSERT_EQ("1.0.0.1", good2->version()->GetString());
EXPECT_EQ(good2->location(), Manifest::EXTERNAL_PREF);
}
// Makes sure that LOAD extension types can downgrade.
TEST_F(ExtensionServiceTest, LoadExtensionsCanDowngrade) {
InitializeEmptyExtensionService();
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
// We'll write the extension manifest dynamically to a temporary path
// to make it easier to change the version number.
base::FilePath extension_path = temp.path();
base::FilePath manifest_path =
extension_path.Append(extensions::kManifestFilename);
ASSERT_FALSE(base::PathExists(manifest_path));
// Start with version 2.0.
base::DictionaryValue manifest;
manifest.SetString("version", "2.0");
manifest.SetString("name", "LOAD Downgrade Test");
manifest.SetInteger("manifest_version", 2);
JSONFileValueSerializer serializer(manifest_path);
ASSERT_TRUE(serializer.Serialize(manifest));
extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(Manifest::UNPACKED, loaded_[0]->location());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ("2.0", loaded_[0]->VersionString());
// Now set the version number to 1.0, reload the extensions and verify that
// the downgrade was accepted.
manifest.SetString("version", "1.0");
ASSERT_TRUE(serializer.Serialize(manifest));
extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(Manifest::UNPACKED, loaded_[0]->location());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ("1.0", loaded_[0]->VersionString());
}
#if !defined(OS_POSIX) || defined(OS_MACOSX)
// LOAD extensions with plugins require approval.
// Only run this on platforms that support NPAPI plugins.
TEST_F(ExtensionServiceTest, LoadExtensionsWithPlugins) {
base::FilePath extension_with_plugin_path = good1_path();
base::FilePath extension_no_plugin_path = good2_path();
InitPluginService();
InitializeEmptyExtensionService();
service()->set_show_extensions_prompts(true);
// Start by canceling any install prompts.
scoped_ptr<extensions::ScopedTestDialogAutoConfirm> auto_confirm(
new extensions::ScopedTestDialogAutoConfirm(
extensions::ScopedTestDialogAutoConfirm::CANCEL));
// The extension that has a plugin should not install.
extensions::UnpackedInstaller::Create(service())
->Load(extension_with_plugin_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(0u, loaded_.size());
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
// But the extension with no plugin should since there's no prompt.
ExtensionErrorReporter::GetInstance()->ClearErrors();
extensions::UnpackedInstaller::Create(service())
->Load(extension_no_plugin_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(1u, loaded_.size());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
// The plugin extension should install if we accept the dialog.
auto_confirm.reset();
auto_confirm.reset(new extensions::ScopedTestDialogAutoConfirm(
extensions::ScopedTestDialogAutoConfirm::ACCEPT));
ExtensionErrorReporter::GetInstance()->ClearErrors();
extensions::UnpackedInstaller::Create(service())
->Load(extension_with_plugin_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(2u, loaded_.size());
EXPECT_EQ(2u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
EXPECT_TRUE(registry()->enabled_extensions().Contains(good1));
EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
// Make sure the granted permissions have been setup.
scoped_ptr<const PermissionSet> permissions =
ExtensionPrefs::Get(profile())->GetGrantedPermissions(good1);
EXPECT_FALSE(permissions->IsEmpty());
EXPECT_TRUE(permissions->HasEffectiveFullAccess());
EXPECT_FALSE(permissions->apis().empty());
EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
// We should be able to reload the extension without getting another prompt.
loaded_.clear();
auto_confirm.reset();
auto_confirm.reset(new extensions::ScopedTestDialogAutoConfirm(
extensions::ScopedTestDialogAutoConfirm::CANCEL));
service()->ReloadExtension(good1);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, loaded_.size());
EXPECT_EQ(2u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
#endif // !defined(OS_POSIX) || defined(OS_MACOSX)
namespace {
bool IsExtension(const Extension* extension) {
return extension->GetType() == Manifest::TYPE_EXTENSION;
}
#if defined(ENABLE_BLACKLIST_TESTS)
std::set<std::string> StringSet(const std::string& s) {
std::set<std::string> set;
set.insert(s);
return set;
}
std::set<std::string> StringSet(const std::string& s1, const std::string& s2) {
std::set<std::string> set = StringSet(s1);
set.insert(s2);
return set;
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
} // namespace
// Test adding a pending extension.
TEST_F(ExtensionServiceTest, AddPendingExtensionFromSync) {
InitializeEmptyExtensionService();
const std::string kFakeId(all_zero);
const GURL kFakeUpdateURL("http:://fake.update/url");
const bool kFakeRemoteInstall(false);
const bool kFakeInstalledByCustodian(false);
EXPECT_TRUE(
service()->pending_extension_manager()->AddFromSync(
kFakeId,
kFakeUpdateURL,
base::Version(),
&IsExtension,
kFakeRemoteInstall,
kFakeInstalledByCustodian));
const extensions::PendingExtensionInfo* pending_extension_info;
ASSERT_TRUE((pending_extension_info =
service()->pending_extension_manager()->GetById(kFakeId)));
EXPECT_EQ(kFakeUpdateURL, pending_extension_info->update_url());
EXPECT_EQ(&IsExtension, pending_extension_info->should_allow_install_);
// Use
// EXPECT_TRUE(kFakeRemoteInstall == pending_extension_info->remote_install())
// instead of
// EXPECT_EQ(kFakeRemoteInstall, pending_extension_info->remote_install())
// as gcc 4.7 issues the following warning on EXPECT_EQ(false, x), which is
// turned into an error with -Werror=conversion-null:
// converting 'false' to pointer type for argument 1 of
// 'char testing::internal::IsNullLiteralHelper(testing::internal::Secret*)'
// https://code.google.com/p/googletest/issues/detail?id=458
EXPECT_TRUE(kFakeRemoteInstall == pending_extension_info->remote_install());
}
namespace {
const char kGoodId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
const char kGoodUpdateURL[] = "http://good.update/url";
const char kGoodVersion[] = "1";
const bool kGoodIsFromSync = true;
const bool kGoodRemoteInstall = false;
const bool kGoodInstalledByCustodian = false;
} // namespace
// Test installing a pending extension (this goes through
// ExtensionService::UpdateExtension).
TEST_F(ExtensionServiceTest, UpdatePendingExtension) {
InitializeEmptyExtensionService();
EXPECT_TRUE(
service()->pending_extension_manager()->AddFromSync(
kGoodId,
GURL(kGoodUpdateURL),
base::Version(kGoodVersion),
&IsExtension,
kGoodRemoteInstall,
kGoodInstalledByCustodian));
EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(kGoodId));
base::FilePath path = data_dir().AppendASCII("good.crx");
UpdateExtension(kGoodId, path, ENABLED);
EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
const Extension* extension = service()->GetExtensionById(kGoodId, true);
EXPECT_TRUE(extension);
}
TEST_F(ExtensionServiceTest, UpdatePendingExtensionWrongVersion) {
InitializeEmptyExtensionService();
base::Version other_version("0.1");
ASSERT_TRUE(other_version.IsValid());
ASSERT_FALSE(other_version.Equals(base::Version(kGoodVersion)));
EXPECT_TRUE(
service()->pending_extension_manager()->AddFromSync(
kGoodId,
GURL(kGoodUpdateURL),
other_version,
&IsExtension,
kGoodRemoteInstall,
kGoodInstalledByCustodian));
EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(kGoodId));
base::FilePath path = data_dir().AppendASCII("good.crx");
// After installation, the extension should be disabled, because it's missing
// permissions.
UpdateExtension(kGoodId, path, DISABLED);
EXPECT_TRUE(
ExtensionPrefs::Get(profile())->DidExtensionEscalatePermissions(kGoodId));
// It should still have been installed though.
EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
const Extension* extension = service()->GetExtensionById(kGoodId, true);
EXPECT_TRUE(extension);
}
namespace {
bool IsTheme(const Extension* extension) {
return extension->is_theme();
}
} // namespace
// Test updating a pending theme.
// Disabled due to ASAN failure. http://crbug.com/108320
TEST_F(ExtensionServiceTest, DISABLED_UpdatePendingTheme) {
InitializeEmptyExtensionService();
EXPECT_TRUE(service()->pending_extension_manager()->AddFromSync(
theme_crx, GURL(), base::Version(), &IsTheme, false, false));
EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(theme_crx));
base::FilePath path = data_dir().AppendASCII("theme.crx");
UpdateExtension(theme_crx, path, ENABLED);
EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(theme_crx));
const Extension* extension = service()->GetExtensionById(theme_crx, true);
ASSERT_TRUE(extension);
EXPECT_FALSE(
ExtensionPrefs::Get(profile())->IsExtensionDisabled(extension->id()));
EXPECT_TRUE(service()->IsExtensionEnabled(theme_crx));
}
#if defined(OS_CHROMEOS)
// Always fails on ChromeOS: http://crbug.com/79737
#define MAYBE_UpdatePendingExternalCrx DISABLED_UpdatePendingExternalCrx
#else
#define MAYBE_UpdatePendingExternalCrx UpdatePendingExternalCrx
#endif
// Test updating a pending CRX as if the source is an external extension
// with an update URL. In this case we don't know if the CRX is a theme
// or not.
TEST_F(ExtensionServiceTest, MAYBE_UpdatePendingExternalCrx) {
InitializeEmptyExtensionService();
EXPECT_TRUE(service()->pending_extension_manager()->AddFromExternalUpdateUrl(
theme_crx,
std::string(),
GURL(),
Manifest::EXTERNAL_PREF_DOWNLOAD,
Extension::NO_FLAGS,
false));
EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(theme_crx));
base::FilePath path = data_dir().AppendASCII("theme.crx");
UpdateExtension(theme_crx, path, ENABLED);
EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(theme_crx));
const Extension* extension = service()->GetExtensionById(theme_crx, true);
ASSERT_TRUE(extension);
EXPECT_FALSE(
ExtensionPrefs::Get(profile())->IsExtensionDisabled(extension->id()));
EXPECT_TRUE(service()->IsExtensionEnabled(extension->id()));
EXPECT_FALSE(
extensions::util::IsIncognitoEnabled(extension->id(), profile()));
}
// Test updating a pending CRX as if the source is an external extension
// with an update URL. The external update should overwrite a sync update,
// but a sync update should not overwrite a non-sync update.
TEST_F(ExtensionServiceTest, UpdatePendingExternalCrxWinsOverSync) {
InitializeEmptyExtensionService();
// Add a crx to be installed from the update mechanism.
EXPECT_TRUE(
service()->pending_extension_manager()->AddFromSync(
kGoodId,
GURL(kGoodUpdateURL),
base::Version(),
&IsExtension,
kGoodRemoteInstall,
kGoodInstalledByCustodian));
// Check that there is a pending crx, with is_from_sync set to true.
const extensions::PendingExtensionInfo* pending_extension_info;
ASSERT_TRUE((pending_extension_info =
service()->pending_extension_manager()->GetById(kGoodId)));
EXPECT_TRUE(pending_extension_info->is_from_sync());
// Add a crx to be updated, with the same ID, from a non-sync source.
EXPECT_TRUE(service()->pending_extension_manager()->AddFromExternalUpdateUrl(
kGoodId,
std::string(),
GURL(kGoodUpdateURL),
Manifest::EXTERNAL_PREF_DOWNLOAD,
Extension::NO_FLAGS,
false));
// Check that there is a pending crx, with is_from_sync set to false.
ASSERT_TRUE((pending_extension_info =
service()->pending_extension_manager()->GetById(kGoodId)));
EXPECT_FALSE(pending_extension_info->is_from_sync());
EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD,
pending_extension_info->install_source());
// Add a crx to be installed from the update mechanism.
EXPECT_FALSE(
service()->pending_extension_manager()->AddFromSync(
kGoodId,
GURL(kGoodUpdateURL),
base::Version(),
&IsExtension,
kGoodRemoteInstall,
kGoodInstalledByCustodian));
// Check that the external, non-sync update was not overridden.
ASSERT_TRUE((pending_extension_info =
service()->pending_extension_manager()->GetById(kGoodId)));
EXPECT_FALSE(pending_extension_info->is_from_sync());
EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD,
pending_extension_info->install_source());
}
// Updating a theme should fail if the updater is explicitly told that
// the CRX is not a theme.
TEST_F(ExtensionServiceTest, UpdatePendingCrxThemeMismatch) {
InitializeEmptyExtensionService();
EXPECT_TRUE(service()->pending_extension_manager()->AddFromSync(
theme_crx, GURL(), base::Version(), &IsExtension, false, false));
EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(theme_crx));
base::FilePath path = data_dir().AppendASCII("theme.crx");
UpdateExtension(theme_crx, path, FAILED_SILENTLY);
EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(theme_crx));
const Extension* extension = service()->GetExtensionById(theme_crx, true);
ASSERT_FALSE(extension);
}
// TODO(akalin): Test updating a pending extension non-silently once
// we can mock out ExtensionInstallUI and inject our version into
// UpdateExtension().
// Test updating a pending extension which fails the should-install test.
TEST_F(ExtensionServiceTest, UpdatePendingExtensionFailedShouldInstallTest) {
InitializeEmptyExtensionService();
// Add pending extension with a flipped is_theme.
EXPECT_TRUE(
service()->pending_extension_manager()->AddFromSync(
kGoodId,
GURL(kGoodUpdateURL),
base::Version(),
&IsTheme,
kGoodRemoteInstall,
kGoodInstalledByCustodian));
EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(kGoodId));
base::FilePath path = data_dir().AppendASCII("good.crx");
UpdateExtension(kGoodId, path, UPDATED);
// TODO(akalin): Figure out how to check that the extensions
// directory is cleaned up properly in OnExtensionInstalled().
EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
}
// TODO(akalin): Figure out how to test that installs of pending
// unsyncable extensions are blocked.
// Test updating a pending extension for one that is not pending.
TEST_F(ExtensionServiceTest, UpdatePendingExtensionNotPending) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
UpdateExtension(kGoodId, path, UPDATED);
EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
}
// Test updating a pending extension for one that is already
// installed.
TEST_F(ExtensionServiceTest, UpdatePendingExtensionAlreadyInstalled) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_FALSE(good->is_theme());
// Use AddExtensionImpl() as AddFrom*() would balk.
service()->pending_extension_manager()->AddExtensionImpl(
good->id(),
std::string(),
extensions::ManifestURL::GetUpdateURL(good),
Version(),
&IsExtension,
kGoodIsFromSync,
Manifest::INTERNAL,
Extension::NO_FLAGS,
false,
kGoodRemoteInstall);
UpdateExtension(good->id(), path, ENABLED);
EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
}
#if defined(ENABLE_BLACKLIST_TESTS)
// Tests blacklisting then unblacklisting extensions after the service has been
// initialized.
TEST_F(ExtensionServiceTest, SetUnsetBlacklistInPrefs) {
extensions::TestBlacklist test_blacklist;
// A profile with 3 extensions installed: good0, good1, and good2.
InitializeGoodInstalledExtensionService();
test_blacklist.Attach(service()->blacklist_);
service()->Init();
const extensions::ExtensionSet& enabled_extensions =
registry()->enabled_extensions();
const extensions::ExtensionSet& blacklisted_extensions =
registry()->blacklisted_extensions();
EXPECT_TRUE(enabled_extensions.Contains(good0) &&
!blacklisted_extensions.Contains(good0));
EXPECT_TRUE(enabled_extensions.Contains(good1) &&
!blacklisted_extensions.Contains(good1));
EXPECT_TRUE(enabled_extensions.Contains(good2) &&
!blacklisted_extensions.Contains(good2));
EXPECT_FALSE(IsPrefExist(good0, "blacklist"));
EXPECT_FALSE(IsPrefExist(good1, "blacklist"));
EXPECT_FALSE(IsPrefExist(good2, "blacklist"));
EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
// Blacklist good0 and good1 (and an invalid extension ID).
test_blacklist.SetBlacklistState(
good0, extensions::BLACKLISTED_MALWARE, true);
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_MALWARE, true);
test_blacklist.SetBlacklistState(
"invalid_id", extensions::BLACKLISTED_MALWARE, true);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(!enabled_extensions.Contains(good0) &&
blacklisted_extensions.Contains(good0));
EXPECT_TRUE(!enabled_extensions.Contains(good1) &&
blacklisted_extensions.Contains(good1));
EXPECT_TRUE(enabled_extensions.Contains(good2) &&
!blacklisted_extensions.Contains(good2));
EXPECT_TRUE(ValidateBooleanPref(good0, "blacklist", true));
EXPECT_TRUE(ValidateBooleanPref(good1, "blacklist", true));
EXPECT_FALSE(IsPrefExist(good2, "blacklist"));
EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
// Un-blacklist good1 and blacklist good2.
test_blacklist.Clear(false);
test_blacklist.SetBlacklistState(
good0, extensions::BLACKLISTED_MALWARE, true);
test_blacklist.SetBlacklistState(
good2, extensions::BLACKLISTED_MALWARE, true);
test_blacklist.SetBlacklistState(
"invalid_id", extensions::BLACKLISTED_MALWARE, true);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(!enabled_extensions.Contains(good0) &&
blacklisted_extensions.Contains(good0));
EXPECT_TRUE(enabled_extensions.Contains(good1) &&
!blacklisted_extensions.Contains(good1));
EXPECT_TRUE(!enabled_extensions.Contains(good2) &&
blacklisted_extensions.Contains(good2));
EXPECT_TRUE(ValidateBooleanPref(good0, "blacklist", true));
EXPECT_FALSE(IsPrefExist(good1, "blacklist"));
EXPECT_TRUE(ValidateBooleanPref(good2, "blacklist", true));
EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
#if defined(ENABLE_BLACKLIST_TESTS)
// Tests trying to install a blacklisted extension.
TEST_F(ExtensionServiceTest, BlacklistedExtensionWillNotInstall) {
scoped_refptr<FakeSafeBrowsingDatabaseManager> blacklist_db(
new FakeSafeBrowsingDatabaseManager(true));
Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_db(blacklist_db);
InitializeEmptyExtensionService();
service()->Init();
// After blacklisting good_crx, we cannot install it.
blacklist_db->SetUnsafe(good_crx).NotifyUpdate();
base::RunLoop().RunUntilIdle();
base::FilePath path = data_dir().AppendASCII("good.crx");
// HACK: specify WAS_INSTALLED_BY_DEFAULT so that test machinery doesn't
// decide to install this silently. Somebody should fix these tests, all
// 6,000 lines of them. Hah!
InstallCRX(path, INSTALL_FAILED, Extension::WAS_INSTALLED_BY_DEFAULT);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
#if defined(ENABLE_BLACKLIST_TESTS)
// Unload blacklisted extension on policy change.
TEST_F(ExtensionServiceTest, UnloadBlacklistedExtensionPolicy) {
extensions::TestBlacklist test_blacklist;
// A profile with no extensions installed.
InitializeEmptyExtensionServiceWithTestingPrefs();
test_blacklist.Attach(service()->blacklist_);
base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
EXPECT_EQ(good_crx, good->id());
UpdateExtension(good_crx, path, FAILED_SILENTLY);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.SetIndividualExtensionInstallationAllowed(good_crx, true);
}
test_blacklist.SetBlacklistState(
good_crx, extensions::BLACKLISTED_MALWARE, true);
base::RunLoop().RunUntilIdle();
// The good_crx is blacklisted and the whitelist doesn't negate it.
ASSERT_TRUE(ValidateBooleanPref(good_crx, "blacklist", true));
EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
#if defined(ENABLE_BLACKLIST_TESTS)
// Tests that a blacklisted extension is eventually unloaded on startup, if it
// wasn't already.
TEST_F(ExtensionServiceTest, WillNotLoadBlacklistedExtensionsFromDirectory) {
extensions::TestBlacklist test_blacklist;
// A profile with 3 extensions installed: good0, good1, and good2.
InitializeGoodInstalledExtensionService();
test_blacklist.Attach(service()->blacklist_);
// Blacklist good1 before the service initializes.
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_MALWARE, false);
// Load extensions.
service()->Init();
ASSERT_EQ(3u, loaded_.size()); // hasn't had time to blacklist yet
base::RunLoop().RunUntilIdle();
ASSERT_EQ(1u, registry()->blacklisted_extensions().size());
ASSERT_EQ(2u, registry()->enabled_extensions().size());
ASSERT_TRUE(registry()->enabled_extensions().Contains(good0));
ASSERT_TRUE(registry()->blacklisted_extensions().Contains(good1));
ASSERT_TRUE(registry()->enabled_extensions().Contains(good2));
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
#if defined(ENABLE_BLACKLIST_TESTS)
// Tests extensions blacklisted in prefs on startup; one still blacklisted by
// safe browsing, the other not. The not-blacklisted one should recover.
TEST_F(ExtensionServiceTest, BlacklistedInPrefsFromStartup) {
extensions::TestBlacklist test_blacklist;
InitializeGoodInstalledExtensionService();
test_blacklist.Attach(service()->blacklist_);
ExtensionPrefs::Get(profile())->SetExtensionBlacklisted(good0, true);
ExtensionPrefs::Get(profile())->SetExtensionBlacklisted(good1, true);
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_MALWARE, false);
// Extension service hasn't loaded yet, but IsExtensionEnabled reads out of
// prefs. Ensure it takes into account the blacklist state (crbug.com/373842).
EXPECT_FALSE(service()->IsExtensionEnabled(good0));
EXPECT_FALSE(service()->IsExtensionEnabled(good1));
EXPECT_TRUE(service()->IsExtensionEnabled(good2));
service()->Init();
EXPECT_EQ(2u, registry()->blacklisted_extensions().size());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(registry()->blacklisted_extensions().Contains(good0));
EXPECT_TRUE(registry()->blacklisted_extensions().Contains(good1));
EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
// Give time for the blacklist to update.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, registry()->blacklisted_extensions().size());
EXPECT_EQ(2u, registry()->enabled_extensions().size());
EXPECT_TRUE(registry()->enabled_extensions().Contains(good0));
EXPECT_TRUE(registry()->blacklisted_extensions().Contains(good1));
EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
#if defined(ENABLE_BLACKLIST_TESTS)
// Extension is added to blacklist with BLACKLISTED_POTENTIALLY_UNWANTED state
// after it is installed. It is then successfully re-enabled by the user.
TEST_F(ExtensionServiceTest, GreylistedExtensionDisabled) {
extensions::TestBlacklist test_blacklist;
// A profile with 3 extensions installed: good0, good1, and good2.
InitializeGoodInstalledExtensionService();
test_blacklist.Attach(service()->blacklist_);
service()->Init();
const extensions::ExtensionSet& enabled_extensions =
registry()->enabled_extensions();
const extensions::ExtensionSet& disabled_extensions =
registry()->disabled_extensions();
EXPECT_TRUE(enabled_extensions.Contains(good0));
EXPECT_TRUE(enabled_extensions.Contains(good1));
EXPECT_TRUE(enabled_extensions.Contains(good2));
// Blacklist good0 and good1 (and an invalid extension ID).
test_blacklist.SetBlacklistState(
good0, extensions::BLACKLISTED_CWS_POLICY_VIOLATION, true);
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_POTENTIALLY_UNWANTED, true);
test_blacklist.SetBlacklistState(
"invalid_id", extensions::BLACKLISTED_MALWARE, true);
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(enabled_extensions.Contains(good0));
EXPECT_TRUE(disabled_extensions.Contains(good0));
EXPECT_FALSE(enabled_extensions.Contains(good1));
EXPECT_TRUE(disabled_extensions.Contains(good1));
EXPECT_TRUE(enabled_extensions.Contains(good2));
EXPECT_FALSE(disabled_extensions.Contains(good2));
ValidateIntegerPref(
good0, "blacklist_state", extensions::BLACKLISTED_CWS_POLICY_VIOLATION);
ValidateIntegerPref(
good1, "blacklist_state", extensions::BLACKLISTED_POTENTIALLY_UNWANTED);
// Now user enables good0.
service()->EnableExtension(good0);
EXPECT_TRUE(enabled_extensions.Contains(good0));
EXPECT_FALSE(disabled_extensions.Contains(good0));
EXPECT_FALSE(enabled_extensions.Contains(good1));
EXPECT_TRUE(disabled_extensions.Contains(good1));
// Remove extensions from blacklist.
test_blacklist.SetBlacklistState(
good0, extensions::NOT_BLACKLISTED, true);
test_blacklist.SetBlacklistState(
good1, extensions::NOT_BLACKLISTED, true);
base::RunLoop().RunUntilIdle();
// All extensions are enabled.
EXPECT_TRUE(enabled_extensions.Contains(good0));
EXPECT_FALSE(disabled_extensions.Contains(good0));
EXPECT_TRUE(enabled_extensions.Contains(good1));
EXPECT_FALSE(disabled_extensions.Contains(good1));
EXPECT_TRUE(enabled_extensions.Contains(good2));
EXPECT_FALSE(disabled_extensions.Contains(good2));
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
#if defined(ENABLE_BLACKLIST_TESTS)
// When extension is removed from greylist, do not re-enable it if it is
// disabled by user.
TEST_F(ExtensionServiceTest, GreylistDontEnableManuallyDisabled) {
extensions::TestBlacklist test_blacklist;
// A profile with 3 extensions installed: good0, good1, and good2.
InitializeGoodInstalledExtensionService();
test_blacklist.Attach(service()->blacklist_);
service()->Init();
const extensions::ExtensionSet& enabled_extensions =
registry()->enabled_extensions();
const extensions::ExtensionSet& disabled_extensions =
registry()->disabled_extensions();
// Manually disable.
service()->DisableExtension(good0,
extensions::Extension::DISABLE_USER_ACTION);
test_blacklist.SetBlacklistState(
good0, extensions::BLACKLISTED_CWS_POLICY_VIOLATION, true);
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_POTENTIALLY_UNWANTED, true);
test_blacklist.SetBlacklistState(
good2, extensions::BLACKLISTED_SECURITY_VULNERABILITY, true);
base::RunLoop().RunUntilIdle();
// All extensions disabled.
EXPECT_FALSE(enabled_extensions.Contains(good0));
EXPECT_TRUE(disabled_extensions.Contains(good0));
EXPECT_FALSE(enabled_extensions.Contains(good1));
EXPECT_TRUE(disabled_extensions.Contains(good1));
EXPECT_FALSE(enabled_extensions.Contains(good2));
EXPECT_TRUE(disabled_extensions.Contains(good2));
// Greylisted extension can be enabled.
service()->EnableExtension(good1);
EXPECT_TRUE(enabled_extensions.Contains(good1));
EXPECT_FALSE(disabled_extensions.Contains(good1));
// good1 is now manually disabled.
service()->DisableExtension(good1,
extensions::Extension::DISABLE_USER_ACTION);
EXPECT_FALSE(enabled_extensions.Contains(good1));
EXPECT_TRUE(disabled_extensions.Contains(good1));
// Remove extensions from blacklist.
test_blacklist.SetBlacklistState(
good0, extensions::NOT_BLACKLISTED, true);
test_blacklist.SetBlacklistState(
good1, extensions::NOT_BLACKLISTED, true);
test_blacklist.SetBlacklistState(
good2, extensions::NOT_BLACKLISTED, true);
base::RunLoop().RunUntilIdle();
// good0 and good1 remain disabled.
EXPECT_FALSE(enabled_extensions.Contains(good0));
EXPECT_TRUE(disabled_extensions.Contains(good0));
EXPECT_FALSE(enabled_extensions.Contains(good1));
EXPECT_TRUE(disabled_extensions.Contains(good1));
EXPECT_TRUE(enabled_extensions.Contains(good2));
EXPECT_FALSE(disabled_extensions.Contains(good2));
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
#if defined(ENABLE_BLACKLIST_TESTS)
// Blacklisted extension with unknown state are not enabled/disabled.
TEST_F(ExtensionServiceTest, GreylistUnknownDontChange) {
extensions::TestBlacklist test_blacklist;
// A profile with 3 extensions installed: good0, good1, and good2.
InitializeGoodInstalledExtensionService();
test_blacklist.Attach(service()->blacklist_);
service()->Init();
const extensions::ExtensionSet& enabled_extensions =
registry()->enabled_extensions();
const extensions::ExtensionSet& disabled_extensions =
registry()->disabled_extensions();
test_blacklist.SetBlacklistState(
good0, extensions::BLACKLISTED_CWS_POLICY_VIOLATION, true);
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_POTENTIALLY_UNWANTED, true);
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(enabled_extensions.Contains(good0));
EXPECT_TRUE(disabled_extensions.Contains(good0));
EXPECT_FALSE(enabled_extensions.Contains(good1));
EXPECT_TRUE(disabled_extensions.Contains(good1));
EXPECT_TRUE(enabled_extensions.Contains(good2));
EXPECT_FALSE(disabled_extensions.Contains(good2));
test_blacklist.SetBlacklistState(
good0, extensions::NOT_BLACKLISTED, true);
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_UNKNOWN, true);
test_blacklist.SetBlacklistState(
good2, extensions::BLACKLISTED_UNKNOWN, true);
base::RunLoop().RunUntilIdle();
// good0 re-enabled, other remain as they were.
EXPECT_TRUE(enabled_extensions.Contains(good0));
EXPECT_FALSE(disabled_extensions.Contains(good0));
EXPECT_FALSE(enabled_extensions.Contains(good1));
EXPECT_TRUE(disabled_extensions.Contains(good1));
EXPECT_TRUE(enabled_extensions.Contains(good2));
EXPECT_FALSE(disabled_extensions.Contains(good2));
}
// Tests that blacklisted extensions cannot be reloaded, both those loaded
// before and after extension service startup.
TEST_F(ExtensionServiceTest, ReloadBlacklistedExtension) {
extensions::TestBlacklist test_blacklist;
InitializeGoodInstalledExtensionService();
test_blacklist.Attach(service()->blacklist_);
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_MALWARE, false);
service()->Init();
test_blacklist.SetBlacklistState(
good2, extensions::BLACKLISTED_MALWARE, false);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(StringSet(good0), registry()->enabled_extensions().GetIDs());
EXPECT_EQ(StringSet(good1, good2),
registry()->blacklisted_extensions().GetIDs());
service()->ReloadExtension(good1);
service()->ReloadExtension(good2);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(StringSet(good0), registry()->enabled_extensions().GetIDs());
EXPECT_EQ(StringSet(good1, good2),
registry()->blacklisted_extensions().GetIDs());
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
// Tests blocking then unblocking enabled extensions after the service has been
// initialized.
TEST_F(ExtensionServiceTest, BlockAndUnblockEnabledExtension) {
InitializeGoodInstalledExtensionService();
service()->Init();
AssertExtensionBlocksAndUnblocks(true, good0);
}
// Tests blocking then unblocking disabled extensions after the service has been
// initialized.
TEST_F(ExtensionServiceTest, BlockAndUnblockDisabledExtension) {
InitializeGoodInstalledExtensionService();
service()->Init();
service()->DisableExtension(good0, Extension::DISABLE_RELOAD);
AssertExtensionBlocksAndUnblocks(true, good0);
}
// Tests blocking then unblocking terminated extensions after the service has
// been initialized.
TEST_F(ExtensionServiceTest, BlockAndUnblockTerminatedExtension) {
InitializeGoodInstalledExtensionService();
service()->Init();
TerminateExtension(good0);
AssertExtensionBlocksAndUnblocks(true, good0);
}
// Tests blocking then unblocking policy-forced extensions after the service has
// been initialized.
TEST_F(ExtensionServiceTest, BlockAndUnblockPolicyExtension) {
InitializeEmptyExtensionServiceWithTestingPrefs();
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
// // Blacklist everything.
// pref.SetBlacklistedByDefault(true);
// Mark good.crx for force-installation.
pref.SetIndividualExtensionAutoInstalled(
good_crx, "http://example.com/update_url", true);
}
// Have policy force-install an extension.
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(
good_crx, "1.0.0.0", data_dir().AppendASCII("good_crx"));
// Reloading extensions should find our externally registered extension
// and install it.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
AssertExtensionBlocksAndUnblocks(false, good_crx);
}
#if defined(ENABLE_BLACKLIST_TESTS)
// Tests blocking then unblocking extensions that are blacklisted both before
// and after Init().
TEST_F(ExtensionServiceTest, BlockAndUnblockBlacklistedExtension) {
extensions::TestBlacklist test_blacklist;
InitializeGoodInstalledExtensionService();
test_blacklist.Attach(service()->blacklist_);
test_blacklist.SetBlacklistState(
good0, extensions::BLACKLISTED_MALWARE, true);
base::RunLoop().RunUntilIdle();
service()->Init();
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_MALWARE, true);
base::RunLoop().RunUntilIdle();
// Blacklisted extensions stay blacklisted.
AssertExtensionBlocksAndUnblocks(false, good0);
AssertExtensionBlocksAndUnblocks(false, good1);
service()->BlockAllExtensions();
// Remove an extension from the blacklist while the service is blocked.
test_blacklist.SetBlacklistState(
good0, extensions::NOT_BLACKLISTED, true);
// Add an extension to the blacklist while the service is blocked.
test_blacklist.SetBlacklistState(
good2, extensions::BLACKLISTED_MALWARE, true);
base::RunLoop().RunUntilIdle();
// Go directly to blocked, do not pass go, do not collect $200.
ASSERT_TRUE(IsBlocked(good0));
// Get on the blacklist - even if you were blocked!
ASSERT_FALSE(IsBlocked(good2));
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
// Tests blocking then unblocking enabled component extensions after the service
// has been initialized.
TEST_F(ExtensionServiceTest, BlockAndUnblockEnabledComponentExtension) {
InitializeEmptyExtensionServiceWithTestingPrefs();
// Install a component extension.
base::FilePath path = data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII(good0)
.AppendASCII("1.0.0.0");
std::string manifest;
ASSERT_TRUE(base::ReadFileToString(
path.Append(extensions::kManifestFilename), &manifest));
service()->component_loader()->Add(manifest, path);
service()->Init();
// Component extension should never block.
AssertExtensionBlocksAndUnblocks(false, good0);
}
// Tests blocking then unblocking a theme after the service has been
// initialized.
TEST_F(ExtensionServiceTest, BlockAndUnblockTheme) {
InitializeEmptyExtensionService();
service()->Init();
base::FilePath path = data_dir().AppendASCII("theme.crx");
InstallCRX(path, INSTALL_NEW);
AssertExtensionBlocksAndUnblocks(true, theme_crx);
}
// Tests that blocking extensions before Init() results in loading blocked
// extensions.
TEST_F(ExtensionServiceTest, WillNotLoadExtensionsWhenBlocked) {
InitializeGoodInstalledExtensionService();
service()->BlockAllExtensions();
service()->Init();
ASSERT_TRUE(IsBlocked(good0));
ASSERT_TRUE(IsBlocked(good0));
ASSERT_TRUE(IsBlocked(good0));
}
// Tests that IsEnabledExtension won't crash on an uninstalled extension.
TEST_F(ExtensionServiceTest, IsEnabledExtensionBlockedAndNotInstalled) {
InitializeEmptyExtensionService();
service()->BlockAllExtensions();
service()->IsExtensionEnabled(theme_crx);
}
// Will not install extension blacklisted by policy.
TEST_F(ExtensionServiceTest, BlacklistedByPolicyWillNotInstall) {
InitializeEmptyExtensionServiceWithTestingPrefs();
// Blacklist everything.
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.SetBlacklistedByDefault(true);
}
// Blacklist prevents us from installing good_crx.
base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_FAILED);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
// Now whitelist this particular extension.
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.SetIndividualExtensionInstallationAllowed(good_crx, true);
}
// Ensure we can now install good_crx.
InstallCRX(path, INSTALL_NEW);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
}
// Extension blacklisted by policy get unloaded after installing.
TEST_F(ExtensionServiceTest, BlacklistedByPolicyRemovedIfRunning) {
InitializeEmptyExtensionServiceWithTestingPrefs();
// Install good_crx.
base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
// Blacklist this extension.
pref.SetIndividualExtensionInstallationAllowed(good_crx, false);
}
// Extension should not be running now.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
// Tests that component extensions are not blacklisted by policy.
TEST_F(ExtensionServiceTest, ComponentExtensionWhitelisted) {
InitializeEmptyExtensionServiceWithTestingPrefs();
// Blacklist everything.
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.SetBlacklistedByDefault(true);
}
// Install a component extension.
base::FilePath path = data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII(good0)
.AppendASCII("1.0.0.0");
std::string manifest;
ASSERT_TRUE(base::ReadFileToString(
path.Append(extensions::kManifestFilename), &manifest));
service()->component_loader()->Add(manifest, path);
service()->Init();
// Extension should be installed despite blacklist.
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(service()->GetExtensionById(good0, false));
// Poke external providers and make sure the extension is still present.
service()->CheckForExternalUpdates();
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(service()->GetExtensionById(good0, false));
// Extension should not be uninstalled on blacklist changes.
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.SetIndividualExtensionInstallationAllowed(good0, false);
}
base::RunLoop().RunUntilIdle();
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(service()->GetExtensionById(good0, false));
}
// Tests that policy-installed extensions are not blacklisted by policy.
TEST_F(ExtensionServiceTest, PolicyInstalledExtensionsWhitelisted) {
InitializeEmptyExtensionServiceWithTestingPrefs();
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
// Blacklist everything.
pref.SetBlacklistedByDefault(true);
// Mark good.crx for force-installation.
pref.SetIndividualExtensionAutoInstalled(
good_crx, "http://example.com/update_url", true);
}
// Have policy force-install an extension.
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(
good_crx, "1.0.0.0", data_dir().AppendASCII("good.crx"));
// Reloading extensions should find our externally registered extension
// and install it.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
// Extension should be installed despite blacklist.
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
// Blacklist update should not uninstall the extension.
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.SetIndividualExtensionInstallationAllowed(good0, false);
}
base::RunLoop().RunUntilIdle();
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
}
// Tests that extensions cannot be installed if the policy provider prohibits
// it. This functionality is implemented in CrxInstaller::ConfirmInstall().
TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsInstall) {
InitializeEmptyExtensionService();
GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider_(
extensions::TestManagementPolicyProvider::PROHIBIT_LOAD);
GetManagementPolicy()->RegisterProvider(&provider_);
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_FAILED);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
// Tests that extensions cannot be loaded from prefs if the policy provider
// prohibits it. This functionality is implemented in InstalledLoader::Load().
TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsLoadFromPrefs) {
InitializeEmptyExtensionService();
// Create a fake extension to be loaded as though it were read from prefs.
base::FilePath path =
data_dir().AppendASCII("management").AppendASCII("simple_extension");
base::DictionaryValue manifest;
manifest.SetString(keys::kName, "simple_extension");
manifest.SetString(keys::kVersion, "1");
// UNPACKED is for extensions loaded from a directory. We use it here, even
// though we're testing loading from prefs, so that we don't need to provide
// an extension key.
extensions::ExtensionInfo extension_info(
&manifest, std::string(), path, Manifest::UNPACKED);
// Ensure we can load it with no management policy in place.
GetManagementPolicy()->UnregisterAllProviders();
EXPECT_EQ(0u, registry()->enabled_extensions().size());
extensions::InstalledLoader(service()).Load(extension_info, false);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
const Extension* extension =
(registry()->enabled_extensions().begin())->get();
EXPECT_TRUE(
service()->UninstallExtension(extension->id(),
extensions::UNINSTALL_REASON_FOR_TESTING,
base::Bind(&base::DoNothing),
NULL));
EXPECT_EQ(0u, registry()->enabled_extensions().size());
// Ensure we cannot load it if management policy prohibits installation.
extensions::TestManagementPolicyProvider provider_(
extensions::TestManagementPolicyProvider::PROHIBIT_LOAD);
GetManagementPolicy()->RegisterProvider(&provider_);
extensions::InstalledLoader(service()).Load(extension_info, false);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
// Tests disabling an extension when prohibited by the ManagementPolicy.
TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsDisable) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider(
extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
GetManagementPolicy()->RegisterProvider(&provider);
// Attempt to disable it.
service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
// Tests uninstalling an extension when prohibited by the ManagementPolicy.
TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsUninstall) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider(
extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
GetManagementPolicy()->RegisterProvider(&provider);
// Attempt to uninstall it.
EXPECT_FALSE(
service()->UninstallExtension(good_crx,
extensions::UNINSTALL_REASON_FOR_TESTING,
base::Bind(&base::DoNothing),
NULL));
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
}
// Tests that previously installed extensions that are now prohibited from
// being installed are removed.
TEST_F(ExtensionServiceTest, ManagementPolicyUnloadsAllProhibited) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
InstallCRX(data_dir().AppendASCII("page_action.crx"), INSTALL_NEW);
EXPECT_EQ(2u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider(
extensions::TestManagementPolicyProvider::PROHIBIT_LOAD);
GetManagementPolicy()->RegisterProvider(&provider);
// Run the policy check.
service()->CheckManagementPolicy();
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
// Tests that previously disabled extensions that are now required to be
// enabled are re-enabled on reinstall.
TEST_F(ExtensionServiceTest, ManagementPolicyRequiresEnable) {
InitializeEmptyExtensionService();
// Install, then disable, an extension.
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
EXPECT_EQ(1u, registry()->disabled_extensions().size());
// Register an ExtensionManagementPolicy that requires the extension to remain
// enabled.
GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider(
extensions::TestManagementPolicyProvider::MUST_REMAIN_ENABLED);
GetManagementPolicy()->RegisterProvider(&provider);
// Reinstall the extension.
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_UPDATED);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
// Tests that extensions disabled by management policy can be installed but
// will get disabled after installing.
TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsEnableOnInstalled) {
InitializeEmptyExtensionService();
// Register an ExtensionManagementPolicy that disables all extensions, with
// a specified Extension::DisableReason.
GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider(
extensions::TestManagementPolicyProvider::MUST_REMAIN_DISABLED);
provider.SetDisableReason(Extension::DISABLE_NOT_VERIFIED);
GetManagementPolicy()->RegisterProvider(&provider);
// Attempts to install an extensions, it should be installed but disabled.
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_WITHOUT_LOAD);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(1u, registry()->disabled_extensions().size());
// Verifies that the disable reason is set properly.
EXPECT_EQ(Extension::DISABLE_NOT_VERIFIED,
service()->extension_prefs_->GetDisableReasons(kGoodId));
}
// Tests that extensions with conflicting required permissions by enterprise
// policy cannot be installed.
TEST_F(ExtensionServiceTest, PolicyBlockedPermissionNewExtensionInstall) {
InitializeEmptyExtensionServiceWithTestingPrefs();
base::FilePath path = data_dir().AppendASCII("permissions_blocklist");
{
// Update policy to block one of the required permissions of target.
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.AddBlockedPermission("*", "tabs");
}
// The extension should be failed to install.
PackAndInstallCRX(path, INSTALL_FAILED);
{
// Update policy to block one of the optional permissions instead.
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.ClearBlockedPermissions("*");
pref.AddBlockedPermission("*", "history");
}
// The extension should succeed to install this time.
std::string id = PackAndInstallCRX(path, INSTALL_NEW)->id();
// Uninstall the extension and update policy to block some arbitrary
// unknown permission.
UninstallExtension(id, false);
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.ClearBlockedPermissions("*");
pref.AddBlockedPermission("*", "unknown.permission.for.testing");
}
// The extension should succeed to install as well.
PackAndInstallCRX(path, INSTALL_NEW);
}
// Tests that extension supposed to be force installed but with conflicting
// required permissions cannot be installed.
TEST_F(ExtensionServiceTest, PolicyBlockedPermissionConflictsWithForceInstall) {
InitializeEmptyExtensionServiceWithTestingPrefs();
// Pack the crx file.
base::FilePath path = data_dir().AppendASCII("permissions_blocklist");
base::FilePath pem_path = data_dir().AppendASCII("permissions_blocklist.pem");
base::ScopedTempDir temp_dir;
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
base::FilePath crx_path = temp_dir.path().AppendASCII("temp.crx");
PackCRX(path, pem_path, crx_path);
{
// Block one of the required permissions.
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.AddBlockedPermission("*", "tabs");
}
// Use MockExtensionProvider to simulate force installing extension.
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(permissions_blocklist, "1.0", crx_path);
{
// Attempts to force install this extension.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
}
// The extension should not be installed.
ASSERT_FALSE(service()->GetInstalledExtension(permissions_blocklist));
// Remove this extension from pending extension manager as we would like to
// give another attempt later.
service()->pending_extension_manager()->Remove(permissions_blocklist);
{
// Clears the permission block list.
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.ClearBlockedPermissions("*");
}
{
// Attempts to force install this extension again.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
}
const Extension* installed =
service()->GetInstalledExtension(permissions_blocklist);
ASSERT_TRUE(installed);
EXPECT_EQ(installed->location(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
}
// Tests that newer versions of an extension with conflicting required
// permissions by enterprise policy cannot be updated to.
TEST_F(ExtensionServiceTest, PolicyBlockedPermissionExtensionUpdate) {
InitializeEmptyExtensionServiceWithTestingPrefs();
base::FilePath path = data_dir().AppendASCII("permissions_blocklist");
base::FilePath path2 = data_dir().AppendASCII("permissions_blocklist2");
base::FilePath pem_path = data_dir().AppendASCII("permissions_blocklist.pem");
// Install 'permissions_blocklist'.
const Extension* installed = PackAndInstallCRX(path, pem_path, INSTALL_NEW);
EXPECT_EQ(installed->id(), permissions_blocklist);
{
// Block one of the required permissions of 'permissions_blocklist2'.
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.AddBlockedPermission("*", "downloads");
}
// Install 'permissions_blocklist' again, should be updated.
const Extension* updated = PackAndInstallCRX(path, pem_path, INSTALL_UPDATED);
EXPECT_EQ(updated->id(), permissions_blocklist);
std::string old_version = updated->VersionString();
// Attempts to update to 'permissions_blocklist2' should fail.
PackAndInstallCRX(path2, pem_path, INSTALL_FAILED);
// Verify that the old version is still enabled.
updated = service()->GetExtensionById(permissions_blocklist, false);
ASSERT_TRUE(updated);
EXPECT_EQ(old_version, updated->VersionString());
}
// Tests that policy update with additional permissions blocked revoke
// conflicting granted optional permissions and unload extensions with
// conflicting required permissions, including the force installed ones.
TEST_F(ExtensionServiceTest, PolicyBlockedPermissionPolicyUpdate) {
InitializeEmptyExtensionServiceWithTestingPrefs();
base::FilePath path = data_dir().AppendASCII("permissions_blocklist");
base::FilePath path2 = data_dir().AppendASCII("permissions_blocklist2");
base::FilePath pem_path = data_dir().AppendASCII("permissions_blocklist.pem");
// Pack the crx file.
base::ScopedTempDir temp_dir;
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
base::FilePath crx_path = temp_dir.path().AppendASCII("temp.crx");
PackCRX(path2, pem_path, crx_path);
// Install two arbitary extensions with specified manifest.
std::string ext1 = PackAndInstallCRX(path, INSTALL_NEW)->id();
std::string ext2 = PackAndInstallCRX(path2, INSTALL_NEW)->id();
ASSERT_NE(ext1, permissions_blocklist);
ASSERT_NE(ext2, permissions_blocklist);
ASSERT_NE(ext1, ext2);
// Force install another extension with known id and same manifest as 'ext2'.
std::string ext2_forced = permissions_blocklist;
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(ext2_forced, "2.0", crx_path);
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
extensions::ExtensionRegistry* registry =
extensions::ExtensionRegistry::Get(profile());
// Verify all three extensions are installed and enabled.
ASSERT_TRUE(registry->enabled_extensions().GetByID(ext1));
ASSERT_TRUE(registry->enabled_extensions().GetByID(ext2));
ASSERT_TRUE(registry->enabled_extensions().GetByID(ext2_forced));
// Grant all optional permissions to each extension.
GrantAllOptionalPermissions(ext1);
GrantAllOptionalPermissions(ext2);
GrantAllOptionalPermissions(ext2_forced);
scoped_ptr<const PermissionSet> active_permissions =
ExtensionPrefs::Get(profile())->GetActivePermissions(ext1);
EXPECT_TRUE(active_permissions->HasAPIPermission(
extensions::APIPermission::kDownloads));
// Set policy to block 'downloads' permission.
{
ManagementPrefUpdater pref(profile_->GetTestingPrefService());
pref.AddBlockedPermission("*", "downloads");
}
base::RunLoop().RunUntilIdle();
// 'ext1' should still be enabled, but with 'downloads' permission revoked.
EXPECT_TRUE(registry->enabled_extensions().GetByID(ext1));
active_permissions =
ExtensionPrefs::Get(profile())->GetActivePermissions(ext1);
EXPECT_FALSE(active_permissions->HasAPIPermission(
extensions::APIPermission::kDownloads));
// 'ext2' should be disabled because one of its required permissions is
// blocked.
EXPECT_FALSE(registry->enabled_extensions().GetByID(ext2));
// 'ext2_forced' should be handled the same as 'ext2'
EXPECT_FALSE(registry->enabled_extensions().GetByID(ext2_forced));
}
// Flaky on windows; http://crbug.com/309833
#if defined(OS_WIN)
#define MAYBE_ExternalExtensionAutoAcknowledgement DISABLED_ExternalExtensionAutoAcknowledgement
#else
#define MAYBE_ExternalExtensionAutoAcknowledgement ExternalExtensionAutoAcknowledgement
#endif
TEST_F(ExtensionServiceTest, MAYBE_ExternalExtensionAutoAcknowledgement) {
InitializeEmptyExtensionService();
service()->set_extensions_enabled(true);
{
// Register and install an external extension.
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(
good_crx, "1.0.0.0", data_dir().AppendASCII("good.crx"));
}
{
// Have policy force-install an extension.
MockExtensionProvider* provider = new MockExtensionProvider(
service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(
page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
}
// Providers are set up. Let them run.
int count = 2;
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
base::Bind(&WaitForCountNotificationsCallback, &count));
service()->CheckForExternalUpdates();
observer.Wait();
ASSERT_EQ(2u, registry()->enabled_extensions().size());
EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
EXPECT_TRUE(service()->GetExtensionById(page_action, false));
ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
ASSERT_TRUE(!prefs->IsExternalExtensionAcknowledged(good_crx));
ASSERT_TRUE(prefs->IsExternalExtensionAcknowledged(page_action));
}
#if !defined(OS_CHROMEOS)
// This tests if default apps are installed correctly.
TEST_F(ExtensionServiceTest, DefaultAppsInstall) {
InitializeEmptyExtensionService();
service()->set_extensions_enabled(true);
{
std::string json_data =
"{"
" \"ldnnhddmnhbkjipkidpdiheffobcpfmf\" : {"
" \"external_crx\": \"good.crx\","
" \"external_version\": \"1.0.0.0\","
" \"is_bookmark_app\": false"
" }"
"}";
default_apps::Provider* provider = new default_apps::Provider(
profile(),
service(),
new extensions::ExternalTestingLoader(json_data, data_dir()),
Manifest::INTERNAL,
Manifest::INVALID_LOCATION,
Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT);
AddMockExternalProvider(provider);
}
ASSERT_EQ(0u, registry()->enabled_extensions().size());
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
const Extension* extension = service()->GetExtensionById(good_crx, false);
EXPECT_TRUE(extension->from_webstore());
EXPECT_TRUE(extension->was_installed_by_default());
}
#endif
// Tests disabling extensions
TEST_F(ExtensionServiceTest, DisableExtension) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
EXPECT_EQ(0u, registry()->terminated_extensions().size());
EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
// Disable it.
service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
EXPECT_FALSE(service()->GetExtensionById(good_crx, false));
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(1u, registry()->disabled_extensions().size());
EXPECT_EQ(0u, registry()->terminated_extensions().size());
EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
}
TEST_F(ExtensionServiceTest, TerminateExtension) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
EXPECT_EQ(0u, registry()->terminated_extensions().size());
EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
TerminateExtension(good_crx);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
EXPECT_EQ(1u, registry()->terminated_extensions().size());
EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
}
TEST_F(ExtensionServiceTest, DisableTerminatedExtension) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
TerminateExtension(good_crx);
EXPECT_TRUE(registry()->GetExtensionById(
good_crx, extensions::ExtensionRegistry::TERMINATED));
// Disable it.
service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
EXPECT_FALSE(registry()->GetExtensionById(
good_crx, extensions::ExtensionRegistry::TERMINATED));
EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(1u, registry()->disabled_extensions().size());
EXPECT_EQ(0u, registry()->terminated_extensions().size());
EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
}
// Tests disabling all extensions (simulating --disable-extensions flag).
TEST_F(ExtensionServiceTest, DisableAllExtensions) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
// Disable extensions.
service()->set_extensions_enabled(false);
service()->ReloadExtensionsForTest();
// There shouldn't be extensions in either list.
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
// This shouldn't do anything when all extensions are disabled.
service()->EnableExtension(good_crx);
service()->ReloadExtensionsForTest();
// There still shouldn't be extensions in either list.
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
// And then re-enable the extensions.
service()->set_extensions_enabled(true);
service()->ReloadExtensionsForTest();
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
// Tests reloading extensions.
TEST_F(ExtensionServiceTest, ReloadExtensions) {
InitializeEmptyExtensionService();
// Simple extension that should install without error.
base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW,
Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT);
const char* const extension_id = good_crx;
service()->DisableExtension(extension_id, Extension::DISABLE_USER_ACTION);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(1u, registry()->disabled_extensions().size());
service()->ReloadExtensionsForTest();
// The creation flags should not change when reloading the extension.
const Extension* extension = service()->GetExtensionById(good_crx, true);
EXPECT_TRUE(extension->from_webstore());
EXPECT_TRUE(extension->was_installed_by_default());
EXPECT_FALSE(extension->from_bookmark());
// Extension counts shouldn't change.
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(1u, registry()->disabled_extensions().size());
service()->EnableExtension(extension_id);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
// Need to clear |loaded_| manually before reloading as the
// EnableExtension() call above inserted into it and
// UnloadAllExtensions() doesn't send out notifications.
loaded_.clear();
service()->ReloadExtensionsForTest();
// Extension counts shouldn't change.
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
// Tests reloading an extension.
TEST_F(ExtensionServiceTest, ReloadExtension) {
InitializeEmptyExtensionService();
// Simple extension that should install without error.
const char extension_id[] = "behllobkkfkfnphdnhnkndlbkcpglgmj";
base::FilePath ext = data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII(extension_id)
.AppendASCII("1.0.0.0");
extensions::UnpackedInstaller::Create(service())->Load(ext);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
service()->ReloadExtension(extension_id);
// Extension should be disabled now, waiting to be reloaded.
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(1u, registry()->disabled_extensions().size());
EXPECT_EQ(Extension::DISABLE_RELOAD,
ExtensionPrefs::Get(profile())->GetDisableReasons(extension_id));
// Reloading again should not crash.
service()->ReloadExtension(extension_id);
// Finish reloading
base::RunLoop().RunUntilIdle();
// Extension should be enabled again.
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
TEST_F(ExtensionServiceTest, UninstallExtension) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
UninstallExtension(good_crx, false);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(UnloadedExtensionInfo::REASON_UNINSTALL, unloaded_reason_);
}
TEST_F(ExtensionServiceTest, UninstallTerminatedExtension) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
TerminateExtension(good_crx);
UninstallExtension(good_crx, false);
EXPECT_EQ(UnloadedExtensionInfo::REASON_TERMINATE, unloaded_reason_);
}
// Tests the uninstaller helper.
TEST_F(ExtensionServiceTest, UninstallExtensionHelper) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
UninstallExtension(good_crx, true);
EXPECT_EQ(UnloadedExtensionInfo::REASON_UNINSTALL, unloaded_reason_);
}
TEST_F(ExtensionServiceTest, UninstallExtensionHelperTerminated) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
TerminateExtension(good_crx);
UninstallExtension(good_crx, true);
EXPECT_EQ(UnloadedExtensionInfo::REASON_TERMINATE, unloaded_reason_);
}
// An extension disabled because of unsupported requirements should re-enabled
// if updated to a version with supported requirements as long as there are no
// other disable reasons.
TEST_F(ExtensionServiceTest, UpgradingRequirementsEnabled) {
InitializeEmptyExtensionService();
BlackListWebGL();
base::FilePath path = data_dir().AppendASCII("requirements");
base::FilePath pem_path =
data_dir().AppendASCII("requirements").AppendASCII("v1_good.pem");
const Extension* extension_v1 = PackAndInstallCRX(path.AppendASCII("v1_good"),
pem_path,
INSTALL_NEW);
std::string id = extension_v1->id();
EXPECT_TRUE(service()->IsExtensionEnabled(id));
base::FilePath v2_bad_requirements_crx = GetTemporaryFile();
PackCRX(path.AppendASCII("v2_bad_requirements"),
pem_path,
v2_bad_requirements_crx);
UpdateExtension(id, v2_bad_requirements_crx, INSTALLED);
EXPECT_FALSE(service()->IsExtensionEnabled(id));
base::FilePath v3_good_crx = GetTemporaryFile();
PackCRX(path.AppendASCII("v3_good"), pem_path, v3_good_crx);
UpdateExtension(id, v3_good_crx, ENABLED);
EXPECT_TRUE(service()->IsExtensionEnabled(id));
}
// Extensions disabled through user action should stay disabled.
TEST_F(ExtensionServiceTest, UpgradingRequirementsDisabled) {
InitializeEmptyExtensionService();
BlackListWebGL();
base::FilePath path = data_dir().AppendASCII("requirements");
base::FilePath pem_path =
data_dir().AppendASCII("requirements").AppendASCII("v1_good.pem");
const Extension* extension_v1 = PackAndInstallCRX(path.AppendASCII("v1_good"),
pem_path,
INSTALL_NEW);
std::string id = extension_v1->id();
service()->DisableExtension(id, Extension::DISABLE_USER_ACTION);
EXPECT_FALSE(service()->IsExtensionEnabled(id));
base::FilePath v2_bad_requirements_crx = GetTemporaryFile();
PackCRX(path.AppendASCII("v2_bad_requirements"),
pem_path,
v2_bad_requirements_crx);
UpdateExtension(id, v2_bad_requirements_crx, INSTALLED);
EXPECT_FALSE(service()->IsExtensionEnabled(id));
base::FilePath v3_good_crx = GetTemporaryFile();
PackCRX(path.AppendASCII("v3_good"), pem_path, v3_good_crx);
UpdateExtension(id, v3_good_crx, INSTALLED);
EXPECT_FALSE(service()->IsExtensionEnabled(id));
}
// The extension should not re-enabled because it was disabled from a
// permission increase.
TEST_F(ExtensionServiceTest, UpgradingRequirementsPermissions) {
InitializeEmptyExtensionService();
BlackListWebGL();
base::FilePath path = data_dir().AppendASCII("requirements");
base::FilePath pem_path =
data_dir().AppendASCII("requirements").AppendASCII("v1_good.pem");
const Extension* extension_v1 = PackAndInstallCRX(path.AppendASCII("v1_good"),
pem_path,
INSTALL_NEW);
std::string id = extension_v1->id();
EXPECT_TRUE(service()->IsExtensionEnabled(id));
base::FilePath v2_bad_requirements_and_permissions_crx = GetTemporaryFile();
PackCRX(path.AppendASCII("v2_bad_requirements_and_permissions"),
pem_path,
v2_bad_requirements_and_permissions_crx);
UpdateExtension(id, v2_bad_requirements_and_permissions_crx, INSTALLED);
EXPECT_FALSE(service()->IsExtensionEnabled(id));
base::FilePath v3_bad_permissions_crx = GetTemporaryFile();
PackCRX(path.AppendASCII("v3_bad_permissions"),
pem_path,
v3_bad_permissions_crx);
UpdateExtension(id, v3_bad_permissions_crx, INSTALLED);
EXPECT_FALSE(service()->IsExtensionEnabled(id));
}
// Unpacked extensions are not allowed to be installed if they have unsupported
// requirements.
TEST_F(ExtensionServiceTest, UnpackedRequirements) {
InitializeEmptyExtensionService();
BlackListWebGL();
base::FilePath path =
data_dir().AppendASCII("requirements").AppendASCII("v2_bad_requirements");
extensions::UnpackedInstaller::Create(service())->Load(path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, GetErrors().size());
EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
class ExtensionCookieCallback {
public:
ExtensionCookieCallback()
: result_(false),
weak_factory_(base::MessageLoop::current()) {}
void SetCookieCallback(bool result) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&base::MessageLoop::QuitWhenIdle,
weak_factory_.GetWeakPtr()));
result_ = result;
}
void GetAllCookiesCallback(const net::CookieList& list) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&base::MessageLoop::QuitWhenIdle,
weak_factory_.GetWeakPtr()));
list_ = list;
}
net::CookieList list_;
bool result_;
base::WeakPtrFactory<base::MessageLoop> weak_factory_;
};
// Verifies extension state is removed upon uninstall.
TEST_F(ExtensionServiceTest, ClearExtensionData) {
InitializeEmptyExtensionService();
ExtensionCookieCallback callback;
// Load a test extension.
base::FilePath path = data_dir();
path = path.AppendASCII("good.crx");
const Extension* extension = InstallCRX(path, INSTALL_NEW);
ASSERT_TRUE(extension);
GURL ext_url(extension->url());
std::string origin_id = storage::GetIdentifierFromOrigin(ext_url);
// Set a cookie for the extension.
net::CookieMonster* cookie_monster = profile()
->GetRequestContextForExtensions()
->GetURLRequestContext()
->cookie_store()
->GetCookieMonster();
ASSERT_TRUE(cookie_monster);
net::CookieOptions options;
cookie_monster->SetCookieWithOptionsAsync(
ext_url, "dummy=value", options,
base::Bind(&ExtensionCookieCallback::SetCookieCallback,
base::Unretained(&callback)));
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(callback.result_);
cookie_monster->GetAllCookiesForURLAsync(
ext_url,
base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
base::Unretained(&callback)));
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1U, callback.list_.size());
// Open a database.
storage::DatabaseTracker* db_tracker =
BrowserContext::GetDefaultStoragePartition(profile())
->GetDatabaseTracker();
base::string16 db_name = base::UTF8ToUTF16("db");
base::string16 description = base::UTF8ToUTF16("db_description");
int64_t size;
db_tracker->DatabaseOpened(origin_id, db_name, description, 1, &size);
db_tracker->DatabaseClosed(origin_id, db_name);
std::vector<storage::OriginInfo> origins;
db_tracker->GetAllOriginsInfo(&origins);
EXPECT_EQ(1U, origins.size());
EXPECT_EQ(origin_id, origins[0].GetOriginIdentifier());
// Create local storage. We only simulate this by creating the backing files.
// Note: This test depends on details of how the dom_storage library
// stores data in the host file system.
base::FilePath lso_dir_path =
profile()->GetPath().AppendASCII("Local Storage");
base::FilePath lso_file_path = lso_dir_path.AppendASCII(origin_id)
.AddExtension(FILE_PATH_LITERAL(".localstorage"));
EXPECT_TRUE(base::CreateDirectory(lso_dir_path));
EXPECT_EQ(0, base::WriteFile(lso_file_path, NULL, 0));
EXPECT_TRUE(base::PathExists(lso_file_path));
// Create indexed db. Similarly, it is enough to only simulate this by
// creating the directory on the disk.
IndexedDBContext* idb_context = BrowserContext::GetDefaultStoragePartition(
profile())->GetIndexedDBContext();
idb_context->SetTaskRunnerForTesting(
base::MessageLoop::current()->task_runner().get());
base::FilePath idb_path = idb_context->GetFilePathForTesting(origin_id);
EXPECT_TRUE(base::CreateDirectory(idb_path));
EXPECT_TRUE(base::DirectoryExists(idb_path));
// Uninstall the extension.
base::RunLoop run_loop;
ASSERT_TRUE(
service()->UninstallExtension(good_crx,
extensions::UNINSTALL_REASON_FOR_TESTING,
run_loop.QuitClosure(),
NULL));
// The data deletion happens on the IO thread.
run_loop.Run();
// Check that the cookie is gone.
cookie_monster->GetAllCookiesForURLAsync(
ext_url,
base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
base::Unretained(&callback)));
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0U, callback.list_.size());
// The database should have vanished as well.
origins.clear();
db_tracker->GetAllOriginsInfo(&origins);
EXPECT_EQ(0U, origins.size());
// Check that the LSO file has been removed.
EXPECT_FALSE(base::PathExists(lso_file_path));
// Check if the indexed db has disappeared too.
EXPECT_FALSE(base::DirectoryExists(idb_path));
}
// Verifies app state is removed upon uninstall.
TEST_F(ExtensionServiceTest, ClearAppData) {
InitializeEmptyExtensionService();
ExtensionCookieCallback callback;
int pref_count = 0;
// Install app1 with unlimited storage.
const Extension* extension =
PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ASSERT_EQ(1u, registry()->enabled_extensions().size());
const std::string id1 = extension->id();
EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
APIPermission::kUnlimitedStorage));
const GURL origin1(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
origin1));
std::string origin_id = storage::GetIdentifierFromOrigin(origin1);
// Install app2 from the same origin with unlimited storage.
extension = PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ASSERT_EQ(2u, registry()->enabled_extensions().size());
const std::string id2 = extension->id();
EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
APIPermission::kUnlimitedStorage));
EXPECT_TRUE(extension->web_extent().MatchesURL(
extensions::AppLaunchInfo::GetFullLaunchURL(extension)));
const GURL origin2(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
EXPECT_EQ(origin1, origin2);
EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
origin2));
// Set a cookie for the extension.
net::CookieMonster* cookie_monster = profile()
->GetRequestContext()
->GetURLRequestContext()
->cookie_store()
->GetCookieMonster();
ASSERT_TRUE(cookie_monster);
net::CookieOptions options;
cookie_monster->SetCookieWithOptionsAsync(
origin1, "dummy=value", options,
base::Bind(&ExtensionCookieCallback::SetCookieCallback,
base::Unretained(&callback)));
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(callback.result_);
cookie_monster->GetAllCookiesForURLAsync(
origin1,
base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
base::Unretained(&callback)));
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1U, callback.list_.size());
// Open a database.
storage::DatabaseTracker* db_tracker =
BrowserContext::GetDefaultStoragePartition(profile())
->GetDatabaseTracker();
base::string16 db_name = base::UTF8ToUTF16("db");
base::string16 description = base::UTF8ToUTF16("db_description");
int64_t size;
db_tracker->DatabaseOpened(origin_id, db_name, description, 1, &size);
db_tracker->DatabaseClosed(origin_id, db_name);
std::vector<storage::OriginInfo> origins;
db_tracker->GetAllOriginsInfo(&origins);
EXPECT_EQ(1U, origins.size());
EXPECT_EQ(origin_id, origins[0].GetOriginIdentifier());
// Create local storage. We only simulate this by creating the backing files.
// Note: This test depends on details of how the dom_storage library
// stores data in the host file system.
base::FilePath lso_dir_path =
profile()->GetPath().AppendASCII("Local Storage");
base::FilePath lso_file_path = lso_dir_path.AppendASCII(origin_id)
.AddExtension(FILE_PATH_LITERAL(".localstorage"));
EXPECT_TRUE(base::CreateDirectory(lso_dir_path));
EXPECT_EQ(0, base::WriteFile(lso_file_path, NULL, 0));
EXPECT_TRUE(base::PathExists(lso_file_path));
// Create indexed db. Similarly, it is enough to only simulate this by
// creating the directory on the disk.
IndexedDBContext* idb_context = BrowserContext::GetDefaultStoragePartition(
profile())->GetIndexedDBContext();
idb_context->SetTaskRunnerForTesting(
base::MessageLoop::current()->task_runner().get());
base::FilePath idb_path = idb_context->GetFilePathForTesting(origin_id);
EXPECT_TRUE(base::CreateDirectory(idb_path));
EXPECT_TRUE(base::DirectoryExists(idb_path));
// Uninstall one of them, unlimited storage should still be granted
// to the origin.
UninstallExtension(id1, false);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
origin1));
// Check that the cookie is still there.
cookie_monster->GetAllCookiesForURLAsync(
origin1,
base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
base::Unretained(&callback)));
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1U, callback.list_.size());
// Now uninstall the other. Storage should be cleared for the apps.
UninstallExtension(id2, false);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_FALSE(
profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
origin1));
// Check that the cookie is gone.
cookie_monster->GetAllCookiesForURLAsync(
origin1,
base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
base::Unretained(&callback)));
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0U, callback.list_.size());
// The database should have vanished as well.
origins.clear();
db_tracker->GetAllOriginsInfo(&origins);
EXPECT_EQ(0U, origins.size());
// Check that the LSO file has been removed.
EXPECT_FALSE(base::PathExists(lso_file_path));
// Check if the indexed db has disappeared too.
EXPECT_FALSE(base::DirectoryExists(idb_path));
}
// Tests loading single extensions (like --load-extension)
// Flaky crashes. http://crbug.com/231806
TEST_F(ExtensionServiceTest, DISABLED_LoadExtension) {
InitializeEmptyExtensionService();
base::FilePath ext1 = data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
.AppendASCII("1.0.0.0");
extensions::UnpackedInstaller::Create(service())->Load(ext1);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(Manifest::UNPACKED, loaded_[0]->location());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
ValidatePrefKeyCount(1);
base::FilePath no_manifest =
data_dir()
.AppendASCII("bad")
// .AppendASCII("Extensions")
.AppendASCII("cccccccccccccccccccccccccccccccc")
.AppendASCII("1");
extensions::UnpackedInstaller::Create(service())->Load(no_manifest);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
// Test uninstall.
std::string id = loaded_[0]->id();
EXPECT_FALSE(unloaded_id_.length());
service()->UninstallExtension(id,
extensions::UNINSTALL_REASON_FOR_TESTING,
base::Bind(&base::DoNothing),
NULL);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(id, unloaded_id_);
ASSERT_EQ(0u, loaded_.size());
EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
// Tests that we generate IDs when they are not specified in the manifest for
// --load-extension.
TEST_F(ExtensionServiceTest, GenerateID) {
InitializeEmptyExtensionService();
base::FilePath no_id_ext = data_dir().AppendASCII("no_id");
extensions::UnpackedInstaller::Create(service())->Load(no_id_ext);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
ASSERT_TRUE(crx_file::id_util::IdIsValid(loaded_[0]->id()));
EXPECT_EQ(loaded_[0]->location(), Manifest::UNPACKED);
ValidatePrefKeyCount(1);
std::string previous_id = loaded_[0]->id();
// If we reload the same path, we should get the same extension ID.
extensions::UnpackedInstaller::Create(service())->Load(no_id_ext);
base::RunLoop().RunUntilIdle();
ASSERT_EQ(1u, loaded_.size());
ASSERT_EQ(previous_id, loaded_[0]->id());
}
TEST_F(ExtensionServiceTest, UnpackedValidatesLocales) {
InitializeEmptyExtensionService();
base::FilePath bad_locale =
data_dir().AppendASCII("unpacked").AppendASCII("bad_messages_file");
extensions::UnpackedInstaller::Create(service())->Load(bad_locale);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, GetErrors().size());
base::FilePath ms_messages_file = bad_locale.AppendASCII("_locales")
.AppendASCII("ms")
.AppendASCII("messages.json");
EXPECT_THAT(base::UTF16ToUTF8(GetErrors()[0]), testing::AllOf(
testing::HasSubstr(
base::UTF16ToUTF8(ms_messages_file.LossyDisplayName())),
testing::HasSubstr("Dictionary keys must be quoted.")));
ASSERT_EQ(0u, loaded_.size());
}
void ExtensionServiceTest::TestExternalProvider(
MockExtensionProvider* provider, Manifest::Location location) {
// Verify that starting with no providers loads no extensions.
service()->Init();
ASSERT_EQ(0u, loaded_.size());
provider->set_visit_count(0);
// Register a test extension externally using the mock registry provider.
base::FilePath source_path = data_dir().AppendASCII("good.crx");
// Add the extension.
provider->UpdateOrAddExtension(good_crx, "1.0.0.0", source_path);
// Reloading extensions should find our externally registered extension
// and install it.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
ASSERT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
ASSERT_EQ(location, loaded_[0]->location());
ASSERT_EQ("1.0.0.0", loaded_[0]->version()->GetString());
ValidatePrefKeyCount(1);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", location);
// Reload extensions without changing anything. The extension should be
// loaded again.
loaded_.clear();
service()->ReloadExtensionsForTest();
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
ValidatePrefKeyCount(1);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", location);
// Now update the extension with a new version. We should get upgraded.
source_path = source_path.DirName().AppendASCII("good2.crx");
provider->UpdateOrAddExtension(good_crx, "1.0.0.1", source_path);
loaded_.clear();
content::WindowedNotificationObserver observer_2(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer_2.Wait();
ASSERT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
ValidatePrefKeyCount(1);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", location);
// Uninstall the extension and reload. Nothing should happen because the
// preference should prevent us from reinstalling.
std::string id = loaded_[0]->id();
bool no_uninstall =
GetManagementPolicy()->MustRemainEnabled(loaded_[0].get(), NULL);
service()->UninstallExtension(id,
extensions::UNINSTALL_REASON_FOR_TESTING,
base::Bind(&base::DoNothing),
NULL);
base::RunLoop().RunUntilIdle();
base::FilePath install_path = extensions_install_dir().AppendASCII(id);
if (no_uninstall) {
// Policy controlled extensions should not have been touched by uninstall.
ASSERT_TRUE(base::PathExists(install_path));
} else {
// The extension should also be gone from the install directory.
ASSERT_FALSE(base::PathExists(install_path));
loaded_.clear();
service()->CheckForExternalUpdates();
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, loaded_.size());
ValidatePrefKeyCount(1);
ValidateIntegerPref(good_crx, "state",
Extension::EXTERNAL_EXTENSION_UNINSTALLED);
ValidateIntegerPref(good_crx, "location", location);
// Now clear the preference and reinstall.
SetPrefInteg(good_crx, "state", Extension::ENABLED);
loaded_.clear();
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
ASSERT_EQ(1u, loaded_.size());
}
ValidatePrefKeyCount(1);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", location);
if (GetManagementPolicy()->MustRemainEnabled(loaded_[0].get(), NULL)) {
EXPECT_EQ(2, provider->visit_count());
} else {
// Now test an externally triggered uninstall (deleting the registry key or
// the pref entry).
provider->RemoveExtension(good_crx);
loaded_.clear();
service()->OnExternalProviderReady(provider);
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, loaded_.size());
ValidatePrefKeyCount(0);
// The extension should also be gone from the install directory.
ASSERT_FALSE(base::PathExists(install_path));
// Now test the case where user uninstalls and then the extension is removed
// from the external provider.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
provider->UpdateOrAddExtension(good_crx, "1.0.0.1", source_path);
service()->CheckForExternalUpdates();
observer.Wait();
ASSERT_EQ(1u, loaded_.size());
ASSERT_EQ(0u, GetErrors().size());
// User uninstalls.
loaded_.clear();
service()->UninstallExtension(id,
extensions::UNINSTALL_REASON_FOR_TESTING,
base::Bind(&base::DoNothing),
NULL);
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, loaded_.size());
// Then remove the extension from the extension provider.
provider->RemoveExtension(good_crx);
// Should still be at 0.
loaded_.clear();
extensions::InstalledLoader(service()).LoadAllExtensions();
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, loaded_.size());
ValidatePrefKeyCount(1);
EXPECT_EQ(5, provider->visit_count());
}
}
// Tests the external installation feature
#if defined(OS_WIN)
TEST_F(ExtensionServiceTest, ExternalInstallRegistry) {
// This should all work, even when normal extension installation is disabled.
InitializeEmptyExtensionService();
service()->set_extensions_enabled(false);
// Now add providers. Extension system takes ownership of the objects.
MockExtensionProvider* reg_provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_REGISTRY);
AddMockExternalProvider(reg_provider);
TestExternalProvider(reg_provider, Manifest::EXTERNAL_REGISTRY);
}
#endif
TEST_F(ExtensionServiceTest, ExternalInstallPref) {
InitializeEmptyExtensionService();
// Now add providers. Extension system takes ownership of the objects.
MockExtensionProvider* pref_provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(pref_provider);
TestExternalProvider(pref_provider, Manifest::EXTERNAL_PREF);
}
TEST_F(ExtensionServiceTest, ExternalInstallPrefUpdateUrl) {
// This should all work, even when normal extension installation is disabled.
InitializeEmptyExtensionService();
service()->set_extensions_enabled(false);
// TODO(skerner): The mock provider is not a good model of a provider
// that works with update URLs, because it adds file and version info.
// Extend the mock to work with update URLs. This test checks the
// behavior that is common to all external extension visitors. The
// browser test ExtensionManagementTest.ExternalUrlUpdate tests that
// what the visitor does results in an extension being downloaded and
// installed.
MockExtensionProvider* pref_provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF_DOWNLOAD);
AddMockExternalProvider(pref_provider);
TestExternalProvider(pref_provider, Manifest::EXTERNAL_PREF_DOWNLOAD);
}
TEST_F(ExtensionServiceTest, ExternalInstallPolicyUpdateUrl) {
// This should all work, even when normal extension installation is disabled.
InitializeEmptyExtensionService();
service()->set_extensions_enabled(false);
// TODO(skerner): The mock provider is not a good model of a provider
// that works with update URLs, because it adds file and version info.
// Extend the mock to work with update URLs. This test checks the
// behavior that is common to all external extension visitors. The
// browser test ExtensionManagementTest.ExternalUrlUpdate tests that
// what the visitor does results in an extension being downloaded and
// installed.
MockExtensionProvider* pref_provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
AddMockExternalProvider(pref_provider);
TestExternalProvider(pref_provider, Manifest::EXTERNAL_POLICY_DOWNLOAD);
}
// Tests that external extensions get uninstalled when the external extension
// providers can't account for them.
TEST_F(ExtensionServiceTest, ExternalUninstall) {
// Start the extensions service with one external extension already installed.
base::FilePath source_install_dir =
data_dir().AppendASCII("good").AppendASCII("Extensions");
base::FilePath pref_path = source_install_dir
.DirName()
.AppendASCII("PreferencesExternal");
// This initializes the extensions service with no ExternalProviders.
InitializeInstalledExtensionService(pref_path, source_install_dir);
service()->set_extensions_enabled(false);
service()->Init();
ASSERT_EQ(0u, GetErrors().size());
ASSERT_EQ(0u, loaded_.size());
// Verify that it's not the disabled extensions flag causing it not to load.
service()->set_extensions_enabled(true);
service()->ReloadExtensionsForTest();
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, GetErrors().size());
ASSERT_EQ(0u, loaded_.size());
}
// Test that running multiple update checks simultaneously does not
// keep the update from succeeding.
TEST_F(ExtensionServiceTest, MultipleExternalUpdateCheck) {
InitializeEmptyExtensionService();
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
// Verify that starting with no providers loads no extensions.
service()->Init();
ASSERT_EQ(0u, loaded_.size());
// Start two checks for updates.
provider->set_visit_count(0);
service()->CheckForExternalUpdates();
service()->CheckForExternalUpdates();
base::RunLoop().RunUntilIdle();
// Two calls should cause two checks for external extensions.
EXPECT_EQ(2, provider->visit_count());
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(0u, loaded_.size());
// Register a test extension externally using the mock registry provider.
base::FilePath source_path = data_dir().AppendASCII("good.crx");
provider->UpdateOrAddExtension(good_crx, "1.0.0.0", source_path);
// Two checks for external updates should find the extension, and install it
// once.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
provider->set_visit_count(0);
service()->CheckForExternalUpdates();
service()->CheckForExternalUpdates();
observer.Wait();
EXPECT_EQ(2, provider->visit_count());
ASSERT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
ASSERT_EQ(Manifest::EXTERNAL_PREF, loaded_[0]->location());
ASSERT_EQ("1.0.0.0", loaded_[0]->version()->GetString());
ValidatePrefKeyCount(1);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", Manifest::EXTERNAL_PREF);
provider->RemoveExtension(good_crx);
provider->set_visit_count(0);
service()->CheckForExternalUpdates();
service()->CheckForExternalUpdates();
base::RunLoop().RunUntilIdle();
// Two calls should cause two checks for external extensions.
// Because the external source no longer includes good_crx,
// good_crx will be uninstalled. So, expect that no extensions
// are loaded.
EXPECT_EQ(2, provider->visit_count());
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(0u, loaded_.size());
}
TEST_F(ExtensionServiceTest, ExternalPrefProvider) {
InitializeEmptyExtensionService();
// Test some valid extension records.
// Set a base path to avoid erroring out on relative paths.
// Paths starting with // are absolute on every platform we support.
base::FilePath base_path(FILE_PATH_LITERAL("//base/path"));
ASSERT_TRUE(base_path.IsAbsolute());
MockProviderVisitor visitor(base_path);
std::string json_data =
"{"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
" \"external_crx\": \"RandomExtension.crx\","
" \"external_version\": \"1.0\""
" },"
" \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
" \"external_crx\": \"RandomExtension2.crx\","
" \"external_version\": \"2.0\""
" },"
" \"cccccccccccccccccccccccccccccccc\": {"
" \"external_update_url\": \"http:\\\\foo.com/update\","
" \"install_parameter\": \"id\""
" }"
"}";
EXPECT_EQ(3, visitor.Visit(json_data));
// Simulate an external_extensions.json file that contains seven invalid
// records:
// - One that is missing the 'external_crx' key.
// - One that is missing the 'external_version' key.
// - One that is specifying .. in the path.
// - One that specifies both a file and update URL.
// - One that specifies no file or update URL.
// - One that has an update URL that is not well formed.
// - One that contains a malformed version.
// - One that has an invalid id.
// - One that has a non-dictionary value.
// - One that has an integer 'external_version' instead of a string.
// The final extension is valid, and we check that it is read to make sure
// failures don't stop valid records from being read.
json_data =
"{"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
" \"external_version\": \"1.0\""
" },"
" \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
" \"external_crx\": \"RandomExtension.crx\""
" },"
" \"cccccccccccccccccccccccccccccccc\": {"
" \"external_crx\": \"..\\\\foo\\\\RandomExtension2.crx\","
" \"external_version\": \"2.0\""
" },"
" \"dddddddddddddddddddddddddddddddd\": {"
" \"external_crx\": \"RandomExtension2.crx\","
" \"external_version\": \"2.0\","
" \"external_update_url\": \"http:\\\\foo.com/update\""
" },"
" \"eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\": {"
" },"
" \"ffffffffffffffffffffffffffffffff\": {"
" \"external_update_url\": \"This string is not a valid URL\""
" },"
" \"gggggggggggggggggggggggggggggggg\": {"
" \"external_crx\": \"RandomExtension3.crx\","
" \"external_version\": \"This is not a valid version!\""
" },"
" \"This is not a valid id!\": {},"
" \"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\": true,"
" \"iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\": {"
" \"external_crx\": \"RandomExtension4.crx\","
" \"external_version\": 1.0"
" },"
" \"pppppppppppppppppppppppppppppppp\": {"
" \"external_crx\": \"RandomValidExtension.crx\","
" \"external_version\": \"1.0\""
" }"
"}";
EXPECT_EQ(1, visitor.Visit(json_data));
// Check that if a base path is not provided, use of a relative
// path fails.
base::FilePath empty;
MockProviderVisitor visitor_no_relative_paths(empty);
// Use absolute paths. Expect success.
json_data =
"{"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
" \"external_crx\": \"//RandomExtension1.crx\","
" \"external_version\": \"3.0\""
" },"
" \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
" \"external_crx\": \"//path/to/RandomExtension2.crx\","
" \"external_version\": \"3.0\""
" }"
"}";
EXPECT_EQ(2, visitor_no_relative_paths.Visit(json_data));
// Use a relative path. Expect that it will error out.
json_data =
"{"
" \"cccccccccccccccccccccccccccccccc\": {"
" \"external_crx\": \"RandomExtension2.crx\","
" \"external_version\": \"3.0\""
" }"
"}";
EXPECT_EQ(0, visitor_no_relative_paths.Visit(json_data));
// Test supported_locales.
json_data =
"{"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
" \"external_crx\": \"RandomExtension.crx\","
" \"external_version\": \"1.0\","
" \"supported_locales\": [ \"en\" ]"
" },"
" \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
" \"external_crx\": \"RandomExtension2.crx\","
" \"external_version\": \"2.0\","
" \"supported_locales\": [ \"en-GB\" ]"
" },"
" \"cccccccccccccccccccccccccccccccc\": {"
" \"external_crx\": \"RandomExtension2.crx\","
" \"external_version\": \"3.0\","
" \"supported_locales\": [ \"en_US\", \"fr\" ]"
" }"
"}";
{
ScopedBrowserLocale guard("en-US");
EXPECT_EQ(2, visitor.Visit(json_data));
}
// Test keep_if_present.
json_data =
"{"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
" \"external_crx\": \"RandomExtension.crx\","
" \"external_version\": \"1.0\","
" \"keep_if_present\": true"
" }"
"}";
{
EXPECT_EQ(0, visitor.Visit(json_data));
}
// Test is_bookmark_app.
MockProviderVisitor from_bookmark_visitor(
base_path, Extension::FROM_BOOKMARK);
json_data =
"{"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
" \"external_crx\": \"RandomExtension.crx\","
" \"external_version\": \"1.0\","
" \"is_bookmark_app\": true"
" }"
"}";
EXPECT_EQ(1, from_bookmark_visitor.Visit(json_data));
// Test is_from_webstore.
MockProviderVisitor from_webstore_visitor(
base_path, Extension::FROM_WEBSTORE);
json_data =
"{"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
" \"external_crx\": \"RandomExtension.crx\","
" \"external_version\": \"1.0\","
" \"is_from_webstore\": true"
" }"
"}";
EXPECT_EQ(1, from_webstore_visitor.Visit(json_data));
// Test was_installed_by_eom.
MockProviderVisitor was_installed_by_eom_visitor(
base_path, Extension::WAS_INSTALLED_BY_OEM);
json_data =
"{"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
" \"external_crx\": \"RandomExtension.crx\","
" \"external_version\": \"1.0\","
" \"was_installed_by_oem\": true"
" }"
"}";
EXPECT_EQ(1, was_installed_by_eom_visitor.Visit(json_data));
// Test min_profile_created_by_version.
MockProviderVisitor min_profile_created_by_version_visitor(base_path);
json_data =
"{"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
" \"external_crx\": \"RandomExtension.crx\","
" \"external_version\": \"1.0\","
" \"min_profile_created_by_version\": \"42.0.0.1\""
" },"
" \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
" \"external_crx\": \"RandomExtension2.crx\","
" \"external_version\": \"1.0\","
" \"min_profile_created_by_version\": \"43.0.0.1\""
" },"
" \"cccccccccccccccccccccccccccccccc\": {"
" \"external_crx\": \"RandomExtension3.crx\","
" \"external_version\": \"3.0\","
" \"min_profile_created_by_version\": \"44.0.0.1\""
" }"
"}";
min_profile_created_by_version_visitor.profile()->GetPrefs()->SetString(
prefs::kProfileCreatedByVersion, "40.0.0.1");
EXPECT_EQ(0, min_profile_created_by_version_visitor.Visit(json_data));
min_profile_created_by_version_visitor.profile()->GetPrefs()->SetString(
prefs::kProfileCreatedByVersion, "43.0.0.1");
EXPECT_EQ(2, min_profile_created_by_version_visitor.Visit(json_data));
min_profile_created_by_version_visitor.profile()->GetPrefs()->SetString(
prefs::kProfileCreatedByVersion, "45.0.0.1");
EXPECT_EQ(3, min_profile_created_by_version_visitor.Visit(json_data));
}
TEST_F(ExtensionServiceTest, DoNotInstallForEnterprise) {
InitializeEmptyExtensionService();
const base::FilePath base_path(FILE_PATH_LITERAL("//base/path"));
ASSERT_TRUE(base_path.IsAbsolute());
MockProviderVisitor visitor(base_path);
policy::ProfilePolicyConnector* const connector =
policy::ProfilePolicyConnectorFactory::GetForBrowserContext(
visitor.profile());
connector->OverrideIsManagedForTesting(true);
EXPECT_TRUE(connector->IsManaged());
std::string json_data =
"{"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
" \"external_crx\": \"RandomExtension.crx\","
" \"external_version\": \"1.0\","
" \"do_not_install_for_enterprise\": true"
" },"
" \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
" \"external_crx\": \"RandomExtension2.crx\","
" \"external_version\": \"1.0\""
" }"
"}";
EXPECT_EQ(1, visitor.Visit(json_data));
}
// Test loading good extensions from the profile directory.
TEST_F(ExtensionServiceTest, LoadAndRelocalizeExtensions) {
// Ensure we're testing in "en" and leave global state untouched.
extension_l10n_util::ScopedLocaleForTest testLocale("en");
// Initialize the test dir with a good Preferences/extensions.
base::FilePath source_install_dir = data_dir().AppendASCII("l10n");
base::FilePath pref_path =
source_install_dir.Append(chrome::kPreferencesFilename);
InitializeInstalledExtensionService(pref_path, source_install_dir);
service()->Init();
ASSERT_EQ(3u, loaded_.size());
// This was equal to "sr" on load.
ValidateStringPref(loaded_[0]->id(), keys::kCurrentLocale, "en");
// These are untouched by re-localization.
ValidateStringPref(loaded_[1]->id(), keys::kCurrentLocale, "en");
EXPECT_FALSE(IsPrefExist(loaded_[1]->id(), keys::kCurrentLocale));
// This one starts with Serbian name, and gets re-localized into English.
EXPECT_EQ("My name is simple.", loaded_[0]->name());
// These are untouched by re-localization.
EXPECT_EQ("My name is simple.", loaded_[1]->name());
EXPECT_EQ("no l10n", loaded_[2]->name());
}
class ExtensionsReadyRecorder : public content::NotificationObserver {
public:
ExtensionsReadyRecorder() : ready_(false) {
registrar_.Add(this,
extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
content::NotificationService::AllSources());
}
void set_ready(bool value) { ready_ = value; }
bool ready() { return ready_; }
private:
void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) override {
switch (type) {
case extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED:
ready_ = true;
break;
default:
NOTREACHED();
}
}
content::NotificationRegistrar registrar_;
bool ready_;
};
// Test that we get enabled/disabled correctly for all the pref/command-line
// combinations. We don't want to derive from the ExtensionServiceTest class
// for this test, so we use ExtensionServiceTestSimple.
//
// Also tests that we always fire EXTENSIONS_READY, no matter whether we are
// enabled or not.
class ExtensionServiceTestSimple : public testing::Test {
content::TestBrowserThreadBundle thread_bundle_;
};
TEST_F(ExtensionServiceTestSimple, Enabledness) {
// Make sure the PluginService singleton is destroyed at the end of the test.
base::ShadowingAtExitManager at_exit_manager;
#if defined(ENABLE_PLUGINS)
content::PluginService::GetInstance()->Init();
content::PluginService::GetInstance()->DisablePluginsDiscoveryForTesting();
#endif
ExtensionErrorReporter::Init(false); // no noisy errors
ExtensionsReadyRecorder recorder;
scoped_ptr<TestingProfile> profile(new TestingProfile());
#if defined OS_CHROMEOS
chromeos::ScopedTestDeviceSettingsService device_settings_service;
chromeos::ScopedTestCrosSettings cros_settings;
scoped_ptr<chromeos::ScopedTestUserManager> user_manager(
new chromeos::ScopedTestUserManager);
#endif
scoped_ptr<base::CommandLine> command_line;
base::FilePath install_dir = profile->GetPath()
.AppendASCII(extensions::kInstallDirectoryName);
// By default, we are enabled.
command_line.reset(new base::CommandLine(base::CommandLine::NO_PROGRAM));
ExtensionService* service = static_cast<extensions::TestExtensionSystem*>(
ExtensionSystem::Get(profile.get()))->
CreateExtensionService(
command_line.get(),
install_dir,
false);
EXPECT_TRUE(service->extensions_enabled());
service->Init();
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(recorder.ready());
#if defined OS_CHROMEOS
user_manager.reset();
#endif
// If either the command line or pref is set, we are disabled.
recorder.set_ready(false);
profile.reset(new TestingProfile());
command_line->AppendSwitch(switches::kDisableExtensions);
service = static_cast<extensions::TestExtensionSystem*>(
ExtensionSystem::Get(profile.get()))->
CreateExtensionService(
command_line.get(),
install_dir,
false);
EXPECT_FALSE(service->extensions_enabled());
service->Init();
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(recorder.ready());
recorder.set_ready(false);
profile.reset(new TestingProfile());
profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
service = static_cast<extensions::TestExtensionSystem*>(
ExtensionSystem::Get(profile.get()))->
CreateExtensionService(
command_line.get(),
install_dir,
false);
EXPECT_FALSE(service->extensions_enabled());
service->Init();
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(recorder.ready());
recorder.set_ready(false);
profile.reset(new TestingProfile());
profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
command_line.reset(new base::CommandLine(base::CommandLine::NO_PROGRAM));
service = static_cast<extensions::TestExtensionSystem*>(
ExtensionSystem::Get(profile.get()))->
CreateExtensionService(
command_line.get(),
install_dir,
false);
EXPECT_FALSE(service->extensions_enabled());
service->Init();
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(recorder.ready());
// Explicitly delete all the resources used in this test.
profile.reset();
service = NULL;
// Execute any pending deletion tasks.
base::RunLoop().RunUntilIdle();
}
// Test loading extensions that require limited and unlimited storage quotas.
TEST_F(ExtensionServiceTest, StorageQuota) {
InitializeEmptyExtensionService();
base::FilePath extensions_path = data_dir().AppendASCII("storage_quota");
base::FilePath limited_quota_ext =
extensions_path.AppendASCII("limited_quota")
.AppendASCII("1.0");
// The old permission name for unlimited quota was "unlimited_storage", but
// we changed it to "unlimitedStorage". This tests both versions.
base::FilePath unlimited_quota_ext =
extensions_path.AppendASCII("unlimited_quota")
.AppendASCII("1.0");
base::FilePath unlimited_quota_ext2 =
extensions_path.AppendASCII("unlimited_quota")
.AppendASCII("2.0");
extensions::UnpackedInstaller::Create(service())->Load(limited_quota_ext);
extensions::UnpackedInstaller::Create(service())->Load(unlimited_quota_ext);
extensions::UnpackedInstaller::Create(service())->Load(unlimited_quota_ext2);
base::RunLoop().RunUntilIdle();
ASSERT_EQ(3u, loaded_.size());
EXPECT_TRUE(profile());
EXPECT_FALSE(profile()->IsOffTheRecord());
EXPECT_FALSE(
profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
loaded_[0]->url()));
EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
loaded_[1]->url()));
EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
loaded_[2]->url()));
}
// Tests ComponentLoader::Add().
TEST_F(ExtensionServiceTest, ComponentExtensions) {
InitializeEmptyExtensionService();
// Component extensions should work even when extensions are disabled.
service()->set_extensions_enabled(false);
base::FilePath path = data_dir()
.AppendASCII("good")
.AppendASCII("Extensions")
.AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
.AppendASCII("1.0.0.0");
std::string manifest;
ASSERT_TRUE(base::ReadFileToString(
path.Append(extensions::kManifestFilename), &manifest));
service()->component_loader()->Add(manifest, path);
service()->Init();
// Note that we do not pump messages -- the extension should be loaded
// immediately.
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(Manifest::COMPONENT, loaded_[0]->location());
EXPECT_EQ(1u, registry()->enabled_extensions().size());
// Component extensions get a prefs entry on first install.
ValidatePrefKeyCount(1);
// Reload all extensions, and make sure it comes back.
std::string extension_id = (*registry()->enabled_extensions().begin())->id();
loaded_.clear();
service()->ReloadExtensionsForTest();
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(extension_id, (*registry()->enabled_extensions().begin())->id());
}
TEST_F(ExtensionServiceTest, InstallPriorityExternalUpdateUrl) {
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(1u);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
extensions::PendingExtensionManager* pending =
service()->pending_extension_manager();
EXPECT_FALSE(pending->IsIdPending(kGoodId));
// Skip install when the location is the same.
EXPECT_FALSE(
service()->OnExternalExtensionUpdateUrlFound(kGoodId,
std::string(),
GURL(kGoodUpdateURL),
Manifest::INTERNAL,
Extension::NO_FLAGS,
false));
EXPECT_FALSE(pending->IsIdPending(kGoodId));
// Install when the location has higher priority.
EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(
kGoodId,
std::string(),
GURL(kGoodUpdateURL),
Manifest::EXTERNAL_POLICY_DOWNLOAD,
Extension::NO_FLAGS,
false));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// Try the low priority again. Should be rejected.
EXPECT_FALSE(service()->OnExternalExtensionUpdateUrlFound(
kGoodId,
std::string(),
GURL(kGoodUpdateURL),
Manifest::EXTERNAL_PREF_DOWNLOAD,
Extension::NO_FLAGS,
false));
// The existing record should still be present in the pending extension
// manager.
EXPECT_TRUE(pending->IsIdPending(kGoodId));
pending->Remove(kGoodId);
// Skip install when the location has the same priority as the installed
// location.
EXPECT_FALSE(
service()->OnExternalExtensionUpdateUrlFound(kGoodId,
std::string(),
GURL(kGoodUpdateURL),
Manifest::INTERNAL,
Extension::NO_FLAGS,
false));
EXPECT_FALSE(pending->IsIdPending(kGoodId));
}
TEST_F(ExtensionServiceTest, InstallPriorityExternalLocalFile) {
Version older_version("0.1.0.0");
Version newer_version("2.0.0.0");
// We don't want the extension to be installed. A path that doesn't
// point to a valid CRX ensures this.
const base::FilePath kInvalidPathToCrx(FILE_PATH_LITERAL("invalid_path"));
const int kCreationFlags = 0;
const bool kDontMarkAcknowledged = false;
const bool kDontInstallImmediately = false;
InitializeEmptyExtensionService();
// The test below uses install source constants to test that
// priority is enforced. It assumes a specific ranking of install
// sources: Registry (EXTERNAL_REGISTRY) overrides external pref
// (EXTERNAL_PREF), and external pref overrides user install (INTERNAL).
// The following assertions verify these assumptions:
ASSERT_EQ(Manifest::EXTERNAL_REGISTRY,
Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_REGISTRY,
Manifest::EXTERNAL_PREF));
ASSERT_EQ(Manifest::EXTERNAL_REGISTRY,
Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_REGISTRY,
Manifest::INTERNAL));
ASSERT_EQ(Manifest::EXTERNAL_PREF,
Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_PREF,
Manifest::INTERNAL));
extensions::PendingExtensionManager* pending =
service()->pending_extension_manager();
EXPECT_FALSE(pending->IsIdPending(kGoodId));
{
// Simulate an external source adding the extension as INTERNAL.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
EXPECT_TRUE(service()->OnExternalExtensionFileFound(
kGoodId,
&older_version,
kInvalidPathToCrx,
Manifest::INTERNAL,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
observer.Wait();
VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
}
{
// Simulate an external source adding the extension as EXTERNAL_PREF.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
EXPECT_TRUE(service()->OnExternalExtensionFileFound(
kGoodId,
&older_version,
kInvalidPathToCrx,
Manifest::EXTERNAL_PREF,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
observer.Wait();
VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
}
// Simulate an external source adding as EXTERNAL_PREF again.
// This is rejected because the version and the location are the same as
// the previous installation, which is still pending.
EXPECT_FALSE(service()->OnExternalExtensionFileFound(
kGoodId,
&older_version,
kInvalidPathToCrx,
Manifest::EXTERNAL_PREF,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// Try INTERNAL again. Should fail.
EXPECT_FALSE(service()->OnExternalExtensionFileFound(
kGoodId,
&older_version,
kInvalidPathToCrx,
Manifest::INTERNAL,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
{
// Now the registry adds the extension.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
EXPECT_TRUE(service()->OnExternalExtensionFileFound(
kGoodId,
&older_version,
kInvalidPathToCrx,
Manifest::EXTERNAL_REGISTRY,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
observer.Wait();
VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
}
// Registry outranks both external pref and internal, so both fail.
EXPECT_FALSE(service()->OnExternalExtensionFileFound(
kGoodId,
&older_version,
kInvalidPathToCrx,
Manifest::EXTERNAL_PREF,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
EXPECT_FALSE(service()->OnExternalExtensionFileFound(
kGoodId,
&older_version,
kInvalidPathToCrx,
Manifest::INTERNAL,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
pending->Remove(kGoodId);
// Install the extension.
base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* ext = InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(1u);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
// Now test the logic of OnExternalExtensionFileFound() when the extension
// being added is already installed.
// Tests assume |older_version| is less than the installed version, and
// |newer_version| is greater. Verify this:
ASSERT_TRUE(older_version.IsOlderThan(ext->VersionString()));
ASSERT_TRUE(ext->version()->IsOlderThan(newer_version.GetString()));
// An external install for the same location should fail if the version is
// older, or the same, and succeed if the version is newer.
// Older than the installed version...
EXPECT_FALSE(service()->OnExternalExtensionFileFound(
kGoodId,
&older_version,
kInvalidPathToCrx,
Manifest::INTERNAL,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_FALSE(pending->IsIdPending(kGoodId));
// Same version as the installed version...
EXPECT_FALSE(service()->OnExternalExtensionFileFound(
kGoodId,
ext->version(),
kInvalidPathToCrx,
Manifest::INTERNAL,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_FALSE(pending->IsIdPending(kGoodId));
// Newer than the installed version...
EXPECT_TRUE(service()->OnExternalExtensionFileFound(
kGoodId,
&newer_version,
kInvalidPathToCrx,
Manifest::INTERNAL,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// An external install for a higher priority install source should succeed
// if the version is greater. |older_version| is not...
EXPECT_FALSE(service()->OnExternalExtensionFileFound(
kGoodId,
&older_version,
kInvalidPathToCrx,
Manifest::EXTERNAL_PREF,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// |newer_version| is newer.
EXPECT_TRUE(service()->OnExternalExtensionFileFound(
kGoodId,
&newer_version,
kInvalidPathToCrx,
Manifest::EXTERNAL_PREF,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// An external install for an even higher priority install source should
// succeed if the version is greater.
EXPECT_TRUE(service()->OnExternalExtensionFileFound(
kGoodId,
&newer_version,
kInvalidPathToCrx,
Manifest::EXTERNAL_REGISTRY,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// Because EXTERNAL_PREF is a lower priority source than EXTERNAL_REGISTRY,
// adding from external pref will now fail.
EXPECT_FALSE(service()->OnExternalExtensionFileFound(
kGoodId,
&newer_version,
kInvalidPathToCrx,
Manifest::EXTERNAL_PREF,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
}
TEST_F(ExtensionServiceTest, ConcurrentExternalLocalFile) {
Version kVersion123("1.2.3");
Version kVersion124("1.2.4");
Version kVersion125("1.2.5");
const base::FilePath kInvalidPathToCrx(FILE_PATH_LITERAL("invalid_path"));
const int kCreationFlags = 0;
const bool kDontMarkAcknowledged = false;
const bool kDontInstallImmediately = false;
InitializeEmptyExtensionService();
extensions::PendingExtensionManager* pending =
service()->pending_extension_manager();
EXPECT_FALSE(pending->IsIdPending(kGoodId));
// An external provider starts installing from a local crx.
EXPECT_TRUE(service()->OnExternalExtensionFileFound(
kGoodId,
&kVersion123,
kInvalidPathToCrx,
Manifest::EXTERNAL_PREF,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
const extensions::PendingExtensionInfo* info;
EXPECT_TRUE((info = pending->GetById(kGoodId)));
EXPECT_TRUE(info->version().IsValid());
EXPECT_TRUE(info->version().Equals(kVersion123));
// Adding a newer version overrides the currently pending version.
EXPECT_TRUE(service()->OnExternalExtensionFileFound(
kGoodId,
&kVersion124,
kInvalidPathToCrx,
Manifest::EXTERNAL_PREF,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE((info = pending->GetById(kGoodId)));
EXPECT_TRUE(info->version().IsValid());
EXPECT_TRUE(info->version().Equals(kVersion124));
// Adding an older version fails.
EXPECT_FALSE(service()->OnExternalExtensionFileFound(
kGoodId,
&kVersion123,
kInvalidPathToCrx,
Manifest::EXTERNAL_PREF,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE((info = pending->GetById(kGoodId)));
EXPECT_TRUE(info->version().IsValid());
EXPECT_TRUE(info->version().Equals(kVersion124));
// Adding an older version fails even when coming from a higher-priority
// location.
EXPECT_FALSE(service()->OnExternalExtensionFileFound(
kGoodId,
&kVersion123,
kInvalidPathToCrx,
Manifest::EXTERNAL_REGISTRY,
kCreationFlags,
kDontMarkAcknowledged,
kDontInstallImmediately));
EXPECT_TRUE((info = pending->GetById(kGoodId)));
EXPECT_TRUE(info->version().IsValid());
EXPECT_TRUE(info->version().Equals(kVersion124));
// Adding the latest version from the webstore overrides a specific version.
GURL kUpdateUrl("http://example.com/update");
EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(
kGoodId,
std::string(),
kUpdateUrl,
Manifest::EXTERNAL_POLICY_DOWNLOAD,
Extension::NO_FLAGS,
false));
EXPECT_TRUE((info = pending->GetById(kGoodId)));
EXPECT_FALSE(info->version().IsValid());
}
// This makes sure we can package and install CRX files that use whitelisted
// permissions.
TEST_F(ExtensionServiceTest, InstallWhitelistedExtension) {
std::string test_id = "hdkklepkcpckhnpgjnmbdfhehckloojk";
base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
extensions::switches::kWhitelistedExtensionID, test_id);
InitializeEmptyExtensionService();
base::FilePath path = data_dir().AppendASCII("permissions");
base::FilePath pem_path = path
.AppendASCII("whitelist.pem");
path = path
.AppendASCII("whitelist");
const Extension* extension = PackAndInstallCRX(path, pem_path, INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(test_id, extension->id());
}
// Test that when multiple sources try to install an extension,
// we consistently choose the right one. To make tests easy to read,
// methods that fake requests to install crx files in several ways
// are provided.
class ExtensionSourcePriorityTest : public ExtensionServiceTest {
public:
void SetUp() override {
ExtensionServiceTest::SetUp();
// All tests use a single extension. Put the id and path in member vars
// that all methods can read.
crx_id_ = kGoodId;
crx_path_ = data_dir().AppendASCII("good.crx");
}
// Fake an external source adding a URL to fetch an extension from.
bool AddPendingExternalPrefUrl() {
return service()->pending_extension_manager()->AddFromExternalUpdateUrl(
crx_id_,
std::string(),
GURL(),
Manifest::EXTERNAL_PREF_DOWNLOAD,
Extension::NO_FLAGS,
false);
}
// Fake an external file from external_extensions.json.
bool AddPendingExternalPrefFileInstall() {
Version version("1.0.0.0");
return service()->OnExternalExtensionFileFound(crx_id_,
&version,
crx_path_,
Manifest::EXTERNAL_PREF,
Extension::NO_FLAGS,
false,
false);
}
// Fake a request from sync to install an extension.
bool AddPendingSyncInstall() {
return service()->pending_extension_manager()->AddFromSync(
crx_id_,
GURL(kGoodUpdateURL),
base::Version(),
&IsExtension,
kGoodRemoteInstall,
kGoodInstalledByCustodian);
}
// Fake a policy install.
bool AddPendingPolicyInstall() {
// Get path to the CRX with id |kGoodId|.
return service()->OnExternalExtensionUpdateUrlFound(
crx_id_,
std::string(),
GURL(),
Manifest::EXTERNAL_POLICY_DOWNLOAD,
Extension::NO_FLAGS,
false);
}
// Get the install source of a pending extension.
Manifest::Location GetPendingLocation() {
const extensions::PendingExtensionInfo* info;
EXPECT_TRUE(
(info = service()->pending_extension_manager()->GetById(crx_id_)));
return info->install_source();
}
// Is an extension pending from a sync request?
bool GetPendingIsFromSync() {
const extensions::PendingExtensionInfo* info;
EXPECT_TRUE(
(info = service()->pending_extension_manager()->GetById(crx_id_)));
return info->is_from_sync();
}
// Is the CRX id these tests use pending?
bool IsCrxPending() {
return service()->pending_extension_manager()->IsIdPending(crx_id_);
}
// Is an extension installed?
bool IsCrxInstalled() {
return (service()->GetExtensionById(crx_id_, true) != NULL);
}
protected:
// All tests use a single extension. Making the id and path member
// vars avoids pasing the same argument to every method.
std::string crx_id_;
base::FilePath crx_path_;
};
// Test that a pending request for installation of an external CRX from
// an update URL overrides a pending request to install the same extension
// from sync.
TEST_F(ExtensionSourcePriorityTest, PendingExternalFileOverSync) {
InitializeEmptyExtensionService();
ASSERT_FALSE(IsCrxInstalled());
// Install pending extension from sync.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
EXPECT_TRUE(AddPendingSyncInstall());
ASSERT_EQ(Manifest::INTERNAL, GetPendingLocation());
EXPECT_TRUE(GetPendingIsFromSync());
ASSERT_FALSE(IsCrxInstalled());
// Install pending as external prefs json would.
AddPendingExternalPrefFileInstall();
ASSERT_EQ(Manifest::EXTERNAL_PREF, GetPendingLocation());
ASSERT_FALSE(IsCrxInstalled());
// Another request from sync should be ignored.
EXPECT_FALSE(AddPendingSyncInstall());
ASSERT_EQ(Manifest::EXTERNAL_PREF, GetPendingLocation());
ASSERT_FALSE(IsCrxInstalled());
observer.Wait();
VerifyCrxInstall(crx_path_, INSTALL_NEW);
ASSERT_TRUE(IsCrxInstalled());
}
// Test that an install of an external CRX from an update overrides
// an install of the same extension from sync.
TEST_F(ExtensionSourcePriorityTest, PendingExternalUrlOverSync) {
InitializeEmptyExtensionService();
ASSERT_FALSE(IsCrxInstalled());
EXPECT_TRUE(AddPendingSyncInstall());
ASSERT_EQ(Manifest::INTERNAL, GetPendingLocation());
EXPECT_TRUE(GetPendingIsFromSync());
ASSERT_FALSE(IsCrxInstalled());
ASSERT_TRUE(AddPendingExternalPrefUrl());
ASSERT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, GetPendingLocation());
EXPECT_FALSE(GetPendingIsFromSync());
ASSERT_FALSE(IsCrxInstalled());
EXPECT_FALSE(AddPendingSyncInstall());
ASSERT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, GetPendingLocation());
EXPECT_FALSE(GetPendingIsFromSync());
ASSERT_FALSE(IsCrxInstalled());
}
// Test that an external install request stops sync from installing
// the same extension.
TEST_F(ExtensionSourcePriorityTest, InstallExternalBlocksSyncRequest) {
InitializeEmptyExtensionService();
ASSERT_FALSE(IsCrxInstalled());
// External prefs starts an install.
AddPendingExternalPrefFileInstall();
// Crx installer was made, but has not yet run.
ASSERT_FALSE(IsCrxInstalled());
// Before the CRX installer runs, Sync requests that the same extension
// be installed. Should fail, because an external source is pending.
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
ASSERT_FALSE(AddPendingSyncInstall());
// Wait for the external source to install.
observer.Wait();
VerifyCrxInstall(crx_path_, INSTALL_NEW);
ASSERT_TRUE(IsCrxInstalled());
// Now that the extension is installed, sync request should fail
// because the extension is already installed.
ASSERT_FALSE(AddPendingSyncInstall());
}
// Test that installing an external extension displays a GlobalError.
TEST_F(ExtensionServiceTest, ExternalInstallGlobalError) {
FeatureSwitch::ScopedOverride prompt(
FeatureSwitch::prompt_for_external_extensions(), true);
InitializeEmptyExtensionService();
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
service()->external_install_manager()->UpdateExternalExtensionAlert();
// Should return false, meaning there aren't any extensions that the user
// needs to know about.
EXPECT_FALSE(HasExternalInstallErrors(service()));
// This is a normal extension, installed normally.
// This should NOT trigger an alert.
service()->set_extensions_enabled(true);
base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
service()->CheckForExternalUpdates();
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(HasExternalInstallErrors(service()));
// A hosted app, installed externally.
// This should NOT trigger an alert.
provider->UpdateOrAddExtension(
hosted_app, "1.0.0.0", data_dir().AppendASCII("hosted_app.crx"));
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
EXPECT_FALSE(HasExternalInstallErrors(service()));
// Another normal extension, but installed externally.
// This SHOULD trigger an alert.
provider->UpdateOrAddExtension(
page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
content::WindowedNotificationObserver observer2(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer2.Wait();
EXPECT_TRUE(HasExternalInstallErrors(service()));
}
// Test that external extensions are initially disabled, and that enabling
// them clears the prompt.
TEST_F(ExtensionServiceTest, ExternalInstallInitiallyDisabled) {
FeatureSwitch::ScopedOverride prompt(
FeatureSwitch::prompt_for_external_extensions(), true);
InitializeEmptyExtensionService();
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(
page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
EXPECT_TRUE(HasExternalInstallErrors(service()));
EXPECT_FALSE(service()->IsExtensionEnabled(page_action));
const Extension* extension =
registry()->disabled_extensions().GetByID(page_action);
EXPECT_TRUE(extension);
EXPECT_EQ(page_action, extension->id());
service()->EnableExtension(page_action);
EXPECT_FALSE(HasExternalInstallErrors(service()));
EXPECT_TRUE(service()->IsExtensionEnabled(page_action));
}
// Test that installing multiple external extensions works.
// Flaky on windows; http://crbug.com/295757 .
// Causes race conditions with an in-process utility thread, so disable under
// TSan: https://crbug.com/518957
#if defined(OS_WIN) || defined(THREAD_SANITIZER)
#define MAYBE_ExternalInstallMultiple DISABLED_ExternalInstallMultiple
#else
#define MAYBE_ExternalInstallMultiple ExternalInstallMultiple
#endif
TEST_F(ExtensionServiceTest, MAYBE_ExternalInstallMultiple) {
FeatureSwitch::ScopedOverride prompt(
FeatureSwitch::prompt_for_external_extensions(), true);
InitializeEmptyExtensionService();
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(
page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
provider->UpdateOrAddExtension(
good_crx, "1.0.0.0", data_dir().AppendASCII("good.crx"));
provider->UpdateOrAddExtension(
theme_crx, "2.0", data_dir().AppendASCII("theme.crx"));
int count = 3;
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
base::Bind(&WaitForCountNotificationsCallback, &count));
service()->CheckForExternalUpdates();
observer.Wait();
EXPECT_TRUE(HasExternalInstallErrors(service()));
EXPECT_FALSE(service()->IsExtensionEnabled(page_action));
EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
EXPECT_FALSE(service()->IsExtensionEnabled(theme_crx));
service()->EnableExtension(page_action);
EXPECT_FALSE(GetError(page_action));
EXPECT_TRUE(GetError(good_crx));
EXPECT_TRUE(GetError(theme_crx));
EXPECT_TRUE(HasExternalInstallErrors(service()));
EXPECT_FALSE(HasExternalInstallBubble(service()));
service()->EnableExtension(theme_crx);
EXPECT_FALSE(GetError(page_action));
EXPECT_FALSE(GetError(theme_crx));
EXPECT_TRUE(GetError(good_crx));
EXPECT_TRUE(HasExternalInstallErrors(service()));
EXPECT_FALSE(HasExternalInstallBubble(service()));
service()->EnableExtension(good_crx);
EXPECT_FALSE(GetError(page_action));
EXPECT_FALSE(GetError(good_crx));
EXPECT_FALSE(GetError(theme_crx));
EXPECT_FALSE(HasExternalInstallErrors(service()));
EXPECT_FALSE(HasExternalInstallBubble(service()));
}
TEST_F(ExtensionServiceTest, MultipleExternalInstallErrors) {
FeatureSwitch::ScopedOverride prompt(
FeatureSwitch::prompt_for_external_extensions(), true);
InitializeEmptyExtensionService();
service()->set_extensions_enabled(true);
MockExtensionProvider* reg_provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_REGISTRY);
AddMockExternalProvider(reg_provider);
std::string extension_info[][3] = {
// {id, path, version}
{good_crx, "1.0.0.0", "good.crx"},
{page_action, "1.0.0.0", "page_action.crx"},
{minimal_platform_app_crx, "0.1", "minimal_platform_app.crx"}};
for (size_t i = 0; i < arraysize(extension_info); ++i) {
reg_provider->UpdateOrAddExtension(
extension_info[i][0], extension_info[i][1],
data_dir().AppendASCII(extension_info[i][2]));
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
const size_t expected_error_count = i + 1u;
EXPECT_EQ(
expected_error_count,
service()->external_install_manager()->GetErrorsForTesting().size());
EXPECT_FALSE(service()->IsExtensionEnabled(extension_info[i][0]));
}
std::string extension_ids[] = {
extension_info[0][0], extension_info[1][0], extension_info[2][0]
};
// Each extension should end up in error.
ASSERT_TRUE(GetError(extension_ids[0]));
EXPECT_TRUE(GetError(extension_ids[1]));
EXPECT_TRUE(GetError(extension_ids[2]));
// Accept the first extension, this will remove the error associated with
// this extension. Also verify the other errors still exist.
GetError(extension_ids[0])->OnInstallPromptDone(
ExtensionInstallPrompt::Result::ACCEPTED);
EXPECT_FALSE(GetError(extension_ids[0]));
ASSERT_TRUE(GetError(extension_ids[1]));
EXPECT_TRUE(GetError(extension_ids[2]));
// Abort the second extension.
GetError(extension_ids[1])->OnInstallPromptDone(
ExtensionInstallPrompt::Result::USER_CANCELED);
EXPECT_FALSE(GetError(extension_ids[0]));
EXPECT_FALSE(GetError(extension_ids[1]));
ASSERT_TRUE(GetError(extension_ids[2]));
// Finally, re-enable the third extension, all errors should be removed.
service()->EnableExtension(extension_ids[2]);
EXPECT_FALSE(GetError(extension_ids[0]));
EXPECT_FALSE(GetError(extension_ids[1]));
EXPECT_FALSE(GetError(extension_ids[2]));
EXPECT_FALSE(HasExternalInstallErrors(service_));
}
// Test that there is a bubble for external extensions that update
// from the webstore if the profile is not new.
TEST_F(ExtensionServiceTest, ExternalInstallUpdatesFromWebstoreOldProfile) {
FeatureSwitch::ScopedOverride prompt(
FeatureSwitch::prompt_for_external_extensions(), true);
// This sets up the ExtensionPrefs used by our ExtensionService to be
// post-first run.
ExtensionServiceInitParams params = CreateDefaultInitParams();
params.is_first_run = false;
InitializeExtensionService(params);
base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
PackCRX(data_dir().AppendASCII("update_from_webstore"),
data_dir().AppendASCII("update_from_webstore.pem"),
crx_path);
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
EXPECT_TRUE(HasExternalInstallErrors(service()));
ASSERT_TRUE(GetError(updates_from_webstore));
EXPECT_EQ(ExternalInstallError::BUBBLE_ALERT,
GetError(updates_from_webstore)->alert_type());
EXPECT_FALSE(service()->IsExtensionEnabled(updates_from_webstore));
}
// Test that there is no bubble for external extensions if the profile is new.
TEST_F(ExtensionServiceTest, ExternalInstallUpdatesFromWebstoreNewProfile) {
FeatureSwitch::ScopedOverride prompt(
FeatureSwitch::prompt_for_external_extensions(), true);
InitializeEmptyExtensionService();
base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
PackCRX(data_dir().AppendASCII("update_from_webstore"),
data_dir().AppendASCII("update_from_webstore.pem"),
crx_path);
MockExtensionProvider* provider =
new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service()->CheckForExternalUpdates();
observer.Wait();
EXPECT_TRUE(HasExternalInstallErrors(service()));
ASSERT_TRUE(GetError(updates_from_webstore));
EXPECT_NE(ExternalInstallError::BUBBLE_ALERT,
GetError(updates_from_webstore)->alert_type());
EXPECT_FALSE(service()->IsExtensionEnabled(updates_from_webstore));
}
// Test that clicking to remove the extension on an external install warning
// uninstalls the extension.
TEST_F(ExtensionServiceTest, ExternalInstallClickToRemove) {
FeatureSwitch::ScopedOverride prompt(
FeatureSwitch::prompt_for_external_extensions(), true);
ExtensionServiceInitParams params = CreateDefaultInitParams();
params.is_first_run = false;
InitializeExtensionService(params);
base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
PackCRX(data_dir().AppendASCII("update_from_webstore"),
data_dir().AppendASCII("update_from_webstore.pem"),
crx_path);
MockExtensionProvider* provider =
new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service_->CheckForExternalUpdates();
observer.Wait();
EXPECT_TRUE(HasExternalInstallErrors(service_));
// We check both enabled and disabled, since these are "eventually exclusive"
// sets.
EXPECT_TRUE(registry()->disabled_extensions().GetByID(updates_from_webstore));
EXPECT_FALSE(registry()->enabled_extensions().GetByID(updates_from_webstore));
// Click the negative response.
service_->external_install_manager()
->GetErrorsForTesting()[0]
->OnInstallPromptDone(ExtensionInstallPrompt::Result::USER_CANCELED);
// The Extension should be uninstalled.
EXPECT_FALSE(registry()->GetExtensionById(updates_from_webstore,
ExtensionRegistry::EVERYTHING));
// The error should be removed.
EXPECT_FALSE(HasExternalInstallErrors(service_));
}
// Test that clicking to keep the extension on an external install warning
// re-enables the extension.
TEST_F(ExtensionServiceTest, ExternalInstallClickToKeep) {
FeatureSwitch::ScopedOverride prompt(
FeatureSwitch::prompt_for_external_extensions(), true);
ExtensionServiceInitParams params = CreateDefaultInitParams();
params.is_first_run = false;
InitializeExtensionService(params);
base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
PackCRX(data_dir().AppendASCII("update_from_webstore"),
data_dir().AppendASCII("update_from_webstore.pem"),
crx_path);
MockExtensionProvider* provider =
new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
content::WindowedNotificationObserver observer(
extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service_->CheckForExternalUpdates();
observer.Wait();
EXPECT_TRUE(HasExternalInstallErrors(service_));
// We check both enabled and disabled, since these are "eventually exclusive"
// sets.
EXPECT_TRUE(registry()->disabled_extensions().GetByID(updates_from_webstore));
EXPECT_FALSE(registry()->enabled_extensions().GetByID(updates_from_webstore));
// Accept the extension.
service_->external_install_manager()
->GetErrorsForTesting()[0]
->OnInstallPromptDone(ExtensionInstallPrompt::Result::ACCEPTED);
// It should be enabled again.
EXPECT_TRUE(registry()->enabled_extensions().GetByID(updates_from_webstore));
EXPECT_FALSE(
registry()->disabled_extensions().GetByID(updates_from_webstore));
// The error should be removed.
EXPECT_FALSE(HasExternalInstallErrors(service_));
}
TEST_F(ExtensionServiceTest, InstallBlacklistedExtension) {
InitializeEmptyExtensionService();
scoped_refptr<Extension> extension = extensions::ExtensionBuilder()
.SetManifest(extensions::DictionaryBuilder()
.Set("name", "extension")
.Set("version", "1.0")
.Set("manifest_version", 2).Build())
.Build();
ASSERT_TRUE(extension.get());
const std::string& id = extension->id();
std::set<std::string> id_set;
id_set.insert(id);
extensions::TestExtensionRegistryObserver observer(
extensions::ExtensionRegistry::Get(profile()));
// Installation should be allowed but the extension should never have been
// loaded and it should be blacklisted in prefs.
service()->OnExtensionInstalled(
extension.get(),
syncer::StringOrdinal(),
(extensions::kInstallFlagIsBlacklistedForMalware |
extensions::kInstallFlagInstallImmediately));
base::RunLoop().RunUntilIdle();
// Extension was installed but not loaded.
observer.WaitForExtensionWillBeInstalled();
EXPECT_TRUE(service()->GetInstalledExtension(id));
EXPECT_FALSE(registry()->enabled_extensions().Contains(id));
EXPECT_TRUE(registry()->blacklisted_extensions().Contains(id));
EXPECT_TRUE(ExtensionPrefs::Get(profile())->IsExtensionBlacklisted(id));
EXPECT_TRUE(
ExtensionPrefs::Get(profile())->IsBlacklistedExtensionAcknowledged(id));
}
// Tests a profile being destroyed correctly disables extensions.
TEST_F(ExtensionServiceTest, DestroyingProfileClearsExtensions) {
InitializeEmptyExtensionService();
InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
EXPECT_NE(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
EXPECT_EQ(0u, registry()->terminated_extensions().size());
EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
service()->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
content::Source<Profile>(profile()),
content::NotificationService::NoDetails());
EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
EXPECT_EQ(0u, registry()->enabled_extensions().size());
EXPECT_EQ(0u, registry()->disabled_extensions().size());
EXPECT_EQ(0u, registry()->terminated_extensions().size());
EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
}
| [
"1480868058@qq.com"
] | 1480868058@qq.com |
0295bb925038de28085cf7e7317667eab9bbd95e | 3db023edb0af1dcf8a1da83434d219c3a96362ba | /windows_nt_3_5_source_code/NT-782/PRIVATE/NET/UI/COMMON/SRC/BLT/BLTCC/BLTSSS.CXX | 769ccf4597b6c6055a96ed3ea90be239e30472c7 | [] | no_license | xiaoqgao/windows_nt_3_5_source_code | de30e9b95856bc09469d4008d76191f94379c884 | d2894c9125ff1c14028435ed1b21164f6b2b871a | refs/heads/master | 2022-12-23T17:58:33.768209 | 2020-09-28T20:20:18 | 2020-09-28T20:20:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,582 | cxx | /**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corp., 1991 **/
/**********************************************************************/
/*
bltsss.cxx
Spin button edit field - implementation
SLE object but only accept number and it will live only in
a spin button.
FILE HISTORY:
terryk 01-May-1991 Created
beng 18-Sep-1991 Pruned UIDEBUGs
terryk 08-Oct-1991 Change SendMessage Position
terryk 11-Nov-1991 Change SPIN_ITEM's type from INT to LONG
terryk 11-Nov-1991 cast QueryRange to LONG
YiHsinS 15-Dec-1992 Got rid of redundant MessageBeep
*/
#include "pchblt.hxx" // Precompiled header
const TCHAR * SPIN_SLE_STR::_pszClassName = SZ("EDIT");
/*********************************************************************
NAME: SPIN_SLE_STR::SPIN_SLE_STR
SYNOPSIS: constructor
ENTRY: OWNER_WINDOW * powin - pointer to owner window
CID cid - id for the object
LONG idsStart - the IDS number of the first string
LONG cIDString - the total number of string
BOOL fWrap - wrap around flag
NOTES: It will pass the information to the SLE and SPIN_ITEM
parent classes.
HISTORY:
terryk 01-May-1991 Created
beng 31-Jul-1991 Control error handling changed
*********************************************************************/
SPIN_SLE_STR::SPIN_SLE_STR( OWNER_WINDOW * powin, CID cid, LONG idsStart,
LONG cIDString, BOOL fWrap )
: SLE( powin, cid ),
CHANGEABLE_SPIN_ITEM( this, 0, 0, cIDString, fWrap ),
_anlsStr( NULL )
{
if ( QueryError() != NERR_Success )
{
return;
}
APIERR err = Initialize( idsStart );
if ( err != NERR_Success )
{
ReportError( err );
}
}
SPIN_SLE_STR::SPIN_SLE_STR( OWNER_WINDOW * powin, CID cid, LONG idsStart,
LONG cIDString, XYPOINT xy, XYDIMENSION dxy,
ULONG flStyle, BOOL fWrap )
: SLE( powin, cid, xy, dxy, flStyle, _pszClassName ),
CHANGEABLE_SPIN_ITEM( this, 0, 0, cIDString, fWrap ),
_anlsStr( NULL )
{
if ( QueryError() != NERR_Success )
{
return;
}
APIERR err = Initialize( idsStart );
if ( err != NERR_Success )
{
ReportError( err );
}
}
SPIN_SLE_STR::SPIN_SLE_STR( OWNER_WINDOW * powin, CID cid,
const TCHAR *apszString[],
LONG cIDString, BOOL fWrap )
: SLE( powin, cid ),
CHANGEABLE_SPIN_ITEM( this, 0, 0, cIDString, fWrap ),
_anlsStr( NULL )
{
if ( QueryError() != NERR_Success )
{
return;
}
APIERR err = Initialize( apszString );
if ( err != NERR_Success )
{
ReportError( err );
}
}
SPIN_SLE_STR::SPIN_SLE_STR( OWNER_WINDOW * powin, CID cid,
const TCHAR *apszString[],
LONG cIDString, XYPOINT xy, XYDIMENSION dxy,
ULONG flStyle, BOOL fWrap )
: SLE( powin, cid, xy, dxy, flStyle, _pszClassName ),
CHANGEABLE_SPIN_ITEM( this, 0, 0, cIDString, fWrap ),
_anlsStr( NULL )
{
if ( QueryError() != NERR_Success )
{
return;
}
APIERR err = Initialize( apszString );
if ( err != NERR_Success )
{
ReportError( err );
}
}
/*********************************************************************
NAME: SPIN_SLE_STR::~SPIN_SLE_STR
SYNOPSIS: destructor
HISTORY:
terryk 01-May-1991 Created
*********************************************************************/
SPIN_SLE_STR::~SPIN_SLE_STR()
{
delete [ QueryRange() ] _anlsStr;
}
/*********************************************************************
NAME: SPIN_SLE_STR::SetRange
SYNOPSIS: you cannot set range again
ENTRY: LONG dRange - range
NOTES: display UIDEBUG message to warn the programmer
HISTORY:
terryk 10-Jul-1991 Created
*********************************************************************/
VOID SPIN_SLE_STR::SetRange( const LONG dRange )
{
UNREFERENCED( dRange );
DBGEOL( SZ("BLTSSS: does not allow to change range.") );
}
/*********************************************************************
NAME: SPIN_SLE_STR::Initialize
SYNOPSIS: Initialize the internal string
HISTORY:
terryk 20-Jun-1991 Created
beng 05-Oct-1991 Win32 conversion
**********************************************************************/
APIERR SPIN_SLE_STR::Initialize( LONG idsStart )
{
APIERR err;
_anlsStr= new NLS_STR[ QueryRange() ];
if ( _anlsStr == NULL )
{
return ERROR_NOT_ENOUGH_MEMORY;
}
for ( LONG i = 0; i < (LONG)QueryRange() ; i++ )
{
_anlsStr[ i ].Load((INT)( idsStart + i ));
if (( err = _anlsStr[ i ].QueryError()) != NERR_Success )
{
return err;
}
}
if (( err = SaveCurrentData()) != NERR_Success )
{
return err;
}
NLS_STR nlsAccKey;
if (( err = GetAccKey( & nlsAccKey )) != NERR_Success )
{
return err;
}
return SetAccKey( nlsAccKey );
}
APIERR SPIN_SLE_STR::Initialize( const TCHAR *apszString[] )
{
APIERR err;
_anlsStr= new NLS_STR[ QueryRange() ];
if ( _anlsStr == NULL )
{
return ERROR_NOT_ENOUGH_MEMORY;
}
for ( LONG i = 0; i < (LONG)QueryRange() ; i++ )
{
_anlsStr[ i ] = apszString[ i ];
if (( err = _anlsStr[ i ].QueryError()) != NERR_Success )
{
return err;
}
}
if (( err = SaveCurrentData()) != NERR_Success )
{
return err;
}
NLS_STR nlsAccKey;
if (( err = GetAccKey( & nlsAccKey )) != NERR_Success )
{
return err;
}
return SetAccKey( nlsAccKey );
}
/*********************************************************************
NAME: SPIN_SLE_STR::OnKeyDown
SYNOPSIS: do the action when a key is hit
ENTRY: VKEY_EVENT event - contain the key
RETURN: TRUE if the routine handles the character
FALSE otherwise
HISTORY:
terryk 10-Jul-1991 Created
*********************************************************************/
BOOL SPIN_SLE_STR::OnKeyDown( const VKEY_EVENT & event )
{
SPIN_GROUP * psb = ( SPIN_GROUP * )SPIN_ITEM::QueryGroup();
switch ( event.QueryVKey() )
{
case VK_UP:
case VK_PRIOR:
psb->ChangeFieldValue( SPN_INCREASE, event.QueryRepeat() );
break;
case VK_DOWN:
case VK_NEXT:
psb->ChangeFieldValue( SPN_DECREASE, event.QueryRepeat() );
break;
case VK_LEFT:
psb->JumpPrevField();
break;
case VK_RIGHT:
psb->JumpNextField();
break;
case VK_HOME:
psb->SetFieldMinMax( SPN_MAX );
break;
case VK_END:
psb->SetFieldMinMax( SPN_MIN );
break;
default:
return FALSE;
}
return TRUE;
}
/*********************************************************************
NAME: SPIN_SLE_STR::SaveCurrentData
SYNOPSIS: save the current window data to the internal variable
NOTES: Assume the current value is correct, otherwise,
the first element is set
HISTORY:
terryk 29-May-91 Created
*********************************************************************/
APIERR SPIN_SLE_STR::SaveCurrentData()
{
SPIN_GROUP * psg = ( SPIN_GROUP * ) SPIN_ITEM::QueryGroup();
if ( ( psg != NULL ) && ! psg->IsActive() )
return NERR_Success;
NLS_STR nlsValue;
APIERR err = QueryText( &nlsValue );
if ( err != NERR_Success )
{
return err;
}
LONG nValue = QueryStrNum( nlsValue, (LONG)QueryRange());
if ( nValue < 0 )
nValue = QueryValue();
SetValue( nValue );
Update();
return err;
}
/*********************************************************************
NAME: SPIN_SLE_STR::QueryStrNum
SYNOPSIS: Find the position of the given string within the array of
string.
ENTRY: NLS_STR & nlsStr - string to look for.
NLS_STR anlsStr[] - array of string
LONG cStr - number of string within the array
RETURN: The location of the given string within the array of string.
It will return -1 if the given string is not in the array
list.
HISTORY:
terryk 22-May-91 Created
*********************************************************************/
LONG SPIN_SLE_STR::QueryStrNum( const NLS_STR & nlsStr, LONG cStr )
{
for ( LONG i = 0; i < cStr; i++ )
{
if ( nlsStr.strcmp( _anlsStr[ i ] ) == 0 )
return i;
}
return -1;
}
/*********************************************************************
NAME: SPIN_SLE_STR::QueryContent
SYNOPSIS: Get the current value in the object
ENTRY: You can request the value in one of the following forms:
NLS_STR *pnlsStr - return as a nls string
EXIT: return the value to the data structure
HISTORY:
terryk 01-May-1991 Created
*********************************************************************/
APIERR SPIN_SLE_STR::QueryContent( NLS_STR * pnlsStr ) const
{
UIASSERT( pnlsStr != NULL );
UIASSERT( pnlsStr->QueryError() == NERR_Success );
* pnlsStr = _anlsStr[ QueryValue() ];
return pnlsStr->QueryError();
}
/*********************************************************************
NAME: SPIN_SLE_STR::SetStr
SYNOPSIS: set the window text to the given number
ENTRY: LONG iStringIndex - number to be set
HISTORY:
terryk 01-May-1991 Created
beng 13-Aug-1992 Hide and show caret appropriately
*********************************************************************/
VOID SPIN_SLE_STR::SetStr( LONG iStringIndex )
{
::HideCaret(WINDOW::QueryHwnd());
SetText( _anlsStr[ iStringIndex ] );
::ShowCaret(WINDOW::QueryHwnd());
}
/*********************************************************************
NAME: SPIN_SLE_STR::Update
SYNOPSIS: update the window text
NOTES: call SetNum to update the number
HISTORY:
terryk 01-May-1991 Created
beng 16-Oct-1991 Win32 conversion
beng 13-Aug-1992 Send EN_UPDATE and EN_CHANGE correctly
beng 16-Aug-1992 Disabled EN_UPDATE
*********************************************************************/
VOID SPIN_SLE_STR::Update()
{
// CODEWORK: this and SPIN_SLE_NUM::Update should share the
// below sendmessages. e.g. embed it in an CHANGEABLE_SPIN_ITEM::Update
// call and give the class another virtual for the SetStr/SetValue calls.
#if 0 // Nobody listens for this message, anyway
#if defined(WIN32)
::SendMessage( QueryOwnerHwnd(), WM_COMMAND,
MAKELONG(QueryCid(), EN_UPDATE), (LPARAM)SLE::QueryHwnd() );
#else
::SendMessage( QueryOwnerHwnd(), WM_COMMAND,
QueryCid(), MAKELONG( SLE::QueryHwnd(), EN_UPDATE ) );
#endif
#endif // disabled
SetStr( QueryValue() );
// Tell the spin group that we have been changed
// CODEWORK - roll this into BLT for proper portability.
#if defined(WIN32)
::SendMessage( QueryOwnerHwnd(), WM_COMMAND,
MAKELONG(QueryCid(), EN_CHANGE), (LPARAM)SLE::QueryHwnd() );
#else
::SendMessage( QueryOwnerHwnd(), WM_COMMAND,
QueryCid(), MAKELONG( SLE::QueryHwnd(), EN_CHANGE ) );
#endif
}
/*********************************************************************
NAME: SPIN_SLE_STR::OnChar
SYNOPSIS: function to be called if the WM_CHAR message is received.
ENTRY: CHAR_EVENT & event
HISTORY:
terryk 01-May-1991 Created
*********************************************************************/
BOOL SPIN_SLE_STR::OnChar( const CHAR_EVENT & event )
{
LONG iString = QueryAccCharPos( event.QueryChar() );
if ( iString == (-1) )
{
// cannot find it
CHANGEABLE_SPIN_ITEM::OnChar( event );
return TRUE;
}
else
{
SPIN_GROUP *pSB=(SPIN_GROUP *)SPIN_ITEM::QueryGroup();
pSB->SetModified( TRUE );
SetValue( iString );
Update();
SLE::SetControlValueFocus();
}
return TRUE;
}
/*********************************************************************
NAME: SPIN_SLE_STR::OnFocus
SYNOPSIS: select the whole string
ENTRY: FOCUS_EVENT & event
HISTORY:
terryk 29-May-91 Created
*********************************************************************/
BOOL SPIN_SLE_STR::OnFocus( const FOCUS_EVENT & event )
{
UNREFERENCED( event );
#if 0
SPIN_GROUP * psg = ( SPIN_GROUP * ) SPIN_ITEM::QueryGroup();
if ( ( psg != NULL ) && ! psg->IsActive() )
return FALSE;
#endif
SLE::SetControlValueFocus();
SPIN_GROUP *pSB=(SPIN_GROUP *)SPIN_ITEM::QueryGroup();
pSB->DoNewFocus((SPIN_ITEM *)this);
return FALSE;
}
/*********************************************************************
NAME: SPIN_SLE_STR::GetAccKey
SYNOPSIS: get the accelerated key - the first character of
each string
ENTRY: NLS_STR *pnlsStr - the accelerated key list
EXIT: NLS_STR *pnlsStr - the accelerated key list
HISTORY:
terryk 29-May-91 Created
*********************************************************************/
APIERR SPIN_SLE_STR::GetAccKey( NLS_STR * pnlsStr )
{
APIERR apierr = pnlsStr->QueryError();
if ( apierr != NERR_Success )
{
return apierr;
}
*pnlsStr = NULL;
apierr = pnlsStr->QueryError();
if ( apierr != NERR_Success )
{
return apierr;
}
for ( LONG i = 0; i < (LONG)QueryRange(); i++ )
{
ISTR istrFirstChar( _anlsStr[ i ] );
ISTR istrEndChar = istrFirstChar;
istrEndChar ++;
// CODEWORK: need AppendChar in NLS_STR
NLS_STR *pnlsFirstChar = _anlsStr[ i ].QuerySubStr( istrFirstChar,
istrEndChar );
UIASSERT( pnlsFirstChar != NULL );
apierr = pnlsFirstChar->QueryError();
if ( apierr != NERR_Success )
{
return apierr;
}
if ( pnlsFirstChar->QueryTextLength() == 0 )
pnlsStr->strcat( SZ(" ") );
else
pnlsStr->strcat( *pnlsFirstChar );
apierr = pnlsStr->QueryError();
if ( apierr != NERR_Success )
{
return apierr;
}
delete pnlsFirstChar;
}
pnlsStr->strupr();
return NERR_Success;
}
/*********************************************************************
NAME: SPIN_SLE_STR::QueryAccCharPos
SYNOPSIS: given a character. return the character position
in the accelator keys list depended on whether
the character is an accelerator key or not
ENTRY: WCHAR wcInput - character to be tested
EXIT: if the given character is one of the accelator key,
it will return the position. Otherwise, it will return 0.
HISTORY:
terryk 29-May-91 Created
beng 05-Mar-1992 Eliminate wsprintf calls; Unicode fixes
*********************************************************************/
LONG SPIN_SLE_STR::QueryAccCharPos( WCHAR wcInput )
{
NLS_STR nlsAccKey;
QueryAccKey( &nlsAccKey );
ASSERT( !!nlsAccKey );
ISTR istrAccKey( nlsAccKey );
// setup a circular search
INT iResult = (INT)QueryValue();
INT iOldIndex = iResult;
// Uppercase search char (this is really awkward)
WCHAR wcSearch;
{
NLS_STR nlsTmp;
nlsTmp.AppendChar(wcInput);
nlsTmp.strupr();
ASSERT(!!nlsTmp);
ISTR istrTmp(nlsTmp);
wcSearch = nlsTmp.QueryChar(istrTmp);
}
istrAccKey += iResult;
for (;;)
{
if ( iResult + 1 > nlsAccKey.QueryTextLength() )
{
iResult = 0;
istrAccKey.Reset();
}
else
{
iResult ++;
istrAccKey ++;
}
if ( wcSearch == nlsAccKey.QueryChar( istrAccKey ))
{
return iResult;
}
if ( iResult == iOldIndex )
{
return -1;
}
}
}
| [
"benjamin.barratt@icloud.com"
] | benjamin.barratt@icloud.com |
8811b72f2a87488e9f70aec4a1453f36a0cb5e32 | d7df0ea341b5e3e155b08c98119beec998f20524 | /threatexchange/tmk/cpp/io/tmkio.h | 69e6e9a5a2a518af2025c55393f6cf8cadb9a253 | [
"BSD-2-Clause",
"MIT"
] | permissive | meedan/alegre | 6c1ee60124f69b559854186d04ff9aff1efccd47 | 013b2b72607b80210076d772c93ed77f0e732ab2 | refs/heads/develop | 2023-08-24T23:21:02.372841 | 2023-08-08T13:19:57 | 2023-08-08T13:19:57 | 44,700,808 | 14 | 10 | MIT | 2023-09-14T20:35:17 | 2015-10-21T19:59:30 | C++ | UTF-8 | C++ | false | false | 3,412 | h | // ================================================================
// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
// ================================================================
// ================================================================
// Methods for reading/writing TMK file formats: .vstr/.feat/.tmk file
// headers, RGB frame-raster contents, and float-array contents.
// ================================================================
#ifndef TMKIO_H
#define TMKIO_H
#include <tmk/cpp/io/tmkiotypes.h>
#include <stdio.h>
#include <vector>
namespace facebook {
namespace tmk {
namespace io {
// ----------------------------------------------------------------
FILE* openFileOrDie(const char* filename, const char* mode, const char* argv0);
// ----------------------------------------------------------------
TMKFramewiseAlgorithm algoFromMagic(char magic[TMK_MAGIC_LENGTH]);
TMKFramewiseAlgorithm algoFromMagicOrDie(
char* argv0,
char magic[TMK_MAGIC_LENGTH],
char* fromFileName);
void reportUnrecognizedAlgorithmMagic(
char* argv0,
char magic[4],
char* fromFileName);
bool algoToMagic(TMKFramewiseAlgorithm algorithm, char magic[TMK_MAGIC_LENGTH]);
TMKFramewiseAlgorithm algoFromLowercaseName(std::string name);
std::string algorithmToName(TMKFramewiseAlgorithm algorithm);
// ----------------------------------------------------------------
bool readDecodedVideoStreamFileHeader(
FILE* fp,
DecodedVideoStreamFileHeader* pheader,
const char* programName);
bool readFrameFeaturesFileHeader(
FILE* fp,
FrameFeaturesFileHeader* pheader,
TMKFramewiseAlgorithm& algorithm,
const char* programName);
bool readFeatureVectorFileHeader(
FILE* fp,
FeatureVectorFileHeader* pheader,
TMKFramewiseAlgorithm& algorithm,
const char* programName);
// ----------------------------------------------------------------
bool writeDecodedVideoStreamFileHeader(
FILE* fp,
int frameHeight,
int frameWidth,
int framesPerSecond,
const char* programName);
bool writeFrameFeaturesFileHeader(
FILE* fp,
TMKFramewiseAlgorithm algorithm,
int frameFeatureDimension,
int framesPerSecond,
const char* programName);
bool writeFeatureVectorFileHeader(
FILE* fp,
TMKFramewiseAlgorithm algorithm, // provenance
int framesPerSecond, // provenance
int numPeriods, // a.k.a. P
int numFourierCoefficients, // a.k.a m
int frameFeatureDimension, // a.k.a d
int frameFeatureCount,
const char* programName);
// ----------------------------------------------------------------
bool checkMagic(char actual[4], char* expected, const char* programName);
char makePrintable(char c);
// ----------------------------------------------------------------
// Precondition: buffer is already allocated.
bool readRGBTriples(
unsigned char* buffer,
int height,
int width,
FILE* fp,
bool& eof);
// ----------------------------------------------------------------
// Precondition: vector is already allocated.
bool readFloatVector(std::vector<float>& vector, FILE* fp, bool& eof);
bool writeFloatVector(const std::vector<float>& vector, FILE* fp);
bool readIntVector(std::vector<int>& vector, FILE* fp);
bool writeIntVector(const std::vector<int>& vector, FILE* fp);
} // namespace io
} // namespace tmk
} // namespace facebook
#endif // TMKIO_H
| [
"noreply@github.com"
] | noreply@github.com |
06750bd094aad9c770bea8dd1147398213b6034c | c681508bf3ad18a832389c402a5029acf6e8c72f | /sparse-iter/control/magma_dmcsrpass_gpu.cpp | af83aa5a437351120a0d242f9ef4db5457ab6c87 | [] | no_license | xulunfan/magma | 6f058ed0e288ecfc88a4ecc3711ad17faf74cb18 | b4e228e14cc1046861c8f38803743d784b06b9bf | refs/heads/master | 2021-01-21T15:50:21.484822 | 2016-02-10T15:08:42 | 2016-02-10T15:08:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,420 | cpp | /*
-- MAGMA (version 2.0.0) --
Univ. of Tennessee, Knoxville
Univ. of California, Berkeley
Univ. of Colorado, Denver
@date February 2016
@generated from sparse-iter/control/magma_zmcsrpass_gpu.cpp normal z -> d, Tue Feb 9 16:05:48 2016
@author Hartwig Anzt
*/
// in this file, many routines are taken from
// the IO functions provided by MatrixMarket
#include "magmasparse_internal.h"
/**
Purpose
-------
Passes a CSR matrix to MAGMA (located on DEV).
Arguments
---------
@param[in]
m magma_int_t
number of rows
@param[in]
n magma_int_t
number of columns
@param[in]
row magmaIndex_ptr
row pointer
@param[in]
col magmaIndex_ptr
column indices
@param[in]
val magmaDouble_ptr
array containing matrix entries
@param[out]
A magma_d_matrix*
matrix in magma sparse matrix format
@param[in]
queue magma_queue_t
Queue to execute in.
@ingroup magmasparse_daux
********************************************************************/
extern "C"
magma_int_t
magma_dcsrset_gpu(
magma_int_t m,
magma_int_t n,
magmaIndex_ptr row,
magmaIndex_ptr col,
magmaDouble_ptr val,
magma_d_matrix *A,
magma_queue_t queue )
{
A->num_rows = m;
A->num_cols = n;
magma_index_t nnz;
magma_index_getvector( 1, row+m, 1, &nnz, 1, queue );
A->nnz = (magma_int_t) nnz;
A->storage_type = Magma_CSR;
A->memory_location = Magma_DEV;
A->dval = val;
A->dcol = col;
A->drow = row;
return MAGMA_SUCCESS;
}
/**
Purpose
-------
Passes a MAGMA matrix to CSR structure (located on DEV).
Arguments
---------
@param[in]
A magma_d_matrix
magma sparse matrix in CSR format
@param[out]
m magma_int_t
number of rows
@param[out]
n magma_int_t
number of columns
@param[out]
row magmaIndex_ptr
row pointer
@param[out]
col magmaIndex_ptr
column indices
@param[out]
val magmaDouble_ptr
array containing matrix entries
@param[in]
queue magma_queue_t
Queue to execute in.
@ingroup magmasparse_daux
********************************************************************/
extern "C"
magma_int_t
magma_dcsrget_gpu(
magma_d_matrix A,
magma_int_t *m,
magma_int_t *n,
magmaIndex_ptr *row,
magmaIndex_ptr *col,
magmaDouble_ptr *val,
magma_queue_t queue )
{
magma_int_t info = 0;
magma_d_matrix A_DEV={Magma_CSR}, A_CSR={Magma_CSR};
if ( A.memory_location == Magma_DEV && A.storage_type == Magma_CSR ) {
*m = A.num_rows;
*n = A.num_cols;
*val = A.dval;
*col = A.dcol;
*row = A.drow;
} else {
CHECK( magma_dmconvert( A, &A_CSR, A.storage_type, Magma_CSR, queue ));
CHECK( magma_dmtransfer( A_CSR, &A_DEV, A.memory_location, Magma_DEV, queue ));
magma_dcsrget_gpu( A_DEV, m, n, row, col, val, queue );
}
cleanup:
magma_dmfree( &A_CSR, queue );
magma_dmfree( &A_DEV, queue );
return info;
}
| [
"maxhutch@gmail.com"
] | maxhutch@gmail.com |
7261f3934a36db259c4b031560796ff78622e431 | e13be1afb7605a58d7c846445b71ed8687a9382e | /btcacoinlinux/src/primitives/block.cpp | c8f7d76141382cd1f8ea6bfcd7aa566546aca3aa | [
"MIT"
] | permissive | bitcoinagain/bitcoinagain | 3042086ea8f3f9036b6cf85b8afc49403eab8a79 | a7493d08dbdbad0f59e8c47c5ab7f03dca84fbb2 | refs/heads/master | 2023-02-06T22:05:39.220131 | 2020-12-29T10:55:28 | 2020-12-29T10:55:28 | 283,498,307 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 941 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2015 The Bitcoinagain Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "primitives/block.h"
#include "hash.h"
#include "tinyformat.h"
#include "utilstrencodings.h"
#include "crypto/common.h"
uint256 CBlockHeader::GetHash() const
{
return SerializeHash(*this);
}
std::string CBlock::ToString() const
{
std::stringstream s;
s << strprintf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%u)\n",
GetHash().ToString(),
nVersion,
hashPrevBlock.ToString(),
hashMerkleRoot.ToString(),
nTime, nBits, nNonce,
vtx.size());
for (unsigned int i = 0; i < vtx.size(); i++)
{
s << " " << vtx[i].ToString() << "\n";
}
return s.str();
}
| [
"wangyh@weherepost.com"
] | wangyh@weherepost.com |
d2d92a23414630a7f7fc3cbcfb28f994d9519c38 | 6cd69d24276d418be9fb3ad5fbb850bdcaca9f7e | /oss_src/sframe_query_engine/util/aggregates.hpp | 6cb5d73eaad8410671e3078fb8e782e80a52340a | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | charles2648/SFrame | e8cd14074932635af067aa20a86d1a9cbf7cf698 | 43fdd3ed9fde4ec0f26d548b5f1eebb4cdf1bea5 | refs/heads/master | 2021-01-18T11:23:21.447110 | 2016-03-16T08:51:56 | 2016-03-16T08:51:56 | 54,029,970 | 1 | 0 | null | 2016-03-16T12:29:02 | 2016-03-16T12:29:02 | null | UTF-8 | C++ | false | false | 3,411 | hpp | /**
* Copyright (C) 2015 Dato, Inc.
* All rights reserved.
*
* This software may be modified and distributed under the terms
* of the BSD license. See the LICENSE file for details.
*/
#ifndef GRAPHLAB_SFRAME_QUERY_ENGINE_UTIL_AGGREGATES_HPP
#define GRAPHLAB_SFRAME_QUERY_ENGINE_UTIL_AGGREGATES_HPP
#include <sframe/sframe.hpp>
#include <serialization/serialization_includes.hpp>
#include <sframe_query_engine/operators/reduce.hpp>
#include <sframe_query_engine/planning/planner.hpp>
namespace graphlab {
namespace query_eval {
/**
* Implements a generic aggregator
*/
template <typename T, typename AggregateFunctionType>
class generic_aggregator: public group_aggregate_value {
public:
generic_aggregator():value(T()) { }
generic_aggregator(AggregateFunctionType fn, const T& t):
fn(fn), initial_value(t), value(t) { }
/// Returns a new empty instance of sum with the same type
group_aggregate_value* new_instance() const {
generic_aggregator* ret =
new generic_aggregator(fn, initial_value);
return ret;
}
/// Adds a new element to be summed
void add_element_simple(const flexible_type& flex) {
fn(flex, value);
}
/// Emits the result
flexible_type emit() const {
// we just emit strings
std::stringstream strm;
oarchive oarc(strm);
oarc << value;
return strm.str();
}
void combine(const group_aggregate_value& flex) {
ASSERT_TRUE(false);
}
bool support_type(flex_type_enum) const {
ASSERT_TRUE(false);
return false;
}
/// Serializer
void save(oarchive& oarc) const {
ASSERT_TRUE(false);
}
/// Deserializer
void load(iarchive& iarc) {
ASSERT_TRUE(false);
}
std::string name() const {
ASSERT_TRUE(false);
return "";
}
private:
AggregateFunctionType fn;
T initial_value;
T value;
};
/**
* Performs a reduction on input in parallel, this function decides the
* degree of parallelism, usually depend on number of CPUs.
*
* \param input The iterator supports parallel batch reading of items
* \param reduce_fn The reduction function to use. This must be of the form
* bool f(const array_value_type&, reduction_type&).
* \param init The initial value to use in the reduction
*
* \tparam ResultType The type of the intermediate result. Must be serializable
* \tparam ReduceFunctionType The result type of each reduction.
* \tparam AggregateFunctionType The type of the reduce function
*
*
*/
template <typename ResultType,
typename ReduceFunctionType,
typename AggregateFunctionType>
ResultType reduce(
std::shared_ptr<planner_node> input,
ReduceFunctionType reduce_fn,
AggregateFunctionType aggregate_fn,
ResultType init = ResultType()) {
generic_aggregator<ResultType, ReduceFunctionType> agg(reduce_fn, init);
auto output = op_reduce::make_planner_node(input, agg, flex_type_enum::STRING);
sframe sf = planner().materialize(output);
auto sfreader = sf.get_reader(1);
auto iter = sfreader->begin(0);
ResultType result = init;
ResultType curval;
while(iter != sfreader->end(0)) {
// data is serialized in an archive:w
std::string st = (*iter)[0];
iarchive iarc(st.c_str(), st.length());
iarc >> curval;
aggregate_fn(curval, result);
++iter;
}
return result;
}
} // namespace query_eval
} // namespace graphlab
#endif
| [
"toby@dato.com"
] | toby@dato.com |
656d3b0397198b79474be95a4de78e145ce8b00e | 329daf9c66c87da480e47e1dc1e78a507d475e22 | /LeetCode/header/MeetingRoomII.h | c3f953cfeb9f12abff5f1c4f18308879a37f9a57 | [] | no_license | guancongyi/LeetCode | 716edae5b5d802a9f95ae961b8724c0fc5a554b6 | 0a399bece086aac9adf8cb3a42c1d03e942b316c | refs/heads/master | 2020-04-14T21:57:43.465583 | 2019-10-19T15:49:02 | 2019-10-19T15:49:02 | 164,040,899 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,107 | h | /*
First sort the vector according to starting time
Then, use min heap to keep track of the end time
Find the room that can be vacate first when allocating.
*/
class myComparator
{
public:
int operator() (const vector<int>& v1, const vector<int>& v2)
{
return v2[1] < v1[1];
}
};
class MeetingRoomIISolution {
public:
int minMeetingRooms(vector<vector<int>>& intervals) {
// sort base on starting time
sort(intervals.begin(), intervals.end());
// add to min heap
int rooms = 0;
priority_queue<vector<int>, vector<vector<int>>, myComparator> pq;
vector<int> min_, cur;
for (size_t i = 0; i < intervals.size(); i++) {
cur = intervals[i];
pq.push(cur);
min_ = pq.top();
if (cur[0] < min_[1]) { rooms++; }
if (cur[0] >= min_[1]) { pq.pop(); }
}
return rooms;
}
int minMeetingRoomsAns(vector<vector<int>>& intervals) {
map<int, int> changes;
for (auto i : intervals) {
changes[i[0]] += 1;
changes[i[1]] -= 1;
}
int rooms = 0, maxrooms = 0;
for (auto change : changes)
maxrooms = max(maxrooms, rooms += change.second);
return maxrooms;
}
};
| [
"congyiguan@gmail.com"
] | congyiguan@gmail.com |
9798302f4cfdc02cad15be6f7819f26f20a4f0ed | 779e1f5e1140e0c09fabc9c286e590ecd55ed612 | /src/Game.cpp | 2de8d5ac3a264e4a9f207dede96b1833ebf65123 | [] | no_license | maro-n/MyGame | 02a80545c755a707d2e87a2076f271ecf06aeb0b | dc5ea6dedec9fd04a6685c2fea3e122293b7ab97 | refs/heads/master | 2021-01-10T07:12:24.370245 | 2015-07-14T06:57:11 | 2015-07-14T06:57:11 | 36,990,607 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 587 | cpp |
#include "Game.h"
cGame::cGame(){
isChange = false;
}
void cGame::init(){
player.setup();
enemy.setup();
}
void cGame::setup(){
player.setup();
enemy.setup();
}
void cGame::keyDown(KeyEvent event){
player.keyDown(event);
if (event.getChar() == 'r'){
isChange = true;
}
}
void cGame::keyUp(KeyEvent event){
player.keyUp(event);
}
void cGame::change(int& scene_change){
if (isChange){
scene_change = RESULT;
isChange = false;
}
}
void cGame::update(){
enemy.update();
player.update();
}
void cGame::draw(){
enemy.draw();
player.draw();
}
| [
"with.tennis.win.0406@gmail.com"
] | with.tennis.win.0406@gmail.com |
da0d119044e5ba9f5e63f3ec9dd575dee09ba6ff | 371178fa6768ca13dda499a21fa1f04f0430a43f | /由前序与中序结果重建二叉树.hpp | a6550b95986cdd5b11d749666025e070f2a8aeb8 | [] | no_license | Aaronlanni/practice | ed55be9d2cc788da3f91af32de78916a129415bd | 6389566fc2b6321a4826a832fa35d2a15f79b3ac | refs/heads/master | 2020-03-18T21:35:48.591147 | 2018-09-11T12:46:33 | 2018-09-11T12:46:33 | 135,288,755 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,161 | hpp | //由前序遍历与中序遍历的结果重建二叉树
pNode RebulitBindaryTree(T*PreResult, size_t PreLen, T*InResult, size_t InLen)
{
if (PreLen != InLen || PreResult == NULL || InResult == NULL)
return NULL;
int index = 0;
_pRoot = _RebulitBindaryTree1(PreResult, PreLen, InResult, 0, InLen, index);//此处给出区间的范围
return _pRoot;
}
pNode _RebulitBindaryTree1(T*PreResult, int PreSize, T*PreEnd, int left, int right, int &index)
{
int i = 0;
pNode pRoot = new Node(PreResult[index]);
if (left > right || PreResult == NULL || PreEnd == NULL)
return pRoot;
if ((index + 1) > right)
return pRoot;
else
{
for (; i < right; ++i)
{
//确定左子树的范围[0,i),此时i值相等的地方就是在中序遍历中的根节点
if (PreEnd[i] == PreResult[index])
break;
}
int rootIdxOfMid = i;
if (i > 0)
{
//重建左子树
pRoot->_pLeft = _RebulitBindaryTree1(PreResult, PreSize, PreEnd, index, rootIdxOfMid, ++index);
}
if (i < right)
{
//重建右子树
pRoot->_pRight = _RebulitBindaryTree1(PreResult, PreSize, PreEnd, rootIdxOfMid + 1, right, ++index);
}
}
return pRoot;
}
| [
"1099384248@qq.com"
] | 1099384248@qq.com |
8aa1c0f2f2ac567a246a2573f66f0769a720159b | a272c9417d443c1a9355d5d119bbe209c270eedd | /src/hvpp/ia32/cpuid/cpuid_eax_01.h | cd05b0de9a796fb8c23ad9081b27a82552bd4dd4 | [
"MIT",
"LicenseRef-scancode-free-unknown",
"BSD-2-Clause"
] | permissive | tandasat/hvpp | 4a3b19105df61ba2a0e35bec007176c8225d5d5b | 204f8f8ea431903bedbe3038cc9dc5b76fecba0b | refs/heads/master | 2020-03-26T17:09:16.172662 | 2018-10-07T17:02:35 | 2018-10-07T17:02:35 | 145,144,533 | 3 | 1 | MIT | 2018-08-17T16:42:22 | 2018-08-17T16:42:22 | null | UTF-8 | C++ | false | false | 4,033 | h | #pragma once
#include <cstdint>
namespace ia32 {
struct cpuid_eax_01
{
union
{
struct
{
int cpu_info[4];
};
struct
{
uint32_t eax;
uint32_t ebx;
uint32_t ecx;
uint32_t edx;
};
struct
{
union
{
uint32_t flags;
struct
{
uint32_t stepping_id : 4;
uint32_t model : 4;
uint32_t family_id : 4;
uint32_t processor_type : 2;
uint32_t reserved1 : 2;
uint32_t extended_model_id : 4;
uint32_t extended_family_id : 8;
uint32_t reserved2 : 4;
};
} version_information;
union
{
uint32_t flags;
struct
{
uint32_t brand_index : 8;
uint32_t clflush_line_size : 8;
uint32_t max_addressable_ids : 8;
uint32_t initial_apic_id : 8;
};
} additional_information;
union
{
uint32_t flags;
struct
{
uint32_t streaming_simd_extensions_3 : 1;
uint32_t pclmulqdq_instruction : 1;
uint32_t ds_area_64bit_layout : 1;
uint32_t monitor_mwait_instruction : 1;
uint32_t cpl_qualified_debug_store : 1;
uint32_t virtual_machine_extensions : 1;
uint32_t safer_mode_extensions : 1;
uint32_t enhanced_intel_speedstep_technology : 1;
uint32_t thermal_monitor_2 : 1;
uint32_t supplemental_streaming_simd_extensions_3 : 1;
uint32_t l1_context_id : 1;
uint32_t silicon_debug : 1;
uint32_t fma_extensions : 1;
uint32_t cmpxchg16b_instruction : 1;
uint32_t xtpr_update_control : 1;
uint32_t perfmon_and_debug_capability : 1;
uint32_t reserved1 : 1;
uint32_t process_context_identifiers : 1;
uint32_t direct_cache_access : 1;
uint32_t sse41_support : 1;
uint32_t sse42_support : 1;
uint32_t x2apic_support : 1;
uint32_t movbe_instruction : 1;
uint32_t popcnt_instruction : 1;
uint32_t tsc_deadline : 1;
uint32_t aesni_instruction_extensions : 1;
uint32_t xsave_xrstor_instruction : 1;
uint32_t osx_save : 1;
uint32_t avx_support : 1;
uint32_t half_precision_conversion_instructions : 1;
uint32_t rdrand_instruction : 1;
uint32_t reserved2 : 1;
};
} feature_information_ecx;
union
{
uint32_t flags;
struct
{
uint32_t floating_point_unit_on_chip : 1;
uint32_t virtual_8086_mode_enhancements : 1;
uint32_t debugging_extensions : 1;
uint32_t page_size_extension : 1;
uint32_t timestamp_counter : 1;
uint32_t rdmsr_wrmsr_instructions : 1;
uint32_t physical_address_extension : 1;
uint32_t machine_check_exception : 1;
uint32_t cmpxchg8b : 1;
uint32_t apic_on_chip : 1;
uint32_t reserved1 : 1;
uint32_t sysenter_sysexit_instructions : 1;
uint32_t memory_type_range_registers : 1;
uint32_t page_global_bit : 1;
uint32_t machine_check_architecture : 1;
uint32_t conditional_move_instructions : 1;
uint32_t page_attribute_table : 1;
uint32_t page_size_extension_36bit : 1;
uint32_t processor_serial_number : 1;
uint32_t clflush : 1;
uint32_t reserved2 : 1;
uint32_t debug_store : 1;
uint32_t thermal_control_msrs_for_acpi : 1;
uint32_t mmx_support : 1;
uint32_t fxsave_fxrstor_instructions : 1;
uint32_t sse_support : 1;
uint32_t sse2_support : 1;
uint32_t self_snoop : 1;
uint32_t hyper_threading_technology : 1;
uint32_t thermal_monitor : 1;
uint32_t reserved3 : 1;
uint32_t pending_break_enable : 1;
};
} feature_information_edx;
};
};
};
}
| [
"w.benny@outlook.com"
] | w.benny@outlook.com |
0f1566bf0b3dd3338bc4e6949f1f3e0034ec5971 | ca8d40d52a3d8a0e50d3630cd57b892e6ca4a9fa | /src/pynuitrack.cpp | 002966f442a35dd683b570434f0d2aa18ac2e98f | [
"MIT"
] | permissive | soltrinox/pynuitrack | 310ad25bbf0cd03b38086a5116883d3907ec6375 | 5174341ed71100790b111bd093ecb10ce735d714 | refs/heads/master | 2022-02-17T22:55:01.342794 | 2019-09-12T17:22:48 | 2019-09-12T17:22:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 18,642 | cpp | /**
* @file pynuitrack.cpp
* @author Silas Alves (silas.alves)
* @brief Contains the Nuitrack and NuitrackException claeses.
* @version 0.1
* @date 2019-09-03
*
* @copyright Copyright (c) 2019
*
* MIT License
*
* Copyright (c) 2019 Silas Franco dos Reis Alves
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "pynuitrack.hpp"
#include <boost/algorithm/string.hpp>
namespace nt = tdv::nuitrack;
namespace bp = boost::python;
namespace np = boost::python::numpy;
NuitrackException::NuitrackException(std::string message)
{
this->message = message;
}
const char *NuitrackException::what() const throw()
{
return this->message.c_str();
}
NuitrackException::~NuitrackException() throw()
{
}
void translateException(NuitrackException const &e)
{
PyErr_SetString(PyExc_RuntimeError, e.what());
}
Nuitrack::Nuitrack()
{
_pyDepthCallback = NULL;
_pyColorCallback = NULL;
_pySkeletonCallback = NULL;
_pyHandsCallback = NULL;
_pyUserCallback = NULL;
_pyGestureCallback = NULL;
_pyIssueCallback = NULL;
_pyFaceCallback = NULL;
_yaml = bp::import("yaml");
_collections = bp::import("collections");
_namedtuple = _collections.attr("namedtuple");
bp::list fieldsSkelResult;
fieldsSkelResult.append("timestamp");
fieldsSkelResult.append("skeleton_num");
fieldsSkelResult.append("skeletons");
_SkelResult = _namedtuple("SkeletonResult", fieldsSkelResult);
bp::list fieldsSkeleton;
fieldsSkeleton.append("userId");
fieldsSkeleton.append("head");
fieldsSkeleton.append("neck");
fieldsSkeleton.append("torso");
fieldsSkeleton.append("waist");
fieldsSkeleton.append("left_collar");
fieldsSkeleton.append("left_shoulder");
fieldsSkeleton.append("left_elbow");
fieldsSkeleton.append("left_wrist");
fieldsSkeleton.append("left_hand");
fieldsSkeleton.append("right_collar");
fieldsSkeleton.append("right_shoulder");
fieldsSkeleton.append("right_elbow");
fieldsSkeleton.append("right_wrist");
fieldsSkeleton.append("right_hand");
fieldsSkeleton.append("left_hip");
fieldsSkeleton.append("left_knee");
fieldsSkeleton.append("left_ankle");
fieldsSkeleton.append("right_hip");
fieldsSkeleton.append("right_knee");
fieldsSkeleton.append("right_ankle");
_Skeleton = _namedtuple("Skeleton", fieldsSkeleton);
bp::list fieldsJoint;
fieldsJoint.append("type");
fieldsJoint.append("confidence");
fieldsJoint.append("real");
fieldsJoint.append("projection");
fieldsJoint.append("orientation");
_Joint = _namedtuple("Joint", fieldsJoint);
bp::list fieldsUserHands;
fieldsUserHands.append("userId");
fieldsUserHands.append("left");
fieldsUserHands.append("right");
_UserHands = _namedtuple("UserHands", fieldsUserHands);
bp::list fieldsHand;
fieldsHand.append("click");
fieldsHand.append("pressure");
fieldsHand.append("proj");
fieldsHand.append("real");
_Hand = _namedtuple("Hand", fieldsHand);
bp::list fieldsGesture;
fieldsGesture.append("userId");
fieldsGesture.append("type");
_Gesture = _namedtuple("Gesture", fieldsGesture);
bp::list fieldsFBIssue;
fieldsFBIssue.append("userId");
fieldsFBIssue.append("left");
fieldsFBIssue.append("right");
fieldsFBIssue.append("top");
_FrameBorderIssue = _namedtuple("FrameBorderIssue", fieldsFBIssue);
bp::list fieldsOIssue;
fieldsOIssue.append("userId");
_OcclusionIssue = _namedtuple("OcclusionIssue", fieldsOIssue);
}
void Nuitrack::init(std::string configPath)
{
// Initialize Nuitrack
try
{
nt::Nuitrack::init(configPath);
}
catch (const nt::Exception &e)
{
throw NuitrackException("Could not initialize Nuitrack");
}
// These two settings are required to enable face tracking.
nt::Nuitrack::setConfigValue("Faces.ToUse", "true");
nt::Nuitrack::setConfigValue("DepthProvider.Depth2ColorRegistration", "true");
_depthSensor = nt::DepthSensor::create();
_depthSensor->connectOnNewFrame(
std::bind(&Nuitrack::_onNewDepthFrame, this, std::placeholders::_1));
_outputModeDepth = _depthSensor->getOutputMode();
_colorSensor = nt::ColorSensor::create();
_colorSensor->connectOnNewFrame(
std::bind(&Nuitrack::_onNewRGBFrame, this, std::placeholders::_1));
_outputModeColor = _colorSensor->getOutputMode();
_handTracker = nt::HandTracker::create();
_handTracker->connectOnUpdate(
std::bind(&Nuitrack::_onHandUpdate, this, std::placeholders::_1));
_userTracker = nt::UserTracker::create();
_userTracker->connectOnUpdate(
std::bind(&Nuitrack::_onUserUpdate, this, std::placeholders::_1));
_skeletonTracker = nt::SkeletonTracker::create();
_skeletonTracker->connectOnUpdate(
std::bind(&Nuitrack::_onSkeletonUpdate, this, std::placeholders::_1));
_gestureRecognizer = nt::GestureRecognizer::create();
_gestureRecognizer->connectOnNewGestures(
std::bind(&Nuitrack::_onNewGesture, this, std::placeholders::_1));
_onIssuesUpdateHandler = nt::Nuitrack::connectOnIssuesUpdate(
std::bind(&Nuitrack::_onIssuesUpdate, this, std::placeholders::_1));
// Start Nuitrack
try
{
nt::Nuitrack::run();
}
catch (const nt::Exception &e)
{
std::string msg("Nuitrack update failed: ");
msg += exceptionType_str[e.type()];
throw NuitrackException(msg);
}
}
void Nuitrack::update()
{
try
{
nt::Nuitrack::waitUpdate(_skeletonTracker);
}
catch (nt::LicenseNotAcquiredException &e)
{
throw NuitrackException("License not acquired.");
}
catch (const nt::Exception &e)
{
std::string msg("Nuitrack update failed: ");
msg += exceptionType_str[e.type()];
throw NuitrackException(msg);
}
}
void Nuitrack::setDepthCallback(PyObject *callable)
{
_pyDepthCallback = callable;
}
void Nuitrack::setColorCallback(PyObject *callable)
{
_pyColorCallback = callable;
}
void Nuitrack::setSkeletonCallback(PyObject *callable)
{
_pySkeletonCallback = callable;
}
void Nuitrack::setFaceCallback(PyObject *callable)
{
_pyFaceCallback = callable;
}
void Nuitrack::setHandsCallback(PyObject *callable)
{
_pyHandsCallback = callable;
}
void Nuitrack::Nuitrack::setUserCallback(PyObject *callable)
{
_pyUserCallback = callable;
}
void Nuitrack::setGestureCallback(PyObject *callable)
{
_pyGestureCallback = callable;
}
void Nuitrack::setIssueCallback(PyObject *callable)
{
_pyIssueCallback = callable;
}
void Nuitrack::_onIssuesUpdate(nt::IssuesData::Ptr issuesData)
{
if (_pyIssueCallback && issuesData)
{
bp::list listIssues;
for (int userId = 0; userId < 8; userId++)
{
auto issueFB = issuesData->getUserIssue<nt::FrameBorderIssue>(userId);
if (issueFB)
listIssues.append(_FrameBorderIssue(userId,
issueFB->isLeft(),
issueFB->isRight(),
issueFB->isTop()));
auto issueOcc = issuesData->getUserIssue<nt::OcclusionIssue>(userId);
if (issueOcc)
listIssues.append(_OcclusionIssue(userId));
}
if (bp::len(listIssues))
bp::call<void>(_pyIssueCallback, listIssues);
}
}
void Nuitrack::_onNewGesture(nt::GestureData::Ptr gestureData)
{
if (_pyGestureCallback)
{
auto gestures = gestureData->getGestures();
bp::list listGest;
for (nt::Gesture gest : gestures)
{
listGest.append(_Gesture(gest.userId, gest.type));
}
bp::call<void>(_pyGestureCallback, listGest);
}
}
void Nuitrack::_onUserUpdate(nt::UserFrame::Ptr frame)
{
if (_pyUserCallback != NULL)
{
const uint16_t *depthPtr = frame->getData();
int nCols = frame->getCols();
int nRows = frame->getRows();
np::ndarray npData = np::from_data(
depthPtr, _dtUInt16,
bp::make_tuple(nRows, nCols),
bp::make_tuple(nCols * sizeof(uint16_t), sizeof(uint16_t)),
bp::object());
bp::call<void>(_pyUserCallback, npData.copy());
}
}
bp::api::object Nuitrack::_getJointData(nt::Joint joint)
{
float fReal[] = {joint.real.x, joint.real.y, joint.real.z};
np::ndarray real = np::from_data(fReal, _dtFloat,
bp::make_tuple(3),
bp::make_tuple(sizeof(float)),
bp::object());
float fProj[] = {joint.proj.x * _outputModeColor.xres,
joint.proj.y * _outputModeColor.yres,
joint.proj.z};
np::ndarray proj = np::from_data(fProj, _dtFloat,
bp::make_tuple(3),
bp::make_tuple(sizeof(float)),
bp::object());
np::ndarray orientation = np::from_data(
joint.orient.matrix, _dtFloat,
bp::make_tuple(3, 3),
bp::make_tuple(3 * sizeof(float), sizeof(float)),
bp::object());
return _Joint(joint.type,
joint.confidence,
real.copy(),
proj.copy(),
orientation.copy());
}
void Nuitrack::_onSkeletonUpdate(nt::SkeletonData::Ptr userSkeletons)
{
if (_pySkeletonCallback)
{
bp::list listSkel;
auto skeletons = userSkeletons->getSkeletons();
for (nt::Skeleton skel : skeletons)
{
bp::list listJoint;
listJoint.append(skel.id);
listJoint.append(_getJointData(skel.joints[nt::JOINT_HEAD]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_NECK]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_TORSO]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_WAIST]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_LEFT_COLLAR]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_LEFT_SHOULDER]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_LEFT_ELBOW]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_LEFT_WRIST]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_LEFT_HAND]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_RIGHT_COLLAR]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_RIGHT_SHOULDER]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_RIGHT_ELBOW]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_RIGHT_WRIST]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_RIGHT_HAND]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_LEFT_HIP]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_LEFT_KNEE]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_LEFT_ANKLE]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_RIGHT_HIP]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_RIGHT_KNEE]));
listJoint.append(_getJointData(skel.joints[nt::JOINT_RIGHT_ANKLE]));
listSkel.append(_Skeleton.attr("_make")(listJoint));
}
auto data = _SkelResult(
userSkeletons->getTimestamp(),
userSkeletons->getNumSkeletons(),
listSkel);
bp::call<void>(_pySkeletonCallback, data);
}
if (_pyFaceCallback)
{
std::string faceInfo = nt::Nuitrack::getInstancesJson();
// Remove the quotes from the JSON file so the (un)quoted numbers can
// be read as int or float. Uses PyYAML for parsing.
boost::replace_all(faceInfo, "\"", "");
bp::call<void>(_pyFaceCallback, _yaml.attr("load")(faceInfo));
}
}
void Nuitrack::_onNewDepthFrame(nt::DepthFrame::Ptr frame)
{
if (_pyDepthCallback != NULL)
{
const uint16_t *depthPtr = frame->getData();
int nCols = frame->getCols();
int nRows = frame->getRows();
np::ndarray npData = np::from_data(
depthPtr, _dtUInt16,
bp::make_tuple(nRows, nCols),
bp::make_tuple(nCols * sizeof(uint16_t), sizeof(uint16_t)),
bp::object());
bp::call<void>(_pyDepthCallback, npData.copy());
}
}
void Nuitrack::_onNewRGBFrame(nt::RGBFrame::Ptr frame)
{
if (_pyColorCallback != NULL)
{
const uint8_t *colorPtr = (uint8_t *)frame->getData();
int nCols = frame->getCols();
int nRows = frame->getRows();
np::ndarray npData = np::from_data(
colorPtr, _dtUInt8,
bp::make_tuple(nRows, nCols, 3),
bp::make_tuple(nCols * 3 * sizeof(uint8_t), 3 * sizeof(uint8_t), sizeof(uint8_t)),
bp::object());
bp::call<void>(_pyColorCallback, npData.copy());
}
}
bp::api::object Nuitrack::_getHandData(nt::Hand::Ptr hand)
{
if (hand && hand->x != -1)
{
float fProj[] = {hand->x * _outputModeColor.xres,
hand->y * _outputModeColor.yres};
np::ndarray proj = np::from_data(fProj, _dtFloat,
bp::make_tuple(2),
bp::make_tuple(sizeof(float)),
bp::object());
float fReal[] = {hand->xReal, hand->yReal, hand->zReal};
np::ndarray real = np::from_data(fReal, _dtFloat,
bp::make_tuple(3),
bp::make_tuple(sizeof(float)),
bp::object());
return _Hand(hand->click, hand->pressure, proj.copy(), real.copy());
}
else
return bp::object();
}
// Callback for the hand data update event
void Nuitrack::_onHandUpdate(nt::HandTrackerData::Ptr handData)
{
if (_pyHandsCallback && handData)
{
bp::list listUserHands;
for (nt::UserHands hands : handData->getUsersHands())
{
auto data = _UserHands(
hands.userId,
_getHandData(hands.leftHand),
_getHandData(hands.rightHand));
listUserHands.append(data);
}
auto data = bp::make_tuple(
handData->getTimestamp(),
handData->getNumUsers(),
listUserHands);
bp::call<void>(_pyHandsCallback, data);
}
}
void Nuitrack::release()
{
nt::Nuitrack::release();
}
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(nt_init_overloads, Nuitrack::init, 0, 1)
BOOST_PYTHON_MODULE(pynuitrack)
{
Py_Initialize();
np::initialize();
bp::register_exception_translator<NuitrackException>(&translateException);
bp::register_exception_translator<NuitrackInitFail>(&translateException);
bp::enum_<nt::GestureType>("GestureType")
.value("waving", nt::GESTURE_WAVING)
.value("swipe_left", nt::GESTURE_SWIPE_LEFT)
.value("swipe_right", nt::GESTURE_SWIPE_RIGHT)
.value("swipe_up", nt::GESTURE_SWIPE_UP)
.value("swipe_down", nt::GESTURE_SWIPE_DOWN)
.value("push", nt::GESTURE_PUSH)
.export_values();
bp::enum_<nt::JointType>("JointType")
.value("none", nt::JOINT_NONE)
.value("head", nt::JOINT_HEAD)
.value("neck", nt::JOINT_NECK)
.value("torso", nt::JOINT_TORSO)
.value("waist", nt::JOINT_WAIST)
.value("left_collar", nt::JOINT_LEFT_COLLAR)
.value("left_shoulder", nt::JOINT_LEFT_SHOULDER)
.value("left_elbow", nt::JOINT_LEFT_ELBOW)
.value("left_wrist", nt::JOINT_LEFT_WRIST)
.value("left_hand", nt::JOINT_LEFT_HAND)
.value("left_fingertip", nt::JOINT_LEFT_FINGERTIP)
.value("right_collar", nt::JOINT_RIGHT_COLLAR)
.value("right_shoulder", nt::JOINT_RIGHT_SHOULDER)
.value("right_elbow", nt::JOINT_RIGHT_ELBOW)
.value("right_wrist", nt::JOINT_RIGHT_WRIST)
.value("right_hand", nt::JOINT_RIGHT_HAND)
.value("right_fingertip", nt::JOINT_RIGHT_FINGERTIP)
.value("left_hip", nt::JOINT_LEFT_HIP)
.value("left_knee", nt::JOINT_LEFT_KNEE)
.value("left_ankle", nt::JOINT_LEFT_ANKLE)
.value("left_foot", nt::JOINT_LEFT_FOOT)
.value("right_hip", nt::JOINT_RIGHT_HIP)
.value("right_knee", nt::JOINT_RIGHT_KNEE)
.value("right_ankle", nt::JOINT_RIGHT_ANKLE)
.value("right_foot", nt::JOINT_RIGHT_FOOT)
.export_values();
bp::class_<Nuitrack>("Nuitrack", bp::init<>())
.def("init", &Nuitrack::init, nt_init_overloads(bp::arg("configPath") = "", "Path to the configuration file"))
.def("release", &Nuitrack::release)
.def("set_depth_callback", &Nuitrack::setDepthCallback)
.def("set_color_callback", &Nuitrack::setColorCallback)
.def("set_skeleton_callback", &Nuitrack::setSkeletonCallback)
.def("set_face_callback", &Nuitrack::setFaceCallback)
.def("set_hands_callback", &Nuitrack::setHandsCallback)
.def("set_user_callback", &Nuitrack::setUserCallback)
.def("set_gesture_callback", &Nuitrack::setGestureCallback)
.def("set_issue_callback", &Nuitrack::setIssueCallback)
.def("update", &Nuitrack::update);
};
| [
"silas.alves@gmail.com"
] | silas.alves@gmail.com |
7fc7860fed3571169253d875dca4266a78fe7cd3 | cebac349711f601c964bab6727c69b716805a673 | /plugins/NSVfitAlgorithmByIntegration.h | 7741e85c5b8c3b686a239d9a1c7751de399913b4 | [] | no_license | JehadMousa/TauAnalysis-CandidateTools | 1338415db346f94f9d1b4e6a298e333d48ac9f12 | 008acd5469a4963688034ec72a14dbff1fc418d3 | refs/heads/master | 2021-01-14T11:53:06.883362 | 2013-06-28T20:10:42 | 2013-06-28T20:10:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,265 | h | #ifndef TauAnalysis_CandidateTools_NSVfitAlgorithmByIntegration_h
#define TauAnalysis_CandidateTools_NSVfitAlgorithmByIntegration_h
/** \class SVfitAlgorithmByIntegration
*
* Concrete implementation of (n)SVfit algorithm
* by integration of likelihood functions
* (based on VEGAS integration algorithm)
*
* \author Christian Veelken, UC Davis
*
* \version $Revision: 1.16 $
*
* $Id: NSVfitAlgorithmByIntegration.h,v 1.16 2012/12/04 14:31:20 veelken Exp $
*
*/
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/Common/interface/Ptr.h"
#include "CommonTools/Utils/interface/StringObjectFunction.h"
#include "TauAnalysis/CandidateTools/interface/NSVfitAlgorithmBase.h"
#include "TauAnalysis/CandidateTools/interface/IndepCombinatoricsGeneratorT.h"
#include "TauAnalysis/CandidateTools/interface/svFitAuxFunctions.h"
#include "AnalysisDataFormats/TauAnalysis/interface/NSVfitEventHypothesisByIntegration.h"
#include "AnalysisDataFormats/TauAnalysis/interface/NSVfitResonanceHypothesisByIntegration.h"
#include <gsl/gsl_monte.h>
#include <gsl/gsl_monte_vegas.h>
#include <TArrayF.h>
#include <TFormula.h>
#include <TH1.h>
#include <TMath.h>
#include <vector>
#include <algorithm>
#include <string>
class NSVfitAlgorithmByIntegration : public NSVfitAlgorithmBase
{
public:
NSVfitAlgorithmByIntegration(const edm::ParameterSet&);
~NSVfitAlgorithmByIntegration();
void beginJob();
void beginEvent(const edm::Event&, const edm::EventSetup&);
void print(std::ostream&) const {}
double nll(const double*, const double*) const;
protected:
void fitImp() const;
void setMassResults(NSVfitResonanceHypothesisByIntegration*, const TH1*, unsigned) const;
bool isDaughter(const std::string&);
bool isResonance(const std::string&);
struct replaceParBase
{
virtual void beginJob(NSVfitAlgorithmByIntegration*) {}
virtual double operator()(const double*) const = 0;
int iPar_;
};
TFormula* makeReplacementFormula(const std::string&, const std::string&, std::vector<replaceParBase*>&, int&);
NSVfitParameter* getFitParameter(const std::string&);
struct NSVfitParameterMappingType
{
NSVfitParameterMappingType(const NSVfitParameter* base)
: base_(base)
{}
const NSVfitParameter* base_;
int idxByIntegration_;
};
std::vector<NSVfitParameterMappingType> fitParameterMappings_;
edm::RunNumber_t currentRunNumber_;
edm::LuminosityBlockNumber_t currentLumiSectionNumber_;
edm::EventNumber_t currentEventNumber_;
struct replaceParByFitParameter : replaceParBase
{
void beginJob(NSVfitAlgorithmByIntegration* algorithm)
{
idx_ = algorithm->getFitParameter(fitParameterName_)->index();
}
double operator()(const double* param) const { return param[idx_]; }
std::string fitParameterName_;
int idx_;
};
struct replaceParByResonanceHypothesis : replaceParBase
{
replaceParByResonanceHypothesis()
: valueExtractor_(0)
{}
~replaceParByResonanceHypothesis()
{
delete valueExtractor_;
}
double operator()(const double* param) const { return value_; }
std::string resonanceName_;
NSVfitResonanceHypothesis* resonanceHypothesis_;
StringObjectFunction<NSVfitResonanceHypothesis>* valueExtractor_;
mutable double value_;
};
struct fitParameterReplacementType
{
fitParameterReplacementType()
: gridPoints_(0),
resBinning_(0),
replaceBy_(0),
deltaFuncDerrivative_(0)
{}
~fitParameterReplacementType()
{
delete gridPoints_;
delete resBinning_;
delete replaceBy_;
delete deltaFuncDerrivative_;
for ( std::vector<replaceParBase*>::iterator it = parForReplacements_.begin();
it != parForReplacements_.end(); ++it ) {
delete (*it);
}
for ( std::vector<replaceParBase*>::iterator it = parForDeltaFuncDerrivative_.begin();
it != parForDeltaFuncDerrivative_.end(); ++it ) {
delete (*it);
}
}
void beginJob(NSVfitAlgorithmByIntegration* algorithm)
{
NSVfitParameter* fitParameterToReplace = algorithm->getFitParameter(toReplace_);
if ( !fitParameterToReplace ) {
throw cms::Exception("fitParameterReplacementType::beginJob")
<< " No fitParameter of name = " << toReplace_ << " defined !!";
}
idxToReplace_ = fitParameterToReplace->index();
for ( std::vector<replaceParBase*>::iterator par = parForReplacements_.begin();
par != parForReplacements_.end(); ++par ) {
(*par)->beginJob(algorithm);
}
for ( std::vector<replaceParBase*>::iterator par = parForDeltaFuncDerrivative_.begin();
par != parForDeltaFuncDerrivative_.end(); ++par ) {
(*par)->beginJob(algorithm);
}
}
void beginEvent(double eventLowerLimit)
{
std::vector<double> gridPoints_vector;
double gridPoint = TMath::Max(iterLowerLimit_, eventLowerLimit);
bool isGridComplete = false;
while ( !isGridComplete ) {
if ( gridPoint >= iterUpperLimit_ ) isGridComplete = true;
gridPoints_vector.push_back(gridPoint);
double stepSize = TMath::Max((iterStepSizeFactor_ - 1.)*gridPoint, iterMinStepSize_);
gridPoint += stepSize;
}
std::sort(gridPoints_vector.begin(), gridPoints_vector.end());
numGridPoints_ = gridPoints_vector.size();
delete gridPoints_;
gridPoints_ = new TArrayF(numGridPoints_);
delete resBinning_;
resBinning_ = new TArrayF(numGridPoints_ + 1);
for ( int iGridPoint = 0; iGridPoint < numGridPoints_; ++iGridPoint ) {
double gridPoint = gridPoints_vector[iGridPoint];
(*gridPoints_)[iGridPoint] = gridPoint;
if ( iGridPoint == 0 ) (*resBinning_)[0] = gridPoint - 0.5*TMath::Abs(gridPoints_vector[1] - gridPoint);
else (*resBinning_)[iGridPoint] = 0.5*(gridPoints_vector[iGridPoint - 1] + gridPoint);
if ( iGridPoint == (numGridPoints_ - 1) )
(*resBinning_)[numGridPoints_] = gridPoint + 0.5*TMath::Abs(gridPoint - gridPoints_vector[iGridPoint - 1]);
}
}
std::string name_;
double iterLowerLimit_;
double iterUpperLimit_;
double iterStepSizeFactor_;
double iterMinStepSize_;
int numGridPoints_;
TArrayF* gridPoints_;
TArrayF* resBinning_;
std::string toReplace_;
int idxToReplace_;
TFormula* replaceBy_;
TFormula* deltaFuncDerrivative_;
int idxMassParameter_;
std::vector<replaceParBase*> parForReplacements_;
int numParForReplacements_;
std::vector<replaceParBase*> parForDeltaFuncDerrivative_;
int numParForDeltaFuncDerrivative_;
};
std::vector<fitParameterReplacementType*> fitParameterReplacements_;
double* fitParameterValues_;
double* xl_;
double* xu_;
gsl_monte_function* integrand_;
gsl_monte_vegas_state* workspace_;
mutable gsl_rng* rnd_;
unsigned numCallsGridOpt_;
unsigned numCallsIntEval_;
double maxChi2_;
unsigned maxIntEvalIter_;
double precision_;
unsigned numDimensions_;
unsigned numMassParameters_;
mutable IndepCombinatoricsGeneratorT<int>* massParForReplacements_;
int max_or_median_;
};
#endif
| [
"sha1-5c72da6f595cce9b6b48aff6d56f01e9beb4aad1@cern.ch"
] | sha1-5c72da6f595cce9b6b48aff6d56f01e9beb4aad1@cern.ch |
7630c048fb04ba6f4d275e10af15fd30e6ae6573 | 497aa5b78b584bf3b7ad40ac5844858490b9b558 | /problems/sm_depth_todo/ibex/test_stability.cpp | f628e223938f351d9f0e9b4a59824ed5d6a1eda7 | [] | no_license | alexlefort/these | 785b952b08633cbd68c76073fbf1a42e640ede67 | db54fbaafdc19bccc76ecf84ff9bbb366ce777be | refs/heads/master | 2020-05-20T22:49:36.889927 | 2019-06-29T17:38:03 | 2019-06-29T17:38:03 | 185,788,560 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,674 | cpp | #include "ibex.h"
#include <string>
#include <ctime>
#include "ibex_Random.h"
using namespace ibex;
//using namespace std;
void test_stability() {
IntervalVector x(9);
double kz = 0.0;
double ktheta = 0.0;
double kpi = 0.0;
double kq = 0.0;
double iz = 0.0;
double eps_ctrl = 5.0;
x[0] = Interval(-eps_ctrl, eps_ctrl);
x[1] = Interval(-eps_ctrl, 3*eps_ctrl);
x[2] = Interval(-eps_ctrl, 3*eps_ctrl);
x[3] = Interval(-1 , 3*eps_ctrl);
x[4] = Interval(-eps_ctrl, eps_ctrl);
double CmQ0 = -0.8116 ;
double CzW0 = -2.6126 ;
double CmB10 = -0.7155 ;
double CzB10 = -1.2233 ;
x[5] = Interval(CmQ0 , CmQ0 );
x[6] = Interval(CzW0 , CzW0 );
x[7] = Interval(CmB10, CmB10);
x[8] = Interval(CzB10, CzB10);
Variable p(9);
Function *coeffs = new Function("functions/Tstab_coefs_x.txt");
const ExprNode& stab1 = (*coeffs)(p)[0];
const ExprNode& stab2 = (*coeffs)(p)[1];
const ExprNode& stab3 = (*coeffs)(p)[2];
const ExprNode& stab4 = (*coeffs)(p)[3];
const ExprNode& stab5 = (*coeffs)(p)[4];
const ExprNode& stab6 = (*coeffs)(p)[5];
const ExprNode& stab7 = (*coeffs)(p)[6];
Vector x_min(5), x_max(5);
x_min[0] = eps_ctrl;
x_min[1] = eps_ctrl;
x_min[2] = eps_ctrl;
x_min[3] = eps_ctrl;
x_min[4] = eps_ctrl;
x_max[0] = -eps_ctrl;
x_max[1] = -eps_ctrl;
x_max[2] = -eps_ctrl;
x_max[3] = -eps_ctrl;
x_max[4] = -eps_ctrl;
Function* stab = new Function(p,ibex::max(ibex::max(ibex::max(ibex::max(ibex::max(ibex::max(-stab7,-stab5),-stab3),-stab1),ibex::pow(stab2,3)*ibex::pow(stab7,3) - stab1*ibex::pow(stab4,3)*ibex::pow(stab7,2) + ibex::pow(stab1,2)*ibex::pow(stab6,3)*stab7 + stab2*stab3*ibex::pow(stab4,2)*ibex::pow(stab7,2) + stab2*ibex::pow(stab3,2)*ibex::pow(stab6,2)*stab7 - 2*ibex::pow(stab2,2)*stab3*stab6*ibex::pow(stab7,2) - ibex::pow(stab2,2)*stab4*stab5*ibex::pow(stab7,2) + ibex::pow(stab2,2)*ibex::pow(stab5,2)*stab6*stab7 + 3*stab1*stab2*stab4*stab6*ibex::pow(stab7,2) - 2*stab1*stab2*stab5*ibex::pow(stab6,2)*stab7 - stab1*stab3*stab4*ibex::pow(stab6,2)*stab7 + stab1*ibex::pow(stab4,2)*stab5*stab6*stab7 - stab2*stab3*stab4*stab5*stab6*stab7),ibex::pow(stab1,2)*ibex::pow(stab6,2) + ibex::pow(stab2,2)*ibex::pow(stab5,2) + stab1*ibex::pow(stab4,2)*stab5 + stab2*ibex::pow(stab3,2)*stab6 - ibex::pow(stab2,2)*stab3*stab7 + stab1*stab2*stab4*stab7 - 2*stab1*stab2*stab5*stab6 - stab1*stab3*stab4*stab6 - stab2*stab3*stab4*stab5),stab1*stab4 - stab2*stab3));
std::cout << x << std::endl;
int count = 0;
for (int i = 0 ; i < 1000000 ; i ++)
{
Vector xrand = x.random();
IntervalVector aux(xrand);
if (i%10000 ==0) std::cout << i << " ; min = " << x_min << " ; max = " << x_max << std::endl;
Interval res = stab->eval(aux);
//std::cout << xrand << " " << res << std::endl;
if (res.ub() < 0)
{
for (int j = 0 ; j < 5 ; j++)
{
if (x_min[j] > xrand[j]) x_min[j] = xrand[j];
if (x_max[j] < xrand[j]) x_max[j] = xrand[j];
}
count ++;
}
else
{
//std::cout << "instable = " << xrand << std::endl;
}
}
std::cout << "count = " << count << std::endl;
}
int main(int argc, char* argv[]) {
RNG::srand(1234);
//test_stability();
int count = 0;
for (int i =1 ; i < 400000 ; i ++) {
int p = rand();
std::cout << p-ibex::pow(2,32) << std::endl;
}
std::cout << "count = " << count << std::endl;
return 1;
} | [
"alexandre.lefort@ensta-bretagne.org"
] | alexandre.lefort@ensta-bretagne.org |
6dff0d473e335d930af436f284e22f6115f5c5a2 | 38c10c01007624cd2056884f25e0d6ab85442194 | /third_party/skia/include/core/SkImageInfo.h | 4b82ae6e2fb317cf2414cb09801d72efc26de423 | [
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"BSD-3-Clause",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-public-domain"
] | permissive | zenoalbisser/chromium | 6ecf37b6c030c84f1b26282bc4ef95769c62a9b2 | e71f21b9b4b9b839f5093301974a45545dad2691 | refs/heads/master | 2022-12-25T14:23:18.568575 | 2016-07-14T21:49:52 | 2016-07-23T08:02:51 | 63,980,627 | 0 | 2 | BSD-3-Clause | 2022-12-12T12:43:41 | 2016-07-22T20:14:04 | null | UTF-8 | C++ | false | false | 9,896 | h | /*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkImageInfo_DEFINED
#define SkImageInfo_DEFINED
#include "SkMath.h"
#include "SkRect.h"
#include "SkSize.h"
class SkReadBuffer;
class SkWriteBuffer;
/**
* Describes how to interpret the alpha component of a pixel.
*/
enum SkAlphaType {
kUnknown_SkAlphaType,
/**
* All pixels are stored as opaque. This differs slightly from kIgnore in
* that kOpaque has correct "opaque" values stored in the pixels, while
* kIgnore may not, but in both cases the caller should treat the pixels
* as opaque.
*/
kOpaque_SkAlphaType,
/**
* All pixels have their alpha premultiplied in their color components.
* This is the natural format for the rendering target pixels.
*/
kPremul_SkAlphaType,
/**
* All pixels have their color components stored without any regard to the
* alpha. e.g. this is the default configuration for PNG images.
*
* This alpha-type is ONLY supported for input images. Rendering cannot
* generate this on output.
*/
kUnpremul_SkAlphaType,
kLastEnum_SkAlphaType = kUnpremul_SkAlphaType
};
static inline bool SkAlphaTypeIsOpaque(SkAlphaType at) {
return kOpaque_SkAlphaType == at;
}
static inline bool SkAlphaTypeIsValid(unsigned value) {
return value <= kLastEnum_SkAlphaType;
}
///////////////////////////////////////////////////////////////////////////////
/**
* Describes how to interpret the components of a pixel.
*
* kN32_SkColorType is an alias for whichever 32bit ARGB format is the "native"
* form for skia's blitters. Use this if you don't have a swizzle preference
* for 32bit pixels.
*/
enum SkColorType {
kUnknown_SkColorType,
kAlpha_8_SkColorType,
kRGB_565_SkColorType,
kARGB_4444_SkColorType,
kRGBA_8888_SkColorType,
kBGRA_8888_SkColorType,
kIndex_8_SkColorType,
kGray_8_SkColorType,
kLastEnum_SkColorType = kGray_8_SkColorType,
#if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
kN32_SkColorType = kBGRA_8888_SkColorType,
#elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
kN32_SkColorType = kRGBA_8888_SkColorType,
#else
#error "SK_*32_SHFIT values must correspond to BGRA or RGBA byte order"
#endif
};
static int SkColorTypeBytesPerPixel(SkColorType ct) {
static const uint8_t gSize[] = {
0, // Unknown
1, // Alpha_8
2, // RGB_565
2, // ARGB_4444
4, // RGBA_8888
4, // BGRA_8888
1, // kIndex_8
1, // kGray_8
};
static_assert(SK_ARRAY_COUNT(gSize) == (size_t)(kLastEnum_SkColorType + 1),
"size_mismatch_with_SkColorType_enum");
SkASSERT((size_t)ct < SK_ARRAY_COUNT(gSize));
return gSize[ct];
}
static inline size_t SkColorTypeMinRowBytes(SkColorType ct, int width) {
return width * SkColorTypeBytesPerPixel(ct);
}
static inline bool SkColorTypeIsValid(unsigned value) {
return value <= kLastEnum_SkColorType;
}
static inline size_t SkColorTypeComputeOffset(SkColorType ct, int x, int y, size_t rowBytes) {
int shift = 0;
switch (SkColorTypeBytesPerPixel(ct)) {
case 4: shift = 2; break;
case 2: shift = 1; break;
case 1: shift = 0; break;
default: return 0;
}
return y * rowBytes + (x << shift);
}
///////////////////////////////////////////////////////////////////////////////
/**
* Return true if alphaType is supported by colorType. If there is a canonical
* alphaType for this colorType, return it in canonical.
*/
bool SkColorTypeValidateAlphaType(SkColorType colorType, SkAlphaType alphaType,
SkAlphaType* canonical = NULL);
///////////////////////////////////////////////////////////////////////////////
/**
* Describes the color space a YUV pixel.
*/
enum SkYUVColorSpace {
/** Standard JPEG color space. */
kJPEG_SkYUVColorSpace,
/** SDTV standard Rec. 601 color space. Uses "studio swing" [16, 235] color
range. See http://en.wikipedia.org/wiki/Rec._601 for details. */
kRec601_SkYUVColorSpace,
/** HDTV standard Rec. 709 color space. Uses "studio swing" [16, 235] color
range. See http://en.wikipedia.org/wiki/Rec._709 for details. */
kRec709_SkYUVColorSpace,
kLastEnum_SkYUVColorSpace = kRec709_SkYUVColorSpace
};
///////////////////////////////////////////////////////////////////////////////
enum SkColorProfileType {
kLinear_SkColorProfileType,
kSRGB_SkColorProfileType,
kLastEnum_SkColorProfileType = kSRGB_SkColorProfileType
};
/**
* Describe an image's dimensions and pixel type.
* Used for both src images and render-targets (surfaces).
*/
struct SK_API SkImageInfo {
public:
SkImageInfo()
: fWidth(0)
, fHeight(0)
, fColorType(kUnknown_SkColorType)
, fAlphaType(kUnknown_SkAlphaType)
, fProfileType(kLinear_SkColorProfileType)
{}
static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at,
SkColorProfileType pt = kLinear_SkColorProfileType) {
return SkImageInfo(width, height, ct, at, pt);
}
/**
* Sets colortype to the native ARGB32 type.
*/
static SkImageInfo MakeN32(int width, int height, SkAlphaType at,
SkColorProfileType pt = kLinear_SkColorProfileType) {
return SkImageInfo(width, height, kN32_SkColorType, at, pt);
}
/**
* Sets colortype to the native ARGB32 type, and the alphatype to premul.
*/
static SkImageInfo MakeN32Premul(int width, int height,
SkColorProfileType pt = kLinear_SkColorProfileType) {
return SkImageInfo(width, height, kN32_SkColorType, kPremul_SkAlphaType, pt);
}
/**
* Sets colortype to the native ARGB32 type, and the alphatype to premul.
*/
static SkImageInfo MakeN32Premul(const SkISize& size,
SkColorProfileType pt = kLinear_SkColorProfileType) {
return MakeN32Premul(size.width(), size.height(), pt);
}
static SkImageInfo MakeA8(int width, int height) {
return SkImageInfo(width, height, kAlpha_8_SkColorType, kPremul_SkAlphaType,
kLinear_SkColorProfileType);
}
static SkImageInfo MakeUnknown(int width, int height) {
return SkImageInfo(width, height, kUnknown_SkColorType, kUnknown_SkAlphaType,
kLinear_SkColorProfileType);
}
static SkImageInfo MakeUnknown() {
return SkImageInfo();
}
int width() const { return fWidth; }
int height() const { return fHeight; }
SkColorType colorType() const { return fColorType; }
SkAlphaType alphaType() const { return fAlphaType; }
SkColorProfileType profileType() const { return fProfileType; }
bool isEmpty() const { return fWidth <= 0 || fHeight <= 0; }
bool isOpaque() const {
return SkAlphaTypeIsOpaque(fAlphaType);
}
bool isLinear() const { return kLinear_SkColorProfileType == fProfileType; }
bool isSRGB() const { return kSRGB_SkColorProfileType == fProfileType; }
SkISize dimensions() const { return SkISize::Make(fWidth, fHeight); }
SkIRect bounds() const { return SkIRect::MakeWH(fWidth, fHeight); }
/**
* Return a new ImageInfo with the same colortype and alphatype as this info,
* but with the specified width and height.
*/
SkImageInfo makeWH(int newWidth, int newHeight) const {
return SkImageInfo::Make(newWidth, newHeight, fColorType, fAlphaType, fProfileType);
}
SkImageInfo makeAlphaType(SkAlphaType newAlphaType) const {
return SkImageInfo::Make(fWidth, fHeight, fColorType, newAlphaType, fProfileType);
}
SkImageInfo makeColorType(SkColorType newColorType) const {
return SkImageInfo::Make(fWidth, fHeight, newColorType, fAlphaType, fProfileType);
}
int bytesPerPixel() const {
return SkColorTypeBytesPerPixel(fColorType);
}
uint64_t minRowBytes64() const {
return sk_64_mul(fWidth, this->bytesPerPixel());
}
size_t minRowBytes() const {
return (size_t)this->minRowBytes64();
}
size_t computeOffset(int x, int y, size_t rowBytes) const {
SkASSERT((unsigned)x < (unsigned)fWidth);
SkASSERT((unsigned)y < (unsigned)fHeight);
return SkColorTypeComputeOffset(fColorType, x, y, rowBytes);
}
bool operator==(const SkImageInfo& other) const {
return 0 == memcmp(this, &other, sizeof(other));
}
bool operator!=(const SkImageInfo& other) const {
return 0 != memcmp(this, &other, sizeof(other));
}
void unflatten(SkReadBuffer&);
void flatten(SkWriteBuffer&) const;
int64_t getSafeSize64(size_t rowBytes) const {
if (0 == fHeight) {
return 0;
}
return sk_64_mul(fHeight - 1, rowBytes) + fWidth * this->bytesPerPixel();
}
size_t getSafeSize(size_t rowBytes) const {
int64_t size = this->getSafeSize64(rowBytes);
if (!sk_64_isS32(size)) {
return 0;
}
return sk_64_asS32(size);
}
bool validRowBytes(size_t rowBytes) const {
uint64_t rb = sk_64_mul(fWidth, this->bytesPerPixel());
return rowBytes >= rb;
}
SkDEBUGCODE(void validate() const;)
private:
int fWidth;
int fHeight;
SkColorType fColorType;
SkAlphaType fAlphaType;
SkColorProfileType fProfileType;
SkImageInfo(int width, int height, SkColorType ct, SkAlphaType at, SkColorProfileType pt)
: fWidth(width)
, fHeight(height)
, fColorType(ct)
, fAlphaType(at)
, fProfileType(pt)
{}
};
#endif
| [
"zeno.albisser@hemispherian.com"
] | zeno.albisser@hemispherian.com |
f4114ec98a74833c09d25b883f48e31bad4f1e30 | be43d3804e0a74c8201e488ee1c7bca3d4ed7818 | /assignment-2/test.cpp | d6a83b3f181c3207999a516d957c6896439505ec | [] | no_license | catlicjohnson/cpsc-457 | 647c8c4ebde17d187f1c863ceb00d3f52ee49543 | f47d208ae5fbb2ee18286ef5cda1ec0e8686fa45 | refs/heads/main | 2023-06-04T02:17:03.033295 | 2021-05-08T16:36:24 | 2021-06-16T11:28:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 260 | cpp | #include <string>
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;
int main() {
std::string path = "/path/to/directory";
for (const auto& entry : fs::directory_iterator(path))
std::cout << entry.path() << std::endl;
} | [
"cloudyyoung74@outlook.com"
] | cloudyyoung74@outlook.com |
e839668cc5f411057011a75016c49da11eaedc58 | 2d2c69acda9154755be0a22b9ec1b710789a5bf0 | /LeetCode/leetcode-may-challenge/week4/SortCharacterByFrequency-strings.cpp | 835b64ab2545bde85511ddabc6c2899fd73854fe | [] | no_license | Kalit31/cp-playground | 2f74282a29222a308c022115e1a733ed2ed8dd6f | 572b543403498ffa12e80236a245bd7fb71249dd | refs/heads/master | 2023-06-26T21:50:26.676082 | 2021-07-31T08:45:15 | 2021-07-31T08:45:15 | 228,023,746 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,162 | cpp | #include <bits/stdc++.h>
using namespace std;
//Type: Strings, Heaps
//Approach: Store the frequency of each character in a map.
// Maintain a max heap whose each element is (freq of char,char)
// Start popping out the elements and add them to the final result.
//Complexity: O(NLgN) time
class Solution
{
public:
string frequencySort(string s)
{
vector<pair<int, char>> count(123, {0, 0});
for (int i = 0; i < s.length(); i++)
{
count[s[i]] = {count[s[i]].first + 1, s[i]};
}
sort(count.begin(), count.end());
string result = "";
for (auto it = count.begin(); it != count.end(); it++)
{
result = string(it->first, it->second) + result;
}
return result;
}
};
class Solution
{
public:
string frequencySort(string s)
{
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(0);
unordered_map<char, int> m;
string result;
for (auto i : s)
m[i]++;
priority_queue<pair<int, char>> q;
for (auto a : m)
{
q.push({a.second, a.first});
}
while (!q.empty())
{
auto t = q.top();
q.pop();
result.append(t.first, t.second);
}
return result;
}
};
class Solution
{
public:
struct myComp
{
bool operator()(const pair<char, int> &p1, const pair<char, int> &p2)
{
return p1.second < p2.second;
}
};
string frequencySort(string s)
{
unordered_map<char, int> m;
for (int i = 0; i < s.length(); i++)
{
m[s[i]]++;
}
vector<pair<char, int>> count;
for (auto it = m.begin(); it != m.end(); it++)
{
count.push_back({it->first, it->second});
}
sort(count.begin(), count.end(), myComp());
string result = "";
for (auto it = count.begin(); it != count.end(); it++)
{
result = string(it->second, it->first) + result;
}
return result;
}
}; | [
"inanikalit31@gmail.com"
] | inanikalit31@gmail.com |
003a20709329c3176713b6dfed2c13440a670a68 | 496b95ce18228acd29ab48586e12694b740fed42 | /utils/options/Option.cpp | a112bc02a053f4fc84cb2776ac22c49f06e9e371 | [] | no_license | pratik101agrawal/Indian_traffic_control | 11fb0de64e09ab9c658ce6db9f48a364ce98e4f5 | 6de2c6880edc853cce7efacebcb10fce475ba8c1 | refs/heads/master | 2022-12-25T09:43:40.295535 | 2020-09-30T18:57:57 | 2020-09-30T18:57:57 | 300,026,534 | 1 | 0 | null | 2020-09-30T18:56:37 | 2020-09-30T18:56:36 | null | UTF-8 | C++ | false | false | 11,496 | cpp | /****************************************************************************/
/// @file Option.cpp
/// @author Daniel Krajzewicz
/// @date Mon, 17 Dec 2001
/// @version $Id: Option.cpp 8648 2010-04-27 09:34:37Z dkrajzew $
///
// A class representing a single program option
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
/****************************************************************************/
// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif
#include <string>
#include <exception>
#include <sstream>
#include "Option.h"
#include <utils/common/TplConvert.h>
#include <utils/common/UtilExceptions.h>
#include <utils/common/StringTokenizer.h>
#include <utils/common/MsgHandler.h>
#ifdef CHECK_MEMORY_LEAKS
#include <foreign/nvwa/debug_new.h>
#endif // CHECK_MEMORY_LEAKS
// ===========================================================================
// method definitions
// ===========================================================================
/* -------------------------------------------------------------------------
* Option - methods
* ----------------------------------------------------------------------- */
Option::Option(bool set) throw()
: myAmSet(set), myHaveTheDefaultValue(true), myAmWritable(true) {}
Option::Option(const Option &s) throw()
: myAmSet(s.myAmSet), myHaveTheDefaultValue(s.myHaveTheDefaultValue),
myAmWritable(s.myAmWritable) {}
Option::~Option() throw() {}
Option &
Option::operator=(const Option &s) throw() {
if (this==&s) {
return *this;
}
myAmSet = s.myAmSet;
myHaveTheDefaultValue = s.myHaveTheDefaultValue;
myAmWritable = s.myAmWritable;
return *this;
}
bool
Option::isSet() const throw() {
return myAmSet;
}
SUMOReal
Option::getFloat() const throw(InvalidArgument) {
throw InvalidArgument("This is not a SUMOReal-option");
}
int
Option::getInt() const throw(InvalidArgument) {
throw InvalidArgument("This is not an int-option");
}
std::string
Option::getString() const throw(InvalidArgument) {
throw InvalidArgument("This is not a string-option");
}
bool
Option::getBool() const throw(InvalidArgument) {
throw InvalidArgument("This is not a bool-option");
}
const IntVector &
Option::getIntVector() const throw(InvalidArgument) {
throw InvalidArgument("This is not an int vector-option");
}
bool
Option::set(const std::string &) throw(InvalidArgument) {
throw InvalidArgument("This is an abstract class.");
}
bool
Option::set(bool) throw(InvalidArgument) {
throw InvalidArgument("This is not a bool-option.");
}
bool
Option::markSet() throw() {
bool ret = myAmWritable;
myHaveTheDefaultValue = false;
myAmSet = true;
myAmWritable = false;
return ret;
}
std::string
Option::getValueString() const throw(InvalidArgument) {
throw InvalidArgument("This is an abstract class.");
}
bool
Option::isBool() const throw() {
return false;
}
bool
Option::isDefault() const throw() {
return myHaveTheDefaultValue;
}
bool
Option::isFileName() const throw() {
return false;
}
bool
Option::isWriteable() const throw() {
return myAmWritable;
}
const std::string &
Option::getDescription() const throw() {
return myDescription;
}
const std::string &
Option::getTypeName() const throw() {
return myTypeName;
}
/* -------------------------------------------------------------------------
* Option_Integer - methods
* ----------------------------------------------------------------------- */
Option_Integer::Option_Integer() throw()
: Option() {
myTypeName = "INT";
}
Option_Integer::Option_Integer(int value) throw()
: Option(true), myValue(value) {
myTypeName = "INT";
}
Option_Integer::~Option_Integer() throw() {}
Option_Integer::Option_Integer(const Option_Integer &s) throw()
: Option(s) {
myValue = s.myValue;
}
Option_Integer &
Option_Integer::operator=(const Option_Integer &s) throw() {
if (this==&s) return *this;
Option::operator=(s);
myValue = s.myValue;
return *this;
}
int
Option_Integer::getInt() const throw(InvalidArgument) {
return myValue;
}
bool
Option_Integer::set(const std::string &v) throw(InvalidArgument) {
try {
myValue = TplConvert<char>::_2int(v.c_str());
return markSet();
} catch (...) {
std::string s = "'" + v + "' is not a valid integer (should be).";
throw InvalidArgument(s);
}
}
std::string
Option_Integer::getValueString() const throw(InvalidArgument) {
std::ostringstream s;
s << myValue;
return s.str();
}
/* -------------------------------------------------------------------------
* Option_String - methods
* ----------------------------------------------------------------------- */
Option_String::Option_String() throw()
: Option() {
myTypeName = "STR";
}
Option_String::Option_String(const std::string &value, std::string typeName) throw()
: Option(true), myValue(value) {
myTypeName = typeName;
}
Option_String::~Option_String() throw() {}
Option_String::Option_String(const Option_String &s) throw()
: Option(s) {
myValue = s.myValue;
}
Option_String &
Option_String::operator=(const Option_String &s) throw() {
if (this==&s) {
return *this;
}
Option::operator=(s);
myValue = s.myValue;
return *this;
}
std::string
Option_String::getString() const throw(InvalidArgument) {
return myValue;
}
bool
Option_String::set(const std::string &v) throw(InvalidArgument) {
myValue = v;
return markSet();
}
std::string
Option_String::getValueString() const throw(InvalidArgument) {
return myValue;
}
/* -------------------------------------------------------------------------
* Option_Float - methods
* ----------------------------------------------------------------------- */
Option_Float::Option_Float() throw()
: Option() {
myTypeName = "FLOAT";
}
Option_Float::Option_Float(SUMOReal value) throw()
: Option(true), myValue(value) {
myTypeName = "FLOAT";
}
Option_Float::~Option_Float() throw() {}
Option_Float::Option_Float(const Option_Float &s) throw()
: Option(s) {
myValue = s.myValue;
}
Option_Float &
Option_Float::operator=(const Option_Float &s) throw() {
if (this==&s) {
return *this;
}
Option::operator=(s);
myValue = s.myValue;
return *this;
}
SUMOReal
Option_Float::getFloat() const throw(InvalidArgument) {
return myValue;
}
bool
Option_Float::set(const std::string &v) throw(InvalidArgument) {
try {
myValue = TplConvert<char>::_2SUMOReal(v.c_str());
return markSet();
} catch (...) {
std::string s = "'" + v + "' is not a valid float (should be).";
throw InvalidArgument(s);
}
}
std::string
Option_Float::getValueString() const throw(InvalidArgument) {
std::ostringstream s;
s << myValue;
return s.str();
}
/* -------------------------------------------------------------------------
* Option_Bool - methods
* ----------------------------------------------------------------------- */
Option_Bool::Option_Bool() throw()
: Option() {
myTypeName = "BOOL";
}
Option_Bool::Option_Bool(bool value) throw()
: Option(true), myValue(value) {
myTypeName = "BOOL";
}
Option_Bool::~Option_Bool() throw() {}
Option_Bool::Option_Bool(const Option_Bool &s) throw()
: Option(s) {
myValue = s.myValue;
}
Option_Bool &
Option_Bool::operator=(const Option_Bool &s) throw() {
if (this==&s) {
return *this;
}
Option::operator=(s);
myValue = s.myValue;
return *this;
}
bool
Option_Bool::getBool() const throw(InvalidArgument) {
return myValue;
}
bool
Option_Bool::set(bool v) throw(InvalidArgument) {
myValue = v;
return markSet();
}
std::string
Option_Bool::getValueString() const throw(InvalidArgument) {
if (myValue) {
return "true";
}
return "false";
}
bool
Option_Bool::isBool() const throw() {
return true;
}
/* -------------------------------------------------------------------------
* Option_FileName - methods
* ----------------------------------------------------------------------- */
Option_FileName::Option_FileName() throw()
: Option_String() {
myTypeName = "FILE";
}
Option_FileName::Option_FileName(const std::string &value) throw()
: Option_String(value) {
myTypeName = "FILE";
}
Option_FileName::Option_FileName(const Option_String &s) throw()
: Option_String(s) {}
Option_FileName::~Option_FileName() throw() {}
Option_FileName &
Option_FileName::operator=(const Option_FileName &s) throw() {
Option_String::operator=(s);
return (*this);
}
bool
Option_FileName::isFileName() const throw() {
return true;
}
/* -------------------------------------------------------------------------
* Option_UIntVector - methods
* ----------------------------------------------------------------------- */
Option_IntVector::Option_IntVector() throw()
: Option() {
myTypeName = "INT[]";
}
Option_IntVector::Option_IntVector(const IntVector &value) throw()
: Option(true), myValue(value) {
myTypeName = "INT[]";
}
Option_IntVector::Option_IntVector(const Option_IntVector &s) throw()
: Option(s), myValue(s.myValue) {}
Option_IntVector::~Option_IntVector() throw() {}
Option_IntVector &
Option_IntVector::operator=(const Option_IntVector &s) throw() {
Option::operator=(s);
myValue = s.myValue;
return (*this);
}
const IntVector &
Option_IntVector::getIntVector() const throw(InvalidArgument) {
return myValue;
}
bool
Option_IntVector::set(const std::string &v) throw(InvalidArgument) {
myValue.clear();
try {
if (v.find(';')!=std::string::npos) {
MsgHandler::getWarningInstance()->inform("Please note that using ';' as list separator is deprecated.\n From 1.0 onwards, only ',' will be accepted.");
}
StringTokenizer st(v, ";,", true);
while (st.hasNext()) {
myValue.push_back(TplConvert<char>::_2int(st.next().c_str()));
}
return markSet();
} catch (EmptyData &) {
throw InvalidArgument("Empty element occured in " + v);
} catch (...) {
throw InvalidArgument("'" + v + "' is not a valid integer vector.");
}
}
std::string
Option_IntVector::getValueString() const throw(InvalidArgument) {
std::ostringstream s;
for (IntVector::const_iterator i=myValue.begin(); i!=myValue.end(); i++) {
if (i!=myValue.begin()) {
s << ',';
}
s << (*i);
}
return s.str();
}
/****************************************************************************/
| [
"chordiasagar14@gmail.com"
] | chordiasagar14@gmail.com |
cea122d2e0caa3b922ba11a32eef771e59d971e0 | e7c657adfc65e15fd2638d5bab8deaa9de07a5bb | /calculator6.0/TEST.cpp | bc93caa03b686c71476a919acf0e3becd06837dc | [] | no_license | HangyuanYang/SimpleMFCCalculator | ee0383f95772ee0eb4edece55fe48a5503df2325 | 18bd5d29a1bfd01618420cab947a72614fcc7bb6 | refs/heads/master | 2021-05-16T10:30:34.754390 | 2017-09-28T06:47:26 | 2017-09-28T06:47:26 | 104,749,020 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 2,176 | cpp | // TEST.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include "TEST.h"
#include "TESTDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CTESTApp
BEGIN_MESSAGE_MAP(CTESTApp, CWinApp)
//{{AFX_MSG_MAP(CTESTApp)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG
ON_COMMAND(ID_HELP, CWinApp::OnHelp)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CTESTApp construction
CTESTApp::CTESTApp()
{
// TODO: add construction code here,
// Place all significant initialization in InitInstance
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CTESTApp object
CTESTApp theApp;
/////////////////////////////////////////////////////////////////////////////
// CTESTApp initialization
BOOL CTESTApp::InitInstance()
{
AfxEnableControlContainer();
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
CTESTDlg dlg;
m_pMainWnd = &dlg;
int nResponse = dlg.DoModal();
if (nResponse == IDOK)
{
// TODO: Place code here to handle when the dialog is
// dismissed with OK
}
else if (nResponse == IDCANCEL)
{
// TODO: Place code here to handle when the dialog is
// dismissed with Cancel
}
// //SetDialogBkColor 只能放到*App.h中的InitInstance()函数中
// //在afxwin.h 中(包含在了stdafx.h中) 经过验证并不能改变对话框背景
SetDialogBkColor(RGB(0, 0, 0), RGB(0, 0, 0));
// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}
| [
"690094231@qq.com"
] | 690094231@qq.com |
c622f30d18a2212726b49bf655a20c67aa2ffe11 | cae60b0fbbd10ccfb50814c88da94bae80253942 | /l4d2Simple/indexes.h | 03c3f014334c633ccb36db0e5c8c8c495613d267 | [] | no_license | zonde306/9306 | fd8dd35683140393ef844de1f012ff7a52ec5fa9 | 97947a9bdfdc3b3856ab4e14b517a57807cfb24e | refs/heads/master | 2021-01-01T15:22:31.504974 | 2017-09-04T09:26:54 | 2017-09-04T09:26:54 | 97,606,870 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,173 | h | #pragma once
namespace indexes
{
// Client
const int GetAllClasses = 7;
const int CreateMove = 20;
const int FrameStageNotify = 34;
const int DispatchUserMessage = 35;
const int InKeyEvent = -1;
const int HudProcessInput = 9;
const int HudUpdate = 10;
const int IN_IsKeyDown = 18;
// Engine
const int GetScreenSize = 5;
const int GetPlayerInfo = 8;
const int GetLocalPlayer = 12;
const int ClientCmd = 107;
const int SetViewAngles = 20;
const int GetViewAngles = 19;
const int WorldToScreenMatrix = 37;
const int GetPlayerForUserId = 9;
const int Con_IsVisible = 11;
const int Time = 14;
const int GetMaxClients = 21;
const int IsInGame = 26;
const int IsConnected = 27;
const int IsDrawingLoadingImage = 28;
const int IsTakingScreenShot = 88;
// ClientEntList
const int GetClientEntity = 3;
const int GetClientEntityFromHandle = 4;
const int GetHighestEntityIndex = 8;
// Surface
const int DrawSetColor = 11;
const int DrawFilledRect = 12;
const int DrawFilledRectArray = 13;
const int DrawOutlinedRect = 14;
const int DrawLine = 15;
const int DrawPolyLine = 16;
const int DrawSetTextFont = 17;
const int DrawSetTextColor_Color = 18;
const int DrawSetTextColor = 19;
const int DrawSetTextPos = 20;
const int DrawGetTextPos = 21;
const int DrawPrintText = 22;
const int DrawUnicodeChar = 23;
const int DrawFlushText = 24;
const int SetCursor = 49;
const int IsCursorVisible = 50;
const int UnlockCursor = 58;
const int LockCursor = 59;
const int SCreateFont = 63;
const int SetFontGlyphSet = 64;
const int DrawColoredCircle = 152;
const int GetTextSize = 72;
const int DrawFilledRectFade = 115;
const int AddCustomFontFile = 65;
const int SurfacePaintTraverse = 85;
const int SurfacePaintTraverseEx = 111;
// ModelInfo
const int GetStudioModel = 30;
const int GetModelName = 3;
// ModelRender
const int DrawModel = 0;
const int ForcedMaterialOverride = 1;
const int DrawModelEx = 16;
const int DrawModelSetup = 18;
const int DrawModelExecute = 19;
// Panel
const int GetName = 36;
const int PaintTraverse = 41;
// MoveHelper
const int SetHost = 1;
// Trace
const int TraceRay = 5;
// Input
const int GetUserCmd = 8;
// Prediction
const int RunCommand = 18;
const int SetupMove = 19;
const int FinishMove = 20;
// GameMovement
const int ProccessMovement = 1;
const int PlayerMove = 18;
// Entity
const int GetClientClass = 1;
const int GetAbsOrigin = 11;
const int GetAbsAngles = 12;
const int GetIndex = 8;
const int SetupBones = 13;
const int IsDormant = 7;
const int GetModel = 8;
const int GetWeaponId = 383;
// ClientModeShared
const int SharedCreateMove = 27;
const int GetMessagePanel = 24;
// CBaseHudChat
const int Printf = 22;
const int ChatPrintf = 23;
// IViewRender
const int VGui_Paint = 39;
const int VguiPaint = 24;
const int Draw3DDebugOverlays = 3;
const int SetBlend = 4;
const int GetBlend = 5;
const int SetColorModulation = 6;
const int GetColorModulation = 7;
const int SceneBegin = 8;
const int SceneEnd = 9;
// CMaterialSystem
const int FindMaterial = 71;
const int IsMaterialLoaded = 72;
const int FindTexture = 77;
}
| [
"zonrex@live.cn"
] | zonrex@live.cn |
baeeecbe8ed541a72b447a86103f9a4849a6a7f3 | 0ddc592ffb9a062386c1efd8eaebc88c6a5bdce7 | /jnx-cc-routeservice/src/sbin/jnx-cc-routeserviced/jnx-routeserviced_ssd.h | f2cd10cafdc6d74a351ed9fded1a2135c06bd092 | [] | no_license | lakshmidm/junos-sdk-sample-apps | 2869c7bab877d610635c17bec0a90b8f8ec5c729 | e40870db65ba4f34f767b6a739745a145a117000 | refs/heads/master | 2021-05-05T04:11:31.435455 | 2016-02-29T23:28:32 | 2016-02-29T23:28:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,514 | h | /*
* $Id: jnx-routeserviced_ssd.h 346460 2009-11-14 05:06:47Z ssiano $
*
* This code is provided as is by Juniper Networks SDK Developer Support.
* It is provided with no warranties or guarantees, and Juniper Networks
* will not provide support or maintenance of this code in any fashion.
* The code is provided only to help a developer better understand how
* the SDK can be used.
*
* Copyright (c) 2007-2008, Juniper Networks, Inc.
* All rights reserved.
*/
#ifndef __JNX_ROUTESERVICED_SSD_H__
#define __JNX_ROUTESERVICED_SSD_H__
/*
* Gencfg Blog key for client-id
*/
#define JNX_ROUTESERVICED_CLIENT_ID_BLOB_KEY 0x00000001
/*
* Gencfg Blog ID for client-id
*/
#define JNX_ROUTESERVICED_CLIENT_ID_BLOB_ID 0x00000001
/**
* Class definition for SSD related attributes and methods
*/
class jnx_routeserviced_ssd {
public:
/**
* Destructor
*/
~jnx_routeserviced_ssd() {}
static jnx_routeserviced_ssd &Instance();
int init(evContext ev_ctx);
void set_reconnect_timer(void);
void process_client_id_restore_msg(void);
void add_route(char *destination, char *nhop, char *family,
unsigned int prefixlen, unsigned int req_ctx);
void del_route(char *destination, char *nhop, char *family,
unsigned int prefixlen, unsigned int req_ctx);
/**
* Get server file descriptor
*/
inline int get_server_fd() {return server_fd;}
/**
* Set server file descriptor
*/
inline void set_server_fd(int fd) {server_fd = fd;}
/**
* Get my client id provided by the server
*/
inline int get_client_id() {return client_id;}
/**
* Store my client provider by the server
*/
inline void set_client_id(int cid) {client_id = cid;}
/**
* Get routing table id
*/
inline int get_rtt_id() {return rtt_id;}
/**
* Store routing table id
*/
inline void set_rtt_id(int rttid) {rtt_id = rttid;}
/**
* Get pending status in unsigned int
*/
inline int get_pending_status() {
return static_cast<unsigned int>(RT_ADD_REQ_STAT_PENDING);
}
/**
* Get success status in unsigned int
*/
inline int get_success_status() {
return static_cast<unsigned int>(RT_ADD_REQ_STAT_SUCCESS);
}
/**
* Get failure status in unsigned int
*/
inline int get_failure_status() {
return static_cast<unsigned int>(RT_ADD_REQ_STAT_FAILURE);
}
/**
* Set the application's state as disconnected with SSD
*/
inline void set_state_restarting() {
jnx_routeserviced_state = JNX_RS_STATE_RESTARTING;
}
/**
* Set the application's state as disconnected with SSD
*/
inline void set_state_ssd_disconnected() {
jnx_routeserviced_state = JNX_RS_STATE_SSD_DISCONNECTED;
}
/**
* Set the application's state as disconnected with SSD
*/
inline void set_state_client_id_restored() {
jnx_routeserviced_state = JNX_RS_STATE_SSD_CLIENT_ID_RESTORED;
}
void deque_route_add_req_by_ctx(unsigned int ctx);
void deque_route_del_req_by_ctx(unsigned int ctx);
/**
* Request client-id from SSD
*/
int request_client_id();
void gencfg_update_client_id(int cid) {
gencfg_delete_client_id(0);
gencfg_store_client_id(cid);
}
private:
/*
* Hide the constructor, copy constructor and assignment operator
* to disallow more than one instances of the class
*/
/**
* Private constructor
*/
jnx_routeserviced_ssd() {}
/**
* Private copy constructor
*
* @param[in] old
* Reference to the object to be copied
*/
jnx_routeserviced_ssd(const jnx_routeserviced_ssd &old);
/**
* Private assignment operator
*
* @param[in] old
* Reference to the object to be assigned
*
* @return
* Reference to the new object to be assigned
*/
const jnx_routeserviced_ssd &operator=(const
jnx_routeserviced_ssd &old);
evContext event_ctx;
uint32_t rtt_id; /**< Routing table instance id */
int client_id; /**< My client id */
int server_fd; /**< Server file descriptor */
static auto_ptr<jnx_routeserviced_ssd> unique_instance; /**< Unique
class
instance */
/**
* An enum definition for route addition requests status
*/
typedef enum jnx_routeserviced_state_e {
JNX_RS_STATE_RESTARTING,
JNX_RS_STATE_SSD_DISCONNECTED,
JNX_RS_STATE_SSD_CLIENT_ID_RESTORED
} jnx_routeserviced_state_t;
/**
* An enum definition for route addition requests status
*/
enum jnx_routeserviced_route_add_status {
RT_ADD_REQ_STAT_PENDING,
RT_ADD_REQ_STAT_SUCCESS,
RT_ADD_REQ_STAT_FAILURE
};
/**
* Class definition with route addition attributes
*/
struct rs_route_add_req {
struct ssd_route_parms rtp; /**< Route parameters */
ssd_sockaddr_un route_addr; /**< Destination address */
ssd_sockaddr_un route_nh; /**< Next hop address for
destination */
ssd_sockaddr_un route_local; /**< Local address
associated
with interface */
unsigned int ctx; /**< Context for the
request */
TAILQ_ENTRY(rs_route_add_req) entries; /** < Tailq entry */
};
/**
* Class definition with route deletion attributes
*/
struct rs_route_del_req {
struct ssd_rt_delete_parms rtp; /**< Route parameters */
ssd_sockaddr_un route_addr; /**< Destination
address */
unsigned int ctx; /**< Context for the
request */
TAILQ_ENTRY(rs_route_del_req) entries; /**< Tailq entry */
};
/**
* Head for the route addition request queue
*/
TAILQ_HEAD(, rs_route_add_req) route_add_queue;
/**
* Head for the route deletion request queue
*/
TAILQ_HEAD(, rs_route_del_req) route_del_queue;
/**
* Variable to keep track of the application's state
*/
jnx_routeserviced_state_t jnx_routeserviced_state;
int connect(evContext ev_ctx);
static void reconnect(evContext ev_ctx, void *uap __unused,
struct timespec due __unused,
struct timespec inter __unused);
const char* get_prefix_by_ifl (ifl_idx_t);
int get_idx_by_iflname (const char *iflname, ifl_idx_t *idx);
/**
* Enques route addition requests in the tail queue
*/
inline void enque_route_add_req(rs_route_add_req * add_req) {
TAILQ_INSERT_TAIL(&route_add_queue, add_req, entries);
}
/**
* Enques route deletion requests in the tail queue
*/
inline void enque_route_del_req(rs_route_del_req * del_req) {
TAILQ_INSERT_TAIL(&route_del_queue, del_req, entries);
}
int gencfg_init(void);
void gencfg_store_client_id(int id);
int gencfg_get_client_id(int *id);
static void gencfg_delete_client_id(int id __unused);
};
#endif /* ! __JNX_ROUTESERVICED_SSD_H__ */
| [
"james@jameskelly.net"
] | james@jameskelly.net |
0c28d1db27bac7cb04b08a987a2336d5ba37f5cc | c7d3efc822825d62bea0cab54b6f01ff5cbbe737 | /gameModes/dotsnetcritsonline/logicComponents/Gravity.cpp | 2d3db49acc2d6f6805142a39df6de34dc9510b76 | [] | no_license | practicing01/Urho3DTemplate | 933835f723fbb2368013a94ae7a2a7617f7578a3 | ab9e151fea3e940d796702cd65b21eeea5e84f1f | refs/heads/master | 2021-01-22T14:32:55.540422 | 2015-11-10T18:27:02 | 2015-11-10T18:27:02 | 27,493,133 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,579 | cpp | /*
* Gravity.cpp
*
* Created on: Jul 13, 2015
* Author: practicing01
*/
#include <Urho3D/Urho3D.h>
#include <Urho3D/Graphics/AnimatedModel.h>
#include <Urho3D/Math/BoundingBox.h>
#include <Urho3D/Graphics/Camera.h>
#include <Urho3D/Physics/CollisionShape.h>
#include <Urho3D/Core/CoreEvents.h>
#include <Urho3D/Engine/Engine.h>
#include <Urho3D/Graphics/Graphics.h>
#include <Urho3D/IO/MemoryBuffer.h>
#include <Urho3D/Network/Network.h>
#include <Urho3D/Network/NetworkEvents.h>
#include <Urho3D/Scene/Node.h>
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/IO/Log.h>
#include <Urho3D/Graphics/Model.h>
#include <Urho3D/Graphics/Octree.h>
#include <Urho3D/Math/Quaternion.h>
#include <Urho3D/Physics/RigidBody.h>
#include <Urho3D/Graphics/StaticModel.h>
#include <Urho3D/Graphics/Viewport.h>
#include <Urho3D/Physics/PhysicsEvents.h>
#include <Urho3D/Physics/PhysicsWorld.h>
#include "Gravity.h"
#include "../../../network/NetworkConstants.h"
#include "../../../Constants.h"
Gravity::Gravity(Context* context, Urho3DPlayer* main) :
LogicComponent(context)
{
main_ = main;
gravity_ = -9.0f;
}
Gravity::~Gravity()
{
}
void Gravity::Start()
{
SubscribeToEvent(E_GETCLIENTGRAVITY, URHO3D_HANDLER(Gravity, HandleGetGravity));
}
void Gravity::HandleGetGravity(StringHash eventType, VariantMap& eventData)
{
Node* clientNode = (Node*)(eventData[GetClientGravity::P_NODE].GetPtr());
if (clientNode == node_)
{
VariantMap vm;
vm[SetClientGravity::P_NODE] = clientNode;
vm[SetClientGravity::P_GRAVITY] = gravity_;
SendEvent(E_SETCLIENTGRAVITY, vm);
}
}
| [
"practicing01@gmail.com"
] | practicing01@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.