blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 905
values | visit_date timestamp[us]date 2015-08-09 11:21:18 2023-09-06 10:45:07 | revision_date timestamp[us]date 1997-09-14 05:04:47 2023-09-17 19:19:19 | committer_date timestamp[us]date 1997-09-14 05:04:47 2023-09-06 06:22:19 | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22
values | gha_event_created_at timestamp[us]date 2012-06-07 00:51:45 2023-09-14 21:58:39 ⌀ | gha_created_at timestamp[us]date 2008-03-27 23:40:48 2023-08-21 23:17:38 ⌀ | gha_language stringclasses 141
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 10.4M | extension stringclasses 115
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
51f3a7314acdf5071c3bc8a0945c0aa6b51a55b5 | a35b30a7c345a988e15d376a4ff5c389a6e8b23a | /boost/phoenix/core/is_actor.hpp | 2fda0f56ebdaa4969fac1bc8e9e4e3a222f41fb7 | [] | 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 | 67 | hpp | #include "thirdparty/boost_1_55_0/boost/phoenix/core/is_actor.hpp"
| [
"liuhuahang@xiaomi.com"
] | liuhuahang@xiaomi.com |
a9276092d68e248e514befd350247c9daab48715 | 5676ed2dc44990e74d1919045cfd62329ab89b90 | /VTK/vis2008PA/include/vtk-5.4/vtkGenericContourFilter.h | a5ddaed61b06d626bfa2b209785f9062d824c93c | [] | no_license | door5719/3DPrinting | 59858028f392b5039af07d1fcedd34d99ac09f99 | 44a0aea8cd78d23e6b8054fa86d1c8b8111436e8 | refs/heads/master | 2021-05-31T12:06:22.516944 | 2015-05-10T15:55:38 | 2015-05-10T15:55:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,744 | h | /*=========================================================================
Program: Visualization Toolkit
Module: $RCSfile: vtkGenericContourFilter.h,v $
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
// .NAME vtkGenericContourFilter - generate isocontours from input dataset
// .SECTION Description
// vtkGenericContourFilter is a filter that takes as input any (generic)
// dataset and generates on output isosurfaces and/or isolines. The exact
// form of the output depends upon the dimensionality of the input data.
// Data consisting of 3D cells will generate isosurfaces, data consisting of
// 2D cells will generate isolines, and data with 1D or 0D cells will
// generate isopoints. Combinations of output type are possible if the input
// dimension is mixed.
//
// To use this filter you must specify one or more contour values.
// You can either use the method SetValue() to specify each contour
// value, or use GenerateValues() to generate a series of evenly
// spaced contours. You can use ComputeNormalsOn to compute the normals
// without the need of a vtkPolyDataNormals
//
// This filter has been implemented to operate on generic datasets, rather
// than the typical vtkDataSet (and subclasses). vtkGenericDataSet is a more
// complex cousin of vtkDataSet, typically consisting of nonlinear,
// higher-order cells. To process this type of data, generic cells are
// automatically tessellated into linear cells prior to isocontouring.
// .SECTION See Also
// vtkContourFilter vtkGenericDataSet
#ifndef __vtkGenericContourFilter_h
#define __vtkGenericContourFilter_h
#include "vtkPolyDataAlgorithm.h"
class vtkContourValues;
class vtkPointLocator;
class vtkPointData;
class vtkCellData;
class VTK_GENERIC_FILTERING_EXPORT vtkGenericContourFilter : public vtkPolyDataAlgorithm
{
public:
vtkTypeRevisionMacro(vtkGenericContourFilter,
vtkPolyDataAlgorithm);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
// Construct object with initial range (0,1) and single contour value
// of 0.0.
static vtkGenericContourFilter *New();
//BTX
typedef double PointType[3]; // Arbitrary definition of a point
//ETX
// Description:
// Methods to set / get contour values.
void SetValue(int i, float value);
double GetValue(int i);
double *GetValues();
void GetValues(double *contourValues);
void SetNumberOfContours(int number);
int GetNumberOfContours();
void GenerateValues(int numContours, double range[2]);
void GenerateValues(int numContours, double rangeStart, double rangeEnd);
// Description:
// Modified GetMTime Because we delegate to vtkContourValues
unsigned long GetMTime();
// Description:
// Set/Get the computation of normals. Normal computation is fairly
// expensive in both time and storage. If the output data will be
// processed by filters that modify topology or geometry, it may be
// wise to turn Normals and Gradients off.
vtkSetMacro(ComputeNormals,int);
vtkGetMacro(ComputeNormals,int);
vtkBooleanMacro(ComputeNormals,int);
// Description:
// Set/Get the computation of gradients. Gradient computation is
// fairly expensive in both time and storage. Note that if
// ComputeNormals is on, gradients will have to be calculated, but
// will not be stored in the output dataset. If the output data
// will be processed by filters that modify topology or geometry, it
// may be wise to turn Normals and Gradients off.
vtkSetMacro(ComputeGradients,int);
vtkGetMacro(ComputeGradients,int);
vtkBooleanMacro(ComputeGradients,int);
// Description:
// Set/Get the computation of scalars.
vtkSetMacro(ComputeScalars,int);
vtkGetMacro(ComputeScalars,int);
vtkBooleanMacro(ComputeScalars,int);
// Description:
// Set / get a spatial locator for merging points. By default,
// an instance of vtkMergePoints is used.
void SetLocator(vtkPointLocator *locator);
vtkGetObjectMacro(Locator,vtkPointLocator);
// Description:
// Create default locator. Used to create one when none is
// specified. The locator is used to merge coincident points.
void CreateDefaultLocator();
// Description:
// If you want to contour by an arbitrary scalar attribute, then set its
// name here.
// By default this in NULL and the filter will use the active scalar array.
vtkGetStringMacro(InputScalarsSelection);
virtual void SelectInputScalars(const char *fieldName);
protected:
vtkGenericContourFilter();
~vtkGenericContourFilter();
int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
int FillInputPortInformation(int, vtkInformation*);
vtkContourValues *ContourValues;
int ComputeNormals;
int ComputeGradients;
int ComputeScalars;
vtkPointLocator *Locator;
char *InputScalarsSelection;
vtkSetStringMacro(InputScalarsSelection);
// Used internal by vtkGenericAdaptorCell::Contour()
vtkPointData *InternalPD;
vtkPointData *SecondaryPD;
vtkCellData *SecondaryCD;
private:
vtkGenericContourFilter(const vtkGenericContourFilter&); // Not implemented.
void operator=(const vtkGenericContourFilter&); // Not implemented.
};
#endif
| [
"dsandesari@gmail.com"
] | dsandesari@gmail.com |
ba3b56a48263b7f13dac7dcd64c1b8abfa830301 | b566c824f7afef50605bc51c254f49f521bde44d | /iyan3d/trunk/assimp-master/code/SkeletonMeshBuilder.h | 3c518e8cd173d9ebcb5e59ce1e7f8ac13594db13 | [
"LGPL-2.0-or-later",
"BSD-3-Clause",
"MIT"
] | permissive | lanping100/Iyan3d | c8292a0a7e4a34b5cb921c00f8bbe4ee30ba78aa | c21bb191cec06039a3f6e9b2f19381cbd7537757 | refs/heads/master | 2020-06-17T13:53:58.907502 | 2019-07-02T07:43:39 | 2019-07-02T07:43:39 | 195,943,149 | 1 | 0 | MIT | 2019-07-09T06:06:31 | 2019-07-09T06:06:31 | null | UTF-8 | C++ | false | false | 4,248 | h | /** Helper class to construct a dummy mesh for file formats containing only motion data */
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the
following conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------
*/
/** @file SkeletonMeshBuilder.h
* Declares SkeletonMeshBuilder, a tiny utility to build dummy meshes
* for animation skeletons.
*/
#ifndef AI_SKELETONMESHBUILDER_H_INC
#define AI_SKELETONMESHBUILDER_H_INC
#include <vector>
#include <assimp/mesh.h>
struct aiMaterial;
struct aiScene;
struct aiNode;
namespace Assimp {
// ---------------------------------------------------------------------------
/**
* This little helper class constructs a dummy mesh for a given scene
* the resembles the node hierarchy. This is useful for file formats
* that don't carry any mesh data but only animation data.
*/
class SkeletonMeshBuilder
{
public:
// -------------------------------------------------------------------
/** The constructor processes the given scene and adds a mesh there.
*
* Does nothing if the scene already has mesh data.
* @param pScene The scene for which a skeleton mesh should be constructed.
* @param root The node to start with. NULL is the scene root
* @param bKnobsOnly Set this to true if you don't want the connectors
* between the knobs representing the nodes.
*/
SkeletonMeshBuilder( aiScene* pScene, aiNode* root = NULL,
bool bKnobsOnly = false);
protected:
// -------------------------------------------------------------------
/** Recursively builds a simple mesh representation for the given node
* and also creates a joint for the node that affects this part of
* the mesh.
* @param pNode The node to build geometry for.
*/
void CreateGeometry( const aiNode* pNode);
// -------------------------------------------------------------------
/** Creates the mesh from the internally accumulated stuff and returns it.
*/
aiMesh* CreateMesh();
// -------------------------------------------------------------------
/** Creates a dummy material and returns it. */
aiMaterial* CreateMaterial();
protected:
/** space to assemble the mesh data: points */
std::vector<aiVector3D> mVertices;
/** faces */
struct Face
{
unsigned int mIndices[3];
Face();
Face( unsigned int p0, unsigned int p1, unsigned int p2)
{ mIndices[0] = p0; mIndices[1] = p1; mIndices[2] = p2; }
};
std::vector<Face> mFaces;
/** bones */
std::vector<aiBone*> mBones;
bool mKnobsOnly;
};
} // end of namespace Assimp
#endif // AI_SKELETONMESHBUILDER_H_INC
| [
"harishankar@19668fbc-42bf-4728-acef-d3afb4f12ffe"
] | harishankar@19668fbc-42bf-4728-acef-d3afb4f12ffe |
0e571edadcf6a2808de352e9f7997ccbdf5726fa | 599c7b0b0fe382aef54612cb7ab390dedd544a53 | /关键活动/关键活动.cpp | 2a46dbffed18213a038bee13d9c21d330566cc45 | [] | no_license | 617076674/MOOC-DataStructure-2018-Autumn | 807c28a317e5c71e26fc4ffaa12621cce7a076ca | e84ade083945c23b0fe1f0d6bd772450839428a8 | refs/heads/master | 2020-04-08T22:32:44.143338 | 2018-12-01T08:33:55 | 2018-12-01T08:33:55 | 159,791,209 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 4,139 | cpp | #include<iostream>
#include<vector>
#include<queue>
#include<set>
#include<algorithm>
using namespace std;
struct node {
int v;
int len;
node(int _v, int _len) {
v = _v;
len = _len;
}
};
struct activity {
int startV, endV;
activity(int _startV, int _endV) {
startV = _startV;
endV = _endV;
}
};
int N, M, inDegree[101], d[101], INF = 1000000000, countInq[101], resultMinTime = INF, startPoint;
vector<node> graph[101]; //邻接表形式存储图
bool inq[101];
vector<int> tempPath;
set<int> pre[101];
int inputSequence[101][101]; //记录每条边输入时的顺序
vector<activity> resultActivities; //保存关键路径上的边信息
void init();
bool spfa(int s);
void dfs(int nowVisit, bool visited[]);
bool cmp(activity a1, activity a2);
int main() {
scanf("%d %d", &N, &M); //读取节点数和边数
bool visited[M]; //标记第i条边是否已经在结果集里
fill(inDegree + 1, inDegree + N + 1, 0);
int v1, v2, len;
for(int i = 0; i < M; i++) {
scanf("%d %d %d", &v1, &v2, &len);
graph[v1].push_back(node(v2, -len));
inDegree[v2]++;
inputSequence[v1][v2] = i;
}
for(int i = 1; i <= N; i++) {
if(inDegree[i] == 0) { //入度为0的点是起点
init();
startPoint = i; //以点i为起点
bool flag = spfa(startPoint); //计算点i到其余点的最短路径
if(flag) {
int minTime = INF;
for(int j = 1; j <= N; j++) {
if(j != i && d[j] < minTime) { //寻找从点i到其余点的最短路径中的最小值
minTime = d[j]; //更新最小时间信息
}
}
if(minTime < resultMinTime) { //如果以i为起点到其余点的最短路径的最小值比当前的最小路径还要小
resultMinTime = minTime; //更新最小路径信息
resultActivities.clear(); //清空resultActivities
fill(visited, visited + M, false); //标记所有节点未被访问
for(int j = 1; j <= N; j++) {
if(j != i && d[j] == minTime) {
dfs(j, visited);
}
}
} else if(minTime == resultMinTime) {
for(int j = 1; j <= N; j++) {
if(j != i && d[j] == minTime) {
dfs(j, visited);
}
}
}
}
}
}
if(resultMinTime == INF) {
printf("0\n");
return 0;
}
printf("%d\n", -resultMinTime); //输出关键路径长度
sort(resultActivities.begin(), resultActivities.end(), cmp); //对结果边进行排序
for(int i = 0; i < resultActivities.size(); i++) { //输出结果
printf("%d->%d\n", resultActivities[i].startV, resultActivities[i].endV);
}
return 0;
}
void init() {
fill(d + 1, d + N + 1, INF);
fill(inq + 1, inq + N + 1, false);
fill(countInq + 1, countInq + N + 1, 0);
for(int j = 1; j <= N; j++) {
pre[j].clear();
}
}
bool spfa(int s) {
d[s] = 0;
queue<int> q;
q.push(s);
inq[s] = true;
countInq[s]++;
while(!q.empty()) {
int u = q.front();
q.pop();
inq[u] = false;
for(int i = 0; i < graph[u].size(); i++) {
int v = graph[u][i].v;
int len = graph[u][i].len;
if(d[u] + len < d[v]) {
d[v] = d[u] + len;
pre[v].clear();
pre[v].insert(u);
if(!inq[v]) {
q.push(v);
inq[v] = true;
countInq[v]++;
if(countInq[v] > N - 1) {
return false;
}
}
} else if(d[u] + len == d[v]) {
pre[v].insert(u);
if(!inq[v]) {
q.push(v);
inq[v] = true;
countInq[v]++;
if(countInq[v] > N - 1) {
return false;
}
}
}
}
}
return true;
}
void dfs(int nowVisit, bool visited[]) {
tempPath.push_back(nowVisit);
if(nowVisit == startPoint) {
for(int i = tempPath.size() - 1; i > 0; i--) {
int inputNumber = inputSequence[tempPath[i]][tempPath[i - 1]];
if(!visited[inputNumber]) {
resultActivities.push_back(activity(tempPath[i], tempPath[i - 1]));
visited[inputNumber] = true;
}
}
tempPath.pop_back();
return;
}
for(set<int>::iterator it = pre[nowVisit].begin(); it != pre[nowVisit].end(); it++) {
dfs(*it, visited);
}
tempPath.pop_back();
}
bool cmp(activity a1, activity a2) {
if(a1.startV == a2.startV) {
return inputSequence[a1.startV][a1.endV] > inputSequence[a2.startV][a2.endV];
} else {
return a1.startV < a2.startV;
}
}
| [
"617076674@qq.com"
] | 617076674@qq.com |
3eff95bf7e8f7a46970f0db8e58c3a8f0aba1a21 | 14a99edd81fe4437435dbe43bd25853c9cd8ae42 | /src/qtwallet/addressbookpage.cpp | 7e1645c6cddfe3d7277cb4c2e884d338e023b193 | [
"MIT"
] | permissive | devflames/pebblecoin | a89967b66054ad35d77bc7696c2c2dbd039f9e53 | 9572b868f2157cb044a60ad68c9cffc798b17144 | refs/heads/master | 2021-01-15T06:12:02.675609 | 2015-12-31T14:35:57 | 2015-12-31T14:35:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,671 | cpp | // Copyright (c) 2011-2013 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#if defined(HAVE_CONFIG_H)
#include "bitcoin-config.h"
#endif
#include "addressbookpage.h"
#include "ui_addressbookpage.h"
#include "addresstablemodel.h"
#include "bitcoingui.h"
#include "csvmodelwriter.h"
#include "editaddressdialog.h"
#include "guiutil.h"
#include <QIcon>
#include <QMenu>
#include <QMessageBox>
#include <QSortFilterProxyModel>
AddressBookPage::AddressBookPage(Mode mode, Tabs tab, QWidget *parent) :
QDialog(parent),
ui(new Ui::AddressBookPage),
model(0),
mode(mode),
tab(tab)
{
ui->setupUi(this);
#ifdef Q_OS_MAC // Icons on push buttons are very uncommon on Mac
ui->newAddress->setIcon(QIcon());
ui->copyAddress->setIcon(QIcon());
ui->deleteAddress->setIcon(QIcon());
ui->exportButton->setIcon(QIcon());
#endif
switch(mode)
{
case ForSelection:
switch(tab)
{
case SendingTab: setWindowTitle(tr("Choose the address to send coins to")); break;
case ReceivingTab: setWindowTitle(tr("Choose the address to receive coins with")); break;
}
connect(ui->tableView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(accept()));
ui->tableView->setEditTriggers(QAbstractItemView::NoEditTriggers);
ui->tableView->setFocus();
ui->closeButton->setText(tr("C&hoose"));
ui->exportButton->hide();
break;
case ForEditing:
switch(tab)
{
case SendingTab: setWindowTitle(tr("Sending addresses")); break;
case ReceivingTab: setWindowTitle(tr("Receiving addresses")); break;
}
break;
}
switch(tab)
{
case SendingTab:
ui->labelExplanation->setText(tr("These are your Pebblecoin addresses for sending payments. Always check the amount and the receiving address before sending coins."));
ui->deleteAddress->setVisible(true);
break;
case ReceivingTab:
ui->labelExplanation->setText(tr("These are your Pebblecoin addresses for receiving payments. It is recommended to use a new receiving address for each transaction."));
ui->deleteAddress->setVisible(false);
break;
}
// Context menu actions
QAction *copyAddressAction = new QAction(tr("&Copy Address"), this);
QAction *copyLabelAction = new QAction(tr("Copy &Label"), this);
QAction *editAction = new QAction(tr("&Edit"), this);
deleteAction = new QAction(ui->deleteAddress->text(), this);
// Build context menu
contextMenu = new QMenu();
contextMenu->addAction(copyAddressAction);
contextMenu->addAction(copyLabelAction);
contextMenu->addAction(editAction);
if(tab == SendingTab)
contextMenu->addAction(deleteAction);
contextMenu->addSeparator();
// Connect signals for context menu actions
connect(copyAddressAction, SIGNAL(triggered()), this, SLOT(on_copyAddress_clicked()));
connect(copyLabelAction, SIGNAL(triggered()), this, SLOT(onCopyLabelAction()));
connect(editAction, SIGNAL(triggered()), this, SLOT(onEditAction()));
connect(deleteAction, SIGNAL(triggered()), this, SLOT(on_deleteAddress_clicked()));
connect(ui->tableView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextualMenu(QPoint)));
connect(ui->closeButton, SIGNAL(clicked()), this, SLOT(accept()));
}
AddressBookPage::~AddressBookPage()
{
delete ui;
}
void AddressBookPage::setModel(AddressTableModel *model)
{
this->model = model;
if(!model)
return;
proxyModel = new QSortFilterProxyModel(this);
proxyModel->setSourceModel(model);
proxyModel->setDynamicSortFilter(true);
proxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
proxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
switch(tab)
{
case ReceivingTab:
// Receive filter
proxyModel->setFilterRole(AddressTableModel::TypeRole);
proxyModel->setFilterFixedString(AddressTableModel::Receive);
break;
case SendingTab:
// Send filter
proxyModel->setFilterRole(AddressTableModel::TypeRole);
proxyModel->setFilterFixedString(AddressTableModel::Send);
break;
}
ui->tableView->setModel(proxyModel);
ui->tableView->sortByColumn(0, Qt::AscendingOrder);
// Set column widths
#if QT_VERSION < 0x050000
ui->tableView->horizontalHeader()->setResizeMode(AddressTableModel::Label, QHeaderView::Stretch);
ui->tableView->horizontalHeader()->setResizeMode(AddressTableModel::Address, QHeaderView::ResizeToContents);
#else
ui->tableView->horizontalHeader()->setSectionResizeMode(AddressTableModel::Label, QHeaderView::Stretch);
ui->tableView->horizontalHeader()->setSectionResizeMode(AddressTableModel::Address, QHeaderView::ResizeToContents);
#endif
connect(ui->tableView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
this, SLOT(selectionChanged()));
// Select row for newly created address
connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(selectNewAddress(QModelIndex,int,int)));
selectionChanged();
}
void AddressBookPage::on_copyAddress_clicked()
{
GUIUtil::copyEntryData(ui->tableView, AddressTableModel::Address);
}
void AddressBookPage::onCopyLabelAction()
{
GUIUtil::copyEntryData(ui->tableView, AddressTableModel::Label);
}
void AddressBookPage::onEditAction()
{
if(!model)
return;
if(!ui->tableView->selectionModel())
return;
QModelIndexList indexes = ui->tableView->selectionModel()->selectedRows();
if(indexes.isEmpty())
return;
EditAddressDialog dlg(
tab == SendingTab ?
EditAddressDialog::EditSendingAddress :
EditAddressDialog::EditReceivingAddress, this);
dlg.setModel(model);
QModelIndex origIndex = proxyModel->mapToSource(indexes.at(0));
dlg.loadRow(origIndex.row());
dlg.exec();
}
void AddressBookPage::on_newAddress_clicked()
{
if(!model)
return;
EditAddressDialog dlg(
tab == SendingTab ?
EditAddressDialog::NewSendingAddress :
EditAddressDialog::NewReceivingAddress, this);
dlg.setModel(model);
if(dlg.exec())
{
newAddressToSelect = dlg.getAddress();
}
}
void AddressBookPage::on_deleteAddress_clicked()
{
QTableView *table = ui->tableView;
if(!table->selectionModel())
return;
QModelIndexList indexes = table->selectionModel()->selectedRows();
if(!indexes.isEmpty())
{
table->model()->removeRow(indexes.at(0).row());
}
}
void AddressBookPage::selectionChanged()
{
// Set button states based on selected tab and selection
QTableView *table = ui->tableView;
if(!table->selectionModel())
return;
if(table->selectionModel()->hasSelection())
{
switch(tab)
{
case SendingTab:
// In sending tab, allow deletion of selection
ui->deleteAddress->setEnabled(true);
ui->deleteAddress->setVisible(true);
deleteAction->setEnabled(true);
break;
case ReceivingTab:
// Deleting receiving addresses, however, is not allowed
ui->deleteAddress->setEnabled(false);
ui->deleteAddress->setVisible(false);
deleteAction->setEnabled(false);
break;
}
ui->copyAddress->setEnabled(true);
}
else
{
ui->deleteAddress->setEnabled(false);
ui->copyAddress->setEnabled(false);
}
}
void AddressBookPage::done(int retval)
{
QTableView *table = ui->tableView;
if(!table->selectionModel() || !table->model())
return;
// Figure out which address was selected, and return it
QModelIndexList indexes = table->selectionModel()->selectedRows(AddressTableModel::Address);
foreach (QModelIndex index, indexes)
{
QVariant address = table->model()->data(index);
returnValue = address.toString();
}
if(returnValue.isEmpty())
{
// If no address entry selected, return rejected
retval = Rejected;
}
QDialog::done(retval);
}
void AddressBookPage::on_exportButton_clicked()
{
// CSV is currently the only supported format
QString filename = GUIUtil::getSaveFileName(this,
tr("Export Address List"), QString(),
tr("Comma separated file (*.csv)"), NULL);
if (filename.isNull())
return;
CSVModelWriter writer(filename);
// name, column, role
writer.setModel(proxyModel);
writer.addColumn("Label", AddressTableModel::Label, Qt::EditRole);
writer.addColumn("Address", AddressTableModel::Address, Qt::EditRole);
if(!writer.write()) {
QMessageBox::critical(this, tr("Exporting Failed"),
tr("There was an error trying to save the address list to %1.").arg(filename));
}
}
void AddressBookPage::contextualMenu(const QPoint &point)
{
QModelIndex index = ui->tableView->indexAt(point);
if(index.isValid())
{
contextMenu->exec(QCursor::pos());
}
}
void AddressBookPage::selectNewAddress(const QModelIndex &parent, int begin, int /*end*/)
{
QModelIndex idx = proxyModel->mapFromSource(model->index(begin, AddressTableModel::Address, parent));
if(idx.isValid() && (idx.data(Qt::EditRole).toString() == newAddressToSelect))
{
// Select row of newly created address, once
ui->tableView->setFocus();
ui->tableView->selectRow(idx.row());
newAddressToSelect.clear();
}
}
| [
"xpbcreator@mac.hush.com"
] | xpbcreator@mac.hush.com |
95f3eb1c08458ce8d2f8c1f980cdfb107c0bd146 | 78388475a90d237c29c73b336fa8fc598d2e3bfa | /lazyfoo/lesson29/src/Dot.cpp | bc46c72c499fdf41c14aadd5673d489d5ccbc20a | [] | no_license | rangaofei/FFmpegDemo | 056941b6805b02012a1348091f9d58194a8ea197 | d0640c8fb7ff5ff1845bdee7602a309391ce5145 | refs/heads/master | 2020-03-17T17:32:44.349302 | 2018-05-25T09:49:06 | 2018-05-25T09:49:06 | 133,792,572 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,805 | cpp | //
// Created by saka on 18-5-22.
//
#include "Dot.h"
#include "LTexture.h"
Dot::Dot(int x, int y) {
posX = x;
posY = y;
collider.r = DOT_WIDTH / 2;
velX = 0;
velY = 0;
shiftColliders();
}
void Dot::handleEvent(SDL_Event &e) {
if (e.type == SDL_KEYDOWN && e.key.repeat == 0) {
switch (e.key.keysym.sym) {
case SDLK_UP:
velY -= DOT_VEL;
break;
case SDLK_DOWN:
velY += DOT_VEL;
break;
case SDLK_LEFT:
velX -= DOT_VEL;
break;
case SDLK_RIGHT:
velX += DOT_VEL;
break;
}
} else if (e.type == SDL_KEYUP && e.key.repeat == 0) {
switch (e.key.keysym.sym) {
case SDLK_UP:
velY += DOT_VEL;
break;
case SDLK_DOWN:
velY -= DOT_VEL;
break;
case SDLK_LEFT:
velX += DOT_VEL;
break;
case SDLK_RIGHT:
velX -= DOT_VEL;
break;
}
}
}
void Dot::render(LTexture *texture, SDL_Renderer *renderer) {
texture->render(posX - collider.r, posY - collider.r, renderer);
}
void Dot::shiftColliders() {
collider.x = posX;
collider.y = posY;
}
void Dot::move(SDL_Rect &square, Circle &circle) {
posX += velX;
shiftColliders();
if (posX < 0 || (posX + DOT_WIDTH > SCREEN_WIDTH)
|| checkCollision(collider, square) || checkCollision(collider, circle)) {
posX -= velX;
shiftColliders();
}
posY += velY;
shiftColliders();
if (posY < 0 || (posY + DOT_HEIGHT > SCREEN_HEIGHT)
|| checkCollision(collider, square) || checkCollision(collider, circle)) {
posY -= velY;
shiftColliders();
}
}
Circle &Dot::getCollider() {
return collider;
}
bool Dot::checkCollision(Circle &a, Circle &b) {
int totalRadiusSquared = a.r + b.r;
totalRadiusSquared = totalRadiusSquared * totalRadiusSquared;
if (distanceSquared(a.x, a.y, b.x, b.y) < totalRadiusSquared) {
return true;
}
return false;
}
bool Dot::checkCollision(Circle &a, SDL_Rect &b) {
int cX, cY;
if (a.x < b.x) {
cX = b.x;
} else if (a.x > b.x + b.w) {
cX = b.x + b.w;
} else {
cX = a.x;
}
if (a.y < b.y) {
cY = b.y;
} else if (a.y > b.y + b.h) {
cY = b.y + b.h;
} else {
cY = a.y;
}
if (distanceSquared(a.x, a.y, cX, cY) < a.r * a.r) {
return true;
}
return false;
}
double Dot::distanceSquared(int x1, int y1, int x2, int y2) {
int deltaX = x2 - x1;
int deltaY = y2 - y1;
return deltaX * deltaX + deltaY * deltaY;
}
| [
"876038559@qq.com"
] | 876038559@qq.com |
67b942612f4df6cdf59bd3995066ca08cdbde770 | 0cdb6d0a79bf0c9f5ae8205c7fad454a9a299933 | /kernel/cc/drv/driver.h | 215a741ea2c2745f6aa8e611a503fdcd034a1c6a | [] | no_license | beneschtech/CRBOs | 544792017145f8a8e436860bf82bfc00d20b2c29 | 33c4bc38a61b653c91a42d39d44b3bc1b7ee0b57 | refs/heads/master | 2021-09-01T08:06:16.078039 | 2017-12-25T23:04:13 | 2017-12-25T23:04:13 | 113,478,386 | 7 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,323 | h | #ifndef DRIVER_H
#define DRIVER_H
/**
* This is the driver root and base class implementation
*
* The general idea is that a driver can be either something that deals with hardware directly, or a parent group or controller class, ie Root->PS/2->keyboard
* A controller, like for example the PS/2 controller can look for a keyboard and mouse under it and create driver objects accordingly, which will themselves
* handle the interrupts
*
* Object oriented design in a kernel, the cornerstone of a microkernel
*/
// Dead Beef is not bad
#define DRIVERMAGIC 0xdeadbeef15407bad
#define DRIVERCHAINFUNC(t) IRQ##t
class Kernel;
// Base class, not directly used
class Driver
{
friend class Kernel;
public:
Driver(Driver *p = NULL):_magic(DRIVERMAGIC),parent(NULL),children(NULL),next(NULL),prev(NULL) { if (p) setParent(p); }
virtual ~Driver() { }
virtual void handle();
virtual const char *type() { return "Driver"; }
volatile u64 _magic;
Driver *parent;
Driver *children;
Driver *next;
Driver *prev;
void setParent(Driver *);
void startupMessage(bool bconf=false);
};
class DriverRoot : public Driver {
friend class Kernel;
public:
DriverRoot(): Driver::Driver() {}
const char *type() { return "DriverRoot"; }
void init();
};
#endif // DRIVER_H
| [
"chris@beneschtech.com"
] | chris@beneschtech.com |
181aea2a532440c4104b3252f106ff1a6c80744c | 3258bbad1c6027c19f0f4e251ddbf4539d5d3753 | /include/hpkmeans/initializers/initializers.hpp | 3eb15cee3a9b8f073f90361e002c910fa2f7a3cb | [
"MIT"
] | permissive | e-dang/K-Means | f1aa420961f316342c2e80ed9dbdec7555e82ad1 | 2cdcfe868e48384160cfd6998f026df07fa3e578 | refs/heads/master | 2020-09-06T07:16:52.865888 | 2020-06-30T21:17:04 | 2020-06-30T21:17:04 | 220,360,801 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 718 | hpp | #pragma once
#include <hpkmeans/initializers/kplusplus.hpp>
#include <memory>
#include <string>
namespace hpkmeans
{
template <typename T, Parallelism Level, class DistanceFunc>
std::unique_ptr<IInitializer<T, Level>> createInitializer(const std::string& initializerString)
{
if (initializerString == KPP)
return std::make_unique<KPlusPlus<T, Level, DistanceFunc>>(new AssignmentUpdater<T, Level, DistanceFunc>());
else if (initializerString == OPTKPP)
return std::make_unique<KPlusPlus<T, Level, DistanceFunc>>(
new NewCentroidAssignmentUpdater<T, Level, DistanceFunc>());
else
std::cerr << "Unrecognized initializer string!\n";
exit(1);
}
} // namespace hpkmeans | [
"edang830@gmail.com"
] | edang830@gmail.com |
eecdf1f71a0a8e8710afa32e1740512867dbd794 | 4b329041a8bd4b165e73f5052b44e485fe749180 | /RR2014-FRC1410/src/Commands/Autonomous/CommandGroups/FinishAuto/FinishAutoBackwards.cpp | f651c72a775aca16329d6c7e5d30cbcb18a288b2 | [] | no_license | Penchant/RR2015-FRC1410 | afa3548caa8c6254a4aaf7981b6ea0ec322e552e | 7f092d03351613344b9d66e4723c736e661f8ad1 | refs/heads/master | 2021-01-17T08:23:26.464218 | 2015-04-03T18:42:03 | 2015-04-03T18:42:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 205 | cpp | #include "FinishAutoBackwards.h"
#include "FinishAutoCommands/FinishAutoBackwards/FinishAutoDriveBackwards.h"
FinishAutoBackwards::FinishAutoBackwards(){
AddSequential(new FinishAutoDriveBackwards());
}
| [
"kingnerdthethird@outlook.com"
] | kingnerdthethird@outlook.com |
afa49b8097cb3ccb0bc39aaed156fdcd875fbc66 | bcfd3336ae1dcac5e6f3b9e2154caad199043b27 | /src/ledger/LedgerState.h | f1fb33b47763982fb3e7170c92ec254ce3155e22 | [
"MIT",
"BSD-3-Clause",
"BSL-1.0",
"Apache-2.0",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause"
] | permissive | acgchain/acg-core | 58ba9d4e0dd147c45a51b33017d75402cdce9531 | 098676521a3211ab702d5f473510dc07e60467e2 | refs/heads/master | 2020-07-26T11:57:58.634134 | 2019-10-08T03:39:28 | 2019-10-08T03:39:28 | 208,636,187 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,021 | h | #pragma once
// Copyright 2018 Stellar Development Foundation and contributors. Licensed
// under the Apache License, Version 2.0. See the COPYING file at the root
// of this distribution or at http://www.apache.org/licenses/LICENSE-2.0
#include "ledger/LedgerStateEntry.h"
#include "ledger/LedgerStateHeader.h"
#include "xdr/Stellar-ledger.h"
#include <functional>
#include <map>
#include <memory>
#include <set>
namespace acg
{
class Database;
struct InflationVotes;
struct LedgerEntry;
struct LedgerKey;
class LedgerRange;
bool isBetterOffer(LedgerEntry const& lhsEntry, LedgerEntry const& rhsEntry);
class AbstractLedgerState;
struct InflationWinner
{
AccountID accountID;
int64_t votes;
};
// LedgerStateDelta represents the difference between a LedgerState and its
// parent. Used in the Invariants subsystem.
struct LedgerStateDelta
{
struct EntryDelta
{
std::shared_ptr<LedgerEntry const> current;
std::shared_ptr<LedgerEntry const> previous;
};
struct HeaderDelta
{
LedgerHeader current;
LedgerHeader previous;
};
std::map<LedgerKey, EntryDelta> entry;
HeaderDelta header;
};
// An abstraction for an object that is iterator-like and permits enumerating
// the LedgerStateEntry objects managed by an AbstractLedgerState. This enables
// an AbstractLedgerStateParent to iterate over the entries managed by its child
// without any knowledge of the implementation of the child.
class EntryIterator
{
public:
class AbstractImpl;
private:
std::unique_ptr<AbstractImpl> mImpl;
std::unique_ptr<AbstractImpl> const& getImpl() const;
public:
EntryIterator(std::unique_ptr<AbstractImpl>&& impl);
EntryIterator(EntryIterator&& other);
EntryIterator& operator++();
explicit operator bool() const;
LedgerEntry const& entry() const;
bool entryExists() const;
LedgerKey const& key() const;
};
// An abstraction for an object that can be the parent of an AbstractLedgerState
// (discussed below). Allows children to commit atomically to the parent. Has no
// notion of a LedgerStateEntry or LedgerStateHeader (discussed respectively in
// LedgerStateEntry.h and LedgerStateHeader.h) but allows access to XDR objects
// such as LedgerEntry and LedgerHeader. This interface is designed such that
// concrete implementations can be databases or AbstractLedgerState objects. In
// general, this interface was not designed to be used directly by end users.
// Rather, end users should interact with AbstractLedgerStateParent through the
// AbstractLedgerState interface.
class AbstractLedgerStateParent
{
public:
virtual ~AbstractLedgerStateParent();
// addChild is called by a newly constructed AbstractLedgerState to become a
// child of AbstractLedgerStateParent. Throws if AbstractLedgerStateParent
// is in the sealed state or already has a child.
virtual void addChild(AbstractLedgerState& child) = 0;
// commitChild and rollbackChild are called by a child AbstractLedgerState
// to trigger an atomic commit or an atomic rollback of the data stored in
// the child.
virtual void commitChild(EntryIterator iter) = 0;
virtual void rollbackChild() = 0;
// getAllOffers, getBestOffer, and getOffersByAccountAndAsset are used to
// handle some specific queries related to Offers.
// - getAllOffers
// Get XDR for every offer, grouped by account.
// - getBestOffer
// Get XDR for the best offer with specified buying and selling assets.
// - getOffersByAccountAndAsset
// Get XDR for every offer owned by the specified account that is either
// buying or selling the specified asset.
virtual std::map<LedgerKey, LedgerEntry> getAllOffers() = 0;
virtual std::shared_ptr<LedgerEntry const>
getBestOffer(Asset const& buying, Asset const& selling,
std::set<LedgerKey>& exclude) = 0;
virtual std::map<LedgerKey, LedgerEntry>
getOffersByAccountAndAsset(AccountID const& account,
Asset const& asset) = 0;
// getHeader returns the LedgerHeader stored by AbstractLedgerStateParent.
// Used to allow the LedgerHeader to propagate to a child.
virtual LedgerHeader const& getHeader() const = 0;
// getInflationWinners is used to handle the specific queries related to
// inflation. Returns a maximum of maxWinners winners, each of which has a
// minimum of minBalance votes.
virtual std::vector<InflationWinner>
getInflationWinners(size_t maxWinners, int64_t minBalance) = 0;
// getNewestVersion finds the newest version of the LedgerEntry associated
// with the LedgerKey key by checking if there is a version stored in this
// AbstractLedgerStateParent, and if not recursively invoking
// getNewestVersion on its parent. Returns nullptr if the key does not exist
// or if the corresponding LedgerEntry has been erased.
virtual std::shared_ptr<LedgerEntry const>
getNewestVersion(LedgerKey const& key) const = 0;
};
// An abstraction for an object that is an AbstractLedgerStateParent and has
// transaction semantics. AbstractLedgerStates manage LedgerStateEntry and
// LedgerStateHeader objects to allow data to be created, modified, and erased.
class AbstractLedgerState : public AbstractLedgerStateParent
{
// deactivate is used to deactivate the LedgerStateEntry associated with the
// given key.
friend class LedgerStateEntry::Impl;
friend class ConstLedgerStateEntry::Impl;
virtual void deactivate(LedgerKey const& key) = 0;
// deactivateHeader is used to deactivate the LedgerStateHeader.
friend class LedgerStateHeader::Impl;
virtual void deactivateHeader() = 0;
public:
// Automatically rollback the data stored in the AbstractLedgerState if it
// has not already been committed or rolled back.
virtual ~AbstractLedgerState();
// commit and rollback trigger an atomic commit into the parent or an atomic
// rollback of the data stored in the AbstractLedgerState.
virtual void commit() = 0;
virtual void rollback() = 0;
// loadHeader, create, erase, load, and loadWithoutRecord provide the main
// interface to interact with data stored in the AbstractLedgerState. These
// functions only allow one instance of a particular data to be active at a
// time.
// - loadHeader
// Loads the current LedgerHeader. Throws if there is already an active
// LedgerStateHeader.
// - create
// Creates a new LedgerStateEntry from entry. Throws if the key
// associated with this entry is already associated with an entry in
// this AbstractLedgerState or any parent.
// - erase
// Erases the existing LedgerEntry associated with key. Throws if the
// key is not already associated with an entry in this
// AbstractLedgerState or any parent. Throws if there is an active
// LedgerStateEntry associated with this key.
// - load:
// Loads a LedgerEntry by key. Returns nullptr if the key is not
// associated with an entry in this AbstractLedgerState or in any
// parent. Throws if there is an active LedgerStateEntry associated with
// this key.
// - loadWithoutRecord:
// Similar to load, but the load is not recorded (meaning that it does
// not lead to a LIVE entry in the bucket list) and the loaded data is
// const as a consequence. Note that if the key was already recorded
// then it will still be recorded after calling loadWithoutRecord.
// Throws if there is an active LedgerStateEntry associated with this
// key.
// All of these functions throw if the AbstractLedgerState is sealed or if
// the AbstractLedgerState has a child.
virtual LedgerStateHeader loadHeader() = 0;
virtual LedgerStateEntry create(LedgerEntry const& entry) = 0;
virtual void erase(LedgerKey const& key) = 0;
virtual LedgerStateEntry load(LedgerKey const& key) = 0;
virtual ConstLedgerStateEntry loadWithoutRecord(LedgerKey const& key) = 0;
// getChanges, getDelta, getDeadEntries, and getLiveEntries are used to
// extract information about changes contained in the AbstractLedgerState
// in different formats. These functions also cause the AbstractLedgerState
// to enter the sealed state, simultaneously updating last modified if
// necessary.
// - getChanges
// Extract all changes from this AbstractLedgerState in XDR format. To
// be stored as meta.
// - getDelta
// Extract all changes from this AbstractLedgerState (including changes
// to the LedgerHeader) in a format convenient for answering queries
// about how specific entries and the header have changed. To be used
// for invariants.
// - getDeadEntries and getLiveEntries
// getDeadEntries extracts a list of keys that are now dead, whereas
// getLiveEntries extracts a list of entries that were recorded and
// are still alive. To be inserted into the BucketList.
// All of these functions throw if the AbstractLedgerState has a child.
virtual LedgerEntryChanges getChanges() = 0;
virtual LedgerStateDelta getDelta() = 0;
virtual std::vector<LedgerKey> getDeadEntries() = 0;
virtual std::vector<LedgerEntry> getLiveEntries() = 0;
// loadAllOffers, loadBestOffer, and loadOffersByAccountAndAsset are used to
// handle some specific queries related to Offers. These functions are built
// on top of load, and so share many properties with that function.
// - loadAllOffers
// Load every offer, grouped by account.
// - loadBestOffer
// Load the best offer with specified buying and selling assets.
// - loadOffersByAccountAndAsset
// Load every offer owned by the specified account that is either buying
// or selling the specified asset.
// All of these functions throw if the AbstractLedgerState is sealed or if
// the AbstractLedgerState has a child. These functions also throw if any
// LedgerKey they try to load is already active.
virtual std::map<AccountID, std::vector<LedgerStateEntry>>
loadAllOffers() = 0;
virtual LedgerStateEntry loadBestOffer(Asset const& buying,
Asset const& selling) = 0;
virtual std::vector<LedgerStateEntry>
loadOffersByAccountAndAsset(AccountID const& accountID,
Asset const& asset) = 0;
// queryInflationWinners is a wrapper around getInflationWinners that throws
// if the AbstractLedgerState is sealed or if the AbstractLedgerState has a
// child.
virtual std::vector<InflationWinner>
queryInflationWinners(size_t maxWinners, int64_t minBalance) = 0;
// unsealHeader is used to modify the LedgerHeader after AbstractLedgerState
// has entered the sealed state. This is required to update bucketListHash,
// which can only be done after getDeadEntries and getLiveEntries have been
// called.
virtual void unsealHeader(std::function<void(LedgerHeader&)> f) = 0;
};
class LedgerState final : public AbstractLedgerState
{
class Impl;
std::unique_ptr<Impl> mImpl;
void deactivate(LedgerKey const& key) override;
void deactivateHeader() override;
std::unique_ptr<Impl> const& getImpl() const;
public:
explicit LedgerState(AbstractLedgerStateParent& parent,
bool shouldUpdateLastModified = true);
explicit LedgerState(LedgerState& parent,
bool shouldUpdateLastModified = true);
virtual ~LedgerState();
void addChild(AbstractLedgerState& child) override;
void commit() override;
void commitChild(EntryIterator iter) override;
LedgerStateEntry create(LedgerEntry const& entry) override;
void erase(LedgerKey const& key) override;
std::map<LedgerKey, LedgerEntry> getAllOffers() override;
std::shared_ptr<LedgerEntry const>
getBestOffer(Asset const& buying, Asset const& selling,
std::set<LedgerKey>& exclude) override;
LedgerEntryChanges getChanges() override;
std::vector<LedgerKey> getDeadEntries() override;
LedgerStateDelta getDelta() override;
std::map<LedgerKey, LedgerEntry>
getOffersByAccountAndAsset(AccountID const& account,
Asset const& asset) override;
LedgerHeader const& getHeader() const override;
std::vector<InflationWinner>
getInflationWinners(size_t maxWinners, int64_t minBalance) override;
std::vector<InflationWinner>
queryInflationWinners(size_t maxWinners, int64_t minBalance) override;
std::vector<LedgerEntry> getLiveEntries() override;
std::shared_ptr<LedgerEntry const>
getNewestVersion(LedgerKey const& key) const override;
LedgerStateEntry load(LedgerKey const& key) override;
std::map<AccountID, std::vector<LedgerStateEntry>> loadAllOffers() override;
LedgerStateEntry loadBestOffer(Asset const& buying,
Asset const& selling) override;
LedgerStateHeader loadHeader() override;
std::vector<LedgerStateEntry>
loadOffersByAccountAndAsset(AccountID const& accountID,
Asset const& asset) override;
ConstLedgerStateEntry loadWithoutRecord(LedgerKey const& key) override;
void rollback() override;
void rollbackChild() override;
void unsealHeader(std::function<void(LedgerHeader&)> f) override;
};
class LedgerStateRoot : public AbstractLedgerStateParent
{
class Impl;
std::unique_ptr<Impl> const mImpl;
public:
explicit LedgerStateRoot(Database& db, size_t entryCacheSize = 4096,
size_t bestOfferCacheSize = 64);
virtual ~LedgerStateRoot();
void addChild(AbstractLedgerState& child) override;
void commitChild(EntryIterator iter) override;
uint64_t countObjects(LedgerEntryType let) const;
uint64_t countObjects(LedgerEntryType let,
LedgerRange const& ledgers) const;
void deleteObjectsModifiedOnOrAfterLedger(uint32_t ledger) const;
void dropAccounts();
void dropData();
void dropOffers();
void dropTrustLines();
std::map<LedgerKey, LedgerEntry> getAllOffers() override;
std::shared_ptr<LedgerEntry const>
getBestOffer(Asset const& buying, Asset const& selling,
std::set<LedgerKey>& exclude) override;
std::map<LedgerKey, LedgerEntry>
getOffersByAccountAndAsset(AccountID const& account,
Asset const& asset) override;
LedgerHeader const& getHeader() const override;
std::vector<InflationWinner>
getInflationWinners(size_t maxWinners, int64_t minBalance) override;
std::shared_ptr<LedgerEntry const>
getNewestVersion(LedgerKey const& key) const override;
void rollbackChild() override;
};
}
| [
"ubuntu@ip-172-31-20-103.ap-southeast-1.compute.internal"
] | ubuntu@ip-172-31-20-103.ap-southeast-1.compute.internal |
d5e8f0b00d68b422ee0d781e344404c27cadadaa | c23105b50db766572c29d3d2e928432cd84caae4 | /Project66/Project66/Source.cpp | 5218117751192fa63b590e32087e1415f79e5785 | [] | no_license | jh3898/c_leetcode | 1817a87a970be96f0a4559718b6fc84bf3eb7611 | 4d98fc08691f2f61545b8d1471a881b6b081d207 | refs/heads/master | 2021-05-11T02:52:57.746043 | 2018-01-21T22:07:18 | 2018-01-21T22:07:18 | 118,373,905 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 592 | cpp | #include<iostream>
#include<vector>
#include<unordered_map>
using namespace std;
class Solution {
public:
vector<int> two_sum(int m, vector<int> S) {
unordered_map<int,int> path;
pair<int,int> result;
path[m- S[0]] =0;
for (int i = 1; i < S.size(); i++) {
if (path.find(S[i]) != path.end() & path[S[i]]>i) {
result.push_back(S[i]);
}
else {
path[m-S[i]] = i;
}
}
return result;
}
};
int main() {
Solution sl2;
vector<int> S = { 1,2,3,6,8 };
vector<int> result;
int m = 9;
result= sl2.two_sum(m, S);
for (auto i : result) {
cout << i << endl;
}
} | [
"jh3898@nyu.edu"
] | jh3898@nyu.edu |
2adf2eef17a27e68302f93787c39a38c960db0b2 | 9e29eea0c3e42878fe4b9186c617f5d9913b9ddf | /src/util.hpp | c2066fe8a16633410f092f920b4f0fb6cf611fc2 | [
"Apache-2.0"
] | permissive | fretboardfreak/audiowav | d844c2bd38c7f418bf819ac661f6e9bc0735aba2 | ea7f8b5e0f34557f9fdf2a459320976739647395 | refs/heads/master | 2020-05-18T02:41:10.350342 | 2019-04-26T16:52:14 | 2019-04-26T16:52:15 | 184,124,163 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 745 | hpp | /*
* Copyright 2019 Curtis Sand
*
* 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.
*/
#ifndef UTIL_HPP
#define UTIL_HPP
/* Test whether float A is close enough to float B to call them equal. */
bool is_close(float A, float B);
#endif
| [
"curtis@curtissand.com"
] | curtis@curtissand.com |
11dec210c2ecf855dea85706ce217e9a6473b901 | 4738be691b674791470cf76ed517ec7ec511a971 | /ADS-implememtation/Prep Work/sqrt_using_binarySearch.cpp | 0783e2fef660813f999a9bb4c1c9376208ca05cd | [] | no_license | TanviSutar/ADS | 2b3b0f4075d46130881d45213063ef1c45c954dc | cc55adcf44abe95d879a63549e6701ccc71010cd | refs/heads/master | 2023-07-05T13:13:29.419985 | 2021-08-11T08:48:45 | 2021-08-11T08:48:45 | 303,682,176 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 583 | cpp | //Find square root of Guven Num without sqrt() function in Time Complexity O(Logn) and No Space Complexity Asked in : Accolite, Qualcomm
#include<bits/stdc++.h>
using namespace std;
int findSqrt(int x)
{
int low = 1, high = x, ans;
while(low <= high){
int mid = (low+high)/2;
if(mid*mid == x) return mid;
if(mid*mid > x) high = mid -1;
else{
low = mid +1;
ans = mid;
}
}
return ans;
}
int main()
{
int x = 8;
cout << findSqrt(x) << endl;
return 0;
} | [
"tanvisutar888@gmail.com"
] | tanvisutar888@gmail.com |
6fdc0d3c64772702265191b74eeb28e888363b9a | 67cf0c1800aeeec1e97773ac57a536a03f0a367d | /gravity.cpp | 5f648c3c5ca29d77dcf21ebd16db7290199101be | [] | no_license | b-hodge/competitive_programming | 23ca6429acd84f7b8bc503005b9e968fafaeec74 | 62dba85494212010c273fdc355d1de3604760df4 | refs/heads/master | 2016-08-12T02:37:23.285410 | 2016-02-25T02:39:39 | 2016-02-25T02:39:39 | 51,408,245 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 567 | cpp | #include <stdio.h>
#include <stdlib.h>
#include <iostream>
void compare(int i, int n, int * cols) {
if(cols[i] > cols[i+1]) {
int diff = cols[i] - cols[i+1];
cols[i] -= diff;
cols[i+1] += diff;
if (i+1 < n-1) {
compare(i+1, n, cols);
}
}
if (i != 0) {
compare(i-1, n, cols);
}
return;
}
int main() {
int n;
std::cin >> n;
int cols[n];
for (int i = 0; i < n; i++) {
std::cin >> cols[i];
}
if (n > 1) {
compare(n-2, n, cols);
}
// print cols
for (int j = 0; j < n; j++) {
printf("%d ", cols[j]);
}
//printf("\n");
return 0;
} | [
"brianhodge@utexas.edu"
] | brianhodge@utexas.edu |
3f1a473c70bca7307f5359a1fdbd79e1d9cc46a2 | 991e5cc571401cf47377c2d351464d13aa24f002 | /PQ12/PQ12_UT/stdafx.cpp | 48bd9805f66a5cf0c2c7502f238986a032482c18 | [] | no_license | robcio89/coursera-algo1 | fb3e408becbb005eeb8d5addf78bc0337c1d8bcd | e3466eef489fe38555424bae12228bc586575aa7 | refs/heads/master | 2020-05-27T20:16:05.526958 | 2015-09-07T14:06:15 | 2015-09-07T14:06:15 | 35,534,674 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 285 | cpp | // stdafx.cpp : source file that includes just the standard includes
// PQ1_UT.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
// TODO: reference any additional headers you need in STDAFX.H
// and not in this file
| [
"robcio89@gmail.com"
] | robcio89@gmail.com |
af94b8a5575260e911cf67586040adeef0750cef | 10560f64e0936560e4621ae31475a9bb65b3ffcd | /source/qt_Kviewer/s4KlogicRect.cpp | b4b113ded101f53370caf7ec6ccdbb41601edb25 | [
"MIT"
] | permissive | chunyisong/s4 | c775e5789d61e5c0940e2f8c38162b2e3bc325b7 | e57f17e729050da09e051221d20dc384027e6f62 | refs/heads/master | 2022-11-21T00:52:31.763539 | 2020-07-19T13:51:37 | 2020-07-19T13:51:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,616 | cpp | #include "qt_Kviewer/s4KlogicRect.h"
#include "qt_Kviewer/s4Kinstrument_scene.h"
namespace S4{
namespace QT{
//grow in vertical
void KlogicRect_h_t::mkGroupItems(void)
{
if(!_scene) return;
_color_positive.body.setAlpha(_alpha);
_color_negtive.body.setAlpha(_alpha);
qreal x = _scene->val_w_to_x(_value.seq);
_x_min = x - _scene->getCtx().val_w_pxl() * 0.8/2;
_x_max = x + _scene->getCtx().val_w_pxl() * 0.8/2;
_y_top = _scene->val_h_to_y(_value.val_top);
_y_btm = _scene->val_h_to_y(_value.val_btm);
QBrush* brush;
if(_value.positive){ //rise
brush = new QBrush(_color_positive.body, Qt::SolidPattern);
}else{
brush = new QBrush(_color_negtive.body, Qt::SolidPattern);
}
QGraphicsRectItem* body = new QGraphicsRectItem(_x_min, _y_top, _x_max - _x_min, _y_btm - _y_top);
body->setPen(QPen(Qt::NoPen));
body->setBrush(*brush);
body->setZValue(1);
addToGroup(body);
}
void KlogicRectGroup_h_t::mkGroupItems(void)
{
if(!_scene) return;
for(const auto& v : _valueList){
KlogicRect_h_t* rect = new KlogicRect_h_t(_scene);
rect->setColor(_color_positive, _color_negtive);
rect->setValue(v);
rect->setAlpha(_alpha);
rect->mkGroupItems();
addToGroup(rect);
}
}
//grow in horizontal
void KlogicRect_w_t::mkGroupItems(void)
{
if(!_scene) return;
_color_positive.body.setAlpha(_alpha);
_color_negtive.body.setAlpha(_alpha);
//qreal y = _scene->val_h_to_y(_value.val_h);
qreal y_min = _scene->val_h_to_y(_value.val_h + _value.val_h_scope / 2);
qreal y_max = _scene->val_h_to_y(_value.val_h - _value.val_h_scope / 2);
_x_min = _scene->val_w_to_x(_value.val_lf);
_x_max = _scene->val_w_to_x(_value.val_rt);
QBrush* brush;
if(_value.positive){ //rise
brush = new QBrush(_color_positive.body, Qt::SolidPattern);
}else{
brush = new QBrush(_color_negtive.body, Qt::SolidPattern);
}
QGraphicsRectItem* body = new QGraphicsRectItem(_x_min, y_min, _x_max - _x_min, y_max - y_min);
body->setPen(QPen(Qt::NoPen));
body->setBrush(*brush);
body->setZValue(1);
addToGroup(body);
}
void KlogicRectGroup_w_t::mkGroupItems(void)
{
if(!_scene) return;
for(const auto& v : _valueList){
KlogicRect_w_t* rect = new KlogicRect_w_t(_scene);
rect->setColor(_color_positive, _color_negtive);
rect->setValue(v);
rect->setAlpha(_alpha);
rect->mkGroupItems();
addToGroup(rect);
}
}
} // namespace QT
} // namespace S4 | [
"chinsaiki@outlook.com"
] | chinsaiki@outlook.com |
f956a61045128514563d6a9fb727cad539a6f49c | 4afc6182476e8e381ea0913f7b1205edf384a029 | /.build/iOS-Debug/include/app/Uno.EventHandler__Uno_Platform_TextInputEventArgs.h | d6794b7590d3160fb07ae5b33149e9963bd6707c | [] | no_license | noircynical/soscon_demoproject | 45a4b5594582447001c2895e24cf2e6566095a63 | aab19822fb8bc46715e6b41ac785faf7a128d9e7 | refs/heads/master | 2021-01-10T05:41:33.994651 | 2015-10-28T04:27:43 | 2015-10-28T04:27:43 | 45,085,497 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 481 | h | // This file was generated based on '/usr/local/share/uno/Packages/UnoCore/0.13.2/Source/Uno/$.uno'.
// WARNING: Changes might be lost if you edit this file directly.
#ifndef __APP_UNO_EVENT_HANDLER__UNO_PLATFORM_TEXT_INPUT_EVENT_ARGS_H__
#define __APP_UNO_EVENT_HANDLER__UNO_PLATFORM_TEXT_INPUT_EVENT_ARGS_H__
#include <app/Uno.Delegate.h>
#include <Uno.h>
namespace app {
namespace Uno {
::uDelegateType* EventHandler__Uno_Platform_TextInputEventArgs__typeof();
}}
#endif
| [
"0101rgb@gmail.com"
] | 0101rgb@gmail.com |
03a30172408fac93dfc44c898d20d851f606f523 | e152344168d3ff2765696354d020a41ae00c8b17 | /Codeforce/RandomSolves/multitasking_2pointer.cpp | 5d21f1de6f1168878461dccc235c3630e70c4772 | [] | no_license | Sasha2508/Python-Codes | 298e176aee2ff4a737676b62e02bdf6df9063ced | d0da8ecd6d6045be29fe449011e8c69c2882cac3 | refs/heads/master | 2023-04-29T23:28:24.383711 | 2021-05-10T18:00:12 | 2021-05-10T18:00:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12 | cpp | # Not Solved | [
"tuhinmitra190221@gmail.com"
] | tuhinmitra190221@gmail.com |
cc235afc4693010e99112f955b7ec12a43ab5337 | e9f6461fea7045bb07fc2be09ae1a9ec609b50f0 | /2011/server_src/Console/Console/CustomControl/CustomButton.cpp | 8c629b3283b7a526e6b62b285ab031e50dc44824 | [] | no_license | cash2one/important-files | bd1a88ea30e3ff16b4fbba6b4939ab6b13f5a6c8 | 12aebeae6322fafb89869ab15eac588420cbb004 | refs/heads/master | 2021-01-15T23:20:54.484632 | 2012-09-19T04:21:08 | 2012-09-19T04:21:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,883 | cpp | #include "stdafx.h"
#include "CustomButton.h"
#include "../../../../include/ui/wtl/atlgdi.h"
#include "../../../../include/ui/ImageHelpers.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
IMPLEMENT_DYNAMIC(CCustomButton, CButton)
CCustomButton::CCustomButton()
: normal_(new ATL::CImage)
, hover_(new ATL::CImage)
, press_(new ATL::CImage)
, disable_(new ATL::CImage)
, isHover_(false)
{}
CCustomButton::~CCustomButton()
{
}
BEGIN_MESSAGE_MAP(CCustomButton, CButton)
ON_WM_ERASEBKGND()
ON_WM_MOUSEMOVE()
ON_WM_MOUSELEAVE()
ON_WM_CREATE()
ON_WM_MOVE()
ON_WM_SIZE()
END_MESSAGE_MAP()
void CCustomButton::SetThememParent(HWND wnd)
{
ATLASSERT(::IsWindow(wnd));
parent_ = wnd;
if( !brBack_.IsNull() )
brBack_.DeleteObject();
}
void CCustomButton::SetTextClr(COLORREF normal, COLORREF clrHover, COLORREF clrPress, COLORREF clrDisable)
{
clrText_[0] = normal;
clrText_[1] = clrHover;
clrText_[2] = clrPress;
clrText_[3] = clrDisable;
if( IsWindow(GetSafeHwnd()) )
Invalidate();
}
void CCustomButton::SetImages(HBITMAP normal, HBITMAP hover, HBITMAP press, HBITMAP disable)
{
if( !normal_->IsNull() )
normal_->Detach();
if( !hover_->IsNull() )
hover_->Detach();
if( !press_->IsNull() )
press_->Detach();
normal_->Attach(CopyBitmap(normal));
hover_->Attach(CopyBitmap(hover));
press_->Attach(CopyBitmap(press));
if( disable == 0 )
{
if( !disable_->IsNull() )
disable_->Detach();
disable_->Attach(CopyBitmap(normal));
}
else
{
if( !disable_->IsNull() )
disable_->Detach();
disable_->Attach(CopyBitmap(disable));
}
if( IsWindow(GetSafeHwnd()) )
Invalidate();
}
void CCustomButton::_Init()
{
CWindow self(GetSafeHwnd());
parent_ = self.GetTopLevelWindow();
clrText_[0] = RGB(0, 0, 0);
clrText_[1] = RGB(0, 0, 0);
clrText_[2] = RGB(0, 0, 0);
clrText_[3] = RGB(128, 128, 128);
textStyle_ = DT_SINGLELINE | DT_VCENTER | DT_CENTER;
LOGFONT lf = {0};
GetObject(GetStockObject(DEFAULT_GUI_FONT), sizeof(lf), &lf);
if( font_.m_hObject != 0 )
font_.DeleteObject();
font_.CreateFontIndirect(&lf);
}
void CCustomButton::PreSubclassWindow()
{
__super::PreSubclassWindow();
ModifyStyle(0, BS_OWNERDRAW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
_Init();
}
void CCustomButton::DrawItem(LPDRAWITEMSTRUCT lpDis)
{
LPNMCUSTOMDRAW *custom = reinterpret_cast<LPNMCUSTOMDRAW *>(lpDis);
WTL::CDCHandle tmpDC = lpDis->hDC;
CRect rcClient(lpDis->rcItem);
WTL::CMemoryDC dc(tmpDC, rcClient);
bool isHot = isHover_;//((lpDis->itemState & CDIS_HOT) != 0);
bool isDisable = ((lpDis->itemState & CDIS_DISABLED) != 0);
bool isPress = ((lpDis->itemState & CDIS_SELECTED) != 0);
// Parent Bk
if( brBack_.IsNull() )
brBack_ = AtlGetBackgroundBrush(GetSafeHwnd(), parent_);
HBRUSH hOldBrush = dc.SelectBrush(brBack_);
dc.PatBlt(rcClient.left, rcClient.top, rcClient.Width(), rcClient.Height(), PATCOPY);
dc.SelectBrush(hOldBrush);
// Button
ATL::CImage *curImg = 0;
if( isDisable )
curImg = disable_.get();
else if( isPress )
curImg = press_.get();
else if( isHot )
curImg = hover_.get();
else
curImg = normal_.get();
CRect rcImg(0, 0, curImg->GetWidth(), curImg->GetHeight());
curImg->Draw(dc, rcClient, rcImg);
// Image Right
CRect rcClientRight(rcClient.right - 2, rcClient.top, rcClient.right, rcClient.bottom);
CRect rcImgRight(curImg->GetWidth() - 2, 0, curImg->GetWidth(), curImg->GetHeight());
curImg->Draw(dc, rcClientRight, rcImgRight);
// Text
CString text;
GetWindowText(text);
COLORREF clrText = clrText_[0];
if( isHot )
clrText = clrText_[1];
if( isPress )
clrText = clrText_[2];
if( isDisable )
clrText = clrText_[3];
HFONT hOldFont = dc.SelectFont(font_);
dc.SetBkMode(TRANSPARENT);
dc.SetTextColor(clrText);
dc.DrawText(text, text.GetLength(), &rcClient, textStyle_);
dc.SelectFont(hOldFont);
}
int CCustomButton::OnCreate(LPCREATESTRUCT lp)
{
_Init();
return __super::OnCreate(lp);
}
BOOL CCustomButton::OnEraseBkgnd(CDC*)
{
return TRUE;
}
void CCustomButton::OnSize(UINT flag, int x, int y)
{
if( !brBack_.IsNull() )
brBack_.DeleteObject();
return __super::OnSize(flag, x, y);
}
void CCustomButton::OnMove(int x, int y)
{
if( !brBack_.IsNull() )
brBack_.DeleteObject();
return __super::OnMove(x, y);
}
void CCustomButton::OnMouseMove(UINT, CPoint)
{
if( !isHover_ )
{
TRACKMOUSEEVENT tme = { 0 };
tme.cbSize = sizeof(tme);
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = m_hWnd;
_TrackMouseEvent(&tme);
isHover_ = true;
Invalidate();
}
}
void CCustomButton::OnMouseLeave()
{
if( isHover_ )
{
isHover_ = false;
Invalidate();
}
} | [
"chenyu2202863@gmail.com@38044a6e-7afd-79ad-2151-d0cf963d283a"
] | chenyu2202863@gmail.com@38044a6e-7afd-79ad-2151-d0cf963d283a |
7aaa55dd9500d64b5198c8305d61f9d39a5bfe2e | 5770e1c7fa3885f5019df14098c9c4f619a42fd8 | /event/src/MCEcalHit.cxx | ae05e56f2859b83def30e7fc51745ae6717619cb | [] | no_license | JeffersonLab/hpstr | db780fcd8c403f785b3013b1072abe147f821b60 | 4cb8342a80397d6b0704e9f1c120505fd98d2163 | refs/heads/master | 2023-08-28T11:19:19.605538 | 2023-08-24T21:54:20 | 2023-08-24T21:54:20 | 168,252,322 | 3 | 12 | null | 2023-08-24T21:54:21 | 2019-01-30T00:34:13 | C++ | UTF-8 | C++ | false | false | 896 | cxx | /**
* @file MCEcalHit.cxx
* @brief Class used to encapsulate mc tracker hit information
* @author Cameron Bravo, SLAC National Accelerator Laboratory
*/
#include "MCEcalHit.h"
ClassImp(MCEcalHit)
MCEcalHit::MCEcalHit()
: TObject() {
}
MCEcalHit::~MCEcalHit() {
Clear();
}
void MCEcalHit::Clear(Option_t* /* options */) {
TObject::Clear();
}
void MCEcalHit::setPosition(const double* position, bool rotate) {
//svt angle: it's already with minus sign.
float svtAngle = 30.5e-3;
//Rotate the the input position automatically to match with the SVT tracker system
if (rotate)
{
y_ = position[2];
z_ = position[1] * sin(svtAngle) + position[0]*cos(svtAngle);
x_ = position[1] * cos(svtAngle) - position[0]*sin(svtAngle);
}
else {
x_ = position[0];
y_ = position[1];
z_ = position[2];
}
}
| [
"bravo@slac.stanford.edu"
] | bravo@slac.stanford.edu |
562eb24e317bf6210146afdeb4402d1e5e6add2c | b97a55265a023f5df816ffaa8b78f8f243b74bd1 | /ScrabbleSolver/ScrabbleLookup.h | 568a433aba51aa62b430b6b60a091af40686da17 | [] | no_license | nainapjj/ScarabbleSolver | 568558efecfac162a800e1b75040876a909a1250 | c6764fe97e16967866d470e32b5cdfce0d8dc810 | refs/heads/master | 2021-01-01T19:01:39.719871 | 2014-01-02T15:38:20 | 2014-01-02T15:38:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 558 | h | //
// ScrabbleLookup.h
// ScrabbleSolver
//
// Created by Jeff Nainaparampil on 6/9/13.
// Copyright (c) 2013 Jeff Nainaparampil. All rights reserved.
//
#ifndef __ScrabbleSolver__ScrabbleLookup__
#define __ScrabbleSolver__ScrabbleLookup__
#include <iostream>
using namespace std;
class ScrabbleLookup
{
private:
// Array of scrabble point values
int lookupTable[26];
public:
ScrabbleLookup();
int pointValue(string word); // Returns the total point value of a certain word
};
#endif /* defined(__ScrabbleSolver__ScrabbleLookup__) */
| [
"jeffxtreme@gmail.com"
] | jeffxtreme@gmail.com |
44859ce1b1e6250716f87266d83845f8c570eef9 | bb273aab12dff441f988225ae7a5a26fcdce34b2 | /src/opencvtest.cpp | a8e627c7d586b58111c1c311ba8471928e666469 | [] | no_license | guidoholz/test_nerves_custom_rpi0_opencv | 17c5a65a1ec0694a1872a8178953a597415f3693 | 693802558b3cd04d152d47b05a2518081cdd9da2 | refs/heads/master | 2021-05-07T01:28:29.533047 | 2017-11-11T13:08:42 | 2017-11-11T13:08:42 | 110,344,242 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 947 | cpp | #include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <iostream>
using namespace cv;
using namespace std;
int main(int argc, char** argv) {
if(argc > 1){
cout << "is working"<<endl;
exit(0);
}
Mat input_image = (Mat_<uchar>(8, 8) <<
0, 0, 0, 0, 0, 0, 0, 0,
0, 255, 255, 255, 0, 0, 0, 255,
0, 255, 255, 255, 0, 0, 0, 0,
0, 255, 255, 255, 0, 255, 0, 0,
0, 0, 255, 0, 0, 0, 0, 0,
0, 0, 255, 0, 0, 255, 255, 0,
0, 255, 0, 255, 0, 0, 255, 0,
0, 255, 255, 255, 0, 0, 0, 0);
Mat kernel = (Mat_<int>(3, 3) <<
0, 1, 0,
1, -1, 1,
0, 1, 0);
Mat output_image;
morphologyEx(input_image, output_image, MORPH_HITMISS, kernel);
const int rate = 50;
kernel = (kernel + 1) * 127;
kernel.convertTo(kernel, CV_8U);
resize(kernel, kernel, Size(), rate, rate, INTER_NEAREST);
// waitKey(0);
return 0;
}
| [
"guido@sportograf.com"
] | guido@sportograf.com |
80d5b922ca37e0ad1f577e28d5cbf26c38d1e80a | 551d26d520f3d4ddfc852add32eb647f3b02ebcf | /cmps109/asg3/main.cpp | 99cddcac6abf7def94e15490d3f475a5e3307f22 | [
"MIT"
] | permissive | isaiah-solo/classwork | 99d116fd67e935bf7593cff1bf1dbd8fcab40259 | a3e834ee26822827f7ea4977707ecf7e42e1b0c9 | refs/heads/master | 2021-09-15T01:57:26.061628 | 2018-05-23T22:16:54 | 2018-05-23T22:16:54 | 56,641,103 | 1 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 3,772 | cpp | // $Id: main.cpp,v 1.6 2014-07-09 11:50:34-07 - - $
//
// Isaiah Solomon
// 1344680
// icsolomo
// Mackey
// CS 109
//
// Assignment 3
//
#include <cstdlib>
#include <exception>
#include <iostream>
#include <fstream>
#include <string>
#include <unistd.h>
using namespace std;
#include "listmap.h"
#include "xpair.h"
#include "util.h"
using str_str_pair = xpair<const string,string>;
using str_str_map = listmap<string,string>;
void scan_options (int argc, char** argv)
{
opterr = 0;
for (;;)
{
int option = getopt (argc, argv, "@:");
if (option == EOF) break;
switch (option)
{
case '@':
traceflags::setflags (optarg);
break;
default:
complain() << "-" << (char) optopt << ": invalid option"
<< endl;
break;
}
}
}
void do_operation (str_str_map& the_map, const string& key,
const string& value, const string& input,
const size_t& equals)
{
if (input.size() and input.at(0) == '#') // #
{
if (input.size() > 1)
cout << input.substr(1, input.size());
cout << endl;
}
else if (key.size() and equals >=
input.size() and not value.size()) // key
{
str_str_pair temp {key, value};
bool found = true;
auto pointer = the_map.find(key, found);
if (found == true)
cout << *pointer << endl;
else
cout << key << ": key not found" << endl;
}
else if (key.size() and equals < input.size()
and not value.size()) // key =
{
the_map.erase(key);
}
else if (key.size() and equals < input.size()
and value.size()) // key = value
{
str_str_pair temp {key, value};
auto pointer = the_map.insert(temp);
cout << *pointer << endl;
}
else if (not key.size() and equals < input.size()
and not value.size()) // =
{
the_map.print();
}
else if (not key.size() and equals < input.size()
and value.size()) // = value
{
the_map.value_print(value);
}
}
void trim (string& key, string& value, const string& input,
size_t& equals)
{
equals = input.find_first_of('=', 0);
key = input.substr(0, equals);
if (equals < input.size())
value = input.substr(equals + 1, input.size());
while (key.size() and key.at(0) == ' ')
key.erase(0, 1);
while (key.size() and key.at(key.size() - 1) == ' ')
key.erase(key.size() - 1, 1);
while (value.size() and value.at(0) == ' ')
value.erase(0, 1);
while (value.size() and value.at(value.size() - 1) == ' ')
value.erase(key.size() - 1, 1);
}
int main (int argc, char** argv)
{
//sys_info::set_execname (argv[0]);
scan_options (argc, argv);
str_str_map the_map {};
string input = "", key = "", value = "";
size_t equals = 0;
int counter = 1;
for (int i = 1; i < argc; ++i)
{
ifstream the_file (argv[i]);
if (not the_file.is_open())
continue;
else
{
while (getline(the_file, input))
{
cout << argv[i] << ": " << counter << ": " << input << endl;
trim(key, value, input, equals);
do_operation(the_map, key, value, input, equals);
++counter;
}
}
the_file.close();
counter = 1;
}
while (argc == 1)
{
input = ""; key = ""; value = "";
getline(cin, input);
if (cin.eof())
{
the_map.erase_all();
break;
}
cout << "-: " << counter << ": " << input << endl;
trim(key, value, input, equals);
do_operation(the_map, key, value, input, equals);
counter += 1;
}
return EXIT_SUCCESS;
}
| [
"isaiah.c.solomon@gmail.com"
] | isaiah.c.solomon@gmail.com |
79375db4c0a29097b37f6bb3790a27a49d2a9efd | 1af49694004c6fbc31deada5618dae37255ce978 | /weblayer/renderer/content_renderer_client_impl.cc | 90cbd198a89f4e912a3d075ea9d28cb4798cafa8 | [
"BSD-3-Clause"
] | permissive | sadrulhc/chromium | 59682b173a00269ed036eee5ebfa317ba3a770cc | a4b950c23db47a0fdd63549cccf9ac8acd8e2c41 | refs/heads/master | 2023-02-02T07:59:20.295144 | 2020-12-01T21:32:32 | 2020-12-01T21:32:32 | 317,678,056 | 3 | 0 | BSD-3-Clause | 2020-12-01T21:56:26 | 2020-12-01T21:56:25 | null | UTF-8 | C++ | false | false | 8,900 | cc | // Copyright 2019 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 "weblayer/renderer/content_renderer_client_impl.h"
#include "base/feature_list.h"
#include "build/build_config.h"
#include "components/autofill/content/renderer/autofill_agent.h"
#include "components/autofill/content/renderer/password_autofill_agent.h"
#include "components/content_settings/renderer/content_settings_agent_impl.h"
#include "components/error_page/common/error.h"
#include "components/grit/components_scaled_resources.h"
#include "components/js_injection/renderer/js_communication.h"
#include "components/no_state_prefetch/common/prerender_types.mojom.h"
#include "components/no_state_prefetch/common/prerender_url_loader_throttle.h"
#include "components/no_state_prefetch/renderer/prerender_helper.h"
#include "components/no_state_prefetch/renderer/prerender_render_frame_observer.h"
#include "components/no_state_prefetch/renderer/prerender_utils.h"
#include "components/no_state_prefetch/renderer/prerenderer_client.h"
#include "components/page_load_metrics/renderer/metrics_render_frame_observer.h"
#include "components/subresource_filter/content/renderer/subresource_filter_agent.h"
#include "components/subresource_filter/content/renderer/unverified_ruleset_dealer.h"
#include "components/subresource_filter/core/common/common_features.h"
#include "content/public/renderer/render_frame.h"
#include "content/public/renderer/render_thread.h"
#include "content/public/renderer/render_view.h"
#include "third_party/blink/public/platform/platform.h"
#include "ui/base/resource/resource_bundle.h"
#include "weblayer/common/features.h"
#include "weblayer/renderer/error_page_helper.h"
#include "weblayer/renderer/url_loader_throttle_provider.h"
#include "weblayer/renderer/weblayer_render_frame_observer.h"
#include "weblayer/renderer/weblayer_render_thread_observer.h"
#if defined(OS_ANDROID)
#include "components/android_system_error_page/error_page_populator.h"
#include "components/cdm/renderer/android_key_systems.h"
#include "components/spellcheck/renderer/spellcheck.h" // nogncheck
#include "components/spellcheck/renderer/spellcheck_provider.h" // nogncheck
#include "content/public/renderer/render_thread.h"
#include "services/service_manager/public/cpp/local_interface_provider.h"
#include "third_party/blink/public/platform/web_runtime_features.h"
#endif
namespace weblayer {
namespace {
#if defined(OS_ANDROID)
class SpellcheckInterfaceProvider
: public service_manager::LocalInterfaceProvider {
public:
SpellcheckInterfaceProvider() = default;
~SpellcheckInterfaceProvider() override = default;
// service_manager::LocalInterfaceProvider:
void GetInterface(const std::string& interface_name,
mojo::ScopedMessagePipeHandle interface_pipe) override {
// A dirty hack to make SpellCheckHost requests work on WebLayer.
// TODO(crbug.com/806394): Use a WebView-specific service for SpellCheckHost
// and SafeBrowsing, instead of |content_browser|.
content::RenderThread::Get()->BindHostReceiver(mojo::GenericPendingReceiver(
interface_name, std::move(interface_pipe)));
}
private:
DISALLOW_COPY_AND_ASSIGN(SpellcheckInterfaceProvider);
};
#endif // defined(OS_ANDROID)
} // namespace
ContentRendererClientImpl::ContentRendererClientImpl() = default;
ContentRendererClientImpl::~ContentRendererClientImpl() = default;
void ContentRendererClientImpl::RenderThreadStarted() {
#if defined(OS_ANDROID)
if (!spellcheck_) {
local_interface_provider_ = std::make_unique<SpellcheckInterfaceProvider>();
spellcheck_ = std::make_unique<SpellCheck>(local_interface_provider_.get());
}
#endif
content::RenderThread* thread = content::RenderThread::Get();
weblayer_observer_ = std::make_unique<WebLayerRenderThreadObserver>();
thread->AddObserver(weblayer_observer_.get());
browser_interface_broker_ =
blink::Platform::Current()->GetBrowserInterfaceBroker();
subresource_filter_ruleset_dealer_ =
std::make_unique<subresource_filter::UnverifiedRulesetDealer>();
thread->AddObserver(subresource_filter_ruleset_dealer_.get());
}
void ContentRendererClientImpl::RenderFrameCreated(
content::RenderFrame* render_frame) {
auto* render_frame_observer = new WebLayerRenderFrameObserver(render_frame);
new prerender::PrerenderRenderFrameObserver(render_frame);
ErrorPageHelper::Create(render_frame);
autofill::PasswordAutofillAgent* password_autofill_agent =
new autofill::PasswordAutofillAgent(
render_frame, render_frame_observer->associated_interfaces());
new autofill::AutofillAgent(render_frame, password_autofill_agent, nullptr,
nullptr,
render_frame_observer->associated_interfaces());
auto* agent = new content_settings::ContentSettingsAgentImpl(
render_frame, false /* should_whitelist */,
std::make_unique<content_settings::ContentSettingsAgentImpl::Delegate>());
if (weblayer_observer_)
agent->SetContentSettingRules(weblayer_observer_->content_setting_rules());
new page_load_metrics::MetricsRenderFrameObserver(render_frame);
// TODO(crbug.com/1116095): Bring up AdResourceTracker?
new subresource_filter::SubresourceFilterAgent(
render_frame, subresource_filter_ruleset_dealer_.get(),
/*ad_resource_tracker=*/nullptr);
#if defined(OS_ANDROID)
// |SpellCheckProvider| manages its own lifetime (and destroys itself when the
// RenderFrame is destroyed).
new SpellCheckProvider(render_frame, spellcheck_.get(),
local_interface_provider_.get());
#endif
new js_injection::JsCommunication(render_frame);
if (!render_frame->IsMainFrame()) {
auto* prerender_helper = prerender::PrerenderHelper::Get(
render_frame->GetRenderView()->GetMainRenderFrame());
if (prerender_helper) {
// Avoid any race conditions from having the browser tell subframes that
// they're prerendering.
new prerender::PrerenderHelper(render_frame,
prerender_helper->prerender_mode(),
prerender_helper->histogram_prefix());
}
}
}
void ContentRendererClientImpl::RenderViewCreated(
content::RenderView* render_view) {
new prerender::PrerendererClient(render_view);
}
SkBitmap* ContentRendererClientImpl::GetSadPluginBitmap() {
return const_cast<SkBitmap*>(ui::ResourceBundle::GetSharedInstance()
.GetImageNamed(IDR_SAD_PLUGIN)
.ToSkBitmap());
}
SkBitmap* ContentRendererClientImpl::GetSadWebViewBitmap() {
return const_cast<SkBitmap*>(ui::ResourceBundle::GetSharedInstance()
.GetImageNamed(IDR_SAD_WEBVIEW)
.ToSkBitmap());
}
void ContentRendererClientImpl::PrepareErrorPage(
content::RenderFrame* render_frame,
const blink::WebURLError& error,
const std::string& http_method,
std::string* error_html) {
auto* error_page_helper = ErrorPageHelper::GetForFrame(render_frame);
if (error_page_helper)
error_page_helper->PrepareErrorPage();
#if defined(OS_ANDROID)
// This does nothing if |error_html| is non-null (which happens if the
// embedder injects an error page).
android_system_error_page::PopulateErrorPageHtml(error, error_html);
#endif
}
std::unique_ptr<content::URLLoaderThrottleProvider>
ContentRendererClientImpl::CreateURLLoaderThrottleProvider(
content::URLLoaderThrottleProviderType provider_type) {
return std::make_unique<URLLoaderThrottleProvider>(
browser_interface_broker_.get(), provider_type);
}
void ContentRendererClientImpl::AddSupportedKeySystems(
std::vector<std::unique_ptr<::media::KeySystemProperties>>* key_systems) {
#if defined(OS_ANDROID)
cdm::AddAndroidWidevine(key_systems);
cdm::AddAndroidPlatformKeySystems(key_systems);
#endif
}
void ContentRendererClientImpl::
SetRuntimeFeaturesDefaultsBeforeBlinkInitialization() {
#if defined(OS_ANDROID)
// Web Share is experimental by default, and explicitly enabled on Android
// (for both Chrome and WebLayer).
blink::WebRuntimeFeatures::EnableWebShare(true);
#endif
}
bool ContentRendererClientImpl::IsPrefetchOnly(
content::RenderFrame* render_frame,
const blink::WebURLRequest& request) {
return prerender::PrerenderHelper::GetPrerenderMode(render_frame) ==
prerender::mojom::PrerenderMode::kPrefetchOnly;
}
bool ContentRendererClientImpl::DeferMediaLoad(
content::RenderFrame* render_frame,
bool has_played_media_before,
base::OnceClosure closure) {
return prerender::DeferMediaLoad(render_frame, has_played_media_before,
std::move(closure));
}
} // namespace weblayer
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
2d0397f88096c1416cecf9c12cbff8c8db4c3818 | 91b04e0ae7939a3087ea3edc2eea73c928a54c89 | /sem2/oop/labs/labs5-7/src/Console.cpp | b7df05006c8a488d0a010e28937d00c84e11c7b2 | [] | no_license | mirceadino/CollegeAssignments | cf9111b87f5aaf00783749b5769b91a8e3e13ca5 | fc0f59ae78a6000d0fc1f63edb52ca7e3b840548 | refs/heads/master | 2021-01-12T14:33:44.619046 | 2018-06-12T08:09:20 | 2018-06-12T08:09:20 | 72,014,014 | 1 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 6,123 | cpp | #include "Console.h"
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
Console::Console() :
controller_(Controller()) {
}
Console::Console(const Controller& ctrl) :
controller_(ctrl) {
}
void Console::run() {
system("clear");
while (true) {
print_main_menu();
int option = read_number("Choose mode: ");
if (option)
system("clear");
if (option == 1)
run_admin();
else if (option == 2)
run_user();
else if (option == 0)
break;
else
cout << "Invalid mode.\n----------\n";
}
cout << "----------\nBon appétit!\n";
}
int Console::read_number(std::string message) {
int value;
string str;
cout << message;
getline(cin, str);
while (true) {
if (sscanf(str.c_str(), "%d", &value))
if (1 + (int) max(0.0, log10(value + 0.5)) == (int) str.size())
break;
cout << "Please type again: ";
getline(cin, str);
}
return value;
}
string Console::read_string(std::string message) {
string value;
cout << message;
getline(cin, value);
return value;
}
void Console::print_main_menu() {
string menu;
menu += ":: MASTER THE ART OF COOKING ::\n";
menu += "----------\n";
menu += "1 - Admin mode\n";
menu += "2 - User mode\n";
menu += "0 - Exit\n";
cout << menu;
}
void Console::print_admin_menu() {
string menu;
menu += "----------\n";
menu += "1 - Add tutorial\n";
menu += "2 - Remove tutorial\n";
menu += "3 - Update tutorial\n";
menu += "4 - Display all tutorials\n";
menu += "0 - Back\n";
cout << menu;
}
void Console::print_user_menu() {
string menu;
menu += "----------\n";
menu += "1 - Watch tutorials by a given presenter\n";
menu += "2 - Remove tutorial from watchlist\n";
menu += "3 - Display all tutorials from watchlist\n";
menu += "0 - Back\n";
cout << menu;
}
void Console::print_playlist_menu() {
string menu;
menu += "----------\n";
menu += "1 - Add to watchlist\n";
menu += "2 - Next tutorial\n";
menu += "0 - Exit playlist\n";
cout << menu;
}
void Console::run_admin() {
cout << ":: ADMIN MODE ::\n";
while (true) {
print_admin_menu();
int option = read_number("Choose option: ");
system("clear");
if (option == 1)
admin_add();
else if (option == 2)
admin_remove();
else if (option == 3)
admin_update();
else if (option == 4)
admin_display();
else if (option == 0)
break;
else
cout << "Invalid option.\n";
}
}
void Console::run_user() {
cout << ":: USER MODE ::\n";
while (true) {
print_user_menu();
int option = read_number("Choose option: ");
system("clear");
if (option == 1)
user_watch_playlist_by_presenter();
else if (option == 2)
user_remove_from_watchlist();
else if (option == 3)
user_display_watchlist();
else if (option == 0)
break;
else
cout << "Invalid option.\n";
}
}
void Console::admin_add() {
string title = read_string("Type title: ");
string presenter = read_string("Type presenter: ");
int min = read_number("Type minutes: ");
int sec = read_number("Type seconds: ");
int upvotes = read_number("Type upvotes: ");
string url = read_string("Type url: ");
if (controller_.add_tutorial_to_repository(title, presenter, Duration(min, sec), upvotes, url))
cout << "Successfully added.\n";
else
cout << "Tutorial could not be added.\n";
}
void Console::admin_remove() {
string title = read_string("Type title: ");
if (controller_.remove_tutorial_from_repository(title))
cout << "Successfully removed.\n";
else
cout << "Tutorial could not be removed.\n";
}
void Console::admin_update() {
string title = read_string("Type title: ");
string new_title = read_string("Type new title: ");
string new_presenter = read_string("Type new presenter: ");
int new_min = read_number("Type new minutes: ");
int new_sec = read_number("Type new seconds: ");
int new_upvotes = read_number("Type new upvotes: ");
string new_url = read_string("Type new url: ");
if (controller_.update_tutorial(title, new_title, new_presenter, Duration(new_min, new_sec), new_upvotes, new_url))
cout << "Successfully updated.\n";
else
cout << "Tutorial could not be updated.\n";
}
void Console::admin_display() {
DynamicVector<Tutorial> all = controller_.get_all_from_repository();
if (all.size() == 0)
cout << "Empty.\n";
for (int i = 0; i < all.size(); i++)
cout << all[i].str() << "\n";
}
void Console::user_watch_playlist_by_presenter() {
string presenter = read_string("Type presenter: ");
if (!this->controller_.create_playlist(presenter)) {
cout << "Playlist could not be created. No tutorials with such presenter.\n";
return;
}
this->controller_.start_playlist();
while (true) {
Tutorial& tuto = this->controller_.play_current_in_playlist();
while (true) {
cout << "Currently playing: ";
cout << tuto.str() << "\n";
print_playlist_menu();
int option = read_number("Choose option: ");
system("clear");
if (option == 1) {
if (this->controller_.add_tutorial_to_watchlist(tuto))
cout << "Successfully added to watchlist.\n";
else
cout << "Tutorial could not be added to watchlist.\n";
} else if (option == 2) {
this->controller_.go_next_in_playlist();
break;
} else if (option == 0) {
return;
} else {
cout << "Invalid option.\n";
}
}
}
}
void Console::user_remove_from_watchlist() {
string title = read_string("Type title: ");
if (controller_.remove_tutorial_from_watchlist(title)) {
while (true) {
string upvotes = read_string("Do you want to upvote (Y/N)? ");
if (upvotes == "Y" || upvotes == "y") {
controller_.upvote_tutorial(title);
cout << "Successfully removed from watchlist (and upvoted).\n";
break;
} else if (upvotes == "N" || upvotes == "n") {
cout << "Successfully removed from watchlist.\n";
break;
}
}
} else {
cout << "Tutorial could not be removed from watchlist.\n";
}
}
void Console::user_display_watchlist() {
DynamicVector<Tutorial> all = controller_.get_all_from_watchlist();
if (all.size() == 0)
cout << "Empty.\n";
for (int i = 0; i < all.size(); i++)
cout << all[i].str() << "\n";
}
| [
"mirceadino97@gmail.com"
] | mirceadino97@gmail.com |
2a3ad15430c73e0c586942f2e7633152fccb2f9e | 33055a9f580625aef7012e4c8e16ad4741853e2a | /src/odd_spin_box.h | dcb591e6de3e30c930b4cc8f424d6884b512f0d0 | [] | no_license | kriolog/median_filter | 3f20d0b9d1e2bbdd62d70cd433aca074cda38710 | 9ff0c6e57e83b1aa25ab08c101ea0a13e9b57754 | refs/heads/master | 2020-12-31T00:53:38.820038 | 2016-01-22T01:25:56 | 2016-01-22T01:25:56 | 80,583,097 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 311 | h | #ifndef ODD_SPIN_BOX_H
#define ODD_SPIN_BOX_H
#include <QSpinBox>
namespace medianFilter {
class OddSpinBox : public QSpinBox
{
Q_OBJECT
public:
OddSpinBox(QWidget* parent = 0);
protected:
int valueFromText(const QString &text) const;
};
} // namespace medianFilter
#endif // ODD_SPIN_BOX_H | [
"kriolog@gmail.com"
] | kriolog@gmail.com |
f9d43880561e7a1517e98cb856d8194b8875d3fb | 0bb15f0fe63b9539c20f0088b29b30e85ad8ffdd | /glprogram.cc | eb1dfe344605df2ed13a779033aeec01f69fcdd9 | [] | no_license | tiagosr/glance | d78d8d922900083db639b798a60184afaf714cd3 | 03be008123aa9520b4a9fbaf48c6ccf091b696d6 | refs/heads/master | 2020-03-29T09:27:29.264016 | 2014-08-26T03:34:29 | 2014-08-26T03:34:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,659 | cc | //
// glshader.c
// glance
//
// Created by Tiago Rezende on 3/7/13.
// Copyright (c) 2013 Tiago Rezende. All rights reserved.
//
#include "m_pd.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define GLFW_INCLUDE_GLCOREARB
#include <GLFW/glfw3.h>
#include "glance.h"
#include "window.hh"
static t_class *glprogram_class;
struct glprogram_obj {
t_object x_obj;
t_canvas *x_canvas;
GLuint shader;
std::shared_ptr<glwindow_program> program;
GLint compiled, linked;
t_outlet *data_out;
t_outlet *info_out;
};
glwindow_program::glwindow_program() {
program = glCreateProgram();
}
glwindow_program::~glwindow_program() {
glDeleteProgram(program);
}
static t_symbol *vtx, *frag, *geom;
static t_symbol *compiled, *linked;
static void *glprogram_new(t_symbol *name) {
glprogram_obj *obj = (glprogram_obj *)pd_new(glprogram_class);
obj->x_canvas = canvas_getcurrent();
obj->shader = 0;
obj->program = glwindow_program::programs.get_create(name);
obj->compiled = false;
obj->linked = false;
obj->data_out = outlet_new(&obj->x_obj, &s_list);
obj->info_out = outlet_new(&obj->x_obj, &s_list);
return (void *)obj;
}
static void glprogram_load(glprogram_obj *obj, t_symbol *sym, int argc, t_atom *argv) {
if (argc > 0) {
char **txts = (char **)alloca(sizeof(char *)*argc);
int *lens = (int *)alloca(sizeof(int)*argc);
for (int c = 0; c < argc; c++) {
t_symbol *filename_s = atom_getsymbolarg(c, argc, argv);
char *fname = NULL;
asprintf(&fname, "%s/%s",canvas_getdir(obj->x_canvas)->s_name, filename_s->s_name);
FILE *f = fopen(fname, "r");
free(fname);
size_t len = 0;
char *txt = NULL;
if (f) {
len = ftell(f);
txt = (char *)alloca(len);
fread(txt, len, 1, f);
fclose(f);
} else {
error("file %s could not be opened", filename_s->s_name);
}
txts[c] = txt;
lens[c] = len;
}
GLenum t = (sym==vtx?GL_VERTEX_SHADER:
(sym==frag?GL_FRAGMENT_SHADER:
(sym==geom)?GL_GEOMETRY_SHADER:-1));
GLuint shader = 0;
if(t!=-1) {
shader = glCreateShader(t);
}
obj->shader = shader;
glShaderSource(shader, 1, (const GLchar **)txts, lens);
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &obj->compiled);
if (obj->compiled) {
glAttachShader(obj->program->program, shader);
t_atom compiled_atoms[2];
SETSYMBOL(compiled_atoms+0, compiled);
SETFLOAT(compiled_atoms+1, shader);
outlet_list(obj->info_out, &s_list, 2, compiled_atoms);
} else {
error("shaders were not compiled");
}
}
}
static void glprogram_link(glprogram_obj *obj) {
glLinkProgram(obj->program->program);
glGetProgramiv(obj->program->program, GL_COMPILE_STATUS, &obj->linked);
if (obj->linked) {
t_atom linked_atoms[2];
SETSYMBOL(linked_atoms+0, linked);
SETFLOAT(linked_atoms+1, obj->program->program);
outlet_list(obj->data_out, &s_list, 2, linked_atoms);
} else {
error("fail on shader linkage");
}
}
static void glprogram_use(glprogram_obj *obj) {
if (obj->linked) {
glUseProgram(obj->program->program);
}
}
static void glprogram_glance_render(glprogram_obj *obj, t_symbol *s, int argc, t_atom *argv) {
glprogram_use(obj);
outlet_anything(obj->data_out, s, argc, argv);
}
void gl_program_setup(void) {
vtx = gensym("vertex");
frag = gensym("fragment");
geom = gensym("geometry");
glprogram_class = class_new(gensym("gl.program"),
(t_newmethod)glprogram_new,
0,
sizeof(glprogram_obj),
CLASS_DEFAULT,
A_SYMBOL, 0);
class_addmethod(glprogram_class, (t_method)glprogram_load,
vtx, A_GIMME, 0);
class_addmethod(glprogram_class, (t_method)glprogram_load,
frag, A_GIMME, 0);
class_addmethod(glprogram_class, (t_method)glprogram_load,
geom, A_GIMME, 0);
class_addmethod(glprogram_class, (t_method)glprogram_link,
gensym("link"), A_NULL, 0);
class_addmethod(glprogram_class, (t_method)glprogram_glance_render,
render, A_GIMME, 0);
}
| [
"tiagosr@gmail.com"
] | tiagosr@gmail.com |
61d09a3d5012f85b38c84b54609fec1d1cc7c556 | 58a36a74e92779c6550bbadae9db9e3c71845dfe | /csci650/p3/node.h | 3c6453776fbce0125e057c8208669842087ab5f1 | [] | no_license | spencermcw/Code | 9b34c2c11aa5b1cd4371ea074fa9220bcfdfe660 | 56cec1000602d2a4b83a085b2a7afd7ad3432016 | refs/heads/master | 2021-01-21T13:15:05.513865 | 2016-04-23T01:37:25 | 2016-04-23T01:37:25 | 56,894,455 | 0 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 477 | h | #include<iostream>
using namespace std;
#ifndef NODE_H
#define NODE_H
template <typename T>
class Node{
public:
Node(): next(NULL), prev(NULL), priority(1) {};
Node(T v, Node *n, Node *p, int pr): value(v), next(n), prev(p), priority(pr) {};
Node(const Node &acopy): value(acopy.value), next(acopy.next), prev(acopy.prev), priority(acopy.priority) {};
T value;
Node* next;
Node* prev;
int priority;
};
#endif
| [
"Spencer@Spencers-MacBook-Pro-2.local"
] | Spencer@Spencers-MacBook-Pro-2.local |
35587664b6939024c0dbe26a5e3cb743757cdffd | 9399a7c2e37449adc91a5b7d8dd7f23f86fda4fd | /flutter_gridview/windows/runner/main.cpp | d7d83ba198fa1b8b9a39b32f7a39fbc8418add54 | [] | no_license | leehoang21/bai-hoc-flutter | ee302895287a1347ba27528d1204b92e8a5c9bbb | 8c3d6956e1bb326d33a659dc90e3d4173d05e070 | refs/heads/main | 2023-08-14T23:24:23.914566 | 2021-10-04T12:25:36 | 2021-10-04T12:25:36 | 413,409,236 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,226 | cpp | #include <flutter/dart_project.h>
#include <flutter/flutter_view_controller.h>
#include <windows.h>
#include "flutter_window.h"
#include "run_loop.h"
#include "utils.h"
int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev,
_In_ wchar_t *command_line, _In_ int show_command) {
// Attach to console when present (e.g., 'flutter run') or create a
// new console when running with a debugger.
if (!::AttachConsole(ATTACH_PARENT_PROCESS) && ::IsDebuggerPresent()) {
CreateAndAttachConsole();
}
// Initialize COM, so that it is available for use in the library and/or
// plugins.
::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
RunLoop run_loop;
flutter::DartProject project(L"data");
std::vector<std::string> command_line_arguments =
GetCommandLineArguments();
project.set_dart_entrypoint_arguments(std::move(command_line_arguments));
FlutterWindow window(&run_loop, project);
Win32Window::Point origin(10, 10);
Win32Window::Size size(1280, 720);
if (!window.CreateAndShow(L"flutter_gridview", origin, size)) {
return EXIT_FAILURE;
}
window.SetQuitOnClose(true);
run_loop.Run();
::CoUninitialize();
return EXIT_SUCCESS;
}
| [
"hoanglethanh2132003@gmail.com"
] | hoanglethanh2132003@gmail.com |
560c86f7eab3a25990907f03891de03642dba11d | a3cb942e5c41f7d6bd2f5ad90418878b9a6ab81f | /Steto2_fw/kl_lib/SimpleSensors.h | 03c23b162e15719f944c5cddb1fd38c90549d46e | [] | no_license | mavka/mic_amp | 019b9409fd784375940b7829e3c38d12fb4d0429 | 7c245c2cd7cb869b5a03080cd61d3ae87a3dc20c | refs/heads/master | 2020-05-29T17:08:07.669206 | 2016-09-12T20:26:33 | 2016-09-12T20:26:33 | 43,977,260 | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 526 | h | /*
* SimpleSensors.h
*
* Created on: 17 ÿíâ. 2015 ã.
* Author: Kreyl
*/
#pragma once
/*
* Simple sensors are sensors with two logic states: Low and High.
*/
#include "hal.h"
#include "kl_lib.h"
#include "PinSnsSettings.h"
#if SIMPLESENSORS_ENABLED
class SimpleSensors_t {
private:
PinSnsState_t States[PIN_SNS_CNT];
public:
void Init();
void Shutdown() { for(uint32_t i=0; i<PIN_SNS_CNT; i++) PinSns[i].Off(); }
// Inner use
void ITask();
};
extern SimpleSensors_t PinSensors;
#endif
| [
"laystoll@yandex.ru"
] | laystoll@yandex.ru |
8744d2e66dbe0c343f7bdfd112b76e737cc13311 | e00ceab3efd02889179b31f54b4e5e9e32919337 | /common/Hardware/GPIOEnum.cpp | 379edf41b59e8333612ff005a5d23a4910b2d204 | [] | no_license | dotsha747/Pi-ExtPlane-IO | 78e74bbd48c595bb468cf5f2b53bda396af17504 | a1397c39f56b162adb1d9f3aa5f83619add586b7 | refs/heads/master | 2021-07-24T11:43:13.479218 | 2018-09-27T20:51:45 | 2018-09-27T20:51:45 | 135,749,053 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,162 | cpp | #include <sstream>
#include "GPIOEnum.h"
std::ostream &operator<<(std::ostream &os, GPIODIR const &m) {
switch (m) {
case GPIODIR::IN:
return os << "GPIODIR::IN";
case GPIODIR::OUT:
return os << "GPIODIR::OUT";
default:
return os << "GPIODIR::UNKNOWN";
}
}
std::ostream &operator<<(std::ostream &os, GPIOSTATE const &m) {
switch (m) {
case GPIOSTATE::HI:
return os << "GPIOSTATE::HI";
case GPIOSTATE::LO:
return os << "GPIOSTATE::LO";
default:
return os << "GPIOSTATE::UNKNOWN";
}
}
std::ostream &operator<<(std::ostream &os, GPIOPULL const &m) {
switch (m) {
case GPIOPULL::DOWN:
return os << "GPIOPULL::DOWN";
case GPIOPULL::OFF:
return os << "GPIOPULL::OFF";
case GPIOPULL::UP:
return os << "GPIOPULL::UP";
default:
return os << "GPIOPULL::UNKNOWN";
}
}
std::ostream &operator<<(std::ostream &os, GPIOEDGE const &m) {
switch (m) {
case GPIOEDGE::BOTH:
return os << "GPIOEDGE::BOTH";
case GPIOEDGE::FALLING:
return os << "GPIOEDGE::FALLING";
case GPIOEDGE::NONE:
return os << "GPIOEDGE::NONE";
case GPIOEDGE::RISING:
return os << "GPIOEDGE::RISING";
default:
return os << "GPIOEDGE::UNKNOWN";
}
}
| [
"shahada@abubakar.net"
] | shahada@abubakar.net |
3e8c891b995af5fcc25114cfb6a95aafa534c58a | 1bc37a26e07f449ba9dca257978ce7fd98cae28b | /MapMatrix3D/DlgCommand_Part2.cpp | 0017c159bc3651feac8df6d462e8762952b8b652 | [] | no_license | gisdevelope/MapMatrix3D1.2 | 0c34384d010cf0ad27dd43a5a4567dbe0fd66fe8 | 05d0284b7b7f4f9dfd5aab0dc23f99ed5293ae70 | refs/heads/master | 2023-03-16T13:08:08.489620 | 2018-04-09T09:43:09 | 2018-04-09T09:43:09 | 151,419,514 | 0 | 0 | null | 2018-10-25T07:56:08 | 2018-10-03T13:45:14 | C++ | GB18030 | C++ | false | false | 716,247 | cpp | #include "stdafx.h"
#include "EditBase.h"
#include "Command.h"
#include "Editor.h"
#include "GeoCurve.h"
#include "RegDef.h"
#include "RegDef2.h"
#include "UIParam2.h"
#include "Linearizer.h"
#include "DataSource.h"
#include "Functions_temp.h "
#include "SmartViewFunctions.h"
#include "Resource.h"
#include "DlgCommand.h"
#include "MainFrm.h"
#include "ExMessage.h"
#include "PropertiesViewBar.h"
#include "EditBasedoc.h"
#include "DlgDataSource.h "
#include "ConditionSelect.h "
#include "StreamCompress.h "
#include "Container.h"
#include "GeoText.h "
#include "GrTrim.h "
#include "Scheme.h "
#include "SymbolLib.h "
#include "PlotText.h "
#include "DlgInputData.h"
//#include "GeoSurface.h "
#include <math.h>
#include "DlgSetXYZ.h"
#include "..\CORE\viewer\EditBase\res\resource.h"
#include "CommandLidar.h"
#include "DlgChangeFCode.h"
#include <map>
#include <list>
#include <set>
#include "baseview.h"
#include "DlgOpSettings.h"
#include "SQLiteAccess.h"
#include "Mapper.h"
#include "DlgEditText.h"
#include "EditBase.h"
#include "DlgBatExportMaps.h"
#include "UIFBoolProp.h"
#include "PlotWChar.h"
#include "DlgInputCode.h"
#include "DlgSymbolTable.h"
#include "SymbolBase.h"
#include "PolygonWork.h"
#include "PolygonBooleanHander.h"
#include "GeoSurfaceBooleanHandle.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#define MAXDISTANCE 99999999
#define INTPAPI_SUCESS 0
#define INTPAPI_INVALIDE_PARAM 1
#define INTPAPI_ERROR 2
int CALLBACK EnumFontFamProc(LPENUMLOGFONT lpelf, LPNEWTEXTMETRIC lpntm, DWORD nFontType, LONG_PTR lparam);
extern BOOL convertStringToStrArray(LPCTSTR str,CStringArray &arr);
static bool GLineIntersectLineSeg1(double x0,double y0, double x1, double y1,double x2,double y2,double z2,double x3,double y3, double z3,double *x, double *y,double *z, double *t,double *t3)
{
double vector1x = x1-x0, vector1y = y1-y0;
double vector2x = x3-x2, vector2y = y3-y2,vector2z=z3-z2;
double delta = vector1x*vector2y-vector1y*vector2x;
if( delta<1e-6 && delta>-1e-6 )return false; //平行无交点
double t1 = ( (x2-x0)*vector2y-(y2-y0)*vector2x )/delta;
double xr = x0 + t1*vector1x, yr = y0 + t1*vector1y;
if( t1<0 || t1>1 )
{
if( fabs(xr-x0)<=1e-6 && fabs(yr-y0)<=1e-6 );
else if( fabs(xr-x1)<=1e-6 && fabs(yr-y1)<=1e-6 );
else return false;
}
double t2 = ( (x2-x0)*vector1y-(y2-y0)*vector1x )/delta;
if( t2<0 || t2>1 )
{
if( fabs(xr-x2)<=1e-6 && fabs(yr-y2)<=1e-6 );
else if( fabs(xr-x3)<=1e-6 && fabs(yr-y3)<=1e-6 );
else return false;
}
if(x)*x = x0 + t1*vector1x;
if(y)*y = y0 + t1*vector1y;
if(z)*z = z2 + t2*vector2z;
if(t)*t = t1;
if (t3)
{
*t3=t2;
}
return true;
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CLineToDirPointCommand,CEditCommand)
CLineToDirPointCommand::CLineToDirPointCommand()
{
}
CLineToDirPointCommand::~CLineToDirPointCommand()
{
}
CString CLineToDirPointCommand::Name()
{
return StrFromResID(IDS_CMDNAME_LINETOPOINT);
}
void CLineToDirPointCommand::Start()
{
if( !m_pEditor )return;
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
m_nStep = 0;
// m_idsOld.RemoveAll();
// m_idsNew.RemoveAll();
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
PtClick(pt,0);
return;
}
CEditCommand::Start();
}
void CLineToDirPointCommand::LineToDirPoint(const FTR_HANDLE* handles,int num)
{
CUndoFtrs undo(m_pEditor,Name());
for (int i=0;i<num;i++)
{
CGeometry *pGeo = HandleToFtr(handles[i])->GetGeometry();
if (!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
{
continue;
}
CArray<PT_3DEX,PT_3DEX> pts;
pGeo->GetShape(pts);
if (pts.GetSize() != 2) continue;
CFeature *pNew = HandleToFtr(handles[i])->Clone();
if (!pNew) continue;
if (!pNew->CreateGeometry(CLS_GEODIRPOINT)) continue;
pNew->GetGeometry()->CreateShape(pts.GetData(),pts.GetSize());
if (!m_pEditor->AddObject(pNew,m_pEditor->GetFtrLayerIDOfFtr(handles[i])))
{
delete pNew;
continue;
}
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(handles[i]),pNew);
undo.AddNewFeature(FTR_HANDLE(pNew));
undo.AddOldFeature(handles[i]);
m_pEditor->DeleteObject(handles[i]);
}
undo.Commit();
}
void CLineToDirPointCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CSelection* pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE* handles = pSel->GetSelectedObjs(num);
LineToDirPoint(handles,num);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CLineToDirPoint1Command,CEditCommand)
CLineToDirPoint1Command::CLineToDirPoint1Command()
{
}
CLineToDirPoint1Command::~CLineToDirPoint1Command()
{
}
CString CLineToDirPoint1Command::Name()
{
return StrFromResID(IDS_CMDNAME_LINETOPOINT);
}
void CLineToDirPoint1Command::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
m_nStep = 0;
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CLineToDirPoint1Command::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_handleLayers);
tab.AddValue(PF_HANDLELAYERS,&CVariantEx(var));
var = (LPCTSTR)(m_targetLayer);
tab.AddValue(PF_LAYERNAME,&CVariantEx(var));
}
void CLineToDirPoint1Command::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("LineToDirPoint1Command",Name());
param->AddLayerNameParamEx(PF_HANDLELAYERS,(LPCTSTR)m_handleLayers,StrFromResID(IDS_CMDPLANE_LINELAYER),NULL,LAYERPARAMITEM_LINE);
param->AddLayerNameParam(PF_LAYERNAME,(LPCTSTR)m_targetLayer,StrFromResID(IDS_CMDPLANE_DIRPOINTLAYER),NULL,LAYERPARAMITEM_POINT);
}
void CLineToDirPoint1Command::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_HANDLELAYERS,var) )
{
m_handleLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_handleLayers.TrimLeft();
m_handleLayers.TrimRight();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_LAYERNAME,var) )
{
m_targetLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_targetLayer.TrimRight();
m_targetLayer.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CLineToDirPoint1Command::PtClick(PT_3D &pt, int flag)
{
if(!m_pEditor || m_targetLayer.IsEmpty())
return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CFtrLayer *out_layer = pDS->GetFtrLayer((LPCTSTR)m_targetLayer);
if(out_layer == NULL)
{
out_layer=new CFtrLayer();
out_layer->SetName((LPCTSTR)m_targetLayer);
pDS->AddFtrLayer(out_layer);
}
m_layerID = out_layer->GetID();
CFeature *pTemp = out_layer->CreateDefaultFeature(pDS->GetScale(), CLS_GEODIRPOINT);
CFtrLayerArray arrLayers;
int i=0, j=0;
pDS->GetFtrLayersByNameOrCode_editable(m_handleLayers,arrLayers);
CUndoFtrs undo(m_pEditor,Name());
for (i=0;i<arrLayers.GetSize();i++)
{
CFtrLayer *pLayer = arrLayers[i];
int nObj = pLayer->GetObjectCount();
for(j=0; j<nObj; j++)
{
CFeature *pFeature = pLayer->GetObject(j);
if(!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
{
continue;
}
CArray<PT_3DEX,PT_3DEX> pts;
pGeo->GetShape(pts);
if (pts.GetSize() != 2) continue;
CFeature *pNew = pTemp->Clone();
if (!pNew) continue;
pNew->GetGeometry()->CreateShape(pts.GetData(),pts.GetSize());
if (!m_pEditor->AddObject(pNew,m_layerID))
{
delete pNew;
continue;
}
GETXDS(m_pEditor)->CopyXAttributes(pFeature,pNew);
undo.AddNewFeature(FTR_HANDLE(pNew));
undo.AddOldFeature(FtrToHandle(pFeature));
m_pEditor->DeleteObject(FtrToHandle(pFeature));
}
}
if(pTemp) delete pTemp;
undo.Commit();
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CPointToSurfacePointCommand,CEditCommand)
CPointToSurfacePointCommand::CPointToSurfacePointCommand()
{
}
CPointToSurfacePointCommand::~CPointToSurfacePointCommand()
{
}
CString CPointToSurfacePointCommand::Name()
{
return StrFromResID(IDS_CMDNAME_POINTTOSURFACEPOINT);
}
void CPointToSurfacePointCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
m_nStep = 0;
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CPointToSurfacePointCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_handleLayers);
tab.AddValue(PF_HANDLELAYERS,&CVariantEx(var));
var = (LPCTSTR)(m_targetLayer);
tab.AddValue(PF_LAYERNAME,&CVariantEx(var));
}
void CPointToSurfacePointCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("PointToSurfacePoint",Name());
param->AddLayerNameParamEx(PF_HANDLELAYERS,(LPCTSTR)m_handleLayers,StrFromResID(IDS_SRC_LAYER),NULL);
param->AddLayerNameParam(PF_LAYERNAME,(LPCTSTR)m_targetLayer,StrFromResID(IDS_DES_LAYER),NULL,LAYERPARAMITEM_POINT);
}
void CPointToSurfacePointCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_HANDLELAYERS,var) )
{
m_handleLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_handleLayers.TrimLeft();
m_handleLayers.TrimRight();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_LAYERNAME,var) )
{
m_targetLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_targetLayer.TrimRight();
m_targetLayer.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CPointToSurfacePointCommand::PtClick(PT_3D &pt, int flag)
{
if(!m_pEditor)
return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CFtrLayer *out_layer = NULL;
if (!m_targetLayer.IsEmpty())
out_layer = pDS->GetOrCreateFtrLayer((LPCTSTR)m_targetLayer);
CFtrLayerArray arrLayers;
int i=0, j=0;
pDS->GetFtrLayersByNameOrCode_editable(m_handleLayers,arrLayers);
CUndoFtrs undo(m_pEditor,Name());
CFeature *pTempFtr = NULL;
if(out_layer)
{
pTempFtr = out_layer->CreateDefaultFeature(pDS->GetScale(), CLS_GEOSURFACEPOINT);
if(!pTempFtr) return;
}
for (i=0;i<arrLayers.GetSize();i++)
{
CFtrLayer *pLayer = arrLayers[i];
int nObj = pLayer->GetObjectCount();
for(j=0; j<nObj; j++)
{
CFeature *pFeature = pLayer->GetObject(j);
if(!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo || (CLS_GEOPOINT!=pGeo->GetClassType()))
{
continue;
}
CArray<PT_3DEX,PT_3DEX> pts;
pGeo->GetShape(pts);
CFeature *pNew = NULL;
if (pTempFtr)
{
pNew = pTempFtr->Clone();
}
else
{
pNew = pFeature->Clone();
if (!pNew->CreateGeometry(CLS_GEOSURFACEPOINT)) continue;
}
if (!pNew) continue;
pNew->GetGeometry()->CreateShape(pts.GetData(),pts.GetSize());
if (!m_pEditor->AddObject(pNew, out_layer ? out_layer->GetID() : pLayer->GetID()) )
{
delete pNew;
continue;
}
if (!out_layer)
{
GETXDS(m_pEditor)->CopyXAttributes(pFeature,pNew);
}
undo.AddNewFeature(FTR_HANDLE(pNew));
undo.AddOldFeature(FtrToHandle(pFeature));
m_pEditor->DeleteObject(FtrToHandle(pFeature));
}
}
if(pTempFtr) delete pTempFtr;
undo.Commit();
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CSurfacePointToPointCommand,CEditCommand)
CSurfacePointToPointCommand::CSurfacePointToPointCommand()
{
}
CSurfacePointToPointCommand::~CSurfacePointToPointCommand()
{
}
CString CSurfacePointToPointCommand::Name()
{
return StrFromResID(IDS_CMDNAME_SURFACEPOINTTOPOINT);
}
void CSurfacePointToPointCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
m_nStep = 0;
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CSurfacePointToPointCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_handleLayers);
tab.AddValue(PF_HANDLELAYERS,&CVariantEx(var));
var = (LPCTSTR)(m_targetLayer);
tab.AddValue(PF_LAYERNAME,&CVariantEx(var));
}
void CSurfacePointToPointCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("SurfacePointToPoint",Name());
param->AddLayerNameParamEx(PF_HANDLELAYERS,(LPCTSTR)m_handleLayers,StrFromResID(IDS_SRC_LAYER),NULL,LAYERPARAMITEM_POINT);
param->AddLayerNameParam(PF_LAYERNAME,(LPCTSTR)m_targetLayer,StrFromResID(IDS_DES_LAYER),NULL,LAYERPARAMITEM_POINT);
}
void CSurfacePointToPointCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_HANDLELAYERS,var) )
{
m_handleLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_handleLayers.TrimLeft();
m_handleLayers.TrimRight();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_LAYERNAME,var) )
{
m_targetLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_targetLayer.TrimRight();
m_targetLayer.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CSurfacePointToPointCommand::PtClick(PT_3D &pt, int flag)
{
if(!m_pEditor)
return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CFtrLayer *out_layer = pDS->GetFtrLayer((LPCTSTR)m_targetLayer);
if(out_layer==NULL && m_targetLayer.GetLength()>0 )
{
out_layer=new CFtrLayer();
out_layer->SetName((LPCTSTR)m_targetLayer);
pDS->AddFtrLayer(out_layer);
}
if(out_layer)
m_layerID = out_layer->GetID();
else
m_layerID = -1;
CFtrLayerArray arrLayers;
int i=0, j=0;
pDS->GetFtrLayersByNameOrCode_editable(m_handleLayers,arrLayers);
CUndoFtrs undo(m_pEditor,Name());
CFeature *pTempFtr = NULL;
if(out_layer)
{
pTempFtr = out_layer->CreateDefaultFeature(pDS->GetScale(), CLS_GEOPOINT);
if(!pTempFtr) return;
}
for (i=0;i<arrLayers.GetSize();i++)
{
CFtrLayer *pLayer = arrLayers[i];
int nObj = pLayer->GetObjectCount();
for(j=0; j<nObj; j++)
{
CFeature *pFeature = pLayer->GetObject(j);
if(!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoSurfacePoint)))
{
continue;
}
CArray<PT_3DEX,PT_3DEX> pts;
pGeo->GetShape(pts);
CFeature *pNew = pTempFtr ? pTempFtr->Clone() : pFeature->Clone();
if (!pNew) continue;
if (!pNew->CreateGeometry(CLS_GEOPOINT)) continue;
pNew->GetGeometry()->CreateShape(pts.GetData(),pts.GetSize());
if (!m_pEditor->AddObject(pNew,m_layerID==-1?pLayer->GetID():m_layerID))
{
delete pNew;
continue;
}
if(m_layerID==-1)
{
GETXDS(m_pEditor)->CopyXAttributes(pFeature,pNew);
}
undo.AddNewFeature(FTR_HANDLE(pNew));
undo.AddOldFeature(FtrToHandle(pFeature));
m_pEditor->DeleteObject(FtrToHandle(pFeature));
}
}
if(pTempFtr) delete pTempFtr;
undo.Commit();
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CModifySurfaceToCurveCommand,CEditCommand)
CModifySurfaceToCurveCommand::CModifySurfaceToCurveCommand()
{
}
CModifySurfaceToCurveCommand::~CModifySurfaceToCurveCommand()
{
}
CString CModifySurfaceToCurveCommand::Name()
{
return StrFromResID(IDS_CMDNAME_SURFACETOCURVE);
}
void CModifySurfaceToCurveCommand::Start()
{
if( !m_pEditor )return;
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
m_nStep = 0;
// m_idsOld.RemoveAll();
// m_idsNew.RemoveAll();
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
PtClick(pt,0);
return;
}
CEditCommand::Start();
}
void CModifySurfaceToCurveCommand::SurfaceToCurve(const FTR_HANDLE* handles,int num)
{
CDlgDataSource *pDS = GETDS(m_pEditor);
CUndoFtrs undo(m_pEditor,Name());
for (int i=0;i<num;i++)
{
CGeometry *pGeo = HandleToFtr(handles[i])->GetGeometry();
if (!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
{
continue;
}
BOOL bOK = FALSE;
CArray<PT_3DEX,PT_3DEX> pts, pts1;
pGeo->GetShape(pts);
int nsize = pts.GetSize();
for(int k=0; k<=nsize; k++)
{
if(k==nsize || (k!=0&&pts[k].pencode==penMove))
{
CValueTable tab;
tab.BeginAddValueItem();
HandleToFtr(handles[i])->WriteTo(tab);
tab.EndAddValueItem();
tab.DelField(FIELDNAME_SHAPE);
tab.DelField(FIELDNAME_GEOCURVE_CLOSED);
tab.DelField(FIELDNAME_FTRDELETED);
tab.DelField(FIELDNAME_FTRID);
tab.DelField(FIELDNAME_GEOCLASS);
tab.DelField(FIELDNAME_FTRDISPLAYORDER);
tab.DelField(FIELDNAME_FTRGROUPID);
tab.DelField(FIELDNAME_SYMBOLNAME);
CFeature *pNew = HandleToFtr(handles[i])->Clone();
if (!pNew) continue;
if (!pNew->CreateGeometry(CLS_GEOCURVE)) continue;
pNew->ReadFrom(tab);
pts1[0].pencode = penLine;
if( !pNew->GetGeometry()->CreateShape(pts1.GetData(),pts1.GetSize()) )
{
delete pNew;
continue;
}
if (!m_pEditor->AddObject(pNew,m_pEditor->GetFtrLayerIDOfFtr(handles[i])))
{
delete pNew;
continue;
}
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(handles[i]),pNew);
undo.AddNewFeature(FTR_HANDLE(pNew));
pts1.RemoveAll();
bOK = TRUE;
}
if(k==nsize) break;
pts1.Add(pts[k]);
}
if(bOK)
{
undo.AddOldFeature(handles[i]);
m_pEditor->DeleteObject(handles[i]);
}
}
undo.Commit();
}
void CModifySurfaceToCurveCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CSelection* pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE* handles = pSel->GetSelectedObjs(num);
SurfaceToCurve(handles,num);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CModifyCurveToSurfaceCommand,CEditCommand)
CModifyCurveToSurfaceCommand::CModifyCurveToSurfaceCommand()
{
m_bClosedCurveOnly = FALSE;
}
CModifyCurveToSurfaceCommand::~CModifyCurveToSurfaceCommand()
{
}
CString CModifyCurveToSurfaceCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CURVETOSURFACE);
}
void CModifyCurveToSurfaceCommand::Start()
{
if( !m_pEditor )return;
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
m_nStep = 0;
// m_idsOld.RemoveAll();
// m_idsNew.RemoveAll();
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
PtClick(pt,0);
return;
}
CEditCommand::Start();
}
void CModifyCurveToSurfaceCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (bool)(m_bClosedCurveOnly);
tab.AddValue(PF_CURVETOSURFACE_CLOSEDONLY,&CVariantEx(var));
}
void CModifyCurveToSurfaceCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("CurveToSurface",StrFromLocalResID(IDS_CMDNAME_CURVETOSURFACE));
param->AddParam(PF_CURVETOSURFACE_CLOSEDONLY,bool(m_bClosedCurveOnly),StrFromResID(IDS_CMDPLANE_CLOSEDCURVEONLY));
}
void CModifyCurveToSurfaceCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_CURVETOSURFACE_CLOSEDONLY,var) )
{
m_bClosedCurveOnly = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CModifyCurveToSurfaceCommand::CurveToSurface(const FTR_HANDLE* handles,int num)
{
CUndoFtrs undo(m_pEditor,Name());
for (int i=0;i<num;i++)
{
CGeometry *pGeo = HandleToFtr(handles[i])->GetGeometry();
if (!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
{
continue;
}
CGeoCurve *pDir = (CGeoCurve*)pGeo;
CArray<PT_3DEX,PT_3DEX> pts;
pDir->GetShape(pts);
if (pts.GetSize() < 3) continue;
BOOL bClosed = pDir->IsClosed();
if (m_bClosedCurveOnly && !bClosed)
{
continue;
}
CValueTable tab;
tab.BeginAddValueItem();
HandleToFtr(handles[i])->WriteTo(tab);
tab.EndAddValueItem();
tab.DelField(FIELDNAME_SHAPE);
tab.DelField(FIELDNAME_GEOCURVE_CLOSED);
tab.DelField(FIELDNAME_FTRDELETED);
tab.DelField(FIELDNAME_FTRID);
tab.DelField(FIELDNAME_GEOCLASS);
tab.DelField(FIELDNAME_FTRDISPLAYORDER);
tab.DelField(FIELDNAME_FTRGROUPID);
CFeature *pNew = HandleToFtr(handles[i])->Clone();
if (!pNew) continue;
if (!pNew->CreateGeometry(CLS_GEOSURFACE)) continue;
pNew->ReadFrom(tab);
// if (bClosed)
// {
// pts.RemoveAt(pts.GetSize()-1);
// }
pNew->GetGeometry()->CreateShape(pts.GetData(),pts.GetSize());
if (!m_pEditor->AddObject(pNew,m_pEditor->GetFtrLayerIDOfFtr(handles[i])))
{
delete pNew;
continue;
}
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(handles[i]),pNew);
undo.AddNewFeature(FTR_HANDLE(pNew));
undo.AddOldFeature(handles[i]);
m_pEditor->DeleteObject(handles[i]);
}
undo.Commit();
}
void CModifyCurveToSurfaceCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CSelection* pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE* handles = pSel->GetSelectedObjs(num);
CurveToSurface(handles,num);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CResetBaseAttributionCommand,CEditCommand)
CResetBaseAttributionCommand::CResetBaseAttributionCommand()
{
m_nResetFlg = 0;
}
CResetBaseAttributionCommand::~CResetBaseAttributionCommand()
{
}
CString CResetBaseAttributionCommand::Name()
{
return StrFromResID(IDS_CMDNAME_RESETATTRIBUTION);
}
void CResetBaseAttributionCommand::Abort()
{
UpdateParams(TRUE);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_pEditor->RefreshView();
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CEditCommand::Abort();
}
void CResetBaseAttributionCommand::Start()
{
if( !m_pEditor )return;
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
m_nStep = 0;
// m_idsOld.RemoveAll();
// m_idsNew.RemoveAll();
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
PtClick(pt,0);
return;
}
CEditCommand::Start();
}
void CResetBaseAttributionCommand::ResetBaseAttributions(const FTR_HANDLE* handles,int num)
{
CDlgDataSource *pDS = PDOC(m_pEditor)->GetDlgDataSource();
if (!pDS) return;
CConfigLibManager *pConfi = ((CEditBaseApp*)AfxGetApp())->GetConfigLibManager();
CScheme *pScheme = pConfi->GetScheme(pDS->GetScale());
if(!pScheme)return;
CUndoBatchAction batchUndo(m_pEditor,Name());
for (int i=0;i<num;i++)
{
CFeature *pFtr = HandleToFtr(handles[i]);
if (!pFtr) continue;
CGeometry *pGeo = pFtr->GetGeometry();
if (!pGeo) continue;
CFtrLayer *pLayer = pDS->GetFtrLayerOfObject(pFtr);
if (!pLayer) continue;
CSchemeLayerDefine *pSchemeLayer = pScheme->GetLayerDefine(pLayer->GetName());
if (!pSchemeLayer) continue;
CUndoModifyProperties undo(m_pEditor,Name());
undo.arrHandles.Add(handles[i]);
m_pEditor->DeleteObject(handles[i],FALSE);
undo.oldVT.BeginAddValueItem();
CPFeature(handles[i])->WriteTo(undo.oldVT);
undo.oldVT.EndAddValueItem();
CValueTable tab;
if (pFtr->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoText)))
{
tab.BeginAddValueItem();
tab.AddValue(FIELDNAME_GEOCOLOR,&(CVariantEx)(long)COLOUR_BYLAYER,IDS_FIELDNAME_COLOR);
tab.AddValue(FIELDNAME_SYMBOLNAME,&(CVariantEx)(const char*)"",IDS_FIELDNAME_GEOSYMBOLNAME);
tab.EndAddValueItem();
PDOC(m_pEditor)->GetTextParamsFromScheme(pLayer->GetName(),tab);
}
if (0 == m_nResetFlg) //0 缺省 1 方案配置
{
pSchemeLayer->GetDefaultValues(tab);
tab.DelField(FIELDNAME_FTRDISPLAYORDER);
tab.DelField(FIELDNAME_GEOTEXT_CONTENT);
tab.DelField(FIELDNAME_FTRMODIFYTIME);
tab.DelField(FIELDNAME_GEOCLASS);
tab.DelField(FIELDNAME_CLSTYPE);
tab.DelField(FIELDNAME_GEOPOINT_ANGLE);
tab.DelField(FIELDNAME_GEOCURVE_WIDTH);
tab.DelField(FIELDNAME_GEOCURVE_DHEIGHT);
tab.DelField(FIELDNAME_SYMBOLNAME);
pFtr->ReadFrom(tab);
}
else
{
pSchemeLayer->GetBasicAttributeDefaultValues(tab);
tab.DelField(FIELDNAME_FTRDISPLAYORDER);
tab.DelField(FIELDNAME_GEOTEXT_CONTENT);
tab.DelField(FIELDNAME_FTRMODIFYTIME);
tab.DelField(FIELDNAME_GEOCLASS);
tab.DelField(FIELDNAME_CLSTYPE);
tab.DelField(FIELDNAME_GEOPOINT_ANGLE);
tab.DelField(FIELDNAME_GEOCURVE_WIDTH);
tab.DelField(FIELDNAME_GEOCURVE_DHEIGHT);
tab.DelField(FIELDNAME_SYMBOLNAME);
pFtr->ReadFrom(tab);
pFtr->GetGeometry()->SetColor(pSchemeLayer->GetColor());
}
m_pEditor->RestoreObject(handles[i]);
undo.newVT.BeginAddValueItem();
CPFeature(handles[i])->WriteTo(undo.newVT);
undo.newVT.EndAddValueItem();
batchUndo.AddAction(&undo);
}
batchUndo.Commit();
}
void CResetBaseAttributionCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_RESETFLG,var) )
{
m_nResetFlg = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CResetBaseAttributionCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)m_nResetFlg;
tab.AddValue(PF_RESETFLG,&(CVariantEx)(long)(var));
}
void CResetBaseAttributionCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("CResetBaseAttributionCommand",StrFromResID(IDS_CMDNAME_RESETATTRIBUTION));
param->BeginOptionParam(PF_RESETFLG,StrFromResID(IDS_RESETFLAGE));
param->AddOption(StrFromResID(IDS_DEFAULTFEATURE),DefaultFeature,' ',m_nResetFlg==DefaultFeature);
param->AddOption(StrFromResID(IDS_LAYERCFGSCHEME),LayerCfgScheme,' ',m_nResetFlg==LayerCfgScheme);
param->EndOptionParam();
}
void CResetBaseAttributionCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CSelection* pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE* handles = pSel->GetSelectedObjs(num);
ResetBaseAttributions(handles,num);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CCommand::PtClick(pt, flag);
}
#include "DeleteCommonSideDlg.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CDeleteCommonSideCommand,CEditCommand)
CDeleteCommonSideCommand::CDeleteCommonSideCommand()
{
m_nStep = 0;
m_lfLimit = 1;
m_bKeepCommonSide = FALSE;
}
CDeleteCommonSideCommand::~CDeleteCommonSideCommand()
{
}
CString CDeleteCommonSideCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DELETECOMMONSIDE);
}
void CDeleteCommonSideCommand::Start()
{
if( !m_pEditor )return;
m_nStep = 0;
m_lfLimit = 1;
m_bKeepCommonSide = FALSE;
CEditCommand::Start();
m_pEditor->CloseSelector();
}
//line为线段
template<class T>
bool GetIntersectPos(T *pData1, int npt, T *line, double *t1, double *t2)
{
int i, ok = 0;
double pos, tol1, tol2, x, y;
pos = -1;
for( i=0; i<npt-1; i++)
{
if( GraphAPI::GGetLineIntersectLineSeg(pData1[i].x,pData1[i].y,
pData1[i+1].x,pData1[i+1].y,line[0].x,line[0].y,
line[1].x,line[1].y,&x,&y,&tol1,&tol2) )
{
if (t1)
{
*t1 = i+tol1;
}
if (t2)
{
*t2 = tol2;
}
ok = 1;
}
}
return ok;
}
void CDeleteCommonSideCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
m_ptLine[0] = pt;
m_nStep = 1;
}
else if (m_nStep == 1)
{
m_ptLine[1] = pt;
m_nStep = 2;
}
if( m_nStep==2 )
{
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
PT_3D Pt[2];
(m_pEditor->GetCoordWnd()).m_pSearchCS->GroundToClient(m_ptLine,Pt);
(m_pEditor->GetCoordWnd()).m_pSearchCS->GroundToClient(m_ptLine+1,Pt+1);
Envelope el;
el.CreateFromPts(Pt,2);
m_pEditor->GetDataQuery()->FindObjectInRect(el,(m_pEditor->GetCoordWnd()).m_pSearchCS);
int num1 ;
const CPFeature *ftr = (m_pEditor->GetDataQuery())->GetFoundHandles(num1);
if(num1!=2) return;
if(!ftr[0]->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) || !ftr[1]->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) )
{
Abort();
return;
}
//指定删除层，如果层相同略过， 层不同弹出对话框选择
int delete_part = 0;
CFtrLayer* pLayer1 = m_pEditor->GetDataSource()->GetFtrLayerOfObject(ftr[0]);
CFtrLayer* pLayer2 = m_pEditor->GetDataSource()->GetFtrLayerOfObject(ftr[1]);
if(!pLayer1 || !pLayer2)
{
Abort();
return;
}
if(pLayer1!=pLayer2)
{
CDeleteCommonSideDlg dlg;
dlg.m_layname1 = pLayer1->GetName();
dlg.m_layname2 = pLayer2->GetName();
if(dlg.DoModal())
{
delete_part = dlg.m_side;
}
}
if(delete_part!=0 && delete_part!=1)
{
Abort();
return;
}
CFeature* pFtr = ftr[delete_part];
int layid = m_pEditor->GetDataSource()->GetFtrLayerOfObject(pFtr)->GetID();
IntersectItemArray arr1, arr2;
GetIntersects(ftr[0], ftr[1], arr1);
int i=0;
for(i=0; i<arr1.GetSize(); i++)
{
//剔除不同地物
if(pFtr != arr1[i].pFtr)
continue;
//剔除重复交点,并从小到大排序
BOOL bSame = FALSE;//是否有重复
int k=0;
for(k=0; k<arr2.GetSize(); k++)
{
double postion1 = arr1[i].ptIdx + arr1[i].t;
double postion2 = arr2[k].ptIdx + arr2[k].t;
if(postion1<postion2)
{
break;
}
if( fabs(postion1-postion2)<1e-5 )
{
bSame = TRUE;
break;
}
}
if(bSame) continue;
if(k==arr2.GetSize())
{
arr2.Add(arr1[i]);
}
else if(k<arr2.GetSize())
{
arr2.InsertAt(k, arr1[i]);
}
}
if(arr2.GetSize()<=1)
{
Abort();
return;
}
CArray<PT_3DEX, PT_3DEX> pts;
pFtr->GetGeometry()->GetShape(pts);
PT_3DEX line[2];
COPY_3DPT(line[0],m_ptLine[0]);
COPY_3DPT(line[1],m_ptLine[1]);
double t;
GetIntersectPos(pts.GetData(), pts.GetSize(), line, &t, NULL);
int j=0, pos1=0, pos2=0;// pos1 pos2记录公共部分的起始/终点ptIdx
double t1=0, t2=0;// t1 t2记录公共部分的起始/终点交点位置
PT_3DEX pt1,pt2;//pt1 pt2记录公共部分的起始/终点交点
LP:
//公共部分的起点
pos1 = arr2[j].ptIdx;
t1 = arr2[j].t;
COPY_3DPT(pt1, arr2[j].pt);
//从下一个点开始找公共部分的末点
j++;
for(; j<arr2.GetSize(); j++)
{
if(arr2[j].ptIdx == arr2[j-1].ptIdx)//同一段
{
continue;
}
if( arr2[j].ptIdx==arr2[j-1].ptIdx+1 && fabs(arr2[j].t)<1e-5)//下一段的起点,也可以算作同一段
{
continue;
}
break;
}
t2 = arr2[j-1].t;
pos2 = arr2[j-1].ptIdx;
COPY_3DPT(pt2, arr2[j-1].pt);
if(pos1+t1>t || pos2+t2<t)
{
if(j>=arr2.GetSize())//没有公共部分
{
Abort();
return;
}
goto LP;
}
CArray<PT_3DEX, PT_3DEX> arrPts1, arrPts2;//可能被分成两部分
for(i=0; i<=pos1; i++)
{
arrPts1.Add(pts[i]);
}
if(t1>0)//添加一个点
{
pt1.pencode = penLine;
arrPts1.Add(pt1);
}
for(i=pos2; i<pts.GetSize(); i++)
{
arrPts2.Add(pts[i]);
}
if(t2>0)
{
COPY_3DPT(arrPts2[0], pt2);
}
int ptnum1 = arrPts1.GetSize();
int ptnum2 = arrPts2.GetSize();
CUndoFtrs undo(m_pEditor,Name());
if(ptnum1>1 && ptnum2>1 && GraphAPI::GIsEqual3DPoint(&arrPts1[0], &arrPts2[ptnum2-1]))
{
arrPts2.RemoveAt(ptnum2-1);
arrPts2.Append(arrPts1);
CFeature *pNew = pFtr->Clone();
pNew->SetID(OUID());
pNew->GetGeometry()->CreateShape(arrPts2.GetData(),arrPts2.GetSize());
m_pEditor->AddObject(pNew,layid);
GETXDS(m_pEditor)->CopyXAttributes(pFtr,pNew);
undo.arrNewHandles.Add(FtrToHandle(pNew));
}
else if(ptnum1<2 && ptnum2<2)
{
Abort();
return;
}
else
{
if(ptnum1>1)
{
CFeature *pNew = pFtr->Clone();
pNew->SetID(OUID());
pNew->GetGeometry()->CreateShape(arrPts1.GetData(),arrPts1.GetSize());
m_pEditor->AddObject(pNew,layid);
GETXDS(m_pEditor)->CopyXAttributes(pFtr,pNew);
undo.arrNewHandles.Add(FtrToHandle(pNew));
}
if(ptnum2>1)
{
CFeature *pNew = pFtr->Clone();
pNew->SetID(OUID());
pNew->GetGeometry()->CreateShape(arrPts2.GetData(),arrPts2.GetSize());
m_pEditor->AddObject(pNew,layid);
GETXDS(m_pEditor)->CopyXAttributes(pFtr,pNew);
undo.arrNewHandles.Add(FtrToHandle(pNew));
}
}
m_pEditor->DeleteObject(FTR_HANDLE(pFtr));
undo.AddOldFeature(FTR_HANDLE(pFtr));
undo.Commit();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
Finish();
m_nStep = 3;
}
CCommand::PtClick(pt, flag);
}
static void _FixT(double& t, double dis)
{
double toler = 1e-4/dis;
if(fabs(t)<toler)t = 0.0;
if(fabs(1-t)<toler)t = 1.0;
}
static void _Swap(double& a, double& b)
{
double t = a;
a = b;
b = t;
}
static bool GGetLineIntersectLineSeg_withOverlap(double lfX0,double lfY0, double lfX1, double lfY1,double lfX2,double lfY2,double lfX3,double lfY3,
double *plfX, double *plfY,double *plfT0, double *plfT1,
bool &twoIntersect,
double *plfX2, double *plfY2,double *plfT02, double *plfT12)
{
twoIntersect = false;
double vector1x = lfX1-lfX0, vector1y = lfY1-lfY0;
double vector2x = lfX3-lfX2, vector2y = lfY3-lfY2;
double delta = vector1x*vector2y-vector1y*vector2x;
if ((fabs(vector1x)+fabs(vector1y))*(fabs(vector2x)+fabs(vector2y))<=1e-15)
{
return false;
}
double unitdelta = delta/((fabs(vector1x)+fabs(vector1y))*(fabs(vector2x)+fabs(vector2y)));
if( unitdelta<GraphAPI::g_lfPraTolerance && unitdelta>-GraphAPI::g_lfPraTolerance )
{
//虽然平行，但并不共线，而是有间距
if(GraphAPI::GGetDisofPtToLine(lfX0,lfY0,lfX1,lfY1,lfX2,lfY2)>GraphAPI::g_lfDisTolerance )
return false;
double vector3x = lfX2-lfX0, vector3y = lfY2-lfY0;
//共线的情况
double av1x = fabs(vector1x), av1y = fabs(vector1y);
double av2x = fabs(vector2x), av2y = fabs(vector2y);
double av3x = fabs(vector3x), av3y = fabs(vector3y);
//两对点都是重叠点
if( av1x<GraphAPI::g_lfDisTolerance && av1y<GraphAPI::g_lfDisTolerance && av2x<GraphAPI::g_lfDisTolerance && av2y<GraphAPI::g_lfDisTolerance )
{
if( av3x<GraphAPI::g_lfDisTolerance && av3y<GraphAPI::g_lfDisTolerance )
{
if(plfX)*plfX = lfX0;
if(plfY)*plfY = lfY0;
if(plfT0)*plfT0 = 0;
if(plfT1)*plfT1 = 0;
return true;
}
return false;
}
//第一对点都是重叠点
else if( av1x<GraphAPI::g_lfDisTolerance && av1y<GraphAPI::g_lfDisTolerance )
{
double t1, t2;
if( av2x>av2y )
t2 = -vector3x/vector2x;
else
t2 = -vector3y/vector2y;
if( t2<0 || t2>1 )
return false;
t1 = 0;
if(plfX)*plfX = lfX0;
if(plfY)*plfY = lfY0;
if(plfT0)*plfT0 = t1;
if(plfT1)*plfT1 = t2;
return true;
}
//第二对点都是重叠点
else if( av2x<GraphAPI::g_lfDisTolerance && av2y<GraphAPI::g_lfDisTolerance )
{
double t1, t2;
if( av1x>av1y )
t1 = vector3x/vector1x;
else
t1 = vector3y/vector1y;
if( t1<0 || t1>1 )
return false;
t2 = 0;
if(plfX)*plfX = lfX2;
if(plfY)*plfY = lfY2;
if(plfT0)*plfT0 = t1;
if(plfT1)*plfT1 = t2;
return true;
}
//一般情况
else
{
twoIntersect = true;
//将两线段的方向调整，保持一致
bool swapflag = false;
if( av2x>av2y )
{
if( vector1x*vector2x<0 )
swapflag = true;
}
else
{
if( vector1y*vector2y<0 )
swapflag = true;
}
if(swapflag)
{
_Swap(lfX2,lfX3);
_Swap(lfY2,lfY3);
vector2x = -vector2x;
vector2y = -vector2y;
}
//先计算线段的端点在另一线段上的比例点ta,tb
double ta1, tb1, ta2, tb2;
if( av2x>av2y )
{
ta1 = (lfX0-lfX2)/vector2x;
tb1 = (lfX1-lfX2)/vector2x;
}
else
{
ta1 = (lfY0-lfY2)/vector2y;
tb1 = (lfY1-lfY2)/vector2y;
}
if( av1x>av1y )
{
ta2 = (lfX2-lfX0)/vector1x;
tb2 = (lfX3-lfX0)/vector1x;
}
else
{
ta2 = (lfY2-lfY0)/vector1y;
tb2 = (lfY3-lfY0)/vector1y;
}
_FixT(ta1,max(av2x,av2y));
_FixT(tb1,max(av2x,av2y));
_FixT(ta2,max(av1x,av1y));
_FixT(tb2,max(av1x,av1y));
//由于两个线段的方向一致，必定有ta1<tb1,ta2<tb2
//根据ta,tb计算两个交点的坐标和参数，由于两线段共线，所以两个交点实际上是靠内的两个端点
//共6种可能性
if( (ta1<0 && tb1<0) || (ta1>1 && tb1>1) )
{
//线段共线不相交
return false;
}
else if(ta1<=0 && tb1>=0 && tb1<=1 )
{
if(plfX)*plfX = lfX2;
if(plfY)*plfY = lfY2;
if(plfT0)*plfT0 = ta2;
if(plfT1)*plfT1 = 0;
if(plfX2)*plfX2 = lfX1;
if(plfY2)*plfY2 = lfY1;
if(plfT02)*plfT02 = 1;
if(plfT12)*plfT12 = tb1;
}
else if(ta1<=0 && tb1>=1 )
{
if(plfX)*plfX = lfX2;
if(plfY)*plfY = lfY2;
if(plfT0)*plfT0 = ta2;
if(plfT1)*plfT1 = 0;
if(plfX2)*plfX2 = lfX3;
if(plfY2)*plfY2 = lfY3;
if(plfT02)*plfT02 = tb2;
if(plfT12)*plfT12 = 1;
}
else if(ta1>=0 && ta1<=1 && tb1>=0 && tb1<=1 )
{
if(plfX)*plfX = lfX0;
if(plfY)*plfY = lfY0;
if(plfT0)*plfT0 = 0;
if(plfT1)*plfT1 = ta1;
if(plfX2)*plfX2 = lfX1;
if(plfY2)*plfY2 = lfY1;
if(plfT02)*plfT02 = 1;
if(plfT12)*plfT12 = tb1;
}
else if(ta1>=0 && ta1<=1 && tb1>=1 )
{
if(plfX)*plfX = lfX0;
if(plfY)*plfY = lfY0;
if(plfT0)*plfT0 = 0;
if(plfT1)*plfT1 = ta1;
if(plfX2)*plfX2 = lfX3;
if(plfY2)*plfY2 = lfY3;
if(plfT02)*plfT02 = tb2;
if(plfT12)*plfT12 = 1;
}
//前后端点衔接的情况，就认为只有一个交点
if( (ta1<0 && tb1==0) || (ta1==1 && tb1>1) )
{
twoIntersect = false;
}
if(swapflag)
{
if(plfT1)*plfT1 = 1.0-*plfT1;
if(plfT12)*plfT12 = 1.0-*plfT12;
}
return true;
}
}
double t1 = ( (lfX2-lfX0)*vector2y-(lfY2-lfY0)*vector2x )/delta;
double t2 = ( (lfX2-lfX0)*vector1y-(lfY2-lfY0)*vector1x )/delta;
double xr = lfX0 + t1*vector1x, yr = lfY0 + t1*vector1y;
bool bSnapEndPoint = true;
if( fabs(xr-lfX0)<=GraphAPI::g_lfDisTolerance && fabs(yr-lfY0)<=GraphAPI::g_lfDisTolerance )
{
t1 = 0;
xr = lfX0; yr = lfY0;
}
else if( fabs(xr-lfX1)<=GraphAPI::g_lfDisTolerance && fabs(yr-lfY1)<=GraphAPI::g_lfDisTolerance )
{
t1 = 1;
xr = lfX1; yr = lfY1;
}
else bSnapEndPoint = false;
if( fabs(xr-lfX2)<=GraphAPI::g_lfDisTolerance && fabs(yr-lfY2)<=GraphAPI::g_lfDisTolerance )
{
t2 = 0;
xr = lfX2; yr = lfY2;
}
else if( fabs(xr-lfX3)<=GraphAPI::g_lfDisTolerance && fabs(yr-lfY3)<=GraphAPI::g_lfDisTolerance )
{
t2 = 1;
xr = lfX3; yr = lfY3;
}
else bSnapEndPoint = false;
if(!bSnapEndPoint)
{
if( t1<0 || t1>1 || t2<0 || t2>1 )
{
return false;
}
}
if(plfX)*plfX = xr;
if(plfY)*plfY = yr;
if(plfT0)*plfT0 = t1;
if(plfT1)*plfT1 = t2;
return true;
}
void CDeleteCommonSideCommand::GetIntersects(CFeature* f1, CFeature* f2, IntersectItemArray &arr)
{
CGeometry *pGeo1 = f1->GetGeometry();
CGeometry *pGeo2 = f2->GetGeometry();
const CShapeLine *pShp1 = pGeo1->GetShape();
const CShapeLine *pShp2 = pGeo2->GetShape();
if( !pShp1 || !pShp2 )
return;
PT_3D pt1,pt2,line[2],ret;
double mindis = -1;
int nIdx1=-1,nIdx2=-1;
int nBaseIdx1 = 0, nBaseIdx2 = 0;
const CShapeLine::ShapeLineUnit *pList1 = pShp1->HeadUnit();
while (pList1!=NULL)
{
nIdx1++;
Envelope e = pList1->evlp;
e.m_xl -= 1e-6; e.m_xh += 1e-6;
e.m_yl -= 1e-6; e.m_yh += 1e-6;
const CShapeLine::ShapeLineUnit *pList2 = pShp2->HeadUnit();
nIdx2 = -1;
while(pList2!=NULL)
{
nIdx2++;
if(e.bIntersect(&(pList2->evlp)))
{
for (int i=0;i<pList1->nuse-1;i++)
{
if( pList1->pts[i+1].pencode==penMove )
continue;
COPY_3DPT(line[0],pList1->pts[i]);
COPY_3DPT(line[1],pList1->pts[i+1]);
Envelope e0 = pList2->evlp;
e0.m_xl -= 1e-4; e0.m_xh += 1e-4;
e0.m_yl -= 1e-4; e0.m_yh += 1e-4;
if(!e0.bIntersect(line,line+1))continue;
for (int j=0;j<pList2->nuse-1;j++)
{
if( pList2->pts[j+1].pencode==penMove )
continue;
//为了优化，先判断一下
double xmin1, xmax1, ymin1, ymax1, xmin2, xmax2, ymin2, ymax2;
if( line[0].x<line[1].x ){ xmin1 = line[0].x; xmax1 = line[1].x; }
else { xmin1 = line[1].x; xmax1 = line[0].x; }
if( line[0].y<line[1].y ){ ymin1 = line[0].y; ymax1 = line[1].y; }
else { ymin1 = line[1].y; ymax1 = line[0].y; }
if( pList2->pts[j].x<pList2->pts[j+1].x ){ xmin2 = pList2->pts[j].x; xmax2 = pList2->pts[j+1].x; }
else { xmin2 = pList2->pts[j+1].x; xmax2 = pList2->pts[j].x; }
if( pList2->pts[j].y<pList2->pts[j+1].y ){ ymin2 = pList2->pts[j].y; ymax2 = pList2->pts[j+1].y; }
else { ymin2 = pList2->pts[j+1].y; ymax2 = pList2->pts[j].y; }
if( xmax1<xmin2-1e-4 || xmax2<xmin1-1e-4 ||
ymax1<ymin2-1e-4 || ymax2<ymin1-1e-4 )
continue;
double xt,yt,xt2,yt2;
double t0=0,t1=0,t2=0,t3=0;
bool twoIntersect = false;
if(GGetLineIntersectLineSeg_withOverlap(line[0].x,line[0].y,line[1].x,line[1].y,pList2->pts[j].x,pList2->pts[j].y,pList2->pts[j+1].x,pList2->pts[j+1].y,
&xt,&yt,&t0,&t1,
twoIntersect,
&xt2,&yt2,&t2,&t3))
{
if(t0<-0.01 || t1<-0.01 || t2<-0.01||t3<-0.01)
{
//不应该得到这样的结果
GGetLineIntersectLineSeg_withOverlap(line[0].x,line[0].y,line[1].x,line[1].y,pList2->pts[j].x,pList2->pts[j].y,pList2->pts[j+1].x,pList2->pts[j+1].y,
&xt,&yt,&t0,&t1,
twoIntersect,
&xt2,&yt2,&t2,&t3);
int a=1;
}
IntersectItem item0,item1;
item0.pFtr = f1;
item0.pt.x = xt;
item0.pt.y = yt;
item0.pt.z = line[0].z + t0 * (line[1].z-line[0].z);
item0.t = t0;
item0.ptIdx = nBaseIdx1 + i;
if( (line[0].x-xt)*(line[0].x-xt)+(line[0].y-yt)*(line[0].y-yt)<1e-8 )
{
item0.t = 0;
}
if( (line[1].x-xt)*(line[1].x-xt)+(line[1].y-yt)*(line[1].y-yt)<1e-8 )
{
item0.ptIdx++;
item0.t = 0;
}
item1.pFtr = f2;
item1.pt.x = xt;
item1.pt.y = yt;
item1.pt.z = pList2->pts[j].z + t1 * (pList2->pts[j+1].z-pList2->pts[j].z);
item1.t = t1;
item1.ptIdx = nBaseIdx2 + j;
if( (pList2->pts[j].x-xt)*(pList2->pts[j].x-xt)+(pList2->pts[j].y-yt)*(pList2->pts[j].y-yt)<1e-8 )
{
item1.t = 0;
}
if( (pList2->pts[j+1].x-xt)*(pList2->pts[j+1].x-xt)+(pList2->pts[j+1].y-yt)*(pList2->pts[j+1].y-yt)<1e-8 )
{
item1.ptIdx++;
item1.t = 0;
}
arr.Add(item0);
arr.Add(item1);
if(twoIntersect)
{
item0 = IntersectItem();
item1 = IntersectItem();
xt = xt2; yt = yt2;
t0 = t2; t1 = t3;
item0.pFtr = f1;
item0.pt.x = xt;
item0.pt.y = yt;
item0.pt.z = line[0].z + t0 * (line[1].z-line[0].z);
item0.t = t0;
item0.ptIdx = nBaseIdx1 + i;
if( (line[0].x-xt)*(line[0].x-xt)+(line[0].y-yt)*(line[0].y-yt)<1e-8 )
{
item0.t = 0;
}
if( (line[1].x-xt)*(line[1].x-xt)+(line[1].y-yt)*(line[1].y-yt)<1e-8 )
{
item0.ptIdx++;
item0.t = 0;
}
item1.pFtr = f2;
item1.pt.x = xt;
item1.pt.y = yt;
item1.pt.z = pList2->pts[j].z + t1 * (pList2->pts[j+1].z-pList2->pts[j].z);
item1.t = t1;
item1.ptIdx = nBaseIdx2 + j;
if( (pList2->pts[j].x-xt)*(pList2->pts[j].x-xt)+(pList2->pts[j].y-yt)*(pList2->pts[j].y-yt)<1e-8 )
{
item1.t = 0;
}
if( (pList2->pts[j+1].x-xt)*(pList2->pts[j+1].x-xt)+(pList2->pts[j+1].y-yt)*(pList2->pts[j+1].y-yt)<1e-8 )
{
item1.ptIdx++;
item1.t = 0;
}
arr.Add(item0);
arr.Add(item1);
}
}
}
}
}
nBaseIdx2 += pList2->nuse;
pList2 = pList2->next;
}
nBaseIdx1 += pList1->nuse;
pList1 = pList1->next;
}
}
void CDeleteCommonSideCommand::PtMove(PT_3D &pt)
{
if (m_nStep == 1)
{
GrBuffer buf;
buf.BeginLineString(255,0,0);
buf.MoveTo(&m_ptLine[0]);
buf.LineTo(&pt);
buf.End();
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
}
CEditCommand::PtMove(pt);
}
/////////////////////////////////////////////////////////////////////
// CModifyZCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CModifyZCommand,CEditCommand)
CModifyZCommand::CModifyZCommand()
{
m_nStep = -1;
m_bOnlyContour = TRUE;
m_lfResultZ = 0;
m_bStartSnapHeight = FALSE;
strcat(m_strRegPath,"\\ModifyZ");
}
CModifyZCommand::~CModifyZCommand()
{
}
void CModifyZCommand::Abort()
{
CEditCommand::Abort();
}
CString CModifyZCommand::Name()
{
return StrFromResID(IDS_CMDNAME_MODIFYZ);
}
void CModifyZCommand::Start()
{
if( !m_pEditor )return;
m_bOnlyContour = TRUE;
m_lfResultZ = 0;
CEditCommand::Start();
}
BOOL CModifyZCommand::CheckObjForContour(CGeometry *pObj)
{
if( !pObj )return FALSE;
CArray<PT_3DEX,PT_3DEX> pts;
pObj->GetShape(pts);
int num = pts.GetSize();
if (num<=0)
{
return FALSE;
}
PT_3DEX pt0,pt1;
pt0 = pts.GetAt(0);
for( int j=1; j<num; j++)
{
pt1 = pts.GetAt(j);
if( fabs(pt1.z-pt0.z)>=GraphAPI::g_lfZTolerance )break;
}
if( j<num )return FALSE;
return TRUE;
}
void CModifyZCommand::PtClick(PT_3D &pt, int flag)
{
if( m_bStartSnapHeight )
{
CSelection * pSel = m_pEditor->GetSelection();
int num = 0;
const FTR_HANDLE * handles = pSel->GetSelectedObjs(num);
if( num<=0 )
return;
double z0 = 0;
CGeometry *pObj = HandleToFtr(handles[0])->GetGeometry();
if( CModifyZCommand::CheckObjForContour(pObj) )
{
CArray<PT_3DEX,PT_3DEX> arrPts;
pObj->GetShape(arrPts);
z0 = arrPts[0].z;
}
else
{
Envelope evlp;
evlp.CreateFromPtAndRadius(pt,1e+100);
PT_3D retPt;
pObj->FindNearestBasePt(pt,evlp,NULL,&retPt,NULL);
z0 = retPt.z;
}
m_lfResultZ = z0;
SetSettingsModifyFlag();
CUIParam param;
FillShowParams(¶m);
m_pEditor->UIRequest(UIREQ_TYPE_SHOWUIPARAM, (LONG_PTR)¶m);
m_bStartSnapHeight = FALSE;
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
return;
}
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CGeometry *pObj;
// CGeometry *pObj1, *pObj2;
CSelection * pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE * handles = pSel->GetSelectedObjs(num);
//CUndoFtrs undo(m_pEditor,Name());
CUndoModifyProperties undo(m_pEditor,Name());
GrBuffer buf;
PT_3DEX pt0,pt1;
for( int i = num-1; i>=0; i--)
{
pObj = HandleToFtr(handles[i])->GetGeometry();
//生成新的对象，这里需要指定新对象层码
if( !pObj || pObj->GetDataPointSum()<=0 )continue;
if( m_bOnlyContour && !CheckObjForContour(pObj) )
continue;
undo.arrHandles.Add(handles[i]);
undo.oldVT.BeginAddValueItem();
HandleToFtr(handles[i])->WriteTo(undo.oldVT);
undo.oldVT.EndAddValueItem();
// pObj = pObj->Clone();
// if( !pObj )continue;
CArray<PT_3DEX,PT_3DEX> arr;
pObj->GetShape(arr);
int num0 = arr.GetSize();
for( int j=0; j<num0; j++)
{
PT_3DEX &pt1 = arr.ElementAt(j);
pt1.z = m_lfResultZ;
}
m_pEditor->DeleteObject(handles[i],FALSE);
pObj->CreateShape(arr.GetData(),arr.GetSize());
if( !m_pEditor->RestoreObject(handles[i]) )
{
Abort();
return;
}
undo.newVT.BeginAddValueItem();
HandleToFtr(handles[i])->WriteTo(undo.newVT);
undo.newVT.EndAddValueItem();
}
undo.Commit();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CEditCommand::PtClick(pt,flag);
}
void CModifyZCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (bool)(m_bOnlyContour);
tab.AddValue(PF_MODIFYZONLYCONTOR,&CVariantEx(var));
var = (double)(m_lfResultZ);
tab.AddValue(PF_MODIFYZHEIGHT,&CVariantEx(var));
}
void CModifyZCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("ModifyZCommand",StrFromLocalResID(IDS_CMDNAME_MODIFYZ));
param->AddParam(PF_MODIFYZONLYCONTOR,bool(m_bOnlyContour),StrFromResID(IDS_CMDPLANE_ONLYCONTOUR));
param->AddParam(PF_MODIFYZHEIGHT,double(m_lfResultZ),StrFromResID(IDS_CMDPLANE_Z));
param->AddButtonParam("SnapHeight",StrFromResID(IDS_SNAPHEIGHT));
}
void CModifyZCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_MODIFYZONLYCONTOR,var) )
{
m_bOnlyContour = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_MODIFYZHEIGHT,var) )
{
m_lfResultZ = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"SnapHeight",var) )
{
m_bStartSnapHeight = TRUE;
m_pEditor->OpenSelector();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CModifyColorCommand Class
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CModifyColorCommand,CEditCommand)
CModifyColorCommand::CModifyColorCommand()
{
m_nStep = -1;
}
CModifyColorCommand::~CModifyColorCommand()
{
}
CString CModifyColorCommand::Name()
{
return StrFromResID(IDS_CMDNAME_MODIFYCOLOR);
}
void CModifyColorCommand::Start()
{
if( !m_pEditor )return;
int num;
m_pEditor->GetSelection()->GetSelectedObjs(num);
if( num>0 )
{
m_nStep = 0;
CCommand::Start();
PT_3D pt;
PtClick(pt,SELSTAT_NONESEL);
return;
}
CEditCommand::Start();
}
void CModifyColorCommand::Abort()
{
CEditCommand::Abort();
}
void CModifyColorCommand::Finish()
{
UpdateParams(TRUE);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
CEditCommand::Finish();
}
void CModifyColorCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("ModifyColorCommand",StrFromLocalResID(IDS_CMDNAME_MODIFYCOLOR));
param->AddColorParam("ChooseColor",(long)m_nColor,StrFromResID(IDS_CHOOSECOLOR));
}
void CModifyColorCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"ChooseColor",var) )
{
m_nColor = (long)(_variant_t)*var;
m_pEditor->OpenSelector();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CModifyColorCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)m_nColor;
tab.AddValue("ChooseColor",&CVariantEx(var));
}
void CModifyColorCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CSelection * pSel = m_pEditor->GetSelection();
int num = 0;
const FTR_HANDLE * handles = pSel->GetSelectedObjs(num);
if( num<=0 )
return;
CUndoModifyProperties undo(m_pEditor,Name());
GetActiveDlgDoc()->BeginBatchUpdate();
for(int i=0; i<num; ++i)
{
CPFeature pftr = HandleToFtr(handles[i]);
if(pftr==NULL || pftr->GetGeometry()==NULL)
continue;
//
undo.arrHandles.Add(handles[i]);
undo.oldVT.BeginAddValueItem();
HandleToFtr(handles[i])->WriteTo(undo.oldVT);
undo.oldVT.EndAddValueItem();
m_pEditor->DeleteObject(handles[i],FALSE);
pftr->GetGeometry()->SetColor(m_nColor);
if( !m_pEditor->RestoreObject(handles[i]) )
{
continue;
}
undo.newVT.BeginAddValueItem();
HandleToFtr(handles[i])->WriteTo(undo.newVT);
undo.newVT.EndAddValueItem();
}
GetActiveDlgDoc()->EndBatchUpdate();
undo.Commit();
}
Finish();
CEditCommand::PtClick(pt,flag);
}
//////////////////////////////////////////////////////////////////////
// CModifyIntersectionCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CModifyIntersectionCommand,CEditCommand)
CModifyIntersectionCommand::CModifyIntersectionCommand()
{
m_nStep = -1;
}
CModifyIntersectionCommand::~CModifyIntersectionCommand()
{
}
CString CModifyIntersectionCommand::Name()
{
return StrFromResID(IDS_CMDNAME_MODIFYINTERSECTION);
}
void CModifyIntersectionCommand::Start()
{
if( !m_pEditor )return;
m_nStep=0;
CEditCommand::Start();
m_pEditor->CloseSelector();
}
void CModifyIntersectionCommand::Abort()
{
CEditCommand::Abort();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
bool CModifyIntersectionCommand::IsInRange(PT_3DEX *pts, int nums, PT_3D pt1, PT_3D pt2)
{
for (int i=0;i<nums;i++)
{
if ((pts+i)->x>=min(pt1.x,pt2.x)&&
(pts+i)->x<=max(pt1.x,pt2.x)&&
(pts+i)->y>=min(pt1.y,pt2.y)&&
(pts+i)->y<=max(pt1.y,pt2.y))
{
continue;
}
else
return false;
}
return true;
}
void CModifyIntersectionCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if( m_nStep==0 )
{
m_start = pt;
GotoState(PROCSTATE_PROCESSING);
m_nStep = 1;
return;
}
if( m_nStep==1 )
{
CArray<CGeometry*,CGeometry*&> addObject;
CArray<FTR_HANDLE,FTR_HANDLE> arrHandles;
// CArray<int,int> objLayerHandle;
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_end = pt;
PT_4D Pt[2];
COPY_3DPT(Pt[0],m_start);
COPY_3DPT(Pt[1], m_end);
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(Pt,2);
Envelope el;
el.CreateFromPts(Pt,2,sizeof(PT_4D));
m_pEditor->DeselectAll();
m_pEditor->GetDataQuery()->FindObjectInRect(el,m_pEditor->GetCoordWnd().m_pSearchCS);
int num1 ;
const CPFeature *ftr = m_pEditor->GetDataQuery()->GetFoundHandles(num1);
if (num1>10)
{
Abort();
return;
}
CArray<CPFeature,CPFeature> arrFtrs;
for (int i=0; i<num1; i++)
{
arrFtrs.Add(ftr[i]);
}
CGeometry *pObj=NULL;
CGeometry *pObj1=NULL;
// 将双线地物打散
CArray<CPFeature,CPFeature> arrSepFtrs;
for (i=0; i<arrFtrs.GetSize(); i++)
{
pObj = ftr[i]->GetGeometry();
if( !pObj )continue;
CGeometry *pCur1 = NULL, *pCur2 = NULL;
if (pObj->IsKindOf(RUNTIME_CLASS(CGeoParallel)))
{
((CGeoParallel*)pObj)->Separate(pCur1,pCur2);
}
else if (pObj->IsKindOf(RUNTIME_CLASS(CGeoDCurve)))
{
((CGeoDCurve*)pObj)->Separate(pCur1,pCur2);
}
if (pCur1)
{
CPFeature pNewFtr = ftr[i]->Clone();
if (pNewFtr)
{
pNewFtr->SetGeometry(pCur1);
arrSepFtrs.Add(pNewFtr);
if( !m_pEditor->AddObject(pNewFtr,m_pEditor->GetFtrLayerIDOfFtr(FTR_HANDLE(ftr[i]))))
{
delete pNewFtr;
Abort();
continue;
}
}
}
if (pCur2)
{
CPFeature pNewFtr = ftr[i]->Clone();
if (pNewFtr)
{
pNewFtr->SetGeometry(pCur2);
arrSepFtrs.Add(pNewFtr);
if( !m_pEditor->AddObject(pNewFtr,m_pEditor->GetFtrLayerIDOfFtr(FTR_HANDLE(ftr[i]))))
{
delete pNewFtr;
Abort();
continue;
}
}
}
}
arrFtrs.Append(arrSepFtrs);
int ftrNum = arrFtrs.GetSize();
for( i=0; i<ftrNum; i++)//遍历每一个线状地物
{
int PtNums1;
CArray<PT_3DEX,PT_3DEX> pts1;
pObj = arrFtrs[i]->GetGeometry();
if( !pObj )continue;
else if( !pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) || pObj->IsKindOf(RUNTIME_CLASS(CGeoParallel))
|| pObj->IsKindOf(RUNTIME_CLASS(CGeoDCurve)))continue;
else if((PtNums1=pObj->GetDataPointSum())<2 )continue;
else
{
const CShapeLine *pSL = pObj->GetShape();
if( !pSL )continue;
pSL->GetPts(pts1);
// pSL->GetPtsCount()
// for (int i=0;i<pts1.GetSize();i++)
// {
// COPY_3DPT()
// }
}
//PtNums = pts1.GetSize();
PtNums1 = GraphAPI::GKickoffSamePoints(pts1.GetData(),pts1.GetSize());
pts1.SetSize(PtNums1);
pts1.FreeExtra();
PT_3D startPt;
COPY_3DPT(startPt,pts1[0]);
PT_3D endPt;
COPY_3DPT(endPt,pts1[0]);
int start=1;
int end=0;
for (int k=0;k<PtNums1-1;k++)//对每条线段处理
{
PT_3DEX ret,minret;
PT_3DEX start1;
double t,mint=1;
start1=pts1[k];
int count=0;
do{
// if (!(max(pts1[k].x,pts1[k+1].x)<min(m_start.x,m_end.x)||
// min(pts1[k].x,pts1[k+1].x)>max(m_start.x,m_end.x)||
// max(pts1[k].y,pts1[k+1].y)<min(m_start.y,m_end.y)||
// min(pts1[k].y,pts1[k+1].y)>max(m_start.y,m_end.y)))
{
mint=1;
for (int j=0;j<ftrNum;j++)//遍历其余地物
{
if (j!=i)
{
int PtNums2;
pObj1 = arrFtrs[j]->GetGeometry();
CArray<PT_3DEX,PT_3DEX> pts2;
if( !pObj1 )continue;
else if( !pObj1->IsKindOf(RUNTIME_CLASS(CGeoCurve)) || pObj1->IsKindOf(RUNTIME_CLASS(CGeoParallel))
|| pObj1->IsKindOf(RUNTIME_CLASS(CGeoDCurve)))continue;
else if((PtNums2=pObj1->GetDataPointSum())<2 )continue;
else
{
const CShapeLine *pSL1 = pObj1->GetShape();
if( !pSL1 )continue;
pSL1->GetPts(pts2);
}
PtNums2 = GraphAPI::GKickoffSamePoints(pts2.GetData(),pts2.GetSize());
pts2.SetSize(PtNums2);
pts2.FreeExtra();
if (
GraphAPI::GGetFirstPointOfIntersect(pts2.GetData(),PtNums2,start1,pts1[k+1],&ret,&t)&&
GraphAPI::GIsPtInRange(m_start,m_end,PT_3D(ret.x,ret.y,ret.z)))//进不去
{
count++;
if (t<=mint)
{
mint=t;
minret=ret;
}
}
}
}
}
if(count==0&&k!=PtNums1-2)
break;
if(count==0&&k==PtNums1-2)
{
endPt=pts1[PtNums1-1];
end=PtNums1-2;
if(!IsInRange(&(pts1[start]),end-start+1,m_start,m_end)||!GraphAPI::GIsPtInRange(m_start,m_end,startPt)||!GraphAPI::GIsPtInRange(m_start,m_end,endPt))
{
if (GraphAPI::GIsEqual3DPoint(&startPt,&endPt))
{
addObject.Add(pObj);
arrHandles.Add(FtrToHandle(arrFtrs[i]));
// objLayerHandle.Add(ids1[i].layhdl);
}
else if (GraphAPI::GIsEqual3DPoint(&pts1[0],&PT_3DEX(endPt,0)))
{
CGeometry *objs[3]={0};
((CGeoCurve*)pObj)->GetBreak(startPt,endPt,objs[0],objs[1],objs[2]);
if( objs[0] )
{
delete objs[0];
objs[0] = NULL;
}
if( objs[1] )
{
delete objs[1];
objs[1] = NULL;
}
if (objs[2])
{
addObject.Add(objs[2]);
arrHandles.Add(FtrToHandle(arrFtrs[i]));
CArray<PT_3DEX,PT_3DEX> arr0;
objs[2]->GetShape(arr0);
int size0 = arr0.GetSize();
if (!GraphAPI::GIsEqual2DPoint(&arr0[0],&pts1[0]))
{
arr0[0].z = (startPt.z + arr0[0].z) / 2;
}
if (!GraphAPI::GIsEqual2DPoint(&arr0[size0-1],&pts1[PtNums1-1]))
{
arr0[size0-1].z = (endPt.z + arr0[size0-1].z) / 2;
}
objs[2]->CreateShape(arr0.GetData(),arr0.GetSize());
// objLayerHandle.Add(ids1[i].layhdl);
}
}
else
{
CGeometry *objs[3]={0};
((CGeoCurve*)pObj)->GetBreak(startPt,endPt,objs[0],objs[1],objs[2]);
if( objs[0] )
{
delete objs[0];
objs[0] = NULL;
}
if( objs[2] )
{
delete objs[2];
objs[2] = NULL;
}
if (objs[1])
{
addObject.Add(objs[1]);
arrHandles.Add(FtrToHandle(arrFtrs[i]));
CArray<PT_3DEX,PT_3DEX> arr0;
objs[1]->GetShape(arr0);
int size0 = arr0.GetSize();
if (!GraphAPI::GIsEqual2DPoint(&arr0[0],&pts1[0]))
{
arr0[0].z = (startPt.z + arr0[0].z) / 2;
}
if (!GraphAPI::GIsEqual2DPoint(&arr0[size0-1],&pts1[PtNums1-1]))
{
arr0[size0-1].z = (endPt.z + arr0[size0-1].z) / 2;
}
objs[1]->CreateShape(arr0.GetData(),arr0.GetSize());
// objLayerHandle.Add(ids1[i].layhdl);
}
}
}
break;
}
if (count==1)
{
endPt=minret;
end=k;
if(!IsInRange(&(pts1[start]),end-start+1,m_start,m_end)||!GraphAPI::GIsPtInRange(m_start,m_end,startPt)||!GraphAPI::GIsPtInRange(m_start,m_end,endPt))
{
CGeometry *objs[3]={0};
((CGeoCurve*)pObj)->GetBreak(startPt,endPt,objs[0],objs[1],objs[2]);
if( objs[0] )
{
delete objs[0];
objs[0] = NULL;
}
if( objs[2] )
{
delete objs[2];
objs[2] = NULL;
}
if (objs[1])
{
addObject.Add(objs[1]);
arrHandles.Add(FtrToHandle(arrFtrs[i]));
CArray<PT_3DEX,PT_3DEX> arr0;
objs[1]->GetShape(arr0);
int size0 = arr0.GetSize();
if (!GraphAPI::GIsEqual2DPoint(&arr0[0],&pts1[0]))
{
arr0[0].z = (startPt.z + arr0[0].z) / 2;
}
if (!GraphAPI::GIsEqual2DPoint(&arr0[size0-1],&pts1[PtNums1-1]))
{
arr0[size0-1].z = (endPt.z + arr0[size0-1].z) / 2;
}
objs[1]->CreateShape(arr0.GetData(),arr0.GetSize());
// objLayerHandle.Add(ids1[i].layhdl);
}
start = end+1;
startPt = endPt;
COPY_3DPT(start1,endPt);
count = 0;
continue;
}
else
{
start = end+1;
count = 0;
startPt = endPt;
COPY_3DPT(start1,endPt);
continue;
}
}
if (count>=2)
{
endPt=minret;
end=k;
if(!IsInRange(&(pts1[start]),end-start+1,m_start,m_end)||!GraphAPI::GIsPtInRange(m_start,m_end,startPt)||!GraphAPI::GIsPtInRange(m_start,m_end,endPt))
{
CGeometry *objs[3]={0};
((CGeoCurve*)pObj)->GetBreak(startPt,endPt,objs[0],objs[1],objs[2]);//首尾相同时做例外处理
if( objs[0] )
{
delete objs[0];
objs[0] = NULL;
}
if( objs[2] )
{
delete objs[2];
objs[2] = NULL;
}
if (objs[1])
{
addObject.Add(objs[1]);
arrHandles.Add(FtrToHandle(arrFtrs[i]));
CArray<PT_3DEX,PT_3DEX> arr0;
objs[1]->GetShape(arr0);
int size0 = arr0.GetSize();
if (!GraphAPI::GIsEqual2DPoint(&arr0[0],&pts1[0]))
{
arr0[0].z = (startPt.z + arr0[0].z) / 2;
}
if (!GraphAPI::GIsEqual2DPoint(&arr0[size0-1],&pts1[PtNums1-1]))
{
arr0[size0-1].z = (endPt.z + arr0[size0-1].z) / 2;
}
objs[1]->CreateShape(arr0.GetData(),arr0.GetSize());
// objLayerHandle.Add(ids1[i].layhdl);
}
}
start = end+1;
startPt = endPt;
count = 0;
COPY_3DPT(start1,endPt);
continue;
}
}while(1);
}
}
CUndoFtrs undo(m_pEditor,Name());
for (int l=0;l<addObject.GetSize();l++) //添加地物
{
CFeature *pFtr = HandleToFtr(arrHandles[l])->Clone() ;
if (pFtr)
{
pFtr->SetID(OUID());
pFtr->SetGeometry(addObject[l]);
int layid = m_pEditor->GetFtrLayerIDOfFtr(arrHandles[l]);
if(!m_pEditor->AddObject(pFtr,layid))
{
delete pFtr;
continue;
}
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(arrHandles[l]),pFtr);
undo.arrNewHandles.Add(FtrToHandle(pFtr));
}
// m_pDoc->AddObject(addObject.GetAt(l),objLayerHandle.GetAt(l) ));
}
for( int b=0; b<num1; b++)//遍历每一个线状地物,将不是全部在拉框内的删除
{
pObj = ftr[b]->GetGeometry();
CArray<PT_3DEX,PT_3DEX> pts;
if( !pObj )continue;
else if( !pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )continue;
else if((pObj->GetDataPointSum())<2 )continue;
else
{
const CShapeLine *pSL = pObj->GetShape();
if( !pSL )continue;
pSL->GetPts(pts);
}
if(!IsInRange(pts.GetData(),pts.GetSize(),m_start,m_end))
{
m_pEditor->DeleteObject(FtrToHandle(ftr[b]));
undo.arrOldHandles.Add(FtrToHandle(ftr[b]));
// m_idsOld.Add(ids1[b]);
}
}
addObject.RemoveAll();
for (i=0; i<arrSepFtrs.GetSize(); i++)
{
if (arrSepFtrs[i])
{
m_pEditor->DeleteObject(FtrToHandle(arrSepFtrs[i])); //删除打散后的双线
}
}
arrSepFtrs.RemoveAll();
undo.Commit();
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CEditCommand::PtClick(pt,flag);
}
void CModifyIntersectionCommand::PtMove(PT_3D &pt)
{
if (m_nStep==1)
{
GrBuffer buf;
PT_3D tem[2];
tem[0].x=m_start.x;
tem[0].y=pt.y;
tem[0].z=m_start.z;
tem[1].x=pt.x;
tem[1].y=m_start.y;
tem[1].z=m_start.z;
buf.BeginLineString(0,0);
buf.MoveTo(&m_start);
buf.LineTo(&tem[0]);
buf.LineTo(&pt);
buf.LineTo(&tem[1]);
buf.LineTo(&m_start);
buf.End();
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
return;
}
}
//////////////////////////////////////////////////////////////////////
// CChamferCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CChamferCommand,CEditCommand)
CChamferCommand::CChamferCommand()
{
m_nStep = -1;
m_nMode = modeArcChamfer;
m_bLineserial = FALSE;
strcat(m_strRegPath,"\\Chamfer");
}
CChamferCommand::~CChamferCommand()
{
}
CString CChamferCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CHAMFER);
}
void CChamferCommand::Start()
{
if( !m_pEditor )return;
m_nMode = modeArcChamfer;
m_bLineserial = FALSE;
m_pNewFtrs[0] = NULL;
m_pNewFtrs[1] = NULL;
CEditCommand::Start();
m_pEditor->OpenSelector(SELMODE_SINGLE);
if( m_nMode==modeArcChamfer )
;//OutputTipString(StrFromResID(IDS_CMDTIP_CLICKCHAMFER));
else
;//OutputTipString(StrFromResID(IDS_CMDTIP_CLICKCHAMFER));
}
void CChamferCommand::Abort()
{
m_pNewFtrs[0] = NULL;
if(m_pNewFtrs[1])
{
delete m_pNewFtrs[1];
m_pNewFtrs[1] = NULL;
}
CEditCommand::Abort();
m_pEditor->RefreshView();
}
int CChamferCommand::GPtinRegion(LINE_2D l1,LINE_2D l2,PT_2D &pt,PT_2D *ret1,PT_2D *ret2,double *t1,double *t2,int mode)
{
PT_2D Pt0;//交点
PT_2D Pt1;//角平分线上的某点
PT_2D Pt2;//过交点且垂直于角平分线的直线上的一点
PT_2D Pt3,Pt4;//垂足
PT_3D temp[3];
PT_3D ptt;
temp[0].x=l1.sp.x;
temp[0].y=l1.sp.y;
temp[2].x=l2.sp.x;
temp[2].y=l2.sp.y;
ptt.x=pt.x;
ptt.y=pt.y;
ptt.z=0;
if(GraphAPI::GGetRay1IntersectRay2(l1.sp.x,l1.sp.y,l1.ep.x,l1.ep.y,l2.sp.x,l2.sp.y,l2.ep.x,l2.ep.y,&(Pt0.x),&(Pt0.y)))
{
temp[1].x=Pt0.x;
temp[1].y=Pt0.y;
if(!GraphAPI::GGetPtInAngleBisector2D(Pt0.x,Pt0.y,l1.sp.x,l1.sp.y,l2.sp.x,l2.sp.y,&(Pt1.x),&(Pt1.y)))return -1;
GraphAPI::GGetPerpendicular(Pt0.x,Pt0.y,Pt1.x,Pt1.y,l1.sp.x,l1.sp.y,&(Pt3.x),&(Pt3.y),NULL);
GraphAPI::GGetPerpendicular(Pt0.x,Pt0.y,Pt1.x,Pt1.y,l2.sp.x,l2.sp.y,&(Pt4.x),&(Pt4.y),NULL);
Pt2.x = -(Pt1.y-Pt0.y)+Pt0.x;
Pt2.y = Pt1.x-Pt0.x+Pt0.y;
}
//pt点在垂直于角平分线，垂足为两线段交点的直线的异于l1起点的一侧
if (GraphAPI::GGetMultiply(Pt0,Pt2,pt)*GraphAPI::GGetMultiply(Pt0,Pt2,l1.sp)<0)
{
return 1;
}
//pt在另一侧的情况
else if (GraphAPI::GGetMultiply(l1.sp,Pt3,pt)*GraphAPI::GGetMultiply(l1.sp,Pt3,Pt0)<0||GraphAPI::GGetMultiply(l2.sp,Pt4,pt)*GraphAPI::GGetMultiply(l2.sp,Pt4,Pt0)<0)
{
return 2;
}
else if (GraphAPI::GIsPtInRegion(ptt,temp,3)==2)
{
PT_2D tem;
if (mode==1)
{
GraphAPI::GGetPerpendicular(Pt0.x,Pt0.y,Pt1.x,Pt1.y,pt.x,pt.y,&(tem.x),&(tem.y),NULL);
GraphAPI::GGetLineIntersectLine(l1.sp.x,l1.sp.y,l1.ep.x-l1.sp.x,l1.ep.y-l1.sp.y,pt.x,pt.y,tem.x-pt.x,tem.y-pt.y,&(ret1->x),&(ret1->y),t1);
GraphAPI::GGetLineIntersectLine(l2.sp.x,l2.sp.y,l2.ep.x-l2.sp.x,l2.ep.y-l2.sp.y,pt.x,pt.y,tem.x-pt.x,tem.y-pt.y,&(ret2->x),&(ret2->y),t2);
}
if(mode==0)
{
double da=l1.ep.x-l1.sp.x;
double db=l1.ep.y-l1.sp.y;
double dx=Pt1.x-Pt0.x;
double dy=Pt1.y-Pt0.y;
double a=(da*da+db*db)*(dx*dx+dy*dy)-(da*dy-db*dx)*(da*dy-db*dx);
double b=2*((da*da+db*db)*((Pt0.x-pt.x)*dx+(Pt0.y-pt.y)*dy)-(da*dy-db*dx)*(da*(Pt0.y-l1.sp.y)-db*(Pt0.x-l1.sp.x)));
double c=(da*da+db*db)*((Pt0.x-pt.x)*(Pt0.x-pt.x)+(Pt0.y-pt.y)*(Pt0.y-pt.y))-(da*(Pt0.y-l1.sp.y)-db*(Pt0.x-l1.sp.x))*(da*(Pt0.y-l1.sp.y)-db*(Pt0.x-l1.sp.x));
double x1,x2;
x1=(-b+sqrt(b*b-4*a*c))/(2*a);
x2=(-b-sqrt(b*b-4*a*c))/(2*a);
x1=x1>x2?x1:x2;
double xcenter = x1*dx+Pt0.x;
double ycenter = x1*dy+Pt0.y;
GraphAPI::GGetPerpendicular(l1.sp.x,l1.sp.y,l1.ep.x,l1.ep.y,xcenter,ycenter,&(ret1->x),&(ret1->y),t1);
GraphAPI::GGetPerpendicular(l2.sp.x,l2.sp.y,l2.ep.x,l2.ep.y,xcenter,ycenter,&(ret2->x),&(ret2->y),t2);
}
return 3;
}
else
{
PT_2D tem;
//mode是标志是圆弧还是折线倒角
if (mode==1)
{
GraphAPI::GGetPerpendicular(Pt0.x,Pt0.y,Pt1.x,Pt1.y,pt.x,pt.y,&(tem.x),&(tem.y),NULL);
GraphAPI::GGetLineIntersectLine(l1.sp.x,l1.sp.y,l1.ep.x-l1.sp.x,l1.ep.y-l1.sp.y,pt.x,pt.y,tem.x-pt.x,tem.y-pt.y,&(ret1->x),&(ret1->y),t1);
GraphAPI::GGetLineIntersectLine(l2.sp.x,l2.sp.y,l2.ep.x-l2.sp.x,l2.ep.y-l2.sp.y,pt.x,pt.y,tem.x-pt.x,tem.y-pt.y,&(ret2->x),&(ret2->y),t2);
}
if(mode==0)
{
GraphAPI::GGetPerpendicular(Pt0.x,Pt0.y,Pt1.x,Pt1.y,pt.x,pt.y,&(tem.x),&(tem.y),NULL);
pt=tem;
double da=l1.ep.x-l1.sp.x;
double db=l1.ep.y-l1.sp.y;
double dx=Pt1.x-Pt0.x;
double dy=Pt1.y-Pt0.y;
double a=(da*da+db*db)*(dx*dx+dy*dy)-(da*dy-db*dx)*(da*dy-db*dx);
double b=2*((da*da+db*db)*((Pt0.x-tem.x)*dx+(Pt0.y-tem.y)*dy)-(da*dy-db*dx)*(da*(Pt0.y-l1.sp.y)-db*(Pt0.x-l1.sp.x)));
double c=(da*da+db*db)*((Pt0.x-tem.x)*(Pt0.x-tem.x)+(Pt0.y-tem.y)*(Pt0.y-tem.y))-(da*(Pt0.y-l1.sp.y)-db*(Pt0.x-l1.sp.x))*(da*(Pt0.y-l1.sp.y)-db*(Pt0.x-l1.sp.x));
double x1,x2;
x1=(-b+sqrt(b*b-4*a*c))/(2*a);
x2=(-b-sqrt(b*b-4*a*c))/(2*a);
x1=x1>x2?x1:x2;
double xcenter = x1*dx+Pt0.x;
double ycenter = x1*dy+Pt0.y;
GraphAPI::GGetPerpendicular(l1.sp.x,l1.sp.y,l1.ep.x,l1.ep.y,xcenter,ycenter,&(ret1->x),&(ret1->y),t1);
GraphAPI::GGetPerpendicular(l2.sp.x,l2.sp.y,l2.ep.x,l2.ep.y,xcenter,ycenter,&(ret2->x),&(ret2->y),t2);
}
return 4;
}
}
void CChamferCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if(m_nStep==0 )//选择第一个地物，并获取待处理的线段
{
if( !CanGetSelObjs(flag,FALSE) )return;
m_pOldHandles[0] = m_pEditor->GetSelection()->GetLastSelectedObj();
if (!m_pOldHandles[0])
{
return;
}
m_pNewFtrs[0] =HandleToFtr(m_pOldHandles[0])->Clone();
if( !(m_pNewFtrs[0]) )return;
if( !(m_pNewFtrs[0]->GetGeometry())->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )return;
int PtNums;
if((PtNums=(m_pNewFtrs[0]->GetGeometry())->GetDataPointSum())<2 )return;
const CShapeLine *pSL = (m_pNewFtrs[0]->GetGeometry())->GetShape();
if( !pSL )return;
CArray<PT_3DEX,PT_3DEX> pts;
pSL->GetPts(pts);
PT_2D *Pnts=new PT_2D[PtNums];
for (int j=0;j<PtNums;j++)//获取点数组
{
COPY_2DPT(Pnts[j],pts[j]);
}
// delete []pts;
int idx;
PT_2D tem,tem1;
COPY_2DPT(tem,pt);
GraphAPI::GGetNearstDisPToPointSet2D(Pnts,PtNums,tem,tem1,&idx);
//判断取出首尾哪条线段来进行倒角处理
if (GraphAPI::GGetAllLen2D(Pnts,idx+1)+GraphAPI::GGet2DDisOf2P(Pnts[idx],tem1)<GraphAPI::GGetAllLen2D(&(Pnts[idx+1]),PtNums-1-idx)+GraphAPI::GGet2DDisOf2P(tem1,Pnts[idx+1]))
{
m_lineseg[0].sp=Pnts[1];
m_lineseg[0].ep=Pnts[0];
}
else
{
m_lineseg[0].sp=Pnts[PtNums-2];
m_lineseg[0].ep=Pnts[PtNums-1];
}
// m_pEditor->SetCurDrawingObj(DrawingInfo(m_pNewFtrs[0]->GetGeometry(),(m_pNewFtrs[0]->GetGeometry())->GetDataPointSum()+1));
if (Pnts)
{
delete []Pnts;
Pnts=NULL;
}
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
}
//选取第二条线段
else if (m_nStep==1)
{
if( !CanGetSelObjs(flag,FALSE) )return;
m_pOldHandles[1] = m_pEditor->GetSelection()->GetLastSelectedObj();
if( m_pOldHandles[1]==0 )
return;
m_pNewFtrs[1]=HandleToFtr(m_pOldHandles[1])->Clone();
if( !(m_pNewFtrs[1]) )return;
if( !(m_pNewFtrs[1]->GetGeometry())->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )return;
int PtNums;
if((m_pNewFtrs[1]->GetGeometry())->GetDataPointSum()<2 )return;
const CShapeLine *pSL = (m_pNewFtrs[1])->GetGeometry()->GetShape();
if( !pSL )return;
CArray<PT_3DEX,PT_3DEX> pts;
pSL->GetPts(pts);
PtNums = pts.GetSize();
PT_2D *Pnts=new PT_2D[PtNums];
for (int j=0;j<PtNums;j++)//获取点数组
{
COPY_2DPT(Pnts[j],pts[j]);
}
PT_2D tem;
COPY_2DPT(tem,pt);
//此时直接根据所点击点距断点的远近来判断
if (GraphAPI::GGet2DDisOf2P(Pnts[0],tem)<GraphAPI::GGet2DDisOf2P(tem,Pnts[PtNums-1]))
{
m_lineseg[1].sp=Pnts[1];
m_lineseg[1].ep=Pnts[0];
}
else
{
m_lineseg[1].sp=Pnts[PtNums-2];
m_lineseg[1].ep=Pnts[PtNums-1];
}
// m_pEditor->SetCurDrawingObj(DrawingInfo(m_pNewFtrs[1]->GetGeometry(),(m_pNewFtrs[1]->GetGeometry())->GetDataPointSum()+1));
m_pEditor->CloseSelector();
if (Pnts)
{
delete []Pnts;
Pnts=NULL;
}
m_nStep = 2;
GotoState(PROCSTATE_PROCESSING);
}
//进行倒角处理
else
{
if(!m_pNewFtrs[0]||!m_pNewFtrs[1])
return;
//层必须相同
CFtrLayer* pLay0 = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(HandleToFtr(m_pOldHandles[0]));
CFtrLayer* pLay1 = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(HandleToFtr(m_pOldHandles[1]));
if (pLay0!=pLay1&&strcmp(pLay0->GetName(),pLay1->GetName())!=0)
{
return;
}
CArray<PT_3DEX,PT_3DEX> pts0;
CArray<PT_3DEX,PT_3DEX> pts1;
(m_pNewFtrs[0]->GetGeometry())->GetShape(pts0);
(m_pNewFtrs[1]->GetGeometry())->GetShape(pts1);
//
PT_2D p1,p2;
double t1,t2;
//较复杂，根据第三下点击的方位决定如何进行倒角处理
if (m_nMode==modePolylineChamfer)
{
PT_2D pt2d,intersec;
COPY_2DPT(pt2d,pt);
//射线延长线有交点再进行进一步处理
if(GraphAPI::GGetRay1IntersectRay2(m_lineseg[0].sp.x,m_lineseg[0].sp.y,m_lineseg[0].ep.x,m_lineseg[0].ep.y,m_lineseg[1].sp.x,m_lineseg[1].sp.y,m_lineseg[1].ep.x,m_lineseg[1].ep.y,&(intersec.x),&(intersec.y)))
{
if( !CanGetSelObjs(flag) )return;
if( !(m_pNewFtrs[0]) )return;
if( !(m_pNewFtrs[0]->GetGeometry())->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )return;
if(((m_pNewFtrs[0]->GetGeometry())->GetDataPointSum())<2 )return;
if( !(m_pNewFtrs[1]) )return;
if( !(m_pNewFtrs[1]->GetGeometry())->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )return;
if(((m_pNewFtrs[1]->GetGeometry())->GetDataPointSum())<2 )return;
CUndoFtrs undo(m_pEditor,Name());
//K代表点所在区域
int K = GPtinRegion(m_lineseg[0],m_lineseg[1],pt2d,&p1,&p2,&t1,&t2,1);
if(K==4||K==3)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = pts0.GetAt(0);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
temp = pts0.GetAt(0);
//z=temp.z;
temp.pencode=penLine;
temp.x=p1.x;
temp.y=p1.y;
//temp.z=z;
pts0.SetAt(0,temp);
// (m_pNewFtrs[0]->GetGeometry())->SetDataPoint(0,temp);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = pts1.GetAt(0);
temp.pencode=penLine;
temp.x=p2.x;
temp.y=p2.y;
pts0.InsertAt(0,temp);
pts1.RemoveAt(0);
int ptnum=pts1.GetSize();
for (int j=0;j<ptnum;j++)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
temp = pts1.GetAt(ptnum-1);
temp.pencode=penLine;
temp.x=p2.x;
temp.y=p2.y;
pts0.InsertAt(0,temp);
pts1.RemoveAt(ptnum-1);
for (int j=ptnum-2;j>=0;j--)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
}
else
{
int ptnum1=pts0.GetSize();
temp = pts0.GetAt(ptnum1-1);
pts0.RemoveAt(ptnum1-1);
temp.pencode=penLine;
temp.x=p1.x;
temp.y=p1.y;
pts0.Add(temp);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = pts1.GetAt(0);
temp.pencode=penLine;
temp.x=p2.x;
temp.y=p2.y;
pts0.Add(temp);
pts1.RemoveAt(0);
int ptnum=pts1.GetSize();
for (int j=0;j<ptnum;j++)
{
pts0.Add(pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
temp = pts1.GetAt(ptnum-1);
temp.pencode=penLine;
temp.x=p2.x;
temp.y=p2.y;
pts0.Add(temp);
pts1.RemoveAt(ptnum-1);
for (int j=ptnum-2;j>=0;j--)
{
pts0.Add(pts1.GetAt(j));
}
}
}
(m_pNewFtrs[0]->GetGeometry())->CreateShape(pts0.GetData(),pts0.GetSize());
m_pNewFtrs[0]->SetID(OUID());
m_pEditor->AddObject(m_pNewFtrs[0],m_pEditor->GetFtrLayerIDOfFtr(m_pOldHandles[0]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_pOldHandles[0]),m_pNewFtrs[0]);
undo.arrNewHandles.Add(FtrToHandle(m_pNewFtrs[0]));
m_pEditor->DeleteObject(m_pOldHandles[0]);
m_pEditor->DeleteObject(m_pOldHandles[1]);
undo.arrOldHandles.Add(m_pOldHandles[0]);
undo.arrOldHandles.Add(m_pOldHandles[1]);
undo.Commit();
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_pEditor->RefreshView();
}
if (K==1)
{
m_pEditor->RefreshView();
PT_3DEX temp;
PT_3D temp1,temp2;
temp = pts0.GetAt(0);
double z;
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
int ptnum=pts1.GetSize();
temp = pts0.GetAt(0);
z=temp.z;
temp = pts1.GetAt(0);
z=(z+temp.z)/2;
temp.pencode=penLine;
temp.x=intersec.x;
temp.y=intersec.y;
temp.z=z;
pts0.InsertAt(0,temp);
for (int j=0;j<ptnum;j++)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
temp = pts0.GetAt(0);
z=temp.z;
temp = pts1.GetAt(ptnum-1);
z=(z+temp.z)/2;
temp.pencode=penLine;
temp.x=intersec.x;
temp.y=intersec.y;
temp.z=z;
pts0.InsertAt(0,temp);
for (int j=ptnum-1;j>=0;j--)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
}
else
{
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
int ptnum=pts1.GetSize();
temp = pts0.GetAt(pts0.GetSize()-1);
z=temp.z;
temp = pts1.GetAt(0);
z=(z+temp.z)/2;
temp.pencode=penLine;
temp.x=intersec.x;
temp.y=intersec.y;
temp.z=z;
pts0.Add(temp);
for (int j=0;j<ptnum;j++)
{
pts0.Add(pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
temp = pts0.GetAt(pts0.GetSize()-1);
z=temp.z;
temp = pts1.GetAt(ptnum-1);
z=(z+temp.z)/2;
temp.pencode=penLine;
temp.x=intersec.x;
temp.y=intersec.y;
temp.z=z;
pts0.Add(temp);
for (int j=ptnum-1;j>=0;j--)
{
pts0.Add(pts1.GetAt(j));
}
}
}
m_pNewFtrs[0]->SetID(OUID());
(m_pNewFtrs[0]->GetGeometry())->CreateShape(pts0.GetData(),pts0.GetSize());
m_pEditor->AddObject(m_pNewFtrs[0],m_pEditor->GetFtrLayerIDOfFtr(m_pOldHandles[0]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_pOldHandles[0]),m_pNewFtrs[0]);
undo.arrNewHandles.Add(FtrToHandle(m_pNewFtrs[0]));
m_pEditor->DeleteObject(m_pOldHandles[0]);
m_pEditor->DeleteObject(m_pOldHandles[1]);
undo.arrOldHandles.Add(m_pOldHandles[0]);
undo.arrOldHandles.Add(m_pOldHandles[1]);
undo.Commit();
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_pEditor->RefreshView();
}
if(K==2)
{
m_pEditor->RefreshView();
PT_3DEX temp;
PT_3D temp1,temp2;
temp = pts0.GetAt(0);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
pts0.RemoveAt(0);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
pts1.RemoveAt(0);
int ptnum=pts1.GetSize();
for (int j=0;j<ptnum;j++)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
pts1.RemoveAt(ptnum-1);
for (int j=ptnum-2;j>=0;j--)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
}
else
{
int ptnum1=pts0.GetSize();
pts0.RemoveAt(ptnum1-1);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
pts1.RemoveAt(0);
int ptnum=pts1.GetSize();
for (int j=0;j<ptnum;j++)
{
pts0.Add(pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
pts1.RemoveAt(ptnum-1);
for (int j=ptnum-2;j>=0;j--)
{
pts0.Add(pts1.GetAt(j));
}
}
}
(m_pNewFtrs[0]->GetGeometry())->CreateShape(pts0.GetData(),pts0.GetSize());
m_pNewFtrs[0]->SetID(OUID());
m_pEditor->AddObject(m_pNewFtrs[0],m_pEditor->GetFtrLayerIDOfFtr(m_pOldHandles[0]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_pOldHandles[0]),m_pNewFtrs[0]);
undo.arrNewHandles.Add(FtrToHandle(m_pNewFtrs[0]));
m_pEditor->DeleteObject(m_pOldHandles[0]);
m_pEditor->DeleteObject(m_pOldHandles[1]);
undo.arrOldHandles.Add(m_pOldHandles[0]);
undo.arrOldHandles.Add(m_pOldHandles[1]);
undo.Commit();
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_pEditor->RefreshView();
}
}
m_pNewFtrs[0]=NULL;
m_pNewFtrs[1]=NULL;
}
if(m_nMode==modeArcChamfer)
{
PT_2D pt2d,intersec;
COPY_2DPT(pt2d,pt);
if(GraphAPI::GGetRay1IntersectRay2(m_lineseg[0].sp.x,m_lineseg[0].sp.y,m_lineseg[0].ep.x,m_lineseg[0].ep.y,m_lineseg[1].sp.x,m_lineseg[1].sp.y,m_lineseg[1].ep.x,m_lineseg[1].ep.y,&(intersec.x),&(intersec.y)))
{
////////////////////////////////
if( !CanGetSelObjs(flag) )return;
if( !(m_pNewFtrs[0]) )return;
if( !(m_pNewFtrs[0]->GetGeometry())->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )return;
if(pts0.GetSize()<2 )return;
if( !(m_pNewFtrs[1]) )return;
if( !(m_pNewFtrs[1]->GetGeometry())->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )return;
if(pts1.GetSize()<2 )return;
///////////////////////////////////////////
int K=GPtinRegion(m_lineseg[0],m_lineseg[1],pt2d,&p1,&p2,&t1,&t2,0);
CUndoFtrs undo(m_pEditor,Name());
if(K==4||K==3)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = pts0.GetAt(0);
double z;
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
int addNum = 0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
temp = pts0.GetAt(0);
z=temp.z;
pts0.RemoveAt(0);
if(t1>0&&t2>0)
{
temp.pencode=penArc;
temp.x=p1.x;
temp.y=p1.y;
temp.z=z;
pts0.InsertAt(0,temp);
addNum++;
}
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = pts1.GetAt(0);
z=(z+temp.z)/2;
if(t1>0&&t2>0)
{
if (K==3)
{
temp.pencode=penArc;
temp.x=pt.x;
temp.y=pt.y;
temp.z=z;
pts0.InsertAt(0,temp);
addNum++;
}
else
{
temp.pencode=penArc;
temp.x=pt2d.x;
temp.y=pt2d.y;
temp.z=z;
pts0.InsertAt(0,temp);
addNum++;
}
temp = pts1.GetAt(0);
z=temp.z;
temp.pencode=penLine;
temp.x=p2.x;
temp.y=p2.y;
temp.z=z;
pts0.InsertAt(0,temp);
addNum++;
if (m_bLineserial)
{
CGeoCurve curve;
curve.CreateShape(pts0.GetData(),addNum);
CGeometry *pNewGeo = curve.Linearize();
if (pNewGeo)
{
pts0.RemoveAt(0,addNum);
CArray<PT_3DEX,PT_3DEX> newPts;
pNewGeo->GetShape(newPts);
for (int j=newPts.GetSize()-1;j>=0;j--)
{
pts0.InsertAt(0,newPts.GetAt(j));
}
delete pNewGeo;
}
}
}
pts1.RemoveAt(0);
int ptnum=pts1.GetSize();
for (int j=0;j<ptnum;j++)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
temp = pts1.GetAt(ptnum-1);
z=(z+temp.z)/2;
if(t1>0&&t2>0)
{
if (K==3)
{
temp.pencode=penArc;
temp.x=pt.x;
temp.y=pt.y;
temp.z=z;
pts0.InsertAt(0,temp);
addNum++;
}
else
{
temp.pencode=penArc;
temp.x=pt2d.x;
temp.y=pt2d.y;
temp.z=z;
pts0.InsertAt(0,temp);
addNum++;
}
temp = pts1.GetAt(ptnum-1);
z=temp.z;
temp.pencode=penLine;
temp.x=p2.x;
temp.y=p2.y;
temp.z=z;
pts0.InsertAt(0,temp);
addNum++;
if (m_bLineserial)
{
CGeoCurve curve;
curve.CreateShape(pts0.GetData(),addNum);
CGeometry *pNewGeo = curve.Linearize();
if (pNewGeo)
{
pts0.RemoveAt(0,addNum);
CArray<PT_3DEX,PT_3DEX> newPts;
pNewGeo->GetShape(newPts);
for (int j=newPts.GetSize()-1;j>=0;j--)
{
pts0.InsertAt(0,newPts.GetAt(j));
}
delete pNewGeo;
}
}
}
pts1.RemoveAt(ptnum-1);
for (int j=ptnum-2;j>=0;j--)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
}
else
{
int ptnum1=pts0.GetSize();
temp = pts0.GetAt(ptnum1-1);
z=temp.z;
pts0.RemoveAt(ptnum1-1);
if(t1>0&&t2>0)
{
temp.pencode=penLine;
temp.x=p1.x;
temp.y=p1.y;
temp.z=z;
pts0.Add(temp);
addNum++;
}
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = pts1.GetAt(0);
z=(z+temp.z)/2;
if(t1>0&&t2>0)
{
if (K==3)
{
temp.pencode=penArc;
temp.x=pt.x;
temp.y=pt.y;
temp.z=z;
pts0.Add(temp);
addNum++;
}
else
{
temp.pencode=penArc;
temp.x=pt2d.x;
temp.y=pt2d.y;
temp.z=z;
pts0.Add(temp);
addNum++;
}
temp = pts1.GetAt(0);
z=temp.z;
temp.pencode=penArc;
temp.x=p2.x;
temp.y=p2.y;
temp.z=z;
pts0.Add(temp);
addNum++;
if (m_bLineserial)
{
CGeoCurve curve;
curve.CreateShape(pts0.GetData()+pts0.GetSize()-addNum,addNum);
CGeometry *pNewGeo = curve.Linearize();
if (pNewGeo)
{
pts0.RemoveAt(pts0.GetSize()-addNum,addNum);
CArray<PT_3DEX,PT_3DEX> newPts;
pNewGeo->GetShape(newPts);
for (int j=0;j<newPts.GetSize();j++)
{
pts0.Add(newPts.GetAt(j));
}
delete pNewGeo;
}
}
}
pts1.RemoveAt(0);
int ptnum=pts1.GetSize();
for (int j=0;j<ptnum;j++)
{
pts0.Add(pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
temp = pts1.GetAt(ptnum-1);
z=(z+temp.z)/2;
if(t1>0&&t2>0)
{
if (K==3)
{
temp.pencode=penArc;
temp.x=pt.x;
temp.y=pt.y;
temp.z=z;
pts0.Add(temp);
addNum++;
}
else
{
temp.pencode=penArc;
temp.x=pt2d.x;
temp.y=pt2d.y;
temp.z=z;
pts0.Add(temp);
addNum++;
}
temp = pts1.GetAt(ptnum-1);
z=temp.z;
temp.pencode=penArc;
temp.x=p2.x;
temp.y=p2.y;
temp.z=z;
pts0.Add(temp);
addNum++;
if (m_bLineserial)
{
CGeoCurve curve;
curve.CreateShape(pts0.GetData()+pts0.GetSize()-addNum,addNum);
CGeometry *pNewGeo = curve.Linearize();
if (pNewGeo)
{
pts0.RemoveAt(pts0.GetSize()-addNum,addNum);
CArray<PT_3DEX,PT_3DEX> newPts;
pNewGeo->GetShape(newPts);
for (int j=0;j<newPts.GetSize();j++)
{
pts0.Add(newPts.GetAt(j));
}
delete pNewGeo;
}
}
}
pts1.RemoveAt(ptnum-1);
for (int j=ptnum-2;j>=0;j--)
{
pts0.Add(pts1.GetAt(j));
}
}
}
(m_pNewFtrs[0]->GetGeometry())->CreateShape(pts0.GetData(),pts0.GetSize());
m_pNewFtrs[0]->SetID(OUID());
m_pEditor->AddObject(m_pNewFtrs[0],m_pEditor->GetFtrLayerIDOfFtr(m_pOldHandles[0]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_pOldHandles[0]),m_pNewFtrs[0]);
undo.arrNewHandles.Add(FtrToHandle(m_pNewFtrs[0]));
m_pEditor->DeleteObject(m_pOldHandles[0]);
m_pEditor->DeleteObject(m_pOldHandles[1]);
undo.arrOldHandles.Add(m_pOldHandles[0]);
undo.arrOldHandles.Add(m_pOldHandles[1]);
undo.Commit();
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_pEditor->RefreshView();
}
if (K==1)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = pts0.GetAt(0);
double z;
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
int ptnum=pts1.GetSize();
temp = pts0.GetAt(0);
z=temp.z;
temp = pts1.GetAt(0);
z=(z+temp.z)/2;
temp.pencode=penLine;
temp.x=intersec.x;
temp.y=intersec.y;
temp.z=z;
pts0.InsertAt(0,temp);
for (int j=0;j<ptnum;j++)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
temp = pts0.GetAt(0);
z=temp.z;
temp = pts1.GetAt(ptnum-1);
z=(z+temp.z)/2;
temp.pencode=penLine;
temp.x=intersec.x;
temp.y=intersec.y;
temp.z=z;
pts0.InsertAt(0,temp);
for (int j=ptnum-1;j>=0;j--)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
}
else
{
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
int ptnum=pts1.GetSize();
temp = pts0.GetAt(pts0.GetSize()-1);
z=temp.z;
temp = pts1.GetAt(0);
z=(z+temp.z)/2;
temp.pencode=penLine;
temp.x=intersec.x;
temp.y=intersec.y;
temp.z=z;
pts0.Add(temp);
for (int j=0;j<ptnum;j++)
{
pts0.Add(pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
temp = pts0.GetAt(pts0.GetSize()-1);
z=temp.z;
temp = pts1.GetAt(ptnum-1);
z=(z+temp.z)/2;
temp.pencode=penLine;
temp.x=intersec.x;
temp.y=intersec.y;
temp.z=z;
pts0.Add(temp);
for (int j=ptnum-1;j>=0;j--)
{
pts0.Add(pts1.GetAt(j));
}
}
}
(m_pNewFtrs[0]->GetGeometry())->CreateShape(pts0.GetData(),pts0.GetSize());
m_pNewFtrs[0]->SetID(OUID());
m_pEditor->AddObject(m_pNewFtrs[0],m_pEditor->GetFtrLayerIDOfFtr(m_pOldHandles[0]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_pOldHandles[0]),m_pNewFtrs[0]);
undo.arrNewHandles.Add(FtrToHandle(m_pNewFtrs[0]));
m_pEditor->DeleteObject(m_pOldHandles[0]);
m_pEditor->DeleteObject(m_pOldHandles[1]);
undo.arrOldHandles.Add(m_pOldHandles[0]);
undo.arrOldHandles.Add(m_pOldHandles[1]);
undo.Commit();
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_pEditor->RefreshView();
}
if(K==2)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = pts0.GetAt(0);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
pts0.RemoveAt(0);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
pts1.RemoveAt(0);
int ptnum=pts1.GetSize();
for (int j=0;j<ptnum;j++)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
pts1.RemoveAt(ptnum-1);
for (int j=ptnum-2;j>=0;j--)
{
pts0.InsertAt(0,pts1.GetAt(j));
}
}
}
else
{
int ptnum1=pts0.GetSize();
pts0.RemoveAt(ptnum1-1);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = pts1.GetAt(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
pts1.RemoveAt(0);
int ptnum=pts1.GetSize();
for (int j=0;j<ptnum;j++)
{
pts0.Add(pts1.GetAt(j));
}
}
else
{
int ptnum=pts1.GetSize();
pts1.RemoveAt(ptnum-1);
for (int j=ptnum-2;j>=0;j--)
{
pts0.Add(pts1.GetAt(j));
}
}
}
(m_pNewFtrs[0]->GetGeometry())->CreateShape(pts0.GetData(),pts0.GetSize());
m_pNewFtrs[0]->SetID(OUID());
m_pEditor->AddObject(m_pNewFtrs[0],m_pEditor->GetFtrLayerIDOfFtr(m_pOldHandles[0]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_pOldHandles[0]),m_pNewFtrs[0]);
undo.arrNewHandles.Add(FtrToHandle(m_pNewFtrs[0]));
m_pEditor->DeleteObject(m_pOldHandles[0]);
m_pEditor->DeleteObject(m_pOldHandles[1]);
undo.arrOldHandles.Add(m_pOldHandles[0]);
undo.arrOldHandles.Add(m_pOldHandles[1]);
undo.Commit();
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_pEditor->RefreshView();
}
}
m_pNewFtrs[0]=NULL;
m_pNewFtrs[1]=NULL;
}
m_nStep=3;
Finish();
}
CEditCommand::PtClick(pt,flag);
}
void CChamferCommand::PtMove(PT_3D &pt)
{
if (!m_pEditor)
{
return;
}
if(m_nStep==2)
{
CFtrLayer* pLayer0 = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(HandleToFtr(m_pOldHandles[0]));
CFtrLayer* pLayer1 = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(HandleToFtr(m_pOldHandles[1]));
if (pLayer0!=pLayer1&&strcmp(pLayer1->GetName(),pLayer0->GetName())!=0)
{
return;
}
PT_3DEX temp;
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint(0);
double z;
PT_2D p1,p2;
double t1,t2;
if (m_nMode==modePolylineChamfer)
{
GrBuffer buf;
buf.BeginLineString(0,0);
PT_3D pt1,pt2,pt3;
PT_2D pt2d,intersec;
COPY_2DPT(pt2d,pt);
if(GraphAPI::GGetRay1IntersectRay2(m_lineseg[0].sp.x,m_lineseg[0].sp.y,m_lineseg[0].ep.x,m_lineseg[0].ep.y,m_lineseg[1].sp.x,m_lineseg[1].sp.y,m_lineseg[1].ep.x,m_lineseg[1].ep.y,&intersec.x,&intersec.y))
{
int K=GPtinRegion(m_lineseg[0],m_lineseg[1],pt2d,&p1,&p2,&t1,&t2,1);
if(K==4||K==3)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint(0);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint(0);
z=temp.z;
pt1.x=p1.x;
pt1.y=p1.y;
pt1.z=z;
buf.MoveTo(&pt1);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(0);
z=temp.z;
pt2.x=p2.x;
pt2.y=p2.y;
pt2.z=z;
buf.LineTo(&pt2);
}
else
{
int ptnum=(m_pNewFtrs[1]->GetGeometry())->GetDataPointSum();
temp = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(ptnum-1);
z=temp.z;
pt2.x=p2.x;
pt2.y=p2.y;
pt2.z=z;
buf.LineTo(&pt2);
}
}
else
{
int ptnum1=(m_pNewFtrs[0]->GetGeometry())->GetDataPointSum();
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint(ptnum1-1);
z=temp.z;
pt1.x=p1.x;
pt1.y=p1.y;
pt1.z=z;
buf.MoveTo(&pt1);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(0);
z=temp.z;
pt2.x=p2.x;
pt2.y=p2.y;
pt2.z=z;
buf.LineTo(&pt2);
}
else
{
int ptnum=(m_pNewFtrs[1]->GetGeometry())->GetDataPointSum();
temp = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(ptnum-1);
z=temp.z;
pt2.x=p2.x;
pt2.y=p2.y;
pt2.z=z;
buf.LineTo(&pt2);
}
}
if (t1>1)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint(0);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
pt3=temp1;
}
else
{
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint(m_pNewFtrs[0]->GetGeometry()->GetDataPointSum()-1);
pt3.x=m_lineseg[0].ep.x;
pt3.y=m_lineseg[0].ep.y;
pt3.z=temp.z;
}
buf.MoveTo(&pt3);
buf.LineTo(&pt1);
}
if(t2>1)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(1);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[1].ep.x;
temp2.y=m_lineseg[1].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
pt3=temp1;
}
else
{
temp = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(m_pNewFtrs[1]->GetGeometry()->GetDataPointSum()-1);
pt3.x=m_lineseg[1].ep.x;
pt3.y=m_lineseg[1].ep.y;
pt3.z=temp.z;
}
buf.MoveTo(&pt3);
buf.LineTo(&pt2);
}
}
if (K==1)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint(0);
double z;
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
buf.MoveTo(&temp1);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint(0);
z=temp.z;
temp = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(0);
z=(z+temp.z)/2;
pt1.x=intersec.x;
pt1.y=intersec.y;
pt1.z=z;
buf.LineTo(&pt1);
buf.LineTo(&tem1);
}
else
{
int ptnum=(m_pNewFtrs[1]->GetGeometry())->GetDataPointSum();
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint(0);
z=temp.z;
temp = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(ptnum-1);
z=(z+temp.z)/2;
pt1.x=intersec.x;
pt1.y=intersec.y;
pt1.z=z;
buf.LineTo(&pt1);
buf.LineTo(&temp);
}
// buf.MoveTo(&pt1);
// buf.LineTo(&temp1);
}
else
{
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint((m_pNewFtrs[0]->GetGeometry())->GetDataPointSum()-1);
buf.MoveTo(&temp);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
int ptnum=(m_pNewFtrs[1]->GetGeometry())->GetDataPointSum();
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(m_pNewFtrs[0]->GetGeometry()->GetDataPointSum()-1);
z=temp.z;
temp = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(0);
z=(z+temp.z)/2;
pt1.x=intersec.x;
pt1.y=intersec.y;
pt1.z=z;
buf.LineTo(&pt1);
buf.LineTo(&tem1);
}
else
{
int ptnum=(m_pNewFtrs[1]->GetGeometry())->GetDataPointSum();
temp = (m_pNewFtrs[0]->GetGeometry())->GetDataPoint(m_pNewFtrs[0]->GetGeometry()->GetDataPointSum()-1);
z=temp.z;
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(ptnum-1);
z=(z+temp.z)/2;
pt1.x=intersec.x;
pt1.y=intersec.y;
pt1.z=z;
buf.LineTo(&pt1);
buf.LineTo(&temp);
}
tem = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(m_pNewFtrs[1]->GetGeometry()->GetDataPointSum()-1);
COPY_3DPT(tem1,tem);
}
}
if(K==2)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
pt1.x=m_lineseg[1].sp.x;
pt1.y=m_lineseg[1].sp.y;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(1);
pt1.z=temp.z;
}
else
{
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(m_pNewFtrs[0]->GetGeometry()->GetDataPointSum()-2);
pt1.z=temp.z;
}
buf.MoveTo(&pt1);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
pt2.x=m_lineseg[0].sp.x;
pt2.y=m_lineseg[0].sp.y;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(1);
pt2.z=temp.z;
}
else
{
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(m_pNewFtrs[1]->GetGeometry()->GetDataPointSum()-2);
pt2.z=temp.z;
}
buf.LineTo(&pt2);
}
buf.End();
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
}
}
if(m_nMode==modeArcChamfer)
{
CShapeLine buf;
GrBuffer buf0;
GrBuffer buf1;
buf0.BeginLineString(0,0);
buf1.BeginLineString(0,0);
CLinearizer bufb;
bufb.SetShapeBuf(&buf);
PT_3D pt1,pt2,pt3;
PT_2D pt2d,intersec;
COPY_2DPT(pt2d,pt);
if(GraphAPI::GGetRay1IntersectRay2(m_lineseg[0].sp.x,m_lineseg[0].sp.y,m_lineseg[0].ep.x,m_lineseg[0].ep.y,m_lineseg[1].sp.x,m_lineseg[1].sp.y,m_lineseg[1].ep.x,m_lineseg[1].ep.y,&intersec.x,&intersec.y))
{
int K=GPtinRegion(m_lineseg[0],m_lineseg[1],pt2d,&p1,&p2,&t1,&t2,0);
if(K==4||K==3)
{
if(t1>0&&t2>0)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp =m_pNewFtrs[0]->GetGeometry()->GetDataPoint(0);
double z;
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(0);
z=temp.z;
pt1.x=p1.x;
pt1.y=p1.y;
pt1.z=z;
PT_3DEX tem;
PT_3D tem1,tem2;
tem = (m_pNewFtrs[1]->GetGeometry())->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if ( GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
z=(z+temp.z)/2;
if (K==3)
{
pt3.x=pt.x;
pt3.y=pt.y;
pt3.z=z;
}
else
{
pt3.x=pt2d.x;
pt3.y=pt2d.y;
pt3.z=z;
}
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
z=temp.z;
pt2.x=p2.x;
pt2.y=p2.y;
pt2.z=z;
bufb.Arc(&pt1,&pt3,&pt2);
}
else
{
int ptnum=(m_pNewFtrs[1]->GetGeometry())->GetDataPointSum();
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(ptnum-1);
z=(z+temp.z)/2;
if (K==3)
{
pt3.x=pt.x;
pt3.y=pt.y;
pt3.z=z;
}
else
{
pt3.x=pt2d.x;
pt3.y=pt2d.y;
pt3.z=z;
}
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(ptnum-1);
z=temp.z;
pt2.x=p2.x;
pt2.y=p2.y;
pt2.z=z;
bufb.Arc(&pt1,&pt3,&pt2);
}
}
else
{
int ptnum1=m_pNewFtrs[0]->GetGeometry()->GetDataPointSum();
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(ptnum1-1);
z=temp.z;
pt1.x=p1.x;
pt1.y=p1.y;
pt1.z=z;
PT_3DEX tem;
PT_3D tem1,tem2;
tem = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
z=(z+temp.z)/2;
if (K==3)
{
pt3.x=pt.x;
pt3.y=pt.y;
pt3.z=z;
}
else
{
pt3.x=pt2d.x;
pt3.y=pt2d.y;
pt3.z=z;
}
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
z=temp.z;
pt2.x=p2.x;
pt2.y=p2.y;
pt2.z=z;
bufb.Arc(&pt1,&pt3,&pt2);
}
else
{
int ptnum=(m_pNewFtrs[1]->GetGeometry())->GetDataPointSum();
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(ptnum-1);
z=(z+temp.z)/2;
if (K==3)
{
pt3.x=pt.x;
pt3.y=pt.y;
pt3.z=z;
}
else
{
pt3.x=pt2d.x;
pt3.y=pt2d.y;
pt3.z=z;
}
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(ptnum-1);
z=temp.z;
pt2.x=p2.x;
pt2.y=p2.y;
pt2.z=z;
bufb.Arc(&pt1,&pt3,&pt2);
}
}
}
else
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
pt1.x=m_lineseg[1].sp.x;
pt1.y=m_lineseg[1].sp.y;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(1);
pt1.z=temp.z;
}
else
{
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(m_pNewFtrs[0]->GetGeometry()->GetDataPointSum()-2);
pt1.z=temp.z;
}
buf0.MoveTo(&pt1);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
pt2.x=m_lineseg[0].sp.x;
pt2.y=m_lineseg[0].sp.y;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(1);
pt2.z=temp.z;
}
else
{
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(m_pNewFtrs[1]->GetGeometry()->GetDataPointSum()-2);
pt2.z=temp.z;
}
buf0.LineTo(&pt2);
}
if (t1>1)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
pt3=temp1;
}
else
{
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(m_pNewFtrs[0]->GetGeometry()->GetDataPointSum()-1);
pt3.x=m_lineseg[0].ep.x;
pt3.y=m_lineseg[0].ep.y;
pt3.z=temp.z;
}
buf0.MoveTo(&pt3);
buf0.LineTo(&pt1);
}
if(t2>1)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(1);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[1].ep.x;
temp2.y=m_lineseg[1].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
pt3=temp1;
}
else
{
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(m_pNewFtrs[1]->GetGeometry()->GetDataPointSum()-1);
pt3.x=m_lineseg[1].ep.x;
pt3.y=m_lineseg[1].ep.y;
pt3.z=temp.z;
}
buf0.MoveTo(&pt3);
buf0.LineTo(&pt2);
}
}
if (K==1)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(0);
double z;
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
buf0.MoveTo(&temp1);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(0);
z=temp.z;
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
z=(z+temp.z)/2;
pt1.x=intersec.x;
pt1.y=intersec.y;
pt1.z=z;
buf0.LineTo(&pt1);
buf0.LineTo(&tem1);
}
else
{
int ptnum=(m_pNewFtrs[1]->GetGeometry())->GetDataPointSum();
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(0);
z=temp.z;
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(ptnum-1);
z=(z+temp.z)/2;
pt1.x=intersec.x;
pt1.y=intersec.y;
pt1.z=z;
buf0.LineTo(&pt1);
buf0.LineTo(&temp);
}
// buf.MoveTo(&pt1);
// buf.LineTo(&temp1);
}
else
{
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(m_pNewFtrs[0]->GetGeometry()->GetDataPointSum()-1);
buf0.MoveTo(&temp);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
int ptnum=(m_pNewFtrs[1])->GetGeometry()->GetDataPointSum();
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(m_pNewFtrs[0]->GetGeometry()->GetDataPointSum()-1);
z=temp.z;
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
z=(z+temp.z)/2;
pt1.x=intersec.x;
pt1.y=intersec.y;
pt1.z=z;
buf0.LineTo(&pt1);
buf0.LineTo(&tem1);
}
else
{
int ptnum=(m_pNewFtrs[1]->GetGeometry())->GetDataPointSum();
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(m_pNewFtrs[0]->GetGeometry()->GetDataPointSum()-1);
z=temp.z;
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(ptnum-1);
z=(z+temp.z)/2;
pt1.x=intersec.x;
pt1.y=intersec.y;
pt1.z=z;
buf0.LineTo(&pt1);
buf0.LineTo(&temp);
}
tem = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(m_pNewFtrs[1]->GetGeometry()->GetDataPointSum()-1);
COPY_3DPT(tem1,tem);
}
}
if(K==2)
{
PT_3DEX temp;
PT_3D temp1,temp2;
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(temp1,temp);
temp2.x=m_lineseg[0].ep.x;
temp2.y=m_lineseg[0].ep.y;
temp2.z=0;
pt1.x=m_lineseg[1].sp.x;
pt1.y=m_lineseg[1].sp.y;
if(GraphAPI::GIsEqual2DPoint(&temp1,&temp2))
{
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(1);
pt1.z=temp.z;
}
else
{
temp = m_pNewFtrs[0]->GetGeometry()->GetDataPoint(m_pNewFtrs[0]->GetGeometry()->GetDataPointSum()-2);
pt1.z=temp.z;
}
buf0.MoveTo(&pt1);
PT_3DEX tem;
PT_3D tem1,tem2;
tem = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(0);
COPY_3DPT(tem1,tem);
tem2.x=m_lineseg[1].ep.x;
tem2.y=m_lineseg[1].ep.y;
tem2.z=0;
pt2.x=m_lineseg[0].sp.x;
pt2.y=m_lineseg[0].sp.y;
if (GraphAPI::GIsEqual2DPoint(&tem1,&tem2))
{
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(1);
pt2.z=temp.z;
}
else
{
temp = m_pNewFtrs[1]->GetGeometry()->GetDataPoint(m_pNewFtrs[1]->GetGeometry()->GetDataPointSum()-2);
pt2.z=temp.z;
}
buf0.LineTo(&pt2);
}
buf.ToGrBuffer(&buf1);
buf0.End();
buf1.End();
buf0.AddBuffer(&buf1);
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf0);
}
}
return;
}
}
void CChamferCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)(m_nMode);
tab.AddValue(PF_CHAMFERWAY,&CVariantEx(var));
var = (bool)m_bLineserial;
tab.AddValue(PF_LINESERIAL,&CVariantEx(var));
}
void CChamferCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("ChamferCommand",StrFromLocalResID(IDS_CMDNAME_CHAMFER));
param->BeginOptionParam(PF_CHAMFERWAY,StrFromResID(IDS_CMDPLANE_WAY));
param->AddOption(StrFromResID(IDS_CMDPLANE_POLYLINE),1,' ',m_nMode==modePolylineChamfer);
param->AddOption(StrFromResID(IDS_CMDPLANE_ARC),0,' ',m_nMode==modeArcChamfer);
param->EndOptionParam();
if (m_nMode==modeArcChamfer || bForLoad)
{
param->AddParam(PF_LINESERIAL,(bool)m_bLineserial,StrFromResID(IDS_CMDPLANE_LINESERIAL));
}
}
void CChamferCommand::Finish()
{
m_pNewFtrs[0] = NULL;
if(m_pNewFtrs[1])
{
delete m_pNewFtrs[1];
m_pNewFtrs[1] = NULL;
}
CEditCommand::Finish();
}
void CChamferCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_CHAMFERWAY,var) )
{
m_nMode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
if (!bInit)
{
Abort();
return;
}
}
if( tab.GetValue(0,PF_LINESERIAL,var) )
{
m_bLineserial = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
/////////////////////////////////////////////////////////////////////
// CIntZCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CIntZCommand,CEditCommand)
CIntZCommand::CIntZCommand()
{
m_nStep = -1;
m_bOnlyContour = TRUE;
m_lfLimitDZ = 0.01;
m_fUnitZ = 5.0;
strcat(m_strRegPath,"\\IntZ");
}
CIntZCommand::~CIntZCommand()
{
}
void CIntZCommand::Abort()
{
CEditCommand::Abort();
}
CString CIntZCommand::Name()
{
return StrFromResID(IDS_CMDNAME_INTZ);
}
void CIntZCommand::Start()
{
if( !m_pEditor )return;
m_bOnlyContour = TRUE;
m_lfLimitDZ = 0.01;
m_fUnitZ = 5.0;
CEditCommand::Start();
// m_pEditor->OpenSelector(SELMODE_NORMAL);
}
void CIntZCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_fUnitZ==0 )
{
// OutputTipString(StrFromResID(IDS_CMDTIP_INTZ_ERR));
return;
}
if( m_nStep==1 )
{
CGeometry *pObj;
// CGeometry *pObj1, *pObj2;
CSelection * pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE * handles = pSel->GetSelectedObjs(num);
CUndoFtrs undo(m_pEditor,Name());
GrBuffer buf;
for( int i = num-1; i>=0; i--)
{
pObj = HandleToFtr(handles[i])->GetGeometry();
//生成新的对象，这里需要指定新对象层码
if( !pObj || pObj->GetDataPointSum()<=0 )continue;
if( m_bOnlyContour && !CModifyZCommand::CheckObjForContour(pObj) )
continue;
pObj = pObj->Clone();
if( !pObj )continue;
CArray<PT_3DEX,PT_3DEX> arr;
pObj->GetShape(arr);
int num0 = arr.GetSize();
double v1, v2;
for( int j=0; j<num0; j++)
{
PT_3DEX &pt1 = arr.ElementAt(j);
v1 = fabs( pt1.z - m_fUnitZ*floor(pt1.z/m_fUnitZ) );
v2 = fabs( pt1.z - m_fUnitZ*ceil(pt1.z/m_fUnitZ) );
if( v1>v2 )
{
if( v2<m_lfLimitDZ )
pt1.z = m_fUnitZ*ceil(pt1.z/m_fUnitZ);
}
else
{
if( v1<m_lfLimitDZ )
pt1.z = m_fUnitZ*floor(pt1.z/m_fUnitZ);
}
}
pObj->CreateShape(arr.GetData(),arr.GetSize());
int nLayerID = m_pEditor->GetFtrLayerIDOfFtr(handles[i]);
CFeature * pFtr1 = HandleToFtr(handles[i])->Clone();
if(pFtr1&& pObj )pFtr1->SetGeometry(pObj);
pFtr1->SetID(OUID());
if( !m_pEditor->AddObject(pFtr1,nLayerID) )
{
delete pFtr1;
Abort();
return;
}
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(handles[i]),pFtr1);
undo.arrNewHandles.Add(FtrToHandle(pFtr1));
m_pEditor->DeleteObject(handles[i]);
undo.arrOldHandles.Add(handles[i]);
}
undo.Commit();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CEditCommand::PtClick(pt,flag);
}
void CIntZCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (bool)(m_bOnlyContour);
tab.AddValue(PF_MODIFYZONLYCONTOR,&CVariantEx(var));
var = (float)(m_fUnitZ);
tab.AddValue(PF_INTZSTEP,&CVariantEx(var));
var = (double)(m_lfLimitDZ);
tab.AddValue(PF_INTZMAXOFFSET,&CVariantEx(var));
}
void CIntZCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("IntZCommand",StrFromResID(IDS_CMDNAME_INTZ));
param->AddParam(PF_MODIFYZONLYCONTOR,bool(m_bOnlyContour),StrFromResID(IDS_CMDPLANE_ONLYCONTOUR));
param->AddParam(PF_INTZSTEP,float(m_fUnitZ),StrFromResID(IDS_CMDPLANE_INTZSTEP));
param->AddParam(PF_INTZMAXOFFSET,double(m_lfLimitDZ),StrFromResID(IDS_CMDPLANE_MAXOFFSET));
}
void CIntZCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_MODIFYZONLYCONTOR,var) )
{
m_bOnlyContour = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_INTZSTEP,var) )
{
m_fUnitZ = (float)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_INTZMAXOFFSET,var) )
{
m_lfLimitDZ = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
/////////////////////////////////////////////////////////////////////
// CConnectCodeChgCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CConnectCodeChgCommand,CEditCommand)
CConnectCodeChgCommand::CConnectCodeChgCommand()
{
m_nStep = -1;
m_nConnectCode= 2;
strcat(m_strRegPath,"\\ConnectCodeChange");
}
CConnectCodeChgCommand::~CConnectCodeChgCommand()
{
}
void CConnectCodeChgCommand::Abort()
{
CEditCommand::Abort();
}
CString CConnectCodeChgCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CHGCODE);
}
void CConnectCodeChgCommand::Start()
{
if( !m_pEditor )return;
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
m_nStep = 0;
// m_idsOld.RemoveAll();
// m_idsNew.RemoveAll();
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
PtClick(pt,0);
m_nExitCode = CMPEC_STARTOLD;
return;
}
CEditCommand::Start();
}
void CConnectCodeChgCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CGeometry *pObj;
// CGeometry *pObj1, *pObj2;
CSelection * pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE * handles = pSel->GetSelectedObjs(num);
CUndoModifyProperties undo(m_pEditor,Name());
GrBuffer buf;
PT_3DEX pt0,pt1;
for( int i = num-1; i>=0; i--)
{
pObj = HandleToFtr(handles[i])->GetGeometry();
//生成新的对象，这里需要指定新对象层码
if( !pObj || pObj->GetDataPointSum()<=0 )continue;
m_pEditor->DeleteObject(handles[i],FALSE);
undo.arrHandles.Add(handles[i]);
undo.oldVT.BeginAddValueItem();
HandleToFtr(handles[i])->WriteTo(undo.oldVT);
undo.oldVT.EndAddValueItem();
CArray<PT_3DEX,PT_3DEX> pts;
pObj->GetShape(pts);
int num0 = pts.GetSize();
for (int j=0;j<num0;j++)
{
pt0 = pts.GetAt(j);
pt0.pencode = m_nConnectCode;
pts.SetAt(j,pt0);
}
pObj->CreateShape(pts.GetData(),pts.GetSize());
//if(pFtr1&& pObj )pFtr1->SetGeometry(pObj);
// if( !m_pEditor->UpdateObject(handles[i]) )
// {
// Abort();
// return;
// }
m_pEditor->RestoreObject(handles[i]);
undo.newVT.BeginAddValueItem();
HandleToFtr(handles[i])->WriteTo(undo.newVT);
undo.newVT.EndAddValueItem();
// undo.arrNewHandles.Add(FtrToHandle(pFtr1));
}
undo.Commit();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CEditCommand::PtClick(pt,flag);
}
void CConnectCodeChgCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)(m_nConnectCode);
tab.AddValue(PF_CHANGECODE,&CVariantEx(var));
}
void CConnectCodeChgCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("ConnectCodeChg",StrFromLocalResID(IDS_CMDNAME_CHGCODE));
param->AddLineTypeParam(PF_CHANGECODE,m_nConnectCode,StrFromResID(IDS_CMDPLANE_LINETYPE));
}
void CConnectCodeChgCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_CHANGECODE,var) )
{
m_nConnectCode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
/////////////////////////////////////////////////////////////////////
// CCompressCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CCompressCommand,CEditCommand)
CCompressCommand::CCompressCommand()
{
m_lfLimit = 0.1;
m_lfAngLimit = 0;
m_nPart = modeWhole;
strcat(m_strRegPath,"\\Compress");
}
CCompressCommand::~CCompressCommand()
{
}
void CCompressCommand::Abort()
{
CEditCommand::Abort();
}
CString CCompressCommand::Name()
{
return StrFromResID(IDS_CMDNAME_COMPRESS);
}
void CCompressCommand::Start()
{
if( !m_pEditor )return;
m_nStep = 0;
m_nPart = modeWhole;
CCommand::Start();
if( m_nPart==modeWhole )
{
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
m_nExitCode = CMPEC_STARTOLD;
return;
}
m_pEditor->OpenSelector();
}
else
{
m_pEditor->CloseSelector();
}
//CEditCommand::Start();
}
CGeometry* CCompressCommand::CompressSimpleCore(CGeometry *pObj)
{
if(!pObj)
return NULL;
if(pObj->GetDataPointSum()<=2)
return NULL;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) || pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface)) || pObj->IsKindOf(RUNTIME_CLASS(CGeoParallel)) )
{
CArray<PT_3DEX,PT_3DEX> arr;
pObj->GetShape(arr);
int num = arr.GetSize();
if( num<=2 )return NULL;
//判断是否全为线串码
PT_3DEX expt;
for( int j=1; j<num; j++)
{
expt = arr.GetAt(j);
if( expt.pencode!=penLine && expt.pencode!=penStream && expt.pencode!=penSpline )
break;
}
if( j<num )
{
return NULL;
}
CGeometry *pNewObj = pObj->Clone();
CArray<PT_3DEX,PT_3DEX> pts;
//弦高压缩
PT_3D pt3d;
CStreamCompress2_PT_3D comp;
comp.BeginCompress(m_lfLimit);
PT_3D pt0 = arr[0];
for( j=0; j<num; j++)
{
COPY_3DPT(pt3d,arr[j]);
pt3d.x -= pt0.x;
pt3d.y -= pt0.y;
pt3d.z -= pt0.z;
comp.AddStreamPt(pt3d);
}
comp.EndCompress();
{
PT_3D *tpts;
int ti, tnpt;
comp.GetPts(tpts,tnpt);
for( ti=0; ti<tnpt; ti++)
{
COPY_3DPT(expt,tpts[ti]);
pts.Add(expt);
}
}
//角度压缩
double anglmt = m_lfAngLimit/180;
anglmt = anglmt-(int)anglmt;
if( anglmt>0 )
{
anglmt = anglmt*PI;
num = pts.GetSize();
PT_3DEX expt1,expt2;
CArray<int, int> flags;
double curAng;
flags.SetSize(num);
flags.SetAt(0,0);
flags.SetAt(num-1,0);
expt = pts.GetAt(0);
expt1 = pts.GetAt(1);
for( j=2; j<num; j++)
{
expt2 = pts.GetAt(j);
curAng = GraphAPI::GGetAngle(expt1.x,expt1.y,expt2.x,expt2.y)-GraphAPI::GGetAngle(expt1.x,expt1.y,expt.x,expt.y);
if( curAng<-PI )curAng += 2*PI;
else if( curAng>PI )curAng -= 2*PI;
if( curAng<0 )curAng = -curAng;
if( curAng<anglmt )
{
flags.SetAt(j-1,1);
}
else flags.SetAt(j-1,0);
expt = expt1; expt1 = expt2;
}
for( j=num-1; j>=0; j--)
{
if( flags[j] )
{
pts.RemoveAt(j);
}
}
}
//添加结果
if( pts.GetSize()>=2 )
{
num = pts.GetSize();
for( j=0; j<num; j++)
{
COPY_3DPT(pt3d,pts[j]);
pt3d.x += pt0.x;
pt3d.y += pt0.y;
pt3d.z += pt0.z;
COPY_3DPT(pts[j],pt3d);
}
if(pNewObj->CreateShape(pts.GetData(),pts.GetSize()))
return pNewObj;
}
else
delete pNewObj;
}
return NULL;
}
CGeometry* CCompressCommand::CompressSimple(CGeometry *pObj)
{
if( pObj && (pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve))||pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface))) )
{
CGeometry *pNew = CCompressCommand::CompressSimpleCore(pObj);
if(pNew && ((CGeoCurveBase*)pNew)->IsClosed())
{
CArray<PT_3DEX,PT_3DEX> arr;
pNew->GetShape(arr);
int num = arr.GetSize();
if( num<5 )return pNew;
PT_3DEX test[3];
test[0] = arr[num-2];
test[1] = arr[num-1];
test[2] = arr[1];
CGeoCurve test_obj;
test_obj.CreateShape(test,3);
CGeometry *pTest = CCompressCommand::CompressSimpleCore(&test_obj);
if(pTest)
{
int npt_test = pTest->GetDataPointSum();
delete pTest;
if( npt_test==2 )
{
arr.RemoveAt(num-1);
arr[0] = arr[num-2];
arr[0].pencode = penLine;
pNew->CreateShape(arr.GetData(),arr.GetSize());
}
return pNew;
}
}
else
{
return pNew;
}
}
return NULL;
}
CGeometry* CCompressCommand::Compress(CGeometry *pObj)
{
if(!pObj)
return NULL;
if(pObj->GetDataPointSum()<=2)
return NULL;
int nGeoClass = pObj->GetClassType();
if( nGeoClass==CLS_GEOCURVE || nGeoClass==CLS_GEOPARALLEL || nGeoClass==CLS_GEOSURFACE )
{
return CompressSimple(pObj);
}
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoDCurve)) || pObj->IsKindOf(RUNTIME_CLASS(CGeoMultiSurface)) )
{
CArray<PT_3DEX,PT_3DEX> arr, arr1, arr2;
pObj->GetShape(arr);
int npt = arr.GetSize();
arr1.Add(arr[0]);
for(int i=1; i<npt; i++)
{
if(arr[i].pencode==penMove || i==(npt-1))
{
if(i==(npt-1))
arr1.Add(arr[i]);
if(arr1.GetSize()>2)
{
CGeoCurve new_obj;
new_obj.CreateShape(arr1.GetData(),arr1.GetSize());
CGeometry *pNew = CompressSimple(&new_obj);
if(pNew)
{
arr1.RemoveAll();
pNew->GetShape(arr1);
if(arr1.GetSize()>0)arr1[0].pencode = penMove;
arr2.Append(arr1);
delete pNew;
}
else
{
arr2.Append(arr1);
}
}
arr1.RemoveAll();
arr1.Add(arr[i]);
}
else
{
arr1.Add(arr[i]);
}
}
if(arr2.GetSize()>2)
{
pObj = pObj->Clone();
pObj->CreateShape(arr2.GetData(),arr2.GetSize());
return pObj;
}
}
return NULL;
}
CGeometry *GetPartInPolygon(CGeometry *pObj, PT_3D *pts, int npt, int &start, int &end)
{
if (!pObj) return NULL;
CArray<PT_3DEX,PT_3DEX> arrPts;
pObj->GetShape(arrPts);
int nsum = arrPts.GetSize();
if( nsum<=2 )return NULL;
start = -1; end = -1;
PT_3DEX expt;
for( int i=0; i<nsum; i++)
{
expt = arrPts[i];
if( start==-1 )
{
if( GraphAPI::GIsPtInRegion(PT_3D(expt),pts,npt)==2 )
{
start = i;
}
}
else
{
if (GraphAPI::GIsPtInRegion(PT_3D(expt),pts,npt) != 2)
{
end = i;
break;
}
}
}
if( start<0 )return NULL;
if( start>0 )start--;
if( end<0 )end = nsum-1;
else if( end==(nsum-1) );
else end++;
if( (end-start)<=1)return NULL;
CGeometry *pPart = new CGeoCurve;
if( !pPart )return NULL;
CArray<PT_3DEX,PT_3DEX> arr;
for( i=start; i<end; i++)
{
arr.Add(arrPts[i]);
}
pPart->CreateShape(arr.GetData(),arr.GetSize());
return pPart;
}
void CCompressCommand::PtMove(PT_3D &pt)
{
if( m_nStep==1 && m_nPart==modePart )
{
//计算范围四边形
PT_4D pts0[2],pts[4];
pts0[0] = PT_4D(m_ptDragStart);
pts0[1] = PT_4D(pt);
m_pEditor->GetCoordWnd().m_pViewCS->GroundToClient(pts0,2);
pts[0].x = pts0[0].x; pts[0].y = pts0[0].y; pts[0].z = pts0[0].x; pts[0].yr = pts0[0].y;
pts[1].x = pts0[0].x; pts[1].y = pts0[1].y; pts[1].z = pts0[0].x; pts[1].yr = pts0[1].y;
pts[2].x = pts0[1].x; pts[2].y = pts0[1].y; pts[2].z = pts0[1].x; pts[2].yr = pts0[1].y;
pts[3].x = pts0[1].x; pts[3].y = pts0[0].y; pts[3].z = pts0[1].x; pts[3].yr = pts0[0].y;
m_pEditor->GetCoordWnd().m_pViewCS->ClientToGround(pts,4);
PT_3D pt3ds[4];
for( int i=0; i<4; i++)pt3ds[i] = pts[i].To3D();
GrBuffer buf;
buf.BeginLineString(0,0);
buf.MoveTo(pt3ds);
buf.LineTo(pt3ds+1);
buf.LineTo(pt3ds+2);
buf.LineTo(pt3ds+3);
buf.LineTo(pt3ds);
buf.End();
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
}
CEditCommand::PtMove(pt);
}
void CCompressCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nPart==modeWhole )
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CGeometry *pObj;
CUndoFtrs undo(m_pEditor,Name());
int num;
const FTR_HANDLE *handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
GProgressStart(num);
for( int i=num-1; i>=0; i--)
{
GProgressStep();
pObj = HandleToFtr(handles[i])->GetGeometry();
if( pObj && (pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve))||pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface))) )
{
CGeometry *pNewObj = Compress(pObj);
//添加结果
if( pNewObj!=NULL )
{
//m_idsOld.Add(idsOld[i]);
CFeature *pFtr = HandleToFtr(handles[i])->Clone();
if (pFtr)
{
pFtr->SetID(OUID());
pFtr->SetGeometry(pNewObj);
m_pEditor->AddObject(pFtr,m_pEditor->GetFtrLayerIDOfFtr(handles[i]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(handles[i]),pFtr);
undo.AddNewFeature(FtrToHandle(pFtr));
m_pEditor->DeleteObject(handles[i]);
undo.AddOldFeature(handles[i]);
}
//m_idsNew.Add(m_pDoc->AddObject(pNewObj,idsOld[i].layhdl));
}
}
}
GProgressEnd();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
undo.Commit();
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
}
else
{
if( m_nStep==0 )
{
m_ptDragStart = pt;
m_nStep = 1;
}
else if( m_nStep==1 )
{
//计算范围四边形
PT_4D pts0[2],pts[4];
pts0[0] = PT_4D(m_ptDragStart);
pts0[1] = PT_4D(pt);
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(pts0,2);
pts[0].x = pts0[0].x; pts[0].y = pts0[0].y; pts[0].z = pts0[0].x; pts[0].yr = pts0[0].y;
pts[1].x = pts0[0].x; pts[1].y = pts0[1].y; pts[1].z = pts0[0].x; pts[1].yr = pts0[1].y;
pts[2].x = pts0[1].x; pts[2].y = pts0[1].y; pts[2].z = pts0[1].x; pts[2].yr = pts0[1].y;
pts[3].x = pts0[1].x; pts[3].y = pts0[0].y; pts[3].z = pts0[1].x; pts[3].yr = pts0[0].y;
//m_pEditor->GetCoordWnd().m_pSearchCS->ClientToGround(pts,4);
PT_3D pt3ds[4],pt3ds1[4];
for( int i=0; i<4; i++)
{
pt3ds[i] = pts[i].To3D();
m_pEditor->GetCoordWnd().m_pSearchCS->ClientToGround(&pts[i],&pt3ds1[i]);
}
Envelope e;
e.CreateFromPts(pt3ds,4);
//获得范围内的地物
m_pEditor->GetDataQuery()->FindObjectInRect(e,m_pEditor->GetCoordWnd().m_pSearchCS);
int num;
const CPFeature * ftr = m_pEditor->GetDataQuery()->GetFoundHandles(num);
if( num>0 )
{
CGeometry *pObj;
CUndoFtrs undo(m_pEditor,Name());
GProgressStart(num);
for(int i=0; i<num; i++)
{
GProgressStep();
pObj = ftr[i]->GetGeometry();
//依次遍历处理
if( pObj && (pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve))||pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface))) )
{
int j, start, end;
PT_3DEX expt;
//取出地物上落在范围内的顶点部分
CGeometry *pPart1 = NULL, *pPart2 = NULL;
pPart1 = GetPartInPolygon(pObj,pt3ds1,4,start,end);
if( pPart1 )
{
//压缩这部分数据
pPart2 = Compress(pPart1);
if( pPart2 )
{
//生成新地物
CGeometry *pNewObj = pObj->Clone();
CArray<PT_3DEX,PT_3DEX> pts, oldpts, part2pts;
pObj->GetShape(oldpts);
pPart2->GetShape(part2pts);
//1、取压缩段之前的顶点
for( j=0; j<start; j++)
{
pts.Add(oldpts[j]);
}
//2、取压缩段的顶点
for( j=0; j<part2pts.GetSize(); j++)
{
pts.Add(part2pts[j]);
}
//3、取压缩段之后的顶点
for( j=end+1; j<pObj->GetDataPointSum(); j++)
{
pts.Add(oldpts[j]);
}
pNewObj->CreateShape(pts.GetData(),pts.GetSize());
//添加地物
CFeature *pFtr = ftr[i]->Clone();
if(pFtr)
{
pFtr->SetID(OUID());
pFtr->SetGeometry(pNewObj);
m_pEditor->AddObject(pFtr,m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(ftr[i])));
GETXDS(m_pEditor)->CopyXAttributes(ftr[i],pFtr);
undo.arrNewHandles.Add(FtrToHandle(pFtr));
m_pEditor->DeleteObject(FtrToHandle(ftr[i]));
undo.arrOldHandles.Add(FtrToHandle(ftr[i]));
}
}
}
if( pPart1 )delete pPart1;
if( pPart2 )delete pPart2;
}
}
undo.Commit();
GProgressEnd();
}
m_pEditor->RefreshView();
m_pEditor->UpdateDrag(ud_SetVariantDrag,0);
Finish();
m_nStep = 2;
}
}
CEditCommand::PtClick(pt,flag);
}
void CCompressCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (double)(m_lfLimit);
tab.AddValue(PF_COMTOL,&CVariantEx(var));
var = (double)(m_lfAngLimit);
tab.AddValue(PF_COMMINANGLE,&CVariantEx(var));
var = (short)(m_nPart);
tab.AddValue(PF_COMWAY,&CVariantEx(var));
}
void CCompressCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("CompressCommand",StrFromLocalResID(IDS_CMDNAME_COMPRESS));
param->AddParam(PF_COMTOL,double(m_lfLimit),StrFromResID(IDS_CMDPLANE_TOLER));
param->AddParam(PF_COMMINANGLE,double(m_lfAngLimit),StrFromResID(IDS_CMDPLANE_MINANGLE),StrFromResID(IDS_CMDTIP_MINANGLE));
param->BeginOptionParam(PF_COMWAY,StrFromResID(IDS_CMDPLANE_WAY));
param->AddOption(StrFromResID(IDS_CMDPLANE_WHOLE),modeWhole,' ',m_nPart==modeWhole);
param->AddOption(StrFromResID(IDS_CMDPLANE_PART),modePart,' ',m_nPart==modePart);
param->EndOptionParam();
}
void CCompressCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_COMTOL,var) )
{
m_lfLimit = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_COMMINANGLE,var) )
{
m_lfAngLimit = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_COMWAY,var) )
{
m_nPart = (short)(_variant_t)*var;
SetSettingsModifyFlag();
}
if (m_nPart==modePart)
{
m_pEditor->CloseSelector();
}
else
m_pEditor->OpenSelector();
CEditCommand::SetParams(tab,bInit);
}
/////////////////////////////////////////////////////////////////////
// CCompressRedundantCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CCompressRedundantCommand,CCompressCommand)
CCompressRedundantCommand::CCompressRedundantCommand()
{
m_lfLimit = 0.00001;
m_lfAngLimit = 0;
m_lfAngLimit = 0.0;
m_nPart = modeWhole;
}
CCompressRedundantCommand::~CCompressRedundantCommand()
{
}
CString CCompressRedundantCommand::Name()
{
return StrFromResID(IDS_CMDNAME_COMPRESS_REDUNDANT);
}
void CCompressRedundantCommand::Start()
{
if( !m_pEditor )return;
m_nStep = 0;
m_lfLimit = 0.00001;
m_lfAngLimit = 0.0;
m_nPart = modeWhole;
CCommand::Start();
m_nPart = modeWhole;
m_lfLimit = 0.00001;
m_lfAngLimit = 0.0;
if( m_nPart==modeWhole )
{
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
m_nExitCode = CMPEC_STARTOLD;
return;
}
m_pEditor->OpenSelector();
}
else
{
m_pEditor->CloseSelector();
}
}
CGeometry* CCompressRedundantCommand::CompressSimple(CGeometry *pObj)
{
if( pObj && (pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve))||pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface))) )
{
CGeometry *pNew = CCompressCommand::CompressSimpleCore(pObj);
if(pNew && ((CGeoCurveBase*)pNew)->IsClosed())
{
CArray<PT_3DEX,PT_3DEX> arr;
pNew->GetShape(arr);
int num = arr.GetSize();
if( num<5 )return pNew;
PT_3DEX test[3];
test[0] = arr[num-2];
test[1] = arr[num-1];
test[2] = arr[1];
CGeoCurve test_obj;
test_obj.CreateShape(test,3);
CGeometry *pTest = CCompressCommand::CompressSimpleCore(&test_obj);
if(pTest)
{
int npt_test = pTest->GetDataPointSum();
delete pTest;
if( npt_test==2 )
{
arr.RemoveAt(num-1);
arr[0] = arr[num-2];
arr[0].pencode = penLine;
pNew->CreateShape(arr.GetData(),arr.GetSize());
return pNew;
}
else
{
return pNew;
}
}
}
else
{
return pNew;
}
}
return NULL;
}
void CCompressRedundantCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
}
void CCompressRedundantCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID(AccelStr(),Name());
}
void CCompressRedundantCommand::SetParams(CValueTable& tab,BOOL bInit)
{
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CCloseCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CCloseCommand,CEditCommand)
CCloseCommand::CCloseCommand()
{
}
CCloseCommand::~CCloseCommand()
{
}
CString CCloseCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CLOSE);
}
void CCloseCommand::Start()
{
if( !m_pEditor )return;
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
m_nStep = 0;
// m_idsOld.RemoveAll();
// m_idsNew.RemoveAll();
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
//PtClick(pt,0);
m_nExitCode = CMPEC_STARTOLD;
return;
}
m_bClose = FALSE;
CEditCommand::Start();
}
void CCloseCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CGeometry *pObj;
CSelection* pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE* handles = pSel->GetSelectedObjs(num);
CUndoFtrs undo(m_pEditor,Name());
//UndoModifyProperties
for( int i=num-1; i>=0; i--)
{
pObj = HandleToFtr(handles[i])->GetGeometry();
if( !pObj )continue;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) )
{
if( pObj->GetDataPointSum()<=2 )continue;
if(!((CGeoCurve*)pObj)->IsClosed())
{
m_bClose = TRUE;
break;
}
m_bClose = FALSE;
}
}
/* if (!m_bClose)*/
{
for( i=num-1; i>=0; i--)
{
pObj = HandleToFtr(handles[i])->GetGeometry();
if( !pObj )continue;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) )
{
if( pObj->GetDataPointSum()<=2 ||
(((CGeoCurveBase*)pObj)->IsClosed()&&m_bClose)||
(!((CGeoCurveBase*)pObj)->IsClosed()&&!m_bClose))
{
continue;
}
CFeature *pFtr = HandleToFtr(handles[i])->Clone();
if (pFtr)
{
pFtr->SetID(OUID());
((CGeoCurveBase*)pFtr->GetGeometry())->EnableClose(m_bClose);
m_pEditor->AddObject(pFtr,m_pEditor->GetFtrLayerIDOfFtr(handles[i]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(handles[i]),pFtr);
undo.arrNewHandles.Add(FtrToHandle(pFtr));
undo.arrOldHandles.Add(handles[i]);
m_pEditor->DeleteObject(handles[i]);
}
}
}
}
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
undo.Commit();
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CCommand::PtClick(pt, flag);
}
void CCloseCommand::Finish()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CEditCommand::Finish();
}
//////////////////////////////////////////////////////////////////////
// CCloseCommandWithTole Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CCloseCommandWithTole,CEditCommand)
CCloseCommandWithTole::CCloseCommandWithTole()
{
m_lfTorlerance = 0;
strcat(m_strRegPath,"\\CloseWithTole");
}
CCloseCommandWithTole::~CCloseCommandWithTole()
{
}
CString CCloseCommandWithTole::Name()
{
return StrFromResID(IDS_CMDNAME_CLOSEWITHTOLE);
}
void CCloseCommandWithTole::Start()
{
if( !m_pEditor )return;
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
m_nStep = 0;
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
m_nExitCode = CMPEC_STARTOLD;
return;
}
// m_bClose = FALSE;
CEditCommand::Start();
}
void CCloseCommandWithTole::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CGeometry *pObj;
double lim = 0;
if( m_lfTorlerance>=1e-4 )lim = m_lfTorlerance*m_lfTorlerance;
CSelection* pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE* handles = pSel->GetSelectedObjs(num);
CUndoModifyProperties undo(m_pEditor,Name());
for( int i=num-1; i>=0; i--)
{
pObj = HandleToFtr(handles[i])->GetGeometry();
if( pObj && pObj->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) && !((CGeoCurveBase*)pObj)->IsClosed())
{
const CShapeLine *pShape = pObj->GetShape();
if (!pShape) continue;
CArray<PT_3DEX,PT_3DEX> pts;
pShape->GetPts(pts);
int num = pts.GetSize();
if( num<=2 )continue;
//判断是否全为线串码
PT_3DEX expt1, expt2;
expt1 = pts[0];
expt2 = pts[num-1];
double dis = (expt1.x-expt2.x)*(expt1.x-expt2.x)+(expt1.y-expt2.y)*(expt1.y-expt2.y)+(expt1.z-expt2.z)*(expt1.z-expt2.z);
if( dis>=lim )continue;
m_pEditor->DeleteObject(handles[i],FALSE);
undo.arrHandles.Add(handles[i]);
undo.oldVT.BeginAddValueItem();
HandleToFtr(handles[i])->WriteTo(undo.oldVT);
undo.newVT.EndAddValueItem();
//添加结果
((CGeoCurveBase*)pObj)->EnableClose(TRUE);
//m_pEditor->UpdateObject(handles[i]);
m_pEditor->RestoreObject(handles[i]);
undo.newVT.BeginAddValueItem();
HandleToFtr(handles[i])->WriteTo(undo.newVT);
undo.newVT.EndAddValueItem();
}
}
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged(TRUE);
undo.Commit();
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CCommand::PtClick(pt, flag);
}
void CCloseCommandWithTole::Finish()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CEditCommand::Finish();
}
void CCloseCommandWithTole::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)(m_lfTorlerance);
tab.AddValue(PF_CLOSETOL,&CVariantEx(var));
}
void CCloseCommandWithTole::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("CloseCommandWithTole",StrFromLocalResID(IDS_CMDNAME_CLOSEWITHTOLE));
param->AddParam(PF_CLOSETOL,double(m_lfTorlerance),StrFromResID(IDS_CMDPLANE_CLOSETOLER));
}
void CCloseCommandWithTole::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_CLOSETOL,var) )
{
m_lfTorlerance = (double )(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CInterpolatePointZCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CInterpolatePointZCommand,CEditCommand)
CInterpolatePointZCommand::CInterpolatePointZCommand()
{
m_nStep = -1;
strcat(m_strRegPath,"\\InterpolatePointZ");
}
CInterpolatePointZCommand::~CInterpolatePointZCommand()
{
}
void CInterpolatePointZCommand::Abort()
{
CEditCommand::Abort();
}
CString CInterpolatePointZCommand::Name()
{
return StrFromResID(IDS_CMDNAME_INTERPOLATEPOINTZ);
}
void CInterpolatePointZCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
GOutPut(StrFromResID(IDS_CMDTIP_SELFIRSTCONTOUR));
m_pEditor->OpenSelector(SELMODE_SINGLE);
}
void CInterpolatePointZCommand::PtMove(PT_3D &pt)
{
CEditCommand::PtMove(pt);
}
void CInterpolatePointZCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if( m_nStep==0 )
{
int nsel;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(nsel);
if( nsel!=1 )
return;
CGeometry *pObj = HandleToFtr(handles[0])->GetGeometry();
//不是等高线
if( !pObj || !pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) || !CModifyZCommand::CheckObjForContour(pObj) )
{
GOutPut(StrFromResID(IDS_CMDTIP_NOTCONTOUR));
return;
}
m_objHandles[0] = handles[0];
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
GOutPut(StrFromResID(IDS_CMDTIP_SELSEDCONTOUR));
}
else if( m_nStep==1 )
{
int nsel;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(nsel);
if( nsel!=1 )
return;
if (m_objHandles[0]==handles[0])
{
return;
}
CGeometry *pObj = HandleToFtr(handles[0])->GetGeometry();
//不是等高线
if( !pObj || !pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) || !CModifyZCommand::CheckObjForContour(pObj) )
{
GOutPut(StrFromResID(IDS_CMDTIP_NOTCONTOUR));
return;
}
m_objHandles[1] = handles[0];
m_pEditor->CloseSelector();
m_nStep = 2;
GotoState(PROCSTATE_PROCESSING);
GOutPut(StrFromResID(IDS_CMDTIP_PLACEPT));
}
else if(m_nStep == 2)
{
// 根据点到两条等高线的距离的比例生成高程点
CArray<PT_3DEX,PT_3DEX> pts1, pts2;
const CShapeLine *pShape1 = HandleToFtr(m_objHandles[0])->GetGeometry()->GetShape();
pShape1->GetPts(pts1);
const CShapeLine *pShape2 = HandleToFtr(m_objHandles[1])->GetGeometry()->GetShape();
pShape2->GetPts(pts2);
double z, dis1, dis2;
PT_3DEX p(pt,penMove), ret;
dis1 = GraphAPI::GGetNearstDisPToPointSet2D(pts1.GetData(),pts1.GetSize(),p,ret,NULL);
dis2 = GraphAPI::GGetNearstDisPToPointSet2D(pts2.GetData(),pts2.GetSize(),p,ret,NULL);
if (dis1 <= 0)
{
z = pts1[0].z;
}
else if (dis2 <= 0)
{
z = pts2[0].z;
}
else
{
// 内插高程
z = pts1[0].z + dis1/(dis1+dis2)*(pts2[0].z-pts1[0].z);
}
ret.x = pt.x;
ret.y = pt.y;
ret.z = z;
CString strLayerName = m_strLayerCode;
if (strLayerName.IsEmpty())
{
strLayerName = StrFromResID(IDS_DEFLAYER_NAMEP);
}
CFtrLayer *pFtrLayer = GETDS(m_pEditor)->GetFtrLayer(strLayerName);
if (pFtrLayer == NULL)
{
Abort();
return;
}
CFeature *pNewFtr = pFtrLayer->CreateDefaultFeature(GETDS(m_pEditor)->GetScale(),CLS_GEOPOINT);
if (!pNewFtr)
{
Abort();
return;
}
if (!pNewFtr->GetGeometry()->CreateShape(&PT_3DEX(ret,penLine),1))
{
Abort();
delete pNewFtr;
return;
}
m_pEditor->AddObject(pNewFtr,pFtrLayer->GetID());
CUndoFtrs undo(m_pEditor,Name());
undo.AddNewFeature(FtrToHandle(pNewFtr));
undo.Commit();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_nStep = 4;
Finish();
}
CCommand::PtClick(pt, flag);
}
void CInterpolatePointZCommand::Finish()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CEditCommand::Finish();
}
void CInterpolatePointZCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (_bstr_t)(m_strLayerCode);
tab.AddValue(PF_CONTOURCODE,&CVariantEx(var));
}
void CInterpolatePointZCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("IntersectPointZ",StrFromLocalResID(IDS_CMDNAME_INTERPOLATEPOINTZ));
param->AddLayerNameParam(PF_CONTOURCODE,LPCTSTR(m_strLayerCode),StrFromResID(IDS_CMDPLANE_POINTZLAYER),NULL,LAYERPARAMITEM_POINT);
}
void CInterpolatePointZCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_CONTOURCODE,var) )
{
m_strLayerCode = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CInterpolatePointZCommand_NoSelect Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CInterpolatePointZCommand_NoSelect,CEditCommand)
CInterpolatePointZCommand_NoSelect::CInterpolatePointZCommand_NoSelect()
{
m_nStep = -1;
}
CInterpolatePointZCommand_NoSelect::~CInterpolatePointZCommand_NoSelect()
{
}
void CInterpolatePointZCommand_NoSelect::Abort()
{
CEditCommand::Abort();
}
CString CInterpolatePointZCommand_NoSelect::Name()
{
return StrFromResID(ID_CMDNAME_INTERPOLATEPOINTZ_NOSELECT);
}
void CInterpolatePointZCommand_NoSelect::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
}
void CInterpolatePointZCommand_NoSelect::PtMove(PT_3D &pt)
{
CEditCommand::PtMove(pt);
}
BOOL CInterpolatePointZCommand_NoSelect::Do(PT_3D pt)
{
CFtrLayer *pFtrLayer0 = GETDS(m_pEditor)->GetFtrLayer(m_strLayerPt);
CFtrLayerArray arrContourLayers;
GETDS(m_pEditor)->GetFtrLayersByNameOrCode(m_strLayerContour,arrContourLayers);
if (pFtrLayer0==NULL || m_strLayerContour.IsEmpty() )
{
GOutPut(StrFromResID(IDS_PARAM_ERROR));
Abort();
return FALSE;
}
PT_3DEX expt;
PT_3D pt3d[8];
Envelope e;
CArray<FTR_HANDLE,FTR_HANDLE> arrIds1, arrIds2;
expt = PT_3DEX(pt,penLine);
CDataSourceEx *pDS = m_pEditor->GetDataSource();
pDS->SaveAllQueryFlags(TRUE,FALSE);
for(int i=0; i<arrContourLayers.GetSize(); i++)
{
((CFtrLayer*)arrContourLayers[i])->SetAllowQuery(TRUE);
}
double r;
int nObj = m_pEditor->GetDataQuery()->FindNearestObjectByObjNum(expt,10,NULL,FALSE,&r,NULL);
pDS->RestoreAllQueryFlags();
if( nObj<2 )
{
GOutPut(StrFromResID(ID_ERR_NOTFIND_NEARCONTOURS));
return FALSE;
}
double dx,dy;
const CPFeature *ftr = m_pEditor->GetDataQuery()->GetFoundHandles(nObj);
nObj = (nObj<=10?nObj:10);
dx = r; dy = r;
pt3d[0].x = expt.x-dx; pt3d[0].y = expt.y-dy; pt3d[0].z = expt.z;
pt3d[1].x = expt.x+dx; pt3d[1].y = expt.y+dy; pt3d[1].z = expt.z;
pt3d[2].x = expt.x-dx; pt3d[2].y = expt.y+dy; pt3d[2].z = expt.z;
pt3d[3].x = expt.x+dx; pt3d[3].y = expt.y-dy; pt3d[3].z = expt.z;
pt3d[4].x = expt.x-dx; pt3d[4].y = expt.y; pt3d[4].z = expt.z;
pt3d[5].x = expt.x+dx; pt3d[5].y = expt.y; pt3d[5].z = expt.z;
pt3d[6].x = expt.x; pt3d[6].y = expt.y+dy; pt3d[6].z = expt.z;
pt3d[7].x = expt.x; pt3d[7].y = expt.y-dy; pt3d[7].z = expt.z;
//找到八个方向(四条线段)下获得地物的数目最多的一个方向
int nfind1 = 0;
for( int n=0; n<4; n++)
{
arrIds2.RemoveAll();
int nfind2;
{
CFeature *pFtr0 = NULL;
CShapeLine::ShapeLineUnit *shapeUnit = NULL;
Envelope evlp,evlp2;
PT_3D pt0, pt1;
PT_3D pts3d[2];
pt0 = pts3d[0] = pt3d[n*2], pt1 = pts3d[1] = pt3d[n*2+1];
evlp.CreateFromPts(pts3d,2,sizeof(PT_3D));
for(int i=0;i<nObj;i++)
{
pFtr0 = ftr[i];
if( !pFtr0 )continue;
const CShapeLine *shape = pFtr0->GetGeometry()->GetShape();
if( !evlp.bIntersect(&shape->GetEnvelope()) )continue;
shapeUnit = shape->HeadUnit();
while( shapeUnit )
{
if (evlp.bIntersect(&shapeUnit->evlp))
{
PT_3DEX *pts = shapeUnit->pts;
for( int k=0; k<shapeUnit->nuse-1; k++,pts++)
{
COPY_3DPT(pts3d[0],pts[0]);
COPY_3DPT(pts3d[1],pts[1]);
evlp2.CreateFromPts(pts3d,2,sizeof(PT_3D));
if( !evlp.bIntersect(&evlp2) )continue;
if( (fabs(pt0.x-pts[0].x)<1e-4&&fabs(pt0.y-pts[0].y)<1e-4)||
(fabs(pt1.x-pts[0].x)<1e-4&&fabs(pt1.y-pts[0].y)<1e-4)||
(fabs(pt0.x-pts[1].x)<1e-4&&fabs(pt0.y-pts[1].y)<1e-4)||
(fabs(pt1.x-pts[1].x)<1e-4&&fabs(pt1.y-pts[1].y)<1e-4) )
continue;
if( GraphAPI::GGetLineIntersectLineSeg(pt0.x,pt0.y,pt1.x,pt1.y,
pts[0].x,pts[0].y,pts[1].x,pts[1].y,NULL,NULL,NULL) )break;
}
if (k < shapeUnit->nuse-1)
{
arrIds2.Add(FtrToHandle(pFtr0));
break;
}
}
shapeUnit = shapeUnit->next;
}
}
}
nfind2 = arrIds2.GetSize();
if( nfind2<2 )continue;
if( n==0 )
{
nfind1 = nfind2;
arrIds1.Copy(arrIds2);
}
else if( nfind1<nfind2 )
{
nfind1 = nfind2;
pt3d[0] = pt3d[n*2]; pt3d[1] = pt3d[n*2+1];
arrIds1.Copy(arrIds2);
}
}
Envelope evlp;
evlp.CreateFromPts(pt3d,2);
CArray<double,double> arrPos, arrZ;
PT_3D ret;
double t;
for( i=0; i<nfind1; i++)
{
CGeometry *po = HandleToFtr(arrIds1[i])->GetGeometry();
if( !po )continue;
const CShapeLine *pShape = ((CGeoCurve*)po)->GetShape();
if (!pShape) continue;
if (evlp.bIntersect(&pShape->GetEnvelope()))
{
CArray<PT_3DEX,PT_3DEX> arrpts;
pShape->GetPts(arrpts);
PT_3DEX *pts = arrpts.GetData();
for( int j=0; j<arrpts.GetSize()-1; j++,pts++)
{
if( CGrTrim::Intersect(pt3d,pt3d+1,&pts[0],&pts[1],&ret,&t) )
{
int nsz = arrPos.GetSize();
for( int k=0; k<nsz; k++)
{
if( t<arrPos[k] )break;
}
if( k>=nsz )
{
arrPos.Add(t);
arrZ.Add(pts[1].z);
}
else
{
arrPos.InsertAt(k,t);
arrZ.InsertAt(k,pts[1].z);
}
}
}
}
}
int nsz = arrPos.GetSize();
for( i=0; i<nsz; i++)
{
if( arrPos[i]>0.5 )break;
}
//等高线之间
if( i>0 && i<nsz && fabs(arrZ[i-1]-arrZ[i])>1e-4 )
{
expt.z = arrZ[i-1] + (arrZ[i]-arrZ[i-1]) * (0.5-arrPos[i-1])/(arrPos[i]-arrPos[i-1]);
}
//山谷或者山顶
else
{
if( 0 && i>=2 && fabs(arrZ[i-1]-arrZ[i])>1e-4 )
{
expt.z = arrZ[i] + (arrZ[i-1]-arrZ[i]) * (0.5-arrPos[i])/(arrPos[i-1]-arrPos[i]);
}
else if( 0 && i>=0 && i<nsz-1 && fabs(arrZ[i+1]-arrZ[i])>1e-4 )
{
expt.z = arrZ[i] + (arrZ[i+1]-arrZ[i]) * (0.5-arrPos[i])/(arrPos[i+1]-arrPos[i]);
}
else
{
GOutPut(StrFromResID(ID_ERR_FAILED_INVALID_RESULT));
return FALSE;
}
}
CFeature *pNewFtr = pFtrLayer0->CreateDefaultFeature(GETDS(m_pEditor)->GetScale(),CLS_GEOPOINT);
if (!pNewFtr)
{
Abort();
return FALSE;
}
pNewFtr->GetGeometry()->CreateShape(&expt,1);
m_pEditor->AddObject(pNewFtr,pFtrLayer0->GetID());
CUndoFtrs undo(m_pEditor,Name());
undo.AddNewFeature(FtrToHandle(pNewFtr));
undo.Commit();
m_nStep = 4;
Finish();
return TRUE;
}
extern void KickoffSameGeoPts(CArray<MYPT_3D,MYPT_3D>& arr);
BOOL CInterpolatePointZCommand_NoSelect::Do_TIN(PT_3D pt)
{
CFtrLayer *pFtrLayer0 = GETDS(m_pEditor)->GetFtrLayer(m_strLayerPt);
if (pFtrLayer0==NULL )
{
GOutPut(StrFromResID(IDS_PARAM_ERROR));
Abort();
return FALSE;
}
PT_3DEX expt;
CArray<FTR_HANDLE,FTR_HANDLE> arrIds1, arrIds2;
expt = PT_3DEX(pt,penLine);
CDataSourceEx *pDS = m_pEditor->GetDataSource();
double r;
int nObj = m_pEditor->GetDataQuery()->FindNearestObjectByObjNum(expt,20,NULL,FALSE,&r,NULL);
if( nObj<2 )
{
GOutPut(StrFromResID(ID_ERR_NOTFIND_NEARCONTOURS));
return FALSE;
}
const CPFeature *ppFtr = m_pEditor->GetDataQuery()->GetFoundHandles(nObj);
CPtrArray arrObjs;
CPtrArray arrAllObjs;
PT_3D polyPts[5];
polyPts[0].x = pt.x-r; polyPts[0].y = pt.y-r;
polyPts[1].x = pt.x+r; polyPts[1].y = pt.y-r;
polyPts[2].x = pt.x+r; polyPts[2].y = pt.y+r;
polyPts[3].x = pt.x-r; polyPts[3].y = pt.y+r;
polyPts[4] = polyPts[0];
int nPt = 5;
CGrTrim trim;
trim.InitTrimPolygon(polyPts,nPt,r*0.5);
Envelope e = CreateEnvelopeFromPts(polyPts,5);
//过滤对象
for(int i=0; i<nObj; i++)
{
CFeature *pFtr = ppFtr[i];
if (!pFtr) continue;
CGeometry *pObj = pFtr->GetGeometry();
if( !pObj )continue;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoText)) )
{
continue;
}
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoMultiPoint)) )
{
continue;
}
CPtrArray arrObjs;
CBatExportMapsCommand::TrimObj(pObj, &arrObjs, e, polyPts, nPt, &trim, FALSE, TRUE);
arrAllObjs.Append(arrObjs);
}
int k = 0, npt;
nObj = arrAllObjs.GetSize();
CArray<MYPT_3D,MYPT_3D> arrAll, arrCur;
MYPT_3D geopt;
MYPT_3D tri[3];
for( int j=0; j<nObj; j++)
{
CGeometry *pGeo = (CGeometry*)arrAllObjs[j];
if( !pGeo )continue;
k++;
if( pGeo->IsKindOf(RUNTIME_CLASS(CGeoPoint)) )
{
expt = pGeo->GetDataPoint(0);
geopt.x = expt.x; geopt.y = expt.y; geopt.z = expt.z; geopt.type = 0;
geopt.id = k;
arrAll.Add(geopt);
}
else if( pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )
{
const CShapeLine *pShape = pGeo->GetShape();
if (!pShape) continue;
CArray<PT_3DEX,PT_3DEX> pts;
pShape->GetKeyPts(pts);
npt = pts.GetSize();
arrCur.RemoveAll();
for( int n=0; n<npt; n++)
{
expt = pts[n];
geopt.x = expt.x; geopt.y = expt.y; geopt.z = expt.z;
geopt.type = 1;
geopt.id = k;
arrCur.Add(geopt);
}
KickoffSameGeoPts(arrCur);
if( arrCur.GetSize()>0 )arrAll.Append(arrCur);
}
else if( pGeo->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )
{
const CShapeLine *pShape = pGeo->GetShape();
if (!pShape) continue;
CArray<PT_3DEX,PT_3DEX> pts;
pShape->GetKeyPts(pts);
npt = pts.GetSize();
arrCur.RemoveAll();
for( int n=0; n<npt; n++)
{
expt = pts[n];
if (expt.pencode == penMove && n != 0)
{
k++;
continue;
}
geopt.x = expt.x; geopt.y = expt.y; geopt.z = expt.z;
geopt.type = 1;
geopt.id = k;
arrCur.Add(geopt);
}
KickoffSameGeoPts(arrCur);
if( arrCur.GetSize()>0 )arrAll.Append(arrCur);
}
delete pGeo;
}
if( arrAll.GetSize()>0 )
{
CMYTinObj tin;
tin.Clear();
MyTriangle::createTIN(arrAll.GetData(),arrAll.GetSize(),&tin.tins,&tin.nTIN,&tin.pts,&tin.npt);
tin.RefreshTriangleBounds();
MYPT_3D tri[3];
CUndoFtrs undo(m_pEditor,Name());
int index = tin.FindTriangle(pt);
if(index>=0)
{
tin.GetTriangle(index,tri);
tin.GetZFromTriangle(tri,pt.x,pt.y,pt.z);
CFeature *pNewFtr = pFtrLayer0->CreateDefaultFeature(GETDS(m_pEditor)->GetScale(),CLS_GEOPOINT);
if (!pNewFtr)
{
Abort();
return FALSE;
}
if (!pNewFtr->GetGeometry()->CreateShape(&PT_3DEX(pt,penLine),1))
{
Abort();
delete pNewFtr;
return FALSE;
}
m_pEditor->AddObject(pNewFtr,pFtrLayer0->GetID());
undo.AddNewFeature(FtrToHandle(pNewFtr));
}
undo.Commit();
}
m_nStep = 4;
Finish();
return TRUE;
}
void CInterpolatePointZCommand_NoSelect::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if(m_strLayerContour.IsEmpty())
Do_TIN(pt);
else
Do(pt);
CCommand::PtClick(pt, flag);
}
void CInterpolatePointZCommand_NoSelect::Finish()
{
CEditCommand::Finish();
}
void CInterpolatePointZCommand_NoSelect::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (_bstr_t)(LPCTSTR)(m_strLayerPt);
tab.AddValue("PointLayer",&CVariantEx(var));
var = (_bstr_t)(LPCTSTR)(m_strLayerContour);
tab.AddValue("ContourLayer",&CVariantEx(var));
}
void CInterpolatePointZCommand_NoSelect::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID(AccelStr(),Name());
param->AddLayerNameParam("PointLayer",LPCTSTR(m_strLayerPt),StrFromResID(IDS_CMDPLANE_POINTZLAYER),NULL,LAYERPARAMITEM_POINT);
param->AddLayerNameParamEx("ContourLayer",LPCTSTR(m_strLayerContour),StrFromResID(IDS_CMDPLANE_CONTOURLAYER),NULL,LAYERPARAMITEM_LINE);
}
void CInterpolatePointZCommand_NoSelect::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"PointLayer",var) )
{
m_strLayerPt = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"ContourLayer",var) )
{
m_strLayerContour = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CDivideCurveCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CDivideCurveCommand,CEditCommand)
CDivideCurveCommand::CDivideCurveCommand()
{
m_nMode = 0;
m_nDivideNum = 10;
m_fDivideDis = 10;
m_nStep = -1;
strcat(m_strRegPath,"\\DivideCurve");
}
CDivideCurveCommand::~CDivideCurveCommand()
{
}
void CDivideCurveCommand::Abort()
{
CEditCommand::Abort();
}
CString CDivideCurveCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DIVIDECURVE);
}
void CDivideCurveCommand::Start()
{
if( !m_pEditor )return;
m_nMode = 0;
m_nDivideNum = 10;
m_fDivideDis = 10;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->OpenSelector(SELMODE_SINGLE);
}
void CDivideCurveCommand::PtMove(PT_3D &pt)
{
CEditCommand::PtMove(pt);
}
void CDivideCurveCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if( m_nStep==0 )
{
int nsel;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(nsel);
if( nsel!=1 )
return;
CGeometry *pObj = HandleToFtr(handles[0])->GetGeometry();
if (!pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) && !pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
{
return;
}
m_objHandles = handles[0];
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
CString tip;
if (m_nMode == 0)
{
tip = StrFromResID(IDS_CMDTIP_DIVIDE_NUM);
}
else
{
tip = StrFromResID(IDS_CMDTIP_DIVIDE_DIS);
}
GOutPut(tip);
}
if(m_nStep == 1)
{
CGeometry *pGeo = HandleToFtr(m_objHandles)->GetGeometry();
CArray<PT_3DEX,PT_3DEX> pts, ret;
const CShapeLine *pShape = pGeo->GetShape();
pShape->GetPts(pts);
float len = pShape->GetLength();
float dCycle = 0;
if (m_nMode == 0)
{
dCycle = len/m_nDivideNum;
}
else if (m_nMode == 1)
{
dCycle = m_fDivideDis;
}
GraphAPI::GGetCycleLine(pts.GetData(),pts.GetSize(),dCycle,dCycle,ret,0);
int retsize = ret.GetSize();
if (m_nMode == 0 && retsize > m_nDivideNum-1)
{
ret.RemoveAt(retsize-1);
}
CString strLayerName = m_strLayerCode;
if (strLayerName.IsEmpty())
{
strLayerName = StrFromResID(IDS_DEFLAYER_NAMEP);
}
CFtrLayer *pFtrLayer = GETDS(m_pEditor)->GetFtrLayer(strLayerName);
if (pFtrLayer == NULL)
{
Abort();
return;
}
CFeature *pFtr0 = pFtrLayer->CreateDefaultFeature(GETDS(m_pEditor)->GetScale(),CLS_GEOPOINT);
if (!pFtr0)
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
for (int i=0; i<ret.GetSize(); i++)
{
CFeature *pNewFtr = pFtr0->Clone();
if (!pNewFtr)
{
Abort();
return;
}
PT_3DEX retPt = ret[i];
retPt.pencode = penLine;
if (!pNewFtr->GetGeometry()->CreateShape(&retPt,1))
{
delete pNewFtr;
continue;
}
m_pEditor->AddObject(pNewFtr,pFtrLayer->GetID());
undo.AddNewFeature(FtrToHandle(pNewFtr));
}
undo.Commit();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_nStep = 4;
Finish();
}
CCommand::PtClick(pt, flag);
}
void CDivideCurveCommand::Finish()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CEditCommand::Finish();
}
void CDivideCurveCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (_bstr_t)(m_strLayerCode);
tab.AddValue(PF_CONTOURCODE,&CVariantEx(var));
var = (long)(m_nMode);
tab.AddValue(PF_DIVIDETYPE,&CVariantEx(var));
var = (long)(m_nDivideNum);
tab.AddValue(PF_DIVIDENUM,&CVariantEx(var));
var = (float)(m_fDivideDis);
tab.AddValue(PF_DIVIDEDIS,&CVariantEx(var));
}
void CDivideCurveCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("DivideCurve",StrFromLocalResID(IDS_CMDNAME_DIVIDECURVE));
param->BeginOptionParam(PF_DIVIDETYPE,StrFromResID(IDS_CMDPLANE_DIVIDEMODE));
param->AddOption(StrFromResID(IDS_CMDPLANE_DIVIDE_NUM),0,' ',m_nMode==0);
param->AddOption(StrFromResID(IDS_CMDPLANE_DIVIDE_DIS),1,' ',m_nMode==1);
param->EndOptionParam();
if (m_nMode == 0 || bForLoad)
{
param->AddParam(PF_DIVIDENUM,(int)m_nDivideNum,StrFromResID(IDS_CMDTIP_DIVIDE_NUM));
}
if (m_nMode == 1 || bForLoad)
{
param->AddParam(PF_DIVIDEDIS,(float)m_fDivideDis,StrFromResID(IDS_CMDTIP_DIVIDE_DIS));
}
param->AddLayerNameParam(PF_CONTOURCODE,LPCTSTR(m_strLayerCode),StrFromResID(IDS_CMDPLANE_DIVIDEPOINTCODE));
}
void CDivideCurveCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_CONTOURCODE,var) )
{
m_strLayerCode = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_DIVIDETYPE,var) )
{
m_nMode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
if(!bInit)
Abort();
}
if( tab.GetValue(0,PF_DIVIDENUM,var) )
{
m_nDivideNum = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_DIVIDEDIS,var) )
{
m_fDivideDis = (float)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CIntersectCurveCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CIntersectCurveCommand,CEditCommand)
CIntersectCurveCommand::CIntersectCurveCommand()
{
m_bIntersectptBreak = TRUE;
m_nStep = -1;
strcat(m_strRegPath,"\\IntersectCurve");
}
CIntersectCurveCommand::~CIntersectCurveCommand()
{
}
void CIntersectCurveCommand::Abort()
{
CEditCommand::Abort();
}
CString CIntersectCurveCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CURVEINTERSECT);
}
void CIntersectCurveCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
GOutPut(StrFromResID(IDS_CMDTIP_SELFIRSTCURVE));
m_pEditor->OpenSelector(SELMODE_SINGLE);
}
void CIntersectCurveCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if( m_nStep==0 )
{
int nsel;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(nsel);
if( nsel!=1 )
return;
CGeometry *pObj = HandleToFtr(handles[0])->GetGeometry();
if (!pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) && !pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
{
return;
}
m_objHandles[0] = handles[0];
m_arrPts[0] = pt;
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
GOutPut(StrFromResID(IDS_CMDTIP_SELSECONDCURVE));
}
else if( m_nStep==1 )
{
int nsel;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(nsel);
if( nsel!=1 )
return;
if (m_objHandles[0]==handles[0])
{
return;
}
CGeometry *pObj = HandleToFtr(handles[0])->GetGeometry();
if (!pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) && !pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
{
return;
}
m_objHandles[1] = handles[0];
m_arrPts[1] = pt;
m_pEditor->CloseSelector();
m_nStep = 2;
GotoState(PROCSTATE_PROCESSING);
GOutPut(StrFromResID(IDS_CMDTIP_CLICKOK));
}
else if(m_nStep == 2)
{
CFeature *pFtr1 = HandleToFtr(m_objHandles[0]);
CFeature *pFtr2 = HandleToFtr(m_objHandles[1]);
CArray<PT_3DEX,PT_3DEX> pts1, pts2;
const CShapeLine *pShape1 = pFtr1->GetGeometry()->GetShape();
pShape1->GetPts(pts1);
int size1 = pts1.GetSize();
const CShapeLine *pShape2 = pFtr2->GetGeometry()->GetShape();
pShape2->GetPts(pts2);
int size2 = pts2.GetSize();
int iIndex1 = -1, iIndex2 = -1;
PT_3DEX p1(m_arrPts[0],penMove),p2(m_arrPts[1],penMove), ret;
GraphAPI::GGetNearstDisPToPointSet2D(pts1.GetData(),pts1.GetSize(),p1,ret,&iIndex1);
GraphAPI::GGetNearstDisPToPointSet2D(pts2.GetData(),pts2.GetSize(),p2,ret,&iIndex2);
if (iIndex1 < 0 || iIndex2 < 0)
{
Abort();
return;
}
PT_3D line1[2], line2[2], ptIntersect;
line1[0] = pts1[iIndex1];
line1[1] = pts1[iIndex1+1];
line2[0] = pts2[iIndex2];
line2[1] = pts2[iIndex2+1];
BOOL bOrder1 = TRUE, bOrder2 = TRUE;
if (GraphAPI::GGetRay1IntersectRay2(line1[0].x,line1[0].y,line1[1].x,line1[1].y,line2[0].x,line2[0].y,line2[1].x,line2[1].y,&ptIntersect.x,&ptIntersect.y));
else if (GraphAPI::GGetRay1IntersectRay2(line1[1].x,line1[1].y,line1[0].x,line1[0].y,line2[1].x,line2[1].y,line2[0].x,line2[0].y,&ptIntersect.x,&ptIntersect.y))
{
bOrder1 = bOrder2 = FALSE;
}
else if (GraphAPI::GGetRay1IntersectRay2(line1[0].x,line1[0].y,line1[1].x,line1[1].y,line2[1].x,line2[1].y,line2[0].x,line2[0].y,&ptIntersect.x,&ptIntersect.y))
{
bOrder2 = FALSE;
}
else if (GraphAPI::GGetRay1IntersectRay2(line1[1].x,line1[1].y,line1[0].x,line1[0].y,line2[0].x,line2[0].y,line2[1].x,line2[1].y,&ptIntersect.x,&ptIntersect.y))
{
bOrder1 = FALSE;
}
else
{
Abort();
return;
}
int i = 0;
if (m_bIntersectptBreak)
{
CUndoModifyProperties undo(m_pEditor,Name());
CArray<PT_3DEX,PT_3DEX> pts1New, pts2New;
if (bOrder1)
{
for (i=0; i<=iIndex1; i++)
{
pts1New.Add(pts1[i]);
}
PT_3DEX addPt1(ptIntersect.x,ptIntersect.y,pts1[iIndex1+1].z,pts1[size1-1].pencode);
pts1New.Add(addPt1);
}
else
{
PT_3DEX addPt1(ptIntersect.x,ptIntersect.y,pts1[0].z,pts1[0].pencode);
pts1New.Add(addPt1);
for (i=iIndex1+1; i<size1; i++)
{
pts1New.Add(pts1[i]);
}
}
if (bOrder2)
{
for (i=0; i<=iIndex2; i++)
{
pts2New.Add(pts2[i]);
}
PT_3DEX addPt2(ptIntersect.x,ptIntersect.y,pts2[iIndex2+1].z,pts2[size2-1].pencode);
pts2New.Add(addPt2);
}
else
{
PT_3DEX addPt2(ptIntersect.x,ptIntersect.y,pts2[0].z,pts2[0].pencode);
pts2New.Add(addPt2);
for (i=iIndex2+1; i<size2; i++)
{
pts2New.Add(pts2[i]);
}
}
/*if (bOrderIntersect)
{
for (int i=0; i<=iIndex1; i++)
{
pts1New.Add(pts1[i]);
}
PT_3DEX addPt1(ptIntersect.x,ptIntersect.y,pts1[iIndex1+1].z,pts1[size1-1].pencode);
pts1New.Add(addPt1);
for (i=0; i<=iIndex2; i++)
{
pts2New.Add(pts2[i]);
}
PT_3DEX addPt2(ptIntersect.x,ptIntersect.y,pts2[iIndex2+1].z,pts2[size2-1].pencode);
pts2New.Add(addPt2);
}
else
{
PT_3DEX addPt1(ptIntersect.x,ptIntersect.y,pts1[0].z,pts1[0].pencode);
pts1New.Add(addPt1);
for (int i=iIndex1+1; i<size1; i++)
{
pts1New.Add(pts1[i]);
}
PT_3DEX addPt2(ptIntersect.x,ptIntersect.y,pts2[0].z,pts2[0].pencode);
pts2New.Add(addPt2);
for (i=iIndex2+1; i<size2; i++)
{
pts2New.Add(pts2[i]);
}
}*/
undo.arrHandles.Add(m_objHandles[0]);
CValueTable oldTab;
oldTab.BeginAddValueItem();
pFtr1->WriteTo(oldTab);
oldTab.EndAddValueItem();
undo.oldVT.AddItemFromTab(oldTab);
m_pEditor->DeleteObject(m_objHandles[0],FALSE);
pFtr1->GetGeometry()->CreateShape(pts1New.GetData(),pts1New.GetSize());
m_pEditor->RestoreObject(m_objHandles[0]);
CValueTable newTab;
newTab.BeginAddValueItem();
pFtr1->WriteTo(undo.newVT);
newTab.EndAddValueItem();
undo.newVT.AddItemFromTab(newTab);
undo.arrHandles.Add(m_objHandles[1]);
oldTab.DelAll();
oldTab.BeginAddValueItem();
pFtr2->WriteTo(oldTab);
oldTab.EndAddValueItem();
undo.oldVT.AddItemFromTab(oldTab);
m_pEditor->DeleteObject(m_objHandles[1],FALSE);
pFtr2->GetGeometry()->CreateShape(pts2New.GetData(),pts2New.GetSize());
m_pEditor->RestoreObject(m_objHandles[1]);
newTab.DelAll();
newTab.BeginAddValueItem();
pFtr2->WriteTo(undo.newVT);
newTab.EndAddValueItem();
undo.newVT.AddItemFromTab(newTab);
undo.Commit();
}
else
{
if (m_pEditor->GetFtrLayerIDOfFtr(m_objHandles[0]) != m_pEditor->GetFtrLayerIDOfFtr(m_objHandles[1]) ||
pFtr1->GetGeometry()->GetClassType() != pFtr2->GetGeometry()->GetClassType())
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
CArray<PT_3DEX,PT_3DEX> ptsNew;
if (bOrder1)
{
for (i=0; i<=iIndex1; i++)
{
ptsNew.Add(pts1[i]);
}
PT_3DEX addPt1(ptIntersect.x,ptIntersect.y,pts1[iIndex1+1].z,pts1[size1-1].pencode);
ptsNew.Add(addPt1);
}
else
{
for (i=size1-1; i>=iIndex1+1; i--)
{
ptsNew.Add(pts1[i]);
}
PT_3DEX addPt1(ptIntersect.x,ptIntersect.y,pts1[0].z,pts1[0].pencode);
ptsNew.Add(addPt1);
}
if (bOrder2)
{
for (i=iIndex2; i>=0; i--)
{
ptsNew.Add(pts2[i]);
}
}
else
{
for (i=iIndex2+1; i<size2; i++)
{
ptsNew.Add(pts2[i]);
}
}
/*if (bOrderIntersect)
{
for (int i=0; i<=iIndex1; i++)
{
ptsNew.Add(pts1[i]);
}
PT_3DEX addPt1(ptIntersect.x,ptIntersect.y,pts1[iIndex1+1].z,pts1[size1-1].pencode);
ptsNew.Add(addPt1);
for (i=iIndex2; i>=0; i--)
{
ptsNew.Add(pts2[i]);
}
}
else
{
for (int i=size1-1; i>=iIndex1+1; i--)
{
ptsNew.Add(pts1[i]);
}
PT_3DEX addPt1(ptIntersect.x,ptIntersect.y,pts1[0].z,pts1[0].pencode);
ptsNew.Add(addPt1);
for (i=iIndex2+1; i<size2; i++)
{
ptsNew.Add(pts2[i]);
}
}*/
undo.AddOldFeature(m_objHandles[0]);
undo.AddOldFeature(m_objHandles[1]);
CFeature *pNewFtr = pFtr1->Clone();
if (!pNewFtr)
{
Abort();
return;
}
pNewFtr->SetID(OUID());
if (!pNewFtr->GetGeometry()->CreateShape(ptsNew.GetData(),ptsNew.GetSize()))
{
Abort();
return;
}
pNewFtr->GetGeometry()->CreateShape(ptsNew.GetData(),ptsNew.GetSize());
m_pEditor->AddObject(pNewFtr,m_pEditor->GetFtrLayerIDOfFtr(m_objHandles[0]));
undo.AddNewFeature(FtrToHandle(pNewFtr));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_objHandles[0]),pNewFtr);
m_pEditor->DeleteObject(m_objHandles[0]);
m_pEditor->DeleteObject(m_objHandles[1]);
undo.Commit();
}
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_nStep = 3;
Finish();
}
CCommand::PtClick(pt, flag);
}
void CIntersectCurveCommand::Finish()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CEditCommand::Finish();
}
void CIntersectCurveCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (bool)(m_bIntersectptBreak);
tab.AddValue(PF_JOIN_MODE,&CVariantEx(var));
}
void CIntersectCurveCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("IntersectCurve",StrFromLocalResID(IDS_CMDNAME_CURVEINTERSECT));
param->AddParam(PF_JOIN_MODE,(bool)(m_bIntersectptBreak),StrFromResID(IDS_CMDPLANE_INTERSECTPOINTSPLIT));
}
void CIntersectCurveCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_JOIN_MODE,var) )
{
m_bIntersectptBreak = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CCurveToBoundCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CCurveToBoundCommand,CEditCommand)
CCurveToBoundCommand::CCurveToBoundCommand()
{
m_lfToler=0.2;
m_nStep = -1;
m_boundScope = NULL;
strcat(m_strRegPath,"\\CurveToBound");
}
CCurveToBoundCommand::~CCurveToBoundCommand()
{
}
void CCurveToBoundCommand::Abort()
{
CEditCommand::Abort();
}
CString CCurveToBoundCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CURVETOBOUND);
}
void CCurveToBoundCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
m_nStep = 0;
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
//线段和射线求交点
static bool GGetLineIntersectLineSeg2(double lfX0,double lfY0, double lfX1, double lfY1,double lfX2,double lfY2,double lfX3,double lfY3, double *plfX, double *plfY)
{
double vector1x = lfX1-lfX0, vector1y = lfY1-lfY0;
double vector2x = lfX3-lfX2, vector2y = lfY3-lfY2;
double delta = vector1x*vector2y-vector1y*vector2x;
if ((fabs(vector1x)+fabs(vector1y))*(fabs(vector2x)+fabs(vector2y))<=1e-15)
{
return false;
}
double toler = GraphAPI::g_lfDisTolerance;
double unitdelta = delta/((fabs(vector1x)+fabs(vector1y))*(fabs(vector2x)+fabs(vector2y)));
if( unitdelta<toler && unitdelta>-toler )return false;
double t1 = ( (lfX2-lfX0)*vector2y-(lfY2-lfY0)*vector2x )/delta;
double xr = lfX0 + t1*vector1x, yr = lfY0 + t1*vector1y;
if( t1<0 || t1>1 )
{
if( fabs(xr-lfX0)<=toler && fabs(yr-lfY0)<=toler );
else if( fabs(xr-lfX1)<=toler && fabs(yr-lfY1)<=toler );
else return false;
}
double t2 = ( (lfX2-lfX0)*vector1y-(lfY2-lfY0)*vector1x )/delta;
if( t2<toler )
{
return false;
}
if(plfX)*plfX = xr;
if(plfY)*plfY = yr;
return true;
}
void CCurveToBoundCommand::CurveToBound(CFeature* pFeature, CUndoModifyProperties& undo)
{
CGeometry* pGeo = pFeature->GetGeometry();
if(!pGeo) return;
CArray<PT_3DEX, PT_3DEX> arrPts;
pGeo->GetShape(arrPts);
int nPt =arrPts.GetSize();
if(nPt<2) return;
if(GraphAPI::GIsEqual3DPoint(&arrPts[0], &arrPts[nPt-1]))
{
return;//闭合的不处理
}
int index1=-1, index2=-1;
//地物的首点
BoundScope* temp = m_boundScope;
PT_3DEX expt1 = arrPts[1];
PT_3DEX expt2 = arrPts[0];
while(temp)
{
if(temp->env.bPtIn(&expt2))
{
PT_3D pt0 = temp->pt0;
PT_3D pt1 = temp->pt1;
PT_3D retPt;
BOOL bret = GGetLineIntersectLineSeg2(pt0.x, pt0.y, pt1.x, pt1.y,
expt1.x, expt1.y, expt2.x, expt2.y, &retPt.x, &retPt.y);
if(bret)
{
expt2.x = retPt.x;
expt2.y = retPt.y;
index1 = 0;
break;
}
}
temp = temp->next;
}
//地物的尾点
temp = m_boundScope;
PT_3DEX expt3 = arrPts[nPt-2];
PT_3DEX expt4 = arrPts[nPt-1];
while(temp)
{
if(temp->env.bPtIn(&expt4))
{
PT_3D pt0 = temp->pt0;
PT_3D pt1 = temp->pt1;
PT_3D retPt;
BOOL bret = GGetLineIntersectLineSeg2(pt0.x, pt0.y, pt1.x, pt1.y,
expt3.x, expt3.y, expt4.x, expt4.y, &retPt.x, &retPt.y);
if(bret)
{
expt4.x = retPt.x;
expt4.y = retPt.y;
index2 = nPt-1;
break;
}
}
temp = temp->next;
}
if(index1==0 || index2>0)
{
undo.arrHandles.Add(FtrToHandle(pFeature));
CValueTable tab2;
tab2.BeginAddValueItem();
pFeature->WriteTo(tab2);
tab2.EndAddValueItem();
undo.oldVT.AddItemFromTab(tab2);
m_pEditor->DeleteObject(FtrToHandle(pFeature));
if(index1==0)
{
pGeo->SetDataPoint(index1, expt2);
}
if(index2>0)
{
pGeo->SetDataPoint(index2, expt4);
}
m_pEditor->RestoreObject(FtrToHandle(pFeature));
CVariantEx var;
CArray<PT_3DEX,PT_3DEX> arrPts;
pGeo->GetShape(arrPts);
var.SetAsShape(arrPts);
if (tab2.SetValue(0,FIELDNAME_SHAPE,&var))
{
undo.newVT.AddItemFromTab(tab2);
}
}
}
void CCurveToBoundCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
//获取层
CFtrLayerArray arrLayers;
int i=0;
pDS->GetFtrLayersByNameOrCode_editable(m_strLayer,arrLayers);
m_boundScope = new BoundScope;
if(m_strLayNameOfTKName.IsEmpty())
{
Envelope e = pDS->GetBound();
m_boundScope->CreateOrAddFromEnv(e, m_lfToler);
}
else
{
CFtrLayerArray ftrLayers;
pDS->GetFtrLayersByNameOrCode(m_strLayNameOfTKName,ftrLayers);
for (i=0; i<ftrLayers.GetSize(); i++)
{
CFtrLayer *pLayer=NULL;
pLayer = pDS->GetFtrLayer(ftrLayers[i]->GetName());
CFeature *pFtr=NULL;
int nObj = ftrLayers[i]->GetObjectCount();
for(int j=0; j<nObj; j++)
{
pFtr = ftrLayers[i]->GetObject(j);
if (pFtr==NULL||!pFtr->IsVisible())
continue;
Envelope e = pFtr->GetGeometry()->GetEnvelope();
m_boundScope->CreateOrAddFromEnv(e, m_lfToler);
}
}
}
CUndoModifyProperties undo(m_pEditor,Name());
for (i=0; i<arrLayers.GetSize(); i++)
{
CFtrLayer *pLayer=NULL;
pLayer = pDS->GetFtrLayer(arrLayers[i]->GetName());
int nObj = arrLayers[i]->GetObjectCount();
for(int j=0; j<nObj; j++)
{
CFeature* pFeature = arrLayers[i]->GetObject(j);
if(!pFeature || !pFeature->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
continue;
PT_3DEX pt3dex;
CurveToBound(pFeature, undo);
}
}
undo.Commit();
Finish();
//清理
BoundScope *temp = m_boundScope;
while(temp)
{
BoundScope *temp1 = temp->next;
delete temp;
temp = temp1;
}
CCommand::PtClick(pt, flag);
}
void CCurveToBoundCommand::Finish()
{
UpdateParams(TRUE);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
CEditCommand::Finish();
}
void CCurveToBoundCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_strLayer);
tab.AddValue("Layer0",&CVariantEx(var));
var = m_lfToler;
tab.AddValue(PF_TOLER,&CVariantEx(var));
var = (_bstr_t)(LPCTSTR)m_strLayNameOfTKName;
tab.AddValue(PF_LAYNAME_BOUNDNAME,&CVariantEx(var));
}
void CCurveToBoundCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("CurveToBound",Name());
param->AddLayerNameParamEx("Layer0",(LPCTSTR)m_strLayer,StrFromResID(IDS_CMDPLANE_HANDLELAYER));
param->AddUsedLayerNameParam(PF_LAYNAME_BOUNDNAME,(LPCTSTR)m_strLayNameOfTKName,StrFromResID(IDS_LAYNAME_BOUNDNAME));
param->AddParam(PF_TOLER,(double)m_lfToler,StrFromResID(IDS_CMDPLANE_TOLER));
}
void CCurveToBoundCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"Layer0",var) )
{
m_strLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strLayer.TrimRight();
m_strLayer.TrimLeft();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_TOLER,var) )
{
m_lfToler = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if (tab.GetValue(0,PF_LAYNAME_BOUNDNAME,var))
{
m_strLayNameOfTKName = (LPCSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CIntersectCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CIntersectCommand,CEditCommand)
CIntersectCommand::CIntersectCommand()
{
m_nStep = -1;
m_nMode = 0;
strcat(m_strRegPath,"\\Intersect");
}
CIntersectCommand::~CIntersectCommand()
{
}
void CIntersectCommand::Abort()
{
CEditCommand::Abort();
}
CString CIntersectCommand::Name()
{
return StrFromResID(IDS_CMDNAME_INTERSECT);
}
void CIntersectCommand::Start()
{
if( !m_pEditor )return;
m_pFtrs[0] = NULL;
m_pFtrs[1] = NULL;
CEditCommand::Start();
m_pEditor->OpenSelector(SELMODE_SINGLE);
}
int KickoffSame2DPoints_notPenMove(CArray<PT_3DEX,PT_3DEX>& arrPts);
void CIntersectCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag,FALSE) )return;
m_objHandles[0] = m_pEditor->GetSelection()->GetLastSelectedObj();
m_pFtrs[0] = HandleToFtr(m_objHandles[0]);
if (m_pFtrs[0]==NULL)
{
return;
}
m_pFtrs[0] =m_pFtrs[0]->Clone();
if( !(m_pFtrs[0]) )return;
if( !(m_pFtrs[0]->GetGeometry())->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) )return;
// m_pEditor->SetCurDrawingObj(DrawingInfo((m_pFtrs[0]->GetGeometry()),(m_pFtrs[0]->GetGeometry())->GetDataPointSum()+1));
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
}
else if( m_nStep==1 )
{
if( !CanGetSelObjs(flag,FALSE) )return;
m_objHandles[1] = m_pEditor->GetSelection()->GetLastSelectedObj();
if (m_objHandles[1]==m_objHandles[0])
{
return;
}
m_pFtrs[1] = HandleToFtr(m_objHandles[1]);
if (m_pFtrs[1]==NULL)
{
return;
}
m_pFtrs[1] = m_pFtrs[1]->Clone();
if( !(m_pFtrs[1]) )return;
if( !(m_pFtrs[1]->GetGeometry())->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) )return;
// m_pEditor->SetCurDrawingObj(DrawingInfo());
m_pEditor->CloseSelector();
m_nStep = 2;
GotoState(PROCSTATE_PROCESSING);
}
else if(m_nStep == 2)
{
int modified=0;
if(((m_pFtrs[0]->GetGeometry())->GetDataPointSum())<2 )return;
const CShapeLine *pSL = (m_pFtrs[0]->GetGeometry())->GetShape();
if( !pSL )return;
CArray<int, int> pos1;
pSL->GetKeyPosOfBaseLines(pos1);
CArray<PT_3DEX,PT_3DEX> pts1,arr1;
pSL->GetPts(pts1);
pSL->GetKeyPts(arr1);
int PtNums1 = pts1.GetSize();
PT_3D *Pnts1=new PT_3D[PtNums1];
if(!Pnts1)return;
for (int j=0;j<PtNums1;j++)//获取点数组
{
COPY_3DPT(Pnts1[j],pts1[j]);
}
if(((m_pFtrs[1]->GetGeometry())->GetDataPointSum())<2 )return;
pSL = (m_pFtrs[1]->GetGeometry())->GetShape();
if( !pSL )return;
CArray<int, int> pos2;
pSL->GetKeyPosOfBaseLines(pos2);
CArray<PT_3DEX,PT_3DEX> pts2,arr2;
pSL->GetPts(pts2);
pSL->GetKeyPts(arr2);
int PtNums2 = pts2.GetSize();
PT_3D *Pnts2=new PT_3D[PtNums2];
if(!Pnts2)return;
for ( j=0;j<PtNums2;j++)//获取点数组
{
COPY_3DPT(Pnts2[j],pts2[j]);
}
int PtNums3=PtNums1;
PT_3D *Pnts3=new PT_3D[PtNums3];
if(!Pnts3)return;
memcpy(Pnts3,Pnts1,PtNums3*sizeof(PT_3D));
int len1=PtNums1;
int len2=PtNums2;
LinkList L=NULL;
LNode *p=NULL;
PT_3DEX ret;
initLList(L);
bool mark;
if (m_nMode==0)
{
mark = true;
}
else
mark = false;
int nAddPtSum = 0;
//内插两条折线的交点。分别以折线1和2为基准进行两次嵌套循环，并将所求节点按照一定顺序（t从小到大）加入到链表中，再从链表中
//从头至尾取出节点插入
//遍历折线1中的每条线段
for(j=0;j<PtNums1-1;j++)
{
int k=j;
//遍历折线2中的每条线段
for( int i=0; i<PtNums2-1; i++)
{
int flag=-1;
if( (flag=GLineIntersectLineSegInLimit1(Pnts1[j].x,Pnts1[j].y,Pnts1[j].z,
Pnts1[j+1].x,Pnts1[j+1].y,Pnts1[j+1].z,
Pnts2[i].x,Pnts2[i].y,Pnts2[i].z,Pnts2[i+1].x,
Pnts2[i+1].y,Pnts2[i+1].z,
&ret.x,&ret.y,&ret.z,10e-4,mark))==0 )
continue;
else
{
if (flag==1)
{
addLnode(&L,&(Pnts1[j]),&ret); //插入链表，排序过程在 addLnode中已经进行
}
else if (flag==2)
{
Pnts1[j].z=ret.z;
}
else if (flag==3)
{
Pnts1[j+1].z=ret.z;
}
modified=1;
/*addLnode(&L,&(Pnts1[j]),&ret);*/ //插入链表，排序过程在 addLnode中已经进行
}
}
int nAddPtSum0 = 0;
int k0 = k + nAddPtSum;
for (p=L;p!=NULL;p=p->next)
{
for (int m=0; m<pos1.GetSize(); m++)
{
if (k0 < pos1[m])
{
PT_3DEX ptex(p->pt3d,arr1[m].pencode);
arr1.InsertAt(m,ptex);
pos1.InsertAt(m,k0);
if (m >= 1 && k0 == pos1[m-1])
{
for (int n=m; n<pos1.GetSize(); n++)
{
pos1[n]++;
}
}
nAddPtSum0++;
break;
}
}
// insertPoint(&Pnts1,&len1,&PtNums1,&(p->pt3d),k+1);//插入Pnts1数组中
// j++;//相应的循环变量也要增加，以便定位于第二条线段的起点
}
nAddPtSum += nAddPtSum0;
destroyList(&L);
}
nAddPtSum = 0;
for(int i=0;i<PtNums2-1;i++)
{
int flag=-1;
int k=i;
for(int j=0; j<PtNums3-1; j++)
{
if( (flag=GLineIntersectLineSegInLimit1(Pnts2[i].x,Pnts2[i].y,Pnts2[i].z,
Pnts2[i+1].x,Pnts2[i+1].y,Pnts2[i+1].z,
Pnts3[j].x,Pnts3[j].y,Pnts3[j].z,
Pnts3[j+1].x,Pnts3[j+1].y,Pnts3[j+1].z,
&ret.x,&ret.y,&ret.z,10e-4,true))==0 )
{
continue;
}
else
{
if (flag==1)
{
addLnode(&L,&(Pnts2[i]),&ret);
}
else if (flag==2)
{
Pnts2[i].z=ret.z;
}
else if (flag==3)
{
Pnts2[i+1].z=ret.z;
}
modified=1;
}
}
int nAddPtSum0 = 0;
int k0 = k + nAddPtSum;
for (p=L;p!=NULL;p=p->next)
{
for (int m=0; m<pos2.GetSize(); m++)
{
if (k0 < pos2[m])
{
PT_3DEX ptex(p->pt3d,arr2[m].pencode);
arr2.InsertAt(m,ptex);
pos2.InsertAt(m,k0);
if (m >= 1 && k0 == pos2[m-1])
{
for (int n=m; n<pos2.GetSize(); n++)
{
pos2[n]++;
}
}
nAddPtSum0++;
break;
}
}
// insertPoint(&Pnts2,&len2,&PtNums2,&(p->pt3d),k+1);
// i++;
}
nAddPtSum += nAddPtSum0;
destroyList(&L);
}
if( modified )
{
CUndoFtrs undo(m_pEditor,Name());
KickoffSame2DPoints_notPenMove(arr1);
m_pFtrs[0]->SetID(OUID());
m_pFtrs[0]->GetGeometry()->CreateShape(arr1.GetData(),arr1.GetSize());
m_pEditor->AddObject(m_pFtrs[0],m_pEditor->GetFtrLayerIDOfFtr(m_objHandles[0]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_objHandles[0]),m_pFtrs[0]);
undo.arrNewHandles.Add(FtrToHandle(m_pFtrs[0]));
m_pEditor->DeleteObject(m_objHandles[0]);
undo.arrOldHandles.Add(m_objHandles[0]);
KickoffSame2DPoints_notPenMove(arr2);
m_pFtrs[1]->SetID(OUID());
m_pFtrs[1]->GetGeometry()->CreateShape(arr2.GetData(),arr2.GetSize());
m_pEditor->AddObject(m_pFtrs[1],m_pEditor->GetFtrLayerIDOfFtr(m_objHandles[1]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_objHandles[1]),m_pFtrs[1]);
undo.arrNewHandles.Add(FtrToHandle(m_pFtrs[1]));
m_pEditor->DeleteObject(m_objHandles[1]);
undo.arrOldHandles.Add(m_objHandles[1]);
undo.Commit();
m_pEditor->RefreshView();
}
if( Pnts1 )delete Pnts1;
if( Pnts2 )delete Pnts2;
if( Pnts3 )delete Pnts3;
m_nStep=3;
Finish();
}
CCommand::PtClick(pt, flag);
}
void CIntersectCommand::Finish()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CEditCommand::Finish();
}
void CIntersectCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)(m_nMode);
tab.AddValue(PF_INTERSECTWAY,&CVariantEx(var));
}
void CIntersectCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("IntersectCommand",StrFromLocalResID(IDS_CMDNAME_INTERSECT));
param->BeginOptionParam(PF_INTERSECTWAY,StrFromResID(IDS_CMDPLANE_INTERSECTWAY));
param->AddOption(StrFromResID(IDS_KEEPZ),0,' ',m_nMode==0);
param->AddOption(StrFromResID(IDS_NOKEEPZ),1,' ',m_nMode==1);
param->EndOptionParam();
}
void CIntersectCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_INTERSECTWAY,var) )
{
m_nMode = (long )(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CLayerIntersectCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CLayerIntersectCommand,CEditCommand)
CLayerIntersectCommand::CLayerIntersectCommand()
{
m_nMode = 0;
m_strFIDs = _T("");
strcat(m_strRegPath,"\\LayerIntersect");
}
CLayerIntersectCommand::~CLayerIntersectCommand()
{
}
void CLayerIntersectCommand::Abort()
{
CEditCommand::Abort();
}
CCommand* CLayerIntersectCommand::Create()
{
return new CLayerIntersectCommand;
}
void CLayerIntersectCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)(m_nMode);
tab.AddValue(PF_INTERSECTWAY,&CVariantEx(var));
var = (_bstr_t)(m_strFIDs);
tab.AddValue(PF_INTERSECTFIRST,&CVariantEx(var));
}
void CLayerIntersectCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("LayerIntersectCommand",StrFromLocalResID(IDS_CMDNAME_LAYERINTERSECT));
param->BeginOptionParam(PF_INTERSECTWAY,StrFromResID(IDS_CMDPLANE_INTERSECTWAY));
param->AddOption(StrFromResID(IDS_KEEPZ),0,' ',m_nMode==0);
param->AddOption(StrFromResID(IDS_NOKEEPZ),1,' ',m_nMode==1);
param->EndOptionParam();
param->AddLayerNameParamEx(PF_INTERSECTFIRST,(LPCTSTR)m_strFIDs,StrFromResID(IDS_FIELDNAME_LAYERNAME),NULL,LAYERPARAMITEM_LINEAREA);
}
void CLayerIntersectCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_INTERSECTWAY,var) )
{
m_nMode = (long )(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_INTERSECTFIRST,var) )
{
m_strFIDs = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
CString CLayerIntersectCommand::Name()
{
return StrFromResID(IDS_CMDNAME_LAYERINTERSECT);
}
void CLayerIntersectCommand::Start()
{
if( !m_pEditor )return;
m_nMode = 0;
m_strFIDs = _T("");
CEditCommand::Start();
m_pEditor->CloseSelector();
}
BOOL CLayerIntersectCommand::PreProcess1(CFeature *pFtr,CArray<ObjItem,ObjItem&> &arrItem)
{
if(!pFtr) return FALSE;
CGeometry *pObj = pFtr->GetGeometry();
if(!pObj) return FALSE;
BOOL ret = FALSE;
const Envelope e = pObj->GetShape()->GetEnvelope();
for(int i=arrItem.GetSize()-1;i>=0;i--)
{
if(pFtr==arrItem[i].pFtr)
{
arrItem[i].flag1 = TRUE;
continue;
}
const Envelope e0 = arrItem[i].pFtr->GetGeometry()->GetShape()->GetEnvelope();
if (e.bIntersect(&e0))
{
arrItem[i].flag1 = FALSE;
ret = TRUE;
}
else
arrItem[i].flag1 = TRUE;
}
return ret;
}
BOOL CLayerIntersectCommand::PreProcess2(PT_3D pt1, PT_3D pt2, CArray<ObjItem,ObjItem&> &arrItem)
{
BOOL ret = FALSE;
for(int i=arrItem.GetSize()-1;i>=0;i--)
{
const CShapeLine *pShape = arrItem[i].pFtr->GetGeometry()->GetShape();
if (pShape && pShape->bIntersect(pt1,pt2))
{
arrItem[i].flag2 = FALSE;
ret = TRUE;
}
else
arrItem[i].flag2 = TRUE;
}
return ret;
}
//类似于智能指针，小范围使用一下
template<class T>
class MemMgr
{
public:
MemMgr()
{
}
~MemMgr()
{
for (int i=arrElement.GetSize()-1;i>=0;i--)
{
if((*(arrElement[i]))==NULL)
continue;
if (arrFlag[i])
{
delete [](*(arrElement[i]));
}
else
delete (*(arrElement[i]));
}
}
void Add(T** elem, BOOL flag = FALSE)
{
arrElement.Add(elem);
arrFlag.Add(flag);
}
protected:
private:
CArray<T**,T**> arrElement;
CArray<BOOL,BOOL> arrFlag;
};
static int _comp_featureP(const void *p1, const void *p2)
{
const CFeature **p3 = (const CFeature **)p1;
const CFeature **p4 = (const CFeature **)p2;
if(*p3==*p4)
return 0;
return *p3<*p4?-1:1;
}
void CLayerIntersectCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CFtrLayerArray arr;
pDS->GetFtrLayersByNameOrCode_editable(m_strFIDs, arr);
CUndoBatchAction undo(m_pEditor,Name());
CFtrArray backupFtrs, modifiedFtrs, ftrs2;
for(int i=0; i<arr.GetSize(); i++)
{
for(int j=i; j<arr.GetSize(); j++)
{
m_strFID1 = arr[i]->GetName();
m_strFID2 = arr[j]->GetName();
CString strMsg;
strMsg.Format("%02d\\%02d: %s--%s",(int)(i+1),(int)(j+1),(LPCTSTR)m_strFID1, (LPCTSTR)m_strFID2);
GOutPut(strMsg);
Process(backupFtrs,modifiedFtrs);
}
}
ftrs2.Copy(modifiedFtrs);
//去除重复
qsort(modifiedFtrs.GetData(),modifiedFtrs.GetSize(),sizeof(CFeature*),_comp_featureP);
modifiedFtrs.SetSize(GraphAPI::GKickoffSameData(modifiedFtrs.GetData(),modifiedFtrs.GetSize()));
for(i=0; i<modifiedFtrs.GetSize(); i++)
{
CUndoShape undo1(m_pEditor,Name());
CFeature *pFtr = modifiedFtrs[i];
for(int j=0; j<ftrs2.GetSize(); j++)
{
if( pFtr==ftrs2[j] )
{
backupFtrs[j]->GetGeometry()->GetShape(undo1.arrPtsOld);
break;
}
}
if(j>=ftrs2.GetSize())
continue;
pFtr->GetGeometry()->GetShape(undo1.arrPtsNew);
undo1.handle = FtrToHandle(pFtr);
m_pEditor->DeleteObject(FtrToHandle(pFtr));
m_pEditor->RestoreObject(FtrToHandle(pFtr));
undo.AddAction(&undo1);
}
for(i=0; i<backupFtrs.GetSize(); i++)
{
delete backupFtrs[i];
}
undo.Commit();
Finish();
CString strMsg;
strMsg.Format(IDS_PROCESS_OBJ_NUM,modifiedFtrs.GetSize());
GOutPut(strMsg);
CEditCommand::PtClick(pt,flag);
}
BOOL CLayerIntersectCommand::Process(CFtrArray& backupFtrs, CFtrArray& modifiedFtrs)
{
{
//得到找到层1和层2的地物
CArray<int,int> delObjsIdx;
CArray<ObjItem,ObjItem&> arr1,arr2;
CFtrLayer *pLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayer(m_strFID1);
if (!pLayer||pLayer->IsLocked()||!pLayer->IsVisible())
{
return FALSE;
}
for (int i=0; i<pLayer->GetObjectCount(); i++)
{
CFeature *pFtr = pLayer->GetObject(i);
if (pFtr)
{
if( !pFtr->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) )
continue;
arr1.Add(ObjItem(pFtr));
}
}
pLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayer(m_strFID2);
if (!pLayer||pLayer->IsLocked()||!pLayer->IsVisible())
{
return FALSE;
}
for (i=0; i<pLayer->GetObjectCount(); i++)
{
CFeature *pFtr = pLayer->GetObject(i);
if (pFtr)
{
if( !pFtr->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) )
continue;
arr2.Add(ObjItem(pFtr));
}
}
int nSum = arr1.GetSize()+arr2.GetSize();
if (m_strFID1==m_strFID2)
{
nSum = nSum>>1;
}
int k,l;
bool mark;
MemMgr<PT_3D> memSecur;
GProgressStart(nSum);
//以arr1为基准，循环取其中的每个地物与arr2中的做内插处理，结果加入数据源.得到内插的原地物需要做个标记，便于以后删除
if (m_nMode==0)
{
mark = true;
}
else
mark = false;
for (i=arr1.GetSize()-1;i>=0;i--)
{
GProgressStep();
//初步过滤掉arr2中明显不想交的地物
if(!PreProcess1(arr1[i].pFtr,arr2)) continue;
CGeometry *pGeo = arr1[i].pFtr->GetGeometry();
const CShapeLine *pSL = pGeo->GetShape();
if( !pSL )return FALSE;
CArray<int, int> pos1;
pSL->GetKeyPosOfBaseLines(pos1);
CArray<PT_3DEX,PT_3DEX> pts1,arrkey1;
pSL->GetPts(pts1);
pSL->GetKeyPts(arrkey1);
BOOL bSame = pts1.GetSize()==arrkey1.GetSize()?TRUE:FALSE;
int nPts1 = pts1.GetSize();
PT_3D *Pnts1=new PT_3D[nPts1];
if(!Pnts1)return FALSE;
memSecur.Add(&Pnts1,TRUE);
for (int j=0;j<nPts1;j++)//获取点数组
{
COPY_3DPT(Pnts1[j],pts1[j]);
}
BOOL modified = FALSE;
LinkList L=NULL;
LNode *p=NULL;
PT_3D ret;
initLList(L);
int len1 = nPts1;
for (j=0;j<nPts1-1;j++)
{
if(!PreProcess2(Pnts1[j],Pnts1[j+1],arr2))continue;
int idx = j;
for (k=arr2.GetSize()-1;k>=0;k--)
{
if (arr2[k].flag1==TRUE||arr2[k].flag2==TRUE)continue;
pSL = arr2[k].pFtr->GetGeometry()->GetShape();
if( !pSL )return FALSE;
CArray<int, int> pos2;
pSL->GetKeyPosOfBaseLines(pos2);
CArray<PT_3DEX,PT_3DEX> pts2,arrkey2;
pSL->GetPts(pts2);
pSL->GetKeyPts(arrkey2);
int nPts2 = pts2.GetSize();
PT_3D *Pnts2=new PT_3D[nPts2];
if(!Pnts2)return FALSE;
memSecur.Add(&Pnts2,TRUE);
for (l=0;l<nPts2;l++)//获取点数组
{
COPY_3DPT(Pnts2[l],pts2[l]);
}
int idx = l;
for ( l=0;l<nPts2-1;l++)
{
int flag=-1;
if( (flag=GLineIntersectLineSegInLimit1(Pnts1[j].x,Pnts1[j].y,Pnts1[j].z,
Pnts1[j+1].x,Pnts1[j+1].y,Pnts1[j+1].z,
Pnts2[l].x,Pnts2[l].y,Pnts2[l].z,Pnts2[l+1].x,
Pnts2[l+1].y,Pnts2[l+1].z,
&ret.x,&ret.y,&ret.z,1e-4,mark))==0 )
continue;
else
{
//交点在线段内部
if (flag==1)
{
//按照距离反序排列
addLnode(&L,&(Pnts1[j]),&ret); //插入链表，排序过程在 addLnode中已经进行
}
else if (flag==2)
{
Pnts1[j].z = ret.z;
}
else if (flag==3)
{
Pnts1[j+1].z = ret.z;
}
modified = TRUE;
}
}
delete []Pnts2;
Pnts2 = NULL;
}
if (bSame)
{
//相交点插入到Pnts1中
for (p=L;p!=NULL;p=p->next)
{
insertPoint(&Pnts1,&len1,&nPts1,&(p->pt3d),idx+1);//插入Pnts1数组中
j++;//相应的循环变量也要增加，以便定位于第二条线段的起点
}
}
else
{
//相交点插入到arrkey1中
for (int m=0; m<pos1.GetSize(); m++)
{
if (idx < pos1[m])
{
for (p=L;p!=NULL;p=p->next)
{
PT_3DEX ptex(p->pt3d,arrkey1[m].pencode);
arrkey1.InsertAt(m,ptex);
pos1.InsertAt(m,idx);
}
break;
}
}
}
destroyList(&L);
}
//添加地物
if (modified)
{
delObjsIdx.Add(i);
CFeature *pFtrObj = arr1[i].pFtr;
backupFtrs.Add(pFtrObj->Clone());
if (bSame)
{
CArray<PT_3DEX,PT_3DEX> arr;
PT_3DEX PtEX;
for (int i=0;i<nPts1;i++)
{
COPY_3DPT(PtEX,Pnts1[i]);
PtEX.pencode = penLine;
arr.Add(PtEX);
}
KickoffSame2DPoints_notPenMove(arr);
pFtrObj->GetGeometry()->CreateShape(arr.GetData(),arr.GetSize());
}
else
{
KickoffSame2DPoints_notPenMove(arrkey1);
pFtrObj->GetGeometry()->CreateShape(arrkey1.GetData(),arrkey1.GetSize());
}
modifiedFtrs.Add(pFtrObj);
}
delete []Pnts1;
Pnts1 = NULL;
}
if (m_strFID1==m_strFID2)
{
goto ret;
}
//以arr2为基准，循环取其中的每个地物与arr1中的做内插处理，结果加入数据源
if (m_nMode==0||m_nMode==1)
{
mark = true;
}
else
mark = false;
for (i=arr2.GetSize()-1;i>=0;i--)
{
GProgressStep();
//初步过滤掉arr2中明显不想交的地物
if(!PreProcess1(arr2[i].pFtr,arr1)) continue;
CGeometry *pGeo = arr2[i].pFtr->GetGeometry();
const CShapeLine *pSL = pGeo->GetShape();
if( !pSL )return FALSE;
CArray<int, int> pos1;
pSL->GetKeyPosOfBaseLines(pos1);
CArray<PT_3DEX,PT_3DEX> pts1,arrkey1;
pSL->GetPts(pts1);
pSL->GetKeyPts(arrkey1);
BOOL bSame = pts1.GetSize()==arrkey1.GetSize()?TRUE:FALSE;
int nPts1 = pts1.GetSize();
PT_3D *Pnts1=new PT_3D[nPts1];
if(!Pnts1)return FALSE;
memSecur.Add(&Pnts1,TRUE);
for (int j=0;j<nPts1;j++)//获取点数组
{
COPY_3DPT(Pnts1[j],pts1[j]);
}
BOOL modified = FALSE;
LinkList L=NULL;
LNode *p=NULL;
PT_3D ret;
initLList(L);
int len1 = nPts1;
for (j=0;j<nPts1-1;j++)
{
if(!PreProcess2(Pnts1[j],Pnts1[j+1],arr1))continue;
int idx = j;
for (k=arr1.GetSize()-1;k>=0;k--)
{
if (arr1[k].flag1==TRUE||arr1[k].flag2==TRUE)continue;
pSL = arr1[k].pFtr->GetGeometry()->GetShape();
if( !pSL )return FALSE;
CArray<int, int> pos2;
pSL->GetKeyPosOfBaseLines(pos2);
CArray<PT_3DEX,PT_3DEX> pts2,arrkey2;
pSL->GetPts(pts2);
pSL->GetKeyPts(arrkey2);
int nPts2 = pts2.GetSize();
PT_3D *Pnts2=new PT_3D[nPts2];
if(!Pnts2)return FALSE;
memSecur.Add(&Pnts2,TRUE);
for (l=0;l<nPts2;l++)//获取点数组
{
COPY_3DPT(Pnts2[l],pts2[l]);
}
int idx = l;
for ( l=0;l<nPts2-1;l++)
{
int flag=-1;
if( (flag=GLineIntersectLineSegInLimit1(Pnts1[j].x,Pnts1[j].y,Pnts1[j].z,
Pnts1[j+1].x,Pnts1[j+1].y,Pnts1[j+1].z,
Pnts2[l].x,Pnts2[l].y,Pnts2[l].z,Pnts2[l+1].x,
Pnts2[l+1].y,Pnts2[l+1].z,
&ret.x,&ret.y,&ret.z,10e-4,mark))==0 )
continue;
else
{
if (flag==1)
{
addLnode(&L,&(Pnts1[j]),&ret); //插入链表，排序过程在 addLnode中已经进行
}
else if (flag==2)
{
Pnts1[j].z = ret.z;
}
else if (flag==3)
{
Pnts1[j+1].z = ret.z;
}
modified = TRUE;
}
}
delete []Pnts2;
Pnts2 = NULL;
}
if (bSame)
{
for (p=L;p!=NULL;p=p->next)
{
insertPoint(&Pnts1,&len1,&nPts1,&(p->pt3d),idx+1);//插入Pnts1数组中
j++;//相应的循环变量也要增加，以便定位于第二条线段的起点
}
}
else
{
for (int m=0; m<pos1.GetSize(); m++)
{
if (idx < pos1[m])
{
for (p=L;p!=NULL;p=p->next)
{
PT_3DEX ptex(p->pt3d,arrkey1[m].pencode);
arrkey1.InsertAt(m,ptex);
pos1.InsertAt(m,idx);
}
break;
}
}
}
destroyList(&L);
}
//添加地物
if (modified)
{
//直接删除原地物
CFeature *pFtrObj = arr2[i].pFtr;
backupFtrs.Add(pFtrObj->Clone());
if (bSame)
{
CArray<PT_3DEX,PT_3DEX> arr;
PT_3DEX PtEX;
for (int i=0;i<nPts1;i++)
{
COPY_3DPT(PtEX,Pnts1[i]);
PtEX.pencode = penLine;
arr.Add(PtEX);
}
KickoffSame2DPoints_notPenMove(arr);
pFtrObj->GetGeometry()->CreateShape(arr.GetData(),arr.GetSize());
}
else
{
KickoffSame2DPoints_notPenMove(arrkey1);
pFtrObj->GetGeometry()->CreateShape(arrkey1.GetData(),arrkey1.GetSize());
}
modifiedFtrs.Add(pFtrObj);
}
delete []Pnts1;
Pnts1 = NULL;
}
ret:
GProgressEnd();
}
return TRUE;
}
//////////////////////////////////////////////////////////////////////
// CDelAllSameCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CDelAllSameCommand,CEditCommand)
CDelAllSameCommand::CDelAllSameCommand()
{
m_nStep = -1;
m_bCheckLayName = FALSE;
m_nMode = 0;
}
CDelAllSameCommand::~CDelAllSameCommand()
{
}
CString CDelAllSameCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DELSAME);
}
//比较两个地物是否完全相同
BOOL CDelAllSameCommand::IsWholeOverlapedObj(CDataSourceEx *pDS, CFeature *pObj1, CFeature *pObj2, BOOL bCheckLayName, int mode)
{
if (!pObj1 || !pObj2)return FALSE;
//特征码必须相同
CFtrLayer* pLay1 = pDS->GetFtrLayerOfObject(pObj1);
CFtrLayer* pLay2 = pDS->GetFtrLayerOfObject(pObj2);
if (bCheckLayName && pLay1 && pLay2 && stricmp(pLay1->GetName(), pLay2->GetName()) != 0)
return FALSE;
CGeometry *pGeo1 = pObj1->GetGeometry();
CGeometry *pGeo2 = pObj2->GetGeometry();
if (!pGeo1 || !pGeo2)
return FALSE;
//点数必须相同
if (mode == 0 && pGeo1->GetDataPointSum() != pGeo2->GetDataPointSum())
return FALSE;
//类型必须相同
if (pGeo1->GetClassType() != pGeo2->GetClassType())
return FALSE;
CArray<PT_3DEX, PT_3DEX> arrPts1, arrPts2;
pGeo1->GetShape(arrPts1);
pGeo2->GetShape(arrPts2);
int nsz1 = GraphAPI::GKickoffSamePoints(arrPts1.GetData(), arrPts1.GetSize());
arrPts1.SetSize(nsz1);
int nsz2 = GraphAPI::GKickoffSamePoints(arrPts2.GetData(), arrPts2.GetSize());
arrPts2.SetSize(nsz2);
if (nsz1 == 1 && nsz2 == 1)//点，文本
{
if (!GraphAPI::GIsEqual3DPoint(&arrPts1[0], &arrPts2[0]))
return FALSE;
if (pGeo1->IsKindOf(RUNTIME_CLASS(CGeoText)))
{
CString text1 = ((CGeoText*)pGeo1)->GetText();
CString text2 = ((CGeoText*)pGeo2)->GetText();
if (0 != text1.CompareNoCase(text2))
return FALSE;
}
return TRUE;
}
if (mode == 1 && nsz1 > 1 && nsz2 > 1)//剔除直线中间的点
{
CArray<PT_3DEX,PT_3DEX> temp;
int i=0, a=1;
double ang;
for(i=0; i<nsz1-2; )
{
if(i+a+1>=nsz1) break;
ang=GraphAPI::GGetIncludedAngle(arrPts1[i], arrPts1[i+a], arrPts1[i+a], arrPts1[i+a+1]);
if(fabs(ang)<0.0001)//共线
{
a++;
}
else
{
temp.Add(arrPts1[i]);
i+=a;
a=1;
}
}
temp.Add(arrPts1[i]);
temp.Add(arrPts1[i+a]);
if(i+a+1<nsz1) temp.Add(arrPts1[i+a+1]);
arrPts1.Copy(temp);
nsz1 = arrPts1.GetSize();
a = 1;
temp.RemoveAll();
for(i=0; i<nsz2-2; )
{
if(i+a+1>=nsz2) break;
ang=GraphAPI::GGetIncludedAngle(arrPts2[i], arrPts2[i+a], arrPts2[i+a], arrPts2[i+a+1]);
if(fabs(ang)<0.0001)//共线
{
a++;
}
else
{
temp.Add(arrPts2[i]);
i+=a;
a=1;
}
}
temp.Add(arrPts2[i]);
temp.Add(arrPts2[i+a]);
if(i+a+1<nsz2) temp.Add(arrPts2[i+a+1]);
arrPts2.Copy(temp);
nsz2 = arrPts2.GetSize();
}
if( nsz1!=nsz2 )
return FALSE;
if( nsz1<=0 )
return FALSE;
double toler = GraphAPI::g_lfDisTolerance;
//当两地物都是面或闭合曲线时
if( pGeo1->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) && pGeo2->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) &&
((CGeoCurveBase*)pGeo1)->IsClosed() && ((CGeoCurveBase*)pGeo2)->IsClosed() && nsz1>2 )
{
//去掉闭合点
int npt = nsz1-1;
PT_3DEX expt1, expt2, expt3;
expt1 = arrPts1[0];
int i;
for ( i=0;i<npt;i++)
{
expt2 = arrPts2[i];
if( (fabs(expt1.x-expt2.x)<toler && fabs(expt1.y-expt2.y)<toler) )
{
break;
}
}
if (i>=npt)
{
return FALSE;
}
else
{
//顺序检验
{
for( int j=1; j<npt; j++ )
{
expt1 = arrPts1[j];
expt2 = arrPts2[(i+j)%npt];
if( (fabs(expt1.x-expt2.x)<toler && fabs(expt1.y-expt2.y)<toler) )
{
}
else
{
break;
}
}
if( j<npt ) ;
else
return TRUE;
}
//反序检验
{
for( int j=1; j<npt; j++ )
{
expt1 = arrPts1[j];
expt2 = arrPts2[(i+npt-j)%npt];
if( (fabs(expt1.x-expt2.x)<toler && fabs(expt1.y-expt2.y)<toler) )
{
}
else
{
break;
}
}
if( j<npt )return FALSE;
else
return TRUE;
}
}
}
else
{
//首尾端点必须相同
int npt = nsz1;
PT_3DEX expt1, expt2, expt3;
BOOL bSame1 = FALSE, bSame2 = FALSE;
expt1 = arrPts1[0];
expt2 = arrPts2[0];
expt3 = arrPts2[npt-1];
if( (fabs(expt1.x-expt2.x)<toler && fabs(expt1.y-expt2.y)<toler) )
{
bSame1 = TRUE;
}
if( (fabs(expt1.x-expt3.x)<toler && fabs(expt1.y-expt3.y)<toler) )
{
bSame2 = TRUE;
}
if( !bSame1 && !bSame2 )
return FALSE;
//其他节点必须相同
if( bSame1 )
{
//顺序比较
for( int i=1; i<npt; i++ )
{
expt1 = arrPts1[i];
expt2 = arrPts2[i];
if( (fabs(expt1.x-expt2.x)<toler && fabs(expt1.y-expt2.y)<toler) )
{
}
else
{
break;
}
}
if( i<npt )return FALSE;
else
return TRUE;
}
else
{
//反序比较
for( int i=1; i<npt; i++ )
{
expt1 = arrPts1[i];
expt2 = arrPts2[npt-1-i];
if( (fabs(expt1.x-expt2.x)<toler && fabs(expt1.y-expt2.y)<toler) )
{
}
else
{
break;
}
}
if( i<npt )return FALSE;
else
return TRUE;
}
}
return TRUE;
}
int CDelAllSameCommand::SelectKeepedOne(CArray<CFeature*,CFeature*>& arrObjs)
{
return 0;
}
void CDelAllSameCommand::Process()
{
CDlgDataSource *pDS = ((CDlgDoc*)m_pEditor)->GetDlgDataSource();
if(!pDS) return;
CFtrLayerArray arr;
pDS->GetFtrLayersByNameOrCode_editable(m_strLayers, arr);
//计数
int num = pDS->GetFtrLayerCount();
CArray<CFeature*, CFeature*> arrObjs, arrObjs2;
int i,j, lSum = 0, nObj;
for ( i=0; i<arr.GetSize(); i++)
{
CFtrLayer *pLayer = arr[i];
nObj = pLayer->GetObjectCount();
for( j=0; j<nObj; j++ )
{
CFeature *pObj = pLayer->GetObject(j);
if( !pObj )continue;
arrObjs.Add(pObj);
lSum++;
}
}
GProgressStart(lSum);
CUndoFtrs undo(m_pEditor,Name());
BOOL bMsgBox = FALSE;
nObj = arrObjs.GetSize();
//遍历处理
for ( i=0; i<nObj; i++)
{
CFeature *pObj = arrObjs[i];
GProgressStep();
if( pObj->IsDeleted() )continue;
//找到相同的地物
arrObjs2.RemoveAll();
arrObjs2.Add(pObj);
for( j=i+1; j<nObj; j++)
{
CFeature *pObj1 = arrObjs[j];
if( pObj1->IsDeleted() )continue;
if( IsWholeOverlapedObj(pDS,pObj,pObj1,m_bCheckLayName, m_nMode) )
{
arrObjs2.Add(pObj1);
}
}
if( arrObjs2.GetSize()>1 )
{
if( !bMsgBox && AfxMessageBox(IDS_CMDTIP_DELSAME,MB_OKCANCEL)!=IDOK )
{
Abort();
m_nExitCode = CMPEC_STARTOLD;
GProgressEnd();
return;
}
bMsgBox = TRUE;
//选择要保留的地物
int nSel = SelectKeepedOne(arrObjs2);
if( nSel>=0 )
{
arrObjs2.RemoveAt(nSel);
//其他的全部删除
for( j=0; j<arrObjs2.GetSize(); j++)
{
m_pEditor->DeleteObject(FtrToHandle(arrObjs2[j]),FALSE);
undo.arrOldHandles.Add(FtrToHandle(arrObjs2[j]));
}
}
}
}
undo.Commit();
GProgressEnd();
CString strFormat, strMsg;
strFormat.LoadString(IDS_CMDTIP_DELSAMEOK);
strMsg.Format(strFormat,lSum,undo.arrOldHandles.GetSize());
AfxMessageBox(strMsg);
}
void CDelAllSameCommand::Start()
{
if( !m_pEditor || !((CDlgDoc*)m_pEditor)->GetDlgDataSource() )
{
Abort();
m_nExitCode = CMPEC_STARTOLD;
return;
}
CEditCommand::Start();
Process();
Finish();
m_nExitCode = CMPEC_STARTOLD;
}
template<class runtimeCLass>
runtimeCLass * getView(CDocument * pdoc);
#include "mm3dprj\OsgbView.h"
//////////////////////////////////////////////////////////////////////
// CSplitSurfaceCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CSplitSurfaceCommand,CEditCommand)
CSplitSurfaceCommand::CSplitSurfaceCommand()
{
m_nStep = -1;
m_pDrawProc = NULL;
m_pGeoCurve = NULL;
m_bKeepSplitLine = TRUE;
m_bPlaneFirst = FALSE;
m_bKeepSrcVertexElevtion = FALSE;
m_nOperMode = 1;
}
CSplitSurfaceCommand::~CSplitSurfaceCommand()
{
if( m_pDrawProc )
{
delete m_pDrawProc;
m_pDrawProc = NULL;
}
if(m_pGeoCurve)
{
delete m_pGeoCurve;
m_pGeoCurve = NULL;
}
}
CString CSplitSurfaceCommand::Name()
{
return StrFromResID(IDS_CMDNAME_SPLITSURFACE);
}
void CSplitSurfaceCommand::Start()
{
if( !m_pEditor )return;
m_nStep = 0;
CEditCommand::Start();
if(m_nOperMode == 1)
{
m_pDrawProc = new CDrawCurveProcedure();
m_pDrawProc->Init(m_pEditor);
m_pGeoCurve = new CGeoCurve;
if(!m_pGeoCurve)
{
Abort();
return ;
}
m_pGeoCurve->SetColor(RGB(255,255,255));
m_pDrawProc->m_pGeoCurve = m_pGeoCurve;
UpdateParams(FALSE);
int num;
m_pEditor->GetSelection()->GetSelectedObjs(num);
if(num>0)
{
m_nStep = 1;
m_pDrawProc->Start();
}
}
}
void CSplitSurfaceCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("SplitSurfaceCommand",Name());
param->BeginOptionParam("OperMode",StrFromResID(IDS_CMDPLANE_RIVERFILLTYPE));
param->AddOption(StrFromResID(IDS_CMDPLANE_SELECT),0,' ',m_nOperMode==0);
param->AddOption(StrFromResID(IDS_CMDPLANE_DRAW),1,' ',m_nOperMode==1);
param->EndOptionParam();
if( m_nOperMode==1)
{
param->AddParam(PF_TRACKLINEACCKEY,'w',StrFromResID(IDS_CMDPLANE_TRACKLINE));
param->AddParam("KeepSplitLine", (bool)m_bKeepSplitLine, StrFromResID(IDS_KEEPSPLITLINE));
if(m_bKeepSplitLine)
{
param->AddLayerNameParam("StoreLayer", m_strStoreLayer,StrFromResID(IDS_PLANENAME_PLACELAYER),NULL,LAYERPARAMITEM_LINE);
}
}
if (getView<COsgbView>(PDOC(m_pEditor)))
{
param->AddParam("PlaneFirst", (bool)m_bPlaneFirst, StrFromResID(IDS_PLANEFIRST));
param->AddParam("KeepVertexElevation", (bool)m_bKeepSrcVertexElevtion, StrFromResID(IDS_KEEPSRCVERTEXELEVATION));
}
}
void CSplitSurfaceCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)(m_nOperMode);
tab.AddValue("OperMode",&CVariantEx(var));
var = (bool)(m_bKeepSplitLine);
tab.AddValue("KeepSplitLine",&CVariantEx(var));
var = (LPCTSTR)(m_strStoreLayer);
tab.AddValue("StoreLayer",&CVariantEx(var));
if (getView<COsgbView>(PDOC(m_pEditor)))
{
var = (bool)(m_bPlaneFirst);
tab.AddValue("PlaneFirst", &CVariantEx(var));
var = (bool)(m_bKeepSrcVertexElevtion);
tab.AddValue("KeepVertexElevation", &CVariantEx(var));
}
}
void CSplitSurfaceCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"OperMode",var) )
{
m_nOperMode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
if(!bInit)
Abort();
}
if( tab.GetValue(0,PF_TRACKLINEACCKEY,var) )
{
char ch = (BYTE)(_variant_t)*var;
if(ch == 'w'||ch == 'W')
{
if(m_nOperMode==1)
{
int num;
const FTR_HANDLE *handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if(num<=0)
{
AfxMessageBox(StrFromResID(IDS_SELECT_SURFACE_FIRST));
Abort();
return;
}
}
m_pDrawProc->TrackLine();
}
}
if( tab.GetValue(0,"KeepSplitLine",var) )
{
m_bKeepSplitLine = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"StoreLayer",var) )
{
m_strStoreLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
if (tab.GetValue(0, "PlaneFirst", var))
{
m_bPlaneFirst = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if (tab.GetValue(0, "KeepVertexElevation", var))
{
m_bKeepSrcVertexElevtion = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CSplitSurfaceCommand::Abort()
{
m_nStep = 0;
CEditCommand::Abort();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
void CSplitSurfaceCommand::Finish()
{
m_pEditor->RefreshView();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
CEditCommand::Finish();
}
CProcedure* CSplitSurfaceCommand::GetActiveSonProc(int nMsgType)
{
if (m_nOperMode==1&&(nMsgType==msgEnd||nMsgType==msgPtMove ||nMsgType==msgBack))
{
return m_pDrawProc;
}
return NULL;
}
void CSplitSurfaceCommand::PtClick(PT_3D &pt, int flag)
{
if(m_nOperMode==0)
{
if( !CanGetSelObjs(flag) )return;
int num=0;
const FTR_HANDLE *handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
CGeoArray arr, arr1;
for(int i=0; i<num; i++)
{
CGeometry *pObj = HandleToFtr(handles[i])->GetGeometry();
if(!pObj || !pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
continue;
arr.Add(pObj);
}
CUndoFtrs undo(m_pEditor, Name());
for(int j=0; j<num; j++)
{
CGeometry *pGeo = HandleToFtr(handles[j])->GetGeometry();
if(pGeo && pGeo->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
{
arr1.RemoveAll();
for(i=0; i<arr.GetSize(); i++)
{
arr1.Add(arr[i]->Clone());
}
Split(HandleToFtr(handles[j]), arr1, undo);
}
}
undo.Commit();
Finish();
}
else if(m_nOperMode==1)
{
if(m_nStep==0)
{
int num;
m_pEditor->GetSelection()->GetSelectedObjs(num);
if (num <= 0) return;
m_nStep = 1;
m_pDrawProc->Start();//启动绘线
}
else if(m_nStep==1)
{
if (m_pDrawProc)
{
GotoState(PROCSTATE_PROCESSING);
m_pDrawProc->PtClick(pt,flag);
}
}
}
CEditCommand::PtClick(pt,flag);
}
void CSplitSurfaceCommand::PtReset(PT_3D &pt)
{
if(!m_pEditor || !m_pDrawProc || m_pDrawProc->m_arrPts.GetSize()<2)
{
Abort();
return;
}
m_pEditor->UpdateDrag(ud_ClearDrag,NULL);
m_pDrawProc->PtReset(pt);
int num;
const FTR_HANDLE *handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if(num<=0)
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor, Name());
for(int i=0; i<num; i++)
{
CGeometry *pGeo = HandleToFtr(handles[i])->GetGeometry();
if(!pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)))
continue;
if (!((CGeoCurveBase*)pGeo)->IsClosed())
continue;
CGeoArray arr;
arr.Add(m_pGeoCurve->Clone());
Split(HandleToFtr(handles[i]), arr, undo);
}
undo.Commit();
m_pEditor->RefreshView();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
Finish();
m_nStep = 3;
}
#include "DlgCommand2.h"
extern bool IsSurfaceInclude(CFeature* pFtr0, CFeature* pFtr1);
extern int GetCurveIntersectCurve(PT_3DEX *pts1, int num1, PT_3DEX *pts2, int num2, CArray<PtIntersect,PtIntersect> &arrIntersectPts);
//点是否在线串上
static bool IsPtInCurve(PT_3DEX pt, CArray<PT_3DEX,PT_3DEX>& arrPts)
{
for(int i=0; i<arrPts.GetSize()-1; i++)
{
if(GraphAPI::GIsPtInLine(arrPts[i], arrPts[i+1], pt))
{
return true;
}
}
return false;
}
double get_min_fabs_no_zero(double a, double b, double c, double _default)
{
double f[3] = {
fabs(a),
fabs(b),
fabs(c)
};
int _idx = 0;
while (f[_idx] == 0) { _idx++; if (_idx > 2) return _default; }
int i = _idx + 1;
for (; i < 3; i ++)
{
if (f[i] < f[_idx]) _idx = i;
}
return f[_idx];
}
class PlaneOrModel
{
double a, b, c, d;
double sa2b2c2;
COsgbView * m_pview;
void setsa2b2c2() {
sa2b2c2 = sqrt(a * a + b * b + c * c);
}
struct PT_3D_cmp:public PT_3D
{
PT_3D_cmp(const PT_3D & s)
{
x = s.x;
y = s.y;
z = s.z;
}
PT_3D_cmp(const PT_3DEX & s)
{
x = s.x;
y = s.y;
z = s.z;
}
bool operator== (const PT_3D_cmp & s) const
{
return s.x == x && s.y == y && s.z == z;
}
bool operator<(const PT_3D_cmp & s) const
{
if (x == s.x)
{
if (y == s.y)
{
return z < s.z;
}
else
return y < s.y;
}
else
return x < s.x;
}
};
bool m_resetSrcPts;
std::set<PT_3D_cmp> srcPtSet;
public:
PlaneOrModel() :a(0), b(0), c(0), d(0), m_pview(nullptr), m_resetSrcPts(false){ sa2b2c2 = 0; }
PlaneOrModel(double a, double b, double c, double d):a(a),b(b),c(c),d(d) {
setsa2b2c2();
}
void setSrcPts(CArray<PT_3DEX, PT_3DEX> & arrPts)
{
if (arrPts.GetCount() >= 0)
{
m_resetSrcPts = true;
for (int i = 0; i < arrPts.GetSize(); i++)
{
srcPtSet.insert(arrPts[i]);
}
}
}
void setCOsgbView(COsgbView * p) { m_pview = p; }
void clear() { a = 0; b = 0; c = 0; sa2b2c2 = 0; }
bool isValid() { return (sa2b2c2 > 0) || m_pview; }
bool isModel() { return m_pview; }
void createFrom3Point(const PT_3D & p1, const PT_3D & p2, const PT_3D & p3)
{
a = ((p2.y - p1.y)*(p3.z - p1.z) - (p2.z - p1.z)*(p3.y - p1.y));
b = ((p2.z - p1.z)*(p3.x - p1.x) - (p2.x - p1.x)*(p3.z - p1.z));
c = ((p2.x - p1.x)*(p3.y - p1.y) - (p2.y - p1.y)*(p3.x - p1.x));
double nd = get_min_fabs_no_zero(a, b, c, 1);
a /= nd;
b /= nd;
c /= nd;
d = (0 - (a*p1.x + b*p1.y + c*p1.z));
setsa2b2c2();
}
double pt_to(const PT_3D & pt)
{
if (m_pview)
{
auto zs = m_pview->getLinePick(pt.x, pt.y);
if (zs.size() > 0)
{
double z = zs.back();
return fabs(z - pt.z);
}
return -1;
}
if (sa2b2c2 == 0) return -1;
double a1 = pt.x * a + pt.y * b + pt.z * c + d;
if (a1 == 0) return 0;
return fabs(a1) / sa2b2c2;
}
bool pt_in(const PT_3D & pt, double accept_error)
{
if (m_pview)
{
auto zs = m_pview->getLinePick(pt.x, pt.y);
if (zs.size() > 0)
{
double z = zs.back();
return fabs(z - pt.z) <= accept_error;
}
return false;
}
double a1 = pt.x * a + pt.y * b + pt.z * c + d;
if (a1 == 0) return true;
if (accept_error == 0) return false;
a1 = fabs(a1);
return a1 <= accept_error;
}
void reset_pt_z(PT_3D & pt)
{
if (m_resetSrcPts && !srcPtSet.empty())
{
if (srcPtSet.find(pt) != srcPtSet.end())
return;
}
if (m_pview)
{
auto zs = m_pview->getLinePick(pt.x, pt.y);
if (zs.size() > 0)
{
double z = zs.back();
if (z != 0)
{
pt.z = z;
return;
}
}
}
if (c == 0) return;
double nz = -(pt.x * a + pt.y * b + d) / c;
pt.z = nz;
}
bool pt_projection(PT_3D & pt)
{
reset_pt_z(pt);
// double a1 = pt.x * a + pt.y * b + pt.z * c + d;
// if (a1 == 0) return false;
// double t = a1 / (sa2b2c2 * sa2b2c2);
// pt.x -= a * t;
// pt.y -= b * t;
// pt.z -= c * t;
return true;
}
};
template<class PTA, class PTB, class PTC>
bool ptsInLine2D(const PTA & a, const PTB & b, const PTC & c, double err = 0.1)
{
double dx_ab = a.x - b.x;
double dy_ab = a.y - b.y;
double dx_ac = a.x - c.x;
double dy_ac = a.y - c.y;
if (dx_ac == 0)
{
if (dx_ab == 0)
return true;
return false;
}
if (dy_ac == 0)
{
if (dy_ab == 0)
return true;
return false;
}
double xc = dx_ab / dx_ac;
double yc = dy_ab / dy_ac;
if (xc == yc) return true;
if (err == 0 || (xc * yc < 0)) return false;
double mc = (std::max)(xc, yc);
xc /= mc;
yc /= mc;
double ec = fabs(xc - yc);
return ec <= err;
}
void CSplitSurfaceCommand::Split(CFeature *pFtr, CGeoArray& curves, CUndoFtrs& undo)
{
if(!pFtr || curves.GetSize()<=0) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CFtrLayer *pLayer = pDS->GetFtrLayerOfObject(pFtr);
if(!pLayer) return;
CFeature *pOldFtr = pFtr->Clone();
CFtrArray oldftrs;
oldftrs.Add(pOldFtr);//被分割的面
COsgbView * pView = getView<COsgbView>(PDOC(m_pEditor));
PlaneOrModel plane;
if (pView)
{
bool setModel = true;
CArray<PT_3DEX, PT_3DEX> arrPts;
if (m_bKeepSrcVertexElevtion)
{
pFtr->GetGeometry()->GetShape(arrPts);
plane.setSrcPts(arrPts);
}
if (m_bPlaneFirst)
{
//被分割的面所在的平面(取前三个点构成)
if (arrPts.IsEmpty())
pFtr->GetGeometry()->GetShape(arrPts);
if (arrPts.GetSize() >= 3)
{
PT_3D pts[3];
COPY_3DPT(pts[0], arrPts[0]);
int _Idx = 0;
for (int i = 1; i < arrPts.GetSize(); i++)
{
if (
//与前一点相近的点
(DIST_3DPT(pts[_Idx], arrPts[i]) < 0.1)
// 与前两点在同一直线上的点
|| ((_Idx == 1) && ptsInLine2D(pts[0], pts[1], arrPts[i]))
)
{
// 点之间尽量分散
}
else
_Idx++;
COPY_3DPT(pts[_Idx], arrPts[i]);
if (_Idx == 2) break;
}
if (_Idx == 2)
{
plane.createFrom3Point(pts[0], pts[1], pts[2]);
setModel = false;
}
}
}
if (setModel)
plane.setCOsgbView(pView);
}
bool need_reset_pts = false;
for(int n=0; n<curves.GetSize(); n++)
{
CFeature *pFtr1 = pFtr->Clone();
pFtr1->SetGeometry(curves[n]);
pFtr1->SetID(OUID());
oldftrs.Add(pFtr1);//分割线
// 判断是否所有分割线的点在平面上
if (pView && (!need_reset_pts) && plane.isValid())
{
if (plane.isModel())
{
need_reset_pts = true;
continue;
}
CArray<PT_3DEX, PT_3DEX> arrPts;
curves[n]->GetShape(arrPts);
for (int i = 0; i < arrPts.GetSize(); i++)
{
if (plane.pt_in(arrPts[i],0.1)) continue;
need_reset_pts = true;
break;
}
}
}
if (need_reset_pts)
{
CArray<PT_3DEX, PT_3DEX> arrPts;
pOldFtr->GetGeometry()->GetShape(arrPts);
bool need_reset_ftr = false;
for (int i = 0; i < arrPts.GetSize(); i++)
need_reset_ftr |= plane.pt_projection(arrPts[i]);
// 把原面设为一个平面
if (need_reset_ftr)
{
pOldFtr->GetGeometry()->CreateShape(arrPts.GetData(), arrPts.GetSize());
}
}
//调用非打断构面
CTopoSurfaceNoBreakCommand cmd;
cmd.Init(m_pEditor);
CFtrArray newftrs;//存放旧地物
cmd.BuildSurface(oldftrs, newftrs);
CGeometry *pOldObj = pFtr->GetGeometry();
BOOL bFill = ((CGeoCurveBase*)pOldObj)->IsFillColor();
COLORREF color = ((CGeoCurveBase*)pOldObj)->GetColor();
COLORREF fillcolor = ((CGeoCurveBase*)pOldObj)->GetFillColor();
DWORD transparency = ((CGeoCurveBase*)pOldObj)->GetTransparency();
CFtrArray arrnews;
int nObj = newftrs.GetSize(), i, j, k;
for(i=0; i<nObj; i++)
{
CFeature* pNewFtr = newftrs[i];
//筛选被原面包含的面
PT_3D opt;
pNewFtr->GetGeometry()->GetCenter(NULL, &opt);
if (!pOldFtr->GetGeometry()->bPtIn(&opt))
{
continue;
}
CFeature *pFtr0 = pFtr->Clone();
pFtr0->SetID(OUID());
pFtr0->SetAppFlag(0);
CArray<PT_3DEX, PT_3DEX> arrPts;
pNewFtr->GetGeometry()->GetShape(arrPts);
CGeometry *pObj = pFtr0->GetGeometry();
if (need_reset_pts)
{
for (int idx = 0; idx < arrPts.GetSize(); idx++)
{
PT_3DEX & pt = arrPts[idx];
// 不在平面上的点重置z值到平面上
if (plane.pt_to(pt) > 0)
{
plane.reset_pt_z(pt);
}
}
}
if(!pObj) continue;
if( !pObj->CreateShape(arrPts.GetData(), arrPts.GetSize()) )
{
delete pFtr0;
continue;
}
pObj->SetColor(color);
if(bFill)
{
((CGeoCurveBase*)pObj)->EnableFillColor(bFill, fillcolor);
((CGeoCurveBase*)pObj)->SetTransparency(transparency);
}
if( !m_pEditor->AddObject(pFtr0,pLayer->GetID()) )
{
delete pFtr0;
continue;
}
arrnews.Add(pFtr0);
GETXDS(m_pEditor)->CopyXAttributes(pFtr,pFtr0);
undo.AddNewFeature(FtrToHandle(pFtr0));
}
m_pEditor->DeleteObject(FtrToHandle(pFtr));
undo.AddOldFeature(FtrToHandle(pFtr));
for(i=0; i<newftrs.GetSize(); i++)
{
delete newftrs[i];
}
if(m_nOperMode==1 && m_bKeepSplitLine && !m_strStoreLayer.IsEmpty())
{
CFtrLayer *pLayer = pDS->GetFtrLayer(m_strStoreLayer);
if(!pLayer)
{
pLayer = new CFtrLayer();
pLayer->SetName(m_strStoreLayer);
m_pEditor->AddFtrLayer(pLayer);
}
for(i=0; i<curves.GetSize(); i++)
{
CArray<PT_3DEX,PT_3DEX> pts, pts1;
curves[i]->GetShape(pts);
int nPt = pts.GetSize();
if(nPt<2) continue;
//插入交点
CArray<PtIntersect,PtIntersect> arr;
for(j=0; j<arrnews.GetSize(); j++)
{
CArray<PT_3DEX,PT_3DEX> pts1;
arrnews[j]->GetGeometry()->GetShape(pts1);
GetCurveIntersectCurve(pts.GetData(), pts.GetSize(), pts1.GetData(), pts1.GetSize(), arr);
}
for(j=0; j<nPt; j++)
{
for(k=0; k<arr.GetSize(); k++)
{
if(arr[k].lfRatio<j &&arr[k].IntersectFlag<0)
{
PT_3DEX pt0(arr[k].pt, penLine);
pts1.Add(pt0);
arr[k].IntersectFlag = 1;
}
}
pts1.Add(pts[j]);
}
nPt = GraphAPI::GKickoffSame2DPoints(pts1.GetData(), pts1.GetSize());
pts1.SetSize(nPt);
CArray<int,int> item;
item.SetSize(nPt-1);
for(j=0; j<nPt-1; j++)
{
item[j] = 0;
}
for(j=0; j<nPt-1; j++)
{
PT_3DEX ptcen;
ptcen.x = (pts1[j].x+pts1[j+1].x)/2;
ptcen.y = (pts1[j].y+pts1[j+1].y)/2;
ptcen.z = (pts1[j].z+pts1[j+1].z)/2;
for(int k=0; k<arrnews.GetSize(); k++)
{
CArray<PT_3DEX,PT_3DEX> pts2;
arrnews[k]->GetGeometry()->GetShape(pts2);
if(IsPtInCurve(ptcen, pts2))
{
item[j] = 1;
break;
}
}
}
j=0;
while(j<nPt-1)
{
for(; j<nPt-1 && item[j]==0 ; j++);
CArray<PT_3DEX,PT_3DEX> pts2;
for(; j<nPt-1 && item[j]==1; j++)
{
pts2.Add(pts1[j]);
}
pts2.Add(pts1[j]);
if(pts2.GetSize()>1)
{
CFeature *pNew = pLayer->CreateDefaultFeature(pDS->GetScale(), CLS_GEOCURVE);
pNew->GetGeometry()->CreateShape(pts2.GetData(), pts2.GetSize());
m_pEditor->AddObject(pNew, pLayer->GetID());
undo.AddNewFeature(FtrToHandle(pNew));
}
}
}
}
}
bool GLineIntersectLineSegInLimit(double x0,double y0, double x1, double y1,double x2,double y2,double x3,double y3, double *x, double *y, double *ret_t1, double *ret_t2, double toler)
{
double vector1x = x1-x0, vector1y = y1-y0;
double vector2x = x3-x2, vector2y = y3-y2;
double delta = vector1x*vector2y-vector1y*vector2x;
if( delta<1e-10 && delta>-1e-10 )return false;
double t1 = ( (x2-x0)*vector2y-(y2-y0)*vector2x )/delta;
double xr = x0 + t1*vector1x, yr = y0 + t1*vector1y;
double t2 = ( (x2-x0)*vector1y-(y2-y0)*vector1x )/delta;
if( t1<0 || t1>1 )
{
if( _FABS(xr-x0)<=toler && _FABS(yr-y0)<=toler ) t1=0.0;
else if( _FABS(xr-x1)<=toler && _FABS(yr-y1)<=toler ) t1=1.0;
else
return false;
}
if( t2<0 || t2>1 )
{
if( _FABS(xr-x2)<=toler && _FABS(yr-y2)<=toler ) t2=0.0;
else if( _FABS(xr-x3)<=toler && _FABS(yr-y3)<=toler ) t2=1.0;
else
return false;
}
if(x) *x = xr;
if(y) *y = yr;
if(ret_t1) *ret_t1 = t1;
if(ret_t2) *ret_t2 = t2;
return true;
}
//////////////////////////////////////////////////////////////////////
// CXORSurfaceCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CXORSurfaceCommand,CEditCommand)
CXORSurfaceCommand::CXORSurfaceCommand()
{
m_nStep = -1;
}
CXORSurfaceCommand::~CXORSurfaceCommand()
{
}
CString CXORSurfaceCommand::Name()
{
return StrFromResID(IDS_CMDNAME_XORSURFACE);
}
void CXORSurfaceCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
GOutPut(StrFromResID(IDS_INFO_XORSUFACE1));
m_pEditor->OpenSelector(SELMODE_MULTI);
}
void CXORSurfaceCommand::Abort()
{
CEditCommand::Abort();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
void CXORSurfaceCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
int num ;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if( m_nStep==0 )
{
if( num==1 )
{
GOutPut(StrFromResID(IDS_INFO_XORSUFACE2));
}
else if( num==2 )
{
if( !CanGetSelObjs(flag,FALSE) )return;
CGeometry *pObj1 = HandleToFtr(handles[0])->GetGeometry();
CGeometry *pObj2 = HandleToFtr(handles[1])->GetGeometry();
if( pObj1==NULL || pObj2==NULL )
return;
if( !pObj1->IsKindOf(RUNTIME_CLASS(CGeoSurface)) || !pObj2->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )
return;
GotoState(PROCSTATE_PROCESSING);
m_nStep = 1;
m_pEditor->CloseSelector();
return;
}
}
if( m_nStep==1 && num==2 )
{
CGeoSurface *pObj1 = (CGeoSurface*)HandleToFtr(handles[1])->GetGeometry();
CGeoSurface *pObj2 = (CGeoSurface*)HandleToFtr(handles[0])->GetGeometry();
CArray<CGeoSurface*,CGeoSurface*> arr;
BOOL bRet = XORSurface(pObj1, pObj2, arr);
if(!bRet)
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
for(int i=0; i<arr.GetSize(); i++)
{
CFeature* pFtr = HandleToFtr(handles[1])->Clone();
pFtr->SetID(OUID());
pFtr->SetGeometry(arr[i]);
m_pEditor->AddObject(pFtr,m_pEditor->GetFtrLayerIDOfFtr(handles[1]));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(handles[1]),pFtr);
undo.arrNewHandles.Add(FtrToHandle(pFtr));
}
m_pEditor->DeleteObject(handles[1]);
undo.arrOldHandles.Add(handles[1]);
undo.Commit();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
Finish();
m_nStep = 3;
}
CEditCommand::PtClick(pt,flag);
}
CGeoSurface *NormalizeSurface(CEditor *pEditor, CGeoSurface *pGeo);
BOOL CXORSurfaceCommand::XORSurface(CGeoSurface *pObj1, CGeoSurface *pObj2, CArray<CGeoSurface*,CGeoSurface*>& arr)
{
if(1)
{
if( !m_pEditor )return FALSE;
if( pObj1==NULL || pObj2==NULL )
return FALSE;
if( !pObj1->IsKindOf(RUNTIME_CLASS(CGeoSurface)) || !pObj2->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )
return FALSE;
GotoState(PROCSTATE_PROCESSING);
gsbh::GeoSurfaceBooleanHandle gsbhandle;
if (!gsbhandle.setSurface(pObj1, pObj2))
return FALSE;
//
if(!gsbhandle.init())
return FALSE;
//
gsbhandle.difference();
std::vector<CGeoSurface*> res;
gsbhandle.getResult(res);
for(int i=0; i<res.size(); ++i)
{
CGeoSurface* pNewObj = res[i];
if(pNewObj == NULL)
return FALSE;
//
CArray<PT_3DEX, PT_3DEX> temp_shape;
pNewObj->GetShape(temp_shape);
pNewObj->CopyFrom(pObj1);
pNewObj->CreateShape(temp_shape.GetData(),temp_shape.GetSize());
pNewObj->EnableClose(TRUE);
arr.Add(pNewObj);
}
// CGeoSurface* pNewObj = gsbhandle.getResult();
// if(pNewObj == NULL)
// return FALSE;
// //
// CArray<PT_3DEX, PT_3DEX> temp_shape;
// pNewObj->GetShape(temp_shape);
// pNewObj->CopyFrom(pObj1);
// pNewObj->CreateShape(temp_shape.GetData(),temp_shape.GetSize());
// pNewObj->EnableClose(TRUE);
//
// arr.Add(pNewObj);
return TRUE;
}
if( !m_pEditor )return FALSE;
if( pObj1==NULL || pObj2==NULL )
return FALSE;
if( !pObj1->IsKindOf(RUNTIME_CLASS(CGeoSurface)) || !pObj2->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )
return FALSE;
GotoState(PROCSTATE_PROCESSING);
CGeoSurface *pObj1_new = NormalizeSurface(m_pEditor,pObj1);
CGeoSurface *pObj2_new = NormalizeSurface(m_pEditor,pObj2);
if(pObj1_new==NULL)
pObj1_new = pObj1;
if(pObj2_new==NULL)
pObj2_new = pObj2;
gsbh::GeoSurfaceBooleanHandle gsbhandle;
if (!gsbhandle.setSurface(pObj1_new,pObj2_new))
{
if(pObj1_new!=pObj1)delete pObj1_new;
if(pObj2_new!=pObj2)delete pObj2_new;
return FALSE;
}
//
if(!gsbhandle.init())
{
if(pObj1_new!=pObj1)delete pObj1_new;
if(pObj2_new!=pObj2)delete pObj2_new;
return FALSE;
}
//
gsbhandle.difference();
if(pObj1_new!=pObj1)delete pObj1_new;
if(pObj2_new!=pObj2)delete pObj2_new;
CGeoSurface* pNewObj = gsbhandle.getResult();
if(pNewObj == NULL)
return FALSE;
//
CArray<PT_3DEX, PT_3DEX> temp_shape;
pNewObj->GetShape(temp_shape);
pNewObj->CopyFrom(pObj1);
pNewObj->CreateShape(temp_shape.GetData(),temp_shape.GetSize());
pNewObj->EnableClose(TRUE);
arr.Add(pNewObj);
return TRUE;
}
BOOL CXORSurfaceCommand::XORSurface_BothSimple(CGeoSurface *pObj1, CGeoSurface *pObj2, CArray<CGeoSurface*,CGeoSurface*>& arr)
{
CArray<PT_3DEX,PT_3DEX> pts1,pts2;
pObj1->GetShape()->GetPts(pts1);
pObj2->GetShape()->GetPts(pts2);
int i=0,j=0;
PolygonIntersect::CPolygonWork pw;
for( i=0; i<pts1.GetSize(); i++)
{
pw.add_point(0,pts1[i].x,pts1[i].y,pts1[i].z);
}
for( i=0; i<pts2.GetSize(); i++)
{
if(i!=0 && pts2[i].pencode==penMove) break;//先简单处理
pw.add_point(1,pts2[i].x,pts2[i].y,pts2[i].z);
}
pw.set_overlap(GraphAPI::GetDisTolerance());
pw.initialize();
vector< vector<PolygonIntersect::tpoint> > *pResult = NULL;
//取补集
pw.find_XOR(0,1,1);
pResult = &pw.xor_list;
int error = pw.GetError();
if( error==PolygonIntersect::CPolygonWork::NONE )
{
if( pResult->size()<=0 )
{
return FALSE;
}
CArray<PT_3DEX,PT_3DEX> arrNewPts;
PT_3DEX expt;
expt.pencode = penLine;
for( i=0; i<pResult->size(); i++)
{
vector<PolygonIntersect::tpoint> list1 = pResult->at(i);
if( list1.size()>=3 )
{
arrNewPts.RemoveAll();
for( j=0; j<list1.size(); j++)
{
PolygonIntersect::tpoint tpt = list1[j];
COPY_3DPT(expt,tpt);
arrNewPts.Add(expt);
}
CGeoSurface *pGeo = new CGeoSurface();
if(pGeo && pGeo->CreateShape(arrNewPts.GetData(),arrNewPts.GetSize()) )
{
pGeo->EnableClose(TRUE);
arr.Add(pGeo);
}
else
{
delete pGeo;
}
}
}
return TRUE;
}
else if(error==PolygonIntersect::CPolygonWork::OVERLAP_EXACT )
{
//相交了，结果为空
return FALSE;
}
else if(error==PolygonIntersect::CPolygonWork::NO_INTERSECTION)
{
PT_3D pt0;
COPY_3DPT(pt0, pts2[0]);
if(pObj1->bPtIn(&pt0))
{
CGeoMultiSurface *pMS = new CGeoMultiSurface();
pMS->AddSurface(pts1);
pMS->AddSurface(pts2);
arr.Add(pMS);
return TRUE;
}
}
return FALSE;
}
//暂时不考虑内边界
BOOL CXORSurfaceCommand::XORSurface_Muti_Simple(CGeoMultiSurface *pObj1, CGeoSurface *pObj2, CArray<CGeoSurface*,CGeoSurface*>& arr)
{
CArray<PT_3DEX,PT_3DEX> pts1,pts2;
pObj1->GetShape()->GetPts(pts1);
pObj2->GetShape()->GetPts(pts2);
int i=0,j=0;
int nSurface = pObj1->GetSurfaceNum();
PolygonIntersect::CPolygonWork pw;
for( i=0; i<pts1.GetSize(); i++)
{
if(i!=0 && pts1[i].pencode==penMove) break;//先简单处理
pw.add_point(0,pts1[i].x,pts1[i].y,pts1[i].z);
}
for( i=0; i<pts2.GetSize(); i++)
{
if(i!=0 && pts2[i].pencode==penMove) break;//先简单处理
pw.add_point(1,pts2[i].x,pts2[i].y,pts2[i].z);
}
pw.set_overlap(GraphAPI::GetDisTolerance());
pw.initialize();
vector< vector<PolygonIntersect::tpoint> > *pResult = NULL;
//取补集
pw.find_XOR(0,1,1);
pResult = &pw.xor_list;
int error = pw.GetError();
if( error==PolygonIntersect::CPolygonWork::NONE )
{
if( pResult->size()<=0 )
{
return FALSE;
}
CArray<PT_3DEX,PT_3DEX> arrNewPts;
PT_3DEX expt;
expt.pencode = penLine;
for( i=0; i<pResult->size(); i++)
{
vector<PolygonIntersect::tpoint> list1 = pResult->at(i);
if( list1.size()>=3 )
{
arrNewPts.RemoveAll();
for( j=0; j<list1.size(); j++)
{
PolygonIntersect::tpoint tpt = list1[j];
COPY_3DPT(expt,tpt);
arrNewPts.Add(expt);
}
CGeoMultiSurface *pGeo = new CGeoMultiSurface();
if(pGeo && pGeo->CreateShape(arrNewPts.GetData(),arrNewPts.GetSize()) )
{
pGeo->EnableClose(TRUE);
CArray<PT_3DEX,PT_3DEX> arrPts;
for(j=1; j<nSurface; j++)
{
arrPts.RemoveAll();
pObj1->GetSurface(j, arrPts);
if(2==GraphAPI::GIsPtInRegion(arrPts[0], arrNewPts.GetData(),arrNewPts.GetSize()))
{
pGeo->AddSurface(arrPts);
}
}
arr.Add(pGeo);
}
else
{
delete pGeo;
}
}
}
return TRUE;
}
else if(error==PolygonIntersect::CPolygonWork::OVERLAP_EXACT )
{
//相交了，结果为空
return FALSE;
}
else if(error==PolygonIntersect::CPolygonWork::NO_INTERSECTION)
{
PT_3D pt0;
COPY_3DPT(pt0, pts2[0]);
if(pObj1->bPtIn(&pt0))
{
CGeoMultiSurface *pMS = (CGeoMultiSurface *)pObj1->Clone();
pMS->AddSurface(pts2);
arr.Add(pMS);
return TRUE;
}
}
return FALSE;
}
//////////////////////////////////////////////////////////////////////
// CMergeSurfaceCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CMergeSurfaceCommand,CEditCommand)
CMergeSurfaceCommand::CMergeSurfaceCommand()
{
m_nStep = -1;
}
CMergeSurfaceCommand::~CMergeSurfaceCommand()
{
}
CString CMergeSurfaceCommand::Name()
{
return StrFromResID(IDS_CMDNAME_MERGESURFACE);
}
void CMergeSurfaceCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_strLayerCommonSide.Empty();
m_pEditor->OpenSelector(SELMODE_MULTI);
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>1 )
{
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
m_nExitCode = CMPEC_STARTOLD;
return;
}
}
void CMergeSurfaceCommand::Abort()
{
CEditCommand::Abort();
}
static void FindSameEdgePart(int *buf, int num, int& start, int& end)
{
int i, i1;
//找到任一个非公共点
for( i=0; i<num; i++)
{
if( buf[i]==0 )break;
}
//无公共点
if( i>=num )
{
start = end = 0;
return;
}
//找到下一个公共点，此点可以认为是非公共部分的末点
for( i1=i+1; i1<num+i; i1++)
{
if( buf[(i1%num)]!=0 )break;
}
end = (i1%num);
//找到下一个非公共点，此点的前一点可以认为是非公共部分的起点
for( ; i1<=num+i; i1++)
{
if( buf[((i1+1)%num)]==0 )break;
}
start = (i1%num);
}
//获得对象中在start和end之间的点，如果start>end，那么，获得的点是包括对象的首尾点的
static void GetObjectPart(CGeometry* pObj, int start, int end, CArray<PT_3DEX,PT_3DEX>& arrPts)
{
CArray<PT_3DEX,PT_3DEX> arr;
pObj->GetShape(arr);
int nPtSum = arr.GetSize();
PT_3DEX expt;
if( end<start )end += nPtSum;
for( int i=start; i<=end; i++)
{
expt = arr[i%nPtSum];
arrPts.Add(expt);
}
}
static BOOL IsSameShape(CArray<PT_3DEX,PT_3DEX>& pts1, CArray<PT_3DEX,PT_3DEX>& pts2)
{
CArray<PT_3DEX,PT_3DEX> arrPts1, arrPts2;
arrPts1.Copy(pts1);
arrPts2.Copy(pts2);
int nsz1 = GraphAPI::GKickoffSamePoints(arrPts1.GetData(),arrPts1.GetSize());
arrPts1.SetSize(nsz1);
int nsz2 = GraphAPI::GKickoffSamePoints(arrPts2.GetData(),arrPts2.GetSize());
arrPts2.SetSize(nsz2);
if( nsz1!=nsz2 )
return FALSE;
if( nsz1<=0 )
return FALSE;
BOOL bClose1 = ((nsz1>1 && GraphAPI::GIsEqual2DPoint(&arrPts1[0],&arrPts1[nsz1-1]))?TRUE:FALSE);
BOOL bClose2 = ((nsz1>1 && GraphAPI::GIsEqual2DPoint(&arrPts2[0],&arrPts2[nsz1-1]))?TRUE:FALSE);
if( bClose1!=bClose2 )
return FALSE;
PT_3DEX expt1, expt2;
double toler = GraphAPI::g_lfDisTolerance;
if(bClose1)
{
nsz1--;
for(int off=0; off<nsz1; off++)
{
for(int i=0; i<nsz1; i++)
{
expt1 = arrPts1[i];
expt2 = arrPts2[((off+i)%nsz1)];
if( (fabs(expt1.x-expt2.x)>toler || fabs(expt1.y-expt2.y)>toler) )
{
break;
}
}
if(i>=nsz1)
return TRUE;
}
for(off=0; off<nsz1; off++)
{
for(int i=0; i<nsz1; i++)
{
expt1 = arrPts1[i];
expt2 = arrPts2[((off+nsz1-i)%nsz1)];
if( (fabs(expt1.x-expt2.x)>toler || fabs(expt1.y-expt2.y)>toler) )
{
break;
}
}
if(i>=nsz1)
return TRUE;
}
}
else
{
for(int i=0; i<nsz1; i++)
{
expt1 = arrPts1[i];
expt2 = arrPts2[i];
if( (fabs(expt1.x-expt2.x)>toler || fabs(expt1.y-expt2.y)>toler) )
{
break;
}
}
if(i>=nsz1)
return TRUE;
for(i=0; i<nsz1; i++)
{
expt1 = arrPts1[i];
expt2 = arrPts2[nsz1-1-i];
if( (fabs(expt1.x-expt2.x)>toler || fabs(expt1.y-expt2.y)>toler) )
{
break;
}
}
if(i>=nsz1)
return TRUE;
}
return FALSE;
}
static BOOL IsSameShape(CGeometry *pObj1, CGeometry *pObj2)
{
CArray<PT_3DEX,PT_3DEX> arrPts1, arrPts2;
pObj1->GetShape(arrPts1);
pObj2->GetShape(arrPts2);
return IsSameShape(arrPts1,arrPts2);
}
static BOOL IsPartShape(CArray<PT_3DEX,PT_3DEX>& pts1, CArray<PT_3DEX,PT_3DEX>& pts2)
{
CArray<PT_3DEX,PT_3DEX> arrPts1, arrPts2;
arrPts1.Copy(pts1);
arrPts2.Copy(pts2);
int nsz1 = GraphAPI::GKickoffSamePoints(arrPts1.GetData(),arrPts1.GetSize());
arrPts1.SetSize(nsz1);
int nsz2 = GraphAPI::GKickoffSamePoints(arrPts2.GetData(),arrPts2.GetSize());
arrPts2.SetSize(nsz2);
if( nsz1<=0 || nsz2<=0 )
return FALSE;
if(nsz1<nsz2)
return FALSE;
double toler = GraphAPI::g_lfDisTolerance;
{
//首尾端点必须相同
int npt = nsz2;
PT_3DEX expt1, expt2, expt3;
BOOL bSame1 = FALSE, bSame2 = FALSE;
expt1 = arrPts1[0];
expt2 = arrPts2[0];
expt3 = arrPts2[npt-1];
if( (fabs(expt1.x-expt2.x)<toler && fabs(expt1.y-expt2.y)<toler) )
{
bSame1 = TRUE;
}
if( (fabs(expt1.x-expt3.x)<toler && fabs(expt1.y-expt3.y)<toler) )
{
bSame2 = TRUE;
}
if( !bSame1 && !bSame2 )
return FALSE;
//其他节点必须相同
if( bSame1 )
{
//顺序比较
for( int i=1; i<npt; i++ )
{
expt1 = arrPts1[i];
expt2 = arrPts2[i];
if( (fabs(expt1.x-expt2.x)<toler && fabs(expt1.y-expt2.y)<toler) )
{
}
else
{
break;
}
}
if( i<npt )return FALSE;
else
return TRUE;
}
else
{
//反序比较
for( int i=1; i<npt; i++ )
{
expt1 = arrPts1[i];
expt2 = arrPts2[npt-1-i];
if( (fabs(expt1.x-expt2.x)<toler && fabs(expt1.y-expt2.y)<toler) )
{
}
else
{
break;
}
}
if( i<npt )return FALSE;
else
return TRUE;
}
}
}
BOOL CMergeSurfaceCommand::FindSameEdgeObj(CArray<PT_3DEX,PT_3DEX>& arrPts, CFtrArray& arrFtrs)
{
Envelope e;
e.CreateFromPtAndRadius(arrPts[0],GraphAPI::g_lfDisTolerance);
m_pEditor->GetDataQuery()->FindObjectInRect(e,NULL);
int num = 0;
const CPFeature * ftrs0 = m_pEditor->GetDataQuery()->GetFoundHandles(num);
if( num<2 )
{
return FALSE;
}
if(num==2)
{
return TRUE;//没有其他公共边，只有要合并的两个面时，直接返回
}
//后面有递归调用，会覆盖 GetFoundHandles 的结果，所以这里将结果复制出来
CArray<CPFeature,CPFeature> ftrs;
ftrs.SetSize(num);
memcpy(ftrs.GetData(),ftrs0,sizeof(CPFeature)*num);
for(int i=0; i<num; i++)
{
CGeometry *pGeo = ftrs[i]->GetGeometry();
CArray<PT_3DEX,PT_3DEX> arrPts2;
pGeo->GetShape(arrPts2);
if(IsPartShape(arrPts,arrPts2) && CAutoLinkContourCommand::CheckObjForLayerCode(PDOC(m_pEditor)->GetDlgDataSource(),ftrs[i],m_strLayerCommonSide) )
{
if(arrPts.GetSize()==arrPts2.GetSize())
{
arrFtrs.Add(ftrs[i]);
return TRUE;
}
else
{
//取出后面一部分，递归查找
//公共边有可能是多个线串衔接起来的
CArray<PT_3DEX,PT_3DEX> arrPts3;
arrPts3.Copy(arrPts);
arrPts3.RemoveAt(0,arrPts2.GetSize()-1);
if(arrPts3.GetSize()>1)
{
CFtrArray ftrs2;
if( FindSameEdgeObj(arrPts3,ftrs2) )
{
arrFtrs.Add(ftrs[i]);
arrFtrs.Append(ftrs2);
return TRUE;
}
}
}
}
}
return FALSE;
}
CGeoSurface *CMergeSurfaceCommand::MergeSurface(CGeoSurface *pObj1, CGeoSurface *pObj2, CFtrArray& commonsideFtrs)
{
Envelope e1 = pObj1->GetEnvelope();
Envelope e2 = pObj2->GetEnvelope();
Envelope e3 = e1;
e3.Intersect(&e2);
double toler = GraphAPI::g_lfDisTolerance;
if( (e3.m_xl-e3.m_xh)>toler || (e3.m_yl-e3.m_yh>toler) )
return NULL;
CGeoSurface *pObj1_old = pObj1;
CGeoSurface *pObj2_old = pObj2;
pObj1 = NormalizeSurface(m_pEditor,pObj1);
pObj2 = NormalizeSurface(m_pEditor,pObj2);
// pObj1 = NULL;
// pObj2 = NULL;
if(pObj1==NULL)
pObj1 = pObj1_old;
if(pObj2==NULL)
pObj2 = pObj2_old;
CGeoSurface *pRetObj = NULL;
if( pObj1->IsKindOf(RUNTIME_CLASS(CGeoMultiSurface)) && pObj2->IsKindOf(RUNTIME_CLASS(CGeoMultiSurface)) )
{
pRetObj = MergeSurface_BothMulti((CGeoMultiSurface*)pObj1,(CGeoMultiSurface*)pObj2,commonsideFtrs);
}
else if( pObj1->IsKindOf(RUNTIME_CLASS(CGeoMultiSurface)) && pObj2->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )
{
CGeoMultiSurface *pObj3 = new CGeoMultiSurface();
pObj3->CopyFrom(pObj2);
CArray<PT_3DEX,PT_3DEX> arr;
pObj2->GetShape(arr);
pObj3->CreateShape(arr.GetData(),arr.GetSize());
CGeoSurface *pNewObj = MergeSurface_BothMulti((CGeoMultiSurface*)pObj1,(CGeoMultiSurface*)pObj3,commonsideFtrs);
delete pObj3;
pRetObj = pNewObj;
}
else if( pObj2->IsKindOf(RUNTIME_CLASS(CGeoMultiSurface)) && pObj1->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )
{
CGeoMultiSurface *pObj3 = new CGeoMultiSurface();
pObj3->CopyFrom(pObj1);
CArray<PT_3DEX,PT_3DEX> arr;
pObj1->GetShape(arr);
pObj3->CreateShape(arr.GetData(),arr.GetSize());
CGeoSurface *pNewObj = MergeSurface_BothMulti((CGeoMultiSurface*)pObj3,(CGeoMultiSurface*)pObj2,commonsideFtrs);
delete pObj3;
pRetObj = pNewObj;
}
else
{
pRetObj = MergeSurface_BothSimple(pObj1,pObj2,commonsideFtrs);
}
if(pObj1_old!=pObj1)delete pObj1;
if(pObj2_old!=pObj2)delete pObj2;
return pRetObj;
}
CGeoSurface *CMergeSurfaceCommand::MergeSurface_new(CGeoSurface *pObj1, CGeoSurface *pObj2, CFtrArray& commonsideFtrs)
{
Envelope e1 = pObj1->GetEnvelope();
Envelope e2 = pObj2->GetEnvelope();
Envelope e3 = e1;
e3.Intersect(&e2);
double toler = GraphAPI::g_lfDisTolerance;
if( (e3.m_xl-e3.m_xh)>toler || (e3.m_yl-e3.m_yh>toler) )
return NULL;
if( pObj1==NULL || pObj2==NULL )
return NULL;
if( !pObj1->IsKindOf(RUNTIME_CLASS(CGeoSurface)) || !pObj2->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )
return NULL;
CGeoSurface *pObj1_new = NormalizeSurface(m_pEditor,pObj1);
CGeoSurface *pObj2_new = NormalizeSurface(m_pEditor,pObj2);
if(pObj1_new==NULL || pObj2_new==NULL)
{
if(pObj1_new!=NULL)delete pObj1_new;
if(pObj2_new!=NULL)delete pObj2_new;
return FALSE;
}
// CGeoSurface *pObj1_new = NULL;
// CGeoSurface *pObj2_new = NULL;
if(pObj1_new==NULL)
pObj1_new = pObj1;
if(pObj2_new==NULL)
pObj2_new = pObj2;
gsbh::GeoSurfaceBooleanHandle gsbhandle;
if(!gsbhandle.setSurface(pObj2_new,pObj1_new))
{
if(pObj1_new!=pObj1)delete pObj1_new;
if(pObj2_new!=pObj2)delete pObj2_new;
return FALSE;
}
//
if(!gsbhandle.init())
{
if(pObj1_new!=pObj1)delete pObj1_new;
if(pObj2_new!=pObj2)delete pObj2_new;
return FALSE;
}
//
gsbhandle.join();
CGeoSurface* pNewObj = gsbhandle.getResult();
if(pObj1_new!=pObj1)delete pObj1_new;
if(pObj2_new!=pObj2)delete pObj2_new;
if(pNewObj == NULL)
return NULL;
//
CArray<PT_3DEX, PT_3DEX> temp_shape;
pNewObj->GetShape(temp_shape);
pNewObj->CopyFrom(pObj1);
pNewObj->CreateShape(temp_shape.GetData(), temp_shape.GetSize());
return pNewObj;
}
BOOL CMergeSurfaceCommand::FindSameEdgeObj(CGeoSurface *pObj1, CGeoSurface *pObj2, CFtrArray& commonsideFtrs)
{
if(m_strLayerCommonSide.GetLength()<=0)
return FALSE;
Envelope e1 = pObj1->GetEnvelope();
Envelope e2 = pObj2->GetEnvelope();
Envelope e3 = e1;
e3.Intersect(&e2);
if(e3.m_xl>e3.m_xh || e3.m_yl>e3.m_yh )
return FALSE;
pObj1 = (CGeoSurface*)pObj1->Clone();
pObj2 = (CGeoSurface*)pObj2->Clone();
CArray<PT_3DEX,PT_3DEX> arr1, arr2;
pObj1->GetShape(arr1);
pObj2->GetShape(arr2);
int npt1 = GraphAPI::GKickoffSame2DPoints(arr1.GetData(),arr1.GetSize());
arr1.SetSize(npt1);
int npt2 = GraphAPI::GKickoffSame2DPoints(arr2.GetData(),arr2.GetSize());
arr2.SetSize(npt2);
pObj1->CreateShape(arr1.GetData(),arr1.GetSize());
pObj2->CreateShape(arr2.GetData(),arr2.GetSize());
int nPtSum1 = arr1.GetSize(), nPtSum2 = arr2.GetSize(), count = 1;
int nSamePtPos;
CArray<int,int> pos1, pos2;
pos1.SetSize(nPtSum1);
pos2.SetSize(nPtSum2);
//找到点重叠的部分，并设置标志位
int *buf1 = pos1.GetData(), *buf2 = pos2.GetData();
memset(buf1,0,sizeof(int)*nPtSum1);
memset(buf2,0,sizeof(int)*nPtSum2);
if (pObj1->IsClosed())
{
nPtSum1--;
}
if (pObj2->IsClosed())
{
nPtSum2--;
}
PT_3DEX expt;
double tolerance = GraphAPI::g_lfDisTolerance;
for( int i=0; i<nPtSum1; i++)
{
expt = arr1[i];
if (i != 0 && GraphAPI::GIsEqual2DPoint(&expt,&arr1[i-1]) )
{
if (buf1[i-1] != 0)
{
buf1[i] = buf1[i-1];
buf1[i-1] = 0;
}
continue;
}
if(!e2.bPtIn(&expt))
continue;
PT_3D p0,p1;
COPY_3DPT(p0,expt);
// m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&p0,&p1);
PT_KEYCTRL pos;
pos = pObj2->FindNearestKeyCtrlPt(p0,tolerance,NULL,1);
if (pos.IsValid())
{
for (int j=pos.index; j<nPtSum2-1; j++)
{
if (!GraphAPI::GIsEqual2DPoint(&arr2[j],&arr2[j+1]))
{
break;
}
}
nSamePtPos = j;
buf1[i] = count;
buf2[nSamePtPos] = count;
count++;
}
}
int start1, end1, start2, end2;
//获得非公共边的部分，但是包括了公共边的起点和末点
FindSameEdgePart(buf1,nPtSum1,start1,end1);
FindSameEdgePart(buf2,nPtSum2,start2,end2);
//有问题的公共边
if( (start1==end1) || (start2==end2) ||
(buf1[start1]!=buf2[start2] && buf1[start1]!=buf2[end2]) ||
(buf1[end1]!=buf2[start2] && buf1[end1]!=buf2[end2]) )
{
delete pObj1;
delete pObj2;
return FALSE;
}
//找公共边，看它是否符合要求
//获取公共部分
CArray<PT_3DEX,PT_3DEX> arrPts1;
GetObjectPart(pObj1,end1,start1,arrPts1);
int npt3 = GraphAPI::GKickoffSame2DPoints(arrPts1.GetData(),arrPts1.GetSize());
arrPts1.SetSize(npt3);
BOOL bRet = FindSameEdgeObj(arrPts1,commonsideFtrs);
delete pObj1;
delete pObj2;
return bRet;
}
CGeoSurface *CMergeSurfaceCommand::MergeSurface_BothSimple(CGeoSurface *pObj1, CGeoSurface *pObj2, CFtrArray& commonsideFtrs)
{
CArray<CGeoSurface*,CGeoSurface*> arrRets;
BOOL bRet = MergeSurface_BothSimple_LogicUnion(pObj1,pObj2,arrRets);
if( bRet && arrRets.GetSize()>0 )
{
CGeoMultiSurface *pObj3 = new CGeoMultiSurface();
pObj3->CopyFrom(pObj1);
CArray<PT_3DEX,PT_3DEX> arr_all, arr;
double area_max = -1;
int k = -1;
for(int i=0; i<arrRets.GetSize(); i++)
{
if(area_max<arrRets[i]->GetArea())
{
area_max = arrRets[i]->GetArea();
k = i;
}
}
if(k>=0)
{
arrRets[k]->GetShape(arr);
arr_all.Append(arr);
}
for(i=0; i<arrRets.GetSize(); i++)
{
if(k==i)continue;
arr.RemoveAll();
arrRets[i]->GetShape(arr);
arr[0].pencode = penMove;
arr_all.Append(arr);
}
pObj3->CreateShape(arr_all.GetData(),arr_all.GetSize());
pObj3->NormalizeDirection();
return pObj3;
}
else
{
return NULL;
}
Envelope e1 = pObj1->GetEnvelope();
Envelope e2 = pObj2->GetEnvelope();
Envelope e3 = e1;
e3.Intersect(&e2);
if(e3.m_xl>e3.m_xh || e3.m_yl>e3.m_yh )
return NULL;
pObj1 = (CGeoSurface*)pObj1->Clone();
pObj2 = (CGeoSurface*)pObj2->Clone();
CArray<PT_3DEX,PT_3DEX> arr1, arr2;
pObj1->GetShape(arr1);
pObj2->GetShape(arr2);
int npt1 = GraphAPI::GKickoffSame2DPoints(arr1.GetData(),arr1.GetSize());
arr1.SetSize(npt1);
int npt2 = GraphAPI::GKickoffSame2DPoints(arr2.GetData(),arr2.GetSize());
arr2.SetSize(npt2);
pObj1->CreateShape(arr1.GetData(),arr1.GetSize());
pObj2->CreateShape(arr2.GetData(),arr2.GetSize());
int nPtSum1 = arr1.GetSize(), nPtSum2 = arr2.GetSize(), count = 1;
int nSamePtPos;
CArray<int,int> pos1, pos2;
pos1.SetSize(nPtSum1);
pos2.SetSize(nPtSum2);
//找到点重叠的部分，并设置标志位
int *buf1 = pos1.GetData(), *buf2 = pos2.GetData();
memset(buf1,0,sizeof(int)*nPtSum1);
memset(buf2,0,sizeof(int)*nPtSum2);
if (pObj1->IsClosed())
{
nPtSum1--;
}
if (pObj2->IsClosed())
{
nPtSum2--;
}
PT_3DEX expt;
double tolerance = GraphAPI::g_lfDisTolerance;
for( int i=0; i<nPtSum1; i++)
{
expt = arr1[i];
if (i != 0 && GraphAPI::GIsEqual2DPoint(&expt,&arr1[i-1]) )
{
if (buf1[i-1] != 0)
{
buf1[i] = buf1[i-1];
buf1[i-1] = 0;
}
continue;
}
if(!e2.bPtIn(&expt))
continue;
PT_3D p0,p1;
COPY_3DPT(p0,expt);
// m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&p0,&p1);
PT_KEYCTRL pos;
pos = pObj2->FindNearestKeyCtrlPt(p0,tolerance,NULL,1);
if (pos.IsValid())
{
for (int j=pos.index; j<nPtSum2-1; j++)
{
if (!GraphAPI::GIsEqual2DPoint(&arr2[j],&arr2[j+1]))
{
break;
}
}
nSamePtPos = j;
buf1[i] = count;
buf2[nSamePtPos] = count;
count++;
}
}
int start1, end1, start2, end2;
//获得非公共边的部分，但是包括了公共边的起点和末点
FindSameEdgePart(buf1,nPtSum1,start1,end1);
FindSameEdgePart(buf2,nPtSum2,start2,end2);
//有问题的公共边
if( (start1==end1) || (start2==end2) ||
(buf1[start1]!=buf2[start2] && buf1[start1]!=buf2[end2]) ||
(buf1[end1]!=buf2[start2] && buf1[end1]!=buf2[end2]) )
{
delete pObj1;
delete pObj2;
return NULL;
}
//找公共边，看它是否符合要求
if(m_strLayerCommonSide.GetLength()>0)
{
//获取公共部分
CArray<PT_3DEX,PT_3DEX> arrPts1;
GetObjectPart(pObj1,end1,start1,arrPts1);
int npt3 = GraphAPI::GKickoffSame2DPoints(arrPts1.GetData(),arrPts1.GetSize());
arrPts1.SetSize(npt3);
if(!FindSameEdgeObj(arrPts1,commonsideFtrs))
{
delete pObj1;
delete pObj2;
return NULL;
}
}
//获取非公共部分
CArray<PT_3DEX,PT_3DEX> arrPts1, arrPts2;
GetObjectPart(pObj1,start1,end1,arrPts1);
GetObjectPart(pObj2,start2,end2,arrPts2);
//调整顺序
if( buf1[end1]!=buf2[start2] )
{
int size = arrPts2.GetSize();
for( i=0; i<size/2; i++)
{
expt = arrPts2.GetAt(i);
arrPts2.SetAt(i,arrPts2.GetAt(size-1-i));
arrPts2.SetAt(size-1-i,expt);
}
}
//添加节点
CArray<PT_3DEX,PT_3DEX> arr;
arr.Append(arrPts1);
arrPts2.RemoveAt(0);
arr.Append(arrPts2);
int npt3 = GraphAPI::GKickoffSame2DPoints(arr.GetData(),arr.GetSize());
arr.SetSize(npt3);
//建立新对象
CGeoSurface *pNewObj = (CGeoSurface*)pObj1->Clone();
pNewObj->CreateShape(arr.GetData(),arr.GetSize());
delete pObj1;
delete pObj2;
return pNewObj;
}
BOOL CMergeSurfaceCommand::MergeSurface_BothSimple_LogicUnion(CGeoSurface *pObj1, CGeoSurface *pObj2, CArray<CGeoSurface*,CGeoSurface*>& arrRets)
{
Envelope e1 = pObj1->GetEnvelope();
Envelope e2 = pObj2->GetEnvelope();
Envelope e3 = e1;
e3.Intersect(&e2);
if(e3.m_xl>e3.m_xh || e3.m_yl>e3.m_yh )
return FALSE;
PolygonIntersect::CPolygonWork pw;
CArray<PT_3DEX,PT_3DEX> arrPts1, arrPts2;
pObj1->GetShape()->GetPts(arrPts1);
pObj2->GetShape()->GetPts(arrPts2);
int i, j;
for( i=0; i<arrPts1.GetSize(); i++)
{
pw.add_point(0,arrPts1[i].x,arrPts1[i].y,arrPts1[i].z);
}
for( i=0; i<arrPts2.GetSize(); i++)
{
pw.add_point(1,arrPts2[i].x,arrPts2[i].y,arrPts2[i].z);
}
pw.set_overlap(GraphAPI::GetDisTolerance());
pw.initialize();
vector< vector<PolygonIntersect::tpoint> > *pResult = NULL;
pw.find_union();
pResult = &pw.union_list;
int error = pw.GetError();
if( error==PolygonIntersect::CPolygonWork::NONE )
{
if( pResult->size()<=0 )
{
return FALSE;
}
CArray<PT_3DEX,PT_3DEX> arrNewPts;
PT_3DEX expt;
expt.pencode = penLine;
for( i=0; i<pResult->size(); i++)
{
vector<PolygonIntersect::tpoint> list1 = pResult->at(i);
if( list1.size()>=3 )
{
//创建模板对象
CGeoSurface *pNew = (CGeoSurface*)pObj1->Clone();
if(!pNew)continue;
arrNewPts.RemoveAll();
for( j=0; j<list1.size(); j++)
{
PolygonIntersect::tpoint tpt = list1[j];
COPY_3DPT(expt,tpt);
arrNewPts.Add(expt);
}
pNew->CreateShape(arrNewPts.GetData(),arrNewPts.GetSize());
pNew->EnableClose(TRUE);
arrRets.Add(pNew);
}
}
}
else if(error==PolygonIntersect::CPolygonWork::OVERLAP_EXACT )
{
arrRets.Add((CGeoSurface*)pObj1->Clone());
return TRUE;
}
return TRUE;
}
BOOL CMergeSurfaceCommand::MergeSurface_BothSimple_LogicSubtract(CGeoSurface *pObj1, CGeoSurface *pObj2, CArray<CGeoSurface*,CGeoSurface*>& arrRets)
{
Envelope e1 = pObj1->GetEnvelope();
Envelope e2 = pObj2->GetEnvelope();
Envelope e3 = e1;
e3.Intersect(&e2);
if(e3.m_xl>e3.m_xh || e3.m_yl>e3.m_yh )
return FALSE;
PolygonIntersect::CPolygonWork pw;
CArray<PT_3DEX,PT_3DEX> arrPts1, arrPts2;
pObj1->GetShape()->GetPts(arrPts1);
pObj2->GetShape()->GetPts(arrPts2);
int i, j;
for( i=0; i<arrPts1.GetSize(); i++)
{
pw.add_point(0,arrPts1[i].x,arrPts1[i].y,arrPts1[i].z);
}
for( i=0; i<arrPts2.GetSize(); i++)
{
pw.add_point(1,arrPts2[i].x,arrPts2[i].y,arrPts2[i].z);
}
pw.set_overlap(GraphAPI::GetDisTolerance());
pw.initialize();
vector< vector<PolygonIntersect::tpoint> > *pResult = NULL;
pw.find_XOR(0,1,1);
pResult = &pw.xor_list;
int error = pw.GetError();
if( error==PolygonIntersect::CPolygonWork::NONE )
{
//等同于不相交
if( pResult->size()<=0 )
{
return FALSE;
}
CArray<PT_3DEX,PT_3DEX> arrNewPts;
PT_3DEX expt;
expt.pencode = penLine;
for( i=0; i<pResult->size(); i++)
{
vector<PolygonIntersect::tpoint> list1 = pResult->at(i);
if( list1.size()>=3 )
{
//创建模板对象
CGeoSurface *pNew = (CGeoSurface*)pObj1->Clone();
if(!pNew)continue;
arrNewPts.RemoveAll();
for( j=0; j<list1.size(); j++)
{
PolygonIntersect::tpoint tpt = list1[j];
COPY_3DPT(expt,tpt);
arrNewPts.Add(expt);
}
pNew->CreateShape(arrNewPts.GetData(),arrNewPts.GetSize());
pNew->EnableClose(TRUE);
arrRets.Add(pNew);
}
}
return TRUE;
}
else if(error==PolygonIntersect::CPolygonWork::OVERLAP_EXACT )
{
//相交了，结果为空
return TRUE;
}
return FALSE;
}
BOOL CMergeSurfaceCommand::MergeSurface_BothSimple_LogicIntersect(CGeoSurface *pObj1, CGeoSurface *pObj2, CArray<CGeoSurface*,CGeoSurface*>& arrRets)
{
Envelope e1 = pObj1->GetEnvelope();
Envelope e2 = pObj2->GetEnvelope();
Envelope e3 = e1;
e3.Intersect(&e2);
if(e3.m_xl>e3.m_xh || e3.m_yl>e3.m_yh )
return FALSE;
PolygonIntersect::CPolygonWork pw;
CArray<PT_3DEX,PT_3DEX> arrPts1, arrPts2;
pObj1->GetShape()->GetPts(arrPts1);
pObj2->GetShape()->GetPts(arrPts2);
int i, j;
for( i=0; i<arrPts1.GetSize(); i++)
{
pw.add_point(0,arrPts1[i].x,arrPts1[i].y,arrPts1[i].z);
}
for( i=0; i<arrPts2.GetSize(); i++)
{
pw.add_point(1,arrPts2[i].x,arrPts2[i].y,arrPts2[i].z);
}
pw.set_overlap(GraphAPI::GetDisTolerance());
pw.initialize();
vector< vector<PolygonIntersect::tpoint> > *pResult = NULL;
pw.find_intersection();
pResult = &pw.intersection_list;
int error = pw.GetError();
if( error==PolygonIntersect::CPolygonWork::NONE )
{
//等同于不相交
if( pResult->size()<=0 )
{
return FALSE;
}
CArray<PT_3DEX,PT_3DEX> arrNewPts;
PT_3DEX expt;
expt.pencode = penLine;
for( i=0; i<pResult->size(); i++)
{
vector<PolygonIntersect::tpoint> list1 = pResult->at(i);
if( list1.size()>=3 )
{
//创建模板对象
CGeoSurface *pNew = (CGeoSurface*)pObj1->Clone();
if(!pNew)continue;
arrNewPts.RemoveAll();
for( j=0; j<list1.size(); j++)
{
PolygonIntersect::tpoint tpt = list1[j];
COPY_3DPT(expt,tpt);
arrNewPts.Add(expt);
}
pNew->CreateShape(arrNewPts.GetData(),arrNewPts.GetSize());
pNew->EnableClose(TRUE);
arrRets.Add(pNew);
}
}
return TRUE;
}
else if(error==PolygonIntersect::CPolygonWork::OVERLAP_EXACT )
{
arrRets.Add((CGeoSurface*)pObj1->Clone());
return TRUE;
}
return FALSE;
}
//判断面包含
static bool IsSurfaceInclude(CGeoSurface* pObj1, CGeoSurface* pObj2, BOOL& bReverse)
{
Envelope e1 = pObj1->GetEnvelope();
Envelope e2 = pObj2->GetEnvelope();
Envelope e3 = e1;
bReverse = FALSE;
if(e1.bEnvelopeIn(&e2))
{
}
else if(e2.bEnvelopeIn(&e1))
{
CGeoSurface* pObj = pObj1;
pObj1 = pObj2;
pObj2 = pObj;
bReverse = TRUE;
}
else
{
return false;
}
CArray<PT_3DEX, PT_3DEX> arrPts1, arrPts2;
pObj1->GetShape()->GetPts(arrPts1);
pObj2->GetShape()->GetPts(arrPts2);
for (int i=0; i<arrPts2.GetSize(); i++)
{
int temp = GraphAPI::GIsPtInRegion(arrPts2[i],arrPts1.GetData(),arrPts1.GetSize());
if (2==temp||0==temp||1==temp)
{
;
}
else
break;
}
if(i==arrPts2.GetSize())
{
return true;
}
return false;
}
void CMergeSurfaceCommand::CalcSurfaceFlags(CArray<CGeoSurface*,CGeoSurface*>& arrObjs, CArray<int,int>& flags)
{
//判断边界的性质，1表示外边界，0表示内边界，方法是当该面的某个顶点落在除该面以外的所有其他子面内部的次数为偶数时，为外边界，奇数时为内边界；
CArray<PT_3DEX,PT_3DEX> arrPts;
for(int i=0; i<arrObjs.GetSize(); i++)
{
CGeoSurface *pObj = arrObjs[i];
CArray<PT_3DEX,PT_3DEX> arrPts1;
pObj->GetShape(arrPts1);
int npt = arrPts1.GetSize();
int count = 0;
for(int k=0; k<npt; k++)
{
PT_3DEX pt0 = arrPts1[k];
BOOL bOnEdge = FALSE;
count = 0;
for(int j=0; j<arrObjs.GetSize(); j++)
{
if(j==i)continue;
arrPts.RemoveAll();
arrObjs[j]->GetShape()->GetPts(arrPts);
int ret = GraphAPI::GIsPtInRegion(pt0,arrPts.GetData(),arrPts.GetSize());
if(ret==2)
{
count++;
}
else if(ret==1)
{
bOnEdge = TRUE;
break;
}
}
//如果该点落在其他边界上，判断会失效，就需要判断其他点
if(!bOnEdge)
break;
}
flags.Add((count%2)==0?1:0);
}
}
//都是复杂面对象
CGeoSurface *CMergeSurfaceCommand::MergeSurface_BothMulti_Logic(CGeoMultiSurface *pObj1, CGeoMultiSurface *pObj2)
{
Envelope e1 = pObj1->GetEnvelope();
Envelope e2 = pObj2->GetEnvelope();
Envelope e3 = e1;
e3.Intersect(&e2);
if(e3.m_xl>e3.m_xh || e3.m_yl>e3.m_yh )
return NULL;
BOOL bModified_whole = FALSE;
int nSon1 = pObj1->GetSurfaceNum();
int nSon2 = pObj2->GetSurfaceNum();
//思路：1、首先判断边界的性质，是外边界还是内边界；
//2、将外边界与外边界合并，内边界与内边界合并，外边界与内边界做逻辑加法运算；
//3、再作包含关系的判定，外边界邻近包含外边界时，去掉较小的外边界，内边界邻近包含内边界时，去掉较大的内边界；
//所谓邻近包含是指：不存在越级包含，比如A包含B，B包含C，那么A包含C就是越级包含；
//4、当2和3都对数据没有任何改动时，表明合并失败；
//下面是实现
//1、生成各个子面对象
int i, j, k;
CArray<CGeoSurface*,CGeoSurface*> sonSurfaces1, sonSurfaces2;
CArray<PT_3DEX,PT_3DEX> arrPts;
for(i=0; i<nSon1; i++)
{
arrPts.RemoveAll();
CGeoSurface *pObj = new CGeoSurface();
pObj1->GetSurface(i,arrPts);
if(arrPts.GetSize()<3)
continue;
pObj->CreateShape(arrPts.GetData(),arrPts.GetSize());
sonSurfaces1.Add(pObj);
}
for(i=0; i<nSon2; i++)
{
arrPts.RemoveAll();
CGeoSurface *pObj = new CGeoSurface();
pObj2->GetSurface(i,arrPts);
if(arrPts.GetSize()<3)
continue;
pObj->CreateShape(arrPts.GetData(),arrPts.GetSize());
sonSurfaces2.Add(pObj);
}
//2、判断边界的性质，1表示外边界，0表示内边界，方法是当该面的某个顶点落在除该面以外的所有其他子面内部的次数为偶数时，为外边界，奇数时为内边界；
CArray<int,int> sonSurfaceFlags1,sonSurfaceFlags2;
CalcSurfaceFlags(sonSurfaces1,sonSurfaceFlags1);
CalcSurfaceFlags(sonSurfaces2,sonSurfaceFlags2);
//3、将外边界与外边界合并，内边界与内边界合并，外边界与内边界做逻辑加法运算；
//先做减法，再做加法
//A的内边界+B的内边界
CArray<CGeoSurface*,CGeoSurface*> sonSurfaces3;
for(i=0; i<sonSurfaces1.GetSize(); i++)
{
CGeoSurface *p1 = sonSurfaces1[i];
if(p1==NULL)
continue;
if(sonSurfaceFlags1[i]!=0)
continue;
for(j=0; j<sonSurfaces2.GetSize(); j++)
{
CGeoSurface *p2 = sonSurfaces2[j];
if(p2==NULL)
continue;
if(sonSurfaceFlags1[i]==sonSurfaceFlags2[j])
{
CArray<CGeoSurface*,CGeoSurface*> arrObjs;
if(MergeSurface_BothSimple_LogicIntersect(p1, p2, arrObjs))
{
bModified_whole = TRUE;
for(k=0; k<arrObjs.GetSize(); k++)
{
sonSurfaces3.Add(arrObjs[k]);
}
}
}
}
}
//A的内边界-B的外边界
for(i=0; i<sonSurfaces1.GetSize(); i++)
{
CGeoSurface *p1 = sonSurfaces1[i];
if(sonSurfaceFlags1[i]!=0)
continue;
for(j=0; j<sonSurfaces2.GetSize(); j++)
{
CGeoSurface *p2 = sonSurfaces2[j];
if(sonSurfaceFlags2[j]!=1)
continue;
CArray<CGeoSurface*,CGeoSurface*> arrObjs;
if(MergeSurface_BothSimple_LogicSubtract(p1, p2, arrObjs))
{
bModified_whole = TRUE;
if(arrObjs.GetSize()==1 && IsSameShape(p1,arrObjs[0]))
{
}
else
{
delete p1;
sonSurfaces1[i] = NULL;
for(k=0; k<arrObjs.GetSize(); k++)
{
sonSurfaces1.Add(arrObjs[k]);
sonSurfaceFlags1.Add(sonSurfaceFlags1[i]);
}
break;
}
}
}
}
//B的内边界-A的外边界
for(i=0; i<sonSurfaces2.GetSize(); i++)
{
CGeoSurface *p1 = sonSurfaces2[i];
if(sonSurfaceFlags2[i]!=0)
continue;
for(j=0; j<sonSurfaces1.GetSize(); j++)
{
CGeoSurface *p2 = sonSurfaces1[j];
if(sonSurfaceFlags1[j]!=1)
continue;
CArray<CGeoSurface*,CGeoSurface*> arrObjs;
if(MergeSurface_BothSimple_LogicSubtract(p1, p2, arrObjs))
{
bModified_whole = TRUE;
if(arrObjs.GetSize()==1 && IsSameShape(p1,arrObjs[0]))
{
}
else
{
delete p1;
sonSurfaces2[i] = NULL;
for(k=0; k<arrObjs.GetSize(); k++)
{
sonSurfaces2.Add(arrObjs[k]);
sonSurfaceFlags2.Add(sonSurfaceFlags2[i]);
}
break;
}
}
}
}
//A的外边界+B的外边界
for(i=0; i<sonSurfaces1.GetSize(); i++)
{
CGeoSurface *p1 = sonSurfaces1[i];
if(p1==NULL)
continue;
if(sonSurfaceFlags1[i]!=1)
continue;
for(j=0; j<sonSurfaces2.GetSize(); j++)
{
CGeoSurface *p2 = sonSurfaces2[j];
if(p2==NULL)
continue;
if(sonSurfaceFlags1[i]==sonSurfaceFlags2[j])
{
CArray<CGeoSurface*,CGeoSurface*> arrObjs;
CArray<int,int> flags;
if( MergeSurface_BothSimple_LogicUnion(p1, p2, arrObjs) )
{
bModified_whole = TRUE;
if( arrObjs.GetSize()==1 )
{
delete p1;
delete p2;
sonSurfaces1[i] = NULL;
sonSurfaces2[j] = arrObjs[0];
break;
}
else if( arrObjs.GetSize()>1 )
{
delete p1;
delete p2;
sonSurfaces1[i] = NULL;
sonSurfaces2[j] = NULL;
sonSurfaces2.Append(arrObjs);
CalcSurfaceFlags(arrObjs,flags);
sonSurfaceFlags2.Append(flags);
break;
}
}
}
}
}
//将内部边界的交集添加进来
for(i=0; i<sonSurfaces3.GetSize(); i++)
{
sonSurfaces1.Add(sonSurfaces3[i]);
sonSurfaceFlags1.Add(0);
}
sonSurfaces1.Append(sonSurfaces2);
sonSurfaceFlags1.Append(sonSurfaceFlags2);
//4、再作包含关系的判定，外边界邻近包含外边界时，去掉较小的外边界，内边界邻近包含内边界时，去掉较大的内边界；
BOOL bModified = TRUE;
while(bModified)
{
bModified = FALSE;
for(i=0; i<sonSurfaces1.GetSize(); i++)
{
CGeoSurface *p1 = sonSurfaces1[i];
if(p1==NULL)continue;
for(j=i+1; j<sonSurfaces1.GetSize(); j++)
{
CGeoSurface *p2 = sonSurfaces1[j];
if(p2==NULL)continue;
if(sonSurfaceFlags1[i]==sonSurfaceFlags1[j])
{
//bReverse：TRUE被p2包含，FALSE包含p2
BOOL bReverse = FALSE;
if( IsSurfaceInclude(p1,p2,bReverse) )
{
CGeoSurface *p_inner = (bReverse?p1:p2);
CGeoSurface *p_outer = (bReverse?p2:p1);
int index_outer = (bReverse?j:i);
int index_inner = (bReverse?i:j);
int nearest_index = index_outer;
CGeoSurface *p_nearest = p_outer;
for(k=0; k<sonSurfaces1.GetSize(); k++)
{
if(k==i || k==j)continue;
CGeoSurface *p3 = sonSurfaces1[k];
if(p3==NULL)continue;
//看看有没有他们之间有没有其他边界
BOOL bReverse2 = FALSE;
if( IsSurfaceInclude(p_inner,p3,bReverse2) )
{
//被包含，取面积最小的
if(bReverse2)
{
if(p_nearest->GetArea()>p3->GetArea())
{
p_nearest = p3;
nearest_index = k;
}
}
}
}
//如果有其他边界，就不处理。我们只处理相邻且同类型边界
if(nearest_index!=index_outer)
continue;
BOOL bKill_Outer = FALSE;
//外边界，去掉较小的
if(sonSurfaceFlags1[i])
{
}
//内边界，去掉较大的
else
{
bKill_Outer = TRUE;
}
if(bKill_Outer)
{
delete p_outer;
sonSurfaces1[index_outer] = NULL;
}
else
{
delete p_inner;
sonSurfaces1[index_inner] = NULL;
}
bModified = TRUE;
bModified_whole = TRUE;
break;
}
}
}
}
}
if(bModified_whole)
{
CGeoMultiSurface *pNewObj = (CGeoMultiSurface*)pObj1->Clone();
CArray<PT_3DEX,PT_3DEX> arrPts_all;
for(i=0; i<sonSurfaces1.GetSize(); i++)
{
if(sonSurfaces1[i]!=NULL)
{
arrPts.RemoveAll();
sonSurfaces1[i]->GetShape(arrPts);
arrPts[0].pencode = penMove;
arrPts_all.Append(arrPts);
delete sonSurfaces1[i];
}
}
if(arrPts_all.GetSize()>0)
arrPts_all[0].pencode = penLine;
pNewObj->CreateShape(arrPts_all.GetData(),arrPts_all.GetSize());
return pNewObj;
}
for(i=0; i<sonSurfaces1.GetSize(); i++)
{
if(sonSurfaces1[i]!=NULL)
{
delete sonSurfaces1[i];
}
}
return NULL;
}
//都是复杂面对象
CGeoSurface *CMergeSurfaceCommand::MergeSurface_BothMulti(CGeoMultiSurface *pObj1, CGeoMultiSurface *pObj2, CFtrArray& commonsideFtrs)
{
return MergeSurface_BothMulti_Logic(pObj1,pObj2);
Envelope e1 = pObj1->GetEnvelope();
Envelope e2 = pObj2->GetEnvelope();
Envelope e3 = e1;
e3.Intersect(&e2);
if(e3.m_xl>e3.m_xh || e3.m_yl>e3.m_yh )
return NULL;
int nSon1 = pObj1->GetSurfaceNum();
int nSon2 = pObj2->GetSurfaceNum();
//合并可以分为两种：1）外围面共边，则外围面合并成新的外围面，子面加到一起，形成新的复杂面；
//2）外围面与子面共边，则外围面与子面形成新的外围面，子面加到一起（去掉前面合并的那个），形成新的复杂面；
CArray<CGeoSurface*,CGeoSurface*> arrGeos1, arrGeos2;
CArray<PT_3DEX,PT_3DEX> arr;
for(int i=0; i<nSon1; i++)
{
arr.RemoveAll();
pObj1->GetSurface(i,arr);
CGeoSurface *pGeo = new CGeoSurface();
pGeo->CreateShape(arr.GetData(),arr.GetSize());
arrGeos1.Add(pGeo);
}
for(i=0; i<nSon2; i++)
{
arr.RemoveAll();
pObj2->GetSurface(i,arr);
CGeoSurface *pGeo = new CGeoSurface();
pGeo->CreateShape(arr.GetData(),arr.GetSize());
arrGeos2.Add(pGeo);
}
CFtrArray commonsideFtrs1;
//1）外围面与外围面共边
CGeoSurface *pNewGeo = MergeSurface_BothSimple(arrGeos1[0],arrGeos2[0],commonsideFtrs1);
if(pNewGeo)
{
CGeoMultiSurface *pNewMulti = (CGeoMultiSurface*)pObj1->Clone();
arr.RemoveAll();
pNewGeo->GetShape(arr);
pNewMulti->CreateShape(arr.GetData(),arr.GetSize());
for(i=1; i<nSon1; i++)
{
arr.RemoveAll();
pObj1->GetSurface(i,arr);
pNewMulti->AddSurface(arr);
delete arrGeos1[i];
}
for(i=1; i<nSon2; i++)
{
arr.RemoveAll();
pObj2->GetSurface(i,arr);
pNewMulti->AddSurface(arr);
delete arrGeos2[i];
}
delete arrGeos1[0];
delete arrGeos2[0];
delete pNewGeo;
commonsideFtrs.Copy(commonsideFtrs1);
return pNewMulti;
}
commonsideFtrs1.RemoveAll();
//2）外围面与子面共边
BOOL bFindMerge = FALSE, bSameEdge = FALSE;
for(i=1; i<nSon2; i++)
{
CGeoSurface *pNewGeo = MergeSurface_BothSimple(arrGeos1[0],arrGeos2[i],commonsideFtrs1);
if(!pNewGeo)
{
if(IsSameShape(arrGeos1[0],arrGeos2[i]))
{
bSameEdge = TRUE;
bFindMerge = TRUE;
delete arrGeos1[0];
delete arrGeos2[i];
arrGeos1[0] = NULL;
arrGeos2[i] = NULL;
}
}
if(pNewGeo)
{
delete arrGeos1[0];
delete arrGeos2[i];
arrGeos1[0] = pNewGeo;
arrGeos2[i] = NULL;
bFindMerge = TRUE;
}
}
if(bFindMerge)
{
CGeoMultiSurface *pNewMulti = (CGeoMultiSurface*)pObj1->Clone();
arr.RemoveAll();
arrGeos2[0]->GetShape(arr);
pNewMulti->CreateShape(arr.GetData(),arr.GetSize());
if(arrGeos1[0])
{
arr.RemoveAll();
arrGeos1[0]->GetShape(arr);
pNewMulti->AddSurface(arr);
delete arrGeos1[0];
}
for(i=1; i<nSon1; i++)
{
arr.RemoveAll();
pObj1->GetSurface(i,arr);
pNewMulti->AddSurface(arr);
delete arrGeos1[i];
}
for(i=1; i<nSon2; i++)
{
if(arrGeos2[i]==NULL)
continue;
arr.RemoveAll();
pObj2->GetSurface(i,arr);
pNewMulti->AddSurface(arr);
delete arrGeos2[i];
}
delete arrGeos2[0];
commonsideFtrs.Copy(commonsideFtrs1);
return pNewMulti;
}
for(i=1; i<nSon1; i++)
{
CGeoSurface *pNewGeo = MergeSurface_BothSimple(arrGeos2[0],arrGeos1[i],commonsideFtrs1);
if(!pNewGeo)
{
if(IsSameShape(arrGeos2[0],arrGeos1[i]))
{
bSameEdge = TRUE;
bFindMerge = TRUE;
delete arrGeos2[0];
delete arrGeos1[i];
arrGeos2[0] = NULL;
arrGeos1[i] = NULL;
}
}
if(pNewGeo)
{
delete arrGeos2[0];
delete arrGeos1[i];
arrGeos2[0] = pNewGeo;
arrGeos1[i] = NULL;
bFindMerge = TRUE;
}
}
if(bFindMerge)
{
CGeoMultiSurface *pNewMulti = (CGeoMultiSurface*)pObj1->Clone();
arr.RemoveAll();
arrGeos1[0]->GetShape(arr);
pNewMulti->CreateShape(arr.GetData(),arr.GetSize());
if(arrGeos2[0])
{
arr.RemoveAll();
arrGeos2[0]->GetShape(arr);
pNewMulti->AddSurface(arr);
delete arrGeos2[0];
}
for(i=1; i<nSon2; i++)
{
arr.RemoveAll();
pObj2->GetSurface(i,arr);
pNewMulti->AddSurface(arr);
delete arrGeos2[i];
}
for(i=1; i<nSon1; i++)
{
if(arrGeos1[i]==NULL)
continue;
arr.RemoveAll();
pObj1->GetSurface(i,arr);
pNewMulti->AddSurface(arr);
delete arrGeos1[i];
}
delete arrGeos1[0];
commonsideFtrs.Copy(commonsideFtrs1);
return pNewMulti;
}
return NULL;
}
void CMergeSurfaceCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
int num0 ;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(num0);
if( m_nStep==0 && num0>=2 )
{
if( !CanGetSelObjs(flag,TRUE) )return;
CFtrArray arrFtrs;
CGeoArray arrGeos;
for(int i=0; i<num0; i++)
{
CGeometry *pObj = HandleToFtr(handles[i])->GetGeometry();
if( !pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )
continue;
arrFtrs.Add(HandleToFtr(handles[i]));
arrGeos.Add(pObj);
}
CGeoArray arrGeos0;
arrGeos0.Copy(arrGeos);
int num = arrGeos.GetSize();
if(num<2)
return;
CFtrArray commonsideFtrs;
BOOL bModified_all = FALSE, bModified = TRUE;
while(bModified)
{
bModified = FALSE;
for(i=0; i<num; i++)
{
for(int j=i+1; j<num; j++)
{
CGeoSurface *pObj1 = (CGeoSurface*)arrGeos[i];
if( pObj1==NULL )continue;
CGeoSurface *pObj2 = (CGeoSurface*)arrGeos[j];
if( pObj2==NULL )continue;
CGeoSurface *pNewObj = MergeSurface_new(pObj2,pObj1,commonsideFtrs);
if(pNewObj)
{
if(arrGeos[i]!=arrGeos0[i])
delete arrGeos[i];
arrGeos[i] = pNewObj;
arrGeos[j] = NULL;
bModified_all = TRUE;
bModified = TRUE;
}
}
}
}
if(bModified_all)
{
CUndoFtrs undo(m_pEditor,Name());
for(i=0; i<num; i++)
{
if(arrGeos[i]!=NULL && arrGeos[i]!=arrGeos0[i])
{
CFeature* pFtr = arrFtrs[1]->Clone();
pFtr->SetID(OUID());
pFtr->SetToDeleted(FALSE);
pFtr->SetGeometry(arrGeos[i]);
m_pEditor->AddObject(pFtr,m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(arrFtrs[1])));
GETXDS(m_pEditor)->CopyXAttributes(arrFtrs[1],pFtr);
undo.arrNewHandles.Add(FtrToHandle(pFtr));
}
}
for(i=0; i<num; i++)
{
if(arrGeos[i]!=arrGeos0[i])
{
m_pEditor->DeleteObject(FtrToHandle(arrFtrs[i]));
undo.arrOldHandles.Add(FtrToHandle(arrFtrs[i]));
}
}
for(int i=0; i<commonsideFtrs.GetSize(); i++)
{
m_pEditor->DeleteObject(FtrToHandle(commonsideFtrs[i]));
undo.arrOldHandles.Add(FtrToHandle(commonsideFtrs[i]));
}
undo.Commit();
}
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
Finish();
m_nStep = 3;
}
CEditCommand::PtClick(pt,flag);
}
void CMergeSurfaceCommand::PtMove(PT_3D &pt)
{
}
void CMergeSurfaceCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
// var = (LPCTSTR)(m_strLayerCommonSide);
// tab.AddValue("LayerCommonSide",&CVariantEx(var));
}
void CMergeSurfaceCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID(AccelStr(),Name());
// param->AddLayerNameParamEx("LayerCommonSide",m_strLayerCommonSide,StrFromResID(IDS_LAY_COMMONSIDE),NULL,LAYERPARAMITEM_LINE);
param->AddParam("Enter",'\r',StrFromResID(IDS_ENTER_AFFIRM));
}
void CMergeSurfaceCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"LayerCommonSide",var) )
{
// m_strLayerCommonSide = (LPCTSTR)(_bstr_t)(_variant_t)*var;
// SetSettingsModifyFlag();
}
if( tab.GetValue(0,"Enter",var) )
{
PtClick(PT_3D(),0);
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CMergeSurfaceCommand_AllMap Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CMergeSurfaceCommand_AllMap,CMergeSurfaceCommand)
CMergeSurfaceCommand_AllMap::CMergeSurfaceCommand_AllMap()
{
}
CMergeSurfaceCommand_AllMap::~CMergeSurfaceCommand_AllMap()
{
}
CString CMergeSurfaceCommand_AllMap::Name()
{
return StrFromResID(IDS_CMDNAME_MERGESURFACE_ALLMAP);
}
void CMergeSurfaceCommand_AllMap::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_strLayerCommonSide.Empty();
m_pEditor->CloseSelector();
}
void CMergeSurfaceCommand_AllMap::Abort()
{
CEditCommand::Abort();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
BOOL Split(CString source, LPCTSTR divKey, CStringArray& dest)
{
if (strlen(divKey)<=0)
{
return FALSE;
}
if (source.IsEmpty())
{
return FALSE;
}
int size = strlen(divKey);
dest.RemoveAll();
//判断结尾是不是分隔符 不是加上一个
if (strcmp((LPCTSTR)source.Right(size),divKey)!=0)
{
source +=divKey;
}
int pos = 0;
int pre_pos = 0;
while( -1 != pos ){
pre_pos = pos;
pos = source.Find(divKey,pos);
if (-1!= pos)
{
dest.Add(source.Mid(pre_pos,(pos-pre_pos)));
pos= pos+1;
}
}
return TRUE;
}
void CMergeSurfaceCommand_AllMap::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
//遍历所有图层，按照图层操作
CDataSourceEx *pDS = m_pEditor->GetDataSource();
int nLay = pDS->GetFtrLayerCount();
if(1)
{
CStringArray fields;
if(m_strEqualFields.GetLength()>0)
{
Split(m_strEqualFields,",",fields);
}
//
CUndoFtrs undo_pre(m_pEditor,Name());
GProgressStart(nLay);
//
std::list<std::vector<CFeature*> > join_ftr_group;
//
for(int i=0; i<nLay; ++i)
{
CFtrLayer *pLayer = pDS->GetFtrLayerByIndex(i);
if( !pLayer && (!pLayer->IsVisible() || pLayer->IsLocked()) )
continue;
//
std::vector<CFeature*> surface_ftrs;
int nObj = pLayer->GetObjectCount();
for(int j=0; j<nObj; ++j)
{
CFeature* pftr = pLayer->GetObject(j);
if(pftr!=NULL && pftr->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
{
if(pftr->GetGeometry()->GetDataPointSum()>=4)
surface_ftrs.push_back(pftr);
}
}
if(surface_ftrs.size()<=1)
continue;
//
bool *grouped = new bool[surface_ftrs.size()];
for(j=0; j<surface_ftrs.size(); ++j)
grouped[j] = false;
//
int k = 0;
//
L: while(k<nObj && grouped[k])
{
++k;
}
if(k>=nObj)
{
continue;
}
CFeature* pftr_sample = surface_ftrs[k];
//
std::vector<CFeature*> group_ftrs;
group_ftrs.push_back(pftr_sample);
grouped[k] = true;
CValueTable tab_sample;
tab_sample.BeginAddValueItem();
GETXDS(m_pEditor)->GetXAttributes(pftr_sample,tab_sample);
tab_sample.EndAddValueItem();
for(j=k+1; j<surface_ftrs.size(); ++j)
{
if(grouped[j])
continue;
//
CFeature* temp = surface_ftrs[j];
//
bool same_xattri = true;
//
CValueTable tab1;
tab1.BeginAddValueItem();
GETXDS(m_pEditor)->GetXAttributes(temp,tab1);
tab1.EndAddValueItem();
//
if(fields.GetSize() == 0 || (tab1.GetFieldCount() == 0 && tab_sample.GetFieldCount() == 0))
same_xattri = true;
else
{
for(int n=0; n<fields.GetSize(); n++)
{
const CVariantEx *var1=NULL, *var2=NULL;
if(!tab_sample.GetValue(0,fields[n],var1) || !tab1.GetValue(0,fields[n],var2))
{
same_xattri = false;
break;
}
if((_variant_t)*var1!=(_variant_t)*var2)
{
same_xattri = false;
break;
}
}
}
//
if(same_xattri)
{
grouped[j] = true;
group_ftrs.push_back(temp);
continue;
}
else
{
join_ftr_group.push_back(group_ftrs);
goto L;
}
}
//
join_ftr_group.push_back(group_ftrs);
delete[] grouped;
grouped = NULL;
//
GProgressStep();
}
GProgressEnd();
//
CUndoFtrs undo(m_pEditor,Name());
GProgressStart(join_ftr_group.size());
//
for(std::list<std::vector<CFeature*> >::iterator itr = join_ftr_group.begin(); itr!= join_ftr_group.end(); ++itr)
{
gsbh::GeoSurfaceSetBooleanHandle gssbh;
std::vector<CFeature*>& waiting_join_ftrs = *itr;
std::map<CString,CFeature*> join_ftrs;
std::vector<CGeometry*> geos;
//
for(int i=0; i<waiting_join_ftrs.size(); ++i)
{
CFeature *pFtr = waiting_join_ftrs[i];
CGeoSurface *pGeo2 = NormalizeSurface(m_pEditor,(CGeoSurface*)pFtr->GetGeometry());
geos.push_back(pGeo2);
if(pGeo2!=NULL && gssbh.addSurface(pGeo2,pFtr->GetID().ToString()))
{
join_ftrs[pFtr->GetID().ToString()] = pFtr;
}
}
//
gssbh.init();
gssbh.join();
std::vector<gsbh::GeoSurfaceSetBooleanHandle::ResultSurface> res;
gssbh.getResult(res);
//
for(int j=0; j<res.size(); ++j)
{
CFeature* pft = join_ftrs[res[j].ftr_id];
CGeoSurface* pgeo = (CGeoSurface*)pft->GetGeometry();
CArray<PT_3DEX, PT_3DEX> temp_shape;
res[j].pgs->GetShape(temp_shape);
res[j].pgs->CopyFrom(pgeo);
res[j].pgs->CreateShape(temp_shape.GetData(), temp_shape.GetSize());
CFeature* pNewFtr = pft->Clone();
if (!pNewFtr)
{
continue;
}
pNewFtr->SetID(OUID());
pNewFtr->SetToDeleted(FALSE);
pNewFtr->SetGeometry(res[j].pgs);
if(!m_pEditor->AddObject(pNewFtr,pDS->GetFtrLayerOfObject(pft)->GetID()))
{
continue;
}
undo.arrNewHandles.Add(FtrToHandle(pNewFtr));
}
//
for(std::map<CString,CFeature*>::iterator itr = join_ftrs.begin(); itr!=join_ftrs.end(); ++itr)
{
m_pEditor->DeleteObject(FtrToHandle(itr->second));
undo.arrOldHandles.Add(FtrToHandle(itr->second));
}
//
for(i=0; i<geos.size(); ++i)
{
if(geos[i]!=NULL)
delete geos[i];
}
GProgressStep();
}
//
undo.Commit();
GProgressEnd();
//
CEditCommand::PtClick(pt,flag);
return ;
}
int nSum = 0;
for(int i=0; i<nLay; i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayerByIndex(i);
if( !pLayer && (!pLayer->IsVisible() || pLayer->IsLocked()) )
continue;
int nObj = pLayer->GetObjectCount();
CFtrArray ftrs;
for(int j=0; j<nObj; j++)
{
CFeature *pFtr = pLayer->GetObject(j);
if(!pFtr)
continue;
nSum++;
}
}
CUndoFtrs undo(m_pEditor,Name());
CStringArray fields;
if(m_strEqualFields.GetLength()>0)
{
Split(m_strEqualFields,",",fields);
}
GProgressStart(nSum);
for(i=0; i<nLay; i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayerByIndex(i);
if( !pLayer && (!pLayer->IsVisible() || pLayer->IsLocked()) )
continue;
int nObj = pLayer->GetObjectCount();
CFtrArray ftrs;
for(int j=0; j<nObj; j++)
{
CFeature *pFtr = pLayer->GetObject(j);
if(!pFtr)
continue;
if(!pFtr->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
{
continue;
}
ftrs.Add(pFtr);
}
CFtrArray ftrs0, ftrs1;
//合并标志，标记ftrs1中的对应元素是否被合并了，与ftrs1数组的长度相同
CArray<int,int> arrMergeFlags;
//无法合并的对象放到ftrs1数组，合并成功的对象，持续合并下去，到最后也放入ftrs1数组
//ftrs0中存放原始对象，与ftrs1数组的长度相同，便于添加数据时，复制其属性
for(j=0; j<ftrs.GetSize(); j++)
{
GProgressStep();
CFeature *pFtr1 = ftrs[j];
for(int k=0; k<ftrs1.GetSize(); k++)
{
CFeature *pFtr2 = ftrs1[k];
if(pFtr2==NULL)continue;
CGeoSurface *pObj1 = (CGeoSurface*)pFtr1->GetGeometry();
CGeoSurface *pObj2 = (CGeoSurface*)pFtr2->GetGeometry();
CFtrArray commonsideFtrs;
CGeoSurface *pNewObj = MergeSurface(pObj1,pObj2,commonsideFtrs);
if(!pNewObj)
{
continue;
}
BOOL bFieldOK = TRUE;
if(fields.GetSize()>0)
{
CValueTable tab1, tab2;
tab1.BeginAddValueItem();
GETXDS(m_pEditor)->GetXAttributes(pFtr1,tab1);
tab1.EndAddValueItem();
tab2.BeginAddValueItem();
GETXDS(m_pEditor)->GetXAttributes(pFtr2,tab2);
tab2.EndAddValueItem();
if( tab1.GetFieldCount()>0 && tab2.GetFieldCount()>0 )
{
for(int n=0; n<fields.GetSize(); n++)
{
const CVariantEx *var1=NULL, *var2=NULL;
if(!tab1.GetValue(0,fields[n],var1) || !tab2.GetValue(0,fields[n],var2))
break;
if((_variant_t)*var1!=(_variant_t)*var2)
break;
}
if(n<fields.GetSize())
bFieldOK = FALSE;
}
else
{
bFieldOK = FALSE;
}
}
if(!bFieldOK)
{
continue;
}
CFeature* pNewFtr = pFtr1->Clone();
pNewFtr->SetID(OUID());
pNewFtr->SetToDeleted(FALSE);
pNewFtr->SetGeometry(pNewObj);
for(int m=0; m<commonsideFtrs.GetSize(); m++)
{
m_pEditor->DeleteObject(FtrToHandle(commonsideFtrs[m]));
undo.arrOldHandles.Add(FtrToHandle(commonsideFtrs[m]));
}
//用新对象替换k位置，便于后面递归处理
if(arrMergeFlags[k]==1)
delete ftrs1[k];
ftrs1[k] = NULL;
pFtr1 = pNewFtr;
}
if( ftrs[j]!=pFtr1 )
{
arrMergeFlags.Add(1);
}
else
{
arrMergeFlags.Add(0);
}
ftrs0.Add(ftrs[j]);
ftrs1.Add(pFtr1);
}
for(j=0; j<ftrs1.GetSize(); j++)
{
if(ftrs1[j]==NULL)
{
m_pEditor->DeleteObject(FtrToHandle(ftrs0[j]));
undo.arrOldHandles.Add(FtrToHandle(ftrs0[j]));
}
else if(ftrs1[j]!=ftrs0[j])
{
m_pEditor->AddObject(ftrs1[j],pLayer->GetID());
GETXDS(m_pEditor)->CopyXAttributes(ftrs0[j],ftrs1[j]);
m_pEditor->DeleteObject(FtrToHandle(ftrs0[j]));
undo.arrOldHandles.Add(FtrToHandle(ftrs0[j]));
undo.arrNewHandles.Add(FtrToHandle(ftrs1[j]));
}
}
}
undo.Commit();
GProgressEnd();
CEditCommand::PtClick(pt,flag);
}
void CMergeSurfaceCommand_AllMap::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
// var = (LPCTSTR)(m_strLayerCommonSide);
// tab.AddValue("LayerCommonSide",&CVariantEx(var));
var = (LPCTSTR)(m_strEqualFields);
tab.AddValue("EqualFields",&CVariantEx(var));
}
void CMergeSurfaceCommand_AllMap::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID(AccelStr(),Name());
// param->AddLayerNameParamEx("LayerCommonSide",m_strLayerCommonSide,StrFromResID(IDS_LAY_COMMONSIDE),NULL,LAYERPARAMITEM_LINE);
param->AddParam("EqualFields",(LPCTSTR)m_strEqualFields,StrFromResID(IDS_EQUALVALUE_FIELDS),NULL);
}
void CMergeSurfaceCommand_AllMap::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"LayerCommonSide",var) )
{
// m_strLayerCommonSide = (LPCTSTR)(_bstr_t)(_variant_t)*var;
// SetSettingsModifyFlag();
}
if( tab.GetValue(0,"EqualFields",var) )
{
m_strEqualFields = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CMergeCurveCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CMergeCurveCommand,CEditCommand)
CMergeCurveCommand::CMergeCurveCommand()
{
m_nStep = -1;
m_nType = 0;
}
CMergeCurveCommand::~CMergeCurveCommand()
{
}
CString CMergeCurveCommand::Name()
{
return StrFromResID(IDS_CMDNAME_MERGECURVE);
}
void CMergeCurveCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
int num ;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if( num==2 )
{
PT_3D pt;
PtClick(pt,0);
PtClick(pt,0);
return;
}
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->OpenSelector();
}
void CMergeCurveCommand::Abort()
{
CEditCommand::Abort();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
void CMergeCurveCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)(m_nType);
tab.AddValue(PF_MERGECURVE_TYPE,&CVariantEx(var));
}
void CMergeCurveCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("MergeCurveCommand",StrFromLocalResID(IDS_CMDNAME_MERGECURVE));
param->BeginOptionParam(PF_MERGECURVE_TYPE,StrFromResID(IDS_CMDPLANE_DCURVETYPE));
param->AddOption(StrFromResID(IDS_PARLINE),0,' ',m_nType==0);
param->AddOption(StrFromResID(IDS_GEO_DCURVE),1,' ',m_nType==1);
param->EndOptionParam();
}
void CMergeCurveCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_MERGECURVE_TYPE,var) )
{
m_nType = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CMergeCurveCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if( m_nStep==0 )
{
int num ;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if (num == 1)
{
CGeometry *pObj1 = HandleToFtr(handles[0])->GetGeometry();
int cls1 = pObj1->GetClassType();
if( cls1 != CLS_GEOCURVE )
{
GOutPut(StrFromResID(IDS_CMDTIP_MERGECURVE_TIP));
return;
}
GotoState(PROCSTATE_PROCESSING);
m_nStep = 1;
m_arrFtrs[0] = handles[0];
}
else if( num==2 )
{
if( !CanGetSelObjs(flag,TRUE) )return;
CGeometry *pObj1 = HandleToFtr(handles[0])->GetGeometry();
CGeometry *pObj2 = HandleToFtr(handles[1])->GetGeometry();
if( pObj1==NULL || pObj2==NULL )
return;
if (m_pEditor->GetFtrLayerIDOfFtr(handles[0]) != m_pEditor->GetFtrLayerIDOfFtr(handles[1]))
{
GOutPut(StrFromResID(IDS_CMDTIP_MERGECURVE_TIP));
return;
}
int cls1 = pObj1->GetClassType(), cls2 = pObj2->GetClassType();
if( cls1 != CLS_GEOCURVE || cls2 != CLS_GEOCURVE )
{
GOutPut(StrFromResID(IDS_CMDTIP_MERGECURVE_TIP));
return;
}
GotoState(PROCSTATE_PROCESSING);
m_nStep = 2;
m_pEditor->CloseSelector();
m_arrFtrs[0] = handles[0];
m_arrFtrs[1] = handles[1];
}
}
else if (m_nStep == 1)
{
FTR_HANDLE handle = m_pEditor->GetSelection()->GetLastSelectedObj();
if (handle == 0 || handle == m_arrFtrs[0]) return;
CGeometry *pObj1 = HandleToFtr(m_arrFtrs[0])->GetGeometry();
CGeometry *pObj2 = HandleToFtr(handle)->GetGeometry();
if( pObj1==NULL || pObj2==NULL )
return;
if (m_pEditor->GetFtrLayerIDOfFtr(m_arrFtrs[0]) != m_pEditor->GetFtrLayerIDOfFtr(handle))
{
GOutPut(StrFromResID(IDS_CMDTIP_MERGECURVE_TIP));
return;
}
int cls1 = pObj1->GetClassType(), cls2 = pObj2->GetClassType();
if( cls1 != CLS_GEOCURVE || cls2 != CLS_GEOCURVE )
{
GOutPut(StrFromResID(IDS_CMDTIP_MERGECURVE_TIP));
return;
}
GotoState(PROCSTATE_PROCESSING);
m_nStep = 2;
m_pEditor->CloseSelector();
m_arrFtrs[1] = handle;
}
if( m_nStep==2 )
{
// 获取双线类型
int layid = m_pEditor->GetFtrLayerIDOfFtr(m_arrFtrs[0]);
CFtrLayer *pLayer = GETDS(m_pEditor)->GetFtrLayer(layid);
if (!pLayer)
{
Abort();
return;
}
CGeoCurve *pObj1 = (CGeoCurve*)HandleToFtr(m_arrFtrs[0])->GetGeometry();
CGeoCurve *pObj2 = (CGeoCurve*)HandleToFtr(m_arrFtrs[1])->GetGeometry();
CArray<PT_3DEX,PT_3DEX> arr1,arr2;
pObj1->GetShape(arr1);
pObj2->GetShape(arr2);
if (arr1.GetSize()<=0||arr2.GetSize()<=0)
{
Abort();
return;
}
int clstype = m_nType==0?CLS_GEOPARALLEL:CLS_GEODCURVE;
// 判断是否可生成平行线
if (clstype == CLS_GEOPARALLEL)
{
PT_3DEX ret;
double dis1 = GraphAPI::GGetNearstDisPToPointSet2D(arr1.GetData(),arr1.GetSize(),arr2[0],ret,NULL);
double dis2 = GraphAPI::GGetNearstDisPToPointSet2D(arr1.GetData(),arr1.GetSize(),arr2[arr2.GetSize()-1],ret,NULL);
if (fabs(dis1-dis2) > 1e-4)
{
GOutPut(StrFromResID(IDS_CMDTIP_MERGECURVE_ERR));
return;
}
}
CFeature *pFtr = pLayer->CreateDefaultFeature(GETDS(m_pEditor)->GetScale(),clstype);
if (!pFtr || !pFtr->GetGeometry())
{
Abort();
return;
}
CGeometry *pGeo = pFtr->GetGeometry();
if (clstype == CLS_GEOPARALLEL)
{
int isSameDirection = -1;//判断平行折线方向
int nret1 = GraphAPI::GIsClockwise(arr1.GetData(),arr1.GetSize());
int nret2 = GraphAPI::GIsClockwise(arr2.GetData(),arr2.GetSize());
if ((nret1!=-1&&nret2!=-1)&&(nret1!=nret2))//不相等为反向
{
isSameDirection = 0;
}
else if ((nret1!=-1&&nret2!=-1)&&(nret1==nret2))//相等则为同向
{
isSameDirection = 1;
}
else
{
isSameDirection = -1; //方向未知按反向处理
}
//双线打散的双线点会反向 符号打散的双线为同向
PT_3D pt_3d;
if(0 == isSameDirection||-1 == isSameDirection)//反向或者方向未知（方向未知按反方向处理）
{
pt_3d = arr2[0];
}
else if (1 ==isSameDirection )//同向
{
pt_3d = arr2[arr2.GetSize()-1];
}
if (!pGeo->CreateShape(arr1.GetData(),arr1.GetSize()) || !((CGeoParallel*)pGeo)->SetCtrlPoint(0,pt_3d))
{
delete pFtr;
Abort();
return;
}
}
else if (clstype == CLS_GEODCURVE)
{
CArray<PT_3DEX,PT_3DEX> pts;
pts.Append(arr1);
arr2[0].pencode = penMove;
pts.Append(arr2);
if (!pGeo->CreateShape(pts.GetData(),pts.GetSize()))
{
delete pFtr;
Abort();
return;
}
}
else
{
delete pFtr;
Abort();
return;
}
CValueTable tab;
tab.BeginAddValueItem();
HandleToFtr(m_arrFtrs[0])->WriteTo(tab);
tab.EndAddValueItem();
tab.DelField(FIELDNAME_SHAPE);
tab.DelField(FIELDNAME_GEOCURVE_CLOSED);
tab.DelField(FIELDNAME_FTRDELETED);
tab.DelField(FIELDNAME_FTRID);
tab.DelField(FIELDNAME_GEOCLASS);
tab.DelField(FIELDNAME_FTRDISPLAYORDER);
tab.DelField(FIELDNAME_FTRGROUPID);
tab.DelField(FIELDNAME_SYMBOLNAME);
pFtr->ReadFrom(tab);
CUndoFtrs undo(m_pEditor,Name());
m_pEditor->AddObject(pFtr,layid);
undo.AddNewFeature(FtrToHandle(pFtr));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_arrFtrs[0]),pFtr );
m_pEditor->DeleteObject(m_arrFtrs[0]);
m_pEditor->DeleteObject(m_arrFtrs[1]);
undo.AddOldFeature(m_arrFtrs[0]);
undo.AddOldFeature(m_arrFtrs[1]);
undo.Commit();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
Finish();
m_nStep = 3;
}
CEditCommand::PtClick(pt,flag);
}
void CMergeCurveCommand::PtMove(PT_3D &pt)
{
}
//////////////////////////////////////////////////////////////////////
// CMirrorCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CMirrorCommand,CEditCommand)
CMirrorCommand::CMirrorCommand()
{
m_nStep = -1;
m_nGetAxisMode = modeDraw;
strcat(m_strRegPath,"\\Mirror");
}
CMirrorCommand::~CMirrorCommand()
{
m_ptrObjs.RemoveAll();
}
CString CMirrorCommand::Name()
{
return StrFromResID(IDS_CMDNAME_MIRROR);
}
void CMirrorCommand::Start()
{
if( !m_pEditor )return;
m_ptrObjs.RemoveAll();
CEditCommand::Start();
int num;
m_pEditor->GetSelection()->GetSelectedObjs(num);
if( m_nGetAxisMode==modeDraw && num>0 )
m_pEditor->CloseSelector();
else if( m_nGetAxisMode==modeSelect )
{
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
}
GOutPut(StrFromResID(IDS_CMDTIP_SELECTTARGET));
}
void CMirrorCommand::Abort()
{
m_ptrObjs.RemoveAll();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
CEditCommand::Abort();
}
void CMirrorCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
//选取
if( m_nGetAxisMode==modeSelect )
{
if( m_nStep==0 )
{
if( m_ptrObjs.GetSize()==0 || (flag&SELSTAT_MULTISEL)!=0 )
{
m_ptrObjs.RemoveAll();
int num ;
const FTR_HANDLE *handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if( num>0 )
{
for(int i=0;i<num;i++)
{
m_ptrObjs.Add(HandleToFtr(handles[i]));
}
}
GOutPut(StrFromResID(IDS_CMDTIP_SELECT_SYMMAXIS));
return;
}
if( m_ptrObjs.GetSize()>0 )
{
GotoState(PROCSTATE_PROCESSING);
m_nStep = 1;
}
}
if( m_nStep==1 )
{
if( (flag&SELSTAT_MULTISEL)!=0 )
{
return;
}
//找到对象
FTR_HANDLE handle = m_pEditor->GetSelection()->GetLastSelectedObj();
if (handle == NULL) return;
CGeometry *pObj = HandleToFtr(handle)->GetGeometry();
if( !pObj )return;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoPoint)) )
{
// OutputTipString(CMDERR_TYPEINVALID);
return;
}
//有效范围
double r = m_pEditor->GetSelection()->GetSelectRadius()*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
PT_3D p;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&pt,&p);
Envelope e ;
e.CreateFromPtAndRadius(p,r);
if( !pObj->FindNearestBaseLine(p,e,m_pEditor->GetCoordWnd().m_pSearchCS,&m_ptDragStart,&m_ptDragEnd,NULL) )
{
return;
}
CUndoFtrs undo(m_pEditor,Name());
for( int i=m_ptrObjs.GetSize()-1; i>=0; i--)
{
pObj = ((CPFeature)m_ptrObjs[i])->GetGeometry();
if( !pObj )continue;
pObj = MirrorObj(pObj, m_ptDragStart, m_ptDragEnd);
if( pObj )
{
CFeature *pFtr = ((CPFeature)m_ptrObjs[i])->Clone();
if (pFtr)
{
pFtr->SetID(OUID());
pFtr->SetGeometry(pObj);
m_pEditor->AddObject(pFtr,m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle((CPFeature)m_ptrObjs[i])));
GETXDS(m_pEditor)->CopyXAttributes((CPFeature)m_ptrObjs[i],pFtr);
}
undo.arrNewHandles.Add(FtrToHandle(pFtr));
}
}
undo.Commit();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
Finish();
m_nStep = 4;
}
}
//画线
else if( m_nGetAxisMode==modeDraw )
{
if( m_nStep==0 )
{
int num ;
const FTR_HANDLE *handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if( num>0 )
{
if( !CanGetSelObjs(flag) )
{
GOutPut(StrFromResID(IDS_CMDTIP_DRAW_SYMMAXIS));
return;
}
EditStepOne();
m_ptDragStart = pt;
m_ptDragEnd = pt;
CGeometry *pObj;
for( int i=num-1; i>=0; i--)
{
pObj = HandleToFtr(handles[i])->GetGeometry();
if( !pObj )continue;
m_ptrObjs.Add(pObj);
}
if( (flag&SELSTAT_DRAGSEL_RESTART)!=0 || flag==SELSTAT_NONESEL )m_nStep = 2;
}
}
else if( m_nStep==1 )
{
m_ptDragStart = pt;
m_ptDragEnd = pt;
m_nStep = 2;
}
else if( m_nStep==3 )
{
CGeometry *pObj;
m_ptDragEnd = pt;
m_ptrObjs.RemoveAll();
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
PT_3D ptdir;
ptdir.x = ptdir.y = 0;
ptdir.z = 1000.0;
CUndoFtrs undo(m_pEditor,Name());
int num ;
const FTR_HANDLE *handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
GProgressStart(num);
for( int i=num-1; i>=0; i--)
{
GProgressStep();
pObj = HandleToFtr(handles[i])->GetGeometry();
if( !pObj )continue;
pObj = MirrorObj(pObj, m_ptDragStart, m_ptDragEnd);
if( pObj )
{
CFeature *pFtr = HandleToFtr(handles[i])->Clone();
if (pFtr)
{
pFtr->SetID(OUID());
pFtr->SetGeometry(pObj);
m_pEditor->AddObject(pFtr,m_pEditor->GetFtrLayerIDOfFtr(handles[i]));
GETXDS(m_pEditor)->CopyXAttributes((CPFeature)handles[i],pFtr);
}
undo.arrNewHandles.Add(FtrToHandle(pFtr));
}
}
GProgressEnd();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
undo.Commit();
m_pEditor->RefreshView();
Finish();
m_nStep = 4;
}
}
CEditCommand::PtClick(pt,flag);
return;
}
CGeometry *CMirrorCommand::MirrorObj(CGeometry *pObj, PT_3D pt0, PT_3D pt1)
{
CGeometry *pNew = pObj->Clone();
if( !pNew )return NULL;
PT_3DEX expt;
double x,y;
CArray<PT_3DEX,PT_3DEX> arr;
pObj->GetShape(arr);
int ptsum = arr.GetSize();
for( int i=0; i<ptsum; i++)
{
expt = arr[i];
GraphAPI::GGetPerpendicular(pt0.x,pt0.y,pt1.x,pt1.y,expt.x,expt.y,&x,&y,NULL);
expt.x = 2*x-expt.x; expt.y = 2*y-expt.y;
arr[i] = expt;
}
pNew->CreateShape(arr.GetData(),arr.GetSize());
return pNew;
}
void CMirrorCommand::PtMove(PT_3D &pt)
{
if( m_nGetAxisMode==modeDraw )
{
if( m_nStep==2 || m_nStep==3 )
{
CGeometry *pObj, *pTmp;
GrBuffer buf;
int num = m_ptrObjs.GetSize();
for( int i=0; i<num; i++)
{
pObj = (CGeometry*)m_ptrObjs[i];
pTmp = MirrorObj(pObj, m_ptDragStart, pt);
pTmp->Draw(&buf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
delete pTmp;
}
buf.BeginLineString(0,0);
buf.MoveTo(&m_ptDragStart);
buf.LineTo(&pt);
buf.End();
m_ptDragEnd = pt;
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
m_nStep = 3;
}
}
CEditCommand::PtMove(pt);
}
void CMirrorCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)(m_nGetAxisMode);
tab.AddValue(PF_MTRRERAXIS,&CVariantEx(var));
}
void CMirrorCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("MirrorCommand",StrFromLocalResID(IDS_CMDNAME_MIRROR));
param->BeginOptionParam(PF_MTRRERAXIS,StrFromResID(IDS_CMDPLANE_AXIS));
param->AddOption(StrFromResID(IDS_CMDPLANE_DRAW),modeDraw,' ',m_nGetAxisMode==modeDraw);
param->AddOption(StrFromResID(IDS_CMDPLANE_SEL),modeSelect,' ',m_nGetAxisMode==modeSelect);
param->EndOptionParam();
}
void CMirrorCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_MTRRERAXIS,var) )
{
m_nGetAxisMode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
if( !bInit )
{
Abort();
}
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CCopyWithRotationCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CCopyWithRotationCommand,CEditCommand)
CCopyWithRotationCommand::CCopyWithRotationCommand()
{
m_nStep = -1;
m_bKeepOld = TRUE;
strcat(m_strRegPath,"\\CopyWithRotation");
}
CCopyWithRotationCommand::~CCopyWithRotationCommand()
{
}
CString CCopyWithRotationCommand::Name()
{
return StrFromResID(IDS_CMDNAME_COPYWITHROTATE);
}
void CCopyWithRotationCommand::Start()
{
if( !m_pEditor )return;
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
// m_pEditor->RefreshView();
m_pEditor->OpenSelector();
CEditCommand::Start();
}
void CCopyWithRotationCommand::Abort()
{
CEditCommand::Abort();
}
void CCopyWithRotationCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
int num;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if( num ==1 )
{
if( flag!=SELSTAT_POINTSEL && flag!=SELSTAT_NONESEL )return;
m_objHandleOld = m_pEditor->GetSelection()->GetLastSelectedObj();
CGeometry *pObj = HandleToFtr(m_objHandleOld)->GetGeometry();
if( !pObj )return;
GOutPut(StrFromResID(IDS_CMDTIP_MOVEMOUSE));
// OutputTipString(StrFromResID(IDS_CMDTIP_ROTATEORIGIN));
double r = m_pEditor->GetSelection()->GetSelectRadius()*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
PT_3D p1;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&pt,&p1);
Envelope e;
e.CreateFromPtAndRadius(p1,r);
BOOL bRes = pObj->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&m_ptKey,NULL);
if(!bRes) return;
m_pEditor->CloseSelector();
GotoState(PROCSTATE_PROCESSING);
m_nStep = 1;
}
}
else if( m_nStep==1 )
{
m_ptNew1 = pt;
m_nStep = 2;
GOutPut(StrFromResID(IDS_CMDTIP_SETANGLE));
}
else if( m_nStep==2 )
{
m_ptNew2 = pt;
CGeometry *pObj = HandleToFtr(m_objHandleOld)->GetGeometry();
if( !pObj )return;
pObj = pObj->Clone();
if( !pObj )return;
double m[16];
m_ptNew1.z = m_ptKey.z;
Matrix44FromMove(m_ptNew1.x-m_ptKey.x, m_ptNew1.y-m_ptKey.y,m_ptNew1.z-m_ptKey.z,m);
pObj->Transform(m);
PT_3D ptdir;
ptdir.x = ptdir.y = 0;
ptdir.z = 1000.0;
Matrix44FromRotate(&m_ptNew1,&ptdir,GraphAPI::GGetAngle(m_ptNew1.x,m_ptNew1.y,m_ptNew2.x,m_ptNew2.y),m);
pObj->Transform(m);
if (pObj->IsKindOf(RUNTIME_CLASS(CGeoPoint)))
{
((CGeoPoint*)pObj)->SetDirection((GraphAPI::GGetAngle(m_ptNew1.x,m_ptNew1.y,m_ptNew2.x,m_ptNew2.y))*180/PI+((CGeoPoint*)pObj)->GetDirection());
}
else if(pObj->IsKindOf(RUNTIME_CLASS(CGeoText)))
{
TEXT_SETTINGS0 testSetting;
((CGeoText*)pObj)->GetSettings(&testSetting);
testSetting.fTextAngle = (GraphAPI::GGetAngle(m_ptNew1.x,m_ptNew1.y,m_ptNew2.x,m_ptNew2.y))*180/PI;
((CGeoText*)pObj)->SetSettings(&testSetting);
}
CUndoFtrs undo(m_pEditor,Name());
CFeature *pFtr = HandleToFtr(m_objHandleOld)->Clone();
if(!pFtr)return;
pFtr->SetID(OUID());
pFtr->SetGeometry(pObj);
m_pEditor->AddObject(pFtr,m_pEditor->GetFtrLayerIDOfFtr(m_objHandleOld));
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_objHandleOld),pFtr);
undo.arrNewHandles.Add(FtrToHandle(pFtr));
if( !m_bKeepOld )
{
m_pEditor->DeleteObject(m_objHandleOld);
undo.arrOldHandles.Add(m_objHandleOld);
}
undo.Commit();
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
Finish();
m_nStep = 3;
}
CEditCommand::PtClick(pt,flag);
}
void CCopyWithRotationCommand::PtMove(PT_3D &pt)
{
if( m_nStep==1 )
{
CGeometry *pObj = HandleToFtr(m_objHandleOld)->GetGeometry();
if( !pObj )return ;
pObj = pObj->Clone();
if( !pObj )return ;
double m[16];
Matrix44FromMove(pt.x-m_ptKey.x, pt.y-m_ptKey.y,pt.z-m_ptKey.z,m);
pObj->Transform(m);
GrBuffer buf;
if (pObj->IsKindOf(RUNTIME_CLASS(CGeoText)))
{
CPlotTextEx plot;
TEXT_SETTINGS0 settings;
((CGeoText*)pObj)->GetSettings(&settings);
settings.fHeight *= PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale();
plot.SetSettings(&settings);
plot.SetShape(((CGeoText*)pObj)->GetShape());
plot.SetText(((CGeoText*)pObj)->GetText());
plot.GetOutLineBuf(&buf);
pObj->Draw(&buf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
delete pObj;
}
else if (pObj->IsKindOf(RUNTIME_CLASS(CGeoPoint)))
{
CFeature *pFtr = HandleToFtr(m_objHandleOld)->Clone();
pFtr->SetGeometry( pObj );
CDlgDataSource *pDS = PDOC(m_pEditor)->GetDlgDataSource();
CFtrLayer *pLayer = pDS->GetFtrLayerOfObject(HandleToFtr(m_objHandleOld));
if( pLayer )
{
pDS->DrawFeature(pFtr,&buf,TRUE,0,pLayer->GetName());
}
delete pFtr;
}
else
{
pObj->Draw(&buf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
//buf.RefreshEnvelope();
delete pObj;
}
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
}
else if( m_nStep==2 )
{
m_ptNew2 = pt;
CGeometry *pObj = HandleToFtr(m_objHandleOld)->GetGeometry();
if( !pObj )return ;
pObj = pObj->Clone();
if( !pObj )return ;
double m[16];
Matrix44FromMove(m_ptNew1.x-m_ptKey.x, m_ptNew1.y-m_ptKey.y,m_ptNew1.z-m_ptKey.z,m);
pObj->Transform(m);
PT_3D ptdir;
ptdir.x = ptdir.y = 0;
ptdir.z = 1000.0;
Matrix44FromRotate(&m_ptNew1,&ptdir,GraphAPI::GGetAngle(m_ptNew1.x,m_ptNew1.y,m_ptNew2.x,m_ptNew2.y),m);
pObj->Transform(m);
GrBuffer buf;
if (pObj->IsKindOf(RUNTIME_CLASS(CGeoPoint)))
{
((CGeoPoint*)pObj)->SetDirection((GraphAPI::GGetAngle(m_ptNew1.x,m_ptNew1.y,m_ptNew2.x,m_ptNew2.y))*180/PI+((CGeoPoint*)pObj)->GetDirection());
CFeature *pFtr = HandleToFtr(m_objHandleOld)->Clone();
pFtr->SetGeometry( pObj );
CDlgDataSource *pDS = PDOC(m_pEditor)->GetDlgDataSource();
CFtrLayer *pLayer = pDS->GetFtrLayerOfObject(HandleToFtr(m_objHandleOld));
if( pLayer )
{
pDS->DrawFeature(pFtr,&buf,TRUE,0,pLayer->GetName());
}
delete pFtr;
}
else if(pObj->IsKindOf(RUNTIME_CLASS(CGeoText)))
{
CFeature *pFtr =HandleToFtr(m_objHandleOld)->Clone();
pFtr->SetGeometry(pObj);
TEXT_SETTINGS0 testSetting;
((CGeoText*)pObj)->GetSettings(&testSetting);
testSetting.fTextAngle = (GraphAPI::GGetAngle(m_ptNew1.x,m_ptNew1.y,m_ptNew2.x,m_ptNew2.y))*180/PI;
((CGeoText*)pObj)->SetSettings(&testSetting);
CDlgDataSource *pDS = PDOC(m_pEditor)->GetDlgDataSource();
CFtrLayer *pLayer = pDS->GetFtrLayerOfObject(HandleToFtr(m_objHandleOld));
if( pLayer )
{
pDS->DrawFeature(pFtr,&buf,TRUE,0,pLayer->GetName());
}
delete pFtr;
}
else
{
pObj->Draw(&buf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
//buf.RefreshEnvelope();
delete pObj;
}
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
}
CEditCommand::PtMove(pt);
}
void CCopyWithRotationCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (bool)(m_bKeepOld);
tab.AddValue(PF_COPYROTATEKPOLD,&CVariantEx(var));
}
void CCopyWithRotationCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("CopyWithRotationCommand",StrFromLocalResID(IDS_CMDNAME_COPYWITHROTATE));
param->AddParam(PF_COPYROTATEKPOLD,bool(m_bKeepOld),StrFromResID(IDS_CMDPLANE_KEEPOLD));
}
void CCopyWithRotationCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_COPYROTATEKPOLD,var) )
{
m_bKeepOld = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CCopyWithRotationCommand::Finish()
{
CEditCommand::Finish();
}
//////////////////////////////////////////////////////////////////////
// CExtendCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CExtendCommand,CEditCommand)
CExtendCommand::CExtendCommand()
{
m_nStep = -1;
m_bMulSelMode = FALSE;
m_pGeoCurve = NULL;
m_pDrawProc = NULL;
m_bAutoExtend = TRUE;
m_bSnap3D = FALSE;
strcat(m_strRegPath,"\\Extend");
}
CExtendCommand::~CExtendCommand()
{
}
CString CExtendCommand::Name()
{
return StrFromResID(IDS_CMDNAME_EXTEND);
}
void CExtendCommand::Start()
{
if( !m_pEditor )return;
m_idsRefer.RemoveAll();
m_bMulSelMode = FALSE;
m_pGeoCurve = NULL;
m_pDrawProc = NULL;
m_bAutoExtend = TRUE;
m_bSnap3D = FALSE;
CEditCommand::Start();
m_pEditor->OpenSelector(SELMODE_NORMAL);
m_pDrawProc = new CDrawCurveProcedure;
if( !m_pDrawProc )return;
m_pDrawProc->Init(m_pEditor);
//m_pDrawProc->Start();
m_pGeoCurve = new CGeoCurve;
if(!m_pGeoCurve)
{
Abort();
return ;
}
m_pGeoCurve->SetColor(RGB(255,255,255));
m_pDrawProc->m_pGeoCurve = (CGeoCurve*)m_pGeoCurve;
m_pDrawProc->m_bClosed = FALSE;
int num;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if( num>0 )
{
m_nStep = 2;
for(int i=0;i<num;i++)
{
m_idsRefer.Add(handles[i]);
}
}
if (m_bAutoExtend)
{
m_pEditor->SelectAll();
int num;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if( num>0 )
{
for (int i=0;i<num;i++)
{
m_idsRefer.Add(handles[i]);
}
}
m_pEditor->DeselectAll();
m_nStep = 2;
}
if (m_nStep == 0)
{
GOutPut(StrFromResID(IDS_TIP_SELREFFTRS));
}
else if (m_nStep == 2)
{
GOutPut(StrFromResID(IDS_TIP_SELEXTENDFTRS));
if (m_bMulSelMode)
{
m_pEditor->CloseSelector();
m_pDrawProc->Start();
}
}
}
void CExtendCommand::Finish()
{
UpdateParams(TRUE);
if( m_pDrawProc )
{
m_pDrawProc->m_pGeoCurve = NULL;
delete m_pDrawProc;
m_pDrawProc = NULL;
}
if (m_pGeoCurve)
{
delete m_pGeoCurve;
m_pGeoCurve = NULL;
}
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->DeselectAll();
m_pEditor->RefreshView();
CEditCommand::Finish();
}
void CExtendCommand::Abort()
{
UpdateParams(TRUE);
if( m_pDrawProc )
{
m_pDrawProc->m_pGeoCurve = NULL;
delete m_pDrawProc;
m_pDrawProc = NULL;
}
if (m_pGeoCurve)
{
delete m_pGeoCurve;
m_pGeoCurve = NULL;
}
m_nStep = -1;
m_idsRefer.RemoveAll();
CEditCommand::Abort();
m_pEditor->DeselectAll();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
void CExtendCommand::GetIntersectPoints(PT_3DEX pt0, PT_3DEX pt1, CArray<double,double> &ret, CArray<double,double> &ret_z)
{
int num = m_idsRefer.GetSize();
PT_3D pt3d0, pt3d1, tpt;
COPY_3DPT(pt3d0,pt0);
COPY_3DPT(pt3d1,pt1);
CDlgDataSource *pDS = GETDS(m_pEditor);
for( int i=0; i<num; i++)
{
CFeature *pFtr = HandleToFtr(m_idsRefer[i]);
if (!pFtr) continue;
CFtrLayer *pLayer = pDS->GetFtrLayerOfObject(pFtr);
if (!pLayer) continue;
CFtrArray arrObjs;
CString strLayerName = pLayer->GetName();
if (strLayerName.Find(StrFromResID(IDS_TIP_LAYERNAMECULVERT)) >= 0)
{
pDS->ExplodeSymbolsFinally(pFtr,pLayer,arrObjs,pLayer->GetName());
}
CGeometry *pObj = pFtr->GetGeometry();
if(pObj && pObj->IsKindOf(RUNTIME_CLASS(CGeoParallel)))
{
CGeometry *pObj1=NULL;
CGeometry *pObj2=NULL;
if( ((CGeoParallel*)pObj)->Separate(pObj1,pObj2) )
{
if(pObj1) delete pObj1;
if(pObj2)
{
CFeature *pFtr1 = pFtr->Clone();
if(pFtr1)
{
pFtr1->SetGeometry(pObj2);
arrObjs.Add(pFtr1);
}
}
}
}
arrObjs.Add(pFtr);
for (int j=0; j<arrObjs.GetSize(); j++)
{
CFeature *pFtr0 = arrObjs[j];
if (!pFtr0) continue;
CGeometry *po = pFtr0->GetGeometry();
if( !po )continue;
const CShapeLine *pb = po->GetShape();
if (pb == NULL) continue;
int npt2 = pb->GetPtsCount();
if( npt2<=1 )continue;
CArray<PT_3DEX,PT_3DEX> pts;
pb->GetPts(pts);
for( int k=0; k<npt2-1; k++)
{
if(pts[k].pencode==penMove) continue;
//求交
double vector1x = pt3d1.x-pt3d0.x, vector1y = pt3d1.y-pt3d0.y;
double vector2x = pts[k+1].x-pts[k].x, vector2y = pts[k+1].y-pts[k].y;
double delta = vector1x*vector2y-vector1y*vector2x;
if( delta<1e-10 && delta>-1e-10 )continue;
double t1 = ( (pts[k].x-pt3d0.x)*vector2y-(pts[k].y-pt3d0.y)*vector2x )/delta;
if( t1<=1.0 )continue;
double t2 = ( (pts[k].x-pt3d0.x)*vector1y-(pts[k].y-pt3d0.y)*vector1x )/delta;
if( t2<0.0 || t2>1.0 )continue;
double z = pts[k].z + t2 * (pts[k+1].z-pts[k].z);
tpt.x = pt3d0.x + t1*vector1x; tpt.y = pt3d0.y + t1*vector1y;
if( fabs(tpt.x-pt3d1.x)<1e-4 && fabs(tpt.y-pt3d1.y)<1e-4 )continue;
//由小到大排序
for( int m=0; m<ret.GetSize(); m++)
{
if( t1<ret[m] )break;
}
if( m<ret.GetSize() )
{
ret.InsertAt(m,t1);
ret_z.InsertAt(m,z);
}
else
{
ret.Add(t1);
ret_z.Add(z);
}
}
if (pFtr0 != pFtr)
{
delete pFtr0;
}
}
}
}
void CExtendCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (bool)(m_bMulSelMode);
tab.AddValue(PF_EXTEND_MULSEL,&CVariantEx(var));
var = (bool)(m_bAutoExtend);
tab.AddValue(PF_EXTEND_AUTO,&CVariantEx(var));
var = (long)(m_bSnap3D);
tab.AddValue("Snap3D",&CVariantEx(var));
}
void CExtendCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("ExtendCommand",StrFromLocalResID(IDS_CMDNAME_EXTEND));
param->BeginOptionParam(PF_EXTEND_MULSEL,StrFromResID(IDS_CMDPLANE_MULSEL));
param->AddOption(StrFromResID(IDS_YES),1,' ',m_bMulSelMode);
param->AddOption(StrFromResID(IDS_NO),0,' ',!m_bMulSelMode);
param->EndOptionParam();
param->AddParam(PF_EXTEND_AUTO,(bool)m_bAutoExtend,StrFromResID(IDS_CMDNAME_AUTOEXTEND));
param->BeginOptionParam("Snap3D",StrFromResID(IDS_CMDPLANE_3DSNAP));
param->AddOption(StrFromResID(IDS_YES),1,' ',m_bSnap3D);
param->AddOption(StrFromResID(IDS_NO),0,' ',!m_bSnap3D);
param->EndOptionParam();
}
void CExtendCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_EXTEND_MULSEL,var) )
{
m_bMulSelMode = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
if(!bInit)
{
Abort();
return;
}
}
if( tab.GetValue(0,PF_EXTEND_AUTO,var) )
{
m_bAutoExtend = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
if(!bInit && m_nStep != 1)
{
Abort();
return;
}
}
if( tab.GetValue(0,"Snap3D",var) )
{
m_bSnap3D = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
CProcedure *CExtendCommand::GetActiveSonProc(int nMsgType)
{
if (m_bMulSelMode&&(nMsgType==msgEnd||nMsgType==msgPtMove||nMsgType==msgBack))
{
return m_pDrawProc;
}
return NULL;
}
void CExtendCommand::OnSonEnd(CProcedure *son)
{
if( m_bMulSelMode )
{
if( m_nStep==2 )
{
if( !m_pDrawProc->m_pGeoCurve || !IsProcFinished(m_pDrawProc) )
return;
GrBuffer buf;
m_pDrawProc->m_pGeoCurve->Draw(&buf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
m_pEditor->UpdateDrag(ud_SetConstDrag,&buf);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_nStep = 3;
}
else
{
Abort();
}
}
if( m_pDrawProc )
{
//m_pGeoCurve = (CGeoCurve *)m_pDrawProc->m_pGeoCurve->Clone();
m_pDrawProc->Start();
// if(m_pDrawProc->m_pGeoCurve) delete m_pDrawProc->m_pGeoCurve;
// m_pDrawProc->m_pGeoCurve = NULL;
// delete m_pDrawProc;
// m_pDrawProc = NULL;
//
// CEditCommand::OnSonEnd(son);
}
}
void CExtendCommand::PtReset(PT_3D &pt)
{
if( m_pDrawProc && IsProcProcessing(m_pDrawProc))
{
m_pDrawProc->PtReset(pt);
}
else
Abort();
}
void CExtendCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if( m_nStep==0 )
{
//by mzy
if( SELSTAT_DRAGSEL_RESTART == flag)
{
int num = -1;
m_pEditor->GetSelection()->GetSelectedObjs(num);
if(num <= 0)
return;
m_pEditor->CloseSelector();
m_nStep = 1;
PT_3D ptnull;
memset(&ptnull, 0, sizeof(PT_3D) );
PtClick(ptnull,0);
}
//
if( (flag&SELSTAT_MULTISEL)!=0 )return;
if( !(flag==SELSTAT_NONESEL||(flag&SELSTAT_POINTSEL)!=0||(flag&SELSTAT_DRAGSEL)!=0) )
return;
// if( !CanGetSelObjs(flag) )return;
//GOutPut(StrFromResID(IDS_CMDTIP_CLICKOK));
m_pEditor->CloseSelector();
m_nStep = 1;
}
if (m_nStep == 1)
{
int num;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if( num<=0 )
{
m_pEditor->SelectAll();
handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
}
if (m_bMulSelMode)
{
m_pEditor->CloseSelector();
m_pDrawProc->Start();
}
// 保持选择框不变
//EditStepOne();
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
for (int i=0;i<num;i++)
{
m_idsRefer.Add(handles[i]);
}
m_pEditor->DeselectAll();
GOutPut(StrFromResID(IDS_TIP_SELEXTENDFTRS));
m_nStep = 2;
if (!m_bMulSelMode)
{
m_pEditor->OpenSelector();
}
}
else if( m_nStep==2 )
{
if (m_bMulSelMode)
{
if (m_pDrawProc)
{
GotoState(PROCSTATE_PROCESSING);
m_pDrawProc->PtClick(pt,flag);
}
}
else
{
m_nStep = 3;
}
}
if (m_nStep == 3)
{
// 寻找要延长的地物和相交点
if (m_bMulSelMode)
{
//粗略查找相交地物
Envelope e1, e2;
CArray<PT_3DEX,PT_3DEX> arrGeo;
m_pGeoCurve->GetShape(arrGeo);
int sum = arrGeo.GetSize();
if (sum < 2)
{
Abort();
return;
}
e1.CreateFromPts(arrGeo.GetData(),arrGeo.GetSize(),sizeof(PT_3DEX));
e2 = e1;
e2.TransformGrdToClt(m_pEditor->GetCoordWnd().m_pSearchCS,1);
m_pEditor->GetDataQuery()->FindObjectInRect(e2,m_pEditor->GetCoordWnd().m_pSearchCS);
int num1;
const CPFeature * ppftr1 = m_pEditor->GetDataQuery()->GetFoundHandles(num1);
if( !ppftr1 )
{
Abort();
return;
}
CArray<CPFeature,CPFeature> ftr1;
ftr1.SetSize(num1);
memcpy(ftr1.GetData(),ppftr1,num1*sizeof(*ppftr1));
//获得有效的对象与两线段的相交信息，并排序
CArray<CSmoothCommand::OBJ_ITEM,CSmoothCommand::OBJ_ITEM> arr1;
CSmoothCommand::OBJ_ITEM item;
CGeometry *pObj;
const CShapeLine *pSL;
PT_3DEX *pts;
int size1;
for (int l=0; l<sum-1; l++)
{
for( int i=0; i<num1; i++)
{
size1 = arr1.GetSize();
for( int k=0; k<size1&&arr1[k].id!=(FTR_HANDLE)ftr1[i]; k++);
if (k < size1) continue;
pObj = ftr1[i]->GetGeometry();
if( !pObj )continue;
if( !pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )continue;
if (((CGeoCurve*)pObj)->IsClosed())continue;
//精细检验是否与相交，记录交点
pSL = pObj->GetShape();
if( !pSL )continue;
PT_3D ret;
double t=-1,st0=-1;
CPtrArray arr;
pSL->GetShapeLineUnit(arr);
int pos = 0;
for( k =0;k<arr.GetSize();k++ )
{
CShapeLine::ShapeLineUnit *pUnit = (CShapeLine::ShapeLineUnit *)arr[k];
if( e1.bIntersect(&pUnit->evlp) )
{
pts = pUnit->pts;
for( int j=0; j<pUnit->nuse-1; j++,pts++)
{
if(e1.bIntersect(&pts[0],&pts[1]) )
{
//求相交点
if (!GLineIntersectLineSeg1(arrGeo[l].x,arrGeo[l].y,arrGeo[l+1].x,arrGeo[l+1].y,pts[0].x,pts[0].y,pts[0].z,
pts[1].x,pts[1].y,pts[1].z,&(ret.x),&(ret.y),&(ret.z),&t,&st0))
{
continue;
}
item.id = FtrToHandle(ftr1[i]);item.pos= pos+j; item.ret= ret; item.t = st0;
arr1.Add(item);
goto FINDOVER_1;
}
}
}
pos += pUnit->nuse;
}
FINDOVER_1:;
}
}
CUndoModifyProperties undo(m_pEditor,Name());
for (int i=0; i<arr1.GetSize(); i++)
{
CFeature *pFtr = (CFeature*)arr1[i].id;
if (!pFtr) continue;
CGeometry *pObj = pFtr->GetGeometry();
if( !pObj )return;
PT_3D ret = arr1[i].ret;
//---计算当前点位于哪一个端
double alllen = pObj->GetShape()->GetLength();
double curlen = pObj->GetShape()->GetLength(&ret);
int nIndex = -1;
PT_3DEX expt0, expt1;
if (curlen <= alllen/2)
{
nIndex = 0;
expt0 = pObj->GetDataPoint(1);
expt1 = pObj->GetDataPoint(0);
}
else
{
nIndex = pObj->GetDataPointSum()-1;
expt0 = pObj->GetDataPoint(nIndex-1);
expt1 = pObj->GetDataPoint(nIndex);
}
//计算端点延长后，相交点的位置
CArray<double,double> arrRets, arrRets_z;
GetIntersectPoints(expt0,expt1,arrRets,arrRets_z);
if( arrRets.GetSize()<=0 ) continue;
m_pEditor->DeleteObject(FtrToHandle(pFtr),FALSE);
//延长端点到相交点
double t = arrRets[0];
PT_3DEX expt = expt1;
expt.x = expt0.x + t*(expt1.x-expt0.x);
expt.y = expt0.y + t*(expt1.y-expt0.y);
if( m_bSnap3D )
{
expt.z = arrRets_z[0];
}
COPY_3DPT(m_ptOld,expt1);
COPY_3DPT(m_ptNew,expt);
undo.arrHandles.Add(FtrToHandle(pFtr));
CValueTable tab2;
tab2.BeginAddValueItem();
pFtr->WriteTo(tab2);
tab2.EndAddValueItem();
undo.oldVT.AddItemFromTab(tab2);
pObj->SetDataPoint(nIndex,expt);
m_pEditor->RestoreObject(FtrToHandle(pFtr));
CVariantEx var;
CArray<PT_3DEX,PT_3DEX> arrPts;
pObj->GetShape(arrPts);
var.SetAsShape(arrPts);
if (tab2.SetValue(0,FIELDNAME_SYMBOLNAME,&var))
{
undo.newVT.AddItemFromTab(tab2);
}
}
undo.Commit();
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->DeselectAll();
// for (i=0;i<m_idsRefer.GetSize();i++)
// {
// m_pEditor->SelectObj(m_idsRefer[i]);
// }
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
m_nStep = 2;
// m_nStep = 2;
// Finish();
// m_idsRefer.RemoveAll();
}
else
{
//找到点中的地物
double r = m_pEditor->GetSelection()->GetSelectRadius()*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
PT_3D p1;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&pt,&p1);
CPFeature pFtr = m_pEditor->GetDataQuery()->FindNearestObject(p1,r,m_pEditor->GetCoordWnd().m_pSearchCS);
if( !pFtr )return;
//if( m_pEditor->GetSelection()->IsObjInSelection(FtrToHandle(pFtr)) )return;
CGeometry *pObj = pFtr->GetGeometry();
if( !pObj )return;
if( !pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )return;
if( ((CGeoCurve*)pObj)->IsClosed() )return;
//---计算当前点位于哪一个端
double alllen = pObj->GetShape()->GetLength();
double curlen = pObj->GetShape()->GetLength(&pt);
int nIndex = -1;
PT_3DEX expt0, expt1;
if( curlen<=alllen/2 )
{
nIndex = 0;
expt0 = pObj->GetDataPoint(1);
expt1 = pObj->GetDataPoint(0);
}
else
{
nIndex = pObj->GetDataPointSum()-1;
expt0 = pObj->GetDataPoint(nIndex-1);
expt1 = pObj->GetDataPoint(nIndex);
}
//计算端点延长后，相交点的位置
CArray<double,double> arrRets, arrRets_z;
GetIntersectPoints(expt0,expt1,arrRets,arrRets_z);
if( arrRets.GetSize()<=0 )return;
m_pEditor->DeleteObject(FtrToHandle(pFtr),FALSE);
//延长端点到相交点
double t = arrRets[0];
PT_3DEX expt = expt1;
expt.x = expt0.x + t*(expt1.x-expt0.x);
expt.y = expt0.y + t*(expt1.y-expt0.y);
if( m_bSnap3D )
{
expt.z = arrRets_z[0];
}
COPY_3DPT(m_ptOld,expt1);
COPY_3DPT(m_ptNew,expt);
CUndoModifyProperties undo(m_pEditor,Name());
undo.arrHandles.Add(FtrToHandle(pFtr));
undo.oldVT.BeginAddValueItem();
pFtr->WriteTo(undo.oldVT);
undo.oldVT.EndAddValueItem();
pObj->SetDataPoint(nIndex,expt);
m_pEditor->RestoreObject(FtrToHandle(pFtr));
//m_pEditor->UpdateObject(FtrToHandle(pFtr));
undo.newVT.BeginAddValueItem();
pFtr->WriteTo(undo.newVT);
undo.newVT.EndAddValueItem();
m_pEditor->DeselectAll();
// for (int i=0;i<m_idsRefer.GetSize();i++)
// {
// m_pEditor->SelectObj(m_idsRefer[i]);
// }
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
m_nStep = 2;
// m_nStep = 2;
// Finish();
// m_idsRefer.RemoveAll();
undo.Commit();
}
m_pEditor->RefreshView();
}
CEditCommand::PtClick(pt,flag);
}
//////////////////////////////////////////////////////////////////////
// CCutPartCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CCutPartCommand,CEditCommand)
CCutPartCommand::CCutPartCommand()
{
m_nStep = -1;
m_bMulSelMode = FALSE;
m_bKeepCutPart = FALSE;
m_pGeoCurve = NULL;
m_pDrawProc = NULL;
m_bCutpartSurface = FALSE;
strcat(m_strRegPath,"\\CutPart");
}
CCutPartCommand::~CCutPartCommand()
{
m_idsRefer.RemoveAll();
}
CString CCutPartCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CUTPART);
}
void CCutPartCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (bool)(m_bMulSelMode);
tab.AddValue(PF_EXTEND_MULSEL,&CVariantEx(var));
var = (bool)(m_bKeepCutPart);
tab.AddValue(PF_KEEPCUTPART,&CVariantEx(var));
//var = (bool)(m_bCutpartSurface);
//tab.AddValue(PF_CUTPARTSURFACE,&CVariantEx(var));
}
void CCutPartCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("CutPart",StrFromLocalResID(IDS_CMDNAME_CUTPART));
param->BeginOptionParam(PF_EXTEND_MULSEL,StrFromResID(IDS_CMDPLANE_MULSEL));
param->AddOption(StrFromResID(IDS_YES),1,' ',m_bMulSelMode);
param->AddOption(StrFromResID(IDS_NO),0,' ',!m_bMulSelMode);
param->EndOptionParam();
param->AddParam(PF_KEEPCUTPART,(bool)m_bKeepCutPart,StrFromResID(IDS_CMDPLANE_KEEPCUTPART));
/* param->BeginOptionParam(PF_CUTPARTSURFACE,StrFromResID(IDS_CMDPLANE_TRIM_SURFACE));
param->AddOption(StrFromResID(IDS_YES),1,' ',m_bCutpartSurface);
param->AddOption(StrFromResID(IDS_NO),0,' ',!m_bCutpartSurface);
param->EndOptionParam();*/
}
void CCutPartCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_EXTEND_MULSEL,var) )
{
m_bMulSelMode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
if(!bInit)
Abort();
}
if( tab.GetValue(0,PF_KEEPCUTPART,var) )
{
m_bKeepCutPart = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
/* if( tab.GetValue(0,PF_CUTPARTSURFACE,var) )
{
m_bCutpartSurface = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}*/
CEditCommand::SetParams(tab,bInit);
}
CProcedure *CCutPartCommand::GetActiveSonProc(int nMsgType)
{
if (m_bMulSelMode&&(nMsgType==msgEnd||nMsgType==msgPtMove||nMsgType==msgBack))
{
return m_pDrawProc;
}
return NULL;
}
void CCutPartCommand::OnSonEnd(CProcedure *son)
{
if( m_bMulSelMode )
{
if( m_nStep==2 )
{
if( !m_pDrawProc->m_pGeoCurve || !IsProcFinished(m_pDrawProc) )
return;
GrBuffer buf;
m_pDrawProc->m_pGeoCurve->Draw(&buf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
m_pEditor->UpdateDrag(ud_SetConstDrag,&buf);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_nStep = 3;
}
else
{
Abort();
}
}
if( m_pDrawProc )
{
m_pDrawProc->Start();
// m_pGeoCurve = (CGeoCurve *)m_pDrawProc->m_pGeoCurve->Clone();
// if(m_pDrawProc->m_pGeoCurve) delete m_pDrawProc->m_pGeoCurve;
// m_pDrawProc->m_pGeoCurve = NULL;
// delete m_pDrawProc;
// m_pDrawProc = NULL;
//
// CEditCommand::OnSonEnd(son);
}
}
void CCutPartCommand::PtReset(PT_3D &pt)
{
if( m_pDrawProc && IsProcProcessing(m_pDrawProc))
{
m_pDrawProc->PtReset(pt);
}
else
Abort();
}
void CCutPartCommand::Start()
{
if( !m_pEditor )return;
m_idsRefer.RemoveAll();
CEditCommand::Start();
m_pEditor->OpenSelector();
m_pDrawProc = new CDrawCurveProcedure;
if( !m_pDrawProc )return;
m_pDrawProc->Init(m_pEditor);
//m_pDrawProc->Start();
m_pGeoCurve = new CGeoCurve;
if(!m_pGeoCurve)
{
Abort();
return ;
}
m_pGeoCurve->SetColor(RGB(255,255,255));
m_pDrawProc->m_pGeoCurve = (CGeoCurve*)m_pGeoCurve;
m_pDrawProc->m_bClosed = FALSE;
int num;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if( num>0 )
{
GotoState(PROCSTATE_PROCESSING);
m_nStep = 1;
for(int i=0;i<num;i++)
{
m_idsRefer.Add(handles[i]);
}
}
if (m_bMulSelMode && m_nStep == 1)
{
}
if (m_nStep == 0)
{
GOutPut(StrFromResID(IDS_TIP_SELREFFTRS));
}
else if (m_nStep == 1)
{
GOutPut(StrFromResID(IDS_TIP_SELCUTPARTFTRS));
if (m_bMulSelMode)
{
m_pEditor->CloseSelector();
m_pDrawProc->Start();
}
m_nStep = 2;
}
}
void CCutPartCommand::Abort()
{
UpdateParams(TRUE);
if( m_pDrawProc )
{
m_pDrawProc->m_pGeoCurve = NULL;
delete m_pDrawProc;
m_pDrawProc = NULL;
}
if (m_pGeoCurve)
{
delete m_pGeoCurve;
m_pGeoCurve = NULL;
}
m_nStep = -1;
m_idsRefer.RemoveAll();
CEditCommand::Abort();
m_pEditor->DeselectAll();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
void CCutPartCommand::Finish()
{
UpdateParams(TRUE);
if( m_pDrawProc )
{
m_pDrawProc->m_pGeoCurve = NULL;
delete m_pDrawProc;
m_pDrawProc = NULL;
}
if (m_pGeoCurve)
{
delete m_pGeoCurve;
m_pGeoCurve = NULL;
}
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->DeselectAll();
m_pEditor->RefreshView();
CEditCommand::Finish();
}
void CCutPartCommand::GetIntersectPoints(CGeometry *pObj, CArray<double,double> &ret)
{
const CShapeLine *pSL = pObj->GetShape();
if (!pSL) return;
int npt = pSL->GetPtsCount();
if( npt<=1 )return;
CArray<PT_3DEX,PT_3DEX> pts ;
pSL->GetPts(pts);
int num = m_idsRefer.GetSize();
double t;
PT_3D ptret;
CDlgDataSource *pDS = GETDS(m_pEditor);
for( int i=0; i<num; i++)
{
CFeature *pFtr = HandleToFtr(m_idsRefer[i]);
if (!pFtr) continue;
CFtrLayer *pLayer = pDS->GetFtrLayerOfObject(pFtr);
if (!pLayer) continue;
CFtrArray arrObjs;
CString strLayerName = pLayer->GetName();
if (strLayerName.Find(StrFromResID(IDS_TIP_LAYERNAMECULVERT)) >= 0)
{
pDS->ExplodeSymbolsFinally(pFtr,pLayer,arrObjs,pLayer->GetName());
}
CGeometry *pObj = pFtr->GetGeometry();
if(pObj && pObj->IsKindOf(RUNTIME_CLASS(CGeoParallel)))
{
CGeometry *pObj1=NULL;
CGeometry *pObj2=NULL;
if( ((CGeoParallel*)pObj)->Separate(pObj1,pObj2) )
{
if(pObj1) delete pObj1;
if(pObj2)
{
CFeature *pFtr1 = pFtr->Clone();
if(pFtr1)
{
pFtr1->SetGeometry(pObj2);
arrObjs.Add(pFtr1);
}
}
}
}
arrObjs.Add(pFtr);
for (int n=0; n<arrObjs.GetSize(); n++)
{
CFeature *pFtr0 = arrObjs[n];
if (!pFtr0) continue;
CGeometry *po = pFtr0->GetGeometry();
if( !po )continue;
const CShapeLine *pb = po->GetShape();
if (!pb) continue;
int npt2 = pb->GetPtsCount();
if( npt2<=1 )continue;
CArray<PT_3DEX,PT_3DEX> pts2 ;
pb->GetPts(pts2);
for( int j=0; j<npt-1; j++)
{
// if( pts[j+1].code==GRBUFFER_PTCODE_MOVETO )continue;*/
for( int k=0; k<npt2-1; k++)
{
if(pts2[k].pencode==penMove) continue;
if(/*GraphAPI:: GGetLineIntersectLineSeg*/GLineIntersectLineSegInLimit(pts[j].x,pts[j].y,
pts[j+1].x,pts[j+1].y,pts2[k].x,pts2[k].y,
pts2[k+1].x,pts2[k+1].y,&ptret.x,&ptret.y,&t, NULL, 1e-4) )
//if( CGrTrim::Intersect(&pts[j].pt,&pts[j+1].pt,
// &pts2[k].pt,&pts2[k+1].pt,&ptret,&t) )
{
t = t+j;
//由小到大排序
for( int m=0; m<ret.GetSize(); m++)
{
if( t<=ret[m] )break;
}
if( m<ret.GetSize() )
{
//去除重复的
if( t==ret[m] )continue;
ret.InsertAt(m,t);
}
else ret.Add(t);
}
}
}
if (pFtr0 != pFtr)
{
delete pFtr0;
}
}
}
}
BOOL CCutPartCommand::IsSelfIntersect(CGeometry *pObj)
{
//是否为CGeoCurve和是否闭合，在执行此函数之前已经判断过了，这里不再重复
const CShapeLine* pSL = pObj->GetShape();
CArray<PT_3DEX,PT_3DEX> arrPts;
pSL->GetPts(arrPts);
int num = arrPts.GetSize();
if( num < 4 )
return FALSE;
for(int i = 0; i < num-3; i++)
{
double x0 = arrPts.GetAt(i).x;
double y0 = arrPts.GetAt(i).y;
double x1 = arrPts.GetAt(i+1).x;
double y1 = arrPts.GetAt(i+1).y;
for(int j = i+2; j < num-1; j++) //两条相邻的线段,不算作相交,所以j=i+2
{
double xRet = 0, yRet = 0, T = -1;
double x2 = arrPts.GetAt(j).x;
double y2 = arrPts.GetAt(j).y;
double x3 = arrPts.GetAt(j+1).x;
double y3 = arrPts.GetAt(j+1).y;
if( GraphAPI::GGetLineIntersectLineSeg(x0, y0, x1, y1, x2, y2, x3, y3, &xRet, &yRet, &T) )
{
return TRUE;
}
}
}
return FALSE;
}
void CCutPartCommand::BreakLine(PT_3DEX pt1, PT_3DEX pt2, CGeoCurve* pCurve, CGeometry*& pObj0, CGeometry*& pObj1, CGeometry*& pObj2)
{
const CShapeLine* pSL = pCurve->GetShape();
if( !pSL ) return;
CArray<PT_3DEX,PT_3DEX> arrPts;
pSL->GetPts( arrPts );
int num = arrPts.GetSize();
if( num <= 1 ) return;
//参数传进来的pt1和pt2必然是曲线上的点，可能是节点或者交点
//分别获取两点在线上的位置，由于某一点可能是多段的相交点，因此它的位置可能不止一个
CArray<double,double> pos1, pos2;
int i = 0, j = 0;
for(i = 0; i < num-1; i++)
{
PT_3DEX tmpt1 = arrPts.GetAt(i);
PT_3DEX tmpt2 = arrPts.GetAt(i+1);
if( GraphAPI::GIsPtInLine(tmpt1, tmpt2, pt1) )
{
double ratio = 0;
if( fabs(pt1.x-tmpt1.x) < 1e-4 && fabs(pt1.y-tmpt1.y) < 1e-4 );
else if( fabs(pt1.x-tmpt2.x) < 1e-4 && fabs(pt1.y-tmpt2.y) < 1e-4 )
ratio = 1;
else if( fabs(tmpt2.x-tmpt1.x) < 1e-4 )
ratio = (pt1.y-tmpt1.y) / (tmpt2.y-tmpt1.y);
else
ratio = (pt1.x-tmpt1.x) / (tmpt2.x-tmpt1.x);
pos1.Add(i+ratio);
i++; //如果一个交点出现在某一段，就绝不会出现在下一个相邻段（节点例个，但需去重）
}
}
int nr1 = pos1.GetSize();
if( nr1 <= 0 ) return;
for(i = 0; i < num-1; i++)
{
PT_3DEX tmpt1 = arrPts.GetAt(i);
PT_3DEX tmpt2 = arrPts.GetAt(i+1);
if( GraphAPI::GIsPtInLine(tmpt1, tmpt2, pt2) )
{
double ratio = 0;
if( fabs(pt2.x-tmpt1.x) < 1e-4 && fabs(pt2.y-tmpt1.y) < 1e-4 );
else if( fabs(pt2.x-tmpt2.x) < 1e-4 && fabs(pt2.y-tmpt2.y) < 1e-4 )
ratio = 1;
else if( fabs(tmpt2.x-tmpt1.x) < 1e-4 )
ratio = (pt2.y-tmpt1.y) / (tmpt2.y-tmpt1.y);
else
ratio = (pt2.x-tmpt1.x) / (tmpt2.x-tmpt1.x);
pos2.Add(i+ratio);
i++; //如果一个交点出现在某一段，就绝不会出现在下一个相邻段（节点例个，但需去重）
}
}
int nr2 = pos2.GetSize();
if( nr2 <= 0 ) return;
//找到第一个pt2前的最后一个pt1的位置 rpos; [0-rpos]作为一段
//找到第一个比rpos大的pt2的位置rpos2; [rpos-rpos2]作为一段
//rpos2到结束作为一段
double rpos = -1;
for(i = 0; i < nr1; i++)
{
if( pos2.GetAt(0) <= pos1.GetAt(i) )
{
if( 0 == i )
rpos = pos1.GetAt(i);
else
rpos = pos1.GetAt(i-1);
break;
}
}
if( rpos == -1 && i >= nr1)
rpos= pos1.GetAt(nr1-1);
double rpos2 = -1;
for(i = 0; i < nr2; i++)
{
if(pos2.GetAt(i) >= rpos)
{
rpos2 = pos2.GetAt(i);
break;
}
}
if( rpos2 == -1 && i >= nr2)
return;
int imin = (int)rpos;
int imax = (int)rpos2;
pObj0 = NULL; pObj1 = NULL; pObj2 = NULL;
CArray<PT_3DEX,PT_3DEX> pts;
//第一段
{
CGeoCurveBase *pObj = (CGeoCurveBase*)pCurve->Clone();
for(int i = 0; i <= imin; i++)
{
PT_3DEX pt = arrPts.GetAt(i);
pts.Add( pt );
}
if( fabs(rpos-imin) > 1e-4 )
{
PT_3DEX ptoo = pt1;
ptoo.pencode = 2;
pts.Add( ptoo );
}
if( pts.GetSize() > 1 )
{
if(!pObj->CreateShape(pts.GetData(),pts.GetSize()))
return;
else
pObj0 = pObj;
}
if( pObj0 && pObj0->GetDataPointSum()==2 )
{
PT_3DEX expt1, expt2;
expt1 = pObj0->GetDataPoint(0);
expt2 = pObj0->GetDataPoint(1);
if( fabs(expt1.x-expt2.x)<1e-6 && fabs(expt1.y-expt2.y)<1e-6 )
{
delete pObj0;
pObj0 = NULL;
}
}
}
//第二段
pts.RemoveAll();
{
CGeoCurveBase *pObj = (CGeoCurveBase*)pCurve->Clone();
PT_3DEX ptoo = pt1;
ptoo.pencode = 2;
pts.Add( ptoo );
for(i = imin+1; i <= imax; i++)
{
PT_3DEX pt = arrPts.GetAt(i);
pts.Add( pt );
}
if( fabs(rpos2-imax) > 1e-4 )
{
PT_3DEX ptoo2 = pt2;
ptoo2.pencode = 2;
pts.Add( ptoo2 );
}
if(!pObj->CreateShape(pts.GetData(),pts.GetSize()))
return;
else
pObj1 = pObj;
}
//第三段
pts.RemoveAll();
{
CGeoCurveBase *pObj = (CGeoCurveBase*)pCurve->Clone();
PT_3DEX ptoo2 = pt2;
ptoo2.pencode = 2;
pts.Add( ptoo2 );
for(i = imax+1; i < num; i++)
{
PT_3DEX pt = arrPts.GetAt(i);
pts.Add( pt );
}
if( pts.GetSize() > 1 )
{
if(!pObj->CreateShape(pts.GetData(),pts.GetSize()))
return;
else
pObj2 = pObj;
}
if( pObj2 && pObj2->GetDataPointSum()==2 )
{
PT_3DEX expt1, expt2;
expt1 = pObj2->GetDataPoint(0);
expt2 = pObj2->GetDataPoint(1);
if( fabs(expt1.x-expt2.x)<1e-6 && fabs(expt1.y-expt2.y)<1e-6 )
{
delete pObj2;
pObj2 = NULL;
}
}
}
return;
}
void CCutPartCommand::UpdateFtrHiliteDisplay()
{
CFtrsHighliteDisplay hd;
hd.SetDoc(PDOC(m_pEditor));
for (int i=0;i<m_idsRefer.GetSize();i++)
{
hd.Add(HandleToFtr(m_idsRefer[i]));
}
hd.Highlite();
}
void CCutPartCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if( m_nStep==0 )
{
//by mzy
if( SELSTAT_DRAGSEL_RESTART == flag)
{
int num = -1;
m_pEditor->GetSelection()->GetSelectedObjs(num);
if(num <= 0)
return;
m_pEditor->CloseSelector();
m_nStep = 1;
PT_3D ptnull;
memset(&ptnull, 0, sizeof(PT_3D) );
PtClick(ptnull,0);
}
//
if( (flag&SELSTAT_MULTISEL)!=0 )return;
if( !(flag==SELSTAT_NONESEL||(flag&SELSTAT_POINTSEL)!=0||(flag&SELSTAT_DRAGSEL)!=0) )
return;
// if( !CanGetSelObjs(flag) )return;
// GOutPut(StrFromResID(IDS_CMDTIP_CLICKOK));
m_pEditor->CloseSelector();
m_nStep = 1;
}
if (m_nStep == 1)
{
int num;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
if( num<=0 )
{
m_pEditor->SelectAll();
handles = m_pEditor->GetSelection()->GetSelectedObjs(num);
}
if (m_bMulSelMode)
{
m_pEditor->CloseSelector();
m_pDrawProc->Start();
}
//EditStepOne();
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
m_idsRefer.RemoveAll();
for (int i=0;i<num;i++)
{
m_idsRefer.Add(handles[i]);
}
UpdateFtrHiliteDisplay();
m_pEditor->DeselectAll();
GOutPut(StrFromResID(IDS_TIP_SELCUTPARTFTRS));
m_nStep = 2;
if (!m_bMulSelMode)
{
m_pEditor->OpenSelector();
}
}
else if( m_nStep==2 )
{
if (m_bMulSelMode)
{
if (m_pDrawProc)
{
GotoState(PROCSTATE_PROCESSING);
m_pDrawProc->PtClick(pt,flag);
}
}
else
{
m_nStep = 3;
}
}
if (m_nStep == 3)
{
if (m_bMulSelMode)
{
//粗略查找相交地物
Envelope e, e1;
CArray<PT_3DEX,PT_3DEX> arrGeo;
m_pGeoCurve->GetShape(arrGeo);
int sum = arrGeo.GetSize();
if (sum < 2)
{
Abort();
return;
}
e.CreateFromPts(arrGeo.GetData(),arrGeo.GetSize(),sizeof(PT_3DEX));
e1 = e;
e1.TransformGrdToClt(m_pEditor->GetCoordWnd().m_pSearchCS,1);
m_pEditor->GetDataQuery()->FindObjectInRect(e1,m_pEditor->GetCoordWnd().m_pSearchCS);
int num1;
const CPFeature * ppftr1 = m_pEditor->GetDataQuery()->GetFoundHandles(num1);
if( !ppftr1 )
{
Abort();
return;
}
CArray<CPFeature,CPFeature> ftr1;
ftr1.SetSize(num1);
memcpy(ftr1.GetData(),ppftr1,num1*sizeof(*ppftr1));
//获得有效的对象与两线段的相交信息，并排序
CArray<CSmoothCommand::OBJ_ITEM,CSmoothCommand::OBJ_ITEM> arr1;
CSmoothCommand::OBJ_ITEM item;
CGeometry *pObj;
const CShapeLine *pSL;
PT_3DEX *pts;
int size1;
for (int l=0; l<sum-1; l++)
{
for( int i=0; i<num1; i++)
{
size1 = arr1.GetSize();
for( int k=0; k<size1&&arr1[k].id!=(FTR_HANDLE)ftr1[i]; k++);
if (k < size1) continue;
pObj = ftr1[i]->GetGeometry();
if( !pObj )continue;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoText)) )continue;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoPoint)) )continue;
//if( pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )continue;
//精细检验是否与相交，记录交点
pSL = pObj->GetShape();
if( !pSL )continue;
PT_3D ret;
double t=-1,st0=-1;
CPtrArray arr;
pSL->GetShapeLineUnit(arr);
int pos = 0;
for( k =0;k<arr.GetSize();k++ )
{
CShapeLine::ShapeLineUnit *pUnit = (CShapeLine::ShapeLineUnit *)arr[k];
if( e.bIntersect(&pUnit->evlp) )
{
pts = pUnit->pts;
for( int j=0; j<pUnit->nuse-1; j++,pts++)
{
if(e.bIntersect(&pts[0],&pts[1]) )
{
//求相交点
if (!GLineIntersectLineSeg1(arrGeo[l].x,arrGeo[l].y,arrGeo[l+1].x,arrGeo[l+1].y,pts[0].x,pts[0].y,pts[0].z,
pts[1].x,pts[1].y,pts[1].z,&(ret.x),&(ret.y),&(ret.z),&t,&st0))
{
continue;
}
item.id = FtrToHandle(ftr1[i]);item.pos= pos+j; item.ret= ret; item.t = st0;
arr1.Add(item);
goto FINDOVER_1;
}
}
}
pos += pUnit->nuse;
}
FINDOVER_1:;
}
}
CUndoFtrs undo(m_pEditor,Name());
for (int f=0; f<arr1.GetSize(); f++)
{
CFeature *pFtr = (CFeature*)arr1[f].id;
CGeometry *pObj = pFtr->GetGeometry();
if( !pObj )continue;
PT_3D ret = arr1[f].ret;
double r = m_pEditor->GetSelection()->GetSelectRadius()*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
PT_3D ptclt;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&ret,&ptclt);
Envelope cltEnlp;
cltEnlp.CreateFromPtAndRadius(ptclt,r);
BOOL bClosed = FALSE;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) && ((CGeoCurve*)pObj)->IsClosed() )
bClosed = TRUE;
BOOL bSurface = FALSE;
CFeature *pOldFtr = NULL, *pNewFtr = NULL;
if (pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
{
CDlgDataSource *pDS = GETDS(m_pEditor);
CFtrLayer *pFtrLayer = pDS->GetFtrLayerOfObject(pFtr);
if (!pFtrLayer)
{
Abort();
return;
}
pNewFtr = pFtrLayer->CreateDefaultFeature(PDOC(m_pEditor)->GetDlgDataSource()->GetScale(),CLS_GEOCURVE);
if( pNewFtr==NULL )
{
Abort();
return;
}
// 复制固定属性
CValueTable tab;
tab.BeginAddValueItem();
pFtr->WriteTo(tab);
tab.EndAddValueItem();
tab.DelField(FIELDNAME_SHAPE);
tab.DelField(FIELDNAME_GEOCURVE_CLOSED);
tab.DelField(FIELDNAME_FTRID);
tab.DelField(FIELDNAME_GEOCLASS);
pNewFtr->ReadFrom(tab);
CArray<PT_3DEX,PT_3DEX> arrPts;
pFtr->GetGeometry()->GetShape(arrPts);
//arrPts.Add(arrPts[0]);
pNewFtr->GetGeometry()->CreateShape(arrPts.GetData(),arrPts.GetSize());
pOldFtr = pFtr;
pFtr = pNewFtr;
pObj = pFtr->GetGeometry();
bClosed = TRUE;
bSurface = TRUE;
}
//---判断当前点位于哪一个相交段
const CShapeLine *pBuf = pObj->GetShape();
CArray<PT_3DEX,PT_3DEX> arrPts;
int num = pBuf->GetPtsCount();
if( num<=0 )continue;
pBuf->GetPts(arrPts);
// 1) 找最近的图形点
PT_3D rpt;
double x,y,z;
double dis,min=-1;
int k;
for( int i=0; i<num-1; i++)
{
//求出当前线段的最近距离
dis = GraphAPI::GGetNearestDisOfPtToLine3D(arrPts[i].x,arrPts[i].y,arrPts[i].z,
arrPts[i+1].x,arrPts[i+1].y,arrPts[i+1].z,ret.x,ret.y,ret.z,&x,&y,&z,false);
if( min<0 || dis<min )
{
min = dis; rpt.x=x; rpt.y=y; rpt.z=z;
k = i;
}
}
// 2) 得到当前点落在基线上的位置变量 t（整数部分表示线段序号，小数部分表示线段上的位置）
double t = k;
if( fabs(rpt.x-arrPts[k].x)<1e-4 && fabs(rpt.y-arrPts[k].y)<1e-4 );
else if( fabs(rpt.x-arrPts[k+1].x)<1e-4 && fabs(rpt.y-arrPts[k+1].y)<1e-4 )
t += 1;
else if( fabs(arrPts[k+1].x-arrPts[k].x)<1e-4 )
t += (rpt.y-arrPts[k].y)/(arrPts[k+1].y-arrPts[k].y);
else t += (rpt.x-arrPts[k].x)/(arrPts[k+1].x-arrPts[k].x);
// 首先检测当前点是否为相交中间段，若为中间段一起处理，否则一段段处理
BOOL bRefSelf = FALSE;
for ( i=0;i<m_idsRefer.GetSize();i++)
{
if (m_idsRefer[i] == FTR_HANDLE(pFtr))
{
bRefSelf = TRUE;
break;
}
}
//计算所有相交点
CArray<double,double> arrRet;
if (bRefSelf)
{
m_idsRefer.RemoveAt(i);
GetIntersectPoints(pObj,arrRet);
int nsz = arrRet.GetSize();
for( i=0; i<nsz; i++)
{
if( t<arrRet[i] )break;
}
if (nsz == 0 || i == 0 || i >= nsz)
{
m_idsRefer.Add(FTR_HANDLE(pFtr));
arrRet.RemoveAll();
GetIntersectPoints(pObj,arrRet);
}
else
{
m_idsRefer.Add(FTR_HANDLE(pFtr));
}
}
else
{
GetIntersectPoints(pObj,arrRet);
}
if( arrRet.GetSize()<=0 ) continue;
// 3) 根据位置变量的关系得到相交段
int nsz = arrRet.GetSize();
for( i=0; i<nsz; i++)
{
if( t<arrRet[i] )break;
}
// 4) 得到相交段的起始点（交点）
PT_3D pt1, pt2;
if( i==0 )
{
pt1 = arrPts[0];
//如果是闭合，相交点应该是最后一个交点
if( bClosed )
{
i = nsz;
k = (int)(arrRet[i-1]);
pt1.x = arrPts[k].x + (arrRet[i-1]-k)*(arrPts[k+1].x-arrPts[k].x);
pt1.y = arrPts[k].y + (arrRet[i-1]-k)*(arrPts[k+1].y-arrPts[k].y);
pt1.z = arrPts[k].z + (arrRet[i-1]-k)*(arrPts[k+1].z-arrPts[k].z);
}
}
else
{
k = (int)(arrRet[i-1]);
pt1.x = arrPts[k].x + (arrRet[i-1]-k)*(arrPts[k+1].x-arrPts[k].x);
pt1.y = arrPts[k].y + (arrRet[i-1]-k)*(arrPts[k+1].y-arrPts[k].y);
pt1.z = arrPts[k].z + (arrRet[i-1]-k)*(arrPts[k+1].z-arrPts[k].z);
}
if( i>=nsz )
{
pt2 = arrPts[num-1];
//如果是闭合，相交点应该是第一个交点
if( bClosed )
{
i = 0;
pt2.x = arrPts[k].x;
pt2.y = arrPts[k].y;
pt2.z = arrPts[k].z;
if(fabs(arrRet[i]-k)>1e-6)
{
pt2.x += (arrRet[i]-k)*(arrPts[k+1].x-arrPts[k].x);
pt2.y += (arrRet[i]-k)*(arrPts[k+1].y-arrPts[k].y);
pt2.z += (arrRet[i]-k)*(arrPts[k+1].z-arrPts[k].z);
}
}
}
else
{
k = (int)(arrRet[i]);
pt2.x = arrPts[k].x;
pt2.y = arrPts[k].y;
pt2.z = arrPts[k].z;
if(fabs(arrRet[i]-k)>1e-6)
{
pt2.x += (arrRet[i]-k)*(arrPts[k+1].x-arrPts[k].x);
pt2.y += (arrRet[i]-k)*(arrPts[k+1].y-arrPts[k].y);
pt2.z += (arrRet[i]-k)*(arrPts[k+1].z-arrPts[k].z);
}
}
// delete[] pts;
//根据起始去除该段，并生成新地物
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )
{
CGeoCurve *pCurve = (CGeoCurve*)pObj;
CGeometry *pObjs[3] = {0};
pCurve->GetBreak(pt1,pt2,pObjs[0],pObjs[1],pObjs[2]);
//-------将需要删除的部分删除，需要生成的部分保留或者合并
//删除中间部分
BOOL bDelMid = FALSE;
if( !bClosed )
{
if (!m_bKeepCutPart)
{
if( pObjs[1] )delete pObjs[1]; pObjs[1] = NULL;
}
}
//如果地物处于闭合时，删除的那部分可能并不是中间的一部分，这里做一次判断
else
{
if( pObjs[1] )
{
PT_3D tpt;
if( (pObjs[1])->FindNearestBasePt(ptclt,cltEnlp,m_pEditor->GetCoordWnd().m_pSearchCS,&tpt,NULL) )
{
//if( fabs(tpt.x-rpt.x)<1e-4 && fabs(tpt.y-rpt.y)<1e-4 )
{
bDelMid = TRUE;
}
}
}
//首尾合并
if( bDelMid )
{
if (!m_bKeepCutPart)
{
if( pObjs[1] )delete pObjs[1]; pObjs[1] = NULL;
}
//不能全空
if( pObjs[0]==NULL && pObjs[2]==NULL )return;
if( pObjs[0] && pObjs[2] )
{
int nkeypt = pObjs[0]->GetDataPointSum();
// PT_3DEX expt;
CArray<PT_3DEX,PT_3DEX> pts;
pObjs[2]->GetShape(pts);
for( i=0; i<nkeypt; i++ )
{
pts.Add(pObjs[0]->GetDataPoint(i));
}
pObjs[2]->CreateShape(pts.GetData(),pts.GetSize());
delete pObjs[0]; pObjs[0] = NULL;
}
}
//首尾删除
else
{
if (!m_bKeepCutPart)
{
if( pObjs[0] )delete pObjs[0]; pObjs[0] = NULL;
if( pObjs[2] )delete pObjs[2]; pObjs[2] = NULL;
}
}
}
//不能全空
if( pObjs[0]==NULL && pObjs[1]==NULL && pObjs[2]==NULL )return;
if (pNewFtr)
{
pFtr = pOldFtr;
delete pNewFtr;
}
CDlgDataSource *pDS = GETDS(m_pEditor);
CFtrLayer *pFtrLayer = pDS->GetFtrLayerOfObject(pFtr);
if (!pFtrLayer)
{
Abort();
return;
}
int nLayerIdOfKeep = pFtrLayer->GetID();
if (m_bKeepCutPart)
{
CString strKeepLayerName;
strKeepLayerName.Format("%s_%s",pFtrLayer->GetName(),Name());
CFtrLayer *pKeepFtrLayer = pDS->GetFtrLayer(strKeepLayerName);
if (pKeepFtrLayer == NULL)
{
pKeepFtrLayer = pDS->CreateFtrLayer(strKeepLayerName);
if (!pKeepFtrLayer)
{
Abort();
return;
}
pKeepFtrLayer->SetColor(pFtrLayer->GetColor());
pDS->AddFtrLayer(pKeepFtrLayer);
}
nLayerIdOfKeep = pKeepFtrLayer->GetID();
}
if( pObjs[0] )
{
CFeature *pF = pFtr->Clone();
pF->SetID(OUID());
BOOL bVisible = (!bClosed||bDelMid);
pF->EnableVisible(bVisible);
pF->SetToDeleted(FALSE);
if (m_bCutpartSurface)
{
pF->SetGeometry(pObjs[0]);
}
else
{
CArray<PT_3DEX,PT_3DEX> pts0;
pObjs[0]->GetShape(pts0);
CGeoCurve *pCurve = new CGeoCurve();
pCurve->CreateShape(pts0.GetData(),pts0.GetSize());
pF->SetGeometry(pCurve);
delete pObjs[0];
}
int layid = bVisible?m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(pFtr)):nLayerIdOfKeep;
m_pEditor->AddObject(pF,layid);
GETXDS(m_pEditor)->CopyXAttributes(pFtr,pF);
undo.arrNewHandles.Add(FtrToHandle(pF));
}
if( pObjs[1] )
{
CFeature *pF = pFtr->Clone();
pF->SetID(OUID());
BOOL bVisible = (bClosed&&!bDelMid);
pF->EnableVisible(bVisible);
pF->SetToDeleted(FALSE);
if (m_bCutpartSurface)
{
pF->SetGeometry(pObjs[1]);
}
else
{
CArray<PT_3DEX,PT_3DEX> pts0;
pObjs[1]->GetShape(pts0);
CGeoCurve *pCurve = new CGeoCurve();
pCurve->CreateShape(pts0.GetData(),pts0.GetSize());
pF->SetGeometry(pCurve);
delete pObjs[1];
}
int layid = bVisible?m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(pFtr)):nLayerIdOfKeep;
m_pEditor->AddObject(pF,layid);
GETXDS(m_pEditor)->CopyXAttributes(pFtr,pF);
undo.arrNewHandles.Add(FtrToHandle(pF));
}
if( pObjs[2] )
{
CFeature *pF = pFtr->Clone();
pF->SetID(OUID());
BOOL bVisible = (!bClosed||bDelMid);
pF->EnableVisible(bVisible);
pF->SetToDeleted(FALSE);
if (m_bCutpartSurface)
{
pF->SetGeometry(pObjs[2]);
}
else
{
CArray<PT_3DEX,PT_3DEX> pts0;
pObjs[2]->GetShape(pts0);
CGeoCurve *pCurve = new CGeoCurve();
pCurve->CreateShape(pts0.GetData(),pts0.GetSize());
pF->SetGeometry(pCurve);
delete pObjs[2];
}
int layid = bVisible?m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(pFtr)):nLayerIdOfKeep;
m_pEditor->AddObject(pF,layid);
GETXDS(m_pEditor)->CopyXAttributes(pFtr,pF);
undo.arrNewHandles.Add(FtrToHandle(pF));
}
m_pEditor->DeleteObject(FtrToHandle(pFtr));
undo.arrOldHandles.Add(FtrToHandle(pFtr));
int numRef = m_idsRefer.GetSize();
for (int k=numRef-1; k>=0; k--)
{
if (m_idsRefer[k] == FtrToHandle(pFtr))
{
m_idsRefer.RemoveAt(k);
for (int m=0; m<undo.arrNewHandles.GetSize(); m++)
{
m_idsRefer.Add(undo.arrNewHandles[m]);
}
break;
}
}
}
}
undo.Commit();
UpdateFtrHiliteDisplay();
m_pEditor->DeselectAll();
// for (i=0;i<m_idsRefer.GetSize();i++)
// {
// m_pEditor->SelectObj(m_idsRefer[i]);
// }
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
m_nStep = 2;
// m_nStep = 2;
// Finish();
// m_idsRefer.RemoveAll();
}
else
{
//找到点中的地物
double r = m_pEditor->GetSelection()->GetSelectRadius()*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
PT_3D p1;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&pt,&p1);
Envelope e;
e.CreateFromPtAndRadius(p1,r);
CPFeature pFtr = m_pEditor->GetDataQuery()->FindNearestObject(p1,r,m_pEditor->GetCoordWnd().m_pSearchCS);
if( !pFtr )return;
//if( m_pEditor->GetSelection()->IsObjInSelection(FtrToHandle(pFtr)) )return;
CGeometry *pObj = pFtr->GetGeometry();
if( !pObj )return;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoText)) )return;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoPoint)) )return;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoMultiPoint)) )return;
BOOL bClosed = FALSE;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) && ((CGeoCurve*)pObj)->IsClosed() )
bClosed = TRUE;
BOOL bSurface = FALSE;
CFeature *pOldFtr = NULL, *pNewFtr = NULL;
if (pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
{
CDlgDataSource *pDS = GETDS(m_pEditor);
CFtrLayer *pFtrLayer = pDS->GetFtrLayerOfObject(pFtr);
if (!pFtrLayer)
{
Abort();
return;
}
pNewFtr = pFtrLayer->CreateDefaultFeature(PDOC(m_pEditor)->GetDlgDataSource()->GetScale(),CLS_GEOCURVE);
if( pNewFtr==NULL )
{
Abort();
return;
}
// 复制固定属性
CValueTable tab;
tab.BeginAddValueItem();
pFtr->WriteTo(tab);
tab.EndAddValueItem();
tab.DelField(FIELDNAME_SHAPE);
tab.DelField(FIELDNAME_GEOCURVE_CLOSED);
tab.DelField(FIELDNAME_FTRID);
tab.DelField(FIELDNAME_GEOCLASS);
pNewFtr->ReadFrom(tab);
CArray<PT_3DEX,PT_3DEX> arrPts;
pFtr->GetGeometry()->GetShape(arrPts);
//arrPts.Add(arrPts[0]);
pNewFtr->GetGeometry()->CreateShape(arrPts.GetData(),arrPts.GetSize());
pOldFtr = pFtr;
pFtr = pNewFtr;
pObj = pFtr->GetGeometry();
bClosed = TRUE;
bSurface = TRUE;
}
//---判断当前点位于哪一个相交段
const CShapeLine *pBuf = pObj->GetShape();
CArray<PT_3DEX,PT_3DEX> arrPts;
int num = pBuf->GetPtsCount();
if( num<=0 )return;
pBuf->GetPts(arrPts);
// 1) 找最近的图形点
PT_3D rpt;
double x,y,z;
double dis,min=-1;
int k;
for( int i=0; i<num-1; i++)
{
//求出当前线段的最近距离
dis = GraphAPI::GGetNearestDisOfPtToLine3D(arrPts[i].x,arrPts[i].y,arrPts[i].z,
arrPts[i+1].x,arrPts[i+1].y,arrPts[i+1].z,pt.x,pt.y,pt.z,&x,&y,&z,false);
if( min<0 || dis<min )
{
min = dis; rpt.x=x; rpt.y=y; rpt.z=z;
k = i;
}
}
// 2) 得到当前点落在基线上的位置变量 t（整数部分表示线段序号，小数部分表示线段上的位置）
double t = k;
if( fabs(rpt.x-arrPts[k].x)<1e-4 && fabs(rpt.y-arrPts[k].y)<1e-4 );
else if( fabs(rpt.x-arrPts[k+1].x)<1e-4 && fabs(rpt.y-arrPts[k+1].y)<1e-4 )
t += 1;
else if( fabs(arrPts[k+1].x-arrPts[k].x)<1e-4 )
t += (rpt.y-arrPts[k].y)/(arrPts[k+1].y-arrPts[k].y);
else t += (rpt.x-arrPts[k].x)/(arrPts[k+1].x-arrPts[k].x);
// 首先检测当前点是否为相交中间段，若为中间段一起处理，否则一段段处理
BOOL bRefSelf = FALSE;
for ( i=0;i<m_idsRefer.GetSize();i++)
{
if (m_idsRefer[i] == FTR_HANDLE(pFtr))
{
bRefSelf = TRUE;
break;
}
}
//计算所有相交点
CArray<double,double> arrRet;
if (bRefSelf)
{
m_idsRefer.RemoveAt(i);
GetIntersectPoints(pObj,arrRet);
int nsz = arrRet.GetSize();
for( i=0; i<nsz; i++)
{
if( t<arrRet[i] )break;
}
if (nsz == 0 || i == 0 || i >= nsz)
{
m_idsRefer.Add(FTR_HANDLE(pFtr));
arrRet.RemoveAll();
GetIntersectPoints(pObj,arrRet);
}
else
{
m_idsRefer.Add(FTR_HANDLE(pFtr));
}
}
else
{
GetIntersectPoints(pObj,arrRet);
}
if( arrRet.GetSize()<=0 )return;
// 3) 根据位置变量的关系得到相交段
int nsz = arrRet.GetSize();
for( i=0; i<nsz; i++)
{
if( t<arrRet[i] )break;
}
// 4) 得到相交段的起始点（交点）
PT_3D pt1, pt2;
if( i==0 )
{
pt1 = arrPts[0];
//如果是闭合，相交点应该是最后一个交点
if( bClosed )
{
i = nsz;
k = (int)(arrRet[i-1]);
pt1.x = arrPts[k].x + (arrRet[i-1]-k)*(arrPts[k+1].x-arrPts[k].x);
pt1.y = arrPts[k].y + (arrRet[i-1]-k)*(arrPts[k+1].y-arrPts[k].y);
pt1.z = arrPts[k].z + (arrRet[i-1]-k)*(arrPts[k+1].z-arrPts[k].z);
}
}
else
{
k = (int)(arrRet[i-1]);
pt1.x = arrPts[k].x + (arrRet[i-1]-k)*(arrPts[k+1].x-arrPts[k].x);
pt1.y = arrPts[k].y + (arrRet[i-1]-k)*(arrPts[k+1].y-arrPts[k].y);
pt1.z = arrPts[k].z + (arrRet[i-1]-k)*(arrPts[k+1].z-arrPts[k].z);
}
if( i>=nsz )
{
pt2 = arrPts[num-1];
//如果是闭合，相交点应该是第一个交点
if( bClosed )
{
i = 0;
k = (int)(arrRet[i]);
pt2.x = arrPts[k].x + (arrRet[i]-k)*(arrPts[k+1].x-arrPts[k].x);
pt2.y = arrPts[k].y + (arrRet[i]-k)*(arrPts[k+1].y-arrPts[k].y);
pt2.z = arrPts[k].z + (arrRet[i]-k)*(arrPts[k+1].z-arrPts[k].z);
}
}
else
{
k = (int)(arrRet[i]);
if (k == num - 1)
{
pt2.x = arrPts[k].x;
pt2.y = arrPts[k].y;
pt2.z = arrPts[k].z;
}
else
{
pt2.x = arrPts[k].x + (arrRet[i] - k)*(arrPts[k + 1].x - arrPts[k].x);
pt2.y = arrPts[k].y + (arrRet[i] - k)*(arrPts[k + 1].y - arrPts[k].y);
pt2.z = arrPts[k].z + (arrRet[i] - k)*(arrPts[k + 1].z - arrPts[k].z);
}
}
// delete[] pts;
//根据起始去除该段，并生成新地物
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )
{
CGeoCurve *pCurve = (CGeoCurve*)pObj;
CGeometry *pObjs[3] = {0};
// pCurve->GetBreak(pt1,pt2,pObjs[0],pObjs[1],pObjs[2]);
if( IsSelfIntersect(pObj) && !bClosed )
{
PT_3DEX ptex1, ptex2;
ptex1.x = pt1.x; ptex1.y = pt1.y; ptex1.z = pt1.z;
ptex2.x = pt2.x; ptex2.y = pt2.y; ptex2.z = pt2.z;
BreakLine(ptex1, ptex2, pCurve, pObjs[0],pObjs[1],pObjs[2]);
}
else
pCurve->GetBreak(pt1,pt2,pObjs[0],pObjs[1],pObjs[2]);
//-------将需要删除的部分删除，需要生成的部分保留或者合并
//删除中间部分
BOOL bDelMid = FALSE;
if( !bClosed )
{
if (!m_bKeepCutPart)
{
if( pObjs[1] )delete pObjs[1]; pObjs[1] = NULL;
}
}
//如果地物处于闭合时，删除的那部分可能并不是中间的一部分，这里做一次判断
else
{
if( pObjs[1] )
{
PT_3D p1;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&pt,&p1);
PT_3D tpt;
if( (pObjs[1])->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&tpt,NULL) )
{
//if( fabs(tpt.x-rpt.x)<1e-4 && fabs(tpt.y-rpt.y)<1e-4 )
{
bDelMid = TRUE;
}
}
}
//首尾合并
if( bDelMid )
{
if (!m_bKeepCutPart)
{
if( pObjs[1] )delete pObjs[1]; pObjs[1] = NULL;
}
//不能全空
if( pObjs[0]==NULL && pObjs[2]==NULL )return;
if( pObjs[0] && pObjs[2] )
{
int nkeypt = pObjs[0]->GetDataPointSum();
// PT_3DEX expt;
CArray<PT_3DEX,PT_3DEX> pts;
pObjs[2]->GetShape(pts);
//by mzy相接处的点可能为闭合地物最初的起始点，这里判断一下
PT_3DEX ptof0 = pObjs[0]->GetDataPoint(0);
PT_3DEX ptof2 = pts.GetAt( pts.GetSize()-1 );
i = 0;
if( fabs(ptof0.x-ptof2.x)<1e-4 && fabs(ptof0.y-ptof2.y)<1e-4 && fabs(ptof0.z-ptof2.z)<1e-4 )
i = 1;
//
for( /*i=0*/; i<nkeypt; i++ )
{
pts.Add(pObjs[0]->GetDataPoint(i));
}
pObjs[2]->CreateShape(pts.GetData(),pts.GetSize());
delete pObjs[0]; pObjs[0] = NULL;
}
}
//首尾删除
else
{
if (!m_bKeepCutPart)
{
if( pObjs[0] )delete pObjs[0]; pObjs[0] = NULL;
if( pObjs[2] )delete pObjs[2]; pObjs[2] = NULL;
}
}
}
//不能全空
if( pObjs[0]==NULL && pObjs[1]==NULL && pObjs[2]==NULL )return;
if (pNewFtr)
{
pFtr = pOldFtr;
delete pNewFtr;
}
CUndoFtrs undo(m_pEditor,Name());
CDlgDataSource *pDS = GETDS(m_pEditor);
CFtrLayer *pFtrLayer = pDS->GetFtrLayerOfObject(pFtr);
if (!pFtrLayer)
{
Abort();
return;
}
int nLayerIdOfKeep = pFtrLayer->GetID();
if (m_bKeepCutPart)
{
CString strKeepLayerName;
strKeepLayerName.Format("%s_%s",pFtrLayer->GetName(),Name());
CFtrLayer *pKeepFtrLayer = pDS->GetFtrLayer(strKeepLayerName);
if (pKeepFtrLayer == NULL)
{
pKeepFtrLayer = pDS->CreateFtrLayer(strKeepLayerName);
if (!pKeepFtrLayer)
{
Abort();
return;
}
pKeepFtrLayer->SetColor(pFtrLayer->GetColor());
pDS->AddFtrLayer(pKeepFtrLayer);
}
nLayerIdOfKeep = pKeepFtrLayer->GetID();
}
if( pObjs[0] )
{
CFeature *pF = pFtr->Clone();
pF->SetID(OUID());
BOOL bVisible = (!bClosed||bDelMid);
pF->EnableVisible(bVisible);
pF->SetToDeleted(FALSE);
if (m_bCutpartSurface)
{
pF->SetGeometry(pObjs[0]);
}
else
{
CArray<PT_3DEX,PT_3DEX> pts0;
pObjs[0]->GetShape(pts0);
CGeoCurve *pCurve = new CGeoCurve();
pCurve->CreateShape(pts0.GetData(),pts0.GetSize());
pF->SetGeometry(pCurve);
delete pObjs[0];
}
int layid = bVisible?m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(pFtr)):nLayerIdOfKeep;
m_pEditor->AddObject(pF,layid);
GETXDS(m_pEditor)->CopyXAttributes(pFtr,pF);
undo.arrNewHandles.Add(FtrToHandle(pF));
}
if( pObjs[1] )
{
CFeature *pF = pFtr->Clone();
pF->SetID(OUID());
BOOL bVisible = (bClosed&&!bDelMid);
pF->EnableVisible(bVisible);
pF->SetToDeleted(FALSE);
if (m_bCutpartSurface)
{
pF->SetGeometry(pObjs[1]);
}
else
{
CArray<PT_3DEX,PT_3DEX> pts0;
pObjs[1]->GetShape(pts0);
CGeoCurve *pCurve = new CGeoCurve();
pCurve->CreateShape(pts0.GetData(),pts0.GetSize());
pF->SetGeometry(pCurve);
delete pObjs[1];
}
int layid = bVisible?m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(pFtr)):nLayerIdOfKeep;
m_pEditor->AddObject(pF,layid);
GETXDS(m_pEditor)->CopyXAttributes(pFtr,pF);
undo.arrNewHandles.Add(FtrToHandle(pF));
}
if( pObjs[2] )
{
CFeature *pF = pFtr->Clone();
pF->SetID(OUID());
BOOL bVisible = (!bClosed||bDelMid);
pF->EnableVisible(bVisible);
pF->SetToDeleted(FALSE);
if (m_bCutpartSurface)
{
pF->SetGeometry(pObjs[2]);
}
else
{
CArray<PT_3DEX,PT_3DEX> pts0;
pObjs[2]->GetShape(pts0);
CGeoCurve *pCurve = new CGeoCurve();
pCurve->CreateShape(pts0.GetData(),pts0.GetSize());
pF->SetGeometry(pCurve);
delete pObjs[2];
}
int layid = bVisible?m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(pFtr)):nLayerIdOfKeep;
m_pEditor->AddObject(pF,layid);
GETXDS(m_pEditor)->CopyXAttributes(pFtr,pF);
undo.arrNewHandles.Add(FtrToHandle(pF));
}
m_pEditor->DeleteObject(FtrToHandle(pFtr));
undo.arrOldHandles.Add(FtrToHandle(pFtr));
undo.Commit();
int numRef = m_idsRefer.GetSize();
for (int k=numRef-1; k>=0; k--)
{
if (m_idsRefer[k] == FtrToHandle(pFtr))
{
m_idsRefer.RemoveAt(k);
for (int m=0; m<undo.arrNewHandles.GetSize(); m++)
{
m_idsRefer.Add(undo.arrNewHandles[m]);
}
break;
}
}
}
m_pEditor->DeselectAll();
UpdateFtrHiliteDisplay();
// for (i=0;i<m_idsRefer.GetSize();i++)
// {
// m_pEditor->SelectObj(m_idsRefer[i]);
// }
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
m_nStep = 2;
// m_nStep = 2;
// Finish();
// m_idsRefer.RemoveAll();
}
}
CEditCommand::PtClick(pt,flag);
}
//////////////////////////////////////////////////////////////////////
// CReplaceLinesCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CReplaceLinesCommand,CDrawCommand)
CReplaceLinesCommand::CReplaceLinesCommand()
{
// m_bAutoClosed = FALSE;
m_nMode = modeTwoPoint;
m_bShowMark = TRUE;
m_bExtendCollect = FALSE;
m_nWaitSelect = 0;
m_nStep = -1;
m_objOldID1 = 0;
m_objOldID2 = 0;
m_pObj = NULL;
m_pOldObj1 = NULL;
m_pOldObj2 = NULL;
m_nStart = -1;
m_nEnd = -1;
m_bCanTwoObjs = TRUE;
m_bMatchHeight = TRUE;
m_nSaveViewParam = 0;
m_bUseViewParam = FALSE;
m_nSnapRadius = 20;
m_bVWsnaplinestyle = FALSE;
m_b3Dsnaplinestyle = TRUE;
m_nVWPen = penLine;
m_n3DPen = penLine;
m_pDrawProc = NULL;
strcat(m_strRegPath,"\\ReplaceLines");
}
CReplaceLinesCommand::~CReplaceLinesCommand()
{
if( m_pDrawProc )delete m_pDrawProc;
if (m_pObj)
{
delete m_pObj;
m_pObj = NULL;
}
}
CProcedure *CReplaceLinesCommand::GetActiveSonProc(int nMsgType)
{
if( nMsgType==msgPtClick || nMsgType==msgPtMove || nMsgType==msgPtReset )
return NULL;
return m_pDrawProc;
}
void CReplaceLinesCommand::OnSonEnd(CProcedure *son)
{
if( !m_pObj||m_pObj->GetDataPointSum()<2 )
{
Abort();
return;
}
if(m_nMode==modeTwoPoint)
{
//当地物有共线的时候，目标地物(m_pOldObj1)可能会选错，而此时如果修测线的首尾两点都落在同一个地物上时，则这个地物应该是目标地物
if(1)
{
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
BOOL bRet1 = FALSE, bRet2 = FALSE;
PT_3D pt1, pt2, pt0;
Envelope e;
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptStart,&pt0);
e.CreateFromPtAndRadius(pt0,r);
bRet1 = m_pOldObj1->GetGeometry()->FindNearestBasePt(pt0,e,m_pEditor->GetCoordWnd().m_pSearchCS,&pt1,NULL);
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptEnd,&pt0);
e.CreateFromPtAndRadius(pt0,r);
CPFeature pObj2 = pDQ->FindNearestObject(pt0,r,m_pEditor->GetCoordWnd().m_pSearchCS);
if(pObj2)
bRet2 = pObj2->GetGeometry()->FindNearestBasePt(pt0,e,m_pEditor->GetCoordWnd().m_pSearchCS,&pt2,NULL);
//寻找所有经过pt1和pt2的地物，进行修测
e.CreateFromPtAndRadius(pt1,GraphAPI::GetDisTolerance());
pDQ->FindObjectInRect(e,NULL);
CFtrArray arr1, arr2;
int num = 0;
const CPFeature *ftrs = pDQ->GetFoundHandles(num);
if(num>0)
{
arr1.SetSize(num);
memcpy(arr1.GetData(),ftrs,num*sizeof(CPFeature));
}
e.CreateFromPtAndRadius(pt2,GraphAPI::GetDisTolerance());
pDQ->FindObjectInRect(e,NULL);
ftrs = pDQ->GetFoundHandles(num);
if(num>0)
{
arr2.SetSize(num);
memcpy(arr2.GetData(),ftrs,num*sizeof(CPFeature));
}
if(!bRet1 || !bRet2)
{
arr1.RemoveAll();
}
//清除未同时经过pt1,pt2的地物
for(int i=arr1.GetSize()-1; i>=0; i--)
{
for(int j=0; j<arr2.GetSize(); j++)
{
if(arr2[j]==arr1[i])break;
}
if(j>=arr2.GetSize())
{
arr1.RemoveAt(i);
}
}
if(arr1.GetSize()>0)
{
m_objOldID1 = FtrToHandle(arr1[0]);
m_pOldObj1 = arr1[0];
m_objOldID2 = NULL_HANDLE;
m_pOldObj2 = NULL;
}
}
CGeometry *pObj = GetReplaceObj();
if (!pObj)
{
Finish();
return;
}
m_pEditor->UpdateDrag(ud_ClearDrag);
CFeature *pFtr = HandleToFtr(m_objOldID1)->Clone();
if (!pFtr) return;
CUndoFtrs undo(m_pEditor,Name());
int layid = m_pEditor->GetFtrLayerIDOfFtr(m_objOldID1);
pFtr->SetID(OUID());
pFtr->SetGeometry(pObj);
if(m_pEditor->AddObject(pFtr,layid))
{
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_objOldID1),pFtr);
undo.AddNewFeature(FtrToHandle(pFtr));
}
if(m_pEditor->DeleteObject(m_objOldID1))
{
undo.AddOldFeature(m_objOldID1);
}
if(m_pEditor->DeleteObject(m_objOldID2))
{
undo.AddOldFeature(m_objOldID2);
}
undo.Commit();
Finish();
}
else
{
if (m_objOldID1==0&&m_objOldID2==0)
{
Abort();
return;
}
if( m_pDrawProc )
{
delete m_pDrawProc;
m_pDrawProc = NULL;
}
GrBuffer buf;
m_pObj->Draw(&buf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
m_pEditor->UpdateDrag(ud_SetConstDrag,&buf);
}
}
void CReplaceLinesCommand::PtReset(PT_3D &pt)
{
if( m_pDrawProc )
{
m_pDrawProc->PtReset(pt);
}
//画线操作结束
if( m_nStep==1 )
{
if( !m_pDrawProc->m_pGeoCurve || IsProcFinished(this) || m_pDrawProc->m_pGeoCurve->GetDataPointSum()<2)
{
Abort();
return;
}
m_pObj = m_pDrawProc->m_pGeoCurve->Clone();
//获得终点
PT_3DEX expt;
expt = m_pObj->GetDataPoint(m_pObj->GetDataPointSum()-1);
COPY_3DPT(m_ptEnd,expt);
//制作替换线
m_nWaitSelect = 0;
if( m_nMode==modeManyPoint )
{
if( m_pOldObj2 && m_pOldObj1!=m_pOldObj2 )
m_nWaitSelect = 2;
else m_nWaitSelect = 1;
}
//需要进一步确认
if( m_nWaitSelect>0 )
{
PDOC(m_pEditor)->UpdateAllViews(NULL,hc_SetCursorType,(CObject*)CURSOR_SELECT);
if( m_nWaitSelect==1 )
PromptString(StrFromResID(IDS_CMDTIP_SELECTTOSAVE));
else
PromptString(StrFromResID(IDS_CMDTIP_SELECTTOSAVE1));
m_nStep = 2;
return;
}
}
if (m_nStep>=2)
{
CDrawCommand::PtReset(pt);
}
}
CString CReplaceLinesCommand::Name()
{
return StrFromResID(IDS_CMDNAME_REPLACE);
}
void CReplaceLinesCommand::Start()
{
m_nStep = 0;
m_nMode = modeTwoPoint;
m_bShowMark = TRUE;
m_nWaitSelect = 0;
m_objOldID1 = 0;
m_objOldID2 = 0;
// m_objNewID = 0;
m_pOldObj1 = NULL;
m_pOldObj2 = NULL;
m_nStart = -1;
m_nEnd = -1;
m_bCanTwoObjs = TRUE;
m_bMatchHeight= TRUE;
m_pObj = NULL;
m_nSaveViewParam = 0;
m_bUseViewParam = FALSE;
m_nSnapRadius = 20;
m_bVWsnaplinestyle = TRUE;
m_b3Dsnaplinestyle = TRUE;
m_pDrawProc = new CDrawCurveProcedure;
if( !m_pDrawProc )return;
m_pDrawProc->Init(m_pEditor);
UpdateParams(FALSE);
m_pObj = new CGeoCurve;
if(!m_pObj)return ;
m_pDrawProc->m_pGeoCurve = (CGeoCurve*)m_pObj;
m_pDrawProc->Start();
if (m_pDrawProc)
{
if( !m_pEditor->GetCoordWnd().m_bIsStereo && !m_bVWsnaplinestyle )
m_pDrawProc->m_nCurPenCode = m_nVWPen;
else if( m_pEditor->GetCoordWnd().m_bIsStereo && !m_b3Dsnaplinestyle )
m_pDrawProc->m_nCurPenCode = m_n3DPen;
else
m_pDrawProc->m_nCurPenCode = penLine;
}
CCommand::Start();
}
void CReplaceLinesCommand::Abort()
{
if( m_bUseViewParam )
{
char params[256]={0};
sprintf(params,"%d",m_nSaveViewParam);
PDOC(m_pEditor)->UpdateAllViewsParams(0,(LPARAM)params);
// CView *pView = PDOC(m_pEditor)->GetCurActiveView();
// if (pView) pView->SendMessage(FCCM_UPDATESTEREOPARAM, 0, (LPARAM)params);
}
UpdateParams(TRUE);
if( m_pDrawProc )
{
if( !IsProcOver(m_pDrawProc) )
m_pDrawProc->Abort();
delete m_pDrawProc;
m_pDrawProc = NULL;
}
if(m_pObj)
{
delete m_pObj;
m_pObj = NULL;
}
if( m_bUseViewParam )
{
char params[256]={0};
sprintf(params,"%d",m_nSaveViewParam);
// AfxCallMessage(FCCM_UPDATESTEREOPARAM,0,(LPARAM)params);
}
CDrawCommand::Abort();
}
void CReplaceLinesCommand::Finish()
{
if( m_bUseViewParam )
{
char params[256]={0};
sprintf(params,"%d",m_nSaveViewParam);
PDOC(m_pEditor)->UpdateAllViewsParams(0,(LPARAM)params);
// CView *pView = PDOC(m_pEditor)->GetCurActiveView();
// if (pView) pView->SendMessage(FCCM_UPDATESTEREOPARAM, 0, (LPARAM)params);
}
UpdateParams(TRUE);
if( m_pDrawProc )
{
if( !IsProcOver(m_pDrawProc) )
m_pDrawProc->Abort();
delete m_pDrawProc;
m_pDrawProc = NULL;
}
if (m_pObj)
{
delete m_pObj;
m_pObj = NULL;
}
// m_pDoc->UpdateAllViews(NULL,hc_Detach_Accubox);
m_pEditor->RefreshView();
m_nStep = -1;
CCommand::Finish();
}
void CReplaceLinesCommand::PtClick(PT_3D &pt, int flag)
{
//输入起点
if( m_nStep==0 )
{
m_ptStart = pt;
//当前选中的地物
int num1;
const FTR_HANDLE *handles = m_pEditor->GetSelection()->GetSelectedObjs(num1);
//吸取绘图钢笔码
PT_3D pt1,pt2,ptnearest;
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
Envelope e ;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptStart,&pt1);
e.CreateFromPtAndRadius(pt1,r);
m_objOldID1 =FtrToHandle(m_pEditor->GetDataQuery()->FindNearestObject(pt1,r,m_pEditor->GetCoordWnd().m_pSearchCS));
int num2;
const CPFeature* ftrs = m_pEditor->GetDataQuery()->GetFoundHandles(num2);
for(int i=0; i<num2; i++)
{
for(int j=0; j<num1; j++)
{
if(HandleToFtr(handles[j]) == ftrs[i])
{
m_objOldID1 = handles[j];
break;
}
}
}
if( !m_objOldID1 )return;
m_pOldObj1 = HandleToFtr(m_objOldID1);
if( !m_pOldObj1 || !(m_pOldObj1->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurve))||m_pOldObj1->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface))) )
return;
if( m_pOldObj1->GetGeometry()->FindNearestBasePt(pt1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&pt2,NULL) )
{
Envelope ee;
ee.CreateMaxEnvelope();
int pos ;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&pt2,&pt1);
m_pOldObj1->GetGeometry()->GetShape()->FindNearestLine(pt1,ee,m_pEditor->GetCoordWnd().m_pSearchCS,NULL,NULL,NULL,&pos);
//得到前面的关键点的绘图钢笔码以及高程
CArray<int,int> pKeyPos;
m_pOldObj1->GetGeometry()->GetShape()->GetKeyPosOfBaseLines(pKeyPos);
if( pKeyPos.GetSize()>0 )
{
int num = m_pOldObj1->GetGeometry()->GetDataPointSum()-1;
while( num>=0 && pKeyPos[num]>pos )num--;
if( num>=0 )
{
PT_3DEX expt;
expt = m_pOldObj1->GetGeometry()->GetDataPoint(num);
if(!m_pEditor->GetCoordWnd().m_bIsStereo)
{
if(m_bVWsnaplinestyle)//如果m_bVWsnaplinestyle是true，则吸取，否则不吸取，而根据工具栏的选择确定
m_pDrawProc->m_nCurPenCode = expt.pencode;
else
m_pDrawProc->m_nCurPenCode = m_nVWPen;
}
else
{
if(m_b3Dsnaplinestyle)//如果m_bVWsnaplinestyle是true，则吸取，否则不吸取，而根据工具栏的选择确定
m_pDrawProc->m_nCurPenCode = expt.pencode;
else
m_pDrawProc->m_nCurPenCode = m_n3DPen;
}
// 保存立体视图参数
char params[256]={0};
PDOC(m_pEditor)->UpdateAllViewsParams(1,(LPARAM)params);
if( sscanf(params,"%d",&m_nSaveViewParam)==1 )
m_bUseViewParam = TRUE;
/*CView *pView = PDOC(m_pEditor)->GetCurActiveView();
if (pView)
{
pView->SendMessage(FCCM_UPDATESTEREOPARAM, 1, (LPARAM)params);
if( sscanf(params,"%d",&m_nSaveViewParam)==1 )
m_bUseViewParam = TRUE;
}*/
// 设置目标层码对应的视图参数
CDlgDataSource *pDS = PDOC(m_pEditor)->GetDlgDataSource();
if (!pDS){ Abort(); return;}
int nLayerId = PDOC(m_pEditor)->GetFtrLayerIDOfFtr(m_objOldID1);
CFtrLayer *pLayer = pDS->GetFtrLayer(nLayerId);
if (pLayer)
{
CPlaceConfigLib *pPlaceLib = gpCfgLibMan->GetPlaceConfigLib(pDS->GetScale());
if (pPlaceLib)
{
CPlaceConfig *pConfig = pPlaceLib->GetConfig(pLayer->GetName());
if (pConfig/* && pView*/)
{
PDOC(m_pEditor)->UpdateAllViewsParams(0,(LPARAM)pConfig->m_strViewParams);
//pView->SendMessage(FCCM_UPDATESTEREOPARAM, 0, (LPARAM)pConfig->m_strViewParams);
}
}
}
//立体窗口
if( m_pEditor->GetCoordWnd().m_bIsStereo )
{
((CDlgDoc*)m_pEditor)->UpdateAllViews(NULL,hc_ModifyHeight,(CObject*)&pt2.z);
}
m_ptStart.z = pt2.z;
pt.z = pt2.z;
}
}
}
long color = m_pOldObj1->GetGeometry()->GetColor();
if (color == FTRCOLOR_BYLAYER)
{
CFtrLayer *pLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(m_pOldObj1);
if (!pLayer)
{
Abort();
return;
}
color = pLayer->GetColor();
}
m_pObj->SetColor(color);
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
}
if( m_nStep>=2 )
{
if( m_nWaitSelect==1 )
m_ptSel1 = pt;
else if( m_nWaitSelect==2 )
{
if( m_nStep==2 )
{
PromptString(StrFromResID(IDS_CMDTIP_SELECTTOSAVE2));
m_ptSel1 = pt;
m_nStep = 3;
return;
}
else m_ptSel2 = pt;
}
CGeometry *pObj = GetReplaceObj_needSelect();
if( !pObj )
{
PromptString(StrFromResID(IDS_CMDTIP_SELECTFAIL));
m_nStep = 2;
return;
}
m_pEditor->UpdateDrag(ud_ClearDrag);
CFeature *pFtr = HandleToFtr(m_objOldID1)->Clone();
if (!pFtr) return;
CUndoFtrs undo(m_pEditor,Name());
int layid = m_pEditor->GetFtrLayerIDOfFtr(m_objOldID1);
pFtr->SetID(OUID());
pFtr->SetGeometry(pObj);
if(m_pEditor->AddObject(pFtr,layid))
{
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_objOldID1),pFtr);
undo.AddNewFeature(FtrToHandle(pFtr));
}
if(m_pEditor->DeleteObject(m_objOldID1))
{
undo.AddOldFeature(m_objOldID1);
}
if(m_pEditor->DeleteObject(m_objOldID2))
{
undo.AddOldFeature(m_objOldID2);
}
undo.Commit();
Finish();
}
if( m_pDrawProc )
{
m_pDrawProc->PtClick(pt,flag);
}
}
void CReplaceLinesCommand::PtMove(PT_3D &pt)
{
if( m_pDrawProc )
{
m_pDrawProc->PtMove(pt);
}
if (m_nWaitSelect==1||m_nWaitSelect==2)
{
return;
}
if( IsProcFinished(this) )return;
{
//判断目标地物是否在可以连接的范围内
BOOL bCanLink = TRUE;
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
//m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
//查找
CFeature *pOldObj = NULL;
PT_3D p1;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&pt,&p1);
Envelope e;
e.CreateFromPtAndRadius(p1,r);
pOldObj = m_pEditor->GetDataQuery()->FindNearestObject(p1,r,m_pEditor->GetCoordWnd().m_pSearchCS);
if( pOldObj )
{
if( (pOldObj->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurve))||pOldObj->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface))) )
{
//层码必须一致
CFtrLayer *pLayer1 = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(m_pOldObj1);
CFtrLayer *pLayer2 = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(pOldObj);
if( pLayer1 && pLayer2&&pLayer1 != pLayer2&&
strcmp(pLayer1->GetName(),pLayer2->GetName())!=0 )
{
pOldObj = NULL;
}
//如果是面，就不支持同时修测两个地物
else if( (m_pOldObj1&&m_pOldObj1->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface)))||
(pOldObj&&pOldObj->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface))) )
{
if( FtrToHandle(pOldObj)!=m_objOldID1 )pOldObj = NULL;
}
}
else pOldObj = NULL;
}
else pOldObj = NULL;
/*if( !pOldObj )pFtr = NULL;*/
//不是处于选点状态
if( m_nWaitSelect==0 && m_bCanTwoObjs )
{
//高程必须对应
if( m_bMatchHeight && pOldObj )
{
if( m_pOldObj1 && CModifyZCommand::CheckObjForContour(m_pOldObj1->GetGeometry()) )
{
PT_3DEX expt1, expt2;
expt1 = m_pOldObj1->GetGeometry()->GetDataPoint(0);
expt2 = pOldObj->GetGeometry()->GetDataPoint(0);
if( !CModifyZCommand::CheckObjForContour(pOldObj->GetGeometry()) ||
fabs(expt1.z-expt2.z)>=1e-4 )
{
pOldObj = NULL;
}
}
}
if (!pOldObj)
{
int aaaa = 10;
}
m_objOldID2 = FtrToHandle(pOldObj);
m_pOldObj2 = pOldObj;
}
//必须是已经被接受处理的两个地物
else
{
if( (m_objOldID1&&FtrToHandle(pOldObj)!=m_objOldID1) && (m_objOldID2&&FtrToHandle(pOldObj)!=m_objOldID2) )
pOldObj = NULL;
}
PT_3D pt0;
if( !pOldObj ||!pOldObj->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&pt0,NULL) )
bCanLink = FALSE;
if( !m_bCanTwoObjs && m_objOldID1 && FtrToHandle(pOldObj)!=m_objOldID1 )
bCanLink = FALSE;
GrBuffer vbuf;
if( bCanLink && m_bShowMark )
{
//更新显示
GrBuffer buf;
buf.BeginLineString(0,0);
DrawPointTip(pOldObj->GetGeometry(),pt0,&buf);
buf.End();
vbuf.CopyFrom(&buf);
}
if (m_pDrawProc&&m_pDrawProc->m_arrPts.GetSize()<=0)
{
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
}
m_pEditor->UpdateDrag(ud_AddVariantDrag,&vbuf);
}
}
void CReplaceLinesCommand::GetParams(CValueTable &tab)
{
if (m_pDrawProc)
{
if( !m_bVWsnaplinestyle )
m_nVWPen = m_pDrawProc->m_nCurPenCode;
if( !m_b3Dsnaplinestyle )
m_n3DPen = m_pDrawProc->m_nCurPenCode;
}
CDrawCommand::GetParams(tab);
_variant_t var;
var = (_variant_t)(long)(m_nMode);
tab.AddValue(PF_REPLACELINEWAY,&CVariantEx(var));
var = (_variant_t)(long)(m_nVWPen);
tab.AddValue(PF_VMPEN,&CVariantEx(var));
var = (_variant_t)(long)(m_n3DPen);
tab.AddValue(PF_3DPEN,&CVariantEx(var));
var = (bool)(m_bCanTwoObjs);
tab.AddValue(PF_REPLACELINETWOOBJ,&CVariantEx(var));
var = (bool)(m_bMatchHeight);
tab.AddValue(PF_REPLACELINEHEIMATCH,&CVariantEx(var));
var = (bool)(m_bShowMark);
tab.AddValue(PF_REPLACELINESHOWMARK,&CVariantEx(var));
var = (_variant_t)(long)(m_nSnapRadius);
tab.AddValue(PF_REPLACELINESNAPRADIUS,&CVariantEx(var));
var = (bool)(m_bVWsnaplinestyle);
tab.AddValue(PF_REPLACELINEVECTOR,&CVariantEx(var));
var = (bool)(m_b3Dsnaplinestyle);
tab.AddValue(PF_REPLACELINESTEREO,&CVariantEx(var));
if(m_pDrawProc)
{
var = (double)(m_pDrawProc->m_compress.GetLimit());
tab.AddValue(PF_TOLER,&CVariantEx(var));
var = (_variant_t)(long)(m_pDrawProc->m_nCurPenCode);
tab.AddValue(PF_PENCODE,&CVariantEx(var));
}
}
void CReplaceLinesCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("ReplaceLines",StrFromResID(IDS_CMDNAME_REPLACE));
param->BeginOptionParam(PF_REPLACELINEWAY,StrFromResID(IDS_CMDPLANE_WAY));
param->AddOption(StrFromResID(IDS_CMDPLANE_TWOPT),modeTwoPoint,' ',m_nMode==modeTwoPoint);
param->AddOption(StrFromResID(IDS_CMDPLANE_THREEPT),modeManyPoint,' ',m_nMode==modeManyPoint);
param->EndOptionParam();
param->AddParam(PF_REPLACELINETWOOBJ,(bool)(m_bCanTwoObjs),StrFromResID(IDS_CMDPLANE_CANTWOOBJ));
if(m_bCanTwoObjs||bForLoad)param->AddParam(PF_REPLACELINEHEIMATCH,(bool)m_bMatchHeight,StrFromResID(IDS_CMDPLANE_MATCHHEIGHT));
param->AddParam(PF_REPLACELINESHOWMARK,(bool)m_bShowMark,StrFromResID(IDS_CMDPLANE_SHOWMARK));
param->AddParam(PF_REPLACELINESNAPRADIUS,(int)m_nSnapRadius,StrFromResID(IDS_CMDPLANE_SNAPRADIUS));
param->AddParam(PF_REPLACELINEVECTOR,(bool)m_bVWsnaplinestyle,StrFromResID(IDS_CMDPLANE_VWSNAPLINESTYLE));
param->AddParam(PF_REPLACELINESTEREO,(bool)m_b3Dsnaplinestyle,StrFromResID(IDS_CMDPLANE_TDSNAPLINESTYLE));
if(m_pDrawProc)
param->AddLineTypeParam(PF_PENCODE,m_pDrawProc->m_nCurPenCode,StrFromLocalResID(IDS_CMDPLANE_LINETYPE));
// param->AddParam(PF_COPYROTATEKPOLD,bool(m_bKeepOld),StrFromResID(IDS_CMDPLANE_KEEPOLD));
BOOL b3D = m_pEditor->GetCoordWnd().m_bIsStereo;
if (((!b3D&&m_bVWsnaplinestyle) || (b3D&&m_b3Dsnaplinestyle))/*m_pDrawProc->m_nCurPenCode == penStream*/ || bForLoad)
{
if(m_pDrawProc)
param->AddParam(PF_TOLER,m_pDrawProc->m_compress.GetLimit(),StrFromResID(IDS_CMDPLANE_TOLERANCE));
}
param->AddParam(PF_REPLACELINE_WAY,char('c'),StrFromResID(IDS_CMDPLANE_WAY));
param->AddParam(PF_TRACKLINEACCKEY,'w',StrFromResID(IDS_CMDPLANE_TRACKLINE));
}
int CReplaceLinesCommand::GetCurPenCode()
{
if(m_pDrawProc)
{
return m_pDrawProc->m_nCurPenCode;
}
return CDrawCommand::GetCurPenCode();
}
DrawingInfo CReplaceLinesCommand::GetCurDrawingInfo()
{
if (m_pDrawProc)
{
CFeature *pFtr = new CFeature;
pFtr->SetGeometry(m_pDrawProc->m_pGeoCurve);
return DrawingInfo(pFtr,m_pDrawProc->m_arrPts);
}
else
return DrawingInfo();
}
void CReplaceLinesCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_REPLACELINEWAY,var) )
{
m_nMode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_VMPEN,var) )
{
m_nVWPen = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_3DPEN,var) )
{
m_n3DPen = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINETWOOBJ,var) )
{
m_bCanTwoObjs = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINEHEIMATCH,var) )
{
m_bMatchHeight = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINESHOWMARK,var) )
{
m_bShowMark = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINESNAPRADIUS,var) )
{
m_nSnapRadius = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINEVECTOR,var) )
{
m_bVWsnaplinestyle = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINESTEREO,var) )
{
m_b3Dsnaplinestyle = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if(m_pDrawProc&&tab.GetValue(0,PF_PENCODE,var) )
{
m_pDrawProc->m_nCurPenCode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if(m_pDrawProc && tab.GetValue(0,PF_TOLER,var) )
{
m_pDrawProc->m_compress.SetLimit((double)(_variant_t)*var);
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINE_WAY,var) )
{
int key = (char)(BYTE)(_variant_t)*var;
if (key == 'c'|| key == 'C')
{
if (m_nMode == modeTwoPoint)
{
m_nMode = modeManyPoint;
}
else
{
m_nMode = modeTwoPoint;
}
SetSettingsModifyFlag();
}
}
if(m_pDrawProc && tab.GetValue(0,PF_TRACKLINEACCKEY,var) )
{
char ch = (BYTE)(_variant_t)*var;
if(ch == 'w'||ch == 'W')
{
m_pDrawProc->TrackLine();
}
}
CDrawCommand::SetParams(tab,bInit);
}
void CReplaceLinesCommand::DrawPointTip(CGeometry *pObj, PT_3D pt, GrBuffer *buf)
{
PT_4D pts[4];
pts[0] = PT_4D(pt);
m_pEditor->GetCoordWnd().m_pViewCS->GroundToClient(pts,1);
pts[0].x -= 10; pts[0].y -= 10; pts[0].z -= 10; pts[0].yr -= 10;
pts[1].x = pts[0].x+20; pts[1].y = pts[0].y+20;
pts[1].z = pts[0].z+20; pts[1].yr = pts[0].yr+20;
pts[2].x = pts[0].x; pts[2].y = pts[0].y+20;
pts[2].z = pts[0].z; pts[2].yr = pts[0].yr+20;
pts[3].x = pts[0].x+20; pts[3].y = pts[0].y;
pts[3].z = pts[0].z+20; pts[3].yr = pts[0].yr;
m_pEditor->GetCoordWnd().m_pViewCS->ClientToGround(pts,4);
PT_3D pt3ds[4];
for( int i=0; i<4; i++)pt3ds[i] = pts[i].To3D();
buf->MoveTo(pt3ds);
buf->LineTo(pt3ds+1);
buf->MoveTo(pt3ds+2);
buf->LineTo(pt3ds+3);
}
CGeometry* CReplaceLinesCommand::GetReplaceObj()
{
//多点方式总是需要选择点的
// if( m_nMode==modeManyPoint )
// {
// if( m_pOldObj2 && m_pOldObj1!=m_pOldObj2 )
// m_nWaitSelect = 2;
// else m_nWaitSelect = 1;
// return NULL;
// }
if( !m_pOldObj1||!m_pOldObj2 || m_pOldObj1==m_pOldObj2 )
return GetReplaceObj_same();
//获得各个点在基线上的最近点
PT_3D ptStart, ptEnd;
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
int start1=-1, end1=-1, start2=-1, end2=-1, i;
PT_3D p1;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptStart,&p1);
Envelope e ;
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptStart,NULL) )
{
start1 = -2;
}
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptEnd,&p1);
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj2->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptEnd,NULL) )
{
start2 = -2;
}
//两点都没有附着到地物上
if( start1==-2 || start2==-2 )return NULL;
CGeometry *pCurve1 = (CGeometry*)m_pOldObj1->GetGeometry(), *pCurve2 = (CGeometry*)m_pOldObj2->GetGeometry();
const CShapeLine *pSL1 = pCurve1->GetShape();
const CShapeLine *pSL2 = pCurve2->GetShape();
//得到关键点在基线中的对应序号
CArray<int,int> KeyPos1 , KeyPos2 ;
if(!pSL1->GetKeyPosOfBaseLines(KeyPos1)) return NULL;
if(!pSL2->GetKeyPosOfBaseLines(KeyPos2)) return NULL;
int keynum1 = KeyPos1.GetSize();
int keynum2 = KeyPos2.GetSize();
CArray<PT_3DEX,PT_3DEX> pts1,pts2;
if(!pSL1->GetPts(pts1))return NULL;
int num1 = pts1.GetSize();
if(!pSL2->GetPts(pts2))return NULL;
int num2 = pts2.GetSize();
if( num1<=1 || num2<=1 )
{
return NULL;
}
//获得上述各个最近点在基线中的位置
PT_3D rpt2;
double x,y,z;
double dis,min1=-1,min2=-1, min3=-1;
int i1=-1, i2=-1, i3=-1;
//计算第一个地物
for( i=0; i<num1-1; i++)
{
//求出当前线段的最近距离
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts1[i].x,pts1[i].y,pts1[i].z,
pts1[i+1].x,pts1[i+1].y,pts1[i+1].z,m_ptStart.x,m_ptStart.y,m_ptStart.z,&x,&y,&z,false);
if( min2<0 || dis<min2 )
{
min2 = dis; rpt2.x=x; rpt2.y=y; rpt2.z=z;
if( _FABS(x-pts1[i+1].x)+_FABS(y-pts1[i+1].y)>1e-10 )
i2=i;
//就是第二个点时，序号增加1
else i2=i+1;
}
}
//(虚拟)插入上述最近点到基线位置表中;
{
double d=0;
if( i2<num1 && i2>=0 )d = _FABS(pts1[i2].x-rpt2.x)+_FABS(pts1[i2].y-rpt2.y)+_FABS(pts1[i2].z-rpt2.z);
if( d>1e-10 && i2<num1 && i2>=0 )
{
pts1.InsertAt(i2+1,PT_3DEX(rpt2,20));
for( i=0; i<keynum1; i++)if( KeyPos1[i]>i2 )KeyPos1[i] = KeyPos1[i]+1;
i2++; num1++;
}
}
//判断哪一头比较长，比较长的保留
{
double d1 = pSL1->GetLength(&ptStart);
double d2 = pSL1->GetLength()-d1;
if( d1>=d2 )
{
start1 = -1;
end1 = i2;
}
else
{
start1 = num1;
end1 = i2;
}
}
//计算第二个地物
for( i=0; i<num2-1; i++)
{
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts2[i].x,pts2[i].y,pts2[i].z,
pts2[i+1].x,pts2[i+1].y,pts2[i+1].z,m_ptEnd.x,m_ptEnd.y,m_ptEnd.z,&x,&y,&z,false);
if( min3<0 || dis<min3 )
{
min3 = dis; rpt2.x=x; rpt2.y=y; rpt2.z=z;
if( _FABS(x-pts2[i+1].x)+_FABS(y-pts2[i+1].y)>1e-10 )
i3=i;
//就是第二个点时，序号增加1
else i3=i+1;
}
}
//(虚拟)插入上述最近点到基线位置表中;
{
double d=0;
if( i3<num2 && i3>=0 )d = _FABS(pts2[i3].x-rpt2.x)+_FABS(pts2[i3].y-rpt2.y)+_FABS(pts2[i3].z-rpt2.z);
if( d>1e-10 && i3<num2 && i3>=0 )
{
pts2.InsertAt(i3+1,PT_3DEX(rpt2,20));
for( i=0; i<keynum2; i++)if( KeyPos2[i]>i3 )KeyPos2[i] = KeyPos2[i]+1;
i3++; num2++;
}
}
//判断哪一头比较长，比较长的保留
{
double d1 = pSL2->GetLength(&ptEnd);
double d2 = pSL2->GetLength()-d1;
if( d1>=d2 )
{
start2 = -1;
end2 = i3;
}
else
{
start2 = num2;
end2 = i3;
}
}
//计算各个位置最邻近的关键点
int startKey1, endKey1,startKey2, endKey2;
for( i=0; i<keynum1; i++)
{
if( start1<KeyPos1[i] )break;
}
startKey1 = i;
for( i=0; i<keynum1; i++)
{
if( end1<KeyPos1[i] )break;
}
endKey1 = i;
for( i=0; i<keynum2; i++)
{
if( start2<KeyPos2[i] )break;
}
startKey2 = i;
for( i=0; i<keynum2; i++)
{
if( end2<KeyPos2[i] )break;
}
endKey2 = i;
//准备新地物
CGeometry *pNewObj = (CGeometry*)m_pOldObj1->GetGeometry()->Clone();
if( !pNewObj )
{
return NULL;
}
PT_3DEX expt;
CArray<PT_3DEX,PT_3DEX> arr;
pts1.RemoveAll();
pNewObj->GetShape(pts1);
//首段
if( start1>end1 )
{
for( i=keynum1-1; i>=endKey1; i--)
{
arr.Add(pts1.GetAt(i));
}
}
else
{
for( i=0; i<endKey1; i++)
{
arr.Add(pts1.GetAt(i));
}
}
//替换段
pts1.RemoveAll();
m_pObj->GetShape(pts1);
arr.Append(pts1);
// int newnum = m_pObj->GetDataPointSum();
// for( i=0; i<newnum; i++)
// {
// arr.Add(m_pObj->GetDataPoint(i));
// }
//尾段
pts1.RemoveAll();
m_pOldObj2->GetGeometry()->GetShape(pts1);
if( start2>end2 )
{
for( i=endKey2; i<keynum2; i++)
{
arr.Add(pts1.GetAt(i));
}
}
else
{
for( i=endKey2-1; i>=0; i--)
{
arr.Add(pts1.GetAt(i));
}
}
//去除重复的点(主要因为起点、终点落在原对象节点上)
PT_3DEX tt;
keynum1 = arr.GetSize();
int pos = 0;
tt = arr.GetAt(pos);
for( i=1; i<keynum1 && keynum1>2; )
{
expt = arr.GetAt(i);
if( _FABS(expt.x-tt.x)<1e-4 && _FABS(expt.y-tt.y)<1e-4 && _FABS(expt.z-tt.z)<1e-4 )
{
arr.RemoveAt(i);
keynum1--;
continue;
}
else
{
pos++;
tt = arr.GetAt(pos);
}
i++;
}
if(!pNewObj->CreateShape(arr.GetData(),arr.GetSize())) return NULL;
return pNewObj;
}
CGeometry* CReplaceLinesCommand::GetReplaceObj_same()
{
if (!m_pOldObj1)
{
return NULL;
}
//获得各个点在基线上的最近点
PT_3D ptStart, ptEnd;
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
int select=-1, start=-1, end=-1, i;
PT_3D p1;
Envelope e;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptStart,&p1);
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptStart,NULL) )
{
start = -2;
}
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptEnd,&p1);
e .CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptEnd,NULL) )
{
end = -2;
}
//两点都没有附着到地物上
if( start==-2 && end==-2 )return NULL;
//如果是面，头尾点必须都附着在地物上
if( m_pOldObj1->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )
{
if( start==-2 || end==-2 )return NULL;
}
CGeometry *pCurve = (CGeometry*)m_pOldObj1->GetGeometry();
int keynum = pCurve->GetDataPointSum();
if( keynum<=1 )return NULL;
const CShapeLine *pSL = pCurve->GetShape();
//得到关键点在基线中的对应序号
CArray<int,int> KeyPos;
if(!pSL->GetKeyPosOfBaseLines(KeyPos)) return NULL;
CArray<PT_3DEX,PT_3DEX> pts;
if(!pSL->GetPts(pts)) return NULL;
int num = pts.GetSize();
if( num<=1 )
{
return NULL;
}
//获得上述各个最近点在基线中的位置
PT_3D rpt2,rpt3;
double x,y,z;
double dis,min2=-1, min3=-1;
int i1=-1, i2=-1, i3=-1;
for( i=0; i<num-1; i++)
{
//求出当前线段的最近距离
if( start!=-2 )
{
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts[i].x,pts[i].y,pts[i].z,
pts[i+1].x,pts[i+1].y,pts[i+1].z,m_ptStart.x,m_ptStart.y,m_ptStart.z,&x,&y,&z,false);
if( min2<0 || dis<min2 )
{
min2 = dis; rpt2.x=x; rpt2.y=y; rpt2.z=z;
if( _FABS(x-pts[i+1].x)+_FABS(y-pts[i+1].y)>1e-10 )
i2=i;
//就是第二个点时，序号增加1
else i2=i+1;
}
}
if( end!=-2 )
{
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts[i].x,pts[i].y,pts[i].z,
pts[i+1].x,pts[i+1].y,pts[i+1].z,m_ptEnd.x,m_ptEnd.y,m_ptEnd.z,&x,&y,&z,false);
if( min3<0 || dis<min3 )
{
min3 = dis; rpt3.x=x; rpt3.y=y; rpt3.z=z;
if( _FABS(x-pts[i+1].x)+_FABS(y-pts[i+1].y)>1e-10 )
i3=i;
//就是第二个点时，序号增加1
else i3=i+1;
}
}
}
if( min2<0 && min3<0 )
{
return NULL;
}
//(虚拟)插入上述最近点到基线位置表中;
{
double d2=0, d3=0;
if( i2<num && i2>=0 )d2 = _FABS(pts[i2].x-rpt2.x)+_FABS(pts[i2].y-rpt2.y)+_FABS(pts[i2].z-rpt2.z);
if( i3<num && i3>=0 )d3 = _FABS(pts[i3].x-rpt3.x)+_FABS(pts[i3].y-rpt3.y)+_FABS(pts[i3].z-rpt3.z);
if( d2>1e-10 && i2<num && i2>=0 )
{
pts.InsertAt(i2+1,PT_3DEX(rpt2,0));
for( i=0; i<keynum; i++)if( KeyPos[i]>i2 )KeyPos[i] = KeyPos[i]+1;
if( i2<i3 ||(i2==i3&&d2<=d3) )i3++;
i2++; num++;
}
if( d3>1e-10 && i3<num && i3>=0 )
{
pts.InsertAt(i3+1,PT_3DEX(rpt3,0));
for( i=0; i<keynum; i++)if( KeyPos[i]>i3 )KeyPos[i] = KeyPos[i]+1;
if( i3<i2 ||(i3==i2&&d3<d2) )i2++;
i3++; num++;
}
}
//有个点在咬合范围外，就判断哪一头比较长，比较长的保留
if( start==-2 || end==-2 )
{
double d1 = pSL->GetLength(&ptStart);
double d2 = pSL->GetLength()-d1;
if( d1>=d2 )
{
select = -1;
start = (start==-2?num:i2);
end = (end==-2?num:i3);
}
else
{
select = num;
start = (start==-2?-1:i2);
end = (end==-2?-1:i3);
}
}
//两个点都在咬合范围内，
else
{
//如果是闭合线或者是面，就判断哪一段比较长，比较长的保留
if( m_pOldObj1->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface)) ||
(m_pOldObj1->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurve)) && ((CGeoCurve*)(m_pOldObj1->GetGeometry()))->IsClosed()) )
{
double d1 = fabs(pSL->GetLength(&ptEnd)-pSL->GetLength(&ptStart));
double d2 = pSL->GetLength()-d1;
//保留中间
if( d1>d2 )
{
select = (i2+i3)/2;
start = i2;
end = i3;
}
//保留头尾
else
{
select = -1;
start = i2;
end = i3;
}
}
//否则替换中间的
else
{
select = -1;
start = i2;
end = i3;
}
}
//计算各个位置最邻近的关键点
int startKey, endKey;
for( i=0; i<keynum; i++)
{
if( start<KeyPos[i] )break;
}
startKey = i;
for( i=0; i<keynum; i++)
{
if( end<KeyPos[i] )break;
}
endKey = i;
//准备新地物
CGeometry *pNewObj = (CGeometry*)m_pOldObj1->GetGeometry()->Clone();
if( !pNewObj )
{
return NULL;
}
CArray<PT_3DEX,PT_3DEX> arr,pts1;
PT_3DEX expt;
//---------分如下情况生成新的地物
//1. 选择点在起始点外
if( select<=(start<end?start:end) || select>=(start>=end?start:end) )
{
if( startKey>endKey ){ int t=startKey; startKey=endKey; endKey=t; }
//首段
pNewObj->GetShape(pts1);
for( i=0; i<startKey; i++)
{
arr.Add(pts1.GetAt(i));
}
//防止expt具有无效的cd码
if( startKey<=0 )expt = m_pObj->GetDataPoint(0);
//替换段
pts.RemoveAll();
m_pObj->GetShape(pts);
int newnum = pts.GetSize();
if( start<=end )
{
arr.Append(pts);
// for( i=0; i<newnum; i++)
// {
// arr.Add(m_pObj->GetDataPoint(i));
// }
}
else
{
for( i=newnum-1; i>=0; i--)
{
arr.Add(pts.GetAt(i));
}
}
//尾段
for( i=endKey; i<keynum; i++)
{
arr.Add(pts1.GetAt(i));
}
if (m_bExtendCollect && ( (i2==0 && i3==num-1) || (i3==0 && i2==num-1) ) )
{
if (startKey < endKey)
{
for (i=endKey-1; i>=startKey; i--)
{
arr.Add(pts1.GetAt(i));
}
}
else
{
for (i=startKey; i<endKey; i++)
{
arr.Add(pts1.GetAt(i));
}
}
}
}
//2. 选择点在起始点内
else
{
if( startKey>endKey ){ int t=startKey; startKey=endKey; endKey=t; }
//中间段
expt = pNewObj->GetDataPoint(startKey);
if( start<=end )COPY_3DPT(expt,m_ptStart);
else COPY_3DPT(expt,m_ptEnd);
arr.Add(expt);
pNewObj->GetShape(pts1);
for( i=startKey; i<endKey; i++)
{
arr.Add(pts1.GetAt(i));
}
if( start<=end )COPY_3DPT(expt,m_ptEnd);
else COPY_3DPT(expt,m_ptStart);
arr.Add(expt);
//替换段
pts.RemoveAll();
m_pObj->GetShape(pts);
int newnum = pts.GetSize();
if( start>end )
{
arr.Append(pts);
// for( i=0; i<newnum; i++)
// {
// arr.Add(m_pObj->GetDataPoint(i));
// }
}
else
{
for( i=newnum-1; i>=0; i--)
{
arr.Add(pts.GetAt(i));
}
}
}
//去除重复的点(主要因为起点、终点落在原对象节点上)
PT_3DEX tt;
keynum = arr.GetSize();
int pos = 0;
tt = arr.GetAt(pos);
for( i=1; i<keynum && keynum>2; )
{
expt = arr.GetAt(i);
if( _FABS(expt.x-tt.x)<1e-4 && _FABS(expt.y-tt.y)<1e-4 && _FABS(expt.z-tt.z)<1e-4 )
{
arr.RemoveAt(i);
keynum--;
continue;
}
else
{
pos++;
tt = arr.GetAt(pos);
}
i++;
}
if (m_bExtendCollect && ( (i2==0 && i3==num-1) || (i3==0 && i2==num-1) ) )
{
arr.Add(arr[0]);
}
if (!pNewObj->CreateShape(arr.GetData(),arr.GetSize()))
{
return NULL;
}
return pNewObj;
}
CGeometry* CReplaceLinesCommand::GetReplaceObj_needSelect_same()
{
//获得各个点在基线上的最近点
PT_3D ptStart, ptSel, ptEnd;
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
Envelope e ;
int select=-1, start=-1, end=-1, i;
PT_3D p1;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptSel1,&p1);
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptSel,NULL) )
return NULL;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptStart,&p1);
e .CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptStart,NULL) )
{
start = -2;
}
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptEnd,&p1);
e .CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptEnd,NULL) )
{
end = -2;
}
if( start==-2 && end==-2 )return NULL;
CGeometry *pCurve = (CGeometry*)m_pOldObj1->GetGeometry();
int keynum = pCurve->GetDataPointSum();
if( keynum<=1 )return NULL;
//得到关键点在基线中的对应序号
CArray<int,int> pKeyPos;
const CShapeLine *pSL = pCurve->GetShape();
pSL->GetKeyPosOfBaseLines(pKeyPos);
CArray<PT_3DEX,PT_3DEX> pts;
pSL->GetPts(pts);
int num = pts.GetSize();
if( num<=1 )
{
return NULL;
}
//获得上述各个最近点在基线中的位置
PT_3D rpt1,rpt2,rpt3;
double x,y,z;
double dis,min1=-1,min2=-1, min3=-1;
int i1=-1, i2=-1, i3=-1;
for( i=0; i<num-1; i++)
{
//求出当前线段的最近距离
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts[i].x,pts[i].y,pts[i].z,
pts[i+1].x,pts[i+1].y,pts[i+1].z,m_ptSel1.x,m_ptSel1.y,m_ptSel1.z,&x,&y,&z,false);
if( min1<0 || dis<min1 )
{
min1 = dis; rpt1.x=x; rpt1.y=y; rpt1.z=z;
if( _FABS(x-pts[i+1].x)+_FABS(y-pts[i+1].y)>1e-10 )
i1=i;
//就是第二个点时，序号增加1
else i1=i+1;
}
if( start!=-2 )
{
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts[i].x,pts[i].y,pts[i].z,
pts[i+1].x,pts[i+1].y,pts[i+1].z,m_ptStart.x,m_ptStart.y,m_ptStart.z,&x,&y,&z,false);
if( min2<0 || dis<min2 )
{
min2 = dis; rpt2.x=x; rpt2.y=y; rpt2.z=z;
if( _FABS(x-pts[i+1].x)+_FABS(y-pts[i+1].y)>1e-10 )
i2=i;
//就是第二个点时，序号增加1
else i2=i+1;
}
}
if( end!=-2 )
{
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts[i].x,pts[i].y,pts[i].z,
pts[i+1].x,pts[i+1].y,pts[i+1].z,m_ptEnd.x,m_ptEnd.y,m_ptEnd.z,&x,&y,&z,false);
if( min3<0 || dis<min3 )
{
min3 = dis; rpt3.x=x; rpt3.y=y; rpt3.z=z;
if( _FABS(x-pts[i+1].x)+_FABS(y-pts[i+1].y)>1e-10 )
i3=i;
//就是第二个点时，序号增加1
else i3=i+1;
}
}
}
if( min1<0 || (min2<0&&min3<0) )
{
return NULL;
}
//(虚拟)插入上述最近点到基线位置表中;
{
// GrNode tnode;
double d1=0, d2=0, d3=0;
d1 = _FABS(pts[i1].x-rpt1.x)+_FABS(pts[i1].y-rpt1.y)+_FABS(pts[i1].z-rpt1.z);
if( i2<num && i2>=0 )d2 = _FABS(pts[i2].x-rpt2.x)+_FABS(pts[i2].y-rpt2.y)+_FABS(pts[i2].z-rpt2.z);
if( i3<num && i3>=0 )d3 = _FABS(pts[i3].x-rpt3.x)+_FABS(pts[i3].y-rpt3.y)+_FABS(pts[i3].z-rpt3.z);
if( d1>1e-10 )
{
PT_3DEX ptt;
COPY_3DPT(ptt,rpt1);
pts.InsertAt(i1+1,ptt);
// memmove(pts+i1+2, pts+i1+1, (num-i1-1)*sizeof(GrNode));
// COPY_3DPT(tnode.pt,rpt1);
// memcpy(pts+i1+1,&tnode,sizeof(GrNode));
for( i=0; i<keynum; i++)if( pKeyPos[i]>i1 )pKeyPos[i] = pKeyPos[i]+1;
if( i1<i2 ||(i1==i2&&d1<=d2) )i2++;
if( i1<i3 ||(i1==i3&&d1<=d3) )i3++;
i1++; num++;
}
if( d2>1e-10 && i2<num && i2>=0 )
{
PT_3DEX ptt;
COPY_3DPT(ptt,rpt2);
pts.InsertAt(i2+1,ptt);
// memmove(pts+i2+2, pts+i2+1, (num-i2-1)*sizeof(GrNode));
// COPY_3DPT(tnode.pt,rpt2);
// memcpy(pts+i2+1,&tnode,sizeof(GrNode));
for( i=0; i<keynum; i++)if( pKeyPos[i]>i2 )pKeyPos[i] = pKeyPos[i]+1;
if( i2<i1 ||(i2==i1&&d2<d1) )i1++;
if( i2<i3 ||(i2==i3&&d2<=d3) )i3++;
i2++; num++;
}
if( d3>1e-10 && i3<num && i3>=0 )
{
PT_3DEX ptt;
COPY_3DPT(ptt,rpt3);
pts.InsertAt(i3+1,ptt);
for( i=0; i<keynum; i++)if( pKeyPos[i]>i3 )pKeyPos[i] = pKeyPos[i]+1;
if( i3<i1 ||(i3==i1&&d3<d1) )i1++;
if( i3<i2 ||(i3==i2&&d3<d2) )i2++;
i3++; num++;
}
//如果点在咬合范围外面，那么他们的位置可以理解为第一点之前或者最后点之后
if( i2<0 )i2 = (i1<=i3?num:-1);
if( i3<0 )i3 = (i1<=i2?num:-1);
}
select = i1;
start = i2;
end = i3;
//计算各个位置最邻近的关键点
int startKey, endKey;
for( i=0; i<keynum; i++)
{
if( start<pKeyPos[i] )break;
}
startKey = i;
for( i=0; i<keynum; i++)
{
if( end<pKeyPos[i] )break;
}
endKey = i;
//准备新地物
CGeometry *pNewObj = (CGeometry*)m_pOldObj1->GetGeometry()->Clone();
if( !pNewObj )
{
return NULL;
}
CArray<PT_3DEX,PT_3DEX> arr,pts1;
PT_3DEX expt;
//---------分如下情况生成新的地物
//1. 选择点在起始点外
if( select<=(start<end?start:end) || select>=(start>=end?start:end) )
{
if( startKey>endKey ){ int t=startKey; startKey=endKey; endKey=t; }
//首段
m_pOldObj1->GetGeometry()->GetShape(pts1);
for( i=0; i<startKey; i++)
{
arr.Add(pts1.GetAt(i));
}
//防止expt具有无效的cd码
if( startKey<=0 )expt = m_pObj->GetDataPoint(0);
//替换段
pts.RemoveAll();
m_pObj->GetShape(pts);
int newnum = pts.GetSize();
if( start<=end )
{
arr.Append(pts);
}
else
{
for( i=newnum-1; i>=0; i--)
{
expt = pts.GetAt(i);
arr.Add(expt);
}
}
//尾段
for( i=endKey; i<keynum; i++)
{
arr.Add(pts1.GetAt(i));
}
}
//2. 选择点在起始点内
else
{
if( startKey>endKey ){ int t=startKey; startKey=endKey; endKey=t; }
//中间段
expt = m_pOldObj1->GetGeometry()->GetDataPoint(startKey);
if( start<=end )COPY_3DPT(expt,m_ptStart);
else COPY_3DPT(expt,m_ptEnd);
arr.Add(expt);
m_pOldObj1->GetGeometry()->GetShape(pts1);
for( i=startKey; i<endKey; i++)
{
arr.Add(pts1.GetAt(i));
}
if( start<=end )COPY_3DPT(expt,m_ptEnd);
else COPY_3DPT(expt,m_ptStart);
arr.Add(expt);
//替换段
pts.RemoveAll();
m_pObj->GetShape(pts);
int newnum = pts.GetSize();
if( start>end )
{
arr.Append(pts);
// for( i=0; i<newnum; i++)
// {
// arr.Add(m_pObj->GetDataPoint(i));
// }
}
else
{
for( i=newnum-1; i>=0; i--)
{
arr.Add(pts.GetAt(i));
}
}
}
//pNewObj->CreateShape(pts.GetData(),pts.GetSize());
//去除重复的点(主要因为起点、终点落在原对象节点上)
PT_3DEX tt;
keynum = arr.GetSize();
int pos = 0;
tt = pNewObj->GetDataPoint(pos);
for( i=1; i<keynum && keynum>2; )
{
expt = arr.GetAt(i);
if( _FABS(expt.x-tt.x)<1e-4 && _FABS(expt.y-tt.y)<1e-4 && _FABS(expt.z-tt.z)<1e-4 )
{
arr.RemoveAt(i);
keynum--;
continue;
}
else
{
pos++;
tt = arr.GetAt(pos);
}
i++;
}
pNewObj->CreateShape(arr.GetData(),arr.GetSize());
return pNewObj;
}
CGeometry* CReplaceLinesCommand::GetReplaceObj_needSelect()
{
if( !m_pOldObj2 || m_pOldObj1==m_pOldObj2 )
return GetReplaceObj_needSelect_same();
//获得各个点在基线上的最近点
PT_3D ptSel1, ptSel2, ptStart, ptEnd;
double r = m_nSnapRadius;
int start1=-1, end1=-1, start2=-1, end2=-1, i;
Envelope e;
//判断m_ptSel1,m_ptSel2两个点是否对应于m_pOldObj1,m_pOldObj2，如果不对应，则需要交换一下
int bShift = 0;
PT_3D p1;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptSel1,&p1);
e .CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptSel1,NULL) )
bShift++;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptSel2,&p1);
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj2->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptSel2,NULL) )
bShift++;
if( bShift!=0 )
{
ptSel1 = m_ptSel1; m_ptSel1 = m_ptSel2; m_ptSel2 = ptSel1;
}
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptSel1,&p1);
e .CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptSel1,NULL) )
return NULL;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptSel2,&p1);
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj2->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptSel2,NULL) )
return NULL;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptStart,&p1);
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptSel2,NULL) )
{
start1 = -2;
}
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptEnd,&p1);
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj2->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptSel2,NULL) )
{
start2 = -2;
}
if( start1==-2 || start2==-2 )return NULL;
CGeometry *pCurve1 = (CGeometry*)m_pOldObj1->GetGeometry(), *pCurve2 = (CGeometry*)m_pOldObj2->GetGeometry();
CArray<int,int> KeyPos1,KeyPos2;
if(!pCurve1->GetShape()->GetKeyPosOfBaseLines(KeyPos1))return NULL;
if(!pCurve2->GetShape()->GetKeyPosOfBaseLines(KeyPos2))return NULL;
int keynum1 = KeyPos1.GetSize(), keynum2 = KeyPos2.GetSize();
if( keynum1<=1 || keynum2<=1 )return NULL;
CArray<PT_3DEX,PT_3DEX> pts1 ,pts2;
if(!pCurve1->GetShape()->GetPts(pts1)) return NULL;
if(!pCurve2->GetShape()->GetPts(pts2)) return NULL;
int num1 = pts1.GetSize();
int num2 = pts2.GetSize();
//获得上述各个最近点在基线中的位置
PT_3D rpt1,rpt2;
double x,y,z;
double dis,min1=-1,min2=-1;
int i1=-1, i2=-1;
//计算第一个地物
for( i=0; i<num1-1; i++)
{
//求出当前线段的最近距离
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts1[i].x,pts1[i].y,pts1[i].z,
pts1[i+1].x,pts1[i+1].y,pts1[i+1].z,m_ptSel1.x,m_ptSel1.y,m_ptSel1.z,&x,&y,&z,false);
if( min1<0 || dis<min1 )
{
min1 = dis; rpt1.x=x; rpt1.y=y; rpt1.z=z;
if( _FABS(x-pts1[i+1].x)+_FABS(y-pts1[i+1].y)>1e-10 )
i1=i;
//就是第二个点时，序号增加1
else i1=i+1;
}
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts1[i].x,pts1[i].y,pts1[i].z,
pts1[i+1].x,pts1[i+1].y,pts1[i+1].z,m_ptStart.x,m_ptStart.y,m_ptStart.z,&x,&y,&z,false);
if( min2<0 || dis<min2 )
{
min2 = dis; rpt2.x=x; rpt2.y=y; rpt2.z=z;
if( _FABS(x-pts1[i+1].x)+_FABS(y-pts1[i+1].y)>1e-10 )
i2=i;
//就是第二个点时，序号增加1
else i2=i+1;
}
}
//(虚拟)插入上述最近点到基线位置表中;
{
double d1=0, d2=0;
d1 = _FABS(pts1[i1].x-rpt1.x)+_FABS(pts1[i1].y-rpt1.y)+_FABS(pts1[i1].z-rpt1.z);
d2 = _FABS(pts1[i2].x-rpt2.x)+_FABS(pts1[i2].y-rpt2.y)+_FABS(pts1[i2].z-rpt2.z);
if( d1>1e-10 )
{
pts1.InsertAt(i1+1,PT_3DEX(rpt1,0));
for( i=0; i<keynum1; i++)if( KeyPos1[i]>i1 )KeyPos1[i] = KeyPos1[i]+1;
if( i1<i2 ||(i1==i2&&d1<=d2) )i2++;
i1++; num1++;
}
if( d2>1e-10 )
{
pts1.InsertAt(i2+1,PT_3DEX(rpt2,0));
for( i=0; i<keynum1; i++)if( KeyPos1[i]>i2 )KeyPos1[i] = KeyPos1[i]+1;
if( i2<i1 ||(i2==i1&&d2<d1) )i1++;
i2++; num1++;
}
}
if( i1<=i2 )
{
start1 = -1;
end1 = i2;
}
else
{
start1 = num1;
end1 = i2;
}
//计算第二个地物
i1=-1, i2=-1;
min1=-1,min2=-1;
for( i=0; i<num2-1; i++)
{
//求出当前线段的最近距离
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts2[i].x,pts2[i].y,pts2[i].z,
pts2[i+1].x,pts2[i+1].y,pts2[i+1].z,m_ptSel2.x,m_ptSel2.y,m_ptSel2.z,&x,&y,&z,false);
if( min1<0 || dis<min1 )
{
min1 = dis; rpt1.x=x; rpt1.y=y; rpt1.z=z;
if( _FABS(x-pts2[i+1].x)+_FABS(y-pts2[i+1].y)>1e-10 )
i1=i;
//就是第二个点时，序号增加1
else i1=i+1;
}
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts2[i].x,pts2[i].y,pts2[i].z,
pts2[i+1].x,pts2[i+1].y,pts2[i+1].z,m_ptEnd.x,m_ptEnd.y,m_ptEnd.z,&x,&y,&z,false);
if( min2<0 || dis<min2 )
{
min2 = dis; rpt2.x=x; rpt2.y=y; rpt2.z=z;
if( _FABS(x-pts2[i+1].x)+_FABS(y-pts2[i+1].y)>1e-10 )
i2=i;
//就是第二个点时，序号增加1
else i2=i+1;
}
}
//(虚拟)插入上述最近点到基线位置表中;
{
double d1=0, d2=0;
d1 = _FABS(pts2[i1].x-rpt1.x)+_FABS(pts2[i1].y-rpt1.y)+_FABS(pts2[i1].z-rpt1.z);
d2 = _FABS(pts2[i2].x-rpt2.x)+_FABS(pts2[i2].y-rpt2.y)+_FABS(pts2[i2].z-rpt2.z);
if( d1>1e-10 )
{
pts2.InsertAt(i1+1,PT_3DEX(rpt1,0));
for( i=0; i<keynum2; i++)if( KeyPos2[i]>i1 )KeyPos2[i] = KeyPos2[i]+1;
if( i1<i2 ||(i1==i2&&d1<=d2) )i2++;
i1++; num2++;
}
if( d2>1e-10 )
{
pts2.InsertAt(i2+1,PT_3DEX(rpt2,0));
for( i=0; i<keynum2; i++)if( KeyPos2[i]>i2 )KeyPos2[i] = KeyPos2[i]+1;
if( i2<i1 ||(i1==i2&&d2<d1) )i1++;
i2++; num2++;
}
}
if( i1<=i2 )
{
start2 = -1;
end2 = i2;
}
else
{
start2 = num2;
end2 = i2;
}
//计算各个位置最邻近的关键点
int startKey1, endKey1,startKey2, endKey2;
for( i=0; i<keynum1; i++)
{
if( start1<KeyPos1[i] )break;
}
startKey1 = i;
for( i=0; i<keynum1; i++)
{
if( end1<KeyPos1[i] )break;
}
endKey1 = i;
for( i=0; i<keynum2; i++)
{
if( start2<KeyPos2[i] )break;
}
startKey2 = i;
for( i=0; i<keynum2; i++)
{
if( end2<KeyPos2[i] )break;
}
endKey2 = i;
//准备新地物
CGeometry *pNewObj = (CGeometry*)m_pOldObj1->GetGeometry()->Clone();
if( !pNewObj )
{
return NULL;
}
PT_3DEX expt;
CArray<PT_3DEX,PT_3DEX> arr;
//首段
pts1.RemoveAll();
pNewObj->GetShape(pts1);
if( start1>end1 )
{
for( i=keynum1-1; i>=endKey1; i--)
{
arr.Add(pts1.GetAt(i));
}
}
else
{
for( i=0; i<endKey1; i++)
{
arr.Add(pts1.GetAt(i));
}
}
//替换段
// int newnum = m_pDrawProc->m_pGeoCurve->GetDataPointSum();
CArray<PT_3DEX,PT_3DEX> pts;
m_pObj->GetShape(pts);
arr.Append(pts);
// for( i=0; i<newnum; i++)
// {
// arr.Add(m_pDrawProc->m_pGeoCurve->GetDataPoint(i));
// }
pts.RemoveAll();
m_pOldObj2->GetGeometry()->GetShape(pts);
//尾段
if( start2>end2 )
{
for( i=endKey2; i<keynum2; i++)
{
arr.Add(pts.GetAt(i));
}
}
else
{
for( i=endKey2-1; i>=0; i--)
{
arr.Add(pts.GetAt(i));
}
}
pNewObj->CreateShape(arr.GetData(),arr.GetSize());
//去除重复的点(主要因为起点、终点落在原对象节点上)
PT_3DEX tt;
keynum1 = arr.GetSize();
int pos = 0;
tt = arr.GetAt(pos);
for( i=1; i<keynum1 && keynum1>2; )
{
expt = arr.GetAt(i);
if( _FABS(expt.x-tt.x)<1e-4 && _FABS(expt.y-tt.y)<1e-4 && _FABS(expt.z-tt.z)<1e-4 )
{
arr.RemoveAt(i);
keynum1--;
continue;
}
else
{
pos++;
tt = arr.GetAt(pos);
}
i++;
}
pNewObj->CreateShape(arr.GetData(),arr.GetSize());
return pNewObj;
}
//////////////////////////////////////////////////////////////////////
// CReplaceLinesCommand_overlap Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CReplaceLinesCommand_overlap,CReplaceLinesCommand)
CReplaceLinesCommand_overlap::CReplaceLinesCommand_overlap()
{
m_nMode = modeTwoPoint;
m_bCanTwoObjs = FALSE;
m_bMatchHeight = FALSE;
}
CReplaceLinesCommand_overlap::~CReplaceLinesCommand_overlap()
{
}
CString CReplaceLinesCommand_overlap::Name()
{
return StrFromResID(IDS_CMDNAME_REPLACE_OVERLAP);
}
void CReplaceLinesCommand_overlap::Start()
{
CReplaceLinesCommand::Start();
m_nMode = modeTwoPoint;
m_bCanTwoObjs = FALSE;
m_bMatchHeight = FALSE;
}
void CReplaceLinesCommand_overlap::OnSonEnd(CProcedure *son)
{
if( !m_pObj||m_pObj->GetDataPointSum()<2 )
{
Abort();
return;
}
if(m_nMode==modeTwoPoint)
{
if(m_pOldObj1==NULL)
{
Abort();
return;
}
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
BOOL bRet1 = FALSE, bRet2 = FALSE;
PT_3D pt1, pt2, pt0;
Envelope e;
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptStart,&pt0);
e.CreateFromPtAndRadius(pt0,r);
bRet1 = m_pOldObj1->GetGeometry()->FindNearestBasePt(pt0,e,m_pEditor->GetCoordWnd().m_pSearchCS,&pt1,NULL);
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptEnd,&pt0);
e.CreateFromPtAndRadius(pt0,r);
CPFeature pObj2 = pDQ->FindNearestObject(pt0,r,m_pEditor->GetCoordWnd().m_pSearchCS);
if(pObj2)
bRet2 = pObj2->GetGeometry()->FindNearestBasePt(pt0,e,m_pEditor->GetCoordWnd().m_pSearchCS,&pt2,NULL);
//寻找所有经过pt1和pt2的地物，进行修测
e.CreateFromPtAndRadius(pt1,GraphAPI::GetDisTolerance());
pDQ->FindObjectInRect(e,NULL);
CFtrArray arr1, arr2;
int num = 0;
const CPFeature *ftrs = pDQ->GetFoundHandles(num);
if(num>0)
{
arr1.SetSize(num);
memcpy(arr1.GetData(),ftrs,num*sizeof(CPFeature));
}
e.CreateFromPtAndRadius(pt2,GraphAPI::GetDisTolerance());
pDQ->FindObjectInRect(e,NULL);
ftrs = pDQ->GetFoundHandles(num);
if(num>0)
{
arr2.SetSize(num);
memcpy(arr2.GetData(),ftrs,num*sizeof(CPFeature));
}
if(!bRet1 || !bRet2)
{
arr1.RemoveAll();
}
//清除未同时经过pt1,pt2的地物
for(int i=arr1.GetSize()-1; i>=0; i--)
{
for(int j=0; j<arr2.GetSize(); j++)
{
if(arr2[j]==arr1[i])break;
}
if(j>=arr2.GetSize())
{
arr1.RemoveAt(i);
}
}
//没有多个符合条件的地物，就按照修测原来的逻辑进行处理
if(arr1.GetSize()<1)
{
CGeometry *pObj = GetReplaceObj();
if (!pObj)
{
Finish();
return;
}
m_pEditor->UpdateDrag(ud_ClearDrag);
CFeature *pFtr = HandleToFtr(m_objOldID1)->Clone();
if (!pFtr) return;
CUndoFtrs undo(m_pEditor,Name());
int layid = m_pEditor->GetFtrLayerIDOfFtr(m_objOldID1);
pFtr->SetID(OUID());
pFtr->SetGeometry(pObj);
if(m_pEditor->AddObject(pFtr,layid))
{
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_objOldID1),pFtr);
undo.AddNewFeature(FtrToHandle(pFtr));
}
if(m_pEditor->DeleteObject(m_objOldID1))
{
undo.AddOldFeature(m_objOldID1);
}
if(m_pEditor->DeleteObject(m_objOldID2))
{
undo.AddOldFeature(m_objOldID2);
}
undo.Commit();
Finish();
return;
}
CUndoFtrs undo(m_pEditor,Name());
for(i=0; i<arr1.GetSize(); i++)
{
m_objOldID1 = FtrToHandle(arr1[i]);
m_pOldObj1 = arr1[i];
CGeometry *pObj = GetReplaceObj();
if (!pObj)
{
continue;
}
CFeature *pFtr = HandleToFtr(m_objOldID1)->Clone();
if (!pFtr) continue;
int layid = m_pEditor->GetFtrLayerIDOfFtr(m_objOldID1);
pFtr->SetID(OUID());
pFtr->SetGeometry(pObj);
if(m_pEditor->AddObject(pFtr,layid))
{
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_objOldID1),pFtr);
undo.AddNewFeature(FtrToHandle(pFtr));
}
if(m_pEditor->DeleteObject(m_objOldID1))
{
undo.AddOldFeature(m_objOldID1);
}
if(m_pEditor->DeleteObject(m_objOldID2))
{
undo.AddOldFeature(m_objOldID2);
}
}
m_pEditor->UpdateDrag(ud_ClearDrag);
undo.Commit();
Finish();
}
}
void CReplaceLinesCommand_overlap::GetParams(CValueTable& tab)
{
}
void CReplaceLinesCommand_overlap::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID(AccelStr(),Name());
}
void CReplaceLinesCommand_overlap::SetParams(CValueTable& tab,BOOL bInit)
{
}
//////////////////////////////////////////////////////////////////////
// CExtendCollectCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CExtendCollectCommand,CDrawCommand)
CExtendCollectCommand::CExtendCollectCommand()
{
m_nStep = 0;
m_bReverse = FALSE;
m_pDrawProc = NULL;
m_pOldFtr = NULL;
pUndo = NULL;
strcat(m_strRegPath,"\\ExtendCollect");
}
CExtendCollectCommand::~CExtendCollectCommand()
{
if( m_pDrawProc )
{
delete m_pDrawProc;
m_pDrawProc = NULL;
}
if(pUndo)
{
delete pUndo;
pUndo = NULL;
}
}
void CExtendCollectCommand::Start()
{
if(!m_pEditor) return;
m_nStep = 0;
m_pFtr = NULL;
m_pOldFtr = NULL;
m_pDrawProc = new CDrawCurveProcedure;
if( !m_pDrawProc )return;
m_pDrawProc->Init(m_pEditor);
CGeoCurve *pGeo = new CGeoCurve;
if(!pGeo) return;
m_pDrawProc->m_pGeoCurve = pGeo;
UpdateParams(FALSE);
m_pDrawProc->Start();
pUndo = new CUndoFtrs(m_pEditor, Name());
CDrawCommand::Start();
}
CString CExtendCollectCommand::Name()
{
return StrFromResID(IDS_CMDNAME_EXTENDCOLLECT);
}
void CExtendCollectCommand::GetParams(CValueTable& tab)
{
CDrawCommand::GetParams(tab);
if(!m_pDrawProc) return;
_variant_t var;
var = (long)(m_pDrawProc->m_nCurPenCode);
tab.AddValue(PF_PENCODE,&CVariantEx(var));
var = (bool)(m_pDrawProc->m_bClosed);
tab.AddValue(PF_CLOSED,&CVariantEx(var));
var = (bool)(m_pDrawProc->m_bOpenIfSnapped);
tab.AddValue(PF_OPENIFSNAP,&CVariantEx(var));
var = (bool)(m_pDrawProc->m_bRectify);
tab.AddValue(PF_RECTIFY,&CVariantEx(var));
var = (double)(m_pDrawProc->m_compress.GetLimit());
tab.AddValue(PF_TOLER,&CVariantEx(var));
var = (double)(m_pDrawProc->m_fAutoCloseToler);
tab.AddValue(PF_AUTOCLOSETOLER,&CVariantEx(var));
var = (bool)(m_pDrawProc->m_bDoSmooth);
tab.AddValue(PF_POSTSMOOTH,&CVariantEx(var));
var = (bool)(m_pDrawProc->m_bFastDisplayCurve);
tab.AddValue(PF_FASTCURVE,&CVariantEx(var));
var = (double)(m_pDrawProc->m_fTolerBuildPt);
tab.AddValue(PF_BUILDPTTOLER,&CVariantEx(var));
}
void CExtendCollectCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID(PID_DRAWCURVE,StrFromLocalResID(IDS_CMDNAME_PLACECURVE));
if( m_pDrawProc )
{
PT_3D pt;
param->AddParam(PF_POINT,pt,StrFromLocalResID(IDS_CMDPLANE_POINT));
// if(m_nStep==0)
// param->AddParam(PF_CLOSED,false,StrFromLocalResID(IDS_CMDPLANE_CLOSE));
// else
// param->AddParam(PF_CLOSED,(bool)(m_pDrawProc->m_bClosed),StrFromLocalResID(IDS_CMDPLANE_CLOSE));
param->AddParam(PF_CLOSEDYACCKEY,'c',StrFromResID(IDS_CMDPLANE_CLOSE));
if (m_pDrawProc->m_bClosed || bForLoad)
{
param->BeginOptionParam(PF_OPENIFSNAP,StrFromResID(IDS_CMDPLANE_OPENIFSNAP));
param->AddOption(StrFromResID(IDS_YES),1,' ',m_pDrawProc->m_bOpenIfSnapped);
param->AddOption(StrFromResID(IDS_NO),0,' ',!m_pDrawProc->m_bOpenIfSnapped);
param->EndOptionParam();
}
if (m_pDrawProc->m_nCurPenCode == penLine || bForLoad)
{
param->BeginOptionParam(PF_RECTIFY,StrFromResID(IDS_CMDPLANE_RECTIFY));
param->AddOption(StrFromResID(IDS_YES),1,' ',m_pDrawProc->m_bRectify);
param->AddOption(StrFromResID(IDS_NO),0,' ',!m_pDrawProc->m_bRectify);
param->EndOptionParam();
}
param->AddParam(PF_RECTIFYACCKEY,'r',StrFromResID(IDS_CMDPLANE_RECTIFY));
param->AddParam(PF_REVERSEACCKEY,'t',StrFromResID(IDS_CMDPLANE_REVERSE));
param->AddParam(PF_TRACKLINEACCKEY,'w',StrFromResID(IDS_CMDPLANE_TRACKLINE));
param->AddParam(PF_MULPTBUILDPTACCKEY,'m',StrFromResID(IDS_CMDPLANE_MULPTBUILDPT));
param->AddParam("ConnectAccKey",'f',StrFromResID(IDS_CMDNAME_COMBINE));
if (m_pDrawProc->m_nCurPenCode == penStream || bForLoad)
{
// 容差，自动闭合容差，采集后光滑
param->AddParam(PF_TOLER,m_pDrawProc->m_compress.GetLimit(),StrFromResID(IDS_CMDPLANE_TOLERANCE));
param->AddParam(PF_AUTOCLOSETOLER,m_pDrawProc->m_fAutoCloseToler,StrFromResID(IDS_CMDPLANE_AUTOCLOSETOLER));
param->BeginOptionParam(PF_POSTSMOOTH,StrFromResID(IDS_CMDPLANE_POSTSMOOTH));
param->AddOption(StrFromResID(IDS_YES),1,' ',m_pDrawProc->m_bDoSmooth);
param->AddOption(StrFromResID(IDS_NO),0,' ',!m_pDrawProc->m_bDoSmooth);
param->EndOptionParam();
}
if (m_pDrawProc->m_nCurPenCode == penSpline || bForLoad)
{
param->BeginOptionParam(PF_FASTCURVE,StrFromResID(IDS_CMDPLANE_FASTCURVE));
param->AddOption(StrFromResID(IDS_YES),1,' ',m_pDrawProc->m_bFastDisplayCurve);
param->AddOption(StrFromResID(IDS_NO),0,' ',!m_pDrawProc->m_bFastDisplayCurve);
param->EndOptionParam();
}
param->AddLineTypeParam(PF_PENCODE,m_pDrawProc->m_nCurPenCode,StrFromLocalResID(IDS_CMDPLANE_LINETYPE));
param->AddParam(PF_LENGTH,double(1.0),StrFromResID(IDS_FIELDNAME_LENGTH),NULL,'D',FALSE);
param->AddParam(PF_ANGLE,double(0.0),StrFromResID(IDS_FIELDNAME_ANGLE),NULL,'A',FALSE);
if (m_pDrawProc->m_bMultiPtBuildPt || bForLoad)
{
param->AddParam(PF_BUILDPTTOLER,m_pDrawProc->m_fTolerBuildPt,StrFromResID(IDS_CMDPLANE_BUILDPTTOLERANCE));
}
}
}
void CExtendCollectCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_PENCODE,var) )
{
if (bInit)
{
m_pDrawProc->m_nCurPenCode = (long)(_variant_t)*var;
}
else
m_pDrawProc->ChangePencod((long)(_variant_t)*var);
}
if( tab.GetValue(0,PF_NODEWID,var) )
{
m_pDrawProc->m_fCurNodeWid = (float)(_variant_t)*var;
}
if( tab.GetValue(0,PF_NODETYPE,var) )
{
m_pDrawProc->m_nCurNodeType = (short)(_variant_t)*var;
}
if( tab.GetValue(0,PF_CLOSED,var) )
{
m_pDrawProc->m_bClosed = (bool)(_variant_t)*var;
}
if( tab.GetValue(0,PF_CLOSEDYACCKEY,var) )
{
char ch = (BYTE)(_variant_t)*var;
if(ch == 'c'||ch == 'C')
{
m_pDrawProc->m_bClosed = !m_pDrawProc->m_bClosed;
}
}
if( tab.GetValue(0,PF_TRACKLINEACCKEY,var) )
{
char ch = (BYTE)(_variant_t)*var;
if(ch == 'w'||ch == 'W')
{
m_pDrawProc->TrackLine();
}
}
if( tab.GetValue(0,PF_OPENIFSNAP,var) )
{
m_pDrawProc->m_bOpenIfSnapped = (bool)(_variant_t)*var;
}
if( tab.GetValue(0,PF_RECTIFY,var) )
{
m_pDrawProc->m_bRectify = (bool)(_variant_t)*var;
}
if( tab.GetValue(0,PF_RECTIFYACCKEY,var) )
{
char ch = (BYTE)(_variant_t)*var;
if(ch == 'r'||ch == 'R')
{
m_pDrawProc->m_bRectify = !m_pDrawProc->m_bRectify;
}
}
if( tab.GetValue(0,PF_REVERSEACCKEY,var) )
{
char ch = (BYTE)(_variant_t)*var;
if(ch == 't'||ch == 'T')
{
m_pDrawProc->ReverseLine();
m_bReverse = !m_bReverse;
}
}
if( tab.GetValue(0,PF_TOLER,var) )
{
m_pDrawProc->m_compress.SetLimit((double)(_variant_t)*var);
}
if( tab.GetValue(0,PF_AUTOCLOSETOLER,var) )
{
m_pDrawProc->m_fAutoCloseToler = (double)(_variant_t)*var;
}
if( tab.GetValue(0,PF_POSTSMOOTH,var) )
{
m_pDrawProc->m_bDoSmooth = (bool)(_variant_t)*var;
}
if( tab.GetValue(0,PF_FASTCURVE,var) )
{
m_pDrawProc->m_bFastDisplayCurve = (bool)(_variant_t)*var;
}
if( tab.GetValue(0,PF_POINT,var) )
{
CArray<PT_3DEX,PT_3DEX> arrPts;
var->GetShape(arrPts);
PT_3D point = arrPts.GetAt(0);
PtClick(point,0);
PtMove(point);
m_pEditor->RefreshView();
}
if( tab.GetValue(0,"ConnectAccKey",var) )
{
char ch = (BYTE)(_variant_t)*var;
if(ch == 'f'||ch == 'F')
{
Connect();
return;
}
}
// 通过长度和角度指定点
if (tab.GetValue(0,PF_LENGTH,var))
{
const CVariantEx *var1;
if (tab.GetValue(0,PF_ANGLE,var1))
{
double len = (double)(_variant_t)*var;
double ang = (double)(_variant_t)*var1;
int num = m_pDrawProc->m_arrPts.GetSize();
if (num > 0)
{
PT_3DEX pt = m_pDrawProc->m_arrPts[num-1];
pt.x += len*cos(ang/180*PI);
pt.y += len*sin(ang/180*PI);
PtClick(pt,0);
PtMove(pt);
m_pEditor->RefreshView();
}
}
}
if( tab.GetValue(0,PF_MULPTBUILDPTACCKEY,var) )
{
char ch = (BYTE)(_variant_t)*var;
if(ch == 'm'||ch == 'M')
{
m_pDrawProc->m_bMultiPtBuildPt?m_pDrawProc->EndBuildPt():m_pDrawProc->StartBuildPt();
}
}
if( tab.GetValue(0,PF_BUILDPTTOLER,var) )
{
m_pDrawProc->m_fTolerBuildPt = (double)(_variant_t)*var;
}
SetSettingsModifyFlag();
CDrawCommand::SetParams(tab,bInit);
}
void CExtendCollectCommand::PtReset(PT_3D &pt)
{
CArray<PT_3DEX,PT_3DEX> arr;
arr.Copy(m_pDrawProc->m_arrPts);
if(arr.GetSize()>0)
{
CGeometry *pGeo = m_pFtr->GetGeometry();
if(m_bReverse)
{
int nSize = arr.GetSize();
for(int i=0; i<nSize/2; i++)
{
PT_3DEX temp = arr[i];
arr[i] = arr[nSize-1-i];
arr[nSize-1-i] = temp;
}
}
if(m_pDrawProc->m_bClosed)
arr.Add(arr[0]);
pGeo->CreateShape(arr.GetData(),arr.GetSize());
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS)
{
Abort();
return;
}
CFtrLayer *pLayer = pDS->GetFtrLayerOfObject(m_pOldFtr);
if(!pLayer || !pLayer->IsVisible())
{
Abort();
return;
}
m_pEditor->AddObject(m_pFtr, pLayer->GetID());
pUndo->AddNewFeature(FtrToHandle(m_pFtr));
pUndo->AddOldFeature(FtrToHandle(m_pOldFtr));
pUndo->Commit();
Finish();
}
else
{
Abort();
}
}
void CExtendCollectCommand::Abort()
{
if( m_pDrawProc )
{
if(m_pOldFtr)
m_pEditor->RestoreObject(FtrToHandle(m_pOldFtr));
if( !IsProcOver(m_pDrawProc) )
m_pDrawProc->Abort();
delete m_pDrawProc;
m_pDrawProc = NULL;
}
m_nStep = 0;
CDrawCommand::Abort();
}
void CExtendCollectCommand::Finish()
{
UpdateParams(TRUE);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
m_nStep = 0;
CDrawCommand::Finish();
}
void CExtendCollectCommand::Back()
{
if(m_pDrawProc)
{
if(m_pDrawProc->m_arrPts.GetSize()<=1)
{
Abort();
return;
}
else
{
m_pDrawProc->Back();
}
}
}
void CExtendCollectCommand::Connect()
{
if(!m_pEditor) return;
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
if(!pDQ) return;
CView *pView = GetActiveView();
if(!pView || !pView->IsKindOf(RUNTIME_CLASS(CBaseView)))
return;
PT_3D pt = ((CBaseView*)pView)->GetCurPoint();
int ptsum = m_pDrawProc->m_arrPts.GetSize();
if(ptsum<2)
{
PtClick(pt, 0);
return;
}
Envelope e;
double r = 0.01;
e.CreateFromPtAndRadius(pt, r);
pDQ->FindObjectInRect(e,NULL,FALSE,FALSE);
int num, i, j;
const CPFeature *ftrs = pDQ->GetFoundHandles(num);
if(num<=0) return;
CArray<PT_3DEX,PT_3DEX> pts, temp;
PT_3DEX curPt(pt, penNone);
for(i=0; i<num; i++)
{
CGeometry *pGeo = ftrs[i]->GetGeometry();
if(!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
continue;
pGeo->GetShape(temp);
int nPt = temp.GetSize();
if(nPt<2) continue;
if( GraphAPI::GIsEqual2DPoint(&curPt, &temp[0]) )
{
pts.Append(temp);
break;
}
else if( GraphAPI::GIsEqual2DPoint(&curPt, &temp[nPt-1]) )
{
for(j=nPt-1; j>=0; j--)
{
pts.Add(temp[j]);
}
break;
}
}
if(i>=num) return;
GrBuffer buf;
buf.BeginLineString(m_pDrawProc->m_layCol,0);
PT_3D lastpt = m_pDrawProc->m_arrPts[ptsum-1];
buf.MoveTo(&lastpt);
buf.LineTo(&pts[0]);
buf.Lines(pts.GetData(), pts.GetSize(), sizeof(PT_3DEX));
buf.End();
m_pEditor->UpdateDrag(ud_AddConstDrag,&buf);
m_pDrawProc->m_arrPts.Append(pts);
pUndo->AddOldFeature(FtrToHandle(ftrs[i]));
m_pEditor->DeleteObject(FtrToHandle(ftrs[i]));
PT_3DEX pt0 = pts[pts.GetSize()-1];
PDOC(m_pEditor)->UpdateAllViews(NULL,hc_SetCrossPos,(CObject*)&pt0);
}
void CExtendCollectCommand::PtClick(PT_3D &pt, int flag)
{
if(!m_pDrawProc)
return;
if(m_nStep==1)
{
m_pDrawProc->PtClick(pt,flag);
}
if( m_nStep==0 )
{
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
//查找延长的地物
Envelope e;
double r = m_pEditor->GetSelection()->GetSelectRadius()*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
PT_4D ptsch = pt;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&ptsch,1);
e.CreateFromPtAndRadius(ptsch, r);
int num = pDQ->FindObjectInRect(e, m_pEditor->GetCoordWnd().m_pSearchCS);
const CPFeature *ftrs = pDQ->GetFoundHandles(num);
if(num<=0) return;
CFeature *pFtr0 = ftrs[0];
CGeometry* pGeo0 = pFtr0->GetGeometry();
if(!pGeo0) return;
int ptsum = pGeo0->GetDataPointSum();
if(ptsum<2)
{
Abort();
return;
}
CGeometry* pObj1 = NULL;
CGeometry* pObj2 = NULL;
CGeometry* pObj3 = NULL;
PT_3D pt0, pt1;
COPY_3DPT(pt0, pGeo0->GetDataPoint(0));
COPY_3DPT(pt1, pGeo0->GetDataPoint(ptsum-1));
if(GraphAPI::GIsEqual3DPoint(&pt0, &pt1))
{
m_pDrawProc->m_bClosed = TRUE;//让闭合的地物继续闭合
}
else
{
m_pDrawProc->m_bClosed = FALSE;
}
((CGeoCurve*)pGeo0)->GetBreak(pt0, pt, pObj1, pObj2, pObj3);
CGeometry* pObj = NULL;
if(pObj2==NULL && pObj3)
{
pObj = pObj3;
}
else if(pObj2 && pObj3==NULL)
{
pObj = pObj2;
}
else if(pObj2 && pObj3)
{
double len1 = pObj2->GetShape()->GetLength();
double len2 = pObj3->GetShape()->GetLength();
if(len1>len2)
{
pObj = pObj2;
}
else
{
pObj = pObj3;
}
}
if(pObj)
{
CArray<PT_3DEX, PT_3DEX> arr;
pObj->GetShape(arr);
if(GraphAPI::GIsEqual3DPoint(&arr[0], &arr[arr.GetSize()-1]))
{
arr.RemoveAt(arr.GetSize()-1);
}
if(pObj==pObj3)
{
for(int i=arr.GetSize()-1; i>=0; i--)
{
m_pDrawProc->m_arrPts.Add(arr[i]);
}
m_bReverse = TRUE;
}
else
{
m_pDrawProc->m_arrPts.Copy(arr);
}
long color = pGeo0->GetColor();
if (color == FTRCOLOR_BYLAYER)
{
CFtrLayer *pLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(pFtr0);
if (!pLayer)
{
if(pObj1) {delete pObj1; pObj1=NULL;}
if(pObj2) {delete pObj2; pObj2=NULL;}
if(pObj3) {delete pObj2; pObj3=NULL;}
Abort();
return;
}
color = pLayer->GetColor();
}
m_pDrawProc->m_layCol = color;
m_pOldFtr = pFtr0;
PT_3D pt3d;
int npt = m_pDrawProc->m_arrPts.GetSize();
COPY_3DPT(pt3d, m_pDrawProc->m_arrPts[npt-1]);
PDOC(m_pEditor)->UpdateAllViews(NULL,hc_SetCrossPos,(CObject*)&pt3d);
m_pFtr = pFtr0->Clone();
m_pFtr->GetGeometry()->CreateShape(m_pDrawProc->m_arrPts.GetData(), m_pDrawProc->m_arrPts.GetSize());
GrBuffer vbuf;
vbuf.BeginLineString(0,0,0);
vbuf.Lines(m_pDrawProc->m_arrPts.GetData(), m_pDrawProc->m_arrPts.GetSize(), sizeof(PT_3DEX));
vbuf.End();
vbuf.SetAllColor(color);
m_pEditor->UpdateDrag(ud_AddConstDrag,&vbuf);
m_pEditor->DeleteObject(FtrToHandle(pFtr0));
GotoState(PROCSTATE_PROCESSING);
}
if(pObj1) {delete pObj1; pObj1=NULL;}
if(pObj2) {delete pObj2; pObj2=NULL;}
if(pObj3) {delete pObj2; pObj3=NULL;}
m_nStep=1;
}
}
void CExtendCollectCommand::PtMove(PT_3D &pt)
{
if(m_nStep==1 && m_pDrawProc)
{
m_pDrawProc->PtMove(pt);
}
}
int CExtendCollectCommand::GetCurPenCode()
{
if(m_pDrawProc)
{
return m_pDrawProc->m_nCurPenCode;
}
return CDrawCommand::GetCurPenCode();
}
DrawingInfo CExtendCollectCommand::GetCurDrawingInfo()
{
if (m_pDrawProc)
{
CFeature *pFtr = new CFeature;
pFtr->SetGeometry(m_pDrawProc->m_pGeoCurve);
return DrawingInfo(pFtr,m_pDrawProc->m_arrPts);
}
else
return DrawingInfo();
}
//////////////////////////////////////////////////////////////////////
// CReplaceLinesWithCatchIntersecCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CReplaceLinesWithCatchIntersecCommand,CDrawCommand)
CReplaceLinesWithCatchIntersecCommand::CReplaceLinesWithCatchIntersecCommand()
{
// m_bAutoClosed = FALSE;
m_bSnap=TRUE;
m_nflag=0;
m_bVWsnaplinestyle = TRUE; //标志矢量窗口吸取线型
m_b3Dsnaplinestyle = TRUE;
m_bShowMark = TRUE;
m_nStep = -1;
m_objOldID1 = 0;
m_objOldID2 = 0;
m_pObj = NULL;
m_pOldObj1 = NULL;
m_pOldObj2 = NULL;
m_nStart = -1;
m_nEnd = -1;
m_nSaveViewParam = 0;
m_bUseViewParam = FALSE;
m_nSnapRadius = 20;
m_pDrawProc = NULL;
strcat(m_strRegPath,"\\ReplaceLinesWithCatchIntersec");
}
CReplaceLinesWithCatchIntersecCommand::~CReplaceLinesWithCatchIntersecCommand()
{
if( m_pDrawProc )delete m_pDrawProc;
if (m_pObj)
{
delete m_pObj;
m_pObj = NULL;
}
}
DrawingInfo CReplaceLinesWithCatchIntersecCommand::GetCurDrawingInfo()
{
if (m_pDrawProc)
{
CFeature *pFtr = new CFeature;
pFtr->SetGeometry(m_pDrawProc->m_pGeoCurve);
return DrawingInfo(pFtr,m_pDrawProc->m_arrPts);
}
else
return DrawingInfo();
}
CProcedure *CReplaceLinesWithCatchIntersecCommand::GetActiveSonProc(int nMsgType)
{
if( nMsgType==msgPtClick || nMsgType==msgPtMove || nMsgType==msgPtReset )
return NULL;
return m_pDrawProc;
}
void CReplaceLinesWithCatchIntersecCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
CFeature *pOldObj = NULL;
PT_3D p1;
PT_3D pt0;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&pt,&p1);
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
Envelope e;
e.CreateFromPtAndRadius(p1,r);
pOldObj = m_pEditor->GetDataQuery()->FindNearestObject(p1,r,m_pEditor->GetCoordWnd().m_pSearchCS);
if( pOldObj )
{
if( !(pOldObj->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurve))||pOldObj->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface))) )
return;
if (!CModifyZCommand::CheckObjForContour(pOldObj->GetGeometry()))
{
return;
}
if(!pOldObj->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&pt0,NULL) )
{
return;
}
m_ptStart = pt;
m_objOldID1 = FtrToHandle(pOldObj);
m_pOldObj1 = pOldObj;
Envelope ee;
ee.CreateMaxEnvelope();
int pos ;
m_pOldObj1->GetGeometry()->GetShape()->FindNearestLine(p1,ee,m_pEditor->GetCoordWnd().m_pSearchCS,NULL,NULL,NULL,&pos);
//得到前面的关键点的绘图钢笔码以及高程
CArray<int,int> pKeyPos;
m_pOldObj1->GetGeometry()->GetShape()->GetKeyPosOfBaseLines(pKeyPos);
if( pKeyPos.GetSize()>0 )
{
int num = m_pOldObj1->GetGeometry()->GetDataPointSum()-1;
while( num>=0 && pKeyPos[num]>pos )num--;
if( num>=0 )
{
PT_3DEX expt;
expt = m_pOldObj1->GetGeometry()->GetDataPoint(num);
if(!m_pEditor->GetCoordWnd().m_bIsStereo)
{
if(m_bVWsnaplinestyle)//如果m_bVWsnaplinestyle是true，则吸取，否则不吸取，而根据工具栏的选择确定
m_pDrawProc->m_nCurPenCode = expt.pencode;
else
;
}
else
{
if(m_b3Dsnaplinestyle)//如果m_bVWsnaplinestyle是true，则吸取，否则不吸取，而根据工具栏的选择确定
m_pDrawProc->m_nCurPenCode = expt.pencode;
else
;
}
// 保存立体视图参数
char params[256]={0};
PDOC(m_pEditor)->UpdateAllViewsParams(1,(LPARAM)params);
if( sscanf(params,"%d",&m_nSaveViewParam)==1 )
m_bUseViewParam = TRUE;
/*CView *pView = PDOC(m_pEditor)->GetCurActiveView();
if (pView)
{
pView->SendMessage(FCCM_UPDATESTEREOPARAM, 1, (LPARAM)params);
if( sscanf(params,"%d",&m_nSaveViewParam)==1 )
m_bUseViewParam = TRUE;
}*/
// 设置目标层码对应的视图参数
CDlgDataSource *pDS = PDOC(m_pEditor)->GetDlgDataSource();
if (!pDS){ Abort(); return;}
int nLayerId = PDOC(m_pEditor)->GetFtrLayerIDOfFtr(m_objOldID1);
CFtrLayer *pLayer = pDS->GetFtrLayer(nLayerId);
if (pLayer)
{
CPlaceConfigLib *pPlaceLib = gpCfgLibMan->GetPlaceConfigLib(pDS->GetScale());
if (pPlaceLib)
{
CPlaceConfig *pConfig = pPlaceLib->GetConfig(pLayer->GetName());
if (pConfig/* && pView*/)
{
PDOC(m_pEditor)->UpdateAllViewsParams(0,(LPARAM)pConfig->m_strViewParams);
//pView->SendMessage(FCCM_UPDATESTEREOPARAM, 0, (LPARAM)pConfig->m_strViewParams);
}
}
}
//立体窗口
if( m_pEditor->GetCoordWnd().m_bIsStereo )
{
((CDlgDoc*)m_pEditor)->UpdateAllViews(NULL,hc_ModifyHeight,(CObject*)&pt0.z);
}
m_ptStart.z = pt0.z;
pt.z = pt0.z;
//二维窗口
/*if( !m_pEditor->GetCoordWnd().m_bIsStereo )
{
pt.z = pt0.z;
m_ptStart.z = pt0.z;
}
else if( CModifyZCommand::CheckObjForContour(m_pOldObj1->GetGeometry()) )
{
((CDlgDoc*)m_pEditor)->UpdateAllViews(NULL,hc_ModifyHeight,(CObject*)&pt0.z);
m_ptStart.z = pt0.z;
pt.z = pt0.z;
}*/
}
}
//更新显示
GrBuffer buf;
buf.BeginLineString(0,0);
DrawPointTip(m_pOldObj1->GetGeometry(),pt0,&buf);
buf.End();
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
long color = m_pOldObj1->GetGeometry()->GetColor();
if (color == FTRCOLOR_BYLAYER)
{
CFtrLayer *pLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(m_pOldObj1);
if (!pLayer)
{
Abort();
return;
}
color = pLayer->GetColor();
}
m_pObj->SetColor(color);
}
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->RefreshView();
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
}
else if (m_nStep==1)
{
if (m_nflag==1&&m_bSnap)
{
//更改所画折线的尾点的位置
m_pDrawProc->PtClick(m_pt,flag);
return;
}
}
if( m_pDrawProc )
{
m_pDrawProc->PtClick(pt,flag);
}
CDrawCommand::PtClick(pt,flag);
}
void CReplaceLinesWithCatchIntersecCommand::PtMove(PT_3D &pt)
{
if( m_pDrawProc )
{
m_pDrawProc->PtMove(pt);
}
CDrawCommand::PtMove(pt);
if( IsProcFinished(this) )return;
m_nflag=0;
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
//m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
//查找
CFeature *pOldObj = NULL;
PT_3D p1;
PT_3D pt0;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&pt,&p1);
Envelope e;
e.CreateFromPtAndRadius(p1,r);
pOldObj = m_pEditor->GetDataQuery()->FindNearestObject(p1,r,m_pEditor->GetCoordWnd().m_pSearchCS);
if( pOldObj )
{
if( !(pOldObj->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurve))||pOldObj->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface))) )
return;
if (m_nStep==0)
{
if (!CModifyZCommand::CheckObjForContour(pOldObj->GetGeometry()))
{
return;
}
if(!pOldObj->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&pt0,NULL) )
{
return;
}
}
if (m_nStep==1)
{
if (!m_pOldObj1)
{
Finish();
return;
}
if(m_pOldObj1)
{
if (FtrToHandle(pOldObj)==m_objOldID1)
{
if(!pOldObj->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&pt0,NULL) )
{
return;
}
}
else
{
// //层码必须一致
// CFtrLayer *pLayer1 = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(m_pOldObj1);
// CFtrLayer *pLayer2 = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetFtrLayerOfObject(pOldObj);
//
// if( pLayer1 && pLayer2&&pLayer1 != pLayer2&&
// strcmp(pLayer1->GetName(),pLayer2->GetName())!=0 )
// {
// return;
// }
//如果是面，就不支持同时修测两个地物
if( (m_pOldObj1&&m_pOldObj1->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface)))||
(pOldObj&&pOldObj->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface))) )
{
if( FtrToHandle(pOldObj)!=m_objOldID1 )return;
}
else
{
if(!FindPointOfSameZInObject(pOldObj->GetGeometry(),r,m_ptStart.z,pt,&pt0 ))
return;
m_nflag = 1;
m_pt = pt0;
}
}
}
}
}
GrBuffer vbuf;
if( pOldObj && m_bShowMark)
{
//更新显示
GrBuffer buf;
buf.BeginLineString(0,0);
DrawPointTip(pOldObj->GetGeometry(),pt0,&buf);
buf.End();
vbuf.CopyFrom(&buf);
}
if (m_pDrawProc && m_pDrawProc->m_pGeoCurve->GetDataPointSum()<=0)
{
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
}
m_pEditor->UpdateDrag(ud_AddVariantDrag,&vbuf);
return;
}
void CReplaceLinesWithCatchIntersecCommand::OnSonEnd(CProcedure *son)
{
if( !m_pObj )
{
CDrawCommand::Abort();
return;
}
{
CGeometry *pObj = GetReplaceObj();
if (!pObj)
{
Finish();
return;
}
m_pEditor->UpdateDrag(ud_ClearDrag);
CFeature *pFtr = HandleToFtr(m_objOldID1)->Clone();
if (!pFtr) return;
CUndoFtrs undo(m_pEditor,Name());
int layid = m_pEditor->GetFtrLayerIDOfFtr(m_objOldID1);
pFtr->SetID(OUID());
pFtr->SetGeometry(pObj);
if(m_pEditor->AddObject(pFtr,layid))
{
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(m_objOldID1),pFtr);
undo.AddNewFeature(FtrToHandle(pFtr));
}
if(m_pEditor->DeleteObject(m_objOldID1))
{
undo.AddOldFeature(m_objOldID1);
}
if(m_pEditor->DeleteObject(m_objOldID2))
{
undo.AddOldFeature(m_objOldID2);
}
undo.Commit();
Finish();
}
}
void CReplaceLinesWithCatchIntersecCommand::PtReset(PT_3D &pt)
{
if( m_pDrawProc )
{
m_pDrawProc->PtReset(pt);
}
//画线操作结束
if( m_nStep==1 )
{
if( !m_pDrawProc->m_pGeoCurve || IsProcFinished(this) )
return;
if( m_pDrawProc->m_pGeoCurve->GetDataPointSum()<=1 )
{
Abort();
return;
}
m_pObj = m_pDrawProc->m_pGeoCurve->Clone();
//获得终点
PT_3DEX expt;
expt = m_pObj->GetDataPoint(m_pObj->GetDataPointSum()-1);
COPY_3DPT(m_ptEnd,expt);
}
}
CString CReplaceLinesWithCatchIntersecCommand::Name()
{
return StrFromResID(IDS_CMDNAME_REPLACECATCH);
}
void CReplaceLinesWithCatchIntersecCommand::Start()
{
m_bSnap=TRUE;
m_nflag=0;
m_bVWsnaplinestyle = TRUE; //标志矢量窗口吸取线型
m_b3Dsnaplinestyle = TRUE;
m_nStep = 0;
m_bShowMark = TRUE;
m_objOldID1 = 0;
m_objOldID2 = 0;
// m_objNewID = 0;
m_pOldObj1 = NULL;
m_pOldObj2 = NULL;
m_nStart = -1;
m_nEnd = -1;
m_pObj = NULL;
m_nSaveViewParam = 0;
m_bUseViewParam = FALSE;
m_nSnapRadius = 20;
m_pDrawProc = new CDrawCurveProcedure;
if( !m_pDrawProc )return;
m_pDrawProc->Init(m_pEditor);
UpdateParams(FALSE);
m_pObj = new CGeoCurve;
if(!m_pObj) return;
m_pDrawProc->m_pGeoCurve = (CGeoCurve*)m_pObj;
m_pDrawProc->Start();
CDrawCommand::Start();
}
void CReplaceLinesWithCatchIntersecCommand::Abort()
{
if( m_bUseViewParam )
{
char params[256]={0};
sprintf(params,"%d",m_nSaveViewParam);
PDOC(m_pEditor)->UpdateAllViewsParams(0,(LPARAM)params);
// CView *pView = PDOC(m_pEditor)->GetCurActiveView();
// if (pView) pView->SendMessage(FCCM_UPDATESTEREOPARAM, 0, (LPARAM)params);
}
UpdateParams(TRUE);
if( m_pDrawProc )
{
if( !IsProcOver(m_pDrawProc) )
m_pDrawProc->Abort();
delete m_pDrawProc;
m_pDrawProc = NULL;
}
if(m_pObj)
{
delete m_pObj;
m_pObj = NULL;
}
CDrawCommand::Abort();
}
void CReplaceLinesWithCatchIntersecCommand::Finish()
{
CDrawCommand::Finish();
if (m_pDrawProc)
{
delete m_pDrawProc;
m_pDrawProc = NULL;
}
if (m_pObj)
{
delete m_pObj;
m_pObj = NULL;
}
}
void CReplaceLinesWithCatchIntersecCommand::GetParams(CValueTable &tab)
{
CDrawCommand::GetParams(tab);
_variant_t var;
var = (bool)(m_bShowMark);
tab.AddValue(PF_REPLACELINESHOWMARK,&CVariantEx(var));
var = (_variant_t)(long)(m_nSnapRadius);
tab.AddValue(PF_REPLACELINESNAPRADIUS,&CVariantEx(var));
var = (bool)(m_bSnap);
tab.AddValue(PF_REPLACELINESNAP,&CVariantEx(var));
var = (bool)(m_bVWsnaplinestyle);
tab.AddValue(PF_REPLACELINEVECTOR,&CVariantEx(var));
var = (bool)(m_b3Dsnaplinestyle);
tab.AddValue(PF_REPLACELINESTEREO,&CVariantEx(var));
if(m_pDrawProc)
{
var = (_variant_t)(long)(m_pDrawProc->m_nCurPenCode);
tab.AddValue(PF_PENCODE,&CVariantEx(var));
}
}
void CReplaceLinesWithCatchIntersecCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("ReplaceLinesWithCatchIntersecCommand",StrFromResID(IDS_CMDNAME_REPLACECATCH));
param->AddParam(PF_REPLACELINESHOWMARK,(bool)m_bShowMark,StrFromResID(IDS_CMDPLANE_SHOWMARK));
param->AddParam(PF_REPLACELINESNAPRADIUS,(int)m_nSnapRadius,StrFromResID(IDS_CMDPLANE_SNAPRADIUS));
param->AddParam(PF_REPLACELINESNAP,(bool)m_bSnap,StrFromResID(IDS_CMDPLANE_SNAP));
param->AddParam(PF_REPLACELINEVECTOR,(bool)m_bVWsnaplinestyle,StrFromResID(IDS_CMDPLANE_VWSNAPLINESTYLE));
param->AddParam(PF_REPLACELINESTEREO,(bool)m_b3Dsnaplinestyle,StrFromResID(IDS_CMDPLANE_TDSNAPLINESTYLE));
if(m_pDrawProc)
param->AddLineTypeParam(PF_PENCODE,m_pDrawProc->m_nCurPenCode,StrFromLocalResID(IDS_CMDPLANE_LINETYPE));
// param->AddParam(PF_COPYROTATEKPOLD,bool(m_bKeepOld),StrFromResID(IDS_CMDPLANE_KEEPOLD));
}
int CReplaceLinesWithCatchIntersecCommand::GetCurPenCode()
{
if (m_pDrawProc)
{
return m_pDrawProc->m_nCurPenCode;
}
return CDrawCommand::GetCurPenCode();
}
void CReplaceLinesWithCatchIntersecCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_REPLACELINESHOWMARK,var) )
{
m_bShowMark = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINESNAP,var) )
{
m_bSnap = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINESNAPRADIUS,var) )
{
m_nSnapRadius = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINEVECTOR,var) )
{
m_bVWsnaplinestyle = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_REPLACELINESTEREO,var) )
{
m_b3Dsnaplinestyle = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if(m_pDrawProc&&tab.GetValue(0,PF_PENCODE,var) )
{
m_pDrawProc->m_nCurPenCode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
CDrawCommand::SetParams(tab,bInit);
}
void CReplaceLinesWithCatchIntersecCommand::DrawPointTip(CGeometry *pObj, PT_3D pt, GrBuffer *buf)
{
PT_4D pts[4];
pts[0] = PT_4D(pt);
m_pEditor->GetCoordWnd().m_pViewCS->GroundToClient(pts,1);
pts[0].x -= 10; pts[0].y -= 10; pts[0].z -= 10; pts[0].yr -= 10;
pts[1].x = pts[0].x+20; pts[1].y = pts[0].y+20;
pts[1].z = pts[0].z+20; pts[1].yr = pts[0].yr+20;
pts[2].x = pts[0].x; pts[2].y = pts[0].y+20;
pts[2].z = pts[0].z; pts[2].yr = pts[0].yr+20;
pts[3].x = pts[0].x+20; pts[3].y = pts[0].y;
pts[3].z = pts[0].z+20; pts[3].yr = pts[0].yr;
m_pEditor->GetCoordWnd().m_pViewCS->ClientToGround(pts,4);
PT_3D pt3ds[4];
for( int i=0; i<4; i++)pt3ds[i] = pts[i].To3D();
buf->MoveTo(pt3ds);
buf->LineTo(pt3ds+1);
buf->MoveTo(pt3ds+2);
buf->LineTo(pt3ds+3);
}
bool CReplaceLinesWithCatchIntersecCommand::FindPointOfSameZInObject(CGeometry *pObj, double r,double z,PT_3D pt, PT_3D *ret)
{
if (!pObj)
{
return false;
}
PT_3DEX p1,p2;
PT_3D tem;
tem.z=z;
double minr=r+1,t;
CArray<PT_3DEX,PT_3DEX> pts;
CGeometry *pObjs[2] = {pObj,NULL};
BOOL bNeedRelease = FALSE;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoParallel)) )
{
if( !((CGeoParallel*)pObj)->Separate(pObjs[0],pObjs[1]) )
{
pObjs[0] = pObj;
pObjs[1] = NULL;
}
else
{
bNeedRelease = TRUE;
}
}
bool bFindOK = false;
for( int k=0; k<2; k++)
{
pObj = pObjs[k];
if( !pObj )continue;
pObj->GetShape(pts);
int num=pts.GetSize()-1;
for (int i=0;i<num;i++)
{
p1 = pts.GetAt(i);
p2 = pts.GetAt(i+1);
double x,y;
t=GraphAPI::GGetNearestDisOfPtToLine(p1.x,p1.y,p2.x,p2.y,pt.x,pt.y,&x,&y,false);
if(z<min(p1.z,p2.z)||z>max(p1.z,p2.z)||t>r) continue;
double dis;
if (fabs(p2.z-p1.z)<1e-6)
{
if (fabs(z-p2.z)<1e-6)
{
dis=sqrt((x-pt.x)*(x-pt.x)+(y-pt.y)*(y-pt.y));
}
else
continue;
}
else
{
x=(p2.x-p1.x)*(z-p1.z)/(p2.z-p1.z)+p1.x;
y=(p2.y-p1.y)*(z-p1.z)/(p2.z-p1.z)+p1.y;
dis=sqrt((x-pt.x)*(x-pt.x)+(y-pt.y)*(y-pt.y));
}
if (r>dis)
{
if(minr>dis)
{
minr=dis;
tem.x=x;
tem.y=y;
}
}
}
if (minr<r&&ret)
{
*ret=tem;
bFindOK = true;
break;
}
}
if( bNeedRelease )
{
if( pObjs[0] )delete pObjs[0];
if( pObjs[1] )delete pObjs[1];
}
return bFindOK;
}
CGeometry* CReplaceLinesWithCatchIntersecCommand::GetReplaceObj()
{
if( !m_pOldObj2 || m_pOldObj1==m_pOldObj2 )
return GetReplaceObj_same();
//获得各个点在基线上的最近点
PT_3D ptStart, ptEnd;
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
int start1=-1, end1=-1, start2=-1, end2=-1, i;
PT_3D p1;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptStart,&p1);
Envelope e ;
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptStart,NULL) )
{
start1 = -2;
}
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptEnd,&p1);
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj2->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptEnd,NULL) )
{
start2 = -2;
}
//两点都没有附着到地物上
if( start1==-2 || start2==-2 )return NULL;
CGeometry *pCurve1 = (CGeometry*)m_pOldObj1->GetGeometry(), *pCurve2 = (CGeometry*)m_pOldObj2->GetGeometry();
const CShapeLine *pSL1 = pCurve1->GetShape();
const CShapeLine *pSL2 = pCurve2->GetShape();
//得到关键点在基线中的对应序号
CArray<int,int> KeyPos1 , KeyPos2 ;
if(!pSL1->GetKeyPosOfBaseLines(KeyPos1)) return NULL;
if(!pSL2->GetKeyPosOfBaseLines(KeyPos2)) return NULL;
int keynum1 = KeyPos1.GetSize();
int keynum2 = KeyPos2.GetSize();
CArray<PT_3DEX,PT_3DEX> pts1,pts2;
if(!pSL1->GetPts(pts1))return NULL;
int num1 = pts1.GetSize();
if(!pSL2->GetPts(pts2))return NULL;
int num2 = pts2.GetSize();
if( num1<=1 || num2<=1 )
{
return NULL;
}
//获得上述各个最近点在基线中的位置
PT_3D rpt2;
double x,y,z;
double dis,min1=-1,min2=-1, min3=-1;
int i1=-1, i2=-1, i3=-1;
//计算第一个地物
for( i=0; i<num1-1; i++)
{
//求出当前线段的最近距离
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts1[i].x,pts1[i].y,pts1[i].z,
pts1[i+1].x,pts1[i+1].y,pts1[i+1].z,m_ptStart.x,m_ptStart.y,m_ptStart.z,&x,&y,&z,false);
if( min2<0 || dis<min2 )
{
min2 = dis; rpt2.x=x; rpt2.y=y; rpt2.z=z;
if( _FABS(x-pts1[i+1].x)+_FABS(y-pts1[i+1].y)>1e-10 )
i2=i;
//就是第二个点时，序号增加1
else i2=i+1;
}
}
//(虚拟)插入上述最近点到基线位置表中;
{
double d=0;
if( i2<num1 && i2>=0 )d = _FABS(pts1[i2].x-rpt2.x)+_FABS(pts1[i2].y-rpt2.y)+_FABS(pts1[i2].z-rpt2.z);
if( d>1e-10 && i2<num1 && i2>=0 )
{
pts1.InsertAt(i2+1,PT_3DEX(rpt2,0));
for( i=0; i<keynum1; i++)if( KeyPos1[i]>i2 )KeyPos1[i] = KeyPos1[i]+1;
i2++; num1++;
}
}
//判断哪一头比较长，比较长的保留
{
double d1 = pSL1->GetLength(&ptStart);
double d2 = pSL1->GetLength()-d1;
if( d1>=d2 )
{
start1 = -1;
end1 = i2;
}
else
{
start1 = num1;
end1 = i2;
}
}
//计算第二个地物
for( i=0; i<num2-1; i++)
{
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts2[i].x,pts2[i].y,pts2[i].z,
pts2[i+1].x,pts2[i+1].y,pts2[i+1].z,m_ptEnd.x,m_ptEnd.y,m_ptEnd.z,&x,&y,&z,false);
if( min3<0 || dis<min3 )
{
min3 = dis; rpt2.x=x; rpt2.y=y; rpt2.z=z;
if( _FABS(x-pts2[i+1].x)+_FABS(y-pts2[i+1].y)>1e-10 )
i3=i;
//就是第二个点时，序号增加1
else i3=i+1;
}
}
//(虚拟)插入上述最近点到基线位置表中;
{
double d=0;
if( i3<num2 && i3>=0 )d = _FABS(pts2[i3].x-rpt2.x)+_FABS(pts2[i3].y-rpt2.y)+_FABS(pts2[i3].z-rpt2.z);
if( d>1e-10 && i3<num2 && i3>=0 )
{
pts2.InsertAt(i3+1,PT_3DEX(rpt2,0));
for( i=0; i<keynum2; i++)if( KeyPos2[i]>i3 )KeyPos2[i] = KeyPos2[i]+1;
i3++; num2++;
}
}
//判断哪一头比较长，比较长的保留
{
double d1 = pSL2->GetLength(&ptEnd);
double d2 = pSL2->GetLength()-d1;
if( d1>=d2 )
{
start2 = -1;
end2 = i3;
}
else
{
start2 = num2;
end2 = i3;
}
}
//计算各个位置最邻近的关键点
int startKey1, endKey1,startKey2, endKey2;
for( i=0; i<keynum1; i++)
{
if( start1<KeyPos1[i] )break;
}
startKey1 = i;
for( i=0; i<keynum1; i++)
{
if( end1<KeyPos1[i] )break;
}
endKey1 = i;
for( i=0; i<keynum2; i++)
{
if( start2<KeyPos2[i] )break;
}
startKey2 = i;
for( i=0; i<keynum2; i++)
{
if( end2<KeyPos2[i] )break;
}
endKey2 = i;
//准备新地物
CGeometry *pNewObj = (CGeometry*)m_pOldObj1->GetGeometry()->Clone();
if( !pNewObj )
{
return NULL;
}
// CDpDBVariant var;
// var = (long)0;
// pNewObj->GetBind()->SetAttrValue("EXCODE",var,DP_CFT_INTEGER);
// pNewObj->UpdateData(FALSE);
PT_3DEX expt;
CArray<PT_3DEX,PT_3DEX> arr;
//首段
pts1.RemoveAll();
pNewObj->GetShape(pts1);
if( start1>end1 )
{
for( i=keynum1-1; i>=endKey1; i--)
{
arr.Add(pts1.GetAt(i));
}
}
else
{
for( i=0; i<endKey1; i++)
{
arr.Add(pts1.GetAt(i));
}
}
//替换段
pts2.RemoveAll();
m_pObj->GetShape(pts2);
// int newnum = m_pObj->GetDataPointSum();
arr.Append(pts2);
// for( i=0; i<newnum; i++)
// {
// arr.Add(m_pObj->GetDataPoint(i));
// }
//尾段
pts2.RemoveAll();
m_pOldObj2->GetGeometry()->GetShape(pts2);
if( start2>end2 )
{
for( i=endKey2; i<keynum2; i++)
{
arr.Add(pts2.GetAt(i));
}
}
else
{
for( i=endKey2-1; i>=0; i--)
{
arr.Add(pts2.GetAt(i));
}
}
//去除重复的点(主要因为起点、终点落在原对象节点上)
PT_3DEX tt;
keynum1 = arr.GetSize();
int pos = 0;
tt = arr.GetAt(pos);
for( i=1; i<keynum1 && keynum1>2; )
{
expt = arr.GetAt(i);
if( _FABS(expt.x-tt.x)<1e-4 && _FABS(expt.y-tt.y)<1e-4 && _FABS(expt.z-tt.z)<1e-4 )
{
arr.RemoveAt(i);
keynum1--;
continue;
}
else
{
pos++;
tt = arr.GetAt(pos);
}
i++;
}
if(!pNewObj->CreateShape(arr.GetData(),arr.GetSize())) return NULL;
return pNewObj;
}
CGeometry* CReplaceLinesWithCatchIntersecCommand::GetReplaceObj_same()
{
if(!m_pOldObj1) return NULL;
//获得各个点在基线上的最近点
PT_3D ptStart, ptEnd;
double r = m_nSnapRadius*m_pEditor->GetCoordWnd().GetScaleOfSearchCSToViewCS();
int select=-1, start=-1, end=-1, i;
PT_3D p1;
Envelope e;
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptStart,&p1);
e.CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptStart,NULL) )
{
start = -2;
}
m_pEditor->GetCoordWnd().m_pSearchCS->GroundToClient(&m_ptEnd,&p1);
e .CreateFromPtAndRadius(p1,r);
if( !m_pOldObj1->GetGeometry()->FindNearestBasePt(p1,e,m_pEditor->GetCoordWnd().m_pSearchCS,&ptEnd,NULL) )
{
end = -2;
}
//两点都没有附着到地物上
if( start==-2 && end==-2 )return NULL;
//如果是面，头尾点必须都附着在地物上
if( m_pOldObj1->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface)) )
{
if( start==-2 || end==-2 )return NULL;
}
CGeometry *pCurve = (CGeometry*)m_pOldObj1->GetGeometry();
int keynum = pCurve->GetDataPointSum();
if( keynum<=1 )return NULL;
const CShapeLine *pSL = pCurve->GetShape();
//得到关键点在基线中的对应序号
CArray<int,int> KeyPos;
if(!pSL->GetKeyPosOfBaseLines(KeyPos)) return NULL;
CArray<PT_3DEX,PT_3DEX> pts;
if(!pSL->GetPts(pts)) return NULL;
int num = pts.GetSize();
if( num<=1 )
{
return NULL;
}
//获得上述各个最近点在基线中的位置
PT_3D rpt2,rpt3;
double x,y,z;
double dis,min2=-1, min3=-1;
int i1=-1, i2=-1, i3=-1;
for( i=0; i<num-1; i++)
{
//求出当前线段的最近距离
if( start!=-2 )
{
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts[i].x,pts[i].y,pts[i].z,
pts[i+1].x,pts[i+1].y,pts[i+1].z,m_ptStart.x,m_ptStart.y,m_ptStart.z,&x,&y,&z,false);
if( min2<0 || dis<min2 )
{
min2 = dis; rpt2.x=x; rpt2.y=y; rpt2.z=z;
if( _FABS(x-pts[i+1].x)+_FABS(y-pts[i+1].y)>1e-10 )
i2=i;
//就是第二个点时，序号增加1
else i2=i+1;
}
}
if( end!=-2 )
{
dis = GraphAPI::GGetNearestDisOfPtToLine3D(pts[i].x,pts[i].y,pts[i].z,
pts[i+1].x,pts[i+1].y,pts[i+1].z,m_ptEnd.x,m_ptEnd.y,m_ptEnd.z,&x,&y,&z,false);
if( min3<0 || dis<min3 )
{
min3 = dis; rpt3.x=x; rpt3.y=y; rpt3.z=z;
if( _FABS(x-pts[i+1].x)+_FABS(y-pts[i+1].y)>1e-10 )
i3=i;
//就是第二个点时，序号增加1
else i3=i+1;
}
}
}
if( min2<0 && min3<0 )
{
return NULL;
}
//(虚拟)插入上述最近点到基线位置表中;
{
double d2=0, d3=0;
if( i2<num && i2>=0 )d2 = _FABS(pts[i2].x-rpt2.x)+_FABS(pts[i2].y-rpt2.y)+_FABS(pts[i2].z-rpt2.z);
if( i3<num && i3>=0 )d3 = _FABS(pts[i3].x-rpt3.x)+_FABS(pts[i3].y-rpt3.y)+_FABS(pts[i3].z-rpt3.z);
if( d2>1e-10 && i2<num && i2>=0 )
{
pts.InsertAt(i2+1,PT_3DEX(rpt2,20));
for( i=0; i<keynum; i++)if( KeyPos[i]>i2 )KeyPos[i] = KeyPos[i]+1;
if( i2<i3 ||(i2==i3&&d2<=d3) )i3++;
i2++; num++;
}
if( d3>1e-10 && i3<num && i3>=0 )
{
pts.InsertAt(i3+1,PT_3DEX(rpt3,20));
for( i=0; i<keynum; i++)if( KeyPos[i]>i3 )KeyPos[i] = KeyPos[i]+1;
if( i3<i2 ||(i3==i2&&d3<d2) )i2++;
i3++; num++;
}
}
//有个点在咬合范围外，就判断哪一头比较长，比较长的保留
if( start==-2 || end==-2 )
{
double d1 = pSL->GetLength(&ptStart);
double d2 = pSL->GetLength()-d1;
if( d1>=d2 )
{
select = -1;
start = (start==-2?num:i2);
end = (end==-2?num:i3);
}
else
{
select = num;
start = (start==-2?-1:i2);
end = (end==-2?-1:i3);
}
}
//两个点都在咬合范围内，
else
{
//如果是闭合线或者是面，就判断哪一段比较长，比较长的保留
if( m_pOldObj1->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoSurface)) ||
(m_pOldObj1->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoCurve)) && ((CGeoCurve*)(m_pOldObj1->GetGeometry()))->IsClosed()) )
{
double d1 = fabs(pSL->GetLength(&ptEnd)-pSL->GetLength(&ptStart));
double d2 = pSL->GetLength()-d1;
//保留中间
if( d1>d2 )
{
select = (i2+i3)/2;
start = i2;
end = i3;
}
//保留头尾
else
{
select = -1;
start = i2;
end = i3;
}
}
//否则替换中间的
else
{
select = -1;
start = i2;
end = i3;
}
}
//计算各个位置最邻近的关键点
int startKey, endKey;
for( i=0; i<keynum; i++)
{
if( start<KeyPos[i] )break;
}
startKey = i;
for( i=0; i<keynum; i++)
{
if( end<KeyPos[i] )break;
}
endKey = i;
//准备新地物
CGeometry *pNewObj = (CGeometry*)m_pOldObj1->GetGeometry()->Clone();
if( !pNewObj )
{
return NULL;
}
CArray<PT_3DEX,PT_3DEX> arr,pts1;
PT_3DEX expt;
//---------分如下情况生成新的地物
//1. 选择点在起始点外
if( select<=(start<end?start:end) || select>=(start>=end?start:end) )
{
if( startKey>endKey ){ int t=startKey; startKey=endKey; endKey=t; }
//首段
pNewObj->GetShape(pts1);
for( i=0; i<startKey; i++)
{
arr.Add(pts1.GetAt(i));
}
//防止expt具有无效的cd码
if( startKey<=0 )expt = m_pObj->GetDataPoint(0);
//替换段
pts.RemoveAll();
m_pObj->GetShape(pts);
int newnum = pts.GetSize();
if( start<=end )
{
arr.Append(pts);
// for( i=0; i<newnum; i++)
// {
// arr.Add(m_pObj->GetDataPoint(i));
// }
}
else
{
for( i=newnum-1; i>=0; i--)
{
arr.Add(pts.GetAt(i));
}
}
//尾段
for( i=endKey; i<keynum; i++)
{
arr.Add(pts1.GetAt(i));
}
}
//2. 选择点在起始点内
else
{
if( startKey>endKey ){ int t=startKey; startKey=endKey; endKey=t; }
//中间段
expt = pNewObj->GetDataPoint(startKey);
if( start<=end )COPY_3DPT(expt,m_ptStart);
else COPY_3DPT(expt,m_ptEnd);
arr.Add(expt);
pNewObj->GetShape(pts1);
for( i=startKey; i<endKey; i++)
{
arr.Add(pts1.GetAt(i));
}
if( start<=end )COPY_3DPT(expt,m_ptEnd);
else COPY_3DPT(expt,m_ptStart);
arr.Add(expt);
//替换段
pts.RemoveAll();
m_pObj->GetShape(pts);
int newnum = pts.GetSize();
if( start>end )
{
arr.Append(pts);
// for( i=0; i<newnum; i++)
// {
// arr.Add(m_pObj->GetDataPoint(i));
// }
}
else
{
for( i=newnum-1; i>=0; i--)
{
arr.Add(pts.GetAt(i));
}
}
}
//去除重复的点(主要因为起点、终点落在原对象节点上)
PT_3DEX tt;
keynum = arr.GetSize();
int pos = 0;
tt = arr.GetAt(pos);
for( i=1; i<keynum && keynum>2; )
{
expt = arr.GetAt(i);
if( _FABS(expt.x-tt.x)<1e-4 && _FABS(expt.y-tt.y)<1e-4 && _FABS(expt.z-tt.z)<1e-4 )
{
arr.RemoveAt(i);
keynum--;
continue;
}
else
{
pos++;
tt = arr.GetAt(pos);
}
i++;
}
if (!pNewObj->CreateShape(arr.GetData(),arr.GetSize()))
{
return NULL;
}
return pNewObj;
}
//////////////////////////////////////////////////////////////////////
// CDrawRectCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDrawRectCommand,CDrawCommand)
CDrawRectCommand::CDrawRectCommand()
{
m_nMode = modeCustom;
m_pFtr = NULL;
m_pSel = NULL;
strcat(m_strRegPath,"\\Rect");
}
CDrawRectCommand::~CDrawRectCommand()
{
if (m_pFtr)
{
delete m_pFtr;
}
if(m_pSel) delete m_pSel;
}
CString CDrawRectCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DRAWRECT);
}
void CDrawRectCommand::Start()
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
if(!pLayer) return;
m_pFtr = pLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOCURVE);
if(!m_pFtr) return;
CDlgDataSource *pDS = GETDS(m_pEditor);
m_nMode = modeCustom;
((CGeoCurve*)m_pFtr->GetGeometry())->EnableClose(TRUE);
CDrawCommand::Start();
m_pSel = new CPermanentExchanger(m_pFtr);
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
m_pEditor->CloseSelector();
}
void CDrawRectCommand::RefreshPropertiesPanel()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
void CDrawRectCommand::Finish()
{
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
if( m_pEditor )
{
if( m_pFtr )
{
BOOL bAnnotToText = AfxGetApp()->GetProfileInt(REGPATH_USER,REGITEM_ANNOTTOTEXT,FALSE);
if( bAnnotToText )
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
// CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayerByNameOrLayerIdx(StrFromResID(IDS_DEFLAYER_NAMET));
CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetLocalFtrLayer(StrFromResID(IDS_DEFLAYER_NAMET));
CFeature *pTempl = NULL;
if(pTextLayer)
pTempl = pTextLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOTEXT);
if( pLayer!=NULL && pTextLayer!=NULL && pTempl!=NULL )
{
CPtrArray arrAnnots;
CConfigLibManager *pCLM = gpCfgLibMan;
pCLM->GetSymbol(GETDS(m_pEditor),m_pFtr,arrAnnots);
CUndoFtrs undo(m_pEditor,Name());
for(int i=0; i<arrAnnots.GetSize(); i++)
{
CSymbol *pSymbol = (CSymbol*)arrAnnots.GetAt(i);
if (pSymbol && pSymbol->GetType()==SYMTYPE_ANNOTATION )
{
CAnnotation *pAnnot = (CAnnotation*)pSymbol;
CPtrArray parr;
CValueTable tab;
PDOC(m_pEditor)->GetDlgDataSource()->GetAllAttribute(m_pFtr,tab);
if( pAnnot->ExtractGeoText(m_pFtr,parr,tab,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale()) )
{
for (int j=0; j<parr.GetSize(); j++)
{
CGeoText *pText = (CGeoText*)parr[j];
pText->SetColor(m_pFtr->GetGeometry()->GetColor());
CFeature *pNewFtr = pTempl->Clone();
pNewFtr->SetGeometry(pText);
PDOC(m_pEditor)->AddObject(pNewFtr,pTextLayer->GetID());
undo.arrNewHandles.Add(FtrToHandle(pNewFtr));
}
}
}
}
undo.Commit();
}
if( pTempl!=NULL )delete pTempl;
}
}
m_pFtr = NULL;
m_pEditor->RefreshView();
}
CDrawCommand::Finish();
}
DrawingInfo CDrawRectCommand::GetCurDrawingInfo()
{
return DrawingInfo(m_pFtr,m_arrPts);
}
int CDrawRectCommand::GetCurPenCode()
{
return penLine;
}
void CDrawRectCommand::Abort()
{
m_pEditor->UpdateDrag(ud_ClearDrag);
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
m_pEditor->RefreshView();
CDrawCommand::Abort();
}
void CDrawRectCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
GotoState(PROCSTATE_PROCESSING);
PT_3DEX expt(pt,penLine);
m_arrPts.Add(expt);
if( m_nMode==modeHoriz )
{
if( m_arrPts.GetSize()==2 )
{
PT_3DEX pt0,pt1;
pt0 = m_arrPts[0];
pt1 = m_arrPts[1];
expt.x = pt1.x; expt.y = pt0.y; expt.z = pt0.z;
m_arrPts.InsertAt(1, expt);
expt.x = pt0.x; expt.y = pt1.y; expt.z = pt1.z;
m_arrPts.Add(expt);
m_arrPts.Add(m_arrPts.GetAt(0));
if(!m_pFtr->GetGeometry()->CreateShape(m_arrPts.GetData(),m_arrPts.GetSize())) return;
if( !AddObject(m_pFtr)/*m_pEditor->AddObject(m_pFtr)*/ )
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
undo.arrNewHandles.Add(FtrToHandle(m_pFtr));
undo.Commit();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pFtr = NULL;
Finish();
return;
}
}
else if( m_nMode==modeCustom )
{
if (m_arrPts.GetSize()==2)
{
GrBuffer buf;
buf.BeginLineString(0,0);
buf.MoveTo(&m_arrPts[0]);
buf.LineTo(&m_arrPts[1]);
buf.End();
buf.SetAllColor(m_pFtr->GetGeometry()->GetColor());
m_pEditor->UpdateDrag(ud_AddConstDrag,&buf);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
}
if( m_arrPts.GetSize()==3 )
{
PT_3DEX pt0,pt1,pt2,pt3;
pt0 = m_arrPts[0];
pt1 = m_arrPts[1];
pt2 = m_arrPts[2];
//根据垂直关系计算第三点和第四点
GraphAPI::GGetRightAnglePoint(pt0.x,pt0.y,pt1.x,pt1.y,pt2.x,pt2.y,&pt2.x,&pt2.y);
pt3.x = pt2.x-pt1.x+pt0.x; pt3.y = pt2.y-pt1.y+pt0.y; pt3.z = pt2.z;
pt3.pencode= pt2.pencode;
m_arrPts.SetAt(2, pt2);
m_arrPts.Add(pt3);
m_arrPts.Add(m_arrPts.GetAt(0));
if(!m_pFtr->GetGeometry()->CreateShape(m_arrPts.GetData(),m_arrPts.GetSize())) return;
if( !AddObject(m_pFtr)/*m_pEditor->AddObject(m_pFtr)*/ )
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
undo.arrNewHandles.Add(FtrToHandle(m_pFtr));
undo.Commit();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pFtr = NULL;
Finish();
return;
}
}
if (PDOC(m_pEditor)->IsAutoSetAnchor() && m_pFtr->GetGeometry()
&& (m_pFtr->GetGeometry()->GetDataPointSum() == 1))
{
PDOC(m_pEditor)->SetAnchorPoint(pt);
}
CDrawCommand::PtClick(pt,flag);
}
void CDrawRectCommand::PtMove(PT_3D &pt)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
PT_3DEX expt(pt,penLine);
m_arrPts.Add(expt);
if( m_nMode==modeHoriz )
{
GrBuffer buf;
if( m_arrPts.GetSize()==2 )
{
buf.BeginLineString(0,0);
PT_3DEX pt0,pt1;
pt0 = m_arrPts[0];
pt1 = m_arrPts[1];
PT_3D t;
COPY_3DPT(t,pt0);
buf.MoveTo(&t);
t.x = pt1.x; t.y = pt0.y; t.z = pt0.z;
buf.LineTo(&t);
COPY_3DPT(t,pt1);
buf.LineTo(&t);
t.x = pt0.x; t.y = pt1.y; t.z = pt0.z;
buf.LineTo(&t);
COPY_3DPT(t,pt0);
buf.LineTo(&t);
buf.End();
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
}
// else
// {
// buf.BeginLineString(0,0);
// buf.MoveTo()
// }
}
else if( m_nMode==modeCustom )
{
if (m_arrPts.GetSize()==2)
{
GrBuffer buf;
PT_3DEX pt0,pt1;
pt0 = m_arrPts[0];
pt1 = m_arrPts[1];
buf.BeginLineString(0,0);
buf.MoveTo(&pt0);
buf.LineTo(&pt1);
buf.End();
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
}
if( m_arrPts.GetSize()==3 )
{
GrBuffer buf;
PT_3DEX pt0,pt1,pt2,pt3;
pt0 = m_arrPts[0];
pt1 = m_arrPts[1];
pt2 = m_arrPts[2];
//根据垂直关系计算第三点和第四点
GraphAPI::GGetRightAnglePoint(pt0.x,pt0.y,pt1.x,pt1.y,pt2.x,pt2.y,&pt2.x,&pt2.y);
pt3.x = pt2.x-pt1.x+pt0.x; pt3.y = pt2.y-pt1.y+pt0.y; pt3.z = pt2.z;
buf.BeginLineString(0,0);
buf.MoveTo(&pt1);
buf.LineTo(&pt2);
buf.LineTo(&pt3);
buf.LineTo(&pt0);
buf.End();
// buf.RefreshEnvelope();
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
}
}
m_arrPts.RemoveAt(m_arrPts.GetSize()-1);
CDrawCommand::PtMove(pt);
}
void CDrawRectCommand::GetParams(CValueTable &tab)
{
CDrawCommand::GetParams(tab);
_variant_t var;
var = (_variant_t)(long)(m_nMode);
tab.AddValue(PF_DRAWRECTWAY,&CVariantEx(var));
}
void CDrawRectCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("DrawRectCommand",StrFromLocalResID(IDS_CMDNAME_DRAW));
param->BeginOptionParam(PF_DRAWRECTWAY,StrFromResID(IDS_CMDPLANE_WAY));
param->AddOption(StrFromResID(IDS_CMDPLANE_HRECT),modeHoriz,' ',m_nMode==modeHoriz);
param->AddOption(StrFromResID(IDS_CMDPLANE_ARECT),modeCustom,' ',m_nMode==modeCustom);
param->EndOptionParam();
}
void CDrawRectCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_DRAWRECTWAY,var) )
{
m_nMode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
CDrawCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CDrawRegularPolygonCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDrawRegularPolygonCommand,CDrawCommand)
CDrawRegularPolygonCommand::CDrawRegularPolygonCommand()
{
m_nSides = 3;
m_pFtr = NULL;
m_pSel = NULL;
strcat(m_strRegPath,"\\Polygon");
}
CDrawRegularPolygonCommand::~CDrawRegularPolygonCommand()
{
if (m_pFtr)
{
delete m_pFtr;
}
if(m_pSel) delete m_pSel;
}
CString CDrawRegularPolygonCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DRAWPOLYGON);
}
void CDrawRegularPolygonCommand::Start()
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
if(!pLayer) return;
m_pFtr = pLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOCURVE);
if(!m_pFtr) return;
m_nSides = 3;
CDrawCommand::Start();
m_pSel = new CPermanentExchanger(m_pFtr);
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
m_pEditor->CloseSelector();
}
void CDrawRegularPolygonCommand::RefreshPropertiesPanel()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
void CDrawRegularPolygonCommand::Finish()
{
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
if( m_pEditor )
{
if( m_pFtr )
{
BOOL bAnnotToText = AfxGetApp()->GetProfileInt(REGPATH_USER,REGITEM_ANNOTTOTEXT,FALSE);
if( bAnnotToText )
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
// CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayerByNameOrLayerIdx(StrFromResID(IDS_DEFLAYER_NAMET));
CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetLocalFtrLayer(StrFromResID(IDS_DEFLAYER_NAMET));
CFeature *pTempl = NULL;
if(pTextLayer)
pTempl = pTextLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOTEXT);
if( pLayer!=NULL && pTextLayer!=NULL && pTempl!=NULL )
{
CPtrArray arrAnnots;
CConfigLibManager *pCLM = gpCfgLibMan;
pCLM->GetSymbol(GETDS(m_pEditor),m_pFtr,arrAnnots);
CUndoFtrs undo(m_pEditor,Name());
for(int i=0; i<arrAnnots.GetSize(); i++)
{
CSymbol *pSymbol = (CSymbol*)arrAnnots.GetAt(i);
if (pSymbol && pSymbol->GetType()==SYMTYPE_ANNOTATION )
{
CAnnotation *pAnnot = (CAnnotation*)pSymbol;
CPtrArray parr;
CValueTable tab;
PDOC(m_pEditor)->GetDlgDataSource()->GetAllAttribute(m_pFtr,tab);
if( pAnnot->ExtractGeoText(m_pFtr,parr,tab,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale()) )
{
for (int j=0; j<parr.GetSize(); j++)
{
CGeoText *pText = (CGeoText*)parr[j];
pText->SetColor(m_pFtr->GetGeometry()->GetColor());
CFeature *pNewFtr = pTempl->Clone();
pNewFtr->SetGeometry(pText);
PDOC(m_pEditor)->AddObject(pNewFtr,pTextLayer->GetID());
undo.arrNewHandles.Add(FtrToHandle(pNewFtr));
}
}
}
}
undo.Commit();
}
if( pTempl!=NULL )delete pTempl;
}
}
m_pFtr = NULL;
m_pEditor->RefreshView();
}
CDrawCommand::Finish();
}
DrawingInfo CDrawRegularPolygonCommand::GetCurDrawingInfo()
{
return DrawingInfo(m_pFtr,m_arrPts);
}
int CDrawRegularPolygonCommand::GetCurPenCode()
{
return penLine;
}
void CDrawRegularPolygonCommand::Abort()
{
m_pEditor->UpdateDrag(ud_ClearDrag);
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
m_pEditor->RefreshView();
CDrawCommand::Abort();
}
template<class T>
static void polygon(const T &pt0, const T &pt1, const T &ptDir, int sides, CArray<T,T> &pts)
{
if( sides < 3 || fabs(pt0.x-pt1.x)+fabs(pt0.y-pt1.y)+fabs(pt0.z-pt1.z) < 1e-4)
return;
T arr[3];
arr[0] = pt0;
arr[1] = pt1;
arr[2] = ptDir;
bool dir = (GraphAPI::GIsClockwise(arr,3)==1);
double ang = 2*PI/sides;
// 中点
T cpt;
cpt.x = (pt0.x+pt1.x)/2;
cpt.y = (pt0.y+pt1.y)/2;
// cpt.z = (pt0.z+pt1.z)/2;
double dx, dy, len;
dx = pt1.x - pt0.x;
dy = pt1.y - pt0.y;
// dz = pt1.z - pt0.z;
len = sqrt(dx*dx+dy*dy/*+dz*dz*/);
// 半径
double r = (len/2)/sin(ang/2);
// 圆心
T point;
double h = sqrt( r*r-(len/2)*(len/2) );
double tdx, tdy;
tdx = -h*dy/len;
tdy = h*dx/len;
if (dir)
{
point.x = cpt.x-tdx;
point.y = cpt.y-tdy;
// point.z = cpt.z;
}
else
{
point.x = cpt.x+tdx;
point.y = cpt.y+tdy;
// point.z = cpt.z;
}
// 沿圆心旋转sides-1次
T retpt;
double dx1,dy1,sina,cosa,lfAngle;
pts.Add(pt0);
lfAngle = ang;
dx1 = pt0.x - point.x;
dy1 = pt0.y - point.y;
for (int i=1; i<sides; i++)
{
sina = sin(lfAngle*i);
cosa = cos(lfAngle*i);
retpt.x = dx1 * cosa - dy1 * sina + point.x;
retpt.y = dy1 * cosa + dx1 * sina + point.y;
// retpt.z = point.z;
GraphAPI::GetHeightFromSurface(pt0,pt1,ptDir,&retpt,1);
pts.Add(retpt);
}
}
void CDrawRegularPolygonCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
if (m_nSides < 3)
{
AfxMessageBox(IDS_PARAM_ERROR);
return;
}
GotoState(PROCSTATE_PROCESSING);
PT_3DEX expt(pt,penLine);
m_arrPts.Add(expt);
int size = m_arrPts.GetSize();
if (size == 2)
{
GrBuffer buf;
buf.BeginLineString(0,0);
buf.MoveTo(&m_arrPts[0]);
buf.LineTo(&m_arrPts[1]);
buf.End();
buf.SetAllColor(m_pFtr->GetGeometry()->GetColor());
m_pEditor->UpdateDrag(ud_AddConstDrag,&buf);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
}
else if (size == 3)
{
CArray<PT_3DEX,PT_3DEX> pts;
polygon(m_arrPts[0],m_arrPts[1],m_arrPts[2],m_nSides,pts);
int size = pts.GetSize();
if (size > 1)
{
pts.Add(pts[0]);
}
else
{
Abort();
return;
}
for (int i=0; i<pts.GetSize(); i++)
{
pts[i].pencode = penLine;
}
if(!m_pFtr->GetGeometry()->CreateShape(pts.GetData(),pts.GetSize())) return;
if( !AddObject(m_pFtr) )
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
undo.arrNewHandles.Add(FtrToHandle(m_pFtr));
undo.Commit();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pFtr = NULL;
Finish();
return;
}
if (PDOC(m_pEditor)->IsAutoSetAnchor() && m_pFtr && m_pFtr->GetGeometry()
&& size == 1)
{
PDOC(m_pEditor)->SetAnchorPoint(pt);
}
CDrawCommand::PtClick(pt,flag);
}
void CDrawRegularPolygonCommand::PtMove(PT_3D &pt)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
if( m_arrPts.GetSize()==1 )
{
GrBuffer buf;
buf.BeginLineString(0,0);
buf.MoveTo(&m_arrPts[0]);
buf.LineTo(&pt);
buf.End();
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
}
CDrawCommand::PtMove(pt);
}
void CDrawRegularPolygonCommand::GetParams(CValueTable &tab)
{
CDrawCommand::GetParams(tab);
_variant_t var;
var = (_variant_t)(long)(m_nSides);
tab.AddValue(PF_POLYGONSIDESNUM,&CVariantEx(var));
}
void CDrawRegularPolygonCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("DrawPolygonCommand",StrFromLocalResID(IDS_CMDNAME_DRAWPOLYGON));
param->AddParam(PF_POLYGONSIDESNUM,int(m_nSides),StrFromResID(IDS_CMDPLANE_SIDES));
}
void CDrawRegularPolygonCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_POLYGONSIDESNUM,var) )
{
m_nSides = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
CDrawCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CDrawCircleCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDrawCircleCommand,CDrawCommand)
CDrawCircleCommand::CDrawCircleCommand()
{
m_nMode = -1;
m_pFtr = NULL;
m_pSel = NULL;
m_bMouseDefineRadius = TRUE;
m_fRadius = 10;
}
CDrawCircleCommand::~CDrawCircleCommand()
{
m_nMode = -1;
if (m_pFtr)
{
delete m_pFtr;
}
if (m_pSel)
{
delete m_pSel;
}
}
CString CDrawCircleCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DRAWCIRCLE);
}
void CDrawCircleCommand::Start()
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
if(!pLayer) return;
m_pFtr = pLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOCURVE);
if(!m_pFtr) return;
/*
CDlgDataSource *pDS = GETDS(m_pEditor);
CScheme *pScheme = gpCfgLibMan->GetScheme(pDS->GetScale());
if (pScheme && pLayer)
{
float wid = pScheme->GetLayerDefineLineWidth(pLayer->GetName());
((CGeoCurve*)m_pFtr->GetGeometry())->m_fLineWidth = wid;
}
*/
//((CGeoCurve*)m_pFtr->GetGeometry())->EnableClose(TRUE);
CDrawCommand::Start();
m_pSel = new CPermanentExchanger(m_pFtr);
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
m_pEditor->CloseSelector();
// CDrawCommand::Start();
}
void CDrawCircleCommand::RefreshPropertiesPanel()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
DrawingInfo CDrawCircleCommand::GetCurDrawingInfo()
{
return DrawingInfo(m_pFtr,m_arrPts);
}
int CDrawCircleCommand::GetCurPenCode()
{
return penArc;
}
void CDrawCircleCommand::Abort()
{
if(m_pFtr)
{
delete m_pFtr;
m_pFtr = NULL;
}
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CDrawCommand::Abort();
}
void CDrawCircleCommand::Finish()
{
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
if( m_pEditor )
{
if( m_pFtr )
{
BOOL bAnnotToText = AfxGetApp()->GetProfileInt(REGPATH_USER,REGITEM_ANNOTTOTEXT,FALSE);
if( bAnnotToText )
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
// CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayerByNameOrLayerIdx(StrFromResID(IDS_DEFLAYER_NAMET));
CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetLocalFtrLayer(StrFromResID(IDS_DEFLAYER_NAMET));
CFeature *pTempl = NULL;
if(pTextLayer)
pTempl = pTextLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOTEXT);
if( pLayer!=NULL && pTextLayer!=NULL && pTempl!=NULL )
{
CPtrArray arrAnnots;
CConfigLibManager *pCLM = gpCfgLibMan;
pCLM->GetSymbol(GETDS(m_pEditor),m_pFtr,arrAnnots);
CUndoFtrs undo(m_pEditor,Name());
for(int i=0; i<arrAnnots.GetSize(); i++)
{
CSymbol *pSymbol = (CSymbol*)arrAnnots.GetAt(i);
if (pSymbol && pSymbol->GetType()==SYMTYPE_ANNOTATION )
{
CAnnotation *pAnnot = (CAnnotation*)pSymbol;
CPtrArray parr;
CValueTable tab;
PDOC(m_pEditor)->GetDlgDataSource()->GetAllAttribute(m_pFtr,tab);
if( pAnnot->ExtractGeoText(m_pFtr,parr,tab,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale()) )
{
for (int j=0; j<parr.GetSize(); j++)
{
CGeoText *pText = (CGeoText*)parr[j];
pText->SetColor(m_pFtr->GetGeometry()->GetColor());
CFeature *pNewFtr = pTempl->Clone();
pNewFtr->SetGeometry(pText);
PDOC(m_pEditor)->AddObject(pNewFtr,pTextLayer->GetID());
undo.arrNewHandles.Add(FtrToHandle(pNewFtr));
}
}
}
}
undo.Commit();
}
if( pTempl!=NULL )delete pTempl;
}
}
m_pFtr = NULL;
m_pEditor->RefreshView();
}
CDrawCommand::Finish();
}
void CDrawCircleCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
GotoState(PROCSTATE_PROCESSING);
// 二点圆
if (m_nMode == 0)
{
PT_3DEX expt(pt,penArc);
m_arrPts.Add(expt);
if (m_arrPts.GetSize() == 2)
{
PT_3DEX cen;
cen.x = (m_arrPts[0].x + m_arrPts[1].x)/2;
cen.y = (m_arrPts[0].y + m_arrPts[1].y)/2;
cen.z = (m_arrPts[0].z + m_arrPts[1].z)/2;
cen.pencode = penArc;
CArray<PT_3DEX,PT_3DEX> arrRotate;
arrRotate.Copy(m_arrPts);
GraphAPI::GRotate2DPT(cen,PI/2,arrRotate.GetData(),arrRotate.GetSize());
arrRotate[0].z = arrRotate[1].z = cen.z;
m_arrPts.InsertAt(1,arrRotate[0]);
m_arrPts.Add(arrRotate[1]);
m_arrPts.Add(m_arrPts[0]);
if(!m_pFtr->GetGeometry()->CreateShape(m_arrPts.GetData(),m_arrPts.GetSize())) return;
CUndoFtrs undo(m_pEditor,Name());
undo.arrNewHandles.Add(FtrToHandle(m_pFtr));
if( !AddObject(m_pFtr) )
m_pEditor->UpdateDrag(ud_ClearDrag);
undo.Commit();
Finish();
}
}
// 三点圆
else if (m_nMode == 1)
{
PT_3DEX expt(pt,penArc);
m_arrPts.Add(expt);
if(!m_pFtr->GetGeometry()->CreateShape(m_arrPts.GetData(),m_arrPts.GetSize())) return;
if (m_arrPts.GetSize()>=3)
{
m_arrPts.Add(m_arrPts.GetAt(0));
if(!m_pFtr->GetGeometry()->CreateShape(m_arrPts.GetData(),m_arrPts.GetSize())) return;
CUndoFtrs undo(m_pEditor,Name());
undo.arrNewHandles.Add(FtrToHandle(m_pFtr));
if( !AddObject(m_pFtr)/*m_pEditor->AddObject(m_pFtr)*/ )
m_pEditor->UpdateDrag(ud_ClearDrag);
undo.Commit();
Finish();
return;
}
GrBuffer buf;
m_pFtr->GetGeometry()->GetShape()->GetAddConstGrBuffer(&buf);
m_pEditor->UpdateDrag(ud_AddConstDrag,&buf);
m_pEditor->UpdateDrag(ud_ClearDrag);
}
// 圆心,半径
else if (m_nMode == 2)
{
PT_3DEX expt(pt,penArc);
m_arrPts.Add(expt);
int num = m_arrPts.GetSize();
if (num >= 1)
{
if (num == 2 && m_bMouseDefineRadius)
{
PT_3DEX pt1, cenPt = m_arrPts[0];
pt1.x = 2*m_arrPts[0].x - m_arrPts[1].x;
pt1.y = 2*m_arrPts[0].y - m_arrPts[1].y;
pt1.z = 2*m_arrPts[0].z - m_arrPts[1].z;
pt1.pencode = penArc;
m_arrPts.RemoveAt(0);
m_arrPts.InsertAt(0,pt1);
CArray<PT_3DEX,PT_3DEX> arrRotate;
arrRotate.Copy(m_arrPts);
GraphAPI::GRotate2DPT(cenPt,PI/2,arrRotate.GetData(),arrRotate.GetSize());
arrRotate[0].z = arrRotate[1].z = m_arrPts[0].z;
m_arrPts.InsertAt(1,arrRotate[0]);
m_arrPts.Add(arrRotate[1]);
m_arrPts.Add(m_arrPts[0]);
}
else if (num == 1 && !m_bMouseDefineRadius)
{
PT_3DEX cen = m_arrPts[0];
m_arrPts.RemoveAll();
double off = m_fRadius/sqrt(2);
m_arrPts.Add(PT_3DEX(cen.x-off,cen.y-off,cen.z,penArc));
m_arrPts.Add(PT_3DEX(cen.x+off,cen.y-off,cen.z,penArc));
m_arrPts.Add(PT_3DEX(cen.x+off,cen.y+off,cen.z,penArc));
m_arrPts.Add(PT_3DEX(cen.x-off,cen.y+off,cen.z,penArc));
m_arrPts.Add(m_arrPts[0]);
}
if(!m_pFtr->GetGeometry()->CreateShape(m_arrPts.GetData(),m_arrPts.GetSize())) return;
CUndoFtrs undo(m_pEditor,Name());
undo.arrNewHandles.Add(FtrToHandle(m_pFtr));
if( !AddObject(m_pFtr) )
m_pEditor->UpdateDrag(ud_ClearDrag);
undo.Commit();
Finish();
}
}
CDrawCommand::PtClick(pt,flag);
}
void CDrawCircleCommand::PtMove(PT_3D &pt)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
int size = m_arrPts.GetSize();
if (size<=0)
{
return;
}
CArray<PT_3DEX,PT_3DEX> arrMovePts;
arrMovePts.Copy(m_arrPts);
if (m_nMode == 0 && size == 1)
{
PT_3DEX expt(pt,penArc);
arrMovePts.Add(expt);
PT_3DEX cen;
cen.x = (arrMovePts[0].x + arrMovePts[1].x)/2;
cen.y = (arrMovePts[0].y + arrMovePts[1].y)/2;
cen.z = (arrMovePts[0].z + arrMovePts[1].z)/2;
cen.pencode = penArc;
CArray<PT_3DEX,PT_3DEX> arrRotate;
arrRotate.Copy(arrMovePts);
GraphAPI::GRotate2DPT(cen,PI/2,arrRotate.GetData(),arrRotate.GetSize());
arrRotate[0].z = arrRotate[1].z = cen.z;
arrMovePts.InsertAt(1,arrRotate[0]);
arrMovePts.Add(arrRotate[1]);
arrMovePts.Add(m_arrPts[0]);
if( m_pFtr->GetGeometry()->CreateShape(arrMovePts.GetData(),arrMovePts.GetSize()) )
{
GrBuffer vbuf;
m_pFtr->Draw(&vbuf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
vbuf.SetAllColor(m_pFtr->GetGeometry()->GetColor());
m_pEditor->UpdateDrag(ud_SetVariantDrag,&vbuf);
}
}
else if (m_nMode == 1 && size == 2)
{
PT_3DEX expt(pt,penArc);
arrMovePts.Add(expt);
arrMovePts.Add(arrMovePts.GetAt(0));
if( m_pFtr->GetGeometry()->CreateShape(arrMovePts.GetData(),arrMovePts.GetSize()) )
{
GrBuffer vbuf;
const CShapeLine *pSL = m_pFtr->GetGeometry()->GetShape();
pSL->GetVariantGrBuffer(&vbuf,true,arrMovePts.GetSize()-2);
vbuf.SetAllColor(m_pFtr->GetGeometry()->GetColor());
m_pEditor->UpdateDrag(ud_SetVariantDrag,&vbuf);
}
}
else if (m_nMode == 2 && size == 1)
{
PT_3DEX expt(pt,penArc);
arrMovePts.Add(expt);
if (m_bMouseDefineRadius)
{
PT_3DEX pt1, cenPt = m_arrPts[0];
pt1.x = 2*arrMovePts[0].x - arrMovePts[1].x;
pt1.y = 2*arrMovePts[0].y - arrMovePts[1].y;
pt1.z = 2*arrMovePts[0].z - arrMovePts[1].z;
pt1.pencode = penArc;
arrMovePts.RemoveAt(0);
arrMovePts.InsertAt(0,pt1);
CArray<PT_3DEX,PT_3DEX> arrRotate;
arrRotate.Copy(arrMovePts);
GraphAPI::GRotate2DPT(cenPt,PI/2,arrRotate.GetData(),arrRotate.GetSize());
arrRotate[0].z = arrRotate[1].z = cenPt.z;
arrMovePts.InsertAt(1,arrRotate[0]);
arrMovePts.Add(arrRotate[1]);
arrMovePts.Add(arrMovePts[0]);
}
if( m_pFtr->GetGeometry()->CreateShape(arrMovePts.GetData(),arrMovePts.GetSize()) )
{
GrBuffer vbuf;
m_pFtr->Draw(&vbuf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
vbuf.SetAllColor(m_pFtr->GetGeometry()->GetColor());
m_pEditor->UpdateDrag(ud_SetVariantDrag,&vbuf);
}
}
CDrawCommand::PtMove(pt);
}
void CDrawCircleCommand::GetParams(CValueTable &tab)
{
CDrawCommand::GetParams(tab);
_variant_t var;
var = (bool)(m_bMouseDefineRadius);
tab.AddValue(PF_MOUSEDEFINE,&CVariantEx(var));
var = (float)m_fRadius;
tab.AddValue(PF_RADIUS,&CVariantEx(var));
}
void CDrawCircleCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("DrawCircle",StrFromLocalResID(IDS_CMDNAME_CICLECENTERRADIUS));
if (m_nMode == 2 || bForLoad)
{
param->BeginOptionParam(PF_MOUSEDEFINE,StrFromResID(IDS_CMDTIP_MOUSEDEF_RADIUS));
param->AddOption(StrFromResID(IDS_YES),1,' ',m_bMouseDefineRadius);
param->AddOption(StrFromResID(IDS_NO),0,' ',!m_bMouseDefineRadius);
param->EndOptionParam();
if (!m_bMouseDefineRadius || bForLoad)
{
param->AddParam(PF_RADIUS,m_fRadius,StrFromResID(IDS_RADIUS));
}
}
}
void CDrawCircleCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_MOUSEDEFINE,var) )
{
m_bMouseDefineRadius = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
if ( tab.GetValue(0,PF_RADIUS,var))
{
m_fRadius = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
CDrawCommand::SetParams(tab,bInit);
}
IMPLEMENT_DYNCREATE(CDrawCircleTwoPtCommand,CDrawCircleCommand)
CDrawCircleTwoPtCommand::CDrawCircleTwoPtCommand()
{
m_nMode = 0;
}
CDrawCircleTwoPtCommand::~CDrawCircleTwoPtCommand()
{
}
CString CDrawCircleTwoPtCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CICLETW0PT);
}
IMPLEMENT_DYNCREATE(CDrawCircleThreePtCommand,CDrawCircleCommand)
CDrawCircleThreePtCommand::CDrawCircleThreePtCommand()
{
m_nMode = 1;
}
CDrawCircleThreePtCommand::~CDrawCircleThreePtCommand()
{
}
CString CDrawCircleThreePtCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CICLETHREEPT);
}
IMPLEMENT_DYNCREATE(CDrawCircleCenterRadiusCommand,CDrawCircleCommand)
CDrawCircleCenterRadiusCommand::CDrawCircleCenterRadiusCommand()
{
m_nMode = 2;
}
CDrawCircleCenterRadiusCommand::~CDrawCircleCenterRadiusCommand()
{
}
CString CDrawCircleCenterRadiusCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CICLECENTERRADIUS);
}
//////////////////////////////////////////////////////////////////////
// CDrawLinesBySide Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDrawLinesBySide,CDrawCommand)
CDrawLinesBySide::CDrawLinesBySide()
{
m_pFtr = NULL;
m_pSel = NULL;
m_bOpenIfSnapped = TRUE;
}
CDrawLinesBySide::~CDrawLinesBySide()
{
if (m_pFtr)
{
delete m_pFtr;
}
if (m_pSel)
{
delete m_pSel;
}
}
CString CDrawLinesBySide::Name()
{
return StrFromResID(IDS_CMDNAME_DRAWLINESBYSIDE);
}
void CDrawLinesBySide::Start()
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
if(!pLayer) return;
m_pFtr = pLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOCURVE);
if(!m_pFtr) return;
CDlgDataSource *pDS = GETDS(m_pEditor);
CDrawCommand::Start();
((CGeoCurve*)m_pFtr->GetGeometry())->EnableClose(TRUE);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_arrPts.RemoveAll();
m_pEditor->CloseSelector();
m_pSel = new CPermanentExchanger(m_pFtr);
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
void CDrawLinesBySide::RefreshPropertiesPanel()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
DrawingInfo CDrawLinesBySide::GetCurDrawingInfo()
{
return DrawingInfo(m_pFtr,m_arrPts);
}
void CDrawLinesBySide::Back()
{
if (!m_pFtr)
{
return;
}
int num = m_arrPts.GetSize();
if( num>=1 )
{
PT_3D pt;
pt = m_arrPts.GetAt(num-1);
PDOC(m_pEditor)->UpdateAllViews(NULL,hc_SetCrossPos,(CObject*)&pt);
m_arrPts.RemoveAt(num-1);
CArray<PT_3DEX,PT_3DEX> arrPts;
arrPts.Copy(m_arrPts);
arrPts.Add(PT_3DEX(pt,penLine));
BOOL finished = FALSE;
CFeature *pObj = CreateObjBySide(arrPts,finished);
if( !pObj )
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
else
{
GrBuffer vbuf;
pObj->Draw(&vbuf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
m_pEditor->UpdateDrag(ud_SetVariantDrag,&vbuf);
delete pObj;
}
m_pEditor->RefreshView();
}
else
{
m_arrPts.RemoveAll();
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
}
CDrawCommand::Back();
}
void CDrawLinesBySide::Abort()
{
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
if(m_pFtr)
{
delete m_pFtr;
m_pFtr = NULL;
}
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CDrawCommand::Abort();
}
BOOL CDrawLinesBySide::IsEndSnapped()
{
if (!m_pEditor)
return FALSE;
if (!PDOC(m_pEditor)->m_snap.bOpen())
return FALSE;
SNAPITEM item = PDOC(m_pEditor)->m_snap.GetFirstSnapResult();
if (!item.IsValid())
return FALSE;
if (item.nSnapMode == CSnap::modeNearPoint ||
item.nSnapMode == CSnap::modeKeyPoint ||
item.nSnapMode == CSnap::modeMidPoint ||
item.nSnapMode == CSnap::modeIntersect ||
item.nSnapMode == CSnap::modePerpPoint ||
item.nSnapMode == CSnap::modeTangPoint ||
item.nSnapMode == CSnap::modeEndPoint)
return TRUE;
return FALSE;
}
CFeature *CDrawLinesBySide::CreateObjBySide(CArray<PT_3DEX,PT_3DEX>& pts, BOOL& finished)
{
// CFtrLayer* pLayer = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetFtrLayer();
CFtrLayer* pLayer = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetCurFtrLayer();
//待改
// CFeature *pFtr = pLayer->CreateDefaultFeature(((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetScale());
CFeature *pFtr = m_pFtr->Clone();//new CFeature;
if (!pFtr)
{
return NULL;
}
CGeometry *pObj = pFtr->GetGeometry();
if( !pObj )return NULL;
int num = pts.GetSize();
BOOL bClosed = TRUE;
if (finished)//结束生成时
{
if (m_bOpenIfSnapped && IsEndSnapped())
{
if (num < 3)
{
finished = FALSE;
return NULL;
}
bClosed = FALSE;
}
else//非端点捕捉，点数至少5且是奇数才能生成地物
{
if (num<5 || num%2==0)
{
finished = FALSE;
return NULL;
}
bClosed = TRUE;
}
}
CArray<PT_3DEX,PT_3DEX> arr;
if( finished )
{
PT_3DEX expt;
expt.pencode = penLine;
const PT_3DEX *buf = pts.GetData();
PT_3DEX lastpt = buf[0];
//加中间的边相交点
for( int i=2; i<num; i++)
{
GraphAPI::GGetPerpendicular3D(lastpt.x,lastpt.y,lastpt.z,
buf[i-1].x,buf[i-1].y,buf[i-1].z,
buf[i].x,buf[i].y,buf[i].z,
&expt.x,&expt.y,&expt.z);
arr.Add(expt);
lastpt = expt;
}
if (bClosed)
{
//加首点
GraphAPI::GGetPerpendicular3D(buf[0].x, buf[0].y, buf[0].z,
buf[1].x, buf[1].y, buf[1].z,
buf[num - 1].x, buf[num - 1].y, buf[num - 1].z,
&expt.x, &expt.y, &expt.z);
arr.Add(expt);
//闭合
arr.Add(arr[0]);
}
else
{
//加首点
arr.InsertAt(0, m_arrPts[0]);
//加尾点
arr.Add(m_arrPts[m_arrPts.GetSize() - 1]);
}
}
else if( num>=2 )
{
PT_3DEX expt;
expt.pencode = penLine;
const PT_3DEX *buf = pts.GetData();
PT_3DEX lastpt = buf[0];
//加首点
COPY_3DPT(expt,buf[0]);
arr.Add(expt);
//加中间的边相交点
for( int i=2; i<num; i++)
{
GraphAPI::GGetPerpendicular3D(lastpt.x,lastpt.y,lastpt.z,
buf[i-1].x,buf[i-1].y,buf[i-1].z,
buf[i].x,buf[i].y,buf[i].z,
&expt.x,&expt.y,&expt.z);
arr.Add(expt);
lastpt = expt;
}
//加尾点
COPY_3DPT(expt,buf[num-1]);
arr.Add(expt);
// 延长距离
double len;
PT_4D pt4d(arr[0].x,arr[0].y,arr[0].z);
m_pEditor->GetCoordWnd().m_pViewCS->GroundToClient(&pt4d,1);
pt4d.x += 400;
m_pEditor->GetCoordWnd().m_pViewCS->ClientToGround(&pt4d,1);
len = GraphAPI::GGet3DDisOf2P(PT_3D(arr[0].x,arr[0].y,arr[0].z),PT_3D(pt4d.x,pt4d.y,pt4d.z));
//将首点和尾点都延长400像素，模拟射线
PT_3DEX expt1, expt2;
expt1 = arr.GetAt(0);
expt2 = arr.GetAt(1);
double len1 = GraphAPI::GGet3DDisOf2P(expt1,expt2);
if (len1 <= GraphAPI::GetDisTolerance())
{
len1 = 1;
}
expt.x = expt1.x + (expt1.x-expt2.x)/len1*len;
expt.y = expt1.y + (expt1.y-expt2.y)/len1*len;
expt.z = expt1.z + (expt1.z-expt2.z)/len1*len;
arr.SetAt(0,expt);
if( num>2 )
{
expt1 = arr.GetAt(num-2);
expt2 = arr.GetAt(num-1);
len1 = GraphAPI::GGet3DDisOf2P(expt1,expt2);
if (len1 <= GraphAPI::GetDisTolerance())
{
len1 = 1;
}
}
expt.x = expt2.x + (expt2.x-expt1.x)/len1*len;
expt.y = expt2.y + (expt2.y-expt1.y)/len1*len;
expt.z = expt2.z + (expt2.z-expt1.z)/len1*len;
arr.SetAt(num-1,expt);
}
pObj->CreateShape(arr.GetData(),arr.GetSize());
return pFtr;
}
void CDrawLinesBySide::PtClick(PT_3D &pt, int flag)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
GotoState(PROCSTATE_PROCESSING);
int ntmppt = m_arrPts.GetSize();
if( ntmppt>0 )GotoState(PROCSTATE_PROCESSING);
if( ntmppt==1 && ((CDlgDoc*)m_pEditor)->IsAutoSetAnchor() )
{
((CDlgDoc*)m_pEditor)->SetAnchorPoint(pt);
}
m_arrPts.Add(PT_3DEX(pt,penLine));
CDrawCommand::PtClick(pt,flag);
}
void CDrawLinesBySide::PtReset(PT_3D &pt)
{
BOOL finished = TRUE;
CFeature *pFtr = CreateObjBySide(m_arrPts,finished);
if( finished && pFtr )
{
if( !AddObject(pFtr) )
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
undo.arrNewHandles.Add(FtrToHandle(pFtr));
undo.Commit();
}
else if( pFtr )delete pFtr;
// m_pEditor->SetCurDrawingObj(DrawingInfo());
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
//m_pDoc->UpdateAllViews(NULL,hc_Detach_Accubox);
m_pEditor->RefreshView();
m_arrPts.RemoveAll();
if( !finished )
Abort();
else
{
if( m_pFtr!=NULL )
delete m_pFtr;
m_pFtr = NULL;
Finish();
}
}
void CDrawLinesBySide::PtMove(PT_3D &pt)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
if( m_arrPts.GetSize()<=0 )return;
CArray<PT_3DEX,PT_3DEX> arrPts;
arrPts.Copy(m_arrPts);
arrPts.Add(PT_3DEX(pt,penLine));
BOOL finished = FALSE;
CFeature *pFtr = CreateObjBySide(arrPts,finished);
if( !pFtr )
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
else
{
GrBuffer vbuf;
pFtr->GetGeometry()->Draw(&vbuf,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale());
m_pEditor->UpdateDrag(ud_SetVariantDrag,&vbuf);
delete pFtr;
}
CDrawCommand::PtMove(pt);
}
void CDrawLinesBySide::GetParams(CValueTable &tab)
{
CDrawCommand::GetParams(tab);
_variant_t var;
var = (bool)(m_bOpenIfSnapped);
tab.AddValue(PF_OPENIFSNAP, &CVariantEx(var));
}
void CDrawLinesBySide::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("DrawLinesBySide", Name());
if (m_pFtr)
{
param->BeginOptionParam(PF_OPENIFSNAP, StrFromResID(IDS_CMDPLANE_OPENIFSNAP));
param->AddOption(StrFromResID(IDS_YES), 1, ' ', m_bOpenIfSnapped);
param->AddOption(StrFromResID(IDS_NO), 0, ' ', !m_bOpenIfSnapped);
param->EndOptionParam();
}
}
void CDrawLinesBySide::Finish()
{
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
if( m_pEditor )
{
if( m_pFtr )
{
BOOL bAnnotToText = AfxGetApp()->GetProfileInt(REGPATH_USER,REGITEM_ANNOTTOTEXT,FALSE);
if( bAnnotToText )
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
// CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayerByNameOrLayerIdx(StrFromResID(IDS_DEFLAYER_NAMET));
CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetLocalFtrLayer(StrFromResID(IDS_DEFLAYER_NAMET));
CFeature *pTempl = NULL;
if(pTextLayer)
pTempl = pTextLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOTEXT);
if( pLayer!=NULL && pTextLayer!=NULL && pTempl!=NULL )
{
CPtrArray arrAnnots;
CConfigLibManager *pCLM = gpCfgLibMan;
pCLM->GetSymbol(GETDS(m_pEditor),m_pFtr,arrAnnots);
CUndoFtrs undo(m_pEditor,Name());
for(int i=0; i<arrAnnots.GetSize(); i++)
{
CSymbol *pSymbol = (CSymbol*)arrAnnots.GetAt(i);
if (pSymbol && pSymbol->GetType()==SYMTYPE_ANNOTATION )
{
CAnnotation *pAnnot = (CAnnotation*)pSymbol;
CPtrArray parr;
CValueTable tab;
PDOC(m_pEditor)->GetDlgDataSource()->GetAllAttribute(m_pFtr,tab);
if( pAnnot->ExtractGeoText(m_pFtr,parr,tab,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale()) )
{
for (int j=0; j<parr.GetSize(); j++)
{
CGeoText *pText = (CGeoText*)parr[j];
pText->SetColor(m_pFtr->GetGeometry()->GetColor());
CFeature *pNewFtr = pTempl->Clone();
pNewFtr->SetGeometry(pText);
PDOC(m_pEditor)->AddObject(pNewFtr,pTextLayer->GetID());
undo.arrNewHandles.Add(FtrToHandle(pNewFtr));
}
}
}
}
undo.Commit();
}
if( pTempl!=NULL )delete pTempl;
}
}
m_pFtr = NULL;
m_pEditor->RefreshView();
}
CDrawCommand::Finish();
}
void CDrawLinesBySide::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if (tab.GetValue(0, PF_OPENIFSNAP, var))
{
m_bOpenIfSnapped = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
CDrawCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CDrawLinesByMultiPt Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDrawLinesByMultiPt,CDrawCommand)
CDrawLinesByMultiPt::CDrawLinesByMultiPt()
{
m_pFtr = NULL;
m_pSel = NULL;
m_bLastRClick = FALSE;
}
CDrawLinesByMultiPt::~CDrawLinesByMultiPt()
{
if (m_pFtr)
{
delete m_pFtr;
}
if (m_pSel)
{
delete m_pSel;
}
}
CString CDrawLinesByMultiPt::Name()
{
return StrFromResID(IDS_CMDNAME_DRAWLINESBYMULTIPT);
}
void CDrawLinesByMultiPt::Start()
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
if(!pLayer) return;
m_pFtr = pLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOCURVE);
if(!m_pFtr) return;
m_bLastRClick = FALSE;
m_arrBuildLine.RemoveAll();
CDrawCommand::Start();
((CGeoCurve*)m_pFtr->GetGeometry())->EnableClose(TRUE);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_arrPts.RemoveAll();
m_pEditor->CloseSelector();
m_pSel = new CPermanentExchanger(m_pFtr);
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
void CDrawLinesByMultiPt::RefreshPropertiesPanel()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
DrawingInfo CDrawLinesByMultiPt::GetCurDrawingInfo()
{
return DrawingInfo(m_pFtr,m_arrPts);
}
void CDrawLinesByMultiPt::Back()
{
if (!m_pFtr)
{
return;
}
int num = m_arrPts.GetSize();
if( num>=1 )
{
PT_3D pt;
pt = m_arrPts.GetAt(num-1);
PDOC(m_pEditor)->UpdateAllViews(NULL,hc_SetCrossPos,(CObject*)&pt);
m_arrPts.RemoveAt(num-1);
CArray<PT_3DEX,PT_3DEX> arrPts;
arrPts.Copy(m_arrPts);
arrPts.Add(PT_3DEX(pt,penLine));
BOOL finished = FALSE;
CFeature *pObj = CreateObjBySide(finished);
if( !pObj )
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
else
{
GrBuffer vbuf;
pObj->Draw(&vbuf);
m_pEditor->UpdateDrag(ud_SetVariantDrag,&vbuf);
delete pObj;
}
m_pEditor->RefreshView();
}
else
{
m_arrPts.RemoveAll();
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
}
CDrawCommand::Back();
}
void CDrawLinesByMultiPt::Abort()
{
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
if(m_pFtr)
{
delete m_pFtr;
m_pFtr = NULL;
}
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CDrawCommand::Abort();
}
CFeature *CDrawLinesByMultiPt::CreateObjBySide(BOOL& finished)
{
CArray<PT_3DEX,PT_3DEX> pts;
pts.Copy(m_arrPts);
int num = pts.GetSize();
if (num < 2) return NULL;
CFtrLayer* pLayer = ((CDlgDoc*)m_pEditor)->GetDlgDataSource()->GetCurFtrLayer();
CFeature *pFtr = m_pFtr->Clone();
if (!pFtr) return NULL;
CGeometry *pObj = pFtr->GetGeometry();
if( !pObj )return NULL;
CArray<PT_3DEX,PT_3DEX> arr;
if( finished )
{
PT_3DEX expt;
expt.pencode = penLine;
//加中间的边相交点
for( int i=2; i<num; i+=2)
{
double vx0 = pts[i-1].x - pts[i-2].x, vx1 = pts[i+1].x - pts[i].x;
double vy0 = pts[i-1].y - pts[i-2].y, vy1 = pts[i+1].y - pts[i].y;
double t;
GraphAPI::GGetLineIntersectLine(pts[i-2].x,pts[i-2].y,vx0,vy0,pts[i].x,pts[i].y,vx1,vy1,&expt.x,&expt.y,&t);
expt.z = pts[i-2].z + t * (pts[i-1].z - pts[i-2].z);
arr.Add(expt);
}
//加首点
double vx0 = pts[1].x - pts[0].x, vx1 = pts[num-1].x - pts[num-2].x;
double vy0 = pts[1].y - pts[0].y, vy1 = pts[num-1].y - pts[num-2].y;
double t;
GraphAPI::GGetLineIntersectLine(pts[0].x,pts[0].y,vx0,vy0,pts[num-2].x,pts[num-2].y,vx1,vy1,&expt.x,&expt.y,&t);
expt.z = pts[0].z + t * (pts[1].z - pts[0].z);
arr.Add(expt);
}
else
{
PT_3DEX expt;
expt.pencode = penLine;
//加首点
arr.Add(pts[0]);
//加中间的边相交点
for( int i=2; i<num; i+=2)
{
double vx0 = pts[i-1].x - pts[i-2].x, vx1 = pts[i+1].x - pts[i].x;
double vy0 = pts[i-1].y - pts[i-2].y, vy1 = pts[i+1].y - pts[i].y;
double t;
GraphAPI::GGetLineIntersectLine(pts[i-2].x,pts[i-2].y,vx0,vy0,pts[i].x,pts[i].y,vx1,vy1,&expt.x,&expt.y,&t);
expt.z = pts[i-2].z + t * (pts[i-1].z - pts[i-2].z);
arr.Add(expt);
}
//加尾点
arr.Add(pts[num-1]);
int num0 = arr.GetSize();
// 延长距离
double len;
PT_4D pt4d(arr[0].x,arr[0].y,arr[0].z);
m_pEditor->GetCoordWnd().m_pViewCS->GroundToClient(&pt4d,1);
pt4d.x += 400;
m_pEditor->GetCoordWnd().m_pViewCS->ClientToGround(&pt4d,1);
len = GraphAPI::GGet3DDisOf2P(PT_3D(arr[0].x,arr[0].y,arr[0].z),PT_3D(pt4d.x,pt4d.y,pt4d.z));
//将首点和尾点都延长400像素，模拟射线
PT_3DEX expt1, expt2;
expt1 = arr.GetAt(0);
expt2 = arr.GetAt(1);
double len1 = GraphAPI::GGet3DDisOf2P(expt1,expt2);
if (len1 <= GraphAPI::GetDisTolerance())
{
len1 = 1;
}
expt.x = expt1.x + (expt1.x-expt2.x)/len1*len;
expt.y = expt1.y + (expt1.y-expt2.y)/len1*len;
expt.z = expt1.z;// + (expt1.z-expt2.z)*10;
arr.SetAt(0,expt);
if( num0>=2 )
{
expt1 = arr.GetAt(num0-2);
expt2 = arr.GetAt(num0-1);
len1 = GraphAPI::GGet3DDisOf2P(expt1,expt2);
if (len1 <= GraphAPI::GetDisTolerance())
{
len1 = 1;
}
}
expt.x = expt2.x + (expt2.x-expt1.x)/len1*len;
expt.y = expt2.y + (expt2.y-expt1.y)/len1*len;
expt.z = expt2.z;// + (expt2.z-expt1.z)*10;
arr.SetAt(num0-1,expt);
}
pObj->CreateShape(arr.GetData(),arr.GetSize());
return pFtr;
}
void CDrawLinesByMultiPt::PtClick(PT_3D &pt, int flag)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
m_bLastRClick = FALSE;
GotoState(PROCSTATE_PROCESSING);
int ntmppt = m_arrPts.GetSize();
if( ntmppt>0 )GotoState(PROCSTATE_PROCESSING);
if( ntmppt==1 && ((CDlgDoc*)m_pEditor)->IsAutoSetAnchor() )
{
((CDlgDoc*)m_pEditor)->SetAnchorPoint(pt);
}
//m_arrPts.Add(PT_3DEX(pt,penLine));
m_arrBuildLine.Add(PT_3DEX(pt,penLine));
CDrawCommand::PtClick(pt,flag);
}
void CDrawLinesByMultiPt::PtReset(PT_3D &pt)
{
if (m_bLastRClick)
{
BOOL finished = TRUE;
CFeature *pFtr = CreateObjBySide(finished);
if (!pFtr)
{
Abort();
return;
}
((CGeoCurve*)pFtr->GetGeometry())->EnableClose(TRUE);
if( finished && pFtr )
{
if( !AddObject(pFtr) )
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
undo.arrNewHandles.Add(FtrToHandle(pFtr));
undo.Commit();
}
else if( pFtr )delete pFtr;
// m_pEditor->SetCurDrawingObj(DrawingInfo());
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
//m_pDoc->UpdateAllViews(NULL,hc_Detach_Accubox);
m_pEditor->RefreshView();
m_arrPts.RemoveAll();
if( !finished )
Abort();
else
{
if( m_pFtr!=NULL )
delete m_pFtr;
m_pFtr = NULL;
Finish();
}
}
else
{
m_bLastRClick = TRUE;
int size = m_arrBuildLine.GetSize();
if (size < 2)
{
m_arrBuildLine.RemoveAll();
return;
}
// 最小二乘法直线似合，调整首尾点平面位置
double A = 0, B = 0, C = 0, D = 0;
for (int i=0; i<size; i++)
{
A += m_arrBuildLine[i].x*m_arrBuildLine[i].x;
B += m_arrBuildLine[i].x;
C += m_arrBuildLine[i].x*m_arrBuildLine[i].y;
D += m_arrBuildLine[i].y;
}
double a = 1, b = 0, tmp = A*size-B*B;
if(fabs(tmp) > 1e-6)
{
a = (C*size-B*D)/tmp;
b = (A*D-C*B)/tmp;
m_arrBuildLine[0].y = a * m_arrBuildLine[0].x + b;
m_arrBuildLine[size-1].y = a * m_arrBuildLine[size-1].x + b;
}
m_arrPts.Add(m_arrBuildLine[0]);
m_arrPts.Add(m_arrBuildLine[size-1]);
m_arrBuildLine.RemoveAll();
//m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
BOOL finished = FALSE;
CFeature *pFtr = CreateObjBySide(finished);
if( !pFtr )
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
else
{
GrBuffer vbuf;
pFtr->GetGeometry()->Draw(&vbuf);
m_pEditor->UpdateDrag(ud_SetVariantDrag,&vbuf);
delete pFtr;
}
}
}
void CDrawLinesByMultiPt::PtMove(PT_3D &pt)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
if( m_arrPts.GetSize()<=0 )
{
GrBuffer vbuf;
for (int i=0; i<m_arrBuildLine.GetSize(); i++)
{
vbuf.Point(m_pFtr->GetGeometry()->GetColor(),&m_arrBuildLine[i],1,1);
}
m_pEditor->UpdateDrag(ud_SetVariantDrag,&vbuf);
return;
}
CArray<PT_3DEX,PT_3DEX> arrPts;
arrPts.Copy(m_arrBuildLine);
//arrPts.Add(PT_3DEX(pt,penLine));
//return;
BOOL finished = FALSE;
CFeature *pFtr = CreateObjBySide(finished);
if( !pFtr )
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
else
{
GrBuffer vbuf;
pFtr->GetGeometry()->Draw(&vbuf);
for (int i=0; i<m_arrBuildLine.GetSize(); i++)
{
vbuf.Point(m_pFtr->GetGeometry()->GetColor(),&m_arrBuildLine[i],1,1);
}
m_pEditor->UpdateDrag(ud_SetVariantDrag,&vbuf);
delete pFtr;
}
CDrawCommand::PtMove(pt);
}
void CDrawLinesByMultiPt::GetParams(CValueTable &tab)
{
CDrawCommand::GetParams(tab);
}
void CDrawLinesByMultiPt::FillShowParams(CUIParam* param, BOOL bForLoad )
{
}
void CDrawLinesByMultiPt::Finish()
{
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
if( m_pEditor )
{
if( m_pFtr )
{
BOOL bAnnotToText = AfxGetApp()->GetProfileInt(REGPATH_USER,REGITEM_ANNOTTOTEXT,FALSE);
if( bAnnotToText )
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
// CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayerByNameOrLayerIdx(StrFromResID(IDS_DEFLAYER_NAMET));
CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetLocalFtrLayer(StrFromResID(IDS_DEFLAYER_NAMET));
CFeature *pTempl = NULL;
if(pTextLayer)
pTempl = pTextLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOTEXT);
if( pLayer!=NULL && pTextLayer!=NULL && pTempl!=NULL )
{
CPtrArray arrAnnots;
CConfigLibManager *pCLM = gpCfgLibMan;
pCLM->GetSymbol(GETDS(m_pEditor),m_pFtr,arrAnnots);
CUndoFtrs undo(m_pEditor,Name());
for(int i=0; i<arrAnnots.GetSize(); i++)
{
CSymbol *pSymbol = (CSymbol*)arrAnnots.GetAt(i);
if (pSymbol && pSymbol->GetType()==SYMTYPE_ANNOTATION )
{
CAnnotation *pAnnot = (CAnnotation*)pSymbol;
CPtrArray parr;
CValueTable tab;
PDOC(m_pEditor)->GetDlgDataSource()->GetAllAttribute(m_pFtr,tab);
if( pAnnot->ExtractGeoText(m_pFtr,parr,tab,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale()) )
{
for (int j=0; j<parr.GetSize(); j++)
{
CGeoText *pText = (CGeoText*)parr[j];
pText->SetColor(m_pFtr->GetGeometry()->GetColor());
CFeature *pNewFtr = pTempl->Clone();
pNewFtr->SetGeometry(pText);
PDOC(m_pEditor)->AddObject(pNewFtr,pTextLayer->GetID());
undo.arrNewHandles.Add(FtrToHandle(pNewFtr));
}
}
}
}
undo.Commit();
}
if( pTempl!=NULL )delete pTempl;
}
}
m_pFtr = NULL;
m_pEditor->RefreshView();
}
CDrawCommand::Finish();
}
void CDrawLinesByMultiPt::SetParams(CValueTable& tab,BOOL bInit)
{
CDrawCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CDrawTableCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDrawTableCommand,CDrawCommand)
CDrawTableCommand::CDrawTableCommand()
{
m_nMode = -1;
m_nTableColumn = 2;
m_nTableWidthSpace = 10;
m_nTableLine = 0;
m_StrTableColumnSpace = _T("200,50");
m_pFtr = NULL;
}
CDrawTableCommand::~CDrawTableCommand()
{
if (m_pFtr)
{
delete m_pFtr;
m_pFtr = NULL;
}
}
CString CDrawTableCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DRAWTABLE);
}
BOOL CDrawTableCommand::GetPartColumSpace(CStringArray &StrColumnSpace,int i,double &Total)
{
if (StrColumnSpace.GetSize()<=0||i<0||i>StrColumnSpace.GetSize())
{
return FALSE;
}
double Temp=0;
for (int j=0;j<i;j++)
{
Temp = atof((LPTSTR)(LPCTSTR)StrColumnSpace.GetAt(j));
Total +=Temp;
}
return TRUE;
}
void CDrawTableCommand::Start()
{
if (!m_pEditor)
{
return;
}
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
if(!pLayer) return;
m_pFtr = pLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOCURVE);
if(!m_pFtr) return;
CDrawCommand::Start();
m_nMode = 0;
m_pEditor->CloseSelector();
}
void CDrawTableCommand::Finish()
{
// AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CDrawCommand::Finish();
}
void CDrawTableCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_TABLELINES,var) )
{
m_nTableLine = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_TABLECOLUMNS,var) )
{
m_nTableColumn = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_TABLESPACE,var) )
{
m_nTableWidthSpace = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_TABLECOLUMNSPACE,var) )
{
m_StrTableColumnSpace = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
CDrawCommand::SetParams(tab,bInit);
}
void CDrawTableCommand::GetParams(CValueTable& tab)
{
CDrawCommand::GetParams(tab);
_variant_t var;
var = (long)m_nTableLine;
tab.AddValue(PF_TABLELINES,&(CVariantEx)(long)(var));
var = (long)m_nTableColumn;
tab.AddValue(PF_TABLECOLUMNS,&(CVariantEx)(long)(var));
var = (long)m_nTableWidthSpace;
tab.AddValue(PF_TABLESPACE,&(CVariantEx)(long)(var));
var = (_bstr_t)(LPCTSTR)m_StrTableColumnSpace;
tab.AddValue(PF_TABLECOLUMNSPACE,&(CVariantEx)(var));
}
void CDrawTableCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("DrawTable",StrFromLocalResID(IDS_CMDNAME_DRAWTABLE));
param->AddParam(PF_TABLELINES,(int)m_nTableLine,StrFromResID(IDS_TABLELINES));
param->AddParam(PF_TABLECOLUMNS,(int)m_nTableColumn,StrFromResID(IDS_TABLECOLUMNS));
param->AddParam(PF_TABLESPACE,(int)m_nTableWidthSpace,StrFromResID(IDS_TABLESPACEWIDTH));
param->AddParam(PF_TABLECOLUMNSPACE,(LPCTSTR)m_StrTableColumnSpace,StrFromResID(IDS_TABLECOLUMNSPACE));
}
// void CDrawTableCommand::PtReset(PT_3D &pt)
// {
//
//
// }
extern CDocument *GetCurDocument();
void CDrawTableCommand::PtClick(PT_3D &pt, int flag)
{
GotoState(PROCSTATE_PROCESSING);
PT_3DEX expt(pt,penLine);
PT_3DEX pt_t(expt);
m_ptStart = pt;
CDlgDoc *pDoc = (CDlgDoc*)GetCurDocument();
CDlgDataSource *pDS = pDoc->GetDlgDataSource();
CFtrLayer *pLayer = pDS->GetFtrLayer(StrFromResID(IDS_LEGEND_TABLELINES));
if (!pLayer)
{
pLayer = pDS->CreateFtrLayer(StrFromResID(IDS_LEGEND_TABLELINES));
if (!pLayer)
{
return;
}
pDS->AddFtrLayer(pLayer);
}
if (!Split(m_StrTableColumnSpace,_T(","),m_StrColumnSpace))
{
return;
}
if (m_nTableColumn != m_StrColumnSpace.GetSize())
{
AfxMessageBox(StrFromResID(IDS_PARAMNOTMATCH));
return;
}
if (m_nMode == 0)
{
GrBuffer buf;
if (m_nTableColumn<2)
{
AfxMessageBox(StrFromResID(IDS_NOTE_DRAWTABLE));
return;
}
CUndoFtrs undo(m_pEditor,Name());
for (int i = 0;i<m_nTableLine; i++)
{
for (int j = 0;j<m_nTableColumn; j++)
{
m_arrPts.RemoveAll();
double TableColumnSpace = 0,TableColumnSpace1 = 0;
if(!GetPartColumSpace(m_StrColumnSpace,j,TableColumnSpace)) return;
if(!GetPartColumSpace(m_StrColumnSpace,j+1,TableColumnSpace1)) return;
pt_t.x = expt.x + TableColumnSpace;
pt_t.y = expt.y - i*m_nTableWidthSpace;
pt_t.z = expt.z;
m_arrPts.Add(pt_t);
pt_t.x = expt.x + TableColumnSpace1;
pt_t.y = expt.y - i*m_nTableWidthSpace;
pt_t.z = expt.z;
m_arrPts.Add(pt_t);
pt_t.x = expt.x + TableColumnSpace1;
pt_t.y = expt.y - (i+1)*m_nTableWidthSpace;
pt_t.z = expt.z;
m_arrPts.Add(pt_t);
pt_t.x = expt.x + TableColumnSpace;
pt_t.y = expt.y - (i+1)*m_nTableWidthSpace;
pt_t.z = expt.z;
m_arrPts.Add(pt_t);
pt_t.x = expt.x + TableColumnSpace;
pt_t.y = expt.y - i*m_nTableWidthSpace;
pt_t.z = expt.z;
m_arrPts.Add(pt_t);
m_pFtr = pLayer->CreateDefaultFeature(pDS->GetScale(),CLS_GEOCURVE);
if(!m_pFtr->GetGeometry()->CreateShape(m_arrPts.GetData(),m_arrPts.GetSize())) return;
m_pFtr->GetGeometry()->SetColor(RGB(255,0,0));
undo.arrNewHandles.Add(FtrToHandle(m_pFtr));
if( !m_pEditor->AddObject(m_pFtr,pLayer->GetID()) )
{
Abort();
return;
}
}
}
undo.Commit();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pFtr = NULL;
Finish();
}
CDrawCommand::PtClick(pt,flag);
}
void CDrawTableCommand::Abort()
{
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CDrawCommand::Abort();
}
//////////////////////////////////////////////////////////////////////
// CCreateSymbolAndDiscriptCommand Class//生成符号和文字描述
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CCreateSymbolAndDiscriptCommand,CDrawCommand)
CCreateSymbolAndDiscriptCommand::CCreateSymbolAndDiscriptCommand()
{
{
m_sTxtSettings.nInclineType = 0;
m_sTxtSettings.fInclineAngle = 0;
m_sTxtSettings.nPlaceType = singPt;
m_sTxtSettings.nAlignment = TAH_MID|TAV_MID;
m_sTxtSettings.SetUnderline(FALSE);
}
m_bType = TRUE;
m_nAlignment = 0;
m_strLayName = StrFromResID(IDS_DEFLAYER_NAMEL);
m_pFtr = NULL;
pLayersymbol = NULL;
m_pFtrSymbol = NULL;
m_nShape = 1;
m_nHeight = 2;
m_nWidth = 2;
m_nDiameter = 2;
strcat(m_strRegPath,"\\CreateSymbolAndDiscript");
}
CCreateSymbolAndDiscriptCommand::~CCreateSymbolAndDiscriptCommand()
{
if(m_pFtr) { delete m_pFtr; m_pFtr=NULL;}
if(m_pFtrSymbol) { delete m_pFtrSymbol; m_pFtr = NULL;}
}
CString CCreateSymbolAndDiscriptCommand::Name()
{
return StrFromResID(IDS_CREATSYMBOLANDDISCRIPTION);
}
void CCreateSymbolAndDiscriptCommand::Start()
{
if (!m_pEditor)
{
return;
}
m_pEditor->CloseSelector();
CDrawCommand::Start();
}
BOOL CheckCodeForLayerName(CDlgDataSource *pDS, LPTSTR code, CString &name)
{
if (!pDS || !name||!code||strlen(code)<=0)
{
return FALSE;
}
CConfigLibManager *pConfi = ((CEditBaseApp*)AfxGetApp())->GetConfigLibManager();
CScheme *pScheme = pConfi->GetScheme(pDS->GetScale());
if(!pScheme)return FALSE;
name.Empty();
CString text(code);
CStringArray arr;
convertStringToStrArray(text, arr);
for (int i = 0; i < arr.GetSize(); i++)
{
CString ret = arr[i];
__int64 code = _atoi64(ret);
if( code>0 )
{
if(pScheme->FindLayerIdx(TRUE,code,ret))//层码层名互转
{
name+=ret;
name+=_T(",");
}
else
{
CString Tip = ret;
Tip+=StrFromResID(IDS_CANNOT_FIND_LOCALLAYERNAME);
GOutPut(Tip);
}
}
else
{
if (pScheme->FindLayerIdx(FALSE, code, ret))//层码层名互转
{
name += ret;
name+=_T(",");
}
else
{
CString Tip = ret;
Tip+=StrFromResID(IDS_CANNOT_FIND_LOCALLAYERNAME);
GOutPut(Tip);
}
}
}
return TRUE;
}
BOOL CCreateSymbolAndDiscriptCommand::CheckStrLayerName(CString SrcLayerName,CStringArray &StrArrLayerName,CString &DesLayerName)
{
if (SrcLayerName.IsEmpty())
{
return FALSE;
}
StrArrLayerName.RemoveAll();
DesLayerName.Empty();
CStringArray StrArrTemp;
if (!Split(SrcLayerName,_T(","),StrArrTemp))
{
return FALSE;
}
int nsize = StrArrTemp.GetSize();
for (int i=0;i<nsize;i++)
{
BOOL IsAdd = TRUE;
for (int j=0;j<StrArrLayerName.GetSize();j++)
{
if (StrArrLayerName.GetAt(j).CompareNoCase(StrArrTemp.GetAt(i)) == 0)
{
IsAdd = FALSE;
}
}
if (IsAdd)
{
StrArrLayerName.Add(StrArrTemp.GetAt(i));
}
}
for (int k=0;k<StrArrLayerName.GetSize();k++)
{
DesLayerName =DesLayerName+StrArrLayerName.GetAt(k)+_T(",");
}
CString DestLayerName;
if(!CheckCodeForLayerName(PDOC(m_pEditor)->GetDlgDataSource(),(LPTSTR)(LPCTSTR)DesLayerName,DestLayerName))
{
return FALSE;
}
DesLayerName.Empty();
DesLayerName = DestLayerName;
CString StrTemp(DesLayerName);
if (StrTemp.Right(1).CompareNoCase(_T(","))==0)
{
DesLayerName.Delete(DesLayerName.GetLength()-1,1);
}
return TRUE;
}
void CCreateSymbolAndDiscriptCommand::Finish()
{
UpdateParams(TRUE);
if( m_pEditor )
{
m_pFtr=NULL;
m_pFtrSymbol = NULL;
m_pEditor->RefreshView();
GotoState(PROCSTATE_FINISHED);
m_pEditor->UpdateDrag(ud_SetConstDrag,NULL);
}
CDrawCommand::Finish();
}
void CCreateSymbolAndDiscriptCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_LAYERNAME,var) )
{
m_strLayName =(LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_CREATETYPE,var) )
{
m_bType =(bool)(_variant_t)*var;
SetSettingsModifyFlag();
if (!bInit)
{
Abort();
}
}
{
if( tab.GetValue(0,PF_FONT,var) )
{
if( var->m_variant.vt==VT_BSTR )
{
CString temp = (LPCTSTR)(_bstr_t)(_variant_t)*var;
strncpy(m_sTxtSettings.strFontName,temp,sizeof(m_sTxtSettings.strFontName)-1);
SetSettingsModifyFlag();
}
}
if( tab.GetValue(0,PF_CHARH,var) )
{
m_sTxtSettings.fHeight = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_CHARW,var) )
{
m_sTxtSettings.fWidScale = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_CHARI,var) )
{
m_sTxtSettings.fCharIntervalScale = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_LINEI,var) )
{
m_sTxtSettings.fLineSpacingScale = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"Bold",var) )
{
m_sTxtSettings.SetBold((bool)(_variant_t)*var);
SetSettingsModifyFlag();
}
}
{
if( tab.GetValue(0,PF_CREATE_SHAPE,var) )
{
m_nShape = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
{
if( tab.GetValue(0,PF_SHAPEWIDTH,var) )
{
m_nWidth = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_SHAPEHEIGHT,var) )
{
m_nHeight = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
}
{
if( tab.GetValue(0,PF_SHAPEDIAMETER,var) )
{
m_nDiameter = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
}
}
CDrawCommand::SetParams(tab,bInit);
}
void CCreateSymbolAndDiscriptCommand::GetParams(CValueTable& tab)
{
CDrawCommand::GetParams(tab);
_variant_t var;
var = (_bstr_t)(LPCTSTR)m_strLayName;
tab.AddValue(PF_LAYERNAME,&CVariantEx(var));
var = (bool)(m_bType);
tab.AddValue(PF_CREATETYPE,&(CVariantEx)(var));
// var = (long)(m_nAlignment);
// tab.AddValue(PF_ALIGNMENT,&(CVariantEx)(var));
var = (_variant_t)(long)(m_nShape);
tab.AddValue(PF_CREATE_SHAPE,&CVariantEx(var));
var = (double)(m_nWidth);
tab.AddValue(PF_SHAPEWIDTH,&CVariantEx(var));
var = (double)(m_nHeight);
tab.AddValue(PF_SHAPEHEIGHT,&CVariantEx(var));
var = (double)(m_nDiameter);
tab.AddValue(PF_SHAPEDIAMETER,&CVariantEx(var));
var = (LPCTSTR)(m_sTxtSettings.strFontName);
tab.AddValue(PF_FONT,&CVariantEx(var));
var = (double)(m_sTxtSettings.fHeight);
tab.AddValue(PF_CHARH,&CVariantEx(var));
var = (double)(m_sTxtSettings.fWidScale);
tab.AddValue(PF_CHARW,&CVariantEx(var));
var = (double)(m_sTxtSettings.fCharIntervalScale);
tab.AddValue(PF_CHARI,&CVariantEx(var));
var = (double)(m_sTxtSettings.fLineSpacingScale);
tab.AddValue(PF_LINEI,&CVariantEx(var));
var = (_variant_t)(bool)(m_sTxtSettings.IsBold());
tab.AddValue("Bold",&CVariantEx(var));
}
void CCreateSymbolAndDiscriptCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("CreateSymbolAndDiscriptCommand",StrFromLocalResID(IDS_CREATSYMBOLANDDISCRIPTION));
param->AddLayerNameParamEx("LayerName",(LPCTSTR)m_strLayName,StrFromResID(IDS_FIELDNAME_LAYERNAME));
param->BeginOptionParam(PF_CREATETYPE,StrFromResID(IDS_CREATETYPE));
param->AddOption(StrFromResID(IDS_LAYERNAME_SYM),0,' ',m_bType == 0);
param->AddOption(StrFromResID(IDS_WORDSDISCRIPTION),1,' ',m_bType == 1);
param->EndOptionParam();
if(!m_bType||bForLoad )
{
param->BeginOptionParam(PF_CREATE_SHAPE,StrFromResID(IDS_CREATE_SHAPE));
param->AddOption(StrFromResID(IDS_DRAWTYPE_LINE),shap_Line,' ',m_nShape==shap_Line);
param->AddOption(StrFromResID(IDS_DRAWTYPE_RECT),shap_Rect,' ',m_nShape==shap_Rect);
param->AddOption(StrFromResID(IDS_DRAWTYPE_CIRCLE),shap_CirCle,' ',m_nShape==shap_CirCle);
param->EndOptionParam();
if (shap_Rect == m_nShape||bForLoad)
{
param->AddParam(PF_SHAPEWIDTH,(double)m_nWidth,StrFromResID(IDS_SHAPE_WIDTH));
param->AddParam(PF_SHAPEHEIGHT,(double)m_nHeight,StrFromResID(IDS_SHAPE_HEIGHT));
}
if ( shap_CirCle == m_nShape||bForLoad)
{
param->AddParam(PF_SHAPEDIAMETER,(double)m_nDiameter,StrFromResID(IDS_SHAPE_DIAMETER));
}
}
if(m_bType||bForLoad)
{
// param->BeginOptionParam(PF_ALIGNMENT,StrFromResID(IDS_CMDPLANE_ALIGNTYPE));
// param->AddOption(StrFromResID(IDS_LEFTALIGN),0,' ',m_nAlignment==0);
// param->AddOption(StrFromResID(IDS_CENTERALIGN),1,' ',m_nAlignment==1);
// param->AddOption(StrFromResID(IDS_RIGHTALIGN),2,' ',m_nAlignment==2);
// param->EndOptionParam();
param->AddFontNameParam(PF_FONT,m_sTxtSettings.strFontName,StrFromResID(IDS_CMDPLANE_FONT));
param->AddParam(PF_CHARH,(double)m_sTxtSettings.fHeight,StrFromResID(IDS_CMDPLANE_CHARH));
param->AddParam(PF_CHARW,(double)m_sTxtSettings.fWidScale,StrFromResID(IDS_CMDPLANE_CHARWS));
param->AddParam(PF_CHARI,(double)m_sTxtSettings.fCharIntervalScale,StrFromResID(IDS_CMDPLANE_CHARIS));
param->AddParam(PF_LINEI,(double)m_sTxtSettings.fLineSpacingScale,StrFromResID(IDS_CMDPLANE_LINEIS));
param->AddParam("Bold",(bool)m_sTxtSettings.IsBold(),StrFromResID(IDS_BOLD));
}
}
void CCreateSymbolAndDiscriptCommand::PtReset(PT_3D &pt)
{
// if( !m_pFtr||!m_pFtrSymbol|| IsProcFinished(this) )
// {
// Abort();
// return;
// }
// if (m_pFtr->GetGeometry()->GetDataPointSum()<=0&&m_pFtrSymbol->GetGeometry()->GetDataPointSum()<=0)
// {
// Abort();
// }
// else
// Finish();
Abort();
CDrawCommand::Abort();
}
void CCreateSymbolAndDiscriptCommand::PtClick(PT_3D &pt, int flag)
{
CDlgDataSource *pDS = GETDS(m_pEditor);
CScheme *pScheme = gpCfgLibMan->GetScheme(pDS->GetScale());
CString desLayerName;
CheckStrLayerName(m_strLayName,m_StrArrLayerName,desLayerName);//去重复
// m_strLayName = desLayerName;
CUndoFtrs undo(m_pEditor,Name());
GotoState(PROCSTATE_PROCESSING);
if (m_bType ==1)
{
pLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetLocalFtrLayer(StrFromResID(IDS_DEFLAYER_NAMET));
if(!pLayer) return;
pLayer->SetName(StrFromResID(IDS_DEFLAYER_NAMET));
m_pFtr = pLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOTEXT);
if(!m_pFtr) return;
if (0 == m_nAlignment )
{
m_sTxtSettings.nAlignment = TAH_LEFT|TAV_MID;
}
else if (1 == m_nAlignment )
{
m_sTxtSettings.nAlignment = TAH_MID|TAV_MID;
}
else if (2 == m_nAlignment)
{
m_sTxtSettings.nAlignment = TAH_RIGHT|TAV_MID;
}
((CGeoText*)m_pFtr->GetGeometry())->SetText(desLayerName);
((CGeoText*)m_pFtr->GetGeometry())->SetSettings(&m_sTxtSettings);
//如果文本内容为空，则return;
CString str=((CGeoText*)m_pFtr->GetGeometry())->GetText();
if(str.IsEmpty())
{
return;
}
TEXT_SETTINGS0 settings;
((CGeoText*)m_pFtr->GetGeometry())->GetSettings(&settings);
CArray<PT_3DEX,PT_3DEX> arr;
CArray<PT_3DEX,PT_3DEX> arrPts;
m_pFtr->GetGeometry()->GetShape(arr);
PT_3DEX t;
PT_3D retpt;
retpt = GetAlignmentPt(pt,arrPts);
int nsize = arrPts.GetSize();
if (nsize!=5)
{
return;
}
t.x = retpt.x;
t.y = retpt.y;
t.z = retpt.z;
t.pencode= penLine;
arr.Add(t);
m_pFtr->GetGeometry()->CreateShape(arr.GetData(),arr.GetSize());
if( settings.nPlaceType==0 )//单点排列
if (m_bType)
{
if(! m_pEditor->AddObject(m_pFtr,pLayer->GetID()) )
{
Abort();
return;
}
undo.arrNewHandles.Add(FtrToHandle(m_pFtr));
}
}
else if (m_bType == 0)//符号
{
int nLayerName = m_StrArrLayerName.GetSize();
PT_3D retpt;
double cx,cy;//矩形的长宽
m_nAlignment = 0;
CArray<PT_3DEX,PT_3DEX> arrPts;
retpt = GetAlignmentPt(pt,arrPts);
for (int i = 0;i<nLayerName;i++)
{
pLayersymbol = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayer(m_StrArrLayerName.GetAt(i));
if(!pLayersymbol) continue;
// CSchemeLayerDefine *pSchemeLayer = pScheme->GetLayerDefine(m_StrArrLayerName.GetAt(i));
// if (!pSchemeLayer) continue;
// m_pFtrSymbol = pLayersymbol->CreateDefaultFeature(GETDS(m_pEditor)->GetScale(),pSchemeLayer->GetGeoClass());
m_pFtrSymbol = pLayersymbol->CreateDefaultFeature(GETDS(m_pEditor)->GetScale());
if(!m_pFtrSymbol) continue;
m_nScale = pDS->GetScale();
int nsize = arrPts.GetSize();
if (nsize!=5)
{
continue;
}
cx =fabs( arrPts.GetAt(1).x-arrPts.GetAt(0).x);
cy =fabs(arrPts.GetAt(0).y-arrPts.GetAt(3).y);
if (0 == m_nAlignment)
{
if (i!=0)
{
retpt.x+=cx/(nLayerName);
}
}
if(!CreateSymbolItem(pLayersymbol,retpt,cx,cy,nLayerName)) continue;
if (m_pEditor)
{
if( !m_pEditor->AddObject(m_pFtrSymbol,pLayersymbol->GetID()) )
{
Abort();
return;
}
undo.arrNewHandles.Add(FtrToHandle(m_pFtrSymbol));
}
}
}
undo.Commit();
Finish();
CDrawCommand::PtClick(pt, flag);
}
void CCreateSymbolAndDiscriptCommand::Abort()
{
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CDrawCommand::Abort();
}
PT_3D CCreateSymbolAndDiscriptCommand::GetAlignmentPt(PT_3D &pt,CArray<PT_3DEX,PT_3DEX> &arrPts)
{
PT_3D retPt;
CDlgDataSource *pDS = GETDS(m_pEditor);
CFtrLayer *pFtr = pDS->GetFtrLayer(StrFromResID(IDS_LEGEND_TABLELINES));//找图例表格线层
if (!pFtr)
{
retPt.x = pt.x;
retPt.y = pt.y;
retPt.z = pt.z;
return retPt;
}
int nObj = pFtr->GetObjectCount();
Envelope e;
for (int j=0;j<nObj;j++)
{
CFeature *pFeatr = pFtr->GetObject(j);
if (!pFeatr||!pFeatr->IsVisible())
continue;
CGeometry *pGeo = pFeatr->GetGeometry();
pGeo->GetShape()->GetPts(arrPts);
int nPts = arrPts.GetSize();
if (nPts!=5)//排除非闭合矩形地物
continue;
e = pGeo->GetShape()->GetEnvelope();
if (e.bPtIn(&pt))
{
if (0 == m_nAlignment )//左对齐
{
retPt.x = arrPts.GetAt(0).x;
retPt.y = (arrPts.GetAt(3).y+arrPts.GetAt(0).y)/2;
retPt.z = arrPts.GetAt(0).z;
}
else if (-1 == m_nAlignment||1 == m_nAlignment )//居中对齐
{
retPt.x = (arrPts.GetAt(0).x+arrPts.GetAt(1).x)/2;
retPt.y = (arrPts.GetAt(3).y+arrPts.GetAt(0).y)/2;
retPt.z = arrPts.GetAt(0).z;
}
else if (2 == m_nAlignment)//右对齐
{
retPt.x = arrPts.GetAt(1).x;
retPt.y = (arrPts.GetAt(1).y+arrPts.GetAt(2).y)/2;
retPt.z = arrPts.GetAt(0).z ;
}
return retPt;
}
}
//找不到返回原坐标
retPt.x = pt.x;
retPt.y = pt.y;
retPt.z = pt.z;
arrPts.RemoveAll();
return retPt;
}
BOOL CCreateSymbolAndDiscriptCommand::CreateSymbolItem(CSchemeLayerDefine *pLayer,PT_3D pt,double cx,double cy,int nLayerNum)
{
if (!pLayer)
{
return FALSE;
}
int nSymbolNum = pLayer->GetSymbolCount();
GrBuffer bufs;
if (!m_pFtrSymbol)
{
// CFeature *pFeature = pLayer->CreateDefaultFeature();
return FALSE;
}
CGeometry *pGeo =m_pFtrSymbol->GetGeometry();
if (!pGeo)
{
return FALSE;
}
int nGeoClass = pGeo->GetClassType();
if (nGeoClass==CLS_GEOPOINT || nGeoClass==CLS_GEODIRPOINT)
{
pGeo->CreateShape(&PT_3DEX(pt.x+cx/nLayerNum/2,pt.y,0,penMove,cy/2),1);
}
else if (nGeoClass == CLS_GEOPARALLEL)//双线
{
// 平行线有填充时填充在基线和辅助线之间
PT_3DEX pts[2];
if (0 == m_nAlignment)//左对齐
{
pts[0].x = pt.x;
pts[0].y = pt.y-cy/2+2;
pts[0].pencode = penLine;
pts[1].x = pt.x+cx/(nLayerNum);
pts[1].y = pt.y-cy/2+2;
pts[1].pencode = penLine;
}
pGeo->CreateShape(pts,2);
CGeoParallel *pParallele = (CGeoParallel*)pGeo;
pParallele->SetWidth(cy-4);
}
else if(nGeoClass == CLS_GEOCURVE)//单线 含填充
{
// 检查是否有颜色或图元填充,有则添加四个点方便填充
BOOL bHatch = FALSE;
BOOL bArc = FALSE;
for(int i=0; i<nSymbolNum; i++)
{
CSymbol *pSym = pLayer->GetSymbol(i);
int nType = pSym->GetType();
if (nType == SYMTYPE_SCALETURNPLATETYPE || nType==SYMTYPE_SCALE_LiangChang || nType==SYMTYPE_SCALE_YouGuan )
{
bArc = TRUE;
}
else if (nType == SYMTYPE_SCALEFUNNELTYPE && (((CScaleFunneltype*)pSym)->m_nFunnelType == 1 || ((CScaleFunneltype*)pSym)->m_nFunnelType == 3))
{
bArc = TRUE;
}
if( nType==SYMTYPE_CELLHATCH || nType==SYMTYPE_COLORHATCH || nType==SYMTYPE_LINEHATCH || nType == SYMTYPE_DIAGONAL || nType == SYMTYPE_SCALE_DiShangYaoDong ||
nType==SYMTYPE_SCALE_JianFangWu || nType==SYMTYPE_ANGBISECTORTYPE )
{
bHatch = TRUE;
break;
}
}
if (bArc)
{
PT_3DEX pts[4];
pts[0].x = pt.x;
pts[0].y = pt.y;
pts[0].pencode = penArc;
pts[1].x = pt.x+cy/nLayerNum/2;
pts[1].y = pt.y+(cy/2);
pts[1].pencode = penArc;
pts[2].x = pt.x+(cy/nLayerNum);
pts[2].y = pt.y;
pts[2].pencode = penArc;
pts[3].x = pt.x;
pts[3].y = pt.y;
pts[3].pencode = penArc;
pGeo->CreateShape(pts,4);
}
else if (bHatch)
{
PT_3DEX pts[5];
pts[0].x = pt.x;
pts[0].y = pt.y;
pts[0].pencode = penLine;
pts[1].x = pt.x+cx/nLayerNum;
pts[1].y = pt.y;
pts[1].pencode = penLine;
pts[2].x = pt.x+cx/nLayerNum;
pts[2].y = pt.y+cy/nLayerNum;
pts[2].pencode = penLine;
pts[3].x = pt.x;
pts[3].y = pt.y+cy/nLayerNum;
pts[3].pencode = penLine;
pts[4].x = pt.x;
pts[4].y = pt.y;
pts[4].pencode = penLine;
pGeo->CreateShape(pts,5);
}
else
{
PT_3DEX pts[2];
if (0 == m_nAlignment )
{
pts[0].x = pt.x;
pts[0].y = pt.y;
pts[0].pencode = penLine;
pts[1].x = pt.x+cx/(nLayerNum);
pts[1].y = pt.y;
pts[1].pencode = penLine;
}
pGeo->CreateShape(pts,2);
}
}
else if (nGeoClass == CLS_GEODCURVE)
{
PT_3DEX pts[4];
if ( 0 == m_nAlignment)
{
pts[0].x = pt.x;
pts[0].y = pt.y-cy/2+2;
pts[0].pencode = penMove;
pts[1].x = pt.x+cx/(nLayerNum);
pts[1].y = pt.y-cy/2+2;
pts[1].pencode = penLine;
pts[2].x = pt.x+cx/(nLayerNum);
pts[2].y = pt.y+cy/2-2;
pts[2].pencode = penMove;
pts[3].x = pt.x;
pts[3].y = pt.y+cy/2-2;
pts[3].pencode = penLine;
}
pGeo->CreateShape(pts,4);
}
else if(nGeoClass == CLS_GEOSURFACE)
{
BOOL bArc = FALSE;
for(int i=0; i<nSymbolNum; i++)
{
CSymbol *pSym = pLayer->GetSymbol(i);
int nType = pSym->GetType();
if (nType == SYMTYPE_SCALEFUNNELTYPE && ((CScaleFunneltype*)pSym)->m_nFunnelType == 1)
{
bArc = TRUE;
}
}
if (bArc)
{
PT_3DEX pts[4];
pts[0].x = pt.x;
pts[0].y = pt.y;
pts[0].pencode = penArc;
pts[1].x = pt.x+cy/nLayerNum/2;
pts[1].y = pt.y+(cy/2);
pts[1].pencode = penArc;
pts[2].x = pt.x+(cy/nLayerNum);
pts[2].y = pt.y;
pts[2].pencode = penArc;
pts[3].x = pt.x;
pts[3].y = pt.y;
pts[3].pencode = penArc;
pGeo->CreateShape(pts,4);
}
else
{
PT_3DEX pts[5];
if (0 == m_nAlignment)
{
pts[0].x = pt.x;
pts[0].y = pt.y-cy/2+2;
pts[0].pencode = penLine;
pts[1].x = pt.x+cx/(nLayerNum);
pts[1].y = pt.y-cy/2+2;
pts[1].pencode = penLine;
pts[2].x = pt.x+cx/(nLayerNum);
pts[2].y = pt.y+cy/2-2;
pts[2].pencode = penLine;
pts[3].x = pt.x;
pts[3].y = pt.y+cy/2-2;
pts[3].pencode = penLine;
pts[4].x = pt.x;
pts[4].y = pt.y-cy/2+2;
pts[4].pencode = penLine;
}
pGeo->CreateShape(pts,5);
}
}
else if (nGeoClass == CLS_GEOTEXT)
{
TEXT_SETTINGS0 settings;
settings.fHeight = cy/(2*nLayerNum);
pGeo->CreateShape(&PT_3DEX(pt.x,pt.y,0,penMove),1);
if (0 == m_nAlignment )
{
settings.nAlignment = TAH_LEFT|TAV_MID;
}
((CGeoText*)pGeo)->SetSettings(&settings);
((CGeoText*)pGeo)->SetText("abc");
}
return TRUE;
}
BOOL CCreateSymbolAndDiscriptCommand::CreateSymbolItem(CFtrLayer *pLayer,PT_3D pt,double cx,double cy,int nLayerNum)
{
GrBuffer bufs;
if (!m_pFtrSymbol) return FALSE;
CGeometry *pGeo =m_pFtrSymbol->GetGeometry();
if (!pGeo) return FALSE;
int nGeoClass = pGeo->GetClassType();
if (nGeoClass==CLS_GEOPOINT || nGeoClass==CLS_GEODIRPOINT)
{
pGeo->CreateShape(&PT_3DEX(pt.x+cx/2/nLayerNum,pt.y,0,penMove,cy/2),1);
}
else if (nGeoClass == CLS_GEOPARALLEL)//双线
{
// 平行线有填充时填充在基线和辅助线之间
PT_3DEX pts[2];
if (0 == m_nAlignment)//左对齐
{
pt.x+=cx/nLayerNum/2;
pts[0].x = pt.x-cx/nLayerNum/4;
pts[0].y = pt.y-cy/4;
pts[0].pencode = penLine;
pts[1].x = pt.x+cx/(nLayerNum)/4;
pts[1].y = pt.y-cy/4;
pts[1].pencode = penLine;
}
pGeo->CreateShape(pts,2);
CGeoParallel *pParallele = (CGeoParallel*)pGeo;
pParallele->SetWidth(cy/2);
}
else if(nGeoClass == CLS_GEOCURVE)//单线 含填充
{
// 检查是否有颜色或图元填充,有则添加四个点方便填充
BOOL bHatch = FALSE;
BOOL bArc = FALSE;
if (m_nShape == shap_CirCle)
{
bArc =TRUE;
if (m_nDiameter<=0)
{
return FALSE;
}
}
if (m_nShape == shap_Rect)
{
bHatch =TRUE;
if (m_nHeight<=0||m_nWidth<=0)
{
return FALSE;
}
}
if (bArc)
{
pt.x +=cx/2/nLayerNum;
PT_3DEX pts[5];
pts[0].x = pt.x;
pts[0].y = pt.y+cy/(2*m_nDiameter);
pts[0].pencode = penArc;
pts[1].x = pt.x-cy/(2*m_nDiameter);
pts[1].y = pt.y;
pts[1].pencode = penArc;
pts[2].x = pt.x;
pts[2].y = pt.y-cy/(2*m_nDiameter);
pts[2].pencode = penArc;
pts[3].x = pt.x+cy/(2*m_nDiameter);
pts[3].y = pt.y;
pts[3].pencode = penArc;
pts[4].x = pt.x;
pts[4].y = pt.y+cy/(2*m_nDiameter);
pts[4].pencode = penArc;
pGeo->CreateShape(pts,5);
}
else if (bHatch)
{
pt.x +=cx/2/nLayerNum;
PT_3DEX pts[5];
pts[0].x = pt.x-cx/(2*m_nWidth*nLayerNum);
pts[0].y = pt.y-cy/(2*m_nHeight);
pts[0].pencode = penLine;
pts[1].x = pt.x+cx/(2*m_nWidth*nLayerNum);
pts[1].y = pt.y-cy/(2*m_nHeight);
pts[1].pencode = penLine;
pts[2].x = pt.x+cx/(2*m_nWidth*nLayerNum);
pts[2].y = pt.y+cy/(2*m_nHeight);
pts[2].pencode = penLine;
pts[3].x = pt.x-cx/(2*m_nWidth*nLayerNum);
pts[3].y = pt.y+cy/(2*m_nHeight);
pts[3].pencode = penLine;
pts[4].x = pt.x-cx/(2*m_nWidth*nLayerNum);
pts[4].y = pt.y-cy/(2*m_nHeight);
pts[4].pencode = penLine;
pGeo->CreateShape(pts,5);
}
else
{
pt.x +=cx/2/nLayerNum;
PT_3DEX pts[2];
if (0 == m_nAlignment )
{
pts[0].x = pt.x-cx/nLayerNum/4;
pts[0].y = pt.y;
pts[0].pencode = penLine;
pts[1].x = pt.x+cx/(nLayerNum)/4;
pts[1].y = pt.y;
pts[1].pencode = penLine;
}
pGeo->CreateShape(pts,2);
}
}
else if (nGeoClass == CLS_GEODCURVE)
{
PT_3DEX pts[4];
if ( 0 == m_nAlignment)
{
pt.x+=cx/nLayerNum/2;
pts[0].x = pt.x-cx/nLayerNum/4;
pts[0].y = pt.y-cy/4;
pts[0].pencode = penMove;
pts[1].x = pt.x+cx/nLayerNum/4;
pts[1].y = pt.y-cy/4;
pts[1].pencode = penLine;
pts[3].x = pt.x+cx/nLayerNum/4;
pts[3].y = pt.y+cy/4;
pts[3].pencode = penLine;
pts[2].x = pt.x-cx/nLayerNum/4;
pts[2].y = pt.y+cy/4;
pts[2].pencode = penMove;
}
pGeo->CreateShape(pts,4);
}
else if(nGeoClass == CLS_GEOSURFACE)
{
BOOL bArc = FALSE;
if (bArc)
{
pt.x +=cx/2/nLayerNum;
PT_3DEX pts[5];
pts[0].x = pt.x;
pts[0].y = pt.y+cx/(2*nLayerNum);
pts[0].pencode = penArc;
pts[1].x = pt.x-cx/(2*nLayerNum);
pts[1].y = pt.y;
pts[1].pencode = penArc;
pts[2].x = pt.x;
pts[2].y = pt.y-cx/(2*nLayerNum);
pts[2].pencode = penArc;
pts[3].x = pt.x+cx/(2*nLayerNum);
pts[3].y = pt.y;
pts[3].pencode = penArc;
pts[4].x = pt.x;
pts[4].y = pt.y+cx/(2*nLayerNum);
pts[4].pencode = penArc;
pGeo->CreateShape(pts,5);
}
else
{
PT_3DEX pts[5];
pt.x +=cx/2/nLayerNum;
pts[0].x = pt.x-cx/(4*nLayerNum);
pts[0].y = pt.y-cy/(4);
pts[0].pencode = penLine;
pts[1].x = pt.x+cx/(4*nLayerNum);
pts[1].y = pt.y-cy/(4);
pts[1].pencode = penLine;
pts[2].x = pt.x+cx/(4*nLayerNum);
pts[2].y = pt.y+cy/(4);
pts[2].pencode = penLine;
pts[3].x = pt.x-cx/(4*nLayerNum);
pts[3].y = pt.y+cy/(4);
pts[3].pencode = penLine;
pts[4].x = pt.x-cx/(4*nLayerNum);
pts[4].y = pt.y-cy/(4);
pts[4].pencode = penLine;
pGeo->CreateShape(pts,5);
}
}
else if (nGeoClass == CLS_GEOTEXT)
{
TEXT_SETTINGS0 settings;
settings.fHeight = cy/(2);
pGeo->CreateShape(&PT_3DEX(pt.x,pt.y,0,penMove),1);
if (0 == m_nAlignment )
{
settings.nAlignment = TAH_LEFT|TAV_MID;
}
((CGeoText*)pGeo)->SetSettings(&settings);
((CGeoText*)pGeo)->SetText("abc");
}
return TRUE;
}
void CCreateSymbolAndDiscriptCommand::DrawSymbolItem(int cx, int cy, const GrBuffer2d *pBuf, COLORREF col, COLORREF colBak)
{
//创建内存设备
CClientDC cdc(PDOC(m_pEditor)->GetCurActiveView());
HDC hDC = ::CreateCompatibleDC(cdc.m_hDC);
if( !hDC )return;
HBITMAP hBmp = ::CreateCompatibleBitmap(cdc.m_hDC,cx,cy);
if( !hBmp )
{
::DeleteDC(hDC);
return;
}
CBitmap bm;
bm.Attach(hBmp);
HBITMAP hOldBmp = (HBITMAP)::SelectObject(hDC, hBmp);
CBrush br(RGB(128,128,128));
::FillRect(hDC,CRect(0,0,cx,cy),(HBRUSH)br);
// HBRUSH hOldBrush = (HBRUSH)::SelectObject(hDC,(HBRUSH)br);
CPen pen;
pen.CreatePen(PS_SOLID,0,(COLORREF)0);
HPEN hOldPen = (HPEN)::SelectObject(hDC,(HPEN)pen);
//计算变换系数
CRect rect(2,2,cx-4,cy-4);
Envelope e = pBuf->GetEnvelope();
float scalex = rect.Width()/(e.m_xh>e.m_xl?(e.m_xh-e.m_xl):1e-10);
float scaley = rect.Height()/(e.m_yh>e.m_yl?(e.m_yh-e.m_yl):1e-10);
float xoff=0, yoff=0;
if( scalex>scaley )
{
xoff = cx/2-((e.m_xh-e.m_xl)/2*scaley+rect.left);
scalex = scaley;
}
else
{
yoff = cy/2-((e.m_yh-e.m_yl)/2*scalex+rect.top);
}
double matrix[9] = {
scalex,0,-e.m_xl*scalex+rect.left+xoff+0.5,
0,-scalex,cy+e.m_yl*scalex-rect.top-yoff-0.5,
0,0,1
};
GDI_DrawGrBuffer2d(hDC,pBuf,TRUE,col,matrix,CSize(cx,cy),CRect(0,0,cx,cy),colBak);
::SelectObject(hDC,hOldPen);
::SelectObject(hDC,hOldBmp);
::DeleteDC(hDC);
::DeleteObject(hBmp);
}
//////////////////////////////////////////////////////////////////////
// CDrawTextCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDrawTextCommand,CDrawCommand)
CDrawTextCommand::CDrawTextCommand()
{
m_pFtr = NULL;
m_bDrag = FALSE;
m_pSel = NULL;
}
CDrawTextCommand::~CDrawTextCommand()
{
if (m_pFtr)
{
delete m_pFtr;
}
if(m_pSel)
delete m_pSel;
}
CString CDrawTextCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DRAWTEXT);
}
static BOOL FindStrInStrArr(const CStringArray *pArr,LPCSTR str)
{
if(!pArr) return FALSE;
for (int i=pArr->GetSize()-1;i>=0;i--)
{
if(strcmp(LPCSTR((*pArr)[i]),LPCSTR(str))==0)
return TRUE;
}
if(i<0)
return FALSE;
return TRUE;
}
int CALLBACK EnumFontFamProc(LPENUMLOGFONT lpelf, LPNEWTEXTMETRIC lpntm, DWORD nFontType, LONG_PTR lparam)
{
CStringArray* pArr = (CStringArray*) lparam;
if(!pArr) return 0;
if (nFontType==TRUETYPE_FONTTYPE )
{
if(!FindStrInStrArr(pArr,lpelf->elfLogFont.lfFaceName))
pArr->Add(lpelf->elfLogFont.lfFaceName);
}
return 1;
}
static BOOL ReadOptionalText(CStringArray& arr)
{
CString path;
path = GetConfigPath();
CString filePath = path + "OptionalText.txt";
FILE *fp = fopen(filePath,"r");
if( !fp )return FALSE;
char line[1024];
while( !feof(fp) )
{
memset(line,0,sizeof(line));
fgets(line,sizeof(line)-1,fp);
if( strlen(line)>0 )
{
arr.Add(line);
}
}
fclose(fp);
return TRUE;
}
static void AddOptionalDrawText(CUIFProp *pProp)
{
CStringArray arr;
if( !ReadOptionalText(arr) )
return;
for( int i=0; i<arr.GetSize(); i++)
{
pProp->AddOption(arr[i]);
}
}
void CDrawTextCommand::Start()
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
if(!pLayer) return;
m_pFtr = pLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOTEXT);
if(!m_pFtr) return;
m_pEditor->CloseSelector();
CDrawCommand::Start();
m_pSel = new CPermanentExchanger(m_pFtr);
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
void CDrawTextCommand::RefreshPropertiesPanel()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
DrawingInfo CDrawTextCommand::GetCurDrawingInfo()
{
if (!m_pFtr)return DrawingInfo();
CArray<PT_3DEX,PT_3DEX> arr;
m_pFtr->GetGeometry()->GetShape(arr);
return DrawingInfo(m_pFtr,arr);
}
void CDrawTextCommand::Abort()
{
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
if(m_pFtr)
{
delete m_pFtr;
m_pFtr = NULL;
}
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CDrawCommand::Abort();
}
void CDrawTextCommand::Back()
{
// if( m_pFtr->GetPtSum()<=2 )
// {
// for( int i=m_pObj->GetPtSum()-1; i>=0; i--)
// m_pObj->DeletePt(m_pObj->GetPtSum()-1);
// }
// else
// {
// if( m_bDrag )
// m_pObj->DeletePt(m_pObj->GetPtSum()-2);
// else
// m_pObj->DeletePt(m_pObj->GetPtSum()-1);
// }
CDrawCommand::Back();
}
void CDrawTextCommand::Finish()
{
if (m_pEditor)
{
if( !AddObject(m_pFtr)/*m_pEditor->AddObject(m_pFtr)*/ )
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
undo.arrNewHandles.Add(FtrToHandle(m_pFtr));
undo.Commit();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
if( m_pEditor )
{
if( m_pFtr )
{
BOOL bAnnotToText = AfxGetApp()->GetProfileInt(REGPATH_USER,REGITEM_ANNOTTOTEXT,FALSE);
if( bAnnotToText )
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
// CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetFtrLayerByNameOrLayerIdx(StrFromResID(IDS_DEFLAYER_NAMET));
CFtrLayer *pTextLayer = PDOC(m_pEditor)->GetDlgDataSource()->GetLocalFtrLayer(StrFromResID(IDS_DEFLAYER_NAMET));
CFeature *pTempl = NULL;
if(pTextLayer)
pTempl = pTextLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOTEXT);
if( pLayer!=NULL && pTextLayer!=NULL && pTempl!=NULL )
{
CPtrArray arrAnnots;
CConfigLibManager *pCLM = gpCfgLibMan;
pCLM->GetSymbol(GETDS(m_pEditor),m_pFtr,arrAnnots);
CUndoFtrs undo(m_pEditor,Name());
for(int i=0; i<arrAnnots.GetSize(); i++)
{
CSymbol *pSymbol = (CSymbol*)arrAnnots.GetAt(i);
if (pSymbol && pSymbol->GetType()==SYMTYPE_ANNOTATION )
{
CAnnotation *pAnnot = (CAnnotation*)pSymbol;
CPtrArray parr;
CValueTable tab;
PDOC(m_pEditor)->GetDlgDataSource()->GetAllAttribute(m_pFtr,tab);
if( pAnnot->ExtractGeoText(m_pFtr,parr,tab,PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale()) )
{
for (int j=0; j<parr.GetSize(); j++)
{
CGeoText *pText = (CGeoText*)parr[j];
pText->SetColor(m_pFtr->GetGeometry()->GetColor());
CFeature *pNewFtr = pTempl->Clone();
pNewFtr->SetGeometry(pText);
PDOC(m_pEditor)->AddObject(pNewFtr,pTextLayer->GetID());
undo.arrNewHandles.Add(FtrToHandle(pNewFtr));
}
}
}
}
undo.Commit();
}
if( pTempl!=NULL )delete pTempl;
}
}
m_pFtr = NULL;
m_pEditor->RefreshView();
}
CDrawCommand::Finish();
}
void CDrawTextCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
GotoState(PROCSTATE_PROCESSING);
((CGeoText*)m_pFtr->GetGeometry())->SetText(m_strText);
((CGeoText*)m_pFtr->GetGeometry())->SetSettings(&m_sTxtSettings);
//如果文本内容为空，则return;
CString str=((CGeoText*)m_pFtr->GetGeometry())->GetText();
if(str.IsEmpty())
{
// Abort();
return;
}
//获得文本设置选项
TEXT_SETTINGS0 settings;
((CGeoText*)m_pFtr->GetGeometry())->GetSettings(&settings);
CArray<PT_3DEX,PT_3DEX> arr;
m_pFtr->GetGeometry()->GetShape(arr);
if( m_bDrag )
{
arr.RemoveAt(arr.GetSize()-1);
m_bDrag = FALSE;
}
PT_3DEX t;
t.x = pt.x;
t.y = pt.y;
t.z = pt.z;
t.pencode= penLine;
arr.Add(t);
m_pFtr->GetGeometry()->CreateShape(arr.GetData(),arr.GetSize());
if( settings.nPlaceType==0 )
PtReset(pt);
else
{
GrBuffer cbuf,vbuf;
CPlotTextEx plotText;
plotText.SetShape(m_pFtr->GetGeometry()->GetShape());
plotText.SetText(LPCTSTR(str));
settings.fHeight *= PDOC(m_pEditor)->GetDlgDataSource()->GetSymbolDrawScale();
plotText.SetSettings(&settings);
plotText.GetAddConstGrBuffer(&cbuf);
// plotText.GetVariantGrBuffer(&vbuf);
long color = m_pFtr->GetGeometry()->GetColor();
if (color == FTRCOLOR_BYLAYER)
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
if(!pLayer)
{
Abort();
return;
}
color = pLayer->GetColor();
}
cbuf.SetAllColor(color);
//vbuf.SetAllColor(m_pFtr->GetGeometry()->GetColor());
m_pEditor->UpdateDrag(ud_AddConstDrag,&cbuf);
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
CDrawCommand::PtClick(pt,flag);
}
return;
}
void CDrawTextCommand::PtMove(PT_3D &pt)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
if( m_pFtr->GetGeometry()->GetDataPointSum()<=0 )return;
PT_3DEX t;
t.x = pt.x;
t.y = pt.y;
t.z = pt.z;
t.pencode= penLine;
if( m_bDrag )
m_pFtr->GetGeometry()->SetDataPoint(m_pFtr->GetGeometry()->GetDataPointSum()-1,t);
else
{
CArray<PT_3DEX,PT_3DEX> arr;
m_pFtr->GetGeometry()->GetShape(arr);
arr.Add(t);
m_pFtr->GetGeometry()->CreateShape(arr.GetData(),arr.GetSize());
m_bDrag = TRUE;
}
GrBuffer vbuf;
CPlotTextEx plotText;
plotText.SetShape(m_pFtr->GetGeometry()->GetShape());
plotText.SetText(LPCTSTR(m_strText));
TEXT_SETTINGS0 settingTmp;
memcpy(&settingTmp,&m_sTxtSettings,sizeof(TEXT_SETTINGS0));
CDlgDataSource *pDS = GETDS(m_pEditor);
settingTmp.fHeight *= pDS->GetSymbolDrawScale();
// m_pFtr->Draw(&vbuf,fDrawScale);
plotText.SetSettings(&settingTmp);
plotText.GetVariantGrBuffer(&vbuf);
m_pEditor->UpdateDrag(ud_SetVariantDrag,&vbuf);
// arr.RemoveAt(arr.GetSize()-1);
// m_pFtr->GetGeometry()->CreateShape(arr.GetData(),arr.GetSize());
CDrawCommand::PtMove(pt);
}
void CDrawTextCommand::PtReset(PT_3D &pt)
{
if( !m_pFtr || IsProcFinished(this) )return;
if( m_bDrag )
{
CArray<PT_3DEX,PT_3DEX> arr;
m_pFtr->GetGeometry()->GetShape(arr);
arr.RemoveAt(arr.GetSize()-1);
m_pFtr->GetGeometry()->CreateShape(arr.GetData(),arr.GetSize());
}
if (m_pFtr->GetGeometry()->GetDataPointSum()<=0)
{
Abort();
}
else
Finish();
}
void CDrawTextCommand::GetParams(CValueTable &tab)
{
CDrawCommand::GetParams(tab);
_variant_t var;
var = (_bstr_t)(m_strText);
tab.AddValue(PF_TEXT,&CVariantEx(var));
var = (LPCTSTR)(m_sTxtSettings.strFontName);
tab.AddValue(PF_FONT,&CVariantEx(var));
var = (double)(m_sTxtSettings.fHeight);
tab.AddValue(PF_CHARH,&CVariantEx(var));
var = (double)(m_sTxtSettings.fWidScale);
tab.AddValue(PF_CHARW,&CVariantEx(var));
var = (double)(m_sTxtSettings.fCharIntervalScale);
tab.AddValue(PF_CHARI,&CVariantEx(var));
var = (double)(m_sTxtSettings.fLineSpacingScale);
tab.AddValue(PF_LINEI,&CVariantEx(var));
var = (_variant_t)(long)(m_sTxtSettings.nInclineType);
tab.AddValue(PF_SHRUG,&CVariantEx(var));
var = (double)(m_sTxtSettings.fInclineAngle);
tab.AddValue(PF_SHRUGA,&CVariantEx(var));
var = (_variant_t)(long)(m_sTxtSettings.nPlaceType);
tab.AddValue(PF_LAYOUT,&CVariantEx(var));
var = (_variant_t)(long)(m_sTxtSettings.nAlignment);
tab.AddValue(PF_ALIGNTYPE,&CVariantEx(var));
var = (_variant_t)(bool)(m_sTxtSettings.IsBold());
tab.AddValue("Bold",&CVariantEx(var));
var = (_variant_t)(bool)(m_sTxtSettings.IsUnderline());
tab.AddValue("Underline",&CVariantEx(var));
}
void CDrawTextCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("DrawTextCommand",Name());
param->AddMultiEditParam(PF_TEXT,(LPCTSTR)m_strText,StrFromResID(IDS_CMDPLANE_TEXT));
param->AddFontNameParam(PF_FONT,m_sTxtSettings.strFontName,StrFromResID(IDS_CMDPLANE_FONT));
param->AddParam(PF_CHARH,(double)m_sTxtSettings.fHeight,StrFromResID(IDS_CMDPLANE_CHARH));
param->AddParam(PF_CHARW,(double)m_sTxtSettings.fWidScale,StrFromResID(IDS_CMDPLANE_CHARWS));
param->AddParam(PF_CHARI,(double)m_sTxtSettings.fCharIntervalScale,StrFromResID(IDS_CMDPLANE_CHARIS));
param->AddParam(PF_LINEI,(double)m_sTxtSettings.fLineSpacingScale,StrFromResID(IDS_CMDPLANE_LINEIS));
param->BeginOptionParam(PF_SHRUG,StrFromResID(IDS_CMDPLANE_SHRUG));
param->AddOption(StrFromResID(IDS_CMDPLANE_SHRUGN),SHRUGN,' ',m_sTxtSettings.nInclineType==SHRUGN);
param->AddOption(StrFromResID(IDS_CMDPLANE_SHRUGL),SHRUGL,' ',m_sTxtSettings.nInclineType==SHRUGL);
param->AddOption(StrFromResID(IDS_CMDPLANE_SHRUGR),SHRUGR,' ',m_sTxtSettings.nInclineType==SHRUGR);
param->AddOption(StrFromResID(IDS_CMDPLANE_SHRUGU),SHRUGU,' ',m_sTxtSettings.nInclineType==SHRUGU);
param->AddOption(StrFromResID(IDS_CMDPLANE_SHRUGD),SHRUGD,' ',m_sTxtSettings.nInclineType==SHRUGD);
param->EndOptionParam();
param->AddParam(PF_SHRUGA,(double)m_sTxtSettings.fInclineAngle,StrFromResID(IDS_CMDPLANE_SHRUGA));
param->BeginOptionParam(PF_LAYOUT,StrFromResID(IDS_CMDPLANE_LAYOUT));
param->AddOption(StrFromResID(IDS_CMDPLANE_SINGLEPT),singPt,' ',m_sTxtSettings.nPlaceType==singPt);
param->AddOption(StrFromResID(IDS_CMDPLANE_MULTIPT),mutiPt,' ',m_sTxtSettings.nPlaceType==mutiPt);
param->AddOption(StrFromResID(IDS_CMDPLANE_BYLINES),byLineH,' ',m_sTxtSettings.nPlaceType==byLineH);
param->AddOption(StrFromResID(IDS_CMDPLANE_BYLINES2),byLineV,' ',m_sTxtSettings.nPlaceType==byLineV);
param->AddOption(StrFromResID(IDS_CMDPLANE_BYLINESGRID),byLineGridH,' ',m_sTxtSettings.nPlaceType==byLineGridH);
param->AddOption(StrFromResID(IDS_CMDPLANE_BYLINES2GRID),byLineGridV,' ',m_sTxtSettings.nPlaceType==byLineGridV);
param->EndOptionParam();
param->BeginOptionParam(PF_ALIGNTYPE,StrFromResID(IDS_CMDPLANE_ALIGNTYPE));
param->AddOption(StrFromResID(IDS_TEXTALIGNLT),TAH_LEFT|TAV_TOP,' ',m_sTxtSettings.nAlignment==(TAH_LEFT|TAV_TOP));
param->AddOption(StrFromResID(IDS_TEXTALIGNLM),TAH_LEFT|TAV_MID,' ',m_sTxtSettings.nAlignment==(TAH_LEFT|TAV_MID));
param->AddOption(StrFromResID(IDS_TEXTALIGNLB),TAH_LEFT|TAV_BOTTOM,' ',m_sTxtSettings.nAlignment==(TAH_LEFT|TAV_BOTTOM));
param->AddOption(StrFromResID(IDS_TEXTALIGNMT),TAH_MID|TAV_TOP,' ',m_sTxtSettings.nAlignment==(TAH_MID|TAV_TOP));
param->AddOption(StrFromResID(IDS_TEXTALIGNMM),TAH_MID|TAV_MID,' ',m_sTxtSettings.nAlignment==(TAH_MID|TAV_MID));
param->AddOption(StrFromResID(IDS_TEXTALIGNMB),TAH_MID|TAV_BOTTOM,' ',m_sTxtSettings.nAlignment==(TAH_MID|TAV_BOTTOM));
param->AddOption(StrFromResID(IDS_TEXTALIGNRT),TAH_RIGHT|TAV_TOP,' ',m_sTxtSettings.nAlignment==(TAH_RIGHT|TAV_TOP));
param->AddOption(StrFromResID(IDS_TEXTALIGNRM),TAH_RIGHT|TAV_MID,' ',m_sTxtSettings.nAlignment==(TAH_RIGHT|TAV_MID));
param->AddOption(StrFromResID(IDS_TEXTALIGNRB),TAH_RIGHT|TAV_BOTTOM,' ',m_sTxtSettings.nAlignment==(TAH_RIGHT|TAV_BOTTOM));
param->AddOption(StrFromResID(IDS_TEXTALIGN_DOT),TAH_DOT,' ',m_sTxtSettings.nAlignment==TAH_DOT);
param->EndOptionParam();
param->AddParam("Bold",(bool)m_sTxtSettings.IsBold(),StrFromResID(IDS_BOLD));
param->AddParam("Underline",(bool)m_sTxtSettings.IsUnderline(),StrFromResID(IDS_UNDERLINE));
}
void CDrawTextCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_TEXT,var) )
{
m_strText = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_FONT,var) )
{
if( var->m_variant.vt==VT_BSTR )
{
CString temp = (LPCTSTR)(_bstr_t)(_variant_t)*var;
strncpy(m_sTxtSettings.strFontName,temp,sizeof(m_sTxtSettings.strFontName)-1);
TextStyle style = GetUsedTextStyles()->GetTextStyleByName(temp);
if( style.IsValid() )
{
m_sTxtSettings.fWidScale = style.fWidScale;
m_sTxtSettings.nInclineType = style.nInclineType;
m_sTxtSettings.fInclineAngle = style.fInclinedAngle;
m_sTxtSettings.SetBold(style.bBold);
}
SetSettingsModifyFlag();
}
}
if( tab.GetValue(0,PF_CHARH,var) )
{
m_sTxtSettings.fHeight = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_CHARW,var) )
{
m_sTxtSettings.fWidScale = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_CHARI,var) )
{
m_sTxtSettings.fCharIntervalScale = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_LINEI,var) )
{
m_sTxtSettings.fLineSpacingScale = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_SHRUG,var) )
{
m_sTxtSettings.nInclineType = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_SHRUGA,var) )
{
m_sTxtSettings.fInclineAngle = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_LAYOUT,var) )
{
m_sTxtSettings.nPlaceType = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_ALIGNTYPE,var) )
{
m_sTxtSettings.nAlignment = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"Bold",var) )
{
m_sTxtSettings.SetBold((bool)(_variant_t)*var);
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"Underline",var) )
{
m_sTxtSettings.SetUnderline((bool)(_variant_t)*var);
SetSettingsModifyFlag();
}
CDrawCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CContourTextCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CContourTextCommand,CEditCommand)
CContourTextCommand::CContourTextCommand()
{
m_nStep = -1;
m_nDigitNum = 2;
m_strTextLayerCode.Format("%s","");
m_nMode = 0;
m_nTextCoverType = COVERTYPE_NONE;
strcat(m_strRegPath,"\\ContourText");
m_fExtendDis = 0;
}
CContourTextCommand::~CContourTextCommand()
{
}
CString CContourTextCommand::Name()
{
return StrFromResID(IDS_CMDNAME_CONTOURTEXT);
}
void CContourTextCommand::Start()
{
if( !m_pEditor )return;
m_nMode = 0;
m_nDigitNum = 2;
m_strTextLayerCode = StrFromResID(IDS_DEFLAYER_NAMET);
m_strContourLayerCode = StrFromResID(IDS_INDEX_CONTOUR);
CEditCommand::Start();
if (m_nMode==modeLinesection)
{
m_pEditor->CloseSelector();
}
else
{
m_pEditor->OpenSelector(SELMODE_SINGLE);
}
}
void CContourTextCommand::Abort()
{
m_pEditor->DeselectAll();
CEditCommand::Abort();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
void CContourTextCommand::PtReset(PT_3D &pt)
{
if( IsProcOver(this) )return;
Abort();
CEditCommand::PtReset(pt);
}
void CContourTextCommand::PtMove(PT_3D &pt)
{
if(m_nStep==1&&m_nMode==modeLinesection)
{
GrBuffer buf;
buf.BeginLineString(0,0,0);
buf.MoveTo(&m_ptDragStart);
buf.LineTo(&pt);
buf.End();
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
}
CEditCommand::PtMove(pt);
}
BOOL CContourTextCommand::FilterFeature(LONG_PTR id)
{
CFeature *pFtr = (CFeature*)id;
CDlgDataSource *pDS = PDOC(m_pEditor)->GetDlgDataSource();
if(pDS)
{
CFtrLayer* pLayer = pDS->GetFtrLayerOfObject(pFtr);
if (!pLayer) return FALSE;
if(pLayer->IsLocked()) return FALSE;
if ((!pLayer->IsVisible()||!pFtr->IsVisible())) return FALSE;
CGeometry *po = pFtr->GetGeometry();
if( !po )return FALSE;
if( !po->IsKindOf(RUNTIME_CLASS(CGeoCurve)) )return FALSE;
if( !CheckNameForLayerCode(pDS,pLayer->GetName(),StrFromResID(IDS_STD_CONTOUR)) && !CheckNameForLayerCode(pDS,pLayer->GetName(),StrFromResID(IDS_INDEX_CONTOUR)))
return FALSE;
if (m_pCurFtr != NULL && fabs(m_pCurFtr->GetGeometry()->GetDataPoint(0).z-po->GetDataPoint(0).z) < 1e-6)
return FALSE;
}
return TRUE;
}
CFeature* CContourTextCommand::CreateText()
{
const CShapeLine *pShape = m_pCurFtr->GetGeometry()->GetShape();
if (!pShape) return NULL;
CArray<PT_3DEX,PT_3DEX> arrPts,arrPts0;
pShape->GetPts(arrPts0);
int size = GraphAPI::GKickoffSamePoints(arrPts0.GetData(),arrPts0.GetSize());
arrPts.SetSize(size);
for (int i=0; i<size; i++)
{
COPY_3DPT(arrPts[i],arrPts0[i]);
arrPts[i].pencode = arrPts0[i].pencode;
}
PT_3D ptIntersect, ptDir;
double pos;
if (m_nMode == modeLinesection)
{
PT_3DEX line[2];
line[0] = PT_3DEX(m_ptDragStart,penLine);
line[1] = PT_3DEX(m_ptDragEnd,penLine);
if (GetIntersectPos(arrPts.GetData(),arrPts.GetSize(),line,&pos,NULL))
{
if (fabs(pos - int(pos)) < 1e-6)
pos++;
int index = int(pos);
double len = pos - index;
if (fabs(pos-(size-1)) <= 1e-4)
{
ptIntersect = arrPts[size-1];
ptDir.x = 2*arrPts[size-1].x - arrPts[size-2].x;
ptDir.y = 2*arrPts[size-1].y - arrPts[size-2].y;
ptDir.z = 2*arrPts[size-1].z - arrPts[size-2].z;
}
else
{
ptIntersect.x = arrPts[index].x + (arrPts[index+1].x - arrPts[index].x)*len;
ptIntersect.y = arrPts[index].y + (arrPts[index+1].y - arrPts[index].y)*len;
ptIntersect.z = arrPts[index].z + (arrPts[index+1].z - arrPts[index].z)*len;
ptDir = arrPts[index+1];
}
}
else
{
return NULL;
}
}
else if (m_nMode == modeSinglePoint)
{
int pos1;
PT_3DEX ret;
GraphAPI::GGetNearstDisPToPointSet2D(arrPts.GetData(),arrPts.GetSize(),PT_3DEX(m_ptDragStart,penLine),ret,&pos1);
if (abs(pos1 - int(pos1)) < 1e-6)
pos1++;
pos = pos1;
ptIntersect = ret;
if (pos1 == size-1)
{
ptDir.x = 2*arrPts[size-1].x - arrPts[size-2].x;
ptDir.y = 2*arrPts[size-1].y - arrPts[size-2].y;
ptDir.z = 2*arrPts[size-1].z - arrPts[size-2].z;
}
else
{
ptDir = arrPts[pos1+1];
}
}
PT_3D ptAnother;
if ( FindAnotherNearestPt(ptIntersect,&ptAnother) )
{
// 计算相对位置
PT_3D dirPts[3];
dirPts[0] = ptAnother;
dirPts[1] = ptIntersect;
dirPts[2] = ptDir;
int dir = GraphAPI::GIsClockwise(dirPts,3);
// 调整
if ( (dir == TRUE && ptIntersect.z < ptAnother.z) || (dir == FALSE && ptIntersect.z > ptAnother.z))
{
if (fabs(pos) <= 1e-4)
{
ptDir.x = 2*arrPts[0].x - arrPts[1].x;
ptDir.y = 2*arrPts[0].y - arrPts[1].y;
ptDir.z = 2*arrPts[0].z - arrPts[1].z;
}
else
{
int prePos = ceil(pos-1);
if (prePos >= 0 && prePos < size)
{
ptDir = arrPts[ceil(pos-1)];
}
}
}
}
PT_3DEX arrText[2];
arrText[0] = PT_3DEX(ptIntersect,penLine);
arrText[1] = PT_3DEX(ptDir,penLine);
// 创建文本
//CFeature *pNewFtr = MarkText(arrText,2,arrPts[0].z);
//return pNewFtr;
CDlgDataSource *pDS = GETDS(m_pEditor);
if (!pDS) return NULL;
CString strLayerName = m_strTextLayerCode;
CFtrLayer *pFtrLay = pDS->GetFtrLayer(strLayerName);
if (pFtrLay == NULL)
{
pFtrLay = pDS->CreateFtrLayer(strLayerName);
if (!pFtrLay) return NULL;
pFtrLay->SetColor(RGB(255,0,0));
pDS->AddFtrLayer(pFtrLay);
}
CFeature *pTextFtr = pFtrLay->CreateDefaultFeature(pDS->GetScale(),CLS_GEOTEXT);
if (pTextFtr)
{
CGeoText *pText = (CGeoText*)pTextFtr->GetGeometry();
if (pText)
{
pText->SetColor(COLOUR_BYLAYER/*RGB(255,255,255)*/);
pText->CreateShape(arrText,2);
CString strFormat, str;
strFormat.Format(_T("%%.%df"), m_nDigitNum);
str.Format(strFormat,arrPts[0].z);
pText->SetText(str);
m_sTxtSettings.nAlignment = TAH_MID|TAV_MID;
m_sTxtSettings.nPlaceType = byLineH;
pText->SetSettings(&m_sTxtSettings);
pText->m_nCoverType = m_nTextCoverType;
pText->m_fExtendDis = m_fExtendDis;
TextSettings set;
set.CopyFrom(&m_sTxtSettings);
double ex[4], ey[4];
g_Fontlib.SetSettings(&set);
g_Fontlib.GetEnvlope(str,ex,ey);
double len = sqrt((ex[1]-ex[0])*(ex[1]-ex[0])+(ey[1]-ey[0])*(ey[1]-ey[0]))*pDS->GetSymbolDrawScale();
double len1 = GraphAPI::GGet2DDisOf2P(arrText[0],arrText[1]);
double a = (len/2)/len1;
// 修正，相交点为文字的中点
PT_3DEX arrTextNew[2];
arrTextNew[1].x = arrText[0].x + (arrText[1].x - arrText[0].x) * a;
arrTextNew[1].y = arrText[0].y + (arrText[1].y - arrText[0].y) * a;
arrTextNew[1].z = arrText[0].z + (arrText[1].z - arrText[0].z) * a;
arrTextNew[1].pencode = penLine;
arrTextNew[0].x = 2 * arrText[0].x - arrTextNew[1].x;
arrTextNew[0].y = 2 * arrText[0].y - arrTextNew[1].y;
arrTextNew[0].z = 2 * arrText[0].z - arrTextNew[1].z;
arrTextNew[0].pencode = penLine;
memcpy(arrText,arrTextNew,sizeof(PT_3DEX)*2);
{
PT_3DEX pt = arrText[1];
PT_3DEX ret = pt;
double dis = GraphAPI::GGetNearstDisPToPointSet2D(arrPts.GetData(),arrPts.GetSize(),pt,ret,NULL);
if (dis < DBL_MAX)
{
COPY_2DPT(arrText[1],ret);
}
pText->CreateShape(arrText,2);
}
int layid = pFtrLay->GetID();
m_pEditor->AddObject(pTextFtr,layid);
}
}
return pTextFtr;
}
BOOL CContourTextCommand::FindAnotherNearestPt(PT_3D pt, PT_3D *ret)
{
CDlgDataQuery* pQuery = (CDlgDataQuery*)PDOC(m_pEditor)->GetDataQuery();
CDlgDataQuery::FilterFeatureItem oldItem;
CDlgDataQuery::FilterFeatureItem newItem((CSearcherFilter*)this, (PFilterFunc)&CContourTextCommand::FilterFeature);
oldItem = pQuery->SetFilterFeature(newItem);
PT_3D cltPt;
(m_pEditor->GetCoordWnd()).m_pSearchCS->GroundToClient(&pt,&cltPt);
CFeature *pFindFtr = NULL;
double r;
int nObj = ((CDlgDataQuery*)(PDOC(m_pEditor)->GetDataQuery()))->FindNearestObjectByObjNum(cltPt,2,m_pEditor->GetCoordWnd().m_pSearchCS,FALSE,&r);
if( nObj>=2 )
{
const CPFeature *ftr = PDOC(m_pEditor)->GetDataQuery()->GetFoundHandles(nObj);
double fMinLen = -1;
for (int i=0; i<nObj; i++)
{
if (ftr[i] != m_pCurFtr)
{
CArray<PT_3DEX,PT_3DEX> arr;
ftr[i]->GetGeometry()->GetShape(arr);
PT_3DEX ret0;
double dis = GraphAPI::GGetNearstDisPToPointSet2D(arr.GetData(),arr.GetSize(),PT_3DEX(pt,penMove),ret0,NULL);
if (fMinLen < 0 || dis < fMinLen)
{
if (ret)
{
*ret = ret0;
}
pFindFtr = ftr[i];
fMinLen = dis;
}
}
}
}
pQuery->SetFilterFeature(oldItem);
return pFindFtr!=NULL?TRUE:FALSE;
}
CFeature* CContourTextCommand::MarkText(PT_3DEX *pts, int num, float height)
{
CDlgDataSource *pDS = GETDS(m_pEditor);
if (!pDS) return FALSE;
CString strLayerName = m_strTextLayerCode;
CFtrLayer *pFtrLay = pDS->GetFtrLayer(strLayerName);
if (pFtrLay == NULL)
{
pFtrLay = pDS->CreateFtrLayer(strLayerName);
if (!pFtrLay) return FALSE;
pFtrLay->SetColor(RGB(255,0,0));
pDS->AddFtrLayer(pFtrLay);
}
CFeature *pTextFtr = pFtrLay->CreateDefaultFeature(pDS->GetScale(),CLS_GEOTEXT);
if (pTextFtr)
{
CGeoText *pText = (CGeoText*)pTextFtr->GetGeometry();
if (pText)
{
pText->SetColor(RGB(255,255,255));
pText->CreateShape(pts,num);
CString strFormat, str;
strFormat.Format(_T("%%.%df"), m_nDigitNum);
str.Format(strFormat,height);
pText->SetText(str);
m_sTxtSettings.nAlignment = TAH_MID|TAV_MID;
m_sTxtSettings.nPlaceType = byLineH;
pText->SetSettings(&m_sTxtSettings);
int layid = pFtrLay->GetID();
m_pEditor->AddObject(pTextFtr,layid);
}
}
return pTextFtr;
}
void CContourTextCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
if( m_nStep==0 )
{
if(m_nMode==modeLinesection)
{
m_ptDragStart = pt;
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
}
else if (m_nMode == modeSinglePoint)
{
if( (flag&SELSTAT_POINTSEL)==0 && (flag&SELSTAT_DRAGSEL)==0 )
return;
m_ptDragStart = pt;
int nsel;
const FTR_HANDLE * handles = m_pEditor->GetSelection()->GetSelectedObjs(nsel);
if( nsel!=1 )
return;
m_idContour = handles[0];
CGeometry *pObj = HandleToFtr(m_idContour)->GetGeometry();
//不是等高线
if( !CModifyZCommand::CheckObjForContour(pObj) )
{
m_pEditor->UIRequest(UIREQ_TYPE_OUTPUTMSG, (LONG_PTR)(LPCTSTR)StrFromResID(IDS_CMDTIP_NOTCONTOUR));
return;
}
if (pObj->GetDataPointSum()==1)
{
return;
}
m_pEditor->CloseSelector();
GotoState(PROCSTATE_PROCESSING);
m_nStep = 2;
}
}
else if (m_nStep==1)
{
m_nStep = 2;
}
if( m_nStep==2 )
{
if (m_nMode == modeLinesection)
{
m_pEditor->UpdateDrag(ud_SetVariantDrag,NULL);
m_ptDragEnd = pt;
PT_3D Pt[2];
(m_pEditor->GetCoordWnd()).m_pSearchCS->GroundToClient(&m_ptDragStart,Pt);
(m_pEditor->GetCoordWnd()).m_pSearchCS->GroundToClient(&m_ptDragEnd,Pt+1);
Envelope el;
el.CreateFromPts(Pt,2);
m_pEditor->GetDataQuery()->FindObjectInRect(el,(m_pEditor->GetCoordWnd()).m_pSearchCS);
int num1 ;
const CPFeature *ftr = (m_pEditor->GetDataQuery())->GetFoundHandles(num1);
CArray<CFeature*,CFeature*> arrFtrs;
for (int i=0; i<num1; i++)
{
arrFtrs.Add(ftr[i]);
}
CDlgDataSource *pDS = GETDS(m_pEditor);
if (!pDS)
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
for(i=0; i<num1; i++)
{
m_pCurFtr = arrFtrs[i];
CGeometry *pObj = (CGeoCurve*)m_pCurFtr->GetGeometry();
if( !pObj )continue;
if( pObj->IsKindOf(RUNTIME_CLASS(CGeoPoint)) || pObj->IsKindOf(RUNTIME_CLASS(CGeoText)) )continue;
if( !CModifyZCommand::CheckObjForContour(pObj) )continue;
if( !CAutoLinkContourCommand::CheckObjForLayerCode(GETDS(m_pEditor),m_pCurFtr,(LPCTSTR)m_strContourLayerCode) )
continue;
CFeature *pNewFtr = CreateText();
if (pNewFtr)
{
undo.AddNewFeature(FtrToHandle(pNewFtr));
}
}
undo.Commit();
Finish();
m_nStep = 3;
}
else if (m_nMode == modeSinglePoint)
{
// 转化为两点
// m_ptDragStart.y -= 5;
// m_ptDragEnd = m_ptDragStart;
// m_ptDragEnd.y += 10;
CUndoFtrs undo(m_pEditor,Name());
m_pCurFtr = HandleToFtr(m_idContour);
CFeature *pNewFtr = CreateText();
if (pNewFtr)
{
undo.AddNewFeature(FtrToHandle(pNewFtr));
}
undo.Commit();
Finish();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
m_nStep = 3;
}
}
CEditCommand::PtClick(pt,flag);
}
void CContourTextCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (long)(m_nMode);
tab.AddValue(PF_CONTOURTEXT_WAY,&CVariantEx(var));
var = (_bstr_t)(m_strContourLayerCode);
tab.AddValue(PF_CONTOURCODE,&CVariantEx(var));
var = (_bstr_t)(m_strTextLayerCode);
tab.AddValue(PF_CONTOURTEXTCODE,&CVariantEx(var));
var = (long)(m_nDigitNum);
tab.AddValue(PF_CONTOURDIGITNUM,&CVariantEx(var));
var = (_bstr_t)(m_sTxtSettings.strFontName);
tab.AddValue(PF_FONT,&CVariantEx(var));
var = (double)(m_sTxtSettings.fHeight);
tab.AddValue(PF_CHARH,&CVariantEx(var));
var = (_variant_t)(long)(m_nTextCoverType);//是否压盖
tab.AddValue(PF_GEOCOVERTYPE,&CVariantEx(var));
var = (_variant_t)(long)(m_fExtendDis);//压盖扩展
tab.AddValue(PF_EXTENDDIS,&CVariantEx(var));
}
int CContourTextCommand::FindIndex(const CStringArray &arrStr,CString str)
{
for (int i= 0;i<arrStr.GetSize();i++)
{
if(strcmp((LPCTSTR)arrStr[i],(LPCTSTR)str)==0)
return i;
}
return -1;
}
void CContourTextCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("ContourTextCommand",Name());
param->BeginOptionParam(PF_CONTOURTEXT_WAY,StrFromResID(IDS_CMDPLANE_BY));
param->AddOption(StrFromResID(IDS_CMDPLANE_SINGLEPT),0,' ',m_nMode==modeSinglePoint);
param->AddOption(StrFromResID(IDS_CMDPLANE_LINESECTION),1,' ',m_nMode==modeLinesection);
param->EndOptionParam();
if (m_nMode == modeLinesection || bForLoad)
{
param->AddLayerNameParam(PF_CONTOURCODE,LPCTSTR(m_strContourLayerCode),StrFromResID(IDS_CMDPLANE_CONTOURLAYER));
}
param->AddLayerNameParam(PF_CONTOURTEXTCODE,LPCTSTR(m_strTextLayerCode),StrFromResID(IDS_CMDPLANE_HPC));
param->AddParam(PF_CONTOURDIGITNUM,int(m_nDigitNum),StrFromResID(IDS_CMDPLANE_DIGITNUM));
param->AddFontNameParam(PF_FONT,m_sTxtSettings.strFontName,StrFromResID(IDS_CMDPLANE_FONT));
param->AddParam(PF_CHARH,(double)m_sTxtSettings.fHeight,StrFromResID(IDS_CMDPLANE_CHARH));
//文字压盖
param->BeginOptionParam(PF_GEOCOVERTYPE,StrFromResID(IDS_CMDPLANE_GEOCOVERTYPE));
param->AddOption(StrFromResID(IDS_COVERTYPE_NONE),COVERTYPE_NONE,' ',m_nTextCoverType==COVERTYPE_NONE);
param->AddOption(StrFromResID(IDS_COVERTYPE_RECT),COVERTYPE_RECT,' ',m_nTextCoverType==COVERTYPE_RECT);
param->AddOption(StrFromResID(IDS_COVERTYPE_CIRCLE),COVERTYPE_CIRCLE,' ',m_nTextCoverType==COVERTYPE_CIRCLE);
param->EndOptionParam();
param->AddParam(PF_EXTENDDIS,(double)m_fExtendDis,StrFromResID(IDS_CMDPLANE_GEOEXTENDDISTANCE));
}
void CContourTextCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
// bool bNeedRefresh = false;
if( tab.GetValue(0,PF_CONTOURTEXT_WAY,var) )
{
m_nMode = (long)(_variant_t)*var;
SetSettingsModifyFlag();
if (!bInit)
{
Abort();
return;
}
}
if( tab.GetValue(0,PF_CONTOURCODE,var) )
{
m_strContourLayerCode = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_CONTOURTEXTCODE,var) )
{
m_strTextLayerCode = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_CONTOURDIGITNUM,var) )
{
m_nDigitNum = (long)(_variant_t)*var;
if (m_nDigitNum < 1)
{
m_nDigitNum = 1;
AfxMessageBox(IDS_PARAM_ERROR);
return;
}
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_FONT,var) )
{
CString temp = (LPCTSTR)(_bstr_t)(_variant_t)*var;
strncpy(m_sTxtSettings.strFontName,temp,sizeof(m_sTxtSettings.strFontName)-1);
TextStyle style = GetUsedTextStyles()->GetTextStyleByName(temp);
if( style.IsValid() )
{
m_sTxtSettings.fWidScale = style.fWidScale;
m_sTxtSettings.nInclineType = style.nInclineType;
m_sTxtSettings.fInclineAngle = style.fInclinedAngle;
m_sTxtSettings.SetBold(style.bBold);
}
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_CHARH,var) )
{
m_sTxtSettings.fHeight = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if (tab.GetValue(0,PF_GEOCOVERTYPE,var))
{
m_nTextCoverType = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_EXTENDDIS,var) )
{
m_fExtendDis = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CNumberTextCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CNumberTextCommand,CDrawCommand)
CNumberTextCommand::CNumberTextCommand()
{
m_pFtr = NULL;
m_bDrag = FALSE;
m_pSel = NULL;
m_nNumber = 1;
}
CNumberTextCommand::~CNumberTextCommand()
{
if (m_pFtr)
{
delete m_pFtr;
}
if(m_pSel)
delete m_pSel;
}
CString CNumberTextCommand::Name()
{
return StrFromResID(IDS_CMDNAME_NUMBERTEXT);
}
void CNumberTextCommand::Start()
{
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
if(!pLayer) return;
m_pFtr = pLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOTEXT);
if(!m_pFtr) return;
m_pEditor->CloseSelector();
m_nNumber = 1;
LOGFONT logfont;
logfont.lfCharSet = DEFAULT_CHARSET;
strcpy(logfont.lfFaceName,"");
HDC hDC = ::CreateCompatibleDC(NULL);
::EnumFontFamiliesEx(hDC,&logfont,
(FONTENUMPROC)EnumFontFamProc,(LPARAM)&m_arrFont,0);
::DeleteDC(hDC);
CDrawCommand::Start();
m_pSel = new CPermanentExchanger(m_pFtr);
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
void CNumberTextCommand::RefreshPropertiesPanel()
{
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
}
DrawingInfo CNumberTextCommand::GetCurDrawingInfo()
{
if (!m_pFtr)return DrawingInfo();
CArray<PT_3DEX,PT_3DEX> arr;
m_pFtr->GetGeometry()->GetShape(arr);
return DrawingInfo(m_pFtr,arr);
}
void CNumberTextCommand::Abort()
{
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
if(m_pFtr)
{
delete m_pFtr;
m_pFtr = NULL;
}
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
CDrawCommand::Abort();
}
void CNumberTextCommand::Back()
{
CDrawCommand::Back();
}
CFtrLayer *CNumberTextCommand::GetLayer(LPCTSTR fid)
{
CDlgDoc *pDoc = (CDlgDoc*)(m_pEditor);
CFtrLayer *pLayer = NULL;
if( fid!=NULL )
pLayer = pDoc->GetDlgDataSource()->GetFtrLayer(fid);
if( pLayer==NULL )
{
pLayer = new CFtrLayer();
pLayer->SetName(fid);
pDoc->AddFtrLayer(pLayer);
}
return pLayer;
}
void CNumberTextCommand::FinishObject()
{
if (m_pEditor)
{
CFtrLayer *pLayer = GetLayer(m_strLayerCode);
if( !AddObject(m_pFtr,pLayer->GetID()) )
{
Abort();
return;
}
CUndoFtrs undo(m_pEditor,Name());
undo.arrNewHandles.Add(FtrToHandle(m_pFtr));
undo.Commit();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
if(m_pSel)
{
delete m_pSel;
m_pSel = NULL;
}
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)NULL);
}
void CNumberTextCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pFtr || GetState()==PROCSTATE_FINISHED )return;
if( m_strLayerCode.IsEmpty() )
{
GOutPut(StrFromResID(IDS_PARAM_ERROR));
return;
}
m_strText.Format("%d",m_nNumber);
((CGeoText*)m_pFtr->GetGeometry())->SetText(m_strText);
((CGeoText*)m_pFtr->GetGeometry())->SetSettings(&m_sTxtSettings);
//如果文本内容为空，则return;
CString str=((CGeoText*)m_pFtr->GetGeometry())->GetText();
if(str.IsEmpty())
{
GOutPut(StrFromResID(IDS_PARAM_ERROR));
return;
}
//获得文本设置选项
TEXT_SETTINGS0 settings;
((CGeoText*)m_pFtr->GetGeometry())->GetSettings(&settings);
CArray<PT_3DEX,PT_3DEX> arr;
m_pFtr->GetGeometry()->GetShape(arr);
PT_3DEX t;
t.x = pt.x;
t.y = pt.y;
t.z = pt.z;
t.pencode= penLine;
arr.Add(t);
m_pFtr->GetGeometry()->CreateShape(arr.GetData(),arr.GetSize());
FinishObject();
m_pFtr = NULL;
CFtrLayer *pLayer = GETCURFTRLAYER(m_pEditor);
if(!pLayer) return;
m_pFtr = pLayer->CreateDefaultFeature(GETCURSCALE(m_pEditor),CLS_GEOTEXT);
if(!m_pFtr) return;
m_nNumber++;
SetSettingsModifyFlag();
m_pEditor->UIRequest(UIREQ_TYPE_SAVEFILEPARAM,0);
CUIParam param;
FillShowParams(¶m);
m_pEditor->UIRequest(UIREQ_TYPE_SHOWUIPARAM, (LONG_PTR)¶m);
m_pSel = new CPermanentExchanger(m_pFtr);
AfxGetMainWnd()->SendMessage(FCCM_MODIFY_PROPERTY_UI,0,(LPARAM)m_pSel);
return;
}
void CNumberTextCommand::PtMove(PT_3D &pt)
{
CDrawCommand::PtMove(pt);
}
void CNumberTextCommand::PtReset(PT_3D &pt)
{
Abort();
}
int CNumberTextCommand::FindIndex(const CStringArray &arrStr,CString str)
{
for (int i= 0;i<arrStr.GetSize();i++)
{
if(strcmp((LPCTSTR)arrStr[i],(LPCTSTR)str)==0)
return i;
}
return -1;
}
void CNumberTextCommand::GetParams(CValueTable &tab)
{
CDrawCommand::GetParams(tab);
_variant_t var;
var = (long)(m_nNumber);
tab.AddValue("Number",&CVariantEx(var));
var = (LPCTSTR)(m_strLayerCode);
tab.AddValue("PlaceLayer",&CVariantEx(var));
var = (_variant_t)(m_sTxtSettings.strFontName);
tab.AddValue(PF_FONT,&CVariantEx(var));
var = (double)(m_sTxtSettings.fHeight);
tab.AddValue(PF_CHARH,&CVariantEx(var));
var = (_variant_t)(long)(m_sTxtSettings.nAlignment);
tab.AddValue(PF_ALIGNTYPE,&CVariantEx(var));
}
void CNumberTextCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("NumberTextCommand",Name());
param->AddParam("Number",(long)m_nNumber,StrFromResID(IDS_PLANENAME_CURNUMBER));
param->AddLayerNameParam("PlaceLayer",(LPCTSTR)m_strLayerCode,StrFromResID(IDS_PLANENAME_PLACELAYER));
param->AddFontNameParam(PF_FONT,(LPCTSTR)m_sTxtSettings.strFontName,StrFromResID(IDS_CMDPLANE_FONT));
param->AddParam(PF_CHARH,(double)m_sTxtSettings.fHeight,StrFromResID(IDS_CMDPLANE_CHARH));
param->BeginOptionParam(PF_ALIGNTYPE,StrFromResID(IDS_CMDPLANE_ALIGNTYPE));
param->AddOption(StrFromResID(IDS_TEXTALIGNLT),TAH_LEFT|TAV_TOP,' ',m_sTxtSettings.nAlignment==(TAH_LEFT|TAV_TOP));
param->AddOption(StrFromResID(IDS_TEXTALIGNMT),TAH_MID|TAV_TOP,' ',m_sTxtSettings.nAlignment==(TAH_MID|TAV_TOP));
param->AddOption(StrFromResID(IDS_TEXTALIGNRT),TAH_RIGHT|TAV_TOP,' ',m_sTxtSettings.nAlignment==(TAH_RIGHT|TAV_TOP));
param->AddOption(StrFromResID(IDS_TEXTALIGNLM),TAH_LEFT|TAV_MID,' ',m_sTxtSettings.nAlignment==(TAH_LEFT|TAV_MID));
param->AddOption(StrFromResID(IDS_TEXTALIGNMM),TAH_MID|TAV_MID,' ',m_sTxtSettings.nAlignment==(TAH_MID|TAV_MID));
param->AddOption(StrFromResID(IDS_TEXTALIGNRM),TAH_RIGHT|TAV_MID,' ',m_sTxtSettings.nAlignment==(TAH_RIGHT|TAV_MID));
param->AddOption(StrFromResID(IDS_TEXTALIGNLB),TAH_LEFT|TAV_BOTTOM,' ',m_sTxtSettings.nAlignment==(TAH_LEFT|TAV_BOTTOM));
param->AddOption(StrFromResID(IDS_TEXTALIGNMB),TAH_MID|TAV_BOTTOM,' ',m_sTxtSettings.nAlignment==(TAH_MID|TAV_BOTTOM));
param->AddOption(StrFromResID(IDS_TEXTALIGNRB),TAH_RIGHT|TAV_BOTTOM,' ',m_sTxtSettings.nAlignment==(TAH_RIGHT|TAV_BOTTOM));
param->EndOptionParam();
}
void CNumberTextCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"Number",var) )
{
m_nNumber = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"PlaceLayer",var) )
{
m_strLayerCode = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_FONT,var) )
{
CString strFont = (LPCTSTR)(_bstr_t)(_variant_t)*var;
strcpy(m_sTxtSettings.strFontName,strFont);
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_CHARH,var) )
{
m_sTxtSettings.fHeight = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_ALIGNTYPE,var) )
{
m_sTxtSettings.nAlignment = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
CDrawCommand::SetParams(tab,bInit);
}
//////////////////////////////////////////////////////////////////////
// CAutoAdjustParallelCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CAutoAdjustParallelCommand,CEditCommand)
CAutoAdjustParallelCommand::CAutoAdjustParallelCommand()
{
}
CAutoAdjustParallelCommand::~CAutoAdjustParallelCommand()
{
}
CString CAutoAdjustParallelCommand::Name()
{
return StrFromResID(IDS_CMDNAME_ADJUST_CL);
}
void CAutoAdjustParallelCommand::PtMove(PT_3D &pt)
{
}
void CAutoAdjustParallelCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CAutoAdjustParallelCommand::Abort()
{
UpdateParams(TRUE);
m_nStep = -1;
CEditCommand::Abort();
m_pEditor->DeselectAll();
m_pEditor->UpdateDrag(ud_ClearDrag);
}
void CAutoAdjustParallelCommand::Finish()
{
UpdateParams(TRUE);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->RefreshView();
CEditCommand::Finish();
}
void CAutoAdjustParallelCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (_bstr_t)(LPCTSTR)m_strParallelCode;
tab.AddValue(CADJUST_CL_PARA, &CVariantEx(var));
var = (_bstr_t)(LPCTSTR)m_strCenterLineCode;
tab.AddValue(CADJUST_CL_CL, &CVariantEx(var));
}
void CAutoAdjustParallelCommand::SetParams(CValueTable& tab, BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,CADJUST_CL_PARA,var) )
{
m_strParallelCode = (const char*)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
if( tab.GetValue(0,CADJUST_CL_CL,var) )
{
m_strCenterLineCode = (const char*)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CAutoAdjustParallelCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID(_T("CAutoAdjustParallelCommand"),Name());
param->AddLayerNameParam(CADJUST_CL_PARA, m_strParallelCode, StrFromResID(IDS_PARALLEL_LAYER));
param->AddLayerNameParam(CADJUST_CL_CL, m_strCenterLineCode, StrFromResID(IDS_CENTER_LINE_LAYER));
}
void CAutoAdjustParallelCommand::PtClick(PT_3D &pt, int flag)
{
if( m_strParallelCode.IsEmpty() || m_strCenterLineCode.IsEmpty() ) return;
if( !m_pEditor )return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
//1.挑出所有与参数中层码对应的平行线地物
CFtrLayerArray para_layers;
pDS->GetFtrLayersByNameOrCode(m_strParallelCode,para_layers);
int num = para_layers.GetSize();
if(num <= 0 ) return;
CFtrArray paraObjs;
for(int i = 0; i < num; i++)
{
CFtrLayer *pLayer = para_layers.GetAt(i);
if(!pLayer||!pLayer->IsVisible())
continue;
int nObj = pLayer->GetObjectCount();
for (int j=0;j<nObj;j++)
{
CFeature *pFtr = pLayer->GetObject(j);
if (!pFtr||!pFtr->IsVisible())
continue;
if( !pFtr->GetGeometry()->IsKindOf(RUNTIME_CLASS(CGeoParallel)) )
continue;
paraObjs.Add( pFtr );
}
}
//2.在平行线附近搜索符合条件的中心线
int n = paraObjs.GetSize();
CUndoFtrs undo(m_pEditor, "Adjust CenterLine");
GProgressStart(n);
for(i = 0; i < n; i++)
{
GProgressStep();
CFeature* pFtr = paraObjs.GetAt(i);
if(!pFtr) continue;
CFeature* pCenterLine = NULL;
if( !IsCenterLineValid(pFtr, pCenterLine) ) continue;
//3.删除找到的中心线，生成新的中心线
CGeoParallel *pGeo = (CGeoParallel*)pFtr->GetGeometry();
if( !pGeo ) continue;
CGeoCurve *pNewGeo = pGeo->GetCenterlineCurve();
if( !pNewGeo ) continue;
// long col = pCenterLine->GetGeometry()->GetColor();
// pNewGeo->SetColor( col );
CFeature* pNew_CL = pCenterLine->Clone();
if( !pNew_CL ) continue;
pNew_CL->SetGeometry(pNewGeo);
CValueTable table;
table.BeginAddValueItem();
pCenterLine->WriteTo(table);
table.EndAddValueItem();
table.DelField(FIELDNAME_SHAPE);
table.DelField(FIELDNAME_GEOCURVE_CLOSED);
table.DelField(FIELDNAME_FTRID);
table.DelField(FIELDNAME_GEOCLASS);
table.DelField(FIELDNAME_GEOTEXT_CONTENT);
table.DelField(FIELDNAME_FTRDISPLAYORDER);
pNew_CL->ReadFrom(table);
if( m_pEditor->AddObject( pNew_CL, m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(pCenterLine))) )
{
GETXDS(m_pEditor)->CopyXAttributes(pCenterLine,pNew_CL);
undo.AddNewFeature(FtrToHandle( pNew_CL ));
}
if( m_pEditor->DeleteObject( FtrToHandle(pCenterLine)) )
undo.AddOldFeature(FtrToHandle( pCenterLine ));
}
GProgressEnd();
undo.DelInvalidUndoInfo();
undo.Commit();
Finish();
}
BOOL CAutoAdjustParallelCommand::IsCenterLineValid(CFeature* pFtr, CFeature*& pCenterLine)
{
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
CDataSourceEx *pDS = m_pEditor->GetDataSource();
//1.算出平行线上所有点的坐标
CArray<PT_3DEX,PT_3DEX> arrPts;
CGeometry* pGeo = pFtr->GetGeometry();
if(!pGeo)
return FALSE;
pGeo->GetShape( arrPts );
int npt = arrPts.GetSize();
if( npt < 2 )
return FALSE;
PT_3DEX* pts = new PT_3DEX[ npt ];
double width = ((CGeoParallel*)pGeo)->GetWidth();
GraphAPI::GGetParallelLine(arrPts.GetData(), npt, width, pts);
for(int k = npt-1; k >= 0; k--)
{
arrPts.Add( pts[k] );
}
delete [] pts;
//2.搜索中心线
Envelope e;
e.CreateFromPts( arrPts.GetData(), arrPts.GetSize(), sizeof(PT_3DEX) );
int n = pDQ->FindObjectInRect(e,NULL,FALSE,FALSE);
const CPFeature *ftrs = pDQ->GetFoundHandles(n);
CFtrArray Objs;
//3.排除不符合要求的
for(int i = 0; i < n; i++)
{
if( pFtr==ftrs[i] )
continue;
//比较层码
CFtrLayer* pLayer = pDS->GetFtrLayerOfObject( ftrs[i] );
CString strLayerName = pLayer->GetName();
__int64 id = -1;
CScheme *pScheme = gpCfgLibMan->GetScheme(pDS->GetScale());
if (pScheme)
{
CSchemeLayerDefine *p_app_layer = pScheme->GetLayerDefine( strLayerName );
if( p_app_layer )
id = p_app_layer->GetLayerCode();
}
CString strID;
strID.Format("%I64d", id);
if( 0 != m_strCenterLineCode.CompareNoCase( strID ) && 0 != m_strCenterLineCode.CompareNoCase(strLayerName) )
continue;
//判断包裹在平行线内的长度是否达80%
if( !IsMostWraped( ftrs[i], arrPts) )
continue;
Objs.Add( ftrs[i] );
}
//如果符合要求的有且只有一个，则取出这个中心线的指针
if( 1 == Objs.GetSize() )
{
pCenterLine = Objs.GetAt(0);
return TRUE;
}
return FALSE;
}
BOOL CAutoAdjustParallelCommand::IsMostWraped(CFeature* pLine, CArray<PT_3DEX,PT_3DEX>& para_pts)
{
//1.计算结的全长
CGeometry* pGeo = pLine->GetGeometry();
if(!pGeo) return FALSE;
const CShapeLine* pSL = pGeo->GetShape();
if(!pSL) return FALSE;
CArray<PT_3DEX,PT_3DEX> line_pts;
pSL->GetPts( line_pts );
int npt1 = line_pts.GetSize();
PT_3DEX* line_pts_copy = new PT_3DEX[npt1];
if(!line_pts_copy) return FALSE;
memcpy( line_pts_copy, line_pts.GetData(), npt1*sizeof(PT_3DEX) );
int m = GraphAPI::GKickoffSame2DPoints( line_pts_copy, npt1);
if(m < 2) return FALSE;
double all_len = GraphAPI::GGetAllLen2D( line_pts_copy, m);
if( all_len < 1e-4 ) return FALSE;
//2.计算被包裹的总长度
int npt2 = para_pts.GetSize();
PT_3DEX* para_pts_copy = new PT_3DEX[npt2];
if(!para_pts_copy) return FALSE;
memcpy( para_pts_copy, para_pts.GetData(), npt2*sizeof(PT_3DEX) );
int n = GraphAPI::GKickoffSame2DPoints( para_pts_copy, npt2);
double len_wraped = 0;
for(int i = 0; i < m-1; i++)
{
PT_3DEX p1 = line_pts_copy[i];
PT_3DEX p2 = line_pts_copy[i+1];
double len = GetWrapedLength(p1, p2, para_pts_copy, n);
len_wraped += len;
}
delete [] line_pts_copy;
delete [] para_pts_copy;
if( len_wraped/all_len > 0.8 )
return TRUE;
return FALSE;
}
double CAutoAdjustParallelCommand::GetWrapedLength(PT_3DEX p1, PT_3DEX p2, PT_3DEX* pts, int n)
{
if( n < 3 ) return 0;
CArray<double,double> idxs;
double len_sum = 0;
//算出线段与多边形的所有交点
for(int i = 0; i < n; i++)
{
PT_3DEX p3, p4;
p3 = pts[i];
if( i == n-1 )
p4 = pts[0];
else
p4 = pts[i+1];
double t = -1;
double x = 0, y = 0;
// if( GraphAPI::GGetLineIntersectLineSeg(p3.x, p3.y, p4.x, p4.y, p1.x, p1.y, p2.x, p2.y, &x, &y, &t) )
if( GraphAPI::GGetLineIntersectLineSeg(p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, p4.x, p4.y, &x, &y, &t) )
{
idxs.Add( t );
}
}
if( 2 == GraphAPI::GIsPtInRegion(p1, pts, n) )
idxs.Add( 0 );
if( 2 == GraphAPI::GIsPtInRegion(p2, pts, n) )
idxs.Add( 1 );
int num = idxs.GetSize();
if( num <= 0 ) return 0;
//将所有交点从左到右排序
double* pIdx = new double[num];
if(!pIdx) return 0;
memcpy( pIdx, idxs.GetData(), num*sizeof(double) );
for(i = 0; i < num-1; i++)
{
int min_idx = i;
for(int j = i+1; j < num; j++)
{
if( pIdx[j] < pIdx[i] )
min_idx = j;
}
double temp = pIdx[i];
pIdx[i] = pIdx[min_idx];
pIdx[min_idx] = temp;
}
//从左到右两两配对，若这一对的中点，在多边形内，则求出这一对之间的距离
for(i = 0; i < num-1; i++)
{
PT_3DEX ptS;
ptS.x = p1.x + pIdx[i]*(p2.x-p1.x);
ptS.y = p1.y + pIdx[i]*(p2.y-p1.y);
PT_3DEX ptE;
ptE.x = p1.x + pIdx[i+1]*(p2.x-p1.x);
ptE.y = p1.y + pIdx[i+1]*(p2.y-p1.y);
PT_3DEX ptMid;
ptMid.x = 0.5*(ptS.x + ptE.x);
ptMid.y = 0.5*(ptS.y + ptE.y);
if( 2 == GraphAPI::GIsPtInRegion(ptMid, pts, n) )
{
double len = GraphAPI::GGet2DDisOf2P(ptS, ptE);
len_sum += len;
}
i++;
}
delete [] pIdx;
return len_sum;
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CDoubleLinesToSurfaceCommand,CEditCommand)
CDoubleLinesToSurfaceCommand::CDoubleLinesToSurfaceCommand()
{
}
CDoubleLinesToSurfaceCommand::~CDoubleLinesToSurfaceCommand()
{
}
CString CDoubleLinesToSurfaceCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DLINE2SURFACE);
}
void CDoubleLinesToSurfaceCommand::Start()
{
if( !m_pEditor )return;
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
m_nStep = 0;
// m_idsOld.RemoveAll();
// m_idsNew.RemoveAll();
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
PtClick(pt,0);
return;
}
CEditCommand::Start();
}
void CDoubleLinesToSurfaceCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_targetLayer);
tab.AddValue(PF_LAYERNAME,&CVariantEx(var));
}
void CDoubleLinesToSurfaceCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("DoubleLinesToSurface",Name());
param->AddLayerNameParam(PF_LAYERNAME,(LPCTSTR)m_targetLayer,StrFromResID(IDS_CMDPLANE_SURFACELAYER),NULL,LAYERPARAMITEM_AREA);
}
void CDoubleLinesToSurfaceCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_LAYERNAME,var) )
{
m_targetLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_targetLayer.TrimRight();
m_targetLayer.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CDoubleLinesToSurfaceCommand::DoubleLineToSurface(const FTR_HANDLE* handles,int num)
{
CUndoFtrs undo(m_pEditor,Name());
CFtrLayer *pTargetLayer = m_pEditor->GetDataSource()->GetFtrLayer(m_targetLayer);
int layid = -1;
CFeature *pTemp = NULL;
if(pTargetLayer)
{
layid = pTargetLayer->GetID();
pTemp = pTargetLayer->CreateDefaultFeature(GETDS(m_pEditor)->GetScale(), CLS_GEOSURFACE);
}
for (int i=0;i<num;i++)
{
CGeometry *pGeo = HandleToFtr(handles[i])->GetGeometry();
if (!pGeo)
{
continue;
}
CGeometry* pObj1=NULL;
CGeometry* pObj2=NULL;
CArray<PT_3DEX,PT_3DEX> arrPts, pts;
if(pGeo->IsKindOf(RUNTIME_CLASS(CGeoDCurve)))
{
((CGeoDCurve*)pGeo)->Separate(pObj1, pObj2);
if(!pObj1 || !pObj2) continue;
pObj1->GetShape(arrPts);
pObj2->GetShape(pts);
PT_3DEX p1 = arrPts[0];
PT_3DEX p2 = pts[0];
PT_3DEX p3 = arrPts[arrPts.GetSize()-1];
PT_3DEX p4 = pts[pts.GetSize()-1];
double x,y,t0,t1;
bool bIntersect = GraphAPI::GGetLineIntersectLineSeg(p1.x,p1.y,
p2.x,p2.y,p3.x,p3.y,p4.x,p4.y,&x,&y,&t0,&t1);
for(int j=0; j<pts.GetSize(); j++)
{
if(bIntersect)
arrPts.Add(pts[j]);
else
arrPts.Add(pts[pts.GetSize()-1-j]);
}
}
else if(pGeo->IsKindOf(RUNTIME_CLASS(CGeoParallel)))
{
((CGeoParallel*)pGeo)->Separate(pObj1, pObj2);
if(!pObj1 || !pObj2) continue;
pObj1->GetShape(arrPts);
pObj2->GetShape(pts);
for(int j=0; j<pts.GetSize(); j++)
{
arrPts.Add(pts[j]);
}
}
else
{
continue;
}
arrPts.Add(arrPts[0]);
CFeature *pNew = NULL;
if(pTemp)
{
pNew = pTemp->Clone();
}
else
{
pNew = HandleToFtr(handles[i])->Clone();
if (!pNew) continue;
pNew->CreateGeometry(CLS_GEOSURFACE);
}
pNew->GetGeometry()->CreateShape(arrPts.GetData(),arrPts.GetSize());
if(layid==-1)
{
layid = m_pEditor->GetFtrLayerIDOfFtr(handles[i]);
}
if ( !m_pEditor->AddObject(pNew,layid) )
{
delete pNew;
continue;
}
if(layid == m_pEditor->GetFtrLayerIDOfFtr(handles[i]))
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(handles[i]),pNew);
undo.AddNewFeature(FTR_HANDLE(pNew));
undo.AddOldFeature(handles[i]);
m_pEditor->DeleteObject(handles[i]);
}
undo.Commit();
if(pTemp) delete pTemp;
}
void CDoubleLinesToSurfaceCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CSelection* pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE* handles = pSel->GetSelectedObjs(num);
DoubleLineToSurface(handles,num);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CDoubleLinesToSurfaceAllCommand,CEditCommand)
CDoubleLinesToSurfaceAllCommand::CDoubleLinesToSurfaceAllCommand()
{
}
CDoubleLinesToSurfaceAllCommand::~CDoubleLinesToSurfaceAllCommand()
{
}
CString CDoubleLinesToSurfaceAllCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DLINE2SURFACE);
}
void CDoubleLinesToSurfaceAllCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
m_nStep = 0;
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CDoubleLinesToSurfaceAllCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_handleLayers);
tab.AddValue(PF_HANDLELAYERS,&CVariantEx(var));
var = (LPCTSTR)(m_targetLayer);
tab.AddValue(PF_LAYERNAME,&CVariantEx(var));
}
void CDoubleLinesToSurfaceAllCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("DoubleLinesToSurfaceAll",Name());
param->AddLayerNameParamEx(PF_HANDLELAYERS,(LPCTSTR)m_handleLayers,StrFromResID(IDS_CMDPLANE_DOUBLELINELAYER),NULL,LAYERPARAMITEM_LINE);
param->AddLayerNameParamEx(PF_LAYERNAME,(LPCTSTR)m_targetLayer,StrFromResID(IDS_CMDPLANE_SURFACELAYER),NULL,LAYERPARAMITEM_AREA);
}
void CDoubleLinesToSurfaceAllCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_HANDLELAYERS,var) )
{
m_handleLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_handleLayers.TrimLeft();
m_handleLayers.TrimRight();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,PF_LAYERNAME,var) )
{
m_targetLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_targetLayer.TrimRight();
m_targetLayer.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CDoubleLinesToSurfaceAllCommand::ReadFileStrings()
{
if (!PathFileExists(m_handleLayers))
return;
FILE *fp = fopen(m_handleLayers, "r");
if (fp)
{
char line[4096];
int pos = 0;
while (!feof(fp))
{
memset(line, 0, sizeof(line));
fgets(line, sizeof(line) - 1, fp);
if (pos == 0)
{
m_handleLayers = CString(line);
m_handleLayers.TrimRight();
}
else if (pos == 1)
{
m_targetLayer = CString(line);
m_targetLayer.TrimRight();
}
pos++;
}
fclose(fp);
fp = NULL;
}
}
void CDoubleLinesToSurfaceAllCommand::PtClick(PT_3D &pt, int flag)
{
if(!m_pEditor) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
ReadFileStrings();
CFtrLayerArray arr;
CStringArray strs0, strs;
convertStringToStrArray(m_handleLayers, strs0);
convertStringToStrArray(m_targetLayer, strs);
int nSum=0, i, j;
for(i=0; i<strs0.GetSize(); i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayer(strs0[i]);
arr.Add(pLayer);
if(pLayer)
{
nSum += pLayer->GetObjectCount();
}
}
if(arr.GetSize()==0)
{
pDS->GetFtrLayersByNameOrCode_editable(m_handleLayers, arr);
for(i=0; i<arr.GetSize(); i++)
{
nSum += arr[i]->GetObjectCount();
}
}
CUndoFtrs undo(m_pEditor,Name());
GProgressStart(nSum);
for (i=0;i<arr.GetSize();i++)
{
CFtrLayer *pLayer = arr[i];
if(!pLayer) continue;
CFtrLayer *pStoreLayer = NULL;
if(strs.GetSize()==1)
{
if(strs[0].IsEmpty())
{
pStoreLayer = arr[i];
}
else
{
pStoreLayer = pDS->GetFtrLayer(strs[0]);
if(!pStoreLayer)
{
pStoreLayer = new CFtrLayer();
pStoreLayer->SetName(strs[0]);
pDS->AddFtrLayer(pStoreLayer);
}
}
}
else if(i<strs.GetSize() && !strs.GetAt(i).IsEmpty())
{
pStoreLayer = pDS->GetFtrLayer(strs[i]);
if(!pStoreLayer)
{
pStoreLayer = new CFtrLayer();
pStoreLayer->SetName(strs[i]);
pDS->AddFtrLayer(pStoreLayer);
}
}
else
{
pStoreLayer = arr[i];
}
if(!pStoreLayer) continue;
CFeature *pTemp = pStoreLayer->CreateDefaultFeature(pDS->GetScale(), CLS_GEOSURFACE);
int nObj = pLayer->GetObjectCount();
for(j=0; j<nObj; j++)
{
GProgressStep();
CFeature *pFeature = pLayer->GetObject(j);
if(!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo)
{
continue;
}
CGeometry* pObj1=NULL;
CGeometry* pObj2=NULL;
CArray<PT_3DEX,PT_3DEX> arrPts, pts;
if(pGeo->IsKindOf(RUNTIME_CLASS(CGeoDCurve)))
{
((CGeoDCurve*)pGeo)->Separate(pObj1, pObj2);
if(!pObj1 || !pObj2) continue;
pObj1->GetShape(arrPts);
pObj2->GetShape(pts);
PT_3DEX p1 = arrPts[0];
PT_3DEX p2 = pts[0];
PT_3DEX p3 = arrPts[arrPts.GetSize()-1];
PT_3DEX p4 = pts[pts.GetSize()-1];
double x,y,t0,t1;
bool bIntersect = GraphAPI::GGetLineIntersectLineSeg(p1.x,p1.y,
p2.x,p2.y,p3.x,p3.y,p4.x,p4.y,&x,&y,&t0,&t1);
for(int j=0; j<pts.GetSize(); j++)
{
if(bIntersect)
arrPts.Add(pts[j]);
else
arrPts.Add(pts[pts.GetSize()-1-j]);
}
}
else if(pGeo->IsKindOf(RUNTIME_CLASS(CGeoParallel)))
{
((CGeoParallel*)pGeo)->Separate(pObj1, pObj2);
if(!pObj1 || !pObj2) continue;
pObj1->GetShape(arrPts);
pObj2->GetShape(pts);
for(int j=0; j<pts.GetSize(); j++)
{
arrPts.Add(pts[j]);
}
}
else
{
continue;
}
arrPts.Add(arrPts[0]);
CFeature *pNew = pTemp->Clone();
if (!pNew) continue;
pNew->GetGeometry()->CreateShape(arrPts.GetData(),arrPts.GetSize());
if (!m_pEditor->AddObject(pNew, pStoreLayer->GetID()))
{
delete pNew;
continue;
}
if(pStoreLayer==arr[i])
GETXDS(m_pEditor)->CopyXAttributes(pFeature,pNew);
undo.AddNewFeature(FTR_HANDLE(pNew));
undo.AddOldFeature(FtrToHandle(pFeature));
m_pEditor->DeleteObject(FtrToHandle(pFeature));
}
if(pTemp) delete pTemp;
}
GProgressEnd();
undo.Commit();
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CReverseAssistlineCommand,CEditCommand)
CReverseAssistlineCommand::CReverseAssistlineCommand()
{
}
CReverseAssistlineCommand::~CReverseAssistlineCommand()
{
}
CString CReverseAssistlineCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DCURVEREVERSE);
}
void CReverseAssistlineCommand::Start()
{
if( !m_pEditor )return;
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
m_nStep = 0;
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
PtClick(pt,0);
return;
}
CEditCommand::Start();
}
void CReverseAssistlineCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CSelection* pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE* handles = pSel->GetSelectedObjs(num);
CUndoFtrs undo(m_pEditor,Name());
for( int i = num-1; i>=0; i--)
{
CGeometry* pObj = HandleToFtr(handles[i])->GetGeometry();
if( pObj && pObj->IsKindOf(RUNTIME_CLASS(CGeoDCurve)) )
{
CFeature *pFtr = HandleToFtr(handles[i])->Clone();
if(!pFtr) continue;
pFtr->SetID(OUID());
pObj = pFtr->GetGeometry();
if (!pObj) continue;
CArray<PT_3DEX,PT_3DEX> arr,arr1, arrnew;
((CGeoDCurve*)pObj)->GetBaseShape(arr);
((CGeoDCurve*)pObj)->GetAssistShape(arr1);
int ptsnum = arr1.GetSize();
PT_3DEX pt3dex = arr1[ptsnum-1];
pt3dex.pencode = penMove;
arrnew.Add(pt3dex);
pt3dex = arr1[ptsnum-1];
pt3dex.pencode = penNone;
arrnew.Add(pt3dex);
for(int j=2; j<ptsnum; j++)
{
pt3dex = arr1[ptsnum-j];
pt3dex.pencode = arr1[ptsnum-j+1].pencode;
arrnew.Add(pt3dex);
}
arr.Append(arrnew);
pObj->CreateShape(arr.GetData(),arr.GetSize());
if( !m_pEditor->AddObject(pFtr,m_pEditor->GetFtrLayerIDOfFtr(handles[i]) ))
{
delete pFtr;
Abort();
return;
}
GETXDS(m_pEditor)->CopyXAttributes(HandleToFtr(handles[i]),pFtr);
undo.arrNewHandles.Add(FtrToHandle(pFtr));
m_pEditor->DeleteObject(handles[i]);
undo.arrOldHandles.Add(handles[i]);
}
}
undo.Commit();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
((CDlgDoc*)m_pEditor)->UpdateAllViews(NULL,hc_Refresh,0);
Finish();
m_nStep = 2;
}
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CSurfaceToDoubleLinesCommand,CEditCommand)
CSurfaceToDoubleLinesCommand::CSurfaceToDoubleLinesCommand()
{
}
CSurfaceToDoubleLinesCommand::~CSurfaceToDoubleLinesCommand()
{
m_pos = 0;
}
CString CSurfaceToDoubleLinesCommand::Name()
{
return StrFromResID(IDS_CMDNAME_SURFACE2DCURVE);
}
void CSurfaceToDoubleLinesCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
m_nStep = 0;
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CSurfaceToDoubleLinesCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_handleLayers);
tab.AddValue(PF_HANDLELAYERS,&CVariantEx(var));
var = (long)(m_pos);
tab.AddValue("StartPos",&CVariantEx(var));
}
void CSurfaceToDoubleLinesCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("SurfaceToDoubleLines",Name());
param->AddLayerNameParamEx(PF_HANDLELAYERS,(LPCTSTR)m_handleLayers,StrFromResID(IDS_CMDPLANE_SURFACELAYER),NULL);
param->AddParam("StartPos",m_pos,StrFromResID(IDS_CMDPLANE_STARTPOS),NULL);
}
void CSurfaceToDoubleLinesCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,PF_HANDLELAYERS,var) )
{
m_handleLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_handleLayers.TrimLeft();
m_handleLayers.TrimRight();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"StartPos",var) )
{
m_pos = (long)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CSurfaceToDoubleLinesCommand::PtClick(PT_3D &pt, int flag)
{
if(!m_pEditor) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CFtrLayerArray arrLayers;
int i=0, j=0;
pDS->GetFtrLayersByNameOrCode_editable(m_handleLayers,arrLayers);
CUndoFtrs undo(m_pEditor,Name());
for (i=0;i<arrLayers.GetSize();i++)
{
CFtrLayer *pLayer = arrLayers[i];
int nObj = pLayer->GetObjectCount();
for(j=0; j<nObj; j++)
{
CFeature *pFeature = pLayer->GetObject(j);
if(!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
{
continue;
}
((CGeoSurface*)pGeo)->EnableFillColor(FALSE, 0);
CArray<PT_3DEX,PT_3DEX> arrPts, pts;
pGeo->GetShape(arrPts);
arrPts.RemoveAt(arrPts.GetSize()-1);//剔除闭合点
int npt = arrPts.GetSize();
if(m_pos<0 || m_pos>npt-1) continue;
int k=0;
for(k=0; k<npt; k++)
{
if(k==npt/2)
{
PT_3DEX temp = arrPts[(k+m_pos)%npt];
temp.pencode = penMove;
pts.Add(temp);
}
else
{
pts.Add(arrPts[(k+m_pos)%npt]);
}
}
CFeature *pNew = pFeature->Clone();
if (!pNew) continue;
if (!pNew->CreateGeometry(CLS_GEODCURVE)) continue;
pNew->GetGeometry()->CreateShape(pts.GetData(),pts.GetSize());
if (!m_pEditor->AddObject(pNew, m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(pFeature))))
{
delete pNew;
continue;
}
GETXDS(m_pEditor)->CopyXAttributes(pFeature,pNew);
m_pEditor->DeleteObject(FtrToHandle(pFeature));
undo.AddOldFeature(FtrToHandle(pFeature));
undo.AddNewFeature(FTR_HANDLE(pNew));
}
}
undo.Commit();
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// CMergeCurveFACommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CMergeCurveFACommand,CEditCommand)
CMergeCurveFACommand::CMergeCurveFACommand()
{
m_nStep = -1;
}
CMergeCurveFACommand::~CMergeCurveFACommand()
{
}
CString CMergeCurveFACommand::Name()
{
return StrFromResID(IDS_CMDNAME_MERGECURVEFA);
}
void CMergeCurveFACommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
}
void CMergeCurveFACommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_lineLayer1);
tab.AddValue("LineLayer1",&CVariantEx(var));
var = (LPCTSTR)(m_lineLayer2);
tab.AddValue("LineLayer2",&CVariantEx(var));
var = (LPCTSTR)(m_DCurveLayer);
tab.AddValue("DCurveLayer",&CVariantEx(var));
}
void CMergeCurveFACommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("MergeCurveFACommand",Name());
param->AddLayerNameParam("LineLayer1",(LPCTSTR)m_lineLayer1,StrFromResID(IDS_CMDPLANE_LINELAYER1));
param->AddLayerNameParam("LineLayer2",(LPCTSTR)m_lineLayer2,StrFromResID(IDS_CMDPLANE_LINELAYER2));
param->AddLayerNameParam("DCurveLayer",(LPCTSTR)m_DCurveLayer,StrFromResID(IDS_CMDPLANE_DCURVELAYER));
}
void CMergeCurveFACommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"LineLayer1",var) )
{
m_lineLayer1 = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_lineLayer1.TrimRight();
m_lineLayer1.TrimLeft();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"LineLayer2",var) )
{
m_lineLayer2 = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_lineLayer2.TrimRight();
m_lineLayer2.TrimLeft();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"DCurveLayer",var) )
{
m_DCurveLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_DCurveLayer.TrimRight();
m_DCurveLayer.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CMergeCurveFACommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
if(!pDQ) return;
if(m_lineLayer1.IsEmpty() || m_lineLayer2.IsEmpty() || m_DCurveLayer.IsEmpty())
return;
vector<FeaItem> container1, container2;
CFtrLayer *pLayer = pDS->GetFtrLayer(m_lineLayer1);
if(!pLayer) return;
int nObj = pLayer->GetObjectCount(), i;
for(i=0; i<nObj; i++)
{
CFeature *pFtr = pLayer->GetObject(i);
if(!pFtr) continue;
CGeometry *pObj = pFtr->GetGeometry();
if(!pObj) continue;
int nCls = pObj->GetClassType();
if(nCls==CLS_GEOCURVE)
{
FeaItem item;
item.pFtr = pFtr;
item.pObj = pObj;
item.sp = pObj->GetDataPoint(0);
int nSum = pObj->GetDataPointSum();
item.ep = pObj->GetDataPoint(nSum-1);
if(!GraphAPI::GIsEqual3DPoint(&item.sp, &item.ep))
{
pFtr->SetAppFlag(1);
container1.push_back(item);
}
}
}
pLayer = pDS->GetFtrLayer(m_lineLayer2);
if(!pLayer) return;
nObj = pLayer->GetObjectCount();
for(i=0; i<nObj; i++)
{
CFeature *pFtr = pLayer->GetObject(i);
if(!pFtr) continue;
CGeometry *pObj = pFtr->GetGeometry();
if(!pObj) continue;
int nCls = pObj->GetClassType();
if(nCls==CLS_GEOCURVE)
{
FeaItem item;
item.pFtr = pFtr;
item.pObj = pObj;
item.sp = pObj->GetDataPoint(0);
int nSum = pObj->GetDataPointSum();
item.ep = pObj->GetDataPoint(nSum-1);
if(!GraphAPI::GIsEqual3DPoint(&item.sp, &item.ep))
{
pFtr->SetAppFlag(1);
container2.push_back(item);
}
}
}
pLayer = pDS->GetFtrLayer(m_DCurveLayer);
if(!pLayer)
{
pLayer = pDS->CreateFtrLayer(m_DCurveLayer);
if(!pLayer) return;
pDS->AddFtrLayer(pLayer);
}
CFeature *pFtrTemp = pLayer->CreateDefaultFeature(pDS->GetScale(),CLS_GEODCURVE);
if (!pFtrTemp || !pFtrTemp->GetGeometry())
{
Abort();
return;
}
vector<FeaItem>::const_iterator it1,it2;
CUndoFtrs undo(m_pEditor, Name());
for(it1= container1.begin();it1<container1.end();it1++)
{
if((*it1).pFtr->GetAppFlag()==0) continue;
(*it1).pFtr->SetAppFlag(0);
for(it2= container2.begin();it2<container2.end();it2++)
{
if((*it2).pFtr->GetAppFlag()==0) continue;
if( (*it1).pFtr == (*it2).pFtr) continue;
BOOL bConnect = FALSE;
const PT_3DEX *pt1 = &(*it1).sp;
const PT_3DEX *pt2 = &(*it1).ep;
const PT_3DEX *pt3 = &(*it2).sp;
const PT_3DEX *pt4 = &(*it2).ep;
if(GraphAPI::GIsEqual2DPoint(pt1, pt3) && GraphAPI::GIsEqual2DPoint(pt2, pt4))
{
bConnect = TRUE;
}
if(GraphAPI::GIsEqual2DPoint(pt1, pt4) && GraphAPI::GIsEqual2DPoint(pt2, pt3))
{
bConnect = TRUE;
}
if(bConnect)
{
(*it2).pFtr->SetAppFlag(0);
CFeature *pFtr = pFtrTemp->Clone();
CGeometry *pGeo = pFtr->GetGeometry();
CArray<PT_3DEX,PT_3DEX> pts1, pts2;
(*it1).pObj->GetShape(pts1);
(*it2).pObj->GetShape(pts2);
pts2[0].pencode = penMove;
pts1.Append(pts2);
if (!pGeo->CreateShape(pts1.GetData(),pts1.GetSize()))
{
delete pFtr;
continue;
}
m_pEditor->AddObject(pFtr,pLayer->GetID());
undo.AddNewFeature(FtrToHandle(pFtr));
m_pEditor->DeleteObject(FtrToHandle((*it1).pFtr));
m_pEditor->DeleteObject(FtrToHandle((*it2).pFtr));
undo.AddOldFeature(FtrToHandle((*it1).pFtr));
undo.AddOldFeature(FtrToHandle((*it2).pFtr));
}
}
}
for(it2= container2.begin();it2<container2.end();it2++)
{
if( (*it2).pFtr )
{
(*it2).pFtr->SetAppFlag(0);
}
}
delete pFtrTemp;
undo.Commit();
Finish();
CEditCommand::PtClick(pt,flag);
}
IMPLEMENT_DYNCREATE(CSurfaceToDoubleLinesCommand_One,CEditCommand)
CSurfaceToDoubleLinesCommand_One::CSurfaceToDoubleLinesCommand_One()
{
m_pFtr = NULL;
}
CSurfaceToDoubleLinesCommand_One::~CSurfaceToDoubleLinesCommand_One()
{
}
CString CSurfaceToDoubleLinesCommand_One::Name()
{
return StrFromResID(IDS_CMDNAME_SURFACE2DCURVE_ONE);
}
void CSurfaceToDoubleLinesCommand_One::Start()
{
CEditCommand::Start();
m_pFtr = NULL;
m_nStep = 0;
}
void CSurfaceToDoubleLinesCommand_One::PtMove(PT_3D &pt)
{
if( m_nStep==1 )
{
m_ptEnd = pt;
CGeometry *pNewObj = Convert(m_pFtr->GetGeometry());
if(pNewObj!=NULL)
{
CGeoDCurve *pNewObj2 = (CGeoDCurve*)pNewObj;
CGeometry *pObj1 = NULL, *pObj2 = NULL;
pNewObj2->Separate(pObj1,pObj2);
if(pObj1)
{
GrBuffer buf;
pObj1->Draw(&buf);
buf.SetAllLineWidth(FALSE,3);
m_pEditor->UpdateDrag(ud_SetVariantDrag,&buf);
delete pObj1;
}
if(pObj2)
{
delete pObj2;
}
delete pNewObj;
}
}
}
void CSurfaceToDoubleLinesCommand_One::PtClick(PT_3D &pt, int flag)
{
if(m_nStep==0)
{
//得到目标地物
if( !CanGetSelObjs(flag,FALSE) )return;
FTR_HANDLE handle = m_pEditor->GetSelection()->GetLastSelectedObj();
m_pFtr = HandleToFtr(handle);
if(!m_pFtr) return;
CGeometry *pObj = m_pFtr->GetGeometry();
if(!pObj->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
return;
m_ptStart = pt;
m_nStep = 1;
GotoState(PROCSTATE_PROCESSING);
m_pEditor->CloseSelector();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
}
else if(m_nStep==1)
{
if(!m_pFtr) return;
m_ptEnd = pt;
CGeometry *pNewObj = Convert(m_pFtr->GetGeometry());
if( pNewObj!=NULL)
{
CFeature *pNewFtr = m_pFtr->Clone();
pNewFtr->SetGeometry(pNewObj);
m_pEditor->AddObject(pNewFtr,m_pEditor->GetDataSource()->GetFtrLayerOfObject(m_pFtr)->GetID());
GETXDS(m_pEditor)->CopyXAttributes(m_pFtr, pNewFtr);
m_pEditor->DeleteObject(FtrToHandle(m_pFtr));
CUndoFtrs undo(m_pEditor,Name());
undo.arrOldHandles.Add(FtrToHandle(m_pFtr));
undo.arrNewHandles.Add(FtrToHandle(pNewFtr));
undo.Commit();
Finish();
}
else
{
Abort();
}
m_pEditor->UpdateDrag(ud_ClearDrag);
return;
}
CEditCommand::PtClick(pt,flag);
}
CGeometry *CSurfaceToDoubleLinesCommand_One::Convert(CGeometry *pObj0)
{
CGeoSurface *pObj = (CGeoSurface *)pObj0;
int pt_index1 = pObj->FindNearestKeyCtrlPt(m_ptStart,1e+10,NULL,1).index;
int pt_index2 = pObj->FindNearestKeyCtrlPt(m_ptEnd,1e+10,NULL,1).index;
if(pt_index1<0 || pt_index2<0 )
return NULL;
CArray<int,int> arrPos;
pObj->GetShape()->GetKeyPosOfBaseLines(arrPos);
int pt_index11 = arrPos[pt_index1];
int pt_index22 = arrPos[pt_index2];
CArray<PT_3DEX,PT_3DEX> arrPts;
pObj->GetShape()->GetPts(arrPts);
double all_len = GraphAPI::GGetAllLen2D(arrPts.GetData(),arrPts.GetSize());
int index_min = min(pt_index11,pt_index22);
int index_max = max(pt_index11,pt_index22);
//取短的一部分
double part_len = GraphAPI::GGetAllLen2D(arrPts.GetData()+index_min,index_max-index_min);
if(part_len>all_len*0.5)
{
index_min = min(pt_index1,pt_index2);
index_max = max(pt_index1,pt_index2);
CArray<PT_3DEX,PT_3DEX> arrPts2;
pObj->GetShape(arrPts2);
if(pObj->IsClosed())
arrPts2.RemoveAt(arrPts2.GetSize()-1);
if(index_max>=arrPts2.GetSize())
return NULL;
int npt = arrPts2.GetSize();
CArray<PT_3DEX,PT_3DEX> arrPts3;
for(int i=index_max; i<=index_min+npt; i++)
{
arrPts3.Add(arrPts2[(i%npt)]);
}
for(i=index_min+1; i<index_max; i++)
{
arrPts3.Add(arrPts2[i]);
if( i==(index_min+1) )
{
arrPts3[arrPts3.GetSize()-1].pencode = penMove;
}
}
CGeometry *pNewObj = pObj->Clone();
pNewObj->CreateShape(arrPts3.GetData(),arrPts3.GetSize());
return pNewObj;
}
else
{
index_min = min(pt_index1,pt_index2);
index_max = max(pt_index1,pt_index2);
CArray<PT_3DEX,PT_3DEX> arrPts2;
pObj->GetShape(arrPts2);
if(pObj->IsClosed())
arrPts2.RemoveAt(arrPts2.GetSize()-1);
if(index_max>=arrPts2.GetSize())
return NULL;
int npt = arrPts2.GetSize();
CArray<PT_3DEX,PT_3DEX> arrPts3;
for(int i=index_min; i<=index_max; i++)
{
arrPts3.Add(arrPts2[i]);
}
for(i=index_max+1; i<index_min+npt; i++)
{
arrPts3.Add(arrPts2[(i%npt)]);
if( i==(index_max+1) )
{
arrPts3[arrPts3.GetSize()-1].pencode = penMove;
}
}
CGeometry *pNewObj = new CGeoDCurve();
pNewObj->CopyFrom(pObj);
pNewObj->CreateShape(arrPts3.GetData(),arrPts3.GetSize());
return pNewObj;
}
return NULL;
}
void CSurfaceToDoubleLinesCommand_One::Abort()
{
m_pEditor->UpdateDrag(ud_ClearDrag);
CEditCommand::Abort();
}
//////////////////////////////////////////////////////////////////////
// CDeleteBorderInVEGACommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDeleteBorderInVEGACommand,CEditCommand)
CDeleteBorderInVEGACommand::CDeleteBorderInVEGACommand()
{
m_nStep = -1;
}
CDeleteBorderInVEGACommand::~CDeleteBorderInVEGACommand()
{
}
CString CDeleteBorderInVEGACommand::Name()
{
return StrFromResID(IDS_CMDNAME_DEL_BORDER);
}
void CDeleteBorderInVEGACommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
}
void CDeleteBorderInVEGACommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_borderLayer);
tab.AddValue("BorderLayer",&CVariantEx(var));
var = (LPCTSTR)(m_VEGALayers);
tab.AddValue("VEGALayers",&CVariantEx(var));
}
void CDeleteBorderInVEGACommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("DeleteBorderInVEGA",Name());
param->AddLayerNameParamEx("BorderLayer",(LPCTSTR)m_borderLayer,StrFromResID(IDS_CMDPLANE_BOUNDALYER));
param->AddLayerNameParamEx("VEGALayers",(LPCTSTR)m_VEGALayers, StrFromResID(IDS_CMPPLANE_VEGALAYER));
}
void CDeleteBorderInVEGACommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"BorderLayer",var) )
{
m_borderLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_borderLayer.TrimRight();
m_borderLayer.TrimLeft();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"VEGALayers",var) )
{
m_VEGALayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_VEGALayers.TrimRight();
m_VEGALayers.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CDeleteBorderInVEGACommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
if(!pDQ) return;
if(m_borderLayer.IsEmpty() || m_VEGALayers.IsEmpty())
return;
CFtrArray arr1, arr2;
int i,j;
//地类界
CFtrLayerArray layers0;
pDS->GetFtrLayersByNameOrCode_editable(m_borderLayer,layers0);
for(i=0; i<layers0.GetSize(); i++)
{
int nObj1 = layers0[i]->GetObjectCount();
for(j=0; j<nObj1; j++)
{
CFeature *pFtr = layers0[i]->GetObject(j);
if(!pFtr || !pFtr->IsVisible()) continue;
arr1.Add(pFtr);
}
}
//植被
CFtrLayerArray layers1;
pDS->GetFtrLayersByNameOrCode_editable(m_VEGALayers,layers1);
for(i=0; i<layers1.GetSize(); i++)
{
int nObj1 = layers1[i]->GetObjectCount();
for(j=0; j<nObj1; j++)
{
CFeature *pFtr = layers1[i]->GetObject(j);
if(!pFtr || !pFtr->IsVisible()) continue;
CGeometry *pGeo = pFtr->GetGeometry();
if(pGeo && pGeo->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
arr2.Add(pFtr);
}
}
CUndoFtrs undo(m_pEditor, Name());
GProgressStart(arr1.GetSize());
for(i=0; i<arr1.GetSize(); i++)
{
GProgressStep();
PT_3DEX pt0, pt1, pt2;
CGeometry *pObj = arr1[i]->GetGeometry();
if(!pObj) continue;
int nPt = pObj->GetDataPointSum();
if(nPt<2) continue;
pt0 = pObj->GetDataPoint(0);
pt1 = pObj->GetDataPoint(nPt-1);
pt2 = pObj->GetDataPoint(1);
pt2.x = (pt0.x+pt2.x)/2;
pt2.y = (pt0.y+pt2.y)/2;
pt2.z = (pt0.z+pt2.z)/2;//pt2是第一段的终点
Envelope e = pObj->GetEnvelope();
for(j=0; j<arr2.GetSize(); j++)
{
CGeometry *pObj1 = arr2[j]->GetGeometry();
if(!pObj1) continue;
Envelope e1 = pObj1->GetEnvelope();
if(!e.bIntersect(&e1)) continue;
CArray<PT_3DEX,PT_3DEX> pts;
const CShapeLine *pSh = pObj1->GetShape();
if(!pSh) continue;
pSh->GetPts(pts);
BOOL bInside = TRUE;
if(0==pObj1->bPtIn(&pt0))
{
bInside = FALSE;
}
else if(0==pObj1->bPtIn(&pt1))
{
bInside = FALSE;
}
else if(pObj1->bPtIn(&pt2)<2)
{
bInside = FALSE;
}
if(bInside)
{
m_pEditor->DeleteObject(FtrToHandle(arr1[i]));
undo.AddOldFeature(FtrToHandle(arr1[i]));
}
}
}
GProgressEnd();
undo.Commit();
Finish();
CEditCommand::PtClick(pt,flag);
}
//////////////////////////////////////////////////////////////////////
// CDelPtAroundCurveCommand Class
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDelPtAroundCurveCommand,CEditCommand)
CDelPtAroundCurveCommand::CDelPtAroundCurveCommand()
{
m_nStep = -1;
m_dis = 10.0;
}
CDelPtAroundCurveCommand::~CDelPtAroundCurveCommand()
{
}
CString CDelPtAroundCurveCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DElPT_AROUNDCURVE);
}
void CDelPtAroundCurveCommand::Start()
{
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
}
void CDelPtAroundCurveCommand::Abort()
{
CEditCommand::Abort();
}
void CDelPtAroundCurveCommand::Finish()
{
UpdateParams(TRUE);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
CEditCommand::Finish();
}
void CDelPtAroundCurveCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("DelPtAroundCurve",Name());
param->AddLayerNameParamEx("PointLayer",(LPCTSTR)m_strPoint,StrFromResID(IDS_CMDPLANE_POINTLAYER));
param->AddLayerNameParamEx("CurveLayer",(LPCTSTR)m_strCurve,StrFromResID(IDS_CMDPLANE_LINELAYER));
param->AddParam("Distance",m_dis,StrFromResID(IDS_CMDPLANE_MM_SCOPE));
}
void CDelPtAroundCurveCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"PointLayer",var) )
{
m_strPoint = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strPoint.TrimLeft();
m_strPoint.TrimRight();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"CurveLayer",var) )
{
m_strCurve = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strCurve.TrimRight();
m_strCurve.TrimLeft();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"Distance",var) )
{
m_dis = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CDelPtAroundCurveCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_strPoint);
tab.AddValue("PointLayer",&CVariantEx(var));
var = (LPCTSTR)(m_strCurve);
tab.AddValue("CurveLayer",&CVariantEx(var));
var = (double)(m_dis);
tab.AddValue("Distance",&CVariantEx(var));
}
static BOOL GetDistanceFromPointToLine(PT_3D ptA, PT_3D ptB, PT_3D ptC, double *fDistance,PT_3D *rtPT)
{
//A B 为线串上两点 C 为点地物 计算时A B 高程相同,暂时计算二维平面距离
double minDistance = 0;
PT_3D AB, AC, BC, BA, BD,D;//向量 ab ac bc
double AB_E, AC_E, BC_E;
double r;
double cosabc,cosbac,sinabc;//<ABC <BAC 夹角
AB = PT_3D(ptB.x-ptA.x,ptB.y-ptA.y,ptB.z-ptA.z);
BA = PT_3D(ptA.x-ptB.x,ptA.y-ptB.y,ptA.z-ptB.z);
AC = PT_3D(ptC.x-ptA.x,ptC.y-ptA.y,ptC.z-ptA.z);
BC = PT_3D(ptC.x-ptB.x,ptC.y-ptB.y,ptC.z-ptB.z);
AB_E = sqrt(AB.x*AB.x+AB.y*AB.y);
AC_E = sqrt(AC.x*AC.x+AC.y*AC.y);
BC_E = sqrt(BC.x*BC.x+BC.y*BC.y);
cosabc = (BA.x*BC.x + BA.y*BC.y )/(AB_E*BC_E);
cosbac = (AB.x*AC.x + AB.y*AC.y )/(AB_E*AC_E);
if (cosabc<0)//余弦值小于0 垂直线在延长线上
{
minDistance = BC_E;//返回点到端点线段的值
if(fDistance) *fDistance = minDistance;
if(rtPT) *rtPT = ptB;
return TRUE;
}
if (cosbac<0) //同上
{
minDistance = AC_E;
if(fDistance) *fDistance = minDistance;
if(rtPT) *rtPT = ptA;
return TRUE;
}
minDistance = BC_E*sqrt(1-cosabc*cosabc);
r = (BC_E*cosabc/AB_E);
D = PT_3D(r*BA.x+ptB.x,r*BA.y+ptB.y,ptB.z);
if(fDistance) *fDistance = minDistance;
if(rtPT) *rtPT = D;
return TRUE;
}
double GetDistanceFromPointToCurve(CArray<PT_3DEX,PT_3DEX>& pts, PT_3D& pt, PT_3D *retpt=NULL)
{
int nPt = pts.GetSize();
double mindis = 9e10;
if(nPt<2) return mindis;
PT_3DEX tPT[2];
for (int i=0;i<nPt-1;i++)//计算线串上两点到点的最近距离
{
tPT[0] = pts.GetAt(i);
tPT[1] = pts.GetAt(i+1);
//获取点对象到线串关键点连线的最短距离
double dis;
PT_3D ret;
if (GetDistanceFromPointToLine(tPT[0],tPT[1],pt,&dis,&ret))
{
if ( mindis>dis )
{
mindis = dis;
if(retpt) *retpt = ret;
}
}
}
return mindis;
}
void CDelPtAroundCurveCommand::PtClick(PT_3D &pt, int flag)
{
if(!m_pEditor) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
if(!pDS || !pDQ) return;
CFtrLayerArray arr,arr1;
pDS->GetFtrLayersByNameOrCode_editable(m_strCurve, arr);
pDS->GetFtrLayersByNameOrCode_editable(m_strPoint, arr1);
pDS->SaveAllQueryFlags(TRUE,FALSE);
int i,j,k,nSum=0;
for( i=0; i<arr.GetSize(); i++)
{
nSum += arr[i]->GetValidObjsCount();
}
for( i=0; i<arr1.GetSize(); i++)
{
arr1[i]->SetAllowQuery(TRUE);
}
double dis1 = m_dis+GraphAPI::g_lfDisTolerance;
GProgressStart(nSum);
CUndoFtrs undo(m_pEditor,Name());
for(i=0; i<arr.GetSize(); i++)
{
int nObj = arr[i]->GetObjectCount();
for(j=0; j<nObj; j++)
{
GProgressStep();
CFeature *pFtr = arr[i]->GetObject(j);
if(!pFtr || !pFtr->IsVisible())
continue;
CGeometry *pGeo = pFtr->GetGeometry();
if(!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
continue;
CArray<PT_3DEX,PT_3DEX> pts;
pGeo->GetShape(pts);
int nPt = pts.GetSize();
if(nPt<2) continue;
Envelope e = pGeo->GetEnvelope();
e.m_xh += dis1;
e.m_xl -= dis1;
e.m_yh += dis1;
e.m_yl -= dis1;
pDQ->FindObjectInRect(e,NULL,TRUE,FALSE);
int num;
const CPFeature *ftrs = pDQ->GetFoundHandles(num);
for(k=0; k<num; k++)
{
CGeometry *pGeo1 = ftrs[k]->GetGeometry();
if(!pGeo1 || !pGeo1->IsKindOf(RUNTIME_CLASS(CGeoPoint)))
continue;
PT_3D temp = pGeo1->GetDataPoint(0);
double dis = GetDistanceFromPointToCurve(pts,temp);
if(dis<dis1)
{
m_pEditor->DeleteObject(FtrToHandle(ftrs[k]));
undo.AddOldFeature(FtrToHandle(ftrs[k]));
}
}
}
}
GProgressEnd();
undo.Commit();
pDS->RestoreAllQueryFlags();
Finish();
CEditCommand::PtClick(pt,flag);
}
//////////////////////////////////////////////////////////////////////
// CModifyRoadBySunRuleCommand Class
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CModifyRoadBySunRuleCommand,CEditCommand)
CModifyRoadBySunRuleCommand::CModifyRoadBySunRuleCommand()
{
m_nStep = -1;
m_splitdis = 15.0;
}
CModifyRoadBySunRuleCommand::~CModifyRoadBySunRuleCommand()
{
}
CString CModifyRoadBySunRuleCommand::Name()
{
return StrFromResID(IDS_CMDNAME_MODIFYROAD);
}
void CModifyRoadBySunRuleCommand::Start()
{
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
}
void CModifyRoadBySunRuleCommand::Abort()
{
CEditCommand::Abort();
}
void CModifyRoadBySunRuleCommand::Finish()
{
UpdateParams(TRUE);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
CEditCommand::Finish();
}
void CModifyRoadBySunRuleCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("ModifyRoadBySunRule",Name());
param->AddLayerNameParamEx("Layers",(LPCTSTR)m_strLayers,StrFromResID(IDS_ROAD_LAYER));
param->AddLayerNameParamEx("VirLayers",(LPCTSTR)m_strVirLayers,StrFromResID(IDS_ROAD_VIRLAYER));
param->AddParam("SplitDis",m_splitdis,StrFromResID(IDS_SPLIT_DIS));
}
void CModifyRoadBySunRuleCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"Layers",var) )
{
m_strLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strLayers.TrimLeft();
m_strLayers.TrimRight();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"VirLayers",var) )
{
m_strVirLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strVirLayers.TrimRight();
m_strVirLayers.TrimLeft();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"SplitDis",var) )
{
m_splitdis = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CModifyRoadBySunRuleCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_strLayers);
tab.AddValue("Layers",&CVariantEx(var));
var = (LPCTSTR)(m_strVirLayers);
tab.AddValue("VirLayers",&CVariantEx(var));
var = (double)(m_splitdis);
tab.AddValue("SplitDis",&CVariantEx(var));
}
void CModifyRoadBySunRuleCommand::PtClick(PT_3D &pt, int flag)
{
if(!m_pEditor) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CStringArray arr1, arr2;
convertStringToStrArray(m_strLayers, arr1);
convertStringToStrArray(m_strVirLayers, arr2);
int minsize = min( arr1.GetSize(), arr2.GetSize() );
int nSum=0, i, j;
for(i=0; i<minsize; i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayer(arr1[i]);
if(!pLayer || !pLayer->IsVisible())
continue;
nSum += pLayer->GetObjectCount();
}
CUndoFtrs undo(m_pEditor, Name());
GProgressStart(nSum*3);
for(i=0; i<minsize; i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayer(arr1[i]);
if(!pLayer || !pLayer->IsVisible())
continue;
CFtrLayer *pVirLayer = pDS->GetFtrLayer(arr2[i]);
if(!pVirLayer)
{
pVirLayer = new CFtrLayer();
pVirLayer->SetName(arr2[i]);
m_pEditor->AddFtrLayer(pVirLayer);
}
pDS->SaveAllQueryFlags(TRUE, FALSE);
pLayer->SetAllowQuery(TRUE);
pVirLayer->SetAllowQuery(TRUE);
ModifyRoad(pLayer, pVirLayer, undo);
//处理短线
ReplaceShortCurve(pLayer, pVirLayer);
ReplaceShortCurve(pVirLayer, pLayer);
pDS->RestoreAllQueryFlags();
for(j=0; j<pLayer->GetObjectCount(); j++)
{
CFeature *pFtr = pLayer->GetObject(j);
if(pFtr && pFtr->IsVisible())
{
undo.AddNewFeature(FtrToHandle(pFtr));
}
}
for(j=0; j<pVirLayer->GetObjectCount(); j++)
{
CFeature *pFtr = pVirLayer->GetObject(j);
if(pFtr && pFtr->IsVisible())
{
undo.AddNewFeature(FtrToHandle(pFtr));
}
}
}
GProgressEnd();
undo.Commit();
Finish();
CEditCommand::PtClick(pt,flag);
}
void CModifyRoadBySunRuleCommand::ModifyRoad(CFtrLayer* pLayer, CFtrLayer *pVirLayer, CUndoFtrs& undo)
{
CDataSourceEx *pDS = m_pEditor->GetDataSource();
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
if(!pDS || !pDQ) return;
CAttributesSource *pXDS = pDS->GetXAttributesSource();
if(!pXDS) return;
double lfRange = 100;//匹配范围
//道路边线分段
int nObj = pLayer->GetObjectCount(), i, j, k;
for(i=0; i<nObj; i++)
{
GProgressStep();
CFeature *pFtr = pLayer->GetObject(i);
if(!pFtr || !pFtr->IsVisible())
continue;
CGeometry *pGeo = pFtr->GetGeometry();
if(!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
continue;
CArray<PT_3DEX,PT_3DEX> arrPts, newPts;
pGeo->GetShape(arrPts);
if(arrPts.GetSize()<2) continue;
if(arrPts[arrPts.GetSize()-1].x < arrPts[0].x)
{
pGeo->ReversePoints();
pGeo->GetShape(arrPts);
}
CGeoArray geos;
//以y=-x为分界线,越过此分界线的不打断
double deta = (arrPts[0].x-arrPts[1].x) + (arrPts[0].y-arrPts[1].y) ;
newPts.Add(arrPts[0]);
for(j=1; j<arrPts.GetSize()-1; j++)
{
newPts.Add(arrPts[j]);
double deta1 = (arrPts[j].x-arrPts[j+1].x) + (arrPts[j].y-arrPts[j+1].y);
if( (deta>0&&deta1<0) || (deta<0&&deta1>0))
{
CGeoCurve *pCurve = new CGeoCurve();
if(pCurve->CreateShape(newPts.GetData(), newPts.GetSize()) )
{
geos.Add(pCurve);
}
else
{
delete pCurve;
}
deta = deta1;
newPts.RemoveAll();
newPts.Add(arrPts[j]);
}
}
//最后一段
newPts.Add(arrPts[j]);
CGeoCurve *pCurve = new CGeoCurve();
if(pCurve->CreateShape(newPts.GetData(), newPts.GetSize()) )
{
geos.Add(pCurve);
}
else
{
delete pCurve;
}
for(k=0; k<geos.GetSize(); k++)
{
CFeature *pNew = pFtr->Clone();
pNew->SetGeometry(geos[k]);
pNew->SetAppFlag(i+1);
m_pEditor->AddObject(pNew, pLayer->GetID());//pNew是临时的feature,不需要添加到undo里面
pXDS->CopyXAttributes(pFtr, pNew);
}
m_pEditor->DeleteObject(FtrToHandle(pFtr));
undo.AddOldFeature(FtrToHandle(pFtr));
}
//阳光法则分虚实
CFeature *pTempVirFtr = pVirLayer->CreateDefaultFeature(pDS->GetScale(), CLS_GEOCURVE);
if(!pTempVirFtr) return;
nObj = pLayer->GetObjectCount();
for(i=0; i<nObj; i++)
{
GProgressStep();
CFeature *pFtr = pLayer->GetObject(i);
if(!pFtr || !pFtr->IsVisible())
continue;
CGeometry *pGeo = pFtr->GetGeometry();
if(!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
continue;
int ptsum = pGeo->GetDataPointSum();
if(ptsum<2) continue;
PT_3D pt0 = pGeo->GetDataPoint(ptsum/2-1);
PT_3D pt1 = pGeo->GetDataPoint(ptsum/2);
{
pt1.x = (pt0.x+pt1.x)/2;
pt1.y = (pt0.y+pt1.y)/2;
}
//配对
Envelope e;
e.CreateFromPtAndRadius(pt1, lfRange);
if( pDQ->FindObjectInRect(e, NULL, FALSE, FALSE) <2 ) continue;
int num;
const CPFeature *ftrs = pDQ->GetFoundHandles(num);
CFeature *pFound = NULL;
PT_3D retpt, retpt1;
double mindis = 9e10;
for(j=0; j<num; j++)
{
if( ftrs[j]==pFtr ) continue;
if( ftrs[j]->GetAppFlag() == pFtr->GetAppFlag() ) continue;
CGeometry *pObj1 = ftrs[j]->GetGeometry();
if(!pObj1 || !pObj1->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
continue;
CArray<PT_3DEX,PT_3DEX> pts;
pObj1->GetShape(pts);
if(pts.GetSize()<2) continue;
double dis = GetDistanceFromPointToCurve(pts, pt1, &retpt1);
if(dis<mindis)
{
pFound = ftrs[j];
retpt = retpt1;
mindis = dis;
}
}
if(mindis>lfRange) continue;
if(!pFound) continue;
BOOL bUpOrLeft = ( fabs(pt0.x-pt1.x) - fabs(pt0.y-pt1.y) ) > 0 ;
//判断虚实
if(bUpOrLeft)//上虚下实
{
if(pt1.y>retpt.y)
{
CFeature *pNew = pTempVirFtr->Clone();
pNew->SetGeometry(pGeo->Clone());
m_pEditor->AddObject(pNew, pVirLayer->GetID());
m_pEditor->DeleteObject(FtrToHandle(pFtr));
}
}
else//左虚右实
{
if(pt1.x<retpt.x)
{
CFeature *pNew = pTempVirFtr->Clone();
pNew->SetGeometry(pGeo->Clone());
m_pEditor->AddObject(pNew, pVirLayer->GetID());
m_pEditor->DeleteObject(FtrToHandle(pFtr));
}
}
}
delete pTempVirFtr;
}
//如果长度小于指定长度，并且两端没有连接同层地物， 则换层到pNewLayer
void CModifyRoadBySunRuleCommand::ReplaceShortCurve(CFtrLayer* pLayer, CFtrLayer *pNewLayer)
{
if(!pLayer || !pNewLayer) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
if(!pDS || !pDQ) return;
int nObj = pLayer->GetObjectCount(), i;
for(i=0; i<nObj; i++)
{
GProgressStep();
CFeature *pFtr = pLayer->GetObject(i);
if(!pFtr || !pFtr->IsVisible())
continue;
CGeometry *pGeo = pFtr->GetGeometry();
if(!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
continue;
CArray<PT_3DEX,PT_3DEX> arrPts;
pGeo->GetShape(arrPts);
if(arrPts.GetSize()<2) continue;
if(GraphAPI::GGetAllLen2D(arrPts.GetData(), arrPts.GetSize())>m_splitdis)
{
continue;
}
Envelope e0, e1;
double r=0.01;
e0.CreateFromPtAndRadius(arrPts[0], r);
e1.CreateFromPtAndRadius(arrPts[arrPts.GetSize()-1], r);
int num1, num2;
CFtrLayer *pLayer1=NULL, *pLayer2=NULL;
pDQ->FindObjectInRect(e0, NULL, FALSE, FALSE);
const CPFeature *ftr = pDQ->GetFoundHandles(num1);
if(num1==2)
{
CFeature *pFtr1 = ftr[0];
if(pFtr1==pFtr) pFtr1=ftr[1];
pLayer1 = pDS->GetFtrLayerOfObject(pFtr1);
}
pDQ->FindObjectInRect(e1, NULL, FALSE, FALSE);
ftr = pDQ->GetFoundHandles(num2);
if(num2==2)
{
CFeature *pFtr2 = ftr[0];
if(pFtr2==pFtr) pFtr2=ftr[1];
pLayer2 = pDS->GetFtrLayerOfObject(pFtr2);
}
if(pLayer1==NULL && pLayer2==NULL)
{
continue;
}
if(pLayer1!=pLayer && pLayer2!=pLayer)
{
CFeature *pNew = pNewLayer->CreateDefaultFeature(pDS->GetScale(), CLS_GEOCURVE);
if(pNew)
{
pNew->SetGeometry(pGeo->Clone());
m_pEditor->AddObject(pNew, pNewLayer->GetID());
m_pEditor->DeleteObject(FtrToHandle(pFtr));
}
}
}
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CModifyLayerCommand,CEditCommand)
CModifyLayerCommand::CModifyLayerCommand()
{
m_bResetBaseAtt = FALSE;
}
CModifyLayerCommand::~CModifyLayerCommand()
{
}
CString CModifyLayerCommand::Name()
{
return StrFromResID(IDS_MODIFY_LAYER);
}
void CModifyLayerCommand::Start()
{
if( !m_pEditor )return;
int numsel;
m_pEditor->GetSelection()->GetSelectedObjs(numsel);
if(numsel>0 )
{
m_nStep = 0;
CCommand::Start();
PT_3D pt;
PtClick(pt,0);
PtClick(pt,0);
return;
}
CEditCommand::Start();
}
void CModifyLayerCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("ModifyLayer",Name());
param->AddLayerNameParam("Layer",(LPCTSTR)m_strLayer,StrFromResID(IDS_CONVERTTO_LAYER));
}
void CModifyLayerCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"Layer",var) )
{
m_strLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CModifyLayerCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_strLayer);
tab.AddValue("Layer",&CVariantEx(var));
}
void CModifyLayerCommand::ModifyLayer(const FTR_HANDLE* handles,int num)
{
if(m_strLayer.IsEmpty()) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CScheme *pScheme = gpCfgLibMan->GetScheme(pDS->GetScale());
if(!pScheme) return;
CFtrLayer *pDestLayer = pDS->GetFtrLayer(m_strLayer);
if(!pDestLayer)
{
pDestLayer = new CFtrLayer();
pDestLayer->SetName(m_strLayer);
pDS->AddFtrLayer(pDestLayer);
}
CSchemeLayerDefine *pSchemeLayer = pScheme->GetLayerDefine(pDestLayer->GetName());
float wid = pScheme->GetLayerDefineLineWidth(pDestLayer->GetName());
CUndoModifyLayerOfObj undo(m_pEditor, "ModifyLayerOfObj");
for (int i=0;i<num;i++)
{
CPFeature pftr = HandleToFtr(handles[i]);
undo.arrHandles.Add(handles[i]);
undo.oldVT.BeginAddValueItem();
pftr->WriteTo(undo.oldVT);
undo.oldVT.EndAddValueItem();
m_pEditor->DeleteObject(handles[i],FALSE);
CGeometry *pGeo = pftr->GetGeometry();
if (!pGeo) continue;
if( pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurveBase)) )
{
((CGeoCurveBase*)pGeo)->m_fLineWidth = wid;
}
CFtrLayer* player_old = pDS->GetFtrLayerOfObject(pftr);
undo.oldLayerArr.Add(player_old->GetID());
pDS->SetFtrLayerOfObject(pftr,pDestLayer->GetID());
undo.newLayerArr.Add(pDestLayer->GetID());
//改变层之后恢复缺省参数
if(pSchemeLayer && m_bResetBaseAtt)
{
CValueTable tab;
pSchemeLayer->GetBasicAttributeDefaultValues(tab);
tab.DelField(FIELDNAME_FTRDISPLAYORDER);
tab.DelField(FIELDNAME_GEOTEXT_CONTENT);
tab.DelField(FIELDNAME_FTRMODIFYTIME);
tab.DelField(FIELDNAME_GEOCLASS);
tab.DelField(FIELDNAME_CLSTYPE);
tab.DelField(FIELDNAME_GEOPOINT_ANGLE);
tab.DelField(FIELDNAME_GEOCURVE_WIDTH);
tab.DelField(FIELDNAME_GEOCURVE_DHEIGHT);
tab.DelField(FIELDNAME_SYMBOLNAME);
pftr->ReadFrom(tab);
pftr->GetGeometry()->SetColor(-1);
pftr->GetGeometry()->SetSymbolName("");
}
undo.newVT.BeginAddValueItem();
pftr->WriteTo(undo.newVT);
undo.newVT.EndAddValueItem();
m_pEditor->RestoreObject(FtrToHandle(pftr));
}
undo.Commit();
}
void CModifyLayerCommand::PtClick(PT_3D &pt, int flag)
{
if( m_nStep==0 )
{
if( !CanGetSelObjs(flag) )return;
EditStepOne();
}
if( m_nStep==1 )
{
CSelection* pSel = m_pEditor->GetSelection();
int num;
const FTR_HANDLE* handles = pSel->GetSelectedObjs(num);
ModifyLayer(handles,num);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
m_pEditor->RefreshView();
Finish();
m_nStep = 2;
}
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// CSaveAssistLineCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CSaveAssistLineCommand,CEditCommand)
CSaveAssistLineCommand::CSaveAssistLineCommand()
{
m_nStep = -1;
}
CSaveAssistLineCommand::~CSaveAssistLineCommand()
{
}
CString CSaveAssistLineCommand::Name()
{
return StrFromResID(IDS_CMDNAME_COPY_ASSISTLINE);
}
void CSaveAssistLineCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CSaveAssistLineCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_HandleLayer);
tab.AddValue("HandleLayer",&CVariantEx(var));
var = (LPCTSTR)(m_StoreLayer);
tab.AddValue("StoreLayer",&CVariantEx(var));
}
void CSaveAssistLineCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("SaveAssistLineCommand",Name());
param->AddLayerNameParamEx("HandleLayer",(LPCTSTR)m_HandleLayer,StrFromResID(IDS_CMDPLANE_HANDLELAYER),NULL,LAYERPARAMITEM_NOTEMPTY_LINE);
param->AddLayerNameParam("StoreLayer",(LPCTSTR)m_StoreLayer,StrFromResID(IDS_CONVERTTO_LAYER));
}
void CSaveAssistLineCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"HandleLayer",var) )
{
m_HandleLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_HandleLayer.TrimRight();
m_HandleLayer.TrimLeft();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"StoreLayer",var) )
{
m_StoreLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_StoreLayer.TrimRight();
m_StoreLayer.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CSaveAssistLineCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
if(m_HandleLayer.IsEmpty() || m_StoreLayer.IsEmpty())
return;
CFtrLayer *pStoreLayer = pDS->GetFtrLayer(m_StoreLayer);
if(!pStoreLayer)
{
pStoreLayer = new CFtrLayer();
pStoreLayer->SetName(m_StoreLayer);
pDS->AddFtrLayer(pStoreLayer);
}
CFtrLayerArray arr;
pDS->GetFtrLayersByNameOrCode_editable(m_HandleLayer, arr);
int nSum=0, i, j;
for(i=0; i<arr.GetSize(); i++)
{
nSum += arr[i]->GetObjectCount();
}
CFeature *pFtrTemp = pStoreLayer->CreateDefaultFeature(pDS->GetScale(),CLS_GEOCURVE);
if (!pFtrTemp || !pFtrTemp->GetGeometry())
{
Abort();
return;
}
GProgressStart(nSum);
CUndoFtrs undo(m_pEditor, Name());
for(i=0; i<arr.GetSize(); i++)
{
int nObj = arr[i]->GetObjectCount();
for(j=0; j<nObj; j++)
{
GProgressStep();
CFeature *pFtr = arr[i]->GetObject(j);
if(!pFtr || !pFtr->IsVisible())
continue;
CGeometry *pGeo = pFtr->GetGeometry();
if(!pGeo) continue;
int nCls = pGeo->GetClassType();
if(nCls==CLS_GEODCURVE)
{
CGeometry *pGeo1=NULL;
CGeometry *pGeo2=NULL;
((CGeoDCurve*)pGeo)->Separate(pGeo1, pGeo2);
if(pGeo1 && pGeo2)
{
delete pGeo1;
CFeature *pNew = pFtrTemp->Clone();
CArray<PT_3DEX,PT_3DEX> arrPts;
pGeo2->GetShape(arrPts);
delete pGeo2;
pNew->GetGeometry()->CreateShape(arrPts.GetData(), arrPts.GetSize());
if(m_pEditor->AddObject(pNew, pStoreLayer->GetID()))
{
undo.AddNewFeature(FtrToHandle(pNew));
}
}
}
else if(nCls==CLS_GEOPARALLEL)
{
CGeometry *pGeo1=NULL;
CGeometry *pGeo2=NULL;
((CGeoParallel*)pGeo)->SeparateNoReverse(pGeo1, pGeo2);
if(pGeo1 && pGeo2)
{
delete pGeo1;
CFeature *pNew = pFtrTemp->Clone();
CArray<PT_3DEX,PT_3DEX> arrPts;
pGeo2->GetShape(arrPts);
delete pGeo2;
pNew->GetGeometry()->CreateShape(arrPts.GetData(), arrPts.GetSize());
if(m_pEditor->AddObject(pNew, pStoreLayer->GetID()))
{
undo.AddNewFeature(FtrToHandle(pNew));
}
}
}
else if(nCls==CLS_GEOSURFACE)
{
CArray<PT_3DEX,PT_3DEX> arrPts, newPts;
pGeo->GetShape(arrPts);
int nPt = arrPts.GetSize();
if(nPt<4) continue;
for(int k=nPt/2; k<nPt-1; k++)
{
newPts.Add(arrPts[k]);
}
CGeoCurve *pCurve = new CGeoCurve();
if(!pCurve->CreateShape(newPts.GetData(), newPts.GetSize()))
{
delete pCurve;
}
CFeature *pNew = pFtrTemp->Clone();
pNew->SetGeometry(pCurve);
if(m_pEditor->AddObject(pNew, pStoreLayer->GetID()))
{
undo.AddNewFeature(FtrToHandle(pNew));
}
else
{
delete pCurve;
}
}
}
}
GProgressEnd();
delete pFtrTemp;
undo.Commit();
Finish();
CEditCommand::PtClick(pt,flag);
}
//////////////////////////////////////////////////////////////////////
// CDelRoadSurfaceCommand Class
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDelRoadSurfaceCommand,CEditCommand)
CDelRoadSurfaceCommand::CDelRoadSurfaceCommand()
{
m_nStep = -1;
m_strLayer = _T("30");
}
CDelRoadSurfaceCommand::~CDelRoadSurfaceCommand()
{
}
CString CDelRoadSurfaceCommand::Name()
{
return StrFromResID(IDS_CMDNAME_DELROAD);
}
void CDelRoadSurfaceCommand::Start()
{
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
}
void CDelRoadSurfaceCommand::Abort()
{
CEditCommand::Abort();
}
void CDelRoadSurfaceCommand::Finish()
{
UpdateParams(TRUE);
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->UpdateDrag(ud_ClearDrag);
CEditCommand::Finish();
}
void CDelRoadSurfaceCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("ModifyRoadBySunRule",Name());
param->AddLayerNameParam("HandleLayer",(LPCTSTR)m_strLayer,StrFromResID(IDS_CMDPLANE_HANDLELAYER),NULL,LAYERPARAMITEM_NOTEMPTY_AREA);
param->AddLayerNameParamEx("RoadLayers",(LPCTSTR)m_strRoadLayers,StrFromResID(IDS_ROAD_LAYERS),NULL,LAYERPARAMITEM_NOTEMPTY_LINE);
// param->AddLayerNameParamEx("ExceptLayers",(LPCTSTR)m_strExceptLayers,_T("排除道路附属图层")/*StrFromResID(IDS_ROAD_LAYERS)*/);
}
void CDelRoadSurfaceCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"HandleLayer",var) )
{
m_strLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strLayer.TrimLeft();
m_strLayer.TrimRight();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"RoadLayers",var) )
{
m_strRoadLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strRoadLayers.TrimRight();
m_strRoadLayers.TrimLeft();
SetSettingsModifyFlag();
}
// if( tab.GetValue(0,"ExceptLayers",var) )
// {
// m_strExceptLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
// m_strExceptLayers.TrimRight();
// m_strExceptLayers.TrimLeft();
// SetSettingsModifyFlag();
// }
CEditCommand::SetParams(tab,bInit);
}
void CDelRoadSurfaceCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_strLayer);
tab.AddValue("HandleLayer",&CVariantEx(var));
var = (LPCTSTR)(m_strRoadLayers);
tab.AddValue("RoadLayers",&CVariantEx(var));
// var = (LPCTSTR)(m_strExceptLayers);
// tab.AddValue("ExceptLayers",&CVariantEx(var));
}
extern BOOL convertStringToStrArray(LPCTSTR str,CStringArray &arr);
static BOOL IsLayerInArr(CFtrLayer *pLayer, CFtrLayerArray& arr)
{
for(int i=0; i<arr.GetSize(); i++)
{
if(pLayer==arr[i])
{
return TRUE;
}
}
return FALSE;
}
void CDelRoadSurfaceCommand::PtClick(PT_3D &pt, int flag)
{
if(!m_pEditor) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
if(!pDQ) return;
CFtrLayer *pLayer = pDS->GetFtrLayer(m_strLayer);
if(!pLayer) return;
int nSum = pLayer->GetObjectCount();
if(nSum<=0) return;
CFtrLayerArray arr1, arr2;
pDS->GetFtrLayersByNameOrCode(m_strRoadLayers, arr1);
// pDS->GetFtrLayersByNameOrCode(m_strExceptLayers, arr2);
//只让道路图层可查询
pDS->SaveAllQueryFlags(TRUE,FALSE);
int i,j,k;
for(i=0; i<arr1.GetSize(); i++)
{
arr1[i]->SetAllowQuery(TRUE);
}
for(i=0; i<arr2.GetSize(); i++)
{
arr2[i]->SetAllowQuery(TRUE);
}
double r = GraphAPI::g_lfDisTolerance;
CUndoFtrs undo(m_pEditor, Name());
GProgressStart(nSum);
for(i=0; i<nSum; i++)
{
GProgressStep();
CFeature *pFtr = pLayer->GetObject(i);
if(!pFtr || !pFtr->IsVisible())
continue;
CGeometry *pGeo = pFtr->GetGeometry();
if(!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoSurface)))
continue;
CArray<PT_3DEX,PT_3DEX> pts;
pGeo->GetShape(pts);
int nSumOnRoad = 0;
int nPt = pts.GetSize();
for(j=0; j<nPt; j++)
{
Envelope e;
e.CreateFromPtAndRadius(pts[j], r);
pDQ->FindObjectInRect(e,NULL,FALSE,FALSE);
int num;
const CPFeature* ftr= pDQ->GetFoundHandles(num);
if(num<=0)
{
continue;
}
for(k=0; k<num; k++)
{
CFtrLayer *pLayer1 = pDS->GetFtrLayerOfObject(ftr[k]);
if(IsLayerInArr(pLayer1, arr1))
{
nSumOnRoad++;
break;
}
}
}
if(nSumOnRoad==nPt || (nPt>10 && 5*nSumOnRoad>4*nPt) )//80%
{
m_pEditor->DeleteObject(FtrToHandle(pFtr));
undo.AddOldFeature(FtrToHandle(pFtr));
}
}
m_pEditor->RefreshView();
GProgressEnd();
undo.Commit();
pDS->RestoreAllQueryFlags();
Finish();
CEditCommand::PtClick(pt,flag);
}
//////////////////////////////////////////////////////////////////////
// CExplodeDcurveToSurfaceCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CExplodeDcurveToSurfaceCommand,CEditCommand)
CExplodeDcurveToSurfaceCommand::CExplodeDcurveToSurfaceCommand()
{
m_lfDis = 15;
m_nStep = -1;
}
CExplodeDcurveToSurfaceCommand::~CExplodeDcurveToSurfaceCommand()
{
}
CString CExplodeDcurveToSurfaceCommand::Name()
{
return StrFromResID(IDS_EXPOLODEDCURVE_TOSURFACE);
}
void CExplodeDcurveToSurfaceCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CExplodeDcurveToSurfaceCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_HandleLayer);
tab.AddValue("HandleLayer",&CVariantEx(var));
var = (LPCTSTR)(m_StoreLayer);
tab.AddValue("StoreLayer",&CVariantEx(var));
var = (double)(m_lfDis);
tab.AddValue("schdis",&CVariantEx(var));
}
void CExplodeDcurveToSurfaceCommand::FillShowParams(CUIParam* param, BOOL bForLoad )
{
param->SetOwnerID("ExplodeDcurveToSurfaceCommand",Name());
param->AddLayerNameParamEx("HandleLayer",(LPCTSTR)m_HandleLayer,StrFromResID(IDS_CMDPLANE_HANDLELAYER),NULL,LAYERPARAMITEM_NOTEMPTY_LINE);
param->AddLayerNameParamEx("StoreLayer",(LPCTSTR)m_StoreLayer,StrFromResID(IDS_CONVERTTO_LAYER));
param->AddParam("schdis",(double)(m_lfDis),StrFromResID(IDS_CHK_CMD_DES_SEARCH_RADIUS));
}
void CExplodeDcurveToSurfaceCommand::SetParams(CValueTable& tab,BOOL bInit)
{
const CVariantEx *var;
if( tab.GetValue(0,"HandleLayer",var) )
{
m_HandleLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_HandleLayer.TrimRight();
m_HandleLayer.TrimLeft();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"StoreLayer",var) )
{
m_StoreLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_StoreLayer.TrimRight();
m_StoreLayer.TrimLeft();
SetSettingsModifyFlag();
}
if( tab.GetValue(0,"schdis",var) )
{
m_lfDis = (double)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab,bInit);
}
void CExplodeDcurveToSurfaceCommand::PtClick(PT_3D &pt, int flag)
{
if( !m_pEditor )return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if(!pDS) return;
if(m_HandleLayer.IsEmpty()) return;
CFtrLayerArray arr;
CStringArray strs0, strs;
convertStringToStrArray(m_HandleLayer, strs0);
convertStringToStrArray(m_StoreLayer, strs);
int nSum=0, i;
for(i=0; i<strs0.GetSize(); i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayer(strs0[i]);
arr.Add(pLayer);
if(pLayer)
{
nSum += pLayer->GetObjectCount();
}
}
pDS->SaveAllQueryFlags(TRUE, FALSE);
GProgressStart(nSum);
CUndoFtrs undo(m_pEditor, Name());
for(i=0; i<arr.GetSize(); i++)
{
if(arr[i]==NULL) continue;
if(arr[i]->GetObjectCount()<2)
continue;
CFtrLayer *pStoreLayer = NULL;
if(i<strs.GetSize() && !strs.GetAt(i).IsEmpty())
{
pStoreLayer = pDS->GetFtrLayer(strs[i]);
if(!pStoreLayer)
{
pStoreLayer = new CFtrLayer();
pStoreLayer->SetName(strs[i]);
pDS->AddFtrLayer(pStoreLayer);
}
}
else
{
pStoreLayer = arr[i];
}
arr[i]->SetAllowQuery(TRUE);
ToSurface(arr[i], pStoreLayer, undo);
arr[i]->SetAllowQuery(FALSE);
}
GProgressEnd();
undo.Commit();
pDS->RestoreAllQueryFlags();
Finish();
CEditCommand::PtClick(pt,flag);
}
void CExplodeDcurveToSurfaceCommand::ToSurface(CFtrLayer* pLayer, CFtrLayer* pStoreLayer, CUndoFtrs& undo)
{
if(!pLayer || !pStoreLayer) return;
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
if(!pDQ) return;
int nObj = pLayer->GetObjectCount(), j, k;
if(nObj<2) return;
CFeature *pFtrTemp = pStoreLayer->CreateDefaultFeature(m_pEditor->GetDataSource()->GetScale(),CLS_GEOSURFACE);
if (!pFtrTemp || !pFtrTemp->GetGeometry())
{
return;
}
for(j=0; j<nObj; j++)
{
GProgressStep();
CFeature *pFtr = pLayer->GetObject(j);
if(!pFtr || !pFtr->IsVisible())
continue;
CGeometry *pGeo = pFtr->GetGeometry();
if(!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
continue;
CArray<PT_3DEX,PT_3DEX> pts, pts1, newPts;
pGeo->GetShape(pts);
int nPt = pts.GetSize();
if(nPt<2) continue;
PT_3D sch_pt = pts[0];
double r;
Envelope e;
e.CreateFromPtAndRadius(pts[0], m_lfDis);
pDQ->FindObjectInRect(e, NULL, FALSE, FALSE);
int nFound;
const CPFeature *ftr = pDQ->GetFoundHandles(nFound);
if(nFound!=2) continue;
CFeature *pFtr1 = ftr[0];
if(pFtr1==pFtr) pFtr1 = ftr[1];
CGeometry *pGeo1 = pFtr1->GetGeometry();
if(!pGeo1 || !pGeo1->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
continue;
pGeo1->GetShape(pts1);
int nPt1 = pts1.GetSize();
if(nPt1<2) continue;
double dis1 = GraphAPI::GGetDisOf2P2D(pts[0].x, pts[0].y, pts1[0].x, pts1[0].y);
double dis2 = GraphAPI::GGetDisOf2P2D(pts[0].x, pts[0].y, pts1[nPt1-1].x, pts1[nPt1-1].y);
if(dis1<dis2)
{
for(k=0; k<nPt1/2; k++)
{
PT_3DEX temp = pts1[k];
pts1[k] = pts1[nPt1-1-k];
pts1[nPt1-1-k] = temp;
}
}
newPts.Copy(pts);
newPts.Append(pts1);
if(0==GraphAPI::GIsClockwise(newPts.GetData(), newPts.GetSize()))
{
int nPt2 = newPts.GetSize();
for(k=0; k<nPt2/2; k++)
{
PT_3DEX temp = newPts[k];
newPts[k] = newPts[nPt2-1-k];
newPts[nPt2-1-k] = temp;
}
}
newPts.Add(newPts[0]);
CGeoSurface *pObj = new CGeoSurface();
if(!pObj->CreateShape(newPts.GetData(), newPts.GetSize()))
{
delete pObj;
}
CFeature *pNew = pFtrTemp->Clone();
pNew->SetGeometry(pObj);
if(!m_pEditor->AddObject(pNew, pStoreLayer->GetID()))
{
delete pObj;
continue;
}
undo.AddNewFeature(FtrToHandle(pNew));
m_pEditor->DeleteObject(FtrToHandle(pFtr));
undo.AddOldFeature(FtrToHandle(pFtr));
m_pEditor->DeleteObject(FtrToHandle(pFtr1));
undo.AddOldFeature(FtrToHandle(pFtr1));
}
delete pFtrTemp;
}
//////////////////////////////////////////////////////////////////////
// CRepairZCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CRepairZCommand,CEditCommand)
CRepairZCommand::CRepairZCommand()
{
}
CRepairZCommand::~CRepairZCommand()
{
}
CString CRepairZCommand::Name()
{
return StrFromResID(IDS_CMDPNAME_REPAIRZ);
}
void CRepairZCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CRepairZCommand::PtClick(PT_3D &pt, int flag)
{
if(!m_pEditor) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
if(!pDQ || !pDS)
return;
int nSum=0, i, j, k;
int nLay = pDS->GetFtrLayerCount();
for(i=0; i<nLay; i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayerByIndex(i);
if(!pLayer || !pLayer->IsVisible())
continue;
nSum += pLayer->GetObjectCount();
}
CUndoModifyProperties undo(m_pEditor,Name());
GProgressStart(nSum);
for(i=0; i<nLay; i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayerByIndex(i);
if(!pLayer || !pLayer->IsVisible())
continue;
int nObj = pLayer->GetObjectCount();
for(j=0; j<nObj; j++)
{
GProgressStep();
CFeature *pFtr = pLayer->GetObject(j);
if(!pFtr || !pFtr->IsVisible())
continue;
CGeometry *pGeo = pFtr->GetGeometry();
if(!pGeo) continue;
CArray<PT_3DEX,PT_3DEX> pts;
pGeo->GetShape(pts);
CVariantEx varEx;
varEx.SetAsShape(pts);
CValueTable oldtab, tab;
oldtab.BeginAddValueItem();
oldtab.AddValue(FIELDNAME_SHAPE,&varEx);
oldtab.EndAddValueItem();
BOOL bChanged = FALSE;
for(k=0; k<pts.GetSize(); k++)
{
if(pts[k].z<-1000)
{
Envelope e;
e.CreateFromPtAndRadius(pts[k], 0.01);
pDQ->FindObjectInRect(e,NULL,FALSE,FALSE);
int num;
const CPFeature *ftr = pDQ->GetFoundHandles(num);
for(int m=0;m<num;m++)
{
if(ftr[m]==pFtr) continue;
CGeometry *pGeo1 = ftr[m]->GetGeometry();
if(!pGeo1) continue;
CArray<PT_3DEX,PT_3DEX> pts1;
pGeo1->GetShape(pts1);
PT_KEYCTRL keypt = pGeo1->FindNearestKeyCtrlPt(pts[k], 0.01, NULL, 1);
if(keypt.IsValid())
{
COPY_3DPT(pts[k], pts1[keypt.index]);
bChanged = TRUE;
break;
}
}
if(m>=num)
{
pts[k].z = ( k==0 ? 0 : pts[0].z );
bChanged = TRUE;
}
}
}
if(bChanged)
{
m_pEditor->DeleteObject(FtrToHandle(pFtr));
pGeo->CreateShape(pts.GetData(), pts.GetSize());
m_pEditor->RestoreObject(FtrToHandle(pFtr));
varEx.SetAsShape(pts);
tab.BeginAddValueItem();
tab.AddValue(FIELDNAME_SHAPE,&varEx);
tab.EndAddValueItem();
undo.SetModifyProperties(FtrToHandle(pFtr),oldtab,tab,TRUE);
}
}
}
undo.Commit();
GProgressEnd();
Finish();
}
//////////////////////////////////////////////////////////////////////
// CRepairLineTypeCommand Class
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CRepairLineTypeCommand,CEditCommand)
CRepairLineTypeCommand::CRepairLineTypeCommand()
{
}
CRepairLineTypeCommand::~CRepairLineTypeCommand()
{
}
CString CRepairLineTypeCommand::Name()
{
return StrFromResID(IDS_CMDNAME_REPAIR_LINETYPE);
}
void CRepairLineTypeCommand::Start()
{
if( !m_pEditor )return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CRepairLineTypeCommand::PtClick(PT_3D &pt, int flag)
{
if(!m_pEditor) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
CDataQueryEx *pDQ = m_pEditor->GetDataQuery();
if(!pDQ || !pDS)
return;
int nSum=0, i, j, k;
int nLay = pDS->GetFtrLayerCount();
for(i=0; i<nLay; i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayerByIndex(i);
if(!pLayer || !pLayer->IsVisible())
continue;
nSum += pLayer->GetObjectCount();
}
CUndoModifyProperties undo(m_pEditor,Name());
GProgressStart(nSum);
int count = 0;
for(i=0; i<nLay; i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayerByIndex(i);
if(!pLayer || !pLayer->IsVisible())
continue;
int nObj = pLayer->GetObjectCount();
for(j=0; j<nObj; j++)
{
GProgressStep();
CFeature *pFtr = pLayer->GetObject(j);
if(!pFtr || !pFtr->IsVisible())
continue;
CGeometry *pGeo = pFtr->GetGeometry();
if(!pGeo) continue;
CArray<PT_3DEX,PT_3DEX> pts;
pGeo->GetShape(pts);
CVariantEx varEx;
varEx.SetAsShape(pts);
CValueTable oldtab, tab;
oldtab.BeginAddValueItem();
oldtab.AddValue(FIELDNAME_SHAPE,&varEx);
oldtab.EndAddValueItem();
BOOL bChanged = FALSE;
int nCls = pGeo->GetClassType();
if(nCls==CLS_GEOPARALLEL || nCls==CLS_GEODCURVE)
{
continue;
}
else if(nCls==CLS_GEOMULTISURFACE)
{
for(k=0; k<pts.GetSize(); k++)
{
if(k==0 && pts[0].pencode!=penLine)
{
pts[0].pencode = penLine;
bChanged = TRUE;
continue;
}
if(pts[k].pencode!=penLine)
{
for(int m=k+1;m<pts.GetSize();m++)
{
if(GraphAPI::GIsEqual2DPoint(&pts[k], &pts[m]))
{
if(pts[k].pencode!=penMove || pts[m].pencode!=penLine)
{
pts[k].pencode = penMove;
pts[m].pencode = penLine;
bChanged = TRUE;
}
break;
}
}
if(m>=pts.GetSize())
{
pts[k].pencode = penLine;
bChanged = TRUE;
}
}
}
}
else
{
for(k=0; k<pts.GetSize(); k++)
{
if(pts[k].pencode!=penLine)
{
pts[k].pencode = penLine;
bChanged = TRUE;
}
}
}
if(bChanged)
{
m_pEditor->DeleteObject(FtrToHandle(pFtr));
pGeo->CreateShape(pts.GetData(), pts.GetSize());
m_pEditor->RestoreObject(FtrToHandle(pFtr));
varEx.SetAsShape(pts);
tab.BeginAddValueItem();
tab.AddValue(FIELDNAME_SHAPE,&varEx);
tab.EndAddValueItem();
undo.SetModifyProperties(FtrToHandle(pFtr),oldtab,tab,TRUE);
count ++;
}
}
}
CString tip;
tip.Format(IDS_MODIFID_OBJSUM, count);
AfxMessageBox(tip);
undo.Commit();
GProgressEnd();
Finish();
}
//////////////////////////////////////////////////////////////////////
// CDHeightToPointCommand Class
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDHeightToPointCommand, CEditCommand)
CDHeightToPointCommand::CDHeightToPointCommand()
{
m_strField = _T("HEIGHT");
}
CDHeightToPointCommand::~CDHeightToPointCommand()
{
}
CString CDHeightToPointCommand::Name()
{
return StrFromResID(IDS_CMDPNAME_DHEIGHT_TO_POINT);
}
void CDHeightToPointCommand::Start()
{
if (!m_pEditor)return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CDHeightToPointCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_strField);
tab.AddValue("strField", &CVariantEx(var));
var = (LPCTSTR)(m_HandleLayer);
tab.AddValue("HandleLayer", &CVariantEx(var));
}
void CDHeightToPointCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("ExplodeDcurveToSurfaceCommand", Name());
param->AddLayerNameParamEx("HandleLayer", (LPCTSTR)m_HandleLayer, StrFromResID(IDS_CMDPLANE_HANDLELAYER), NULL, LAYERPARAMITEM_NOTEMPTY_LINE);
param->AddParam("strField", (LPCTSTR)(m_strField), StrFromResID(IDS_CHK_PARAM_ATTRI_NAME));
}
void CDHeightToPointCommand::SetParams(CValueTable& tab, BOOL bInit)
{
const CVariantEx *var;
if (tab.GetValue(0, "HandleLayer", var))
{
m_HandleLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_HandleLayer.TrimRight();
m_HandleLayer.TrimLeft();
SetSettingsModifyFlag();
}
if (tab.GetValue(0, "strField", var))
{
m_strField = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strField.TrimRight();
m_strField.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab, bInit);
}
void CDHeightToPointCommand::PtClick(PT_3D &pt, int flag)
{
if (!m_pEditor || m_HandleLayer.IsEmpty())
return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if (!pDS) return;
CFtrLayerArray arrLayers;
int i = 0, j = 0;
pDS->GetFtrLayersByNameOrCode_editable(m_HandleLayer, arrLayers);
CUndoFtrs undo(m_pEditor, Name());
for (i = 0; i < arrLayers.GetSize(); i++)
{
CFtrLayer *pLayer = arrLayers[i];
int nObj = pLayer->GetObjectCount();
for (j = 0; j < nObj; j++)
{
CFeature *pFeature = pLayer->GetObject(j);
if (!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoCurve)))
{
continue;
}
CArray<PT_3DEX, PT_3DEX> arrPts, pts;
pGeo->GetShape(arrPts);
if (arrPts.GetSize() != 2) continue;
double height = arrPts[0].z - arrPts[1].z;
pts.Add(arrPts[0]);
CFeature *pNew = pFeature->Clone();
if (!pNew) continue;
if (!pNew->CreateGeometry(CLS_GEOPOINT)) continue;
pNew->GetGeometry()->CreateShape(pts.GetData(), pts.GetSize());
if (!m_pEditor->AddObject(pNew, m_pEditor->GetFtrLayerIDOfFtr(FtrToHandle(pFeature))))
{
delete pNew;
continue;
}
CValueTable tab;
tab.BeginAddValueItem();
_variant_t var(height);
tab.AddValue(m_strField, &CVariantEx(var));
tab.EndAddValueItem();
GETXDS(m_pEditor)->CopyXAttributes(pFeature, pNew);
GETXDS(m_pEditor)->SetXAttributes(pNew, tab);
m_pEditor->DeleteObject(FtrToHandle(pFeature));
undo.AddOldFeature(FtrToHandle(pFeature));
undo.AddNewFeature(FTR_HANDLE(pNew));
}
}
undo.Commit();
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// CDCurveSplitCommand Class
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CDCurveSplitCommand, CEditCommand)
CDCurveSplitCommand::CDCurveSplitCommand()
{
}
CDCurveSplitCommand::~CDCurveSplitCommand()
{
}
CString CDCurveSplitCommand::Name()
{
return StrFromResID(IDS_CMDNAME_SPLTPARALLEL);
}
void CDCurveSplitCommand::Start()
{
if (!m_pEditor)return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CDCurveSplitCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_HandleLayer);
tab.AddValue("HandleLayer", &CVariantEx(var));
var = (LPCTSTR)(m_strLayer1);
tab.AddValue("strLayer1", &CVariantEx(var));
var = (LPCTSTR)(m_strLayer2);
tab.AddValue("strLayer2", &CVariantEx(var));
}
void CDCurveSplitCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("ExplodeDcurveToSurfaceCommand", Name());
param->AddLayerNameParamEx("HandleLayer", (LPCTSTR)m_HandleLayer, StrFromResID(IDS_CMDPLANE_HANDLELAYER), NULL, LAYERPARAMITEM_NOTEMPTY_LINE);
param->AddLayerNameParamEx("strLayer1", (LPCTSTR)m_strLayer1, StrFromResID(IDS_CMDNAME_COPY_BASELINE), NULL, LAYERPARAMITEM_NOTEMPTY_LINE);
param->AddLayerNameParamEx("strLayer2", (LPCTSTR)m_strLayer2, StrFromResID(IDS_CMDPLANE_ASSISTLAYER), NULL, LAYERPARAMITEM_NOTEMPTY_LINE);
}
void CDCurveSplitCommand::SetParams(CValueTable& tab, BOOL bInit)
{
const CVariantEx *var;
if (tab.GetValue(0, "HandleLayer", var))
{
m_HandleLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_HandleLayer.TrimRight();
m_HandleLayer.TrimLeft();
SetSettingsModifyFlag();
}
if (tab.GetValue(0, "strLayer1", var))
{
m_strLayer1 = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strLayer1.TrimRight();
m_strLayer1.TrimLeft();
SetSettingsModifyFlag();
}
if (tab.GetValue(0, "strLayer2", var))
{
m_strLayer2 = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strLayer2.TrimRight();
m_strLayer2.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab, bInit);
}
void CDCurveSplitCommand::ReadFileStrings()
{
if (!PathFileExists(m_HandleLayer))
return;
FILE *fp = fopen(m_HandleLayer, "r");
if (fp)
{
char line[4096];
int pos = 0;
while (!feof(fp))
{
memset(line, 0, sizeof(line));
fgets(line, sizeof(line) - 1, fp);
if (pos == 0)
{
m_HandleLayer = CString(line);
m_HandleLayer.TrimRight();
}
else if (pos == 1)
{
m_strLayer1 = CString(line);
m_strLayer1.TrimRight();
}
else if (pos == 2)
{
m_strLayer2 = CString(line);
m_strLayer2.TrimRight();
}
pos++;
}
fclose(fp);
fp = NULL;
}
}
void CDCurveSplitCommand::PtClick(PT_3D &pt, int flag)
{
if (!m_pEditor) return;
if (m_HandleLayer.IsEmpty())
{
AfxMessageBox(StrFromResID(IDS_PARAM_ERROR));
return;
}
ReadFileStrings();
if (m_strLayer1.IsEmpty() || m_strLayer2.IsEmpty())
{
AfxMessageBox(StrFromResID(IDS_PARAM_ERROR));
return;
}
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if (!pDS) return;
CFtrLayerArray arrLayers;
CStringArray arr1, arr2;
int i = 0, j = 0;
pDS->GetFtrLayersByNameOrCode_editable(m_HandleLayer, arrLayers);
convertStringToStrArray(m_strLayer1, arr1);
convertStringToStrArray(m_strLayer2, arr2);
int nSize = arrLayers.GetSize();
int nSize1 = arr1.GetSize();
int nSize2 = arr2.GetSize();
if (nSize != nSize1 || nSize != nSize2)
{
AfxMessageBox(StrFromResID(IDS_PARAM_ERROR));
return;
}
CUndoFtrs undo(m_pEditor, Name());
for (i = 0; i < arrLayers.GetSize(); i++)
{
CFtrLayer *pLayer = arrLayers[i];
int nObj = pLayer->GetObjectCount();
CFtrLayer *pTargetLayer1 = pDS->GetFtrLayer(arr1.GetAt(i));
if (!pTargetLayer1) continue;
CFtrLayer *pTargetLayer2 = pDS->GetFtrLayer(arr2.GetAt(i));
if (!pTargetLayer2) continue;
CFeature *pTemp1 = pTargetLayer1->CreateDefaultFeature(GETDS(m_pEditor)->GetScale(), CLS_GEOCURVE);
CFeature *pTemp2 = pTargetLayer2->CreateDefaultFeature(GETDS(m_pEditor)->GetScale(), CLS_GEOCURVE);
for (j = 0; j < nObj; j++)
{
CFeature *pFeature = pLayer->GetObject(j);
if (!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo) continue;
CGeometry* pObj1 = NULL;
CGeometry* pObj2 = NULL;
CArray<PT_3DEX, PT_3DEX> pts1, pts2;
if (pGeo->IsKindOf(RUNTIME_CLASS(CGeoDCurve)))
{
((CGeoDCurve*)pGeo)->Separate(pObj1, pObj2);
if (!pObj1 || !pObj2) continue;
pObj1->GetShape(pts1);
pObj2->GetShape(pts2);
delete pObj1;
delete pObj2;
}
else if (pGeo->IsKindOf(RUNTIME_CLASS(CGeoParallel)))
{
((CGeoParallel*)pGeo)->Separate(pObj1, pObj2);
if (!pObj1 || !pObj2) continue;
pObj1->GetShape(pts1);
pObj2->GetShape(pts2);
delete pObj1;
delete pObj2;
}
else
{
continue;
}
CFeature *pNew1 = pTemp1->Clone();
pNew1->GetGeometry()->CreateShape(pts1.GetData(), pts1.GetSize());
if (!m_pEditor->AddObject(pNew1, pTargetLayer1->GetID()))
{
delete pNew1;
continue;
}
undo.AddNewFeature(FTR_HANDLE(pNew1));
CFeature *pNew2 = pTemp2->Clone();
pNew2->GetGeometry()->CreateShape(pts2.GetData(), pts2.GetSize());
if (!m_pEditor->AddObject(pNew2, pTargetLayer2->GetID()))
{
delete pNew2;
continue;
}
undo.AddNewFeature(FTR_HANDLE(pNew2));
m_pEditor->DeleteObject(FtrToHandle(pFeature));
undo.AddOldFeature(FtrToHandle(pFeature));
}
delete pTemp1;
delete pTemp2;
}
undo.Commit();
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// CTextToSurfacePointCommand Class
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CTextToSurfacePointCommand, CEditCommand)
CTextToSurfacePointCommand::CTextToSurfacePointCommand()
{
}
CTextToSurfacePointCommand::~CTextToSurfacePointCommand()
{
}
CString CTextToSurfacePointCommand::Name()
{
return StrFromResID(IDS_MODIFY_TEXTTOSURFACEPOINT);
}
void CTextToSurfacePointCommand::Start()
{
if (!m_pEditor)return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
m_nStep = 0;
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CTextToSurfacePointCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_handleLayers);
tab.AddValue(PF_HANDLELAYERS, &CVariantEx(var));
var = (LPCTSTR)(m_targetLayer);
tab.AddValue(PF_LAYERNAME, &CVariantEx(var));
}
void CTextToSurfacePointCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("PointToSurfacePoint", Name());
param->AddLayerNameParamEx(PF_HANDLELAYERS, (LPCTSTR)m_handleLayers, StrFromResID(IDS_SRC_LAYER), NULL, LAYERPARAMITEM_POINT);
param->AddLayerNameParam(PF_LAYERNAME, (LPCTSTR)m_targetLayer, StrFromResID(IDS_DES_LAYER), NULL, LAYERPARAMITEM_POINT);
}
void CTextToSurfacePointCommand::SetParams(CValueTable& tab, BOOL bInit)
{
const CVariantEx *var;
if (tab.GetValue(0, PF_HANDLELAYERS, var))
{
m_handleLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_handleLayers.TrimLeft();
m_handleLayers.TrimRight();
SetSettingsModifyFlag();
}
if (tab.GetValue(0, PF_LAYERNAME, var))
{
m_targetLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_targetLayer.TrimRight();
m_targetLayer.TrimLeft();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab, bInit);
}
void CTextToSurfacePointCommand::PtClick(PT_3D &pt, int flag)
{
if (!m_pEditor)
return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if (!pDS) return;
CFtrLayer *out_layer = pDS->GetFtrLayer((LPCTSTR)m_targetLayer);
if (out_layer == NULL && m_targetLayer.GetLength() > 0)
{
out_layer = new CFtrLayer();
out_layer->SetName((LPCTSTR)m_targetLayer);
pDS->AddFtrLayer(out_layer);
}
int layid = -1;
if (out_layer)
{
layid = out_layer->GetID();
}
CFtrLayerArray arrLayers;
int i = 0, j = 0;
pDS->GetFtrLayersByNameOrCode_editable(m_handleLayers, arrLayers);
CUndoFtrs undo(m_pEditor, Name());
CFeature *pTempFtr = NULL;
if (out_layer)
{
pTempFtr = out_layer->CreateDefaultFeature(pDS->GetScale(), CLS_GEOSURFACEPOINT);
if (!pTempFtr) return;
}
for (i = 0; i < arrLayers.GetSize(); i++)
{
CFtrLayer *pLayer = arrLayers[i];
int nObj = pLayer->GetObjectCount();
for (j = 0; j < nObj; j++)
{
CFeature *pFeature = pLayer->GetObject(j);
if (!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoText)))
{
continue;
}
CArray<PT_3DEX, PT_3DEX> pts;
pGeo->GetShape(pts);
CFeature *pNew = pTempFtr ? pTempFtr->Clone() : pFeature->Clone();
if (!pNew) continue;
if (!pNew->CreateGeometry(CLS_GEOSURFACEPOINT)) continue;
pNew->GetGeometry()->CreateShape(pts.GetData(), pts.GetSize());
if (!m_pEditor->AddObject(pNew, layid == -1 ? pLayer->GetID() : layid))
{
delete pNew;
continue;
}
if (layid == -1)
{
GETXDS(m_pEditor)->CopyXAttributes(pFeature, pNew);
}
undo.AddNewFeature(FTR_HANDLE(pNew));
undo.AddOldFeature(FtrToHandle(pFeature));
m_pEditor->DeleteObject(FtrToHandle(pFeature));
}
}
if (pTempFtr) delete pTempFtr;
undo.Commit();
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// CAnnoToSurfacePointCommand Class
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CAnnoToSurfacePointCommand, CEditCommand)
CAnnoToSurfacePointCommand::CAnnoToSurfacePointCommand()
{
}
CAnnoToSurfacePointCommand::~CAnnoToSurfacePointCommand()
{
}
CString CAnnoToSurfacePointCommand::Name()
{
return StrFromResID(IDS_MODIFY_ANNOTOSURFACEPOINT);
}
void CAnnoToSurfacePointCommand::Start()
{
if (!m_pEditor)return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
m_nStep = 0;
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CAnnoToSurfacePointCommand::GetParams(CValueTable& tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_strcode);
tab.AddValue(PF_HANDLELAYERS, &CVariantEx(var));
}
void CAnnoToSurfacePointCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("PointToSurfacePoint", Name());
param->AddFileNameParam(PF_HANDLELAYERS, (LPCTSTR)m_strcode, "*.txt|*.txt||", StrFromResID(IDS_TABLE_FILE));
}
void CAnnoToSurfacePointCommand::SetParams(CValueTable& tab, BOOL bInit)
{
const CVariantEx *var;
if (tab.GetValue(0, PF_HANDLELAYERS, var))
{
m_strcode = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strcode.TrimLeft();
m_strcode.TrimRight();
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab, bInit);
}
void CAnnoToSurfacePointCommand::PtClick(PT_3D &pt, int flag)
{
if (!m_pEditor) return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if (!pDS) return;
if (!PathFileExists(m_strcode))
return;
FILE *fp = fopen(m_strcode, "r");
if (!fp) return;
char src[128];
char dst[128];
CStringArray arr1, arr2;
while (!feof(fp))
{
if (2 == fscanf(fp, "%s%s", src, dst))
{
arr1.Add(src);
arr2.Add(dst);
}
}
fclose(fp);
int nSize = arr1.GetSize();
if (nSize <= 0 || arr2.GetSize() != nSize)
return;
CUndoFtrs undo(m_pEditor, Name());
for (int i = 0; i < nSize; i++)
{
CFtrLayer *pLayer = pDS->GetFtrLayer((LPCTSTR)arr1[i]);
if (!pLayer) continue;
int nObj = pLayer->GetObjectCount();
if (nObj < 0) continue;
CFtrLayer *out_layer = pDS->GetFtrLayer((LPCTSTR)arr2[i]);
if (out_layer == NULL)
{
out_layer = new CFtrLayer();
out_layer->SetName((LPCTSTR)arr2[i]);
pDS->AddFtrLayer(out_layer);
if (!out_layer) continue;
}
CFeature *pTempFtr = out_layer->CreateDefaultFeature(pDS->GetScale(), CLS_GEOSURFACEPOINT);
if (!pTempFtr) continue;
for (int j = 0; j < nObj; j++)
{
CFeature *pFeature = pLayer->GetObject(j);
if (!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoText)))
{
continue;
}
CArray<PT_3DEX, PT_3DEX> pts;
pGeo->GetShape(pts);
CFeature *pNew = pTempFtr->Clone();
if (!pNew) continue;
if (!pNew->CreateGeometry(CLS_GEOSURFACEPOINT)) continue;
pNew->GetGeometry()->CreateShape(pts.GetData(), pts.GetSize());
if (!m_pEditor->AddObject(pNew, out_layer->GetID()))
{
delete pNew;
continue;
}
undo.AddNewFeature(FTR_HANDLE(pNew));
undo.AddOldFeature(FtrToHandle(pFeature));
m_pEditor->DeleteObject(FtrToHandle(pFeature));
}
if (pTempFtr) delete pTempFtr;
}
undo.Commit();
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// CChangeDcurveByWidthCommand Class
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CChangeDcurveByWidthCommand, CEditCommand)
CChangeDcurveByWidthCommand::CChangeDcurveByWidthCommand()
{
m_bExplode = FALSE;
}
CChangeDcurveByWidthCommand::~CChangeDcurveByWidthCommand()
{
}
CString CChangeDcurveByWidthCommand::Name()
{
return StrFromResID(IDS_CHANGEDCURVEBYWIDTH);
}
void CChangeDcurveByWidthCommand::Start()
{
if (!m_pEditor)return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CChangeDcurveByWidthCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_HandleLayer);
tab.AddValue("HandleLayer", &CVariantEx(var));
var = (LPCTSTR)(m_strWidth);
tab.AddValue("strWidth", &CVariantEx(var));
var = (LPCTSTR)(m_strLayers);
tab.AddValue("strLayers", &CVariantEx(var));
var = (bool)m_bExplode;
tab.AddValue("bExplode", &CVariantEx(var));
}
void CChangeDcurveByWidthCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("ExplodeDcurveToSurfaceCommand", Name());
param->AddLayerNameParam("HandleLayer", (LPCTSTR)m_HandleLayer, StrFromResID(IDS_PARALLEL_LAYER), NULL, LAYERPARAMITEM_NOTEMPTY_LINE);
param->AddParam("strWidth", (LPCTSTR)m_strWidth, StrFromResID(IDS_WIDTH_CONDITION));
param->AddLayerNameParamEx("strLayers", (LPCTSTR)m_strLayers, StrFromResID(IDS_CONVERTTO_LAYER), NULL, LAYERPARAMITEM_NOTEMPTY_LINE);
param->AddParam("bExplode", (bool)m_bExplode, StrFromResID(IDS_CMDNAME_SEPPARALLEL));
}
void CChangeDcurveByWidthCommand::SetParams(CValueTable& tab, BOOL bInit)
{
const CVariantEx *var;
if (tab.GetValue(0, "HandleLayer", var))
{
m_HandleLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_HandleLayer.TrimRight();
m_HandleLayer.TrimLeft();
SetSettingsModifyFlag();
}
if (tab.GetValue(0, "strWidth", var))
{
m_strWidth = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strWidth.TrimRight();
m_strWidth.TrimLeft();
SetSettingsModifyFlag();
}
if (tab.GetValue(0, "strLayers", var))
{
m_strLayers = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strLayers.TrimRight();
m_strLayers.TrimLeft();
SetSettingsModifyFlag();
}
if (tab.GetValue(0, "bExplode", var))
{
m_bExplode = (bool)(_variant_t)*var;
SetSettingsModifyFlag();
}
CEditCommand::SetParams(tab, bInit);
}
void CChangeDcurveByWidthCommand::PtClick(PT_3D &pt, int flag)
{
if (!m_pEditor) return;
if (m_strWidth.IsEmpty() || m_strLayers.IsEmpty())
{
AfxMessageBox(StrFromResID(IDS_PARAM_ERROR));
return;
}
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if (!pDS) return;
CFtrLayer* pHandleLayer = pDS->GetFtrLayer(m_HandleLayer);
if (!pHandleLayer) return;
CStringArray arr1, arr2;
convertStringToStrArray(m_strWidth, arr1);
convertStringToStrArray(m_strLayers, arr2);
int nSize1 = arr1.GetSize();
int nSize2 = arr2.GetSize();
if (nSize1 != nSize2)
{
AfxMessageBox(StrFromResID(IDS_PARAM_ERROR));
return;
}
//处理宽度组合
double *widths = new double[nSize1 * 2];
int i = 0, j = 0;
for (i = 0; i < nSize1; i++)
{
CString str = arr1[i];
int pos = str.Find('~');
if (pos > 0)
{
widths[2 * i] = strtod(str.Left(pos), NULL);
widths[2 * i + 1] = strtod(str.Mid(pos + 1), NULL);
}
else
{
AfxMessageBox(StrFromResID(IDS_PARAM_ERROR));
return;
}
}
//创建Feature模板
int *ids = new int[nSize2];
FTR_HANDLE *pTempFtrs = new FTR_HANDLE[nSize2];
int scale = GETDS(m_pEditor)->GetScale();
int nCls = m_bExplode ? CLS_GEOCURVE : CLS_GEOPARALLEL;
for (i = 0; i < nSize2; i++)
{
CFtrLayer *pLayer = pDS->GetOrCreateFtrLayer(arr2[i]);
if (pLayer)
{
ids[i] = pLayer->GetID();
pTempFtrs[i] = FtrToHandle(pLayer->CreateDefaultFeature(scale, nCls));
}
else
{
ids[i] = -1;
pTempFtrs[i] = NULL;
}
}
CUndoFtrs undo(m_pEditor, Name());
int nObj = pHandleLayer->GetObjectCount();
for (i = 0; i < nObj; i++)
{
CFeature *pFeature = pHandleLayer->GetObject(i);
if (!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo || !pGeo->IsKindOf(RUNTIME_CLASS(CGeoParallel)))
continue;
double width = ((CGeoParallel*)pGeo)->GetWidth();
for (j = 0; j<nSize1; j++)
{
if (fabs(width)>widths[2 * j] && fabs(width) < widths[2 * j + 1])
{
break;
}
}
if (j >= nSize1 || pTempFtrs[j] == NULL || ids[j] < 0)
continue;
if (m_bExplode)
{
CGeometry* pObj1 = NULL;
CGeometry* pObj2 = NULL;
CArray<PT_3DEX, PT_3DEX> pts1, pts2;
((CGeoParallel*)pGeo)->Separate(pObj1, pObj2);
if (!pObj1 || !pObj2) continue;
pObj1->GetShape(pts1);
pObj2->GetShape(pts2);
delete pObj1;
delete pObj2;
CFeature *pNew1 = HandleToFtr(pTempFtrs[j])->Clone();
pNew1->GetGeometry()->CreateShape(pts1.GetData(), pts1.GetSize());
if (!m_pEditor->AddObject(pNew1, ids[j]))
{
delete pNew1;
continue;
}
CFeature *pNew2 = HandleToFtr(pTempFtrs[j])->Clone();
pNew2->GetGeometry()->CreateShape(pts2.GetData(), pts2.GetSize());
if (!m_pEditor->AddObject(pNew2, ids[j]))
{
delete pNew2;
continue;
}
undo.AddNewFeature(FTR_HANDLE(pNew1));
undo.AddNewFeature(FTR_HANDLE(pNew2));
}
else
{
CArray<PT_3DEX, PT_3DEX> pts;
pGeo->GetShape(pts);
CFeature *pNew = HandleToFtr(pTempFtrs[j])->Clone();
CGeometry *pNewGeo = pNew->GetGeometry();
pNewGeo->CreateShape(pts.GetData(), pts.GetSize());
PT_3DEX expt = ((CGeoParallel*)pGeo)->GetCtrlPoint(0);
expt.pencode = 70;
((CGeoParallel*)pNewGeo)->SetCtrlPoint(0, expt);
if (!m_pEditor->AddObject(pNew, ids[j]))
{
delete pNew;
continue;
}
undo.AddNewFeature(FTR_HANDLE(pNew));
}
m_pEditor->DeleteObject(FtrToHandle(pFeature));
undo.AddOldFeature(FtrToHandle(pFeature));
}
undo.Commit();
delete[] widths;
delete[] ids;
for (i = 0; i < nSize2; i++)
{
if (pTempFtrs[i])
{
delete HandleToFtr(pTempFtrs[i]);
}
}
CCommand::PtClick(pt, flag);
}
//////////////////////////////////////////////////////////////////////
// CPointtoDirPointCommand Class
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CPointtoDirPointCommand, CEditCommand)
CPointtoDirPointCommand::CPointtoDirPointCommand()
{
m_HandleLayer = _T("");
m_strLayer = _T("");
m_bCopyAttr = TRUE;
}
CPointtoDirPointCommand::~CPointtoDirPointCommand()
{
}
CString CPointtoDirPointCommand::Name()
{
return StrFromResID(IDS_CMDPNAME_POINT_TO_DIRPOINT);
}
void CPointtoDirPointCommand::Start()
{
if (!m_pEditor)return;
CEditCommand::Start();
m_pEditor->DeselectAll();
m_pEditor->OnSelectChanged();
m_pEditor->CloseSelector();
GOutPut(StrFromResID(IDS_CMDTIP_PLACELEFTKEY));
}
void CPointtoDirPointCommand::GetParams(CValueTable &tab)
{
CEditCommand::GetParams(tab);
_variant_t var;
var = (LPCTSTR)(m_HandleLayer);
tab.AddValue("HandleLayer", &CVariantEx(var));
var = (LPCTSTR)(m_strLayer);
tab.AddValue("strLayer", &CVariantEx(var));
var = (bool)m_bCopyAttr;
tab.AddValue("CopyAttr", &CVariantEx(var));
}
void CPointtoDirPointCommand::FillShowParams(CUIParam* param, BOOL bForLoad)
{
param->SetOwnerID("ExplodeDcurveToSurfaceCommand", Name());
param->AddLayerNameParamEx("HandleLayer", (LPCTSTR)m_HandleLayer, StrFromResID(IDS_CMDPLANE_HANDLELAYER), NULL, LAYERPARAMITEM_NOTEMPTY_POINT);
param->AddLayerNameParam("strLayer", (LPCTSTR)m_strLayer, StrFromResID(IDS_CONVERTTO_LAYER), NULL, LAYERPARAMITEM_NOTEMPTY_POINT);
param->AddParam("CopyAttr", (bool)m_bCopyAttr, StrFromResID(IDS_CMDNAME_COPYEXT));
}
void CPointtoDirPointCommand::SetParams(CValueTable& tab, BOOL bInit)
{
const CVariantEx *var;
if (tab.GetValue(0, "HandleLayer", var))
{
m_HandleLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_HandleLayer.TrimRight();
m_HandleLayer.TrimLeft();
SetSettingsModifyFlag();
}
if (tab.GetValue(0, "strLayer", var))
{
m_strLayer = (LPCTSTR)(_bstr_t)(_variant_t)*var;
m_strLayer.TrimRight();
m_strLayer.TrimLeft();
SetSettingsModifyFlag();
}
if (tab.GetValue(0, "CopyAttr", var))
{
m_bCopyAttr = (bool)(_variant_t)*var;
}
CEditCommand::SetParams(tab, bInit);
}
void CPointtoDirPointCommand::PtClick(PT_3D &pt, int flag)
{
if (!m_pEditor || m_HandleLayer.IsEmpty())
return;
CDataSourceEx *pDS = m_pEditor->GetDataSource();
if (!pDS) return;
int layid = -1;
if (!m_strLayer.IsEmpty())
{
CFtrLayer *pTagLayer = pDS->GetOrCreateFtrLayer(m_strLayer);
if (!pTagLayer) return;
layid = pTagLayer->GetID();
}
CFtrLayerArray arrLayers;
int i = 0, j = 0;
pDS->GetFtrLayersByNameOrCode_editable(m_HandleLayer, arrLayers);
CUndoFtrs undo(m_pEditor, Name());
for (i = 0; i < arrLayers.GetSize(); i++)
{
CFtrLayer *pLayer = arrLayers[i];
int nObj = pLayer->GetObjectCount();
for (j = 0; j < nObj; j++)
{
CFeature *pFeature = pLayer->GetObject(j);
if (!pFeature) continue;
CGeometry *pGeo = pFeature->GetGeometry();
if (!pGeo || pGeo->GetClassType() != CLS_GEOPOINT)
{
continue;
}
CArray<PT_3DEX, PT_3DEX> arrPts;
pGeo->GetShape(arrPts);
if (arrPts.GetSize() < 1) continue;
double angle = ((CGeoPoint*)pGeo)->GetDirection();
CFeature *pNew = pFeature->Clone();
if (!pNew) continue;
if (!pNew->CreateGeometry(CLS_GEODIRPOINT)) continue;
pNew->GetGeometry()->CreateShape(arrPts.GetData(), arrPts.GetSize());
((CGeoPoint*)pNew->GetGeometry())->SetDirection(angle);
if (!m_pEditor->AddObject(pNew, layid==-1?pLayer->GetID():layid))
{
delete pNew;
continue;
}
if (m_bCopyAttr)
{
GETXDS(m_pEditor)->CopyXAttributes(pFeature, pNew);
}
m_pEditor->DeleteObject(FtrToHandle(pFeature));
undo.AddOldFeature(FtrToHandle(pFeature));
undo.AddNewFeature(FTR_HANDLE(pNew));
}
}
undo.Commit();
CCommand::PtClick(pt, flag);
} | [
"chenjinjing1943@qq.com"
] | chenjinjing1943@qq.com |
709d08763fedd904ea885e222eb64901eb4f3a07 | 4f37a2544e5c665dc5a505f009b62aed78afc455 | /2020/sem1/lecture13_compilation_linking/ex4_class/example_class_2.cpp | b736029e5ace325fddd806497f3be04446504ac0 | [
"MIT"
] | permissive | broniyasinnik/cpp_shad_students | b6ccab3c61943f4167e0621f78fde9b35af39156 | eaff4d24d18afa08ecf8c0c52dfd3acc74e370d0 | refs/heads/master | 2022-10-31T13:49:31.901463 | 2022-10-13T11:08:42 | 2022-10-13T11:08:42 | 250,561,827 | 1 | 0 | MIT | 2020-03-27T14:53:02 | 2020-03-27T14:53:01 | null | UTF-8 | C++ | false | false | 458 | cpp | #include <cstdio>
class HTMLPrinter {
public:
HTMLPrinter();
~HTMLPrinter();
void p();
void div();
private:
void print(const char* s);
};
HTMLPrinter::HTMLPrinter() = default;
HTMLPrinter::~HTMLPrinter() = default;
void HTMLPrinter::p() {
print("<p>");
}
void HTMLPrinter::div() {
print("<div>");
}
void HTMLPrinter::print(const char* const s) {
std::puts(s);
}
void f() {
HTMLPrinter printer;
printer.p();
}
| [
"ivafanas@gmail.com"
] | ivafanas@gmail.com |
b4e76b5edeeebd48d513189169587bfe9c51d080 | 0a36256dee97d0b5c008b0931bf0ba31a5946cd8 | /CompetitiveProgramming/code/Towers.cpp | 1c1a4fe985dfb405abe1f399aa5e6b8ff8abb4cf | [] | no_license | gianmarcosilluzio/CompetitiveProgramming | a5c4043bc249c24649525835afb474ca7b060ed2 | 54fb279e795274e65a5c8cdbe2e99bc84c8a9117 | refs/heads/master | 2021-09-04T10:14:51.143184 | 2018-01-17T22:03:50 | 2018-01-17T22:03:50 | 104,198,996 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,465 | cpp | /*
* Towers.cpp
*
* Created on: 26 set 2017
* Updated on: 03 jan 2018
* Author: Gianmarco Silluzio
* Problem: http://codeforces.com/problemset/problem/37/A?locale=en
* Description Solution:
* The idea is sort the array elements, keep track maximum value level, and increment towers counter when current element is different from the next item.
* Time complexity --> O(nlog(N)) of sort and O(n) of loop
* Space complexity --> O(n) for loop and O(n) auxiliary space for sort.
*
*/
#include<iostream>
#include <algorithm>
#include <vector>
using namespace std;
vector<int> getTowers(int n, vector<int> vec){
int tot = 0, currentLength = 0, currentHeight = 0, max = 1;
for(int i = 0; i < n; i++) {
if(vec[i] == currentLength) {
currentHeight += 1;
if(currentHeight > max){
max = currentHeight;
}
} else {
currentLength = vec[i];
currentHeight = 1;
tot++;
}
}
return {max, tot};
}
int main(){
int n = 0;
cin >> n;
vector<int> inputs;
inputs.reserve(n);
for(int i = 0; i < n; i++){
int elem = 0;
cin >> elem;
inputs.push_back(elem);
}
sort(inputs.begin(), inputs.end());
vector<int> results = getTowers(n, inputs);
cout << results[0] << " " << results[1];
return 0;
}
| [
"silluziogianmarco@gmail.com"
] | silluziogianmarco@gmail.com |
fff87a6603407c1350e2be5b3612a35e6efd9a84 | 2fdec958bc5378e0b6208019996b14a28bb27c7f | /Clipping polygons/CAddShapeDlg.h | 23b490b3fc5599cf88bcf589b5359ed73d375a72 | [] | no_license | alexey3nemckovich/ClippingPolygons | 0a33f5a5d7ed757048b14c3d34ec8e65b2840707 | 4a8e93a3930299983ac6a1ccb833b18f6d0a0bf4 | refs/heads/master | 2021-05-16T17:40:28.388053 | 2017-09-14T05:43:41 | 2017-09-14T05:45:27 | 102,977,559 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 629 | h | #pragma once
#include "afxwin.h"
#include <vector>
using namespace std;
class CAddShapeDlg
: public CDialogEx
{
public:
CAddShapeDlg();
~CAddShapeDlg();
// Dialog Data
#ifdef AFX_DESIGN_TIME
enum { IDD = IDD_NEW_SHAPE_DIALOG};
#endif
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
DECLARE_MESSAGE_MAP()
afx_msg void OnOk();
// CComboBox _comboBoxShapeType;
private:
CComboBox _shapeTypeBox;
// int _selectedShapeTypeIndex;
int _shapeHeight;
int _shapeWidth;
vector<CString> _shapeTypeNames;
protected:
virtual BOOL OnInitDialog();
public:
CString _selectedShapeTypeName;
};
| [
"alexey3nemckovich@gmail.com"
] | alexey3nemckovich@gmail.com |
d8f2c1d446c2c84df82da8f2cefcad983c8699e4 | 3bf8f51594a222c1abb70e31fb4ef613c08e019d | /easy/cpp/0013.cpp | 64178dfb230a8ea791b9ba2ccab96edfbcdf2d24 | [] | no_license | choupingru/leetcode | 9615bbf49f77c2dab5786d89451ab428f0df4931 | 40f21b4bda3cdfa5f6d33a322cf99f456fd1666c | refs/heads/main | 2023-01-03T14:07:02.743831 | 2020-11-01T12:42:03 | 2020-11-01T12:42:03 | 309,067,156 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 541 | cpp | class Solution {
public:
int romanToInt(string s) {
map<char, int> table = {
{'I', 1},
{'V', 5},
{'X', 10},
{'L', 50},
{'C', 100},
{'D', 500},
{'M', 1000}
};
int number = 0;
int size = s.length();
for(int i = 0 ; i < size - 1; i++){
if(table[s[i]] >= table[s[i+1]])number += table[s[i]];
else number -= table[s[i]];
}
number += table[s[size-1]];
return number;
}
}; | [
"pingruchou1125tw@gmail.com"
] | pingruchou1125tw@gmail.com |
9b0fb28048ffda6f36035fc7a4e6944ba8725b4d | b22e0f0ffed31455e816dbf8c0b98a0d7ce896f8 | /main/pwm_rgb_led.h | b2ff7ba3bc0779aeaaa269af56d34bff4be57f9f | [
"CC0-1.0"
] | permissive | BenCorneau/arduino-led-control | 878ab4ed17419ac74c42ce3ed4ec3bb9951143a1 | 267c9463f19a9de715aad42fdf2e50d84c3c76ff | refs/heads/master | 2022-12-15T03:53:06.582149 | 2020-08-13T04:18:58 | 2020-08-13T04:18:58 | 287,171,530 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 867 | h | #pragma once
#include "rgb_led.h"
/**
* An implemetnion of an RGB led controlled by 3 PWM (Pulse Width Modified) pins.
*/
class PwmRgbLed : public RgbLed {
private:
const byte redPin;
const byte greenPin;
const byte bluePin;
public:
PwmRgbLed (byte redPin_PWM, byte greenPin_PWM, byte bluePin_PWM)
:redPin{redPin_PWM}, greenPin{greenPin_PWM}, bluePin{bluePin_PWM} {}
public:
void init(){
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
}
void setColor(byte red, byte green, byte blue){
//analogWrite will set the PWM duty cylce so a value of 0 is always on and 255 is off
analogWrite(redPin, 255 - red);
analogWrite(greenPin, 255 - green);
analogWrite(bluePin, 255 - blue);
}
};
| [
"ben.corneau@coxautoinc.com"
] | ben.corneau@coxautoinc.com |
c598bda58fdf9bfc69334586692bfd822c03279f | c1f445ea04f51c6f16495cdea9a179c85f53b011 | /101_Symmetric_Tree.cpp | 5b5ff75baf0cd1b09bc95dd59ee7b1b496dc96e8 | [] | no_license | wyjss2015/LeetCode | 1981c9c9c4b45709aa70afcacee93850975a68ed | 48e4e5713d8d49d335b4e03185a51ffe764629e0 | refs/heads/master | 2021-01-01T05:15:41.121603 | 2016-09-23T13:55:00 | 2016-09-23T13:55:00 | 59,494,230 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,499 | cpp | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if(root==nullptr)
return true;
vector<int> leftChild, rightChild;
leftChild = DFS(root->left, 'l');
rightChild = DFS(root->right, 'r');
if(leftChild==rightChild)
return true;
else
return false;
}
vector<int> DFS(TreeNode *root, char direction){
vector<int> flag, leftChild, rightChild;
if(root==nullptr){
flag.push_back(-1);
return flag;
}
flag.push_back(root->val);
leftChild = DFS(root->left, direction);
rightChild = DFS(root->right, direction);
if(direction=='l'){
for(auto a:leftChild)
flag.push_back(a);
for(auto a:rightChild)
flag.push_back(a);
}else{
for(auto a:rightChild)
flag.push_back(a);
for(auto a:leftChild)
flag.push_back(a);
}
return flag;
}
};
//Solution 2 recurtive
class Solution {
public:
bool isSymmetric(TreeNode* root) {
return !root||isSymmetricHelper(root->left, root->right);
}
bool isSymmetricHelper(TreeNode *left, TreeNode *right){
if(left==nullptr||right==nullptr)
return left == right;
else if(left->val!=right->val)
return false;
else{
return isSymmetricHelper(left->left, right->right) && isSymmetricHelper(left->right, right->left);
}
}
};
//Solution 3 iterative
class Solution {
public:
bool isSymmetric(TreeNode* root) {
return !root||isSymmetricHelper(root->left, root->right);
}
bool isSymmetricHelper(TreeNode *left, TreeNode *right){
if(left==nullptr||right==nullptr)
return left==right;
else if(left->val!=right->val)
return false;
else{
TreeNode *leftStack[100], *rightStack[100];
int leftStackFlag[100], rightStackFlag[100];
int leftTop=-1, rightTop=-1;
leftStack[++leftTop] = left;
leftStackFlag[leftTop] = 0;
rightStack[++rightTop] = right;
rightStackFlag[rightTop] = 0;
while(leftTop!=-1&&rightTop!=-1){
left = leftStack[leftTop];
right = rightStack[rightTop];
if(leftStackFlag[leftTop]==0){
if(left->left==nullptr||right->right==nullptr){
if(left->left == right->right){
leftStackFlag[leftTop] = 1;
rightStackFlag[rightTop] = 1;
continue;
}else
return false;
}else if(left->left->val!=right->right->val)
return false;
else{
leftStackFlag[leftTop] = 1;
leftStack[++leftTop] = left->left;
leftStackFlag[leftTop] = 0;
rightStackFlag[rightTop] = 1;
rightStack[++rightTop] = right->right;
rightStackFlag[rightTop] = 0;
}
}else if(leftStackFlag[leftTop]==1){
if(left->right==nullptr||right->left==nullptr){
if(left->right == right->left){
leftStackFlag[leftTop] = 2;
rightStackFlag[rightTop] = 2;
continue;
}else
return false;
}else if(left->right->val!=right->left->val)
return false;
else{
leftStackFlag[leftTop] = 2;
leftStack[++leftTop] = left->right;
leftStackFlag[leftTop] = 0;
rightStackFlag[rightTop] = 2;
rightStack[++rightTop] = right->left;
rightStackFlag[rightTop] = 0;
}
}else{
--leftTop;
--rightTop;
}
}
return true;
}
}
};
| [
"wyjss08@gmail.com"
] | wyjss08@gmail.com |
1628e3d4295c2d1e2f91bf36b8efa382676460e4 | 222b4ee1dfe6b471cb65945e42949fd54ccd18de | /Project1 - Forms/Project1 - Forms/solve.cpp | 9967e508838b934f0cf566e653268b123165f8e3 | [] | no_license | rarescheseli/313CAb-1 | fc1962a3d4872f6b7466e288118d960690b8a274 | 7901c00aa0ff21b012052a4444d698c610f66103 | refs/heads/master | 2021-01-10T23:19:35.883321 | 2016-04-13T11:14:21 | 2016-04-13T11:14:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,217 | cpp | #include "Classes.h"
Solve::Solve()
{
}
Solve::~Solve()
{
}
void Solve::Task1a(ResizableArray < Magazin > &magazine, Produs *produse, Hash < string, int > &H) {
int szBon;
string idBon;
ofstream g("output/task1a.txt");
int magSz = magazine.size();
for (int i = 0; i < magSz; ++i) {
int totalVanzari = 0;
for (int j = 1; j < 367; ++j) {
int bonuriZi = magazine[i].zi[j].size(); // cate bonuri am vandut in ziua j
for (int k = 0; k < bonuriZi; ++k) {
idBon = magazine[i].zi[j][k];
ResizableArray < int > continutBon = H.getValue(idBon);
szBon = continutBon.size();
for (int l = 0; l < szBon; ++l) {
totalVanzari += produse[continutBon[l]].getPret();
}
}
}
g << magazine[i].getLocatie() << ',' << totalVanzari << '\n';
}
g.close();
}
void Solve::Task1b(Hash < string, int > &H, Produs *produse,
ResizableArray < Bon < int, string, time_t > > &bonuri) {
ofstream g("output/task1b.txt");
int szBonuri = bonuri.size();
int fcvProduse[NumarProduse] = {0}; // fcvProduse[i] = de cate ori am vandut produsul cu id-ul i
for (int i = 0; i < szBonuri; ++i) {
ResizableArray < int > continutBon = H.getValue(bonuri[i].idBon);
int szContinut = continutBon.size();
for (int j = 0; j < szContinut; ++j) {
++fcvProduse[continutBon[j]];
}
}
for (int i = 0; i < NumarProduse; ++i) {
if (fcvProduse[i] > 0) {
g << produse[i].getNume() << ',' << fcvProduse[i] * produse[i].getPret() << '\n';
}
}
g.close();
}
void Solve::Task1c(Hash < string, int > &H, Produs *produse,
ResizableArray < Bon < int, string, time_t > > &bonuri) {
double costTotal = 0;
int szBonuri = bonuri.size();
for (int i = 0; i < szBonuri; ++i) {
ResizableArray < int > continutBon = H.getValue(bonuri[i].idBon);
int szContinut = continutBon.size();
for (int j = 0; j < szContinut; ++j) {
costTotal += produse[ continutBon[j] ].getPret();
}
}
cout << "Valoare cosului mediu este: "<<
(1.0 * costTotal / (double)bonuri.size()) <<'\n';
}
void Solve::Task1d(ResizableArray<Magazin> &magazine, Hash < string,
int > &hBonuri, Categorii &cat, Produs *produse) {
string idBon, categoria;
int szBon;
for (int idmag = 0; idmag < (int)magazine.size(); ++idmag) {
int *fcvCateg = new int[cat.GetSize()]();
for (int i = 1; i < 367; ++i) {
for (int j = 0; j < (int)magazine[idmag].zi[i].size(); ++j) {
idBon = magazine[idmag].zi[i][j];
ResizableArray < int > continut = hBonuri.getValue(idBon);
szBon = continut.size();
for (int k = 0; k < szBon; ++k) {
categoria = produse[continut[k]].getCategorie();
fcvCateg[cat.GetId(categoria)] += 1;
}
}
}
cout << "Pentru magazinul din " << magazine[idmag].getLocatie();
cout << " cele mai vandute 3 categorii au fost:" << '\n' << "\t";
int max[3] = { -1 }, luna=0, zi=0;
Maxime(fcvCateg, cat.GetSize(), max[0], max[1], max[2]);
for (int k = 0; k < 3; ++k) {
for (int i = 1; i < cat.GetSize(); ++i) {
if (fcvCateg[i] == max[k])
cout << cat.Get(i) << ' ';
}
cout << "de " << max[k] << " ori " << '\n' << '\t';
}
cout << '\n';
delete[] fcvCateg;
}
}
void Solve::Task1e(Hash < string, int > &H, Produs *produse,
ResizableArray < Bon < int, string, time_t > > &bonuri) {
Pair < int, int > pereche;
List < Pair < int, int > > bestPair;
// numar intr-o matrice de cate ori apare
// perechea (i, j) pe bonuri
int **perechi;
perechi = new int*[NumarProduse];
int i;
for (i = 0; i < NumarProduse; i++) {
perechi[i] = new int[NumarProduse]();
}
int bonActual=0, nrBonuri=0, nrProduse=0;
int maxVanzari = 1; // trebuie sa fie vandute cel putin o data
int prod1, prod2;
bool inList;
int szBonuri = bonuri.size();
for (int i = 0; i < szBonuri; ++i) {
int *fcvProduse = new int[NumarProduse]();
ResizableArray < int > continutBon = H.getValue(bonuri[i].idBon);
int szContinut = continutBon.size();
// daca e un singur produs pe bon, nu avem ce verifica
if (szContinut < 2) continue;
for (int j = 0; j < szContinut; ++j) {
fcvProduse[continutBon[j]]++;
}
for (int j = 0; j < szContinut - 1; ++j) {
for (int k = j + 1; k < szContinut; ++k) {
prod1 = continutBon[j];
prod2 = continutBon[k];
if (prod1 == prod2) continue;
bonActual = Min(fcvProduse[prod1], fcvProduse[prod2]);
perechi[prod1][prod2] += bonActual;
perechi[prod2][prod1] += bonActual;
pereche.makePair(prod1, prod2);
if (perechi[prod1][prod2] == maxVanzari) {
// adaug la lista cu cele mai bine vandute perechi
inList = bestPair.getpos(pereche) < 0 ? 0 : 1;
if (!inList) bestPair.push_back(pereche);
}
if (perechi[prod1][prod2] > maxVanzari) {
// resetez lista cu cele mai bine vandute perechi
bestPair.clear();
maxVanzari = perechi[prod1][prod2];
bestPair.push_back(pereche);
}
}
}
delete[] fcvProduse;
}
if (bestPair.empty()) {
cout << "Nu exista nicio pereche de produse vandute bine impreuna\n";
return;
}
cout << "Perechile de produse cel mai bine vandute impreuna sunt:\n\n";
Node < Pair < int, int> > *perecheP; //pointer la pereche
perecheP = bestPair.first();
while (perecheP != NULL) {
prod1 = perecheP->value.first;
prod2 = perecheP->value.second;
cout << produse[prod1].getNume() << ", ";
cout << produse[prod2].getNume() << "\n";
perecheP = perecheP->next;
}
cout << "Aceste perechi au fost vandute de " << maxVanzari << " ori\n";
}
// cele mai mari 3 elemente dintr-un vector
void Solve::Maxime(int *v, int sz, int &max1, int &max2, int &max3)
{
for (int i = 1; i < sz; ++i) {
if (v[i] < max1)
{
if (v[i] < max2)
{
if (v[i] > max3) max3 = v[i];
}
else
if (v[i] > max2)
{
max3 = max2;
max2 = v[i];
}
}
else
if (v[i] > max1)
{
max3 = max2;
max2 = max1;
max1 = v[i];
}
}
}
// Converteste zilele trecute in format luna, zi
void Solve::ZileToData(int trecute, int &luna, int &zi) {
unsigned short v[] = { 1, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 367 };
for (int i = 1; i < 13; ++i)
if (trecute >= v[i - 1] && trecute < v[i]) {
luna = i;
zi = trecute - v[i - 1] + 1;
}
}
void Solve::Task2a(ResizableArray<Magazin> &magazine, Hash < string, int > &hBonuri) {
int *fcvVanzari = new int[367]();
int vanzareInZi;
string idBon;
ofstream g("output/NrProdusePeZile2a.txt");
cout << "Zilele in care au fost cele mai multe produse vandute sunt:" << '\n';
for (int idmag = 0; idmag < (int)magazine.size(); ++idmag) {
cout << "Pentru magazinul din locatia " << magazine[idmag].getLocatie() << '\n' << '\t';
int *fcvVanzari = new int[367]();
for (int i = 1; i < 367; ++i) {
vanzareInZi = 0;
for (int j = 0; j < (int)magazine[idmag].zi[i].size(); ++j) {
idBon = magazine[idmag].zi[i][j];
ResizableArray < int > continut = hBonuri.getValue(idBon);
vanzareInZi += continut.size();
}
fcvVanzari[i] += vanzareInZi;
}
for (int i = 1; i < 367; ++i)
g << i << ',' << fcvVanzari[i] << '\n';
// g << '%' << '\n';
int max[3] = { -1 }, luna, zi;
Maxime(fcvVanzari, 367, max[0], max[1], max[2]);
for (int k = 0; k < 3; ++k) {
for (int i = 1; i < 367; ++i) {
if (fcvVanzari[i] == max[k]) {
ZileToData(i, luna, zi);
cout << "2016/" << luna << '/' << zi << ' ';
}
}
cout << "-> " << max[k] << " produse" << '\n' << '\t';
}
cout << '\n';
delete[] fcvVanzari;
}
g.close();
}
void Solve::Task2b(ResizableArray<Magazin> &magazine, Hash < string, int > &hBonuri) {
ofstream g("output/NrCumparatoriPeZile2b.txt");
cout << "Zilele in care au fost cei mai multi cumparatori sunt:" << '\n';
for (int idmag = 0; idmag < (int)magazine.size(); ++idmag) {
int *fcvBonuri = new int[367]();
for (int i = 1; i < 367; ++i) {
fcvBonuri[i] += magazine[idmag].zi[i].size();
}
cout << "Pentru magazinul din locatia " << magazine[idmag].getLocatie() << '\n' << '\t';
for (int i = 1; i < 367; ++i)
g << i << ',' << fcvBonuri[i] << '\n';
g << '%' << '\n';
int max[3] = { -1 }, luna, zi;
Maxime(fcvBonuri, 367, max[0], max[1], max[2]);
for (int k = 0; k < 3; ++k) {
for (int i = 1; i < 367; ++i) {
if (fcvBonuri[i] == max[k]) {
ZileToData(i, luna, zi);
cout << "2016/" << luna << '/' << zi << ' ';
}
}
cout << "-> " << max[k] << " cumparatori " << '\n' << '\t';
}
delete[] fcvBonuri;
cout << '\n';
}
g.close();
}
void Solve::Task2c(string idBon, Hash < string, int > &H, Produs *produse) {
ResizableArray < int > continut = H.getValue(idBon);
if (continut.size() == 0) {
cout << "Id de bon invalid!\n";
return;
}
cout << "Bonul cu id-ul " << idBon << " contine urmatoarele produse:\n";
int sz = continut.size();
for (int i = 0; i < sz; ++i) {
cout << " " << produse[continut[i]].getNume() << '\n';
}
}
void Solve::Task2d(ResizableArray < Bon < int, string, time_t > > &bonuri, Hash < string, int > &H) {
int szBonuri = bonuri.size();
int nrClienti = 0;
int i, szContinut, timpPerTranzactie;
time_t timp1, timp2;
for (i = 0; i < szBonuri - 1; ++i) {
szContinut = H.getValue(bonuri[i].idBon).size();
timpPerTranzactie = szContinut * TimpPerProdus;
timp1 = bonuri[i].timestamp;
timp2 = bonuri[i + 1].timestamp;
if (timp2 - timp1 < timpPerTranzactie &&
bonuri[i].idMag == bonuri[i + 1].idMag) {
nrClienti++;
}
if (bonuri[i].idMag != bonuri[i + 1].idMag) {
cout << "In magazinul " << bonuri[i].idMag;
if (nrClienti == 0) {
cout << ", niciun client nu ar beneficia de introducerea unei a doua case.\n";
continue;
}
cout << ", " << nrClienti << " clienti ar beneficia de o a doua casa.\n";
nrClienti = 0;
}
}
cout << "In magazinul " << bonuri[i].idMag;
if (nrClienti == 0) {
cout << ", niciun client nu ar beneficia de introducerea unei a doua case.\n";
return;
}
cout << ", " << nrClienti << " clienti ar beneficia de o a doua casa.\n";
}
void Solve::Task3a(int idProdus, DepozitGlobal& depozit) {
int idSlot;
idSlot = depozit.FindSlot(idProdus);
cout << "Produsul a fost gasit in slotul: "<< idSlot <<'\n';
}
void Solve::Task3b(int idProdus,DepozitGlobal& depozit) {
if (depozit.Comanda(idProdus)) cout << "Comanda onorata" << '\n';
else cout << "Comanda nu a putut fi onorata" << "\n";
}
void Solve::Task3c(ResizableArray < Bon < int, string, time_t > > &bonuri,
ResizableArray< Magazin > magazine, DepozitGlobal depozit, Hash < string, int > &hBonuri) {
ResizableArray <int> produse;
int nrBonuri = bonuri.size() - 1;
int i, j;
for (i = 0; i <= nrBonuri; i++) {
produse = hBonuri.getValue(bonuri[i].idBon);
for (j = 0; j < (int)produse.size(); j++) {
int check = magazine[bonuri[i].idMag-1].removeProdus(produse[j], 1, depozit);
if (check == -1) {
cout << "\nDupa realizarea tranzactiei bonului cu id-ul "
<< bonuri[i].idBon << ", magazinul cu id-ul " << bonuri[i].idMag << " a cerut depozitului" <<
" un palet de produse cu id-ul " << produse[j]
<< ". Depozitul nu a putut onora aceasta comanda.\n";
return;
}
}
}
}
| [
"alexandru.lincan@stud.acs.upb.ro"
] | alexandru.lincan@stud.acs.upb.ro |
08119982d75476856af70d0afdbbabb9f443165d | 415e315dae2850532d777aec335dc1fbd7566729 | /clang/lib/CodeGen/CGBuiltin.cpp | 7f231425db61e97c5f6ef62f2aae2b7f80fabf1a | [
"NCSA",
"LLVM-exception",
"Apache-2.0"
] | permissive | WYK15/swift-Ollvm12 | e5409339b290e0e7f38c9516999b3a684839782e | c1cdde6cc2e99222883c16db63dd6a3ff9592bb4 | refs/heads/main | 2023-03-31T17:22:21.257139 | 2021-04-07T02:45:43 | 2021-04-07T02:45:43 | 355,389,882 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 739,629 | cpp | //===---- CGBuiltin.cpp - Emit LLVM Code for builtins ---------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This contains code to emit Builtin calls as LLVM code.
//
//===----------------------------------------------------------------------===//
#include "CGCXXABI.h"
#include "CGObjCRuntime.h"
#include "CGOpenCLRuntime.h"
#include "CGRecordLayout.h"
#include "CodeGenFunction.h"
#include "CodeGenModule.h"
#include "ConstantEmitter.h"
#include "PatternInit.h"
#include "TargetInfo.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Decl.h"
#include "clang/AST/OSLog.h"
#include "clang/Basic/TargetBuiltins.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/CodeGen/CGFunctionInfo.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/InlineAsm.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/IntrinsicsAArch64.h"
#include "llvm/IR/IntrinsicsAMDGPU.h"
#include "llvm/IR/IntrinsicsARM.h"
#include "llvm/IR/IntrinsicsBPF.h"
#include "llvm/IR/IntrinsicsHexagon.h"
#include "llvm/IR/IntrinsicsNVPTX.h"
#include "llvm/IR/IntrinsicsPowerPC.h"
#include "llvm/IR/IntrinsicsR600.h"
#include "llvm/IR/IntrinsicsS390.h"
#include "llvm/IR/IntrinsicsWebAssembly.h"
#include "llvm/IR/IntrinsicsX86.h"
#include "llvm/IR/MDBuilder.h"
#include "llvm/IR/MatrixBuilder.h"
#include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/ScopedPrinter.h"
#include "llvm/Support/X86TargetParser.h"
#include <sstream>
using namespace clang;
using namespace CodeGen;
using namespace llvm;
static
int64_t clamp(int64_t Value, int64_t Low, int64_t High) {
return std::min(High, std::max(Low, Value));
}
static void initializeAlloca(CodeGenFunction &CGF, AllocaInst *AI, Value *Size,
Align AlignmentInBytes) {
ConstantInt *Byte;
switch (CGF.getLangOpts().getTrivialAutoVarInit()) {
case LangOptions::TrivialAutoVarInitKind::Uninitialized:
// Nothing to initialize.
return;
case LangOptions::TrivialAutoVarInitKind::Zero:
Byte = CGF.Builder.getInt8(0x00);
break;
case LangOptions::TrivialAutoVarInitKind::Pattern: {
llvm::Type *Int8 = llvm::IntegerType::getInt8Ty(CGF.CGM.getLLVMContext());
Byte = llvm::dyn_cast<llvm::ConstantInt>(
initializationPatternFor(CGF.CGM, Int8));
break;
}
}
if (CGF.CGM.stopAutoInit())
return;
auto *I = CGF.Builder.CreateMemSet(AI, Byte, Size, AlignmentInBytes);
I->addAnnotationMetadata("auto-init");
}
/// getBuiltinLibFunction - Given a builtin id for a function like
/// "__builtin_fabsf", return a Function* for "fabsf".
llvm::Constant *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD,
unsigned BuiltinID) {
assert(Context.BuiltinInfo.isLibFunction(BuiltinID));
// Get the name, skip over the __builtin_ prefix (if necessary).
StringRef Name;
GlobalDecl D(FD);
// If the builtin has been declared explicitly with an assembler label,
// use the mangled name. This differs from the plain label on platforms
// that prefix labels.
if (FD->hasAttr<AsmLabelAttr>())
Name = getMangledName(D);
else
Name = Context.BuiltinInfo.getName(BuiltinID) + 10;
llvm::FunctionType *Ty =
cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType()));
return GetOrCreateLLVMFunction(Name, Ty, D, /*ForVTable=*/false);
}
/// Emit the conversions required to turn the given value into an
/// integer of the given size.
static Value *EmitToInt(CodeGenFunction &CGF, llvm::Value *V,
QualType T, llvm::IntegerType *IntType) {
V = CGF.EmitToMemory(V, T);
if (V->getType()->isPointerTy())
return CGF.Builder.CreatePtrToInt(V, IntType);
assert(V->getType() == IntType);
return V;
}
static Value *EmitFromInt(CodeGenFunction &CGF, llvm::Value *V,
QualType T, llvm::Type *ResultType) {
V = CGF.EmitFromMemory(V, T);
if (ResultType->isPointerTy())
return CGF.Builder.CreateIntToPtr(V, ResultType);
assert(V->getType() == ResultType);
return V;
}
/// Utility to insert an atomic instruction based on Intrinsic::ID
/// and the expression node.
static Value *MakeBinaryAtomicValue(
CodeGenFunction &CGF, llvm::AtomicRMWInst::BinOp Kind, const CallExpr *E,
AtomicOrdering Ordering = AtomicOrdering::SequentiallyConsistent) {
QualType T = E->getType();
assert(E->getArg(0)->getType()->isPointerType());
assert(CGF.getContext().hasSameUnqualifiedType(T,
E->getArg(0)->getType()->getPointeeType()));
assert(CGF.getContext().hasSameUnqualifiedType(T, E->getArg(1)->getType()));
llvm::Value *DestPtr = CGF.EmitScalarExpr(E->getArg(0));
unsigned AddrSpace = DestPtr->getType()->getPointerAddressSpace();
llvm::IntegerType *IntType =
llvm::IntegerType::get(CGF.getLLVMContext(),
CGF.getContext().getTypeSize(T));
llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace);
llvm::Value *Args[2];
Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
Args[1] = CGF.EmitScalarExpr(E->getArg(1));
llvm::Type *ValueType = Args[1]->getType();
Args[1] = EmitToInt(CGF, Args[1], T, IntType);
llvm::Value *Result = CGF.Builder.CreateAtomicRMW(
Kind, Args[0], Args[1], Ordering);
return EmitFromInt(CGF, Result, T, ValueType);
}
static Value *EmitNontemporalStore(CodeGenFunction &CGF, const CallExpr *E) {
Value *Val = CGF.EmitScalarExpr(E->getArg(0));
Value *Address = CGF.EmitScalarExpr(E->getArg(1));
// Convert the type of the pointer to a pointer to the stored type.
Val = CGF.EmitToMemory(Val, E->getArg(0)->getType());
Value *BC = CGF.Builder.CreateBitCast(
Address, llvm::PointerType::getUnqual(Val->getType()), "cast");
LValue LV = CGF.MakeNaturalAlignAddrLValue(BC, E->getArg(0)->getType());
LV.setNontemporal(true);
CGF.EmitStoreOfScalar(Val, LV, false);
return nullptr;
}
static Value *EmitNontemporalLoad(CodeGenFunction &CGF, const CallExpr *E) {
Value *Address = CGF.EmitScalarExpr(E->getArg(0));
LValue LV = CGF.MakeNaturalAlignAddrLValue(Address, E->getType());
LV.setNontemporal(true);
return CGF.EmitLoadOfScalar(LV, E->getExprLoc());
}
static RValue EmitBinaryAtomic(CodeGenFunction &CGF,
llvm::AtomicRMWInst::BinOp Kind,
const CallExpr *E) {
return RValue::get(MakeBinaryAtomicValue(CGF, Kind, E));
}
/// Utility to insert an atomic instruction based Intrinsic::ID and
/// the expression node, where the return value is the result of the
/// operation.
static RValue EmitBinaryAtomicPost(CodeGenFunction &CGF,
llvm::AtomicRMWInst::BinOp Kind,
const CallExpr *E,
Instruction::BinaryOps Op,
bool Invert = false) {
QualType T = E->getType();
assert(E->getArg(0)->getType()->isPointerType());
assert(CGF.getContext().hasSameUnqualifiedType(T,
E->getArg(0)->getType()->getPointeeType()));
assert(CGF.getContext().hasSameUnqualifiedType(T, E->getArg(1)->getType()));
llvm::Value *DestPtr = CGF.EmitScalarExpr(E->getArg(0));
unsigned AddrSpace = DestPtr->getType()->getPointerAddressSpace();
llvm::IntegerType *IntType =
llvm::IntegerType::get(CGF.getLLVMContext(),
CGF.getContext().getTypeSize(T));
llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace);
llvm::Value *Args[2];
Args[1] = CGF.EmitScalarExpr(E->getArg(1));
llvm::Type *ValueType = Args[1]->getType();
Args[1] = EmitToInt(CGF, Args[1], T, IntType);
Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
llvm::Value *Result = CGF.Builder.CreateAtomicRMW(
Kind, Args[0], Args[1], llvm::AtomicOrdering::SequentiallyConsistent);
Result = CGF.Builder.CreateBinOp(Op, Result, Args[1]);
if (Invert)
Result =
CGF.Builder.CreateBinOp(llvm::Instruction::Xor, Result,
llvm::ConstantInt::getAllOnesValue(IntType));
Result = EmitFromInt(CGF, Result, T, ValueType);
return RValue::get(Result);
}
/// Utility to insert an atomic cmpxchg instruction.
///
/// @param CGF The current codegen function.
/// @param E Builtin call expression to convert to cmpxchg.
/// arg0 - address to operate on
/// arg1 - value to compare with
/// arg2 - new value
/// @param ReturnBool Specifies whether to return success flag of
/// cmpxchg result or the old value.
///
/// @returns result of cmpxchg, according to ReturnBool
///
/// Note: In order to lower Microsoft's _InterlockedCompareExchange* intrinsics
/// invoke the function EmitAtomicCmpXchgForMSIntrin.
static Value *MakeAtomicCmpXchgValue(CodeGenFunction &CGF, const CallExpr *E,
bool ReturnBool) {
QualType T = ReturnBool ? E->getArg(1)->getType() : E->getType();
llvm::Value *DestPtr = CGF.EmitScalarExpr(E->getArg(0));
unsigned AddrSpace = DestPtr->getType()->getPointerAddressSpace();
llvm::IntegerType *IntType = llvm::IntegerType::get(
CGF.getLLVMContext(), CGF.getContext().getTypeSize(T));
llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace);
Value *Args[3];
Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
Args[1] = CGF.EmitScalarExpr(E->getArg(1));
llvm::Type *ValueType = Args[1]->getType();
Args[1] = EmitToInt(CGF, Args[1], T, IntType);
Args[2] = EmitToInt(CGF, CGF.EmitScalarExpr(E->getArg(2)), T, IntType);
Value *Pair = CGF.Builder.CreateAtomicCmpXchg(
Args[0], Args[1], Args[2], llvm::AtomicOrdering::SequentiallyConsistent,
llvm::AtomicOrdering::SequentiallyConsistent);
if (ReturnBool)
// Extract boolean success flag and zext it to int.
return CGF.Builder.CreateZExt(CGF.Builder.CreateExtractValue(Pair, 1),
CGF.ConvertType(E->getType()));
else
// Extract old value and emit it using the same type as compare value.
return EmitFromInt(CGF, CGF.Builder.CreateExtractValue(Pair, 0), T,
ValueType);
}
/// This function should be invoked to emit atomic cmpxchg for Microsoft's
/// _InterlockedCompareExchange* intrinsics which have the following signature:
/// T _InterlockedCompareExchange(T volatile *Destination,
/// T Exchange,
/// T Comparand);
///
/// Whereas the llvm 'cmpxchg' instruction has the following syntax:
/// cmpxchg *Destination, Comparand, Exchange.
/// So we need to swap Comparand and Exchange when invoking
/// CreateAtomicCmpXchg. That is the reason we could not use the above utility
/// function MakeAtomicCmpXchgValue since it expects the arguments to be
/// already swapped.
static
Value *EmitAtomicCmpXchgForMSIntrin(CodeGenFunction &CGF, const CallExpr *E,
AtomicOrdering SuccessOrdering = AtomicOrdering::SequentiallyConsistent) {
assert(E->getArg(0)->getType()->isPointerType());
assert(CGF.getContext().hasSameUnqualifiedType(
E->getType(), E->getArg(0)->getType()->getPointeeType()));
assert(CGF.getContext().hasSameUnqualifiedType(E->getType(),
E->getArg(1)->getType()));
assert(CGF.getContext().hasSameUnqualifiedType(E->getType(),
E->getArg(2)->getType()));
auto *Destination = CGF.EmitScalarExpr(E->getArg(0));
auto *Comparand = CGF.EmitScalarExpr(E->getArg(2));
auto *Exchange = CGF.EmitScalarExpr(E->getArg(1));
// For Release ordering, the failure ordering should be Monotonic.
auto FailureOrdering = SuccessOrdering == AtomicOrdering::Release ?
AtomicOrdering::Monotonic :
SuccessOrdering;
// The atomic instruction is marked volatile for consistency with MSVC. This
// blocks the few atomics optimizations that LLVM has. If we want to optimize
// _Interlocked* operations in the future, we will have to remove the volatile
// marker.
auto *Result = CGF.Builder.CreateAtomicCmpXchg(
Destination, Comparand, Exchange,
SuccessOrdering, FailureOrdering);
Result->setVolatile(true);
return CGF.Builder.CreateExtractValue(Result, 0);
}
// 64-bit Microsoft platforms support 128 bit cmpxchg operations. They are
// prototyped like this:
//
// unsigned char _InterlockedCompareExchange128...(
// __int64 volatile * _Destination,
// __int64 _ExchangeHigh,
// __int64 _ExchangeLow,
// __int64 * _ComparandResult);
static Value *EmitAtomicCmpXchg128ForMSIntrin(CodeGenFunction &CGF,
const CallExpr *E,
AtomicOrdering SuccessOrdering) {
assert(E->getNumArgs() == 4);
llvm::Value *Destination = CGF.EmitScalarExpr(E->getArg(0));
llvm::Value *ExchangeHigh = CGF.EmitScalarExpr(E->getArg(1));
llvm::Value *ExchangeLow = CGF.EmitScalarExpr(E->getArg(2));
llvm::Value *ComparandPtr = CGF.EmitScalarExpr(E->getArg(3));
assert(Destination->getType()->isPointerTy());
assert(!ExchangeHigh->getType()->isPointerTy());
assert(!ExchangeLow->getType()->isPointerTy());
assert(ComparandPtr->getType()->isPointerTy());
// For Release ordering, the failure ordering should be Monotonic.
auto FailureOrdering = SuccessOrdering == AtomicOrdering::Release
? AtomicOrdering::Monotonic
: SuccessOrdering;
// Convert to i128 pointers and values.
llvm::Type *Int128Ty = llvm::IntegerType::get(CGF.getLLVMContext(), 128);
llvm::Type *Int128PtrTy = Int128Ty->getPointerTo();
Destination = CGF.Builder.CreateBitCast(Destination, Int128PtrTy);
Address ComparandResult(CGF.Builder.CreateBitCast(ComparandPtr, Int128PtrTy),
CGF.getContext().toCharUnitsFromBits(128));
// (((i128)hi) << 64) | ((i128)lo)
ExchangeHigh = CGF.Builder.CreateZExt(ExchangeHigh, Int128Ty);
ExchangeLow = CGF.Builder.CreateZExt(ExchangeLow, Int128Ty);
ExchangeHigh =
CGF.Builder.CreateShl(ExchangeHigh, llvm::ConstantInt::get(Int128Ty, 64));
llvm::Value *Exchange = CGF.Builder.CreateOr(ExchangeHigh, ExchangeLow);
// Load the comparand for the instruction.
llvm::Value *Comparand = CGF.Builder.CreateLoad(ComparandResult);
auto *CXI = CGF.Builder.CreateAtomicCmpXchg(Destination, Comparand, Exchange,
SuccessOrdering, FailureOrdering);
// The atomic instruction is marked volatile for consistency with MSVC. This
// blocks the few atomics optimizations that LLVM has. If we want to optimize
// _Interlocked* operations in the future, we will have to remove the volatile
// marker.
CXI->setVolatile(true);
// Store the result as an outparameter.
CGF.Builder.CreateStore(CGF.Builder.CreateExtractValue(CXI, 0),
ComparandResult);
// Get the success boolean and zero extend it to i8.
Value *Success = CGF.Builder.CreateExtractValue(CXI, 1);
return CGF.Builder.CreateZExt(Success, CGF.Int8Ty);
}
static Value *EmitAtomicIncrementValue(CodeGenFunction &CGF, const CallExpr *E,
AtomicOrdering Ordering = AtomicOrdering::SequentiallyConsistent) {
assert(E->getArg(0)->getType()->isPointerType());
auto *IntTy = CGF.ConvertType(E->getType());
auto *Result = CGF.Builder.CreateAtomicRMW(
AtomicRMWInst::Add,
CGF.EmitScalarExpr(E->getArg(0)),
ConstantInt::get(IntTy, 1),
Ordering);
return CGF.Builder.CreateAdd(Result, ConstantInt::get(IntTy, 1));
}
static Value *EmitAtomicDecrementValue(CodeGenFunction &CGF, const CallExpr *E,
AtomicOrdering Ordering = AtomicOrdering::SequentiallyConsistent) {
assert(E->getArg(0)->getType()->isPointerType());
auto *IntTy = CGF.ConvertType(E->getType());
auto *Result = CGF.Builder.CreateAtomicRMW(
AtomicRMWInst::Sub,
CGF.EmitScalarExpr(E->getArg(0)),
ConstantInt::get(IntTy, 1),
Ordering);
return CGF.Builder.CreateSub(Result, ConstantInt::get(IntTy, 1));
}
// Build a plain volatile load.
static Value *EmitISOVolatileLoad(CodeGenFunction &CGF, const CallExpr *E) {
Value *Ptr = CGF.EmitScalarExpr(E->getArg(0));
QualType ElTy = E->getArg(0)->getType()->getPointeeType();
CharUnits LoadSize = CGF.getContext().getTypeSizeInChars(ElTy);
llvm::Type *ITy =
llvm::IntegerType::get(CGF.getLLVMContext(), LoadSize.getQuantity() * 8);
Ptr = CGF.Builder.CreateBitCast(Ptr, ITy->getPointerTo());
llvm::LoadInst *Load = CGF.Builder.CreateAlignedLoad(Ptr, LoadSize);
Load->setVolatile(true);
return Load;
}
// Build a plain volatile store.
static Value *EmitISOVolatileStore(CodeGenFunction &CGF, const CallExpr *E) {
Value *Ptr = CGF.EmitScalarExpr(E->getArg(0));
Value *Value = CGF.EmitScalarExpr(E->getArg(1));
QualType ElTy = E->getArg(0)->getType()->getPointeeType();
CharUnits StoreSize = CGF.getContext().getTypeSizeInChars(ElTy);
llvm::Type *ITy =
llvm::IntegerType::get(CGF.getLLVMContext(), StoreSize.getQuantity() * 8);
Ptr = CGF.Builder.CreateBitCast(Ptr, ITy->getPointerTo());
llvm::StoreInst *Store =
CGF.Builder.CreateAlignedStore(Value, Ptr, StoreSize);
Store->setVolatile(true);
return Store;
}
// Emit a simple mangled intrinsic that has 1 argument and a return type
// matching the argument type. Depending on mode, this may be a constrained
// floating-point intrinsic.
static Value *emitUnaryMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,
const CallExpr *E, unsigned IntrinsicID,
unsigned ConstrainedIntrinsicID) {
llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
if (CGF.Builder.getIsFPConstrained()) {
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);
Function *F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID, Src0->getType());
return CGF.Builder.CreateConstrainedFPCall(F, { Src0 });
} else {
Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
return CGF.Builder.CreateCall(F, Src0);
}
}
// Emit an intrinsic that has 2 operands of the same type as its result.
// Depending on mode, this may be a constrained floating-point intrinsic.
static Value *emitBinaryMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,
const CallExpr *E, unsigned IntrinsicID,
unsigned ConstrainedIntrinsicID) {
llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
if (CGF.Builder.getIsFPConstrained()) {
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);
Function *F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID, Src0->getType());
return CGF.Builder.CreateConstrainedFPCall(F, { Src0, Src1 });
} else {
Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
return CGF.Builder.CreateCall(F, { Src0, Src1 });
}
}
// Emit an intrinsic that has 3 operands of the same type as its result.
// Depending on mode, this may be a constrained floating-point intrinsic.
static Value *emitTernaryMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,
const CallExpr *E, unsigned IntrinsicID,
unsigned ConstrainedIntrinsicID) {
llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
llvm::Value *Src2 = CGF.EmitScalarExpr(E->getArg(2));
if (CGF.Builder.getIsFPConstrained()) {
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);
Function *F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID, Src0->getType());
return CGF.Builder.CreateConstrainedFPCall(F, { Src0, Src1, Src2 });
} else {
Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
return CGF.Builder.CreateCall(F, { Src0, Src1, Src2 });
}
}
// Emit an intrinsic where all operands are of the same type as the result.
// Depending on mode, this may be a constrained floating-point intrinsic.
static Value *emitCallMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,
unsigned IntrinsicID,
unsigned ConstrainedIntrinsicID,
llvm::Type *Ty,
ArrayRef<Value *> Args) {
Function *F;
if (CGF.Builder.getIsFPConstrained())
F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID, Ty);
else
F = CGF.CGM.getIntrinsic(IntrinsicID, Ty);
if (CGF.Builder.getIsFPConstrained())
return CGF.Builder.CreateConstrainedFPCall(F, Args);
else
return CGF.Builder.CreateCall(F, Args);
}
// Emit a simple mangled intrinsic that has 1 argument and a return type
// matching the argument type.
static Value *emitUnaryBuiltin(CodeGenFunction &CGF,
const CallExpr *E,
unsigned IntrinsicID) {
llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
return CGF.Builder.CreateCall(F, Src0);
}
// Emit an intrinsic that has 2 operands of the same type as its result.
static Value *emitBinaryBuiltin(CodeGenFunction &CGF,
const CallExpr *E,
unsigned IntrinsicID) {
llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
return CGF.Builder.CreateCall(F, { Src0, Src1 });
}
// Emit an intrinsic that has 3 operands of the same type as its result.
static Value *emitTernaryBuiltin(CodeGenFunction &CGF,
const CallExpr *E,
unsigned IntrinsicID) {
llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
llvm::Value *Src2 = CGF.EmitScalarExpr(E->getArg(2));
Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
return CGF.Builder.CreateCall(F, { Src0, Src1, Src2 });
}
// Emit an intrinsic that has 1 float or double operand, and 1 integer.
static Value *emitFPIntBuiltin(CodeGenFunction &CGF,
const CallExpr *E,
unsigned IntrinsicID) {
llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
return CGF.Builder.CreateCall(F, {Src0, Src1});
}
// Emit an intrinsic that has overloaded integer result and fp operand.
static Value *
emitMaybeConstrainedFPToIntRoundBuiltin(CodeGenFunction &CGF, const CallExpr *E,
unsigned IntrinsicID,
unsigned ConstrainedIntrinsicID) {
llvm::Type *ResultType = CGF.ConvertType(E->getType());
llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
if (CGF.Builder.getIsFPConstrained()) {
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);
Function *F = CGF.CGM.getIntrinsic(ConstrainedIntrinsicID,
{ResultType, Src0->getType()});
return CGF.Builder.CreateConstrainedFPCall(F, {Src0});
} else {
Function *F =
CGF.CGM.getIntrinsic(IntrinsicID, {ResultType, Src0->getType()});
return CGF.Builder.CreateCall(F, Src0);
}
}
/// EmitFAbs - Emit a call to @llvm.fabs().
static Value *EmitFAbs(CodeGenFunction &CGF, Value *V) {
Function *F = CGF.CGM.getIntrinsic(Intrinsic::fabs, V->getType());
llvm::CallInst *Call = CGF.Builder.CreateCall(F, V);
Call->setDoesNotAccessMemory();
return Call;
}
/// Emit the computation of the sign bit for a floating point value. Returns
/// the i1 sign bit value.
static Value *EmitSignBit(CodeGenFunction &CGF, Value *V) {
LLVMContext &C = CGF.CGM.getLLVMContext();
llvm::Type *Ty = V->getType();
int Width = Ty->getPrimitiveSizeInBits();
llvm::Type *IntTy = llvm::IntegerType::get(C, Width);
V = CGF.Builder.CreateBitCast(V, IntTy);
if (Ty->isPPC_FP128Ty()) {
// We want the sign bit of the higher-order double. The bitcast we just
// did works as if the double-double was stored to memory and then
// read as an i128. The "store" will put the higher-order double in the
// lower address in both little- and big-Endian modes, but the "load"
// will treat those bits as a different part of the i128: the low bits in
// little-Endian, the high bits in big-Endian. Therefore, on big-Endian
// we need to shift the high bits down to the low before truncating.
Width >>= 1;
if (CGF.getTarget().isBigEndian()) {
Value *ShiftCst = llvm::ConstantInt::get(IntTy, Width);
V = CGF.Builder.CreateLShr(V, ShiftCst);
}
// We are truncating value in order to extract the higher-order
// double, which we will be using to extract the sign from.
IntTy = llvm::IntegerType::get(C, Width);
V = CGF.Builder.CreateTrunc(V, IntTy);
}
Value *Zero = llvm::Constant::getNullValue(IntTy);
return CGF.Builder.CreateICmpSLT(V, Zero);
}
static RValue emitLibraryCall(CodeGenFunction &CGF, const FunctionDecl *FD,
const CallExpr *E, llvm::Constant *calleeValue) {
CGCallee callee = CGCallee::forDirect(calleeValue, GlobalDecl(FD));
return CGF.EmitCall(E->getCallee()->getType(), callee, E, ReturnValueSlot());
}
/// Emit a call to llvm.{sadd,uadd,ssub,usub,smul,umul}.with.overflow.*
/// depending on IntrinsicID.
///
/// \arg CGF The current codegen function.
/// \arg IntrinsicID The ID for the Intrinsic we wish to generate.
/// \arg X The first argument to the llvm.*.with.overflow.*.
/// \arg Y The second argument to the llvm.*.with.overflow.*.
/// \arg Carry The carry returned by the llvm.*.with.overflow.*.
/// \returns The result (i.e. sum/product) returned by the intrinsic.
static llvm::Value *EmitOverflowIntrinsic(CodeGenFunction &CGF,
const llvm::Intrinsic::ID IntrinsicID,
llvm::Value *X, llvm::Value *Y,
llvm::Value *&Carry) {
// Make sure we have integers of the same width.
assert(X->getType() == Y->getType() &&
"Arguments must be the same type. (Did you forget to make sure both "
"arguments have the same integer width?)");
Function *Callee = CGF.CGM.getIntrinsic(IntrinsicID, X->getType());
llvm::Value *Tmp = CGF.Builder.CreateCall(Callee, {X, Y});
Carry = CGF.Builder.CreateExtractValue(Tmp, 1);
return CGF.Builder.CreateExtractValue(Tmp, 0);
}
static Value *emitRangedBuiltin(CodeGenFunction &CGF,
unsigned IntrinsicID,
int low, int high) {
llvm::MDBuilder MDHelper(CGF.getLLVMContext());
llvm::MDNode *RNode = MDHelper.createRange(APInt(32, low), APInt(32, high));
Function *F = CGF.CGM.getIntrinsic(IntrinsicID, {});
llvm::Instruction *Call = CGF.Builder.CreateCall(F);
Call->setMetadata(llvm::LLVMContext::MD_range, RNode);
return Call;
}
namespace {
struct WidthAndSignedness {
unsigned Width;
bool Signed;
};
}
static WidthAndSignedness
getIntegerWidthAndSignedness(const clang::ASTContext &context,
const clang::QualType Type) {
assert(Type->isIntegerType() && "Given type is not an integer.");
unsigned Width = Type->isBooleanType() ? 1
: Type->isExtIntType() ? context.getIntWidth(Type)
: context.getTypeInfo(Type).Width;
bool Signed = Type->isSignedIntegerType();
return {Width, Signed};
}
// Given one or more integer types, this function produces an integer type that
// encompasses them: any value in one of the given types could be expressed in
// the encompassing type.
static struct WidthAndSignedness
EncompassingIntegerType(ArrayRef<struct WidthAndSignedness> Types) {
assert(Types.size() > 0 && "Empty list of types.");
// If any of the given types is signed, we must return a signed type.
bool Signed = false;
for (const auto &Type : Types) {
Signed |= Type.Signed;
}
// The encompassing type must have a width greater than or equal to the width
// of the specified types. Additionally, if the encompassing type is signed,
// its width must be strictly greater than the width of any unsigned types
// given.
unsigned Width = 0;
for (const auto &Type : Types) {
unsigned MinWidth = Type.Width + (Signed && !Type.Signed);
if (Width < MinWidth) {
Width = MinWidth;
}
}
return {Width, Signed};
}
Value *CodeGenFunction::EmitVAStartEnd(Value *ArgValue, bool IsStart) {
llvm::Type *DestType = Int8PtrTy;
if (ArgValue->getType() != DestType)
ArgValue =
Builder.CreateBitCast(ArgValue, DestType, ArgValue->getName().data());
Intrinsic::ID inst = IsStart ? Intrinsic::vastart : Intrinsic::vaend;
return Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue);
}
/// Checks if using the result of __builtin_object_size(p, @p From) in place of
/// __builtin_object_size(p, @p To) is correct
static bool areBOSTypesCompatible(int From, int To) {
// Note: Our __builtin_object_size implementation currently treats Type=0 and
// Type=2 identically. Encoding this implementation detail here may make
// improving __builtin_object_size difficult in the future, so it's omitted.
return From == To || (From == 0 && To == 1) || (From == 3 && To == 2);
}
static llvm::Value *
getDefaultBuiltinObjectSizeResult(unsigned Type, llvm::IntegerType *ResType) {
return ConstantInt::get(ResType, (Type & 2) ? 0 : -1, /*isSigned=*/true);
}
llvm::Value *
CodeGenFunction::evaluateOrEmitBuiltinObjectSize(const Expr *E, unsigned Type,
llvm::IntegerType *ResType,
llvm::Value *EmittedE,
bool IsDynamic) {
uint64_t ObjectSize;
if (!E->tryEvaluateObjectSize(ObjectSize, getContext(), Type))
return emitBuiltinObjectSize(E, Type, ResType, EmittedE, IsDynamic);
return ConstantInt::get(ResType, ObjectSize, /*isSigned=*/true);
}
/// Returns a Value corresponding to the size of the given expression.
/// This Value may be either of the following:
/// - A llvm::Argument (if E is a param with the pass_object_size attribute on
/// it)
/// - A call to the @llvm.objectsize intrinsic
///
/// EmittedE is the result of emitting `E` as a scalar expr. If it's non-null
/// and we wouldn't otherwise try to reference a pass_object_size parameter,
/// we'll call @llvm.objectsize on EmittedE, rather than emitting E.
llvm::Value *
CodeGenFunction::emitBuiltinObjectSize(const Expr *E, unsigned Type,
llvm::IntegerType *ResType,
llvm::Value *EmittedE, bool IsDynamic) {
// We need to reference an argument if the pointer is a parameter with the
// pass_object_size attribute.
if (auto *D = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) {
auto *Param = dyn_cast<ParmVarDecl>(D->getDecl());
auto *PS = D->getDecl()->getAttr<PassObjectSizeAttr>();
if (Param != nullptr && PS != nullptr &&
areBOSTypesCompatible(PS->getType(), Type)) {
auto Iter = SizeArguments.find(Param);
assert(Iter != SizeArguments.end());
const ImplicitParamDecl *D = Iter->second;
auto DIter = LocalDeclMap.find(D);
assert(DIter != LocalDeclMap.end());
return EmitLoadOfScalar(DIter->second, /*Volatile=*/false,
getContext().getSizeType(), E->getBeginLoc());
}
}
// LLVM can't handle Type=3 appropriately, and __builtin_object_size shouldn't
// evaluate E for side-effects. In either case, we shouldn't lower to
// @llvm.objectsize.
if (Type == 3 || (!EmittedE && E->HasSideEffects(getContext())))
return getDefaultBuiltinObjectSizeResult(Type, ResType);
Value *Ptr = EmittedE ? EmittedE : EmitScalarExpr(E);
assert(Ptr->getType()->isPointerTy() &&
"Non-pointer passed to __builtin_object_size?");
Function *F =
CGM.getIntrinsic(Intrinsic::objectsize, {ResType, Ptr->getType()});
// LLVM only supports 0 and 2, make sure that we pass along that as a boolean.
Value *Min = Builder.getInt1((Type & 2) != 0);
// For GCC compatibility, __builtin_object_size treat NULL as unknown size.
Value *NullIsUnknown = Builder.getTrue();
Value *Dynamic = Builder.getInt1(IsDynamic);
return Builder.CreateCall(F, {Ptr, Min, NullIsUnknown, Dynamic});
}
namespace {
/// A struct to generically describe a bit test intrinsic.
struct BitTest {
enum ActionKind : uint8_t { TestOnly, Complement, Reset, Set };
enum InterlockingKind : uint8_t {
Unlocked,
Sequential,
Acquire,
Release,
NoFence
};
ActionKind Action;
InterlockingKind Interlocking;
bool Is64Bit;
static BitTest decodeBitTestBuiltin(unsigned BuiltinID);
};
} // namespace
BitTest BitTest::decodeBitTestBuiltin(unsigned BuiltinID) {
switch (BuiltinID) {
// Main portable variants.
case Builtin::BI_bittest:
return {TestOnly, Unlocked, false};
case Builtin::BI_bittestandcomplement:
return {Complement, Unlocked, false};
case Builtin::BI_bittestandreset:
return {Reset, Unlocked, false};
case Builtin::BI_bittestandset:
return {Set, Unlocked, false};
case Builtin::BI_interlockedbittestandreset:
return {Reset, Sequential, false};
case Builtin::BI_interlockedbittestandset:
return {Set, Sequential, false};
// X86-specific 64-bit variants.
case Builtin::BI_bittest64:
return {TestOnly, Unlocked, true};
case Builtin::BI_bittestandcomplement64:
return {Complement, Unlocked, true};
case Builtin::BI_bittestandreset64:
return {Reset, Unlocked, true};
case Builtin::BI_bittestandset64:
return {Set, Unlocked, true};
case Builtin::BI_interlockedbittestandreset64:
return {Reset, Sequential, true};
case Builtin::BI_interlockedbittestandset64:
return {Set, Sequential, true};
// ARM/AArch64-specific ordering variants.
case Builtin::BI_interlockedbittestandset_acq:
return {Set, Acquire, false};
case Builtin::BI_interlockedbittestandset_rel:
return {Set, Release, false};
case Builtin::BI_interlockedbittestandset_nf:
return {Set, NoFence, false};
case Builtin::BI_interlockedbittestandreset_acq:
return {Reset, Acquire, false};
case Builtin::BI_interlockedbittestandreset_rel:
return {Reset, Release, false};
case Builtin::BI_interlockedbittestandreset_nf:
return {Reset, NoFence, false};
}
llvm_unreachable("expected only bittest intrinsics");
}
static char bitActionToX86BTCode(BitTest::ActionKind A) {
switch (A) {
case BitTest::TestOnly: return '\0';
case BitTest::Complement: return 'c';
case BitTest::Reset: return 'r';
case BitTest::Set: return 's';
}
llvm_unreachable("invalid action");
}
static llvm::Value *EmitX86BitTestIntrinsic(CodeGenFunction &CGF,
BitTest BT,
const CallExpr *E, Value *BitBase,
Value *BitPos) {
char Action = bitActionToX86BTCode(BT.Action);
char SizeSuffix = BT.Is64Bit ? 'q' : 'l';
// Build the assembly.
SmallString<64> Asm;
raw_svector_ostream AsmOS(Asm);
if (BT.Interlocking != BitTest::Unlocked)
AsmOS << "lock ";
AsmOS << "bt";
if (Action)
AsmOS << Action;
AsmOS << SizeSuffix << " $2, ($1)";
// Build the constraints. FIXME: We should support immediates when possible.
std::string Constraints = "={@ccc},r,r,~{cc},~{memory}";
std::string MachineClobbers = CGF.getTarget().getClobbers();
if (!MachineClobbers.empty()) {
Constraints += ',';
Constraints += MachineClobbers;
}
llvm::IntegerType *IntType = llvm::IntegerType::get(
CGF.getLLVMContext(),
CGF.getContext().getTypeSize(E->getArg(1)->getType()));
llvm::Type *IntPtrType = IntType->getPointerTo();
llvm::FunctionType *FTy =
llvm::FunctionType::get(CGF.Int8Ty, {IntPtrType, IntType}, false);
llvm::InlineAsm *IA =
llvm::InlineAsm::get(FTy, Asm, Constraints, /*hasSideEffects=*/true);
return CGF.Builder.CreateCall(IA, {BitBase, BitPos});
}
static llvm::AtomicOrdering
getBitTestAtomicOrdering(BitTest::InterlockingKind I) {
switch (I) {
case BitTest::Unlocked: return llvm::AtomicOrdering::NotAtomic;
case BitTest::Sequential: return llvm::AtomicOrdering::SequentiallyConsistent;
case BitTest::Acquire: return llvm::AtomicOrdering::Acquire;
case BitTest::Release: return llvm::AtomicOrdering::Release;
case BitTest::NoFence: return llvm::AtomicOrdering::Monotonic;
}
llvm_unreachable("invalid interlocking");
}
/// Emit a _bittest* intrinsic. These intrinsics take a pointer to an array of
/// bits and a bit position and read and optionally modify the bit at that
/// position. The position index can be arbitrarily large, i.e. it can be larger
/// than 31 or 63, so we need an indexed load in the general case.
static llvm::Value *EmitBitTestIntrinsic(CodeGenFunction &CGF,
unsigned BuiltinID,
const CallExpr *E) {
Value *BitBase = CGF.EmitScalarExpr(E->getArg(0));
Value *BitPos = CGF.EmitScalarExpr(E->getArg(1));
BitTest BT = BitTest::decodeBitTestBuiltin(BuiltinID);
// X86 has special BT, BTC, BTR, and BTS instructions that handle the array
// indexing operation internally. Use them if possible.
if (CGF.getTarget().getTriple().isX86())
return EmitX86BitTestIntrinsic(CGF, BT, E, BitBase, BitPos);
// Otherwise, use generic code to load one byte and test the bit. Use all but
// the bottom three bits as the array index, and the bottom three bits to form
// a mask.
// Bit = BitBaseI8[BitPos >> 3] & (1 << (BitPos & 0x7)) != 0;
Value *ByteIndex = CGF.Builder.CreateAShr(
BitPos, llvm::ConstantInt::get(BitPos->getType(), 3), "bittest.byteidx");
Value *BitBaseI8 = CGF.Builder.CreatePointerCast(BitBase, CGF.Int8PtrTy);
Address ByteAddr(CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, BitBaseI8,
ByteIndex, "bittest.byteaddr"),
CharUnits::One());
Value *PosLow =
CGF.Builder.CreateAnd(CGF.Builder.CreateTrunc(BitPos, CGF.Int8Ty),
llvm::ConstantInt::get(CGF.Int8Ty, 0x7));
// The updating instructions will need a mask.
Value *Mask = nullptr;
if (BT.Action != BitTest::TestOnly) {
Mask = CGF.Builder.CreateShl(llvm::ConstantInt::get(CGF.Int8Ty, 1), PosLow,
"bittest.mask");
}
// Check the action and ordering of the interlocked intrinsics.
llvm::AtomicOrdering Ordering = getBitTestAtomicOrdering(BT.Interlocking);
Value *OldByte = nullptr;
if (Ordering != llvm::AtomicOrdering::NotAtomic) {
// Emit a combined atomicrmw load/store operation for the interlocked
// intrinsics.
llvm::AtomicRMWInst::BinOp RMWOp = llvm::AtomicRMWInst::Or;
if (BT.Action == BitTest::Reset) {
Mask = CGF.Builder.CreateNot(Mask);
RMWOp = llvm::AtomicRMWInst::And;
}
OldByte = CGF.Builder.CreateAtomicRMW(RMWOp, ByteAddr.getPointer(), Mask,
Ordering);
} else {
// Emit a plain load for the non-interlocked intrinsics.
OldByte = CGF.Builder.CreateLoad(ByteAddr, "bittest.byte");
Value *NewByte = nullptr;
switch (BT.Action) {
case BitTest::TestOnly:
// Don't store anything.
break;
case BitTest::Complement:
NewByte = CGF.Builder.CreateXor(OldByte, Mask);
break;
case BitTest::Reset:
NewByte = CGF.Builder.CreateAnd(OldByte, CGF.Builder.CreateNot(Mask));
break;
case BitTest::Set:
NewByte = CGF.Builder.CreateOr(OldByte, Mask);
break;
}
if (NewByte)
CGF.Builder.CreateStore(NewByte, ByteAddr);
}
// However we loaded the old byte, either by plain load or atomicrmw, shift
// the bit into the low position and mask it to 0 or 1.
Value *ShiftedByte = CGF.Builder.CreateLShr(OldByte, PosLow, "bittest.shr");
return CGF.Builder.CreateAnd(
ShiftedByte, llvm::ConstantInt::get(CGF.Int8Ty, 1), "bittest.res");
}
namespace {
enum class MSVCSetJmpKind {
_setjmpex,
_setjmp3,
_setjmp
};
}
/// MSVC handles setjmp a bit differently on different platforms. On every
/// architecture except 32-bit x86, the frame address is passed. On x86, extra
/// parameters can be passed as variadic arguments, but we always pass none.
static RValue EmitMSVCRTSetJmp(CodeGenFunction &CGF, MSVCSetJmpKind SJKind,
const CallExpr *E) {
llvm::Value *Arg1 = nullptr;
llvm::Type *Arg1Ty = nullptr;
StringRef Name;
bool IsVarArg = false;
if (SJKind == MSVCSetJmpKind::_setjmp3) {
Name = "_setjmp3";
Arg1Ty = CGF.Int32Ty;
Arg1 = llvm::ConstantInt::get(CGF.IntTy, 0);
IsVarArg = true;
} else {
Name = SJKind == MSVCSetJmpKind::_setjmp ? "_setjmp" : "_setjmpex";
Arg1Ty = CGF.Int8PtrTy;
if (CGF.getTarget().getTriple().getArch() == llvm::Triple::aarch64) {
Arg1 = CGF.Builder.CreateCall(
CGF.CGM.getIntrinsic(Intrinsic::sponentry, CGF.AllocaInt8PtrTy));
} else
Arg1 = CGF.Builder.CreateCall(
CGF.CGM.getIntrinsic(Intrinsic::frameaddress, CGF.AllocaInt8PtrTy),
llvm::ConstantInt::get(CGF.Int32Ty, 0));
}
// Mark the call site and declaration with ReturnsTwice.
llvm::Type *ArgTypes[2] = {CGF.Int8PtrTy, Arg1Ty};
llvm::AttributeList ReturnsTwiceAttr = llvm::AttributeList::get(
CGF.getLLVMContext(), llvm::AttributeList::FunctionIndex,
llvm::Attribute::ReturnsTwice);
llvm::FunctionCallee SetJmpFn = CGF.CGM.CreateRuntimeFunction(
llvm::FunctionType::get(CGF.IntTy, ArgTypes, IsVarArg), Name,
ReturnsTwiceAttr, /*Local=*/true);
llvm::Value *Buf = CGF.Builder.CreateBitOrPointerCast(
CGF.EmitScalarExpr(E->getArg(0)), CGF.Int8PtrTy);
llvm::Value *Args[] = {Buf, Arg1};
llvm::CallBase *CB = CGF.EmitRuntimeCallOrInvoke(SetJmpFn, Args);
CB->setAttributes(ReturnsTwiceAttr);
return RValue::get(CB);
}
// Many of MSVC builtins are on x64, ARM and AArch64; to avoid repeating code,
// we handle them here.
enum class CodeGenFunction::MSVCIntrin {
_BitScanForward,
_BitScanReverse,
_InterlockedAnd,
_InterlockedDecrement,
_InterlockedExchange,
_InterlockedExchangeAdd,
_InterlockedExchangeSub,
_InterlockedIncrement,
_InterlockedOr,
_InterlockedXor,
_InterlockedExchangeAdd_acq,
_InterlockedExchangeAdd_rel,
_InterlockedExchangeAdd_nf,
_InterlockedExchange_acq,
_InterlockedExchange_rel,
_InterlockedExchange_nf,
_InterlockedCompareExchange_acq,
_InterlockedCompareExchange_rel,
_InterlockedCompareExchange_nf,
_InterlockedCompareExchange128,
_InterlockedCompareExchange128_acq,
_InterlockedCompareExchange128_rel,
_InterlockedCompareExchange128_nf,
_InterlockedOr_acq,
_InterlockedOr_rel,
_InterlockedOr_nf,
_InterlockedXor_acq,
_InterlockedXor_rel,
_InterlockedXor_nf,
_InterlockedAnd_acq,
_InterlockedAnd_rel,
_InterlockedAnd_nf,
_InterlockedIncrement_acq,
_InterlockedIncrement_rel,
_InterlockedIncrement_nf,
_InterlockedDecrement_acq,
_InterlockedDecrement_rel,
_InterlockedDecrement_nf,
__fastfail,
};
static Optional<CodeGenFunction::MSVCIntrin>
translateArmToMsvcIntrin(unsigned BuiltinID) {
using MSVCIntrin = CodeGenFunction::MSVCIntrin;
switch (BuiltinID) {
default:
return None;
case ARM::BI_BitScanForward:
case ARM::BI_BitScanForward64:
return MSVCIntrin::_BitScanForward;
case ARM::BI_BitScanReverse:
case ARM::BI_BitScanReverse64:
return MSVCIntrin::_BitScanReverse;
case ARM::BI_InterlockedAnd64:
return MSVCIntrin::_InterlockedAnd;
case ARM::BI_InterlockedExchange64:
return MSVCIntrin::_InterlockedExchange;
case ARM::BI_InterlockedExchangeAdd64:
return MSVCIntrin::_InterlockedExchangeAdd;
case ARM::BI_InterlockedExchangeSub64:
return MSVCIntrin::_InterlockedExchangeSub;
case ARM::BI_InterlockedOr64:
return MSVCIntrin::_InterlockedOr;
case ARM::BI_InterlockedXor64:
return MSVCIntrin::_InterlockedXor;
case ARM::BI_InterlockedDecrement64:
return MSVCIntrin::_InterlockedDecrement;
case ARM::BI_InterlockedIncrement64:
return MSVCIntrin::_InterlockedIncrement;
case ARM::BI_InterlockedExchangeAdd8_acq:
case ARM::BI_InterlockedExchangeAdd16_acq:
case ARM::BI_InterlockedExchangeAdd_acq:
case ARM::BI_InterlockedExchangeAdd64_acq:
return MSVCIntrin::_InterlockedExchangeAdd_acq;
case ARM::BI_InterlockedExchangeAdd8_rel:
case ARM::BI_InterlockedExchangeAdd16_rel:
case ARM::BI_InterlockedExchangeAdd_rel:
case ARM::BI_InterlockedExchangeAdd64_rel:
return MSVCIntrin::_InterlockedExchangeAdd_rel;
case ARM::BI_InterlockedExchangeAdd8_nf:
case ARM::BI_InterlockedExchangeAdd16_nf:
case ARM::BI_InterlockedExchangeAdd_nf:
case ARM::BI_InterlockedExchangeAdd64_nf:
return MSVCIntrin::_InterlockedExchangeAdd_nf;
case ARM::BI_InterlockedExchange8_acq:
case ARM::BI_InterlockedExchange16_acq:
case ARM::BI_InterlockedExchange_acq:
case ARM::BI_InterlockedExchange64_acq:
return MSVCIntrin::_InterlockedExchange_acq;
case ARM::BI_InterlockedExchange8_rel:
case ARM::BI_InterlockedExchange16_rel:
case ARM::BI_InterlockedExchange_rel:
case ARM::BI_InterlockedExchange64_rel:
return MSVCIntrin::_InterlockedExchange_rel;
case ARM::BI_InterlockedExchange8_nf:
case ARM::BI_InterlockedExchange16_nf:
case ARM::BI_InterlockedExchange_nf:
case ARM::BI_InterlockedExchange64_nf:
return MSVCIntrin::_InterlockedExchange_nf;
case ARM::BI_InterlockedCompareExchange8_acq:
case ARM::BI_InterlockedCompareExchange16_acq:
case ARM::BI_InterlockedCompareExchange_acq:
case ARM::BI_InterlockedCompareExchange64_acq:
return MSVCIntrin::_InterlockedCompareExchange_acq;
case ARM::BI_InterlockedCompareExchange8_rel:
case ARM::BI_InterlockedCompareExchange16_rel:
case ARM::BI_InterlockedCompareExchange_rel:
case ARM::BI_InterlockedCompareExchange64_rel:
return MSVCIntrin::_InterlockedCompareExchange_rel;
case ARM::BI_InterlockedCompareExchange8_nf:
case ARM::BI_InterlockedCompareExchange16_nf:
case ARM::BI_InterlockedCompareExchange_nf:
case ARM::BI_InterlockedCompareExchange64_nf:
return MSVCIntrin::_InterlockedCompareExchange_nf;
case ARM::BI_InterlockedOr8_acq:
case ARM::BI_InterlockedOr16_acq:
case ARM::BI_InterlockedOr_acq:
case ARM::BI_InterlockedOr64_acq:
return MSVCIntrin::_InterlockedOr_acq;
case ARM::BI_InterlockedOr8_rel:
case ARM::BI_InterlockedOr16_rel:
case ARM::BI_InterlockedOr_rel:
case ARM::BI_InterlockedOr64_rel:
return MSVCIntrin::_InterlockedOr_rel;
case ARM::BI_InterlockedOr8_nf:
case ARM::BI_InterlockedOr16_nf:
case ARM::BI_InterlockedOr_nf:
case ARM::BI_InterlockedOr64_nf:
return MSVCIntrin::_InterlockedOr_nf;
case ARM::BI_InterlockedXor8_acq:
case ARM::BI_InterlockedXor16_acq:
case ARM::BI_InterlockedXor_acq:
case ARM::BI_InterlockedXor64_acq:
return MSVCIntrin::_InterlockedXor_acq;
case ARM::BI_InterlockedXor8_rel:
case ARM::BI_InterlockedXor16_rel:
case ARM::BI_InterlockedXor_rel:
case ARM::BI_InterlockedXor64_rel:
return MSVCIntrin::_InterlockedXor_rel;
case ARM::BI_InterlockedXor8_nf:
case ARM::BI_InterlockedXor16_nf:
case ARM::BI_InterlockedXor_nf:
case ARM::BI_InterlockedXor64_nf:
return MSVCIntrin::_InterlockedXor_nf;
case ARM::BI_InterlockedAnd8_acq:
case ARM::BI_InterlockedAnd16_acq:
case ARM::BI_InterlockedAnd_acq:
case ARM::BI_InterlockedAnd64_acq:
return MSVCIntrin::_InterlockedAnd_acq;
case ARM::BI_InterlockedAnd8_rel:
case ARM::BI_InterlockedAnd16_rel:
case ARM::BI_InterlockedAnd_rel:
case ARM::BI_InterlockedAnd64_rel:
return MSVCIntrin::_InterlockedAnd_rel;
case ARM::BI_InterlockedAnd8_nf:
case ARM::BI_InterlockedAnd16_nf:
case ARM::BI_InterlockedAnd_nf:
case ARM::BI_InterlockedAnd64_nf:
return MSVCIntrin::_InterlockedAnd_nf;
case ARM::BI_InterlockedIncrement16_acq:
case ARM::BI_InterlockedIncrement_acq:
case ARM::BI_InterlockedIncrement64_acq:
return MSVCIntrin::_InterlockedIncrement_acq;
case ARM::BI_InterlockedIncrement16_rel:
case ARM::BI_InterlockedIncrement_rel:
case ARM::BI_InterlockedIncrement64_rel:
return MSVCIntrin::_InterlockedIncrement_rel;
case ARM::BI_InterlockedIncrement16_nf:
case ARM::BI_InterlockedIncrement_nf:
case ARM::BI_InterlockedIncrement64_nf:
return MSVCIntrin::_InterlockedIncrement_nf;
case ARM::BI_InterlockedDecrement16_acq:
case ARM::BI_InterlockedDecrement_acq:
case ARM::BI_InterlockedDecrement64_acq:
return MSVCIntrin::_InterlockedDecrement_acq;
case ARM::BI_InterlockedDecrement16_rel:
case ARM::BI_InterlockedDecrement_rel:
case ARM::BI_InterlockedDecrement64_rel:
return MSVCIntrin::_InterlockedDecrement_rel;
case ARM::BI_InterlockedDecrement16_nf:
case ARM::BI_InterlockedDecrement_nf:
case ARM::BI_InterlockedDecrement64_nf:
return MSVCIntrin::_InterlockedDecrement_nf;
}
llvm_unreachable("must return from switch");
}
static Optional<CodeGenFunction::MSVCIntrin>
translateAarch64ToMsvcIntrin(unsigned BuiltinID) {
using MSVCIntrin = CodeGenFunction::MSVCIntrin;
switch (BuiltinID) {
default:
return None;
case AArch64::BI_BitScanForward:
case AArch64::BI_BitScanForward64:
return MSVCIntrin::_BitScanForward;
case AArch64::BI_BitScanReverse:
case AArch64::BI_BitScanReverse64:
return MSVCIntrin::_BitScanReverse;
case AArch64::BI_InterlockedAnd64:
return MSVCIntrin::_InterlockedAnd;
case AArch64::BI_InterlockedExchange64:
return MSVCIntrin::_InterlockedExchange;
case AArch64::BI_InterlockedExchangeAdd64:
return MSVCIntrin::_InterlockedExchangeAdd;
case AArch64::BI_InterlockedExchangeSub64:
return MSVCIntrin::_InterlockedExchangeSub;
case AArch64::BI_InterlockedOr64:
return MSVCIntrin::_InterlockedOr;
case AArch64::BI_InterlockedXor64:
return MSVCIntrin::_InterlockedXor;
case AArch64::BI_InterlockedDecrement64:
return MSVCIntrin::_InterlockedDecrement;
case AArch64::BI_InterlockedIncrement64:
return MSVCIntrin::_InterlockedIncrement;
case AArch64::BI_InterlockedExchangeAdd8_acq:
case AArch64::BI_InterlockedExchangeAdd16_acq:
case AArch64::BI_InterlockedExchangeAdd_acq:
case AArch64::BI_InterlockedExchangeAdd64_acq:
return MSVCIntrin::_InterlockedExchangeAdd_acq;
case AArch64::BI_InterlockedExchangeAdd8_rel:
case AArch64::BI_InterlockedExchangeAdd16_rel:
case AArch64::BI_InterlockedExchangeAdd_rel:
case AArch64::BI_InterlockedExchangeAdd64_rel:
return MSVCIntrin::_InterlockedExchangeAdd_rel;
case AArch64::BI_InterlockedExchangeAdd8_nf:
case AArch64::BI_InterlockedExchangeAdd16_nf:
case AArch64::BI_InterlockedExchangeAdd_nf:
case AArch64::BI_InterlockedExchangeAdd64_nf:
return MSVCIntrin::_InterlockedExchangeAdd_nf;
case AArch64::BI_InterlockedExchange8_acq:
case AArch64::BI_InterlockedExchange16_acq:
case AArch64::BI_InterlockedExchange_acq:
case AArch64::BI_InterlockedExchange64_acq:
return MSVCIntrin::_InterlockedExchange_acq;
case AArch64::BI_InterlockedExchange8_rel:
case AArch64::BI_InterlockedExchange16_rel:
case AArch64::BI_InterlockedExchange_rel:
case AArch64::BI_InterlockedExchange64_rel:
return MSVCIntrin::_InterlockedExchange_rel;
case AArch64::BI_InterlockedExchange8_nf:
case AArch64::BI_InterlockedExchange16_nf:
case AArch64::BI_InterlockedExchange_nf:
case AArch64::BI_InterlockedExchange64_nf:
return MSVCIntrin::_InterlockedExchange_nf;
case AArch64::BI_InterlockedCompareExchange8_acq:
case AArch64::BI_InterlockedCompareExchange16_acq:
case AArch64::BI_InterlockedCompareExchange_acq:
case AArch64::BI_InterlockedCompareExchange64_acq:
return MSVCIntrin::_InterlockedCompareExchange_acq;
case AArch64::BI_InterlockedCompareExchange8_rel:
case AArch64::BI_InterlockedCompareExchange16_rel:
case AArch64::BI_InterlockedCompareExchange_rel:
case AArch64::BI_InterlockedCompareExchange64_rel:
return MSVCIntrin::_InterlockedCompareExchange_rel;
case AArch64::BI_InterlockedCompareExchange8_nf:
case AArch64::BI_InterlockedCompareExchange16_nf:
case AArch64::BI_InterlockedCompareExchange_nf:
case AArch64::BI_InterlockedCompareExchange64_nf:
return MSVCIntrin::_InterlockedCompareExchange_nf;
case AArch64::BI_InterlockedCompareExchange128:
return MSVCIntrin::_InterlockedCompareExchange128;
case AArch64::BI_InterlockedCompareExchange128_acq:
return MSVCIntrin::_InterlockedCompareExchange128_acq;
case AArch64::BI_InterlockedCompareExchange128_nf:
return MSVCIntrin::_InterlockedCompareExchange128_nf;
case AArch64::BI_InterlockedCompareExchange128_rel:
return MSVCIntrin::_InterlockedCompareExchange128_rel;
case AArch64::BI_InterlockedOr8_acq:
case AArch64::BI_InterlockedOr16_acq:
case AArch64::BI_InterlockedOr_acq:
case AArch64::BI_InterlockedOr64_acq:
return MSVCIntrin::_InterlockedOr_acq;
case AArch64::BI_InterlockedOr8_rel:
case AArch64::BI_InterlockedOr16_rel:
case AArch64::BI_InterlockedOr_rel:
case AArch64::BI_InterlockedOr64_rel:
return MSVCIntrin::_InterlockedOr_rel;
case AArch64::BI_InterlockedOr8_nf:
case AArch64::BI_InterlockedOr16_nf:
case AArch64::BI_InterlockedOr_nf:
case AArch64::BI_InterlockedOr64_nf:
return MSVCIntrin::_InterlockedOr_nf;
case AArch64::BI_InterlockedXor8_acq:
case AArch64::BI_InterlockedXor16_acq:
case AArch64::BI_InterlockedXor_acq:
case AArch64::BI_InterlockedXor64_acq:
return MSVCIntrin::_InterlockedXor_acq;
case AArch64::BI_InterlockedXor8_rel:
case AArch64::BI_InterlockedXor16_rel:
case AArch64::BI_InterlockedXor_rel:
case AArch64::BI_InterlockedXor64_rel:
return MSVCIntrin::_InterlockedXor_rel;
case AArch64::BI_InterlockedXor8_nf:
case AArch64::BI_InterlockedXor16_nf:
case AArch64::BI_InterlockedXor_nf:
case AArch64::BI_InterlockedXor64_nf:
return MSVCIntrin::_InterlockedXor_nf;
case AArch64::BI_InterlockedAnd8_acq:
case AArch64::BI_InterlockedAnd16_acq:
case AArch64::BI_InterlockedAnd_acq:
case AArch64::BI_InterlockedAnd64_acq:
return MSVCIntrin::_InterlockedAnd_acq;
case AArch64::BI_InterlockedAnd8_rel:
case AArch64::BI_InterlockedAnd16_rel:
case AArch64::BI_InterlockedAnd_rel:
case AArch64::BI_InterlockedAnd64_rel:
return MSVCIntrin::_InterlockedAnd_rel;
case AArch64::BI_InterlockedAnd8_nf:
case AArch64::BI_InterlockedAnd16_nf:
case AArch64::BI_InterlockedAnd_nf:
case AArch64::BI_InterlockedAnd64_nf:
return MSVCIntrin::_InterlockedAnd_nf;
case AArch64::BI_InterlockedIncrement16_acq:
case AArch64::BI_InterlockedIncrement_acq:
case AArch64::BI_InterlockedIncrement64_acq:
return MSVCIntrin::_InterlockedIncrement_acq;
case AArch64::BI_InterlockedIncrement16_rel:
case AArch64::BI_InterlockedIncrement_rel:
case AArch64::BI_InterlockedIncrement64_rel:
return MSVCIntrin::_InterlockedIncrement_rel;
case AArch64::BI_InterlockedIncrement16_nf:
case AArch64::BI_InterlockedIncrement_nf:
case AArch64::BI_InterlockedIncrement64_nf:
return MSVCIntrin::_InterlockedIncrement_nf;
case AArch64::BI_InterlockedDecrement16_acq:
case AArch64::BI_InterlockedDecrement_acq:
case AArch64::BI_InterlockedDecrement64_acq:
return MSVCIntrin::_InterlockedDecrement_acq;
case AArch64::BI_InterlockedDecrement16_rel:
case AArch64::BI_InterlockedDecrement_rel:
case AArch64::BI_InterlockedDecrement64_rel:
return MSVCIntrin::_InterlockedDecrement_rel;
case AArch64::BI_InterlockedDecrement16_nf:
case AArch64::BI_InterlockedDecrement_nf:
case AArch64::BI_InterlockedDecrement64_nf:
return MSVCIntrin::_InterlockedDecrement_nf;
}
llvm_unreachable("must return from switch");
}
static Optional<CodeGenFunction::MSVCIntrin>
translateX86ToMsvcIntrin(unsigned BuiltinID) {
using MSVCIntrin = CodeGenFunction::MSVCIntrin;
switch (BuiltinID) {
default:
return None;
case clang::X86::BI_BitScanForward:
case clang::X86::BI_BitScanForward64:
return MSVCIntrin::_BitScanForward;
case clang::X86::BI_BitScanReverse:
case clang::X86::BI_BitScanReverse64:
return MSVCIntrin::_BitScanReverse;
case clang::X86::BI_InterlockedAnd64:
return MSVCIntrin::_InterlockedAnd;
case clang::X86::BI_InterlockedCompareExchange128:
return MSVCIntrin::_InterlockedCompareExchange128;
case clang::X86::BI_InterlockedExchange64:
return MSVCIntrin::_InterlockedExchange;
case clang::X86::BI_InterlockedExchangeAdd64:
return MSVCIntrin::_InterlockedExchangeAdd;
case clang::X86::BI_InterlockedExchangeSub64:
return MSVCIntrin::_InterlockedExchangeSub;
case clang::X86::BI_InterlockedOr64:
return MSVCIntrin::_InterlockedOr;
case clang::X86::BI_InterlockedXor64:
return MSVCIntrin::_InterlockedXor;
case clang::X86::BI_InterlockedDecrement64:
return MSVCIntrin::_InterlockedDecrement;
case clang::X86::BI_InterlockedIncrement64:
return MSVCIntrin::_InterlockedIncrement;
}
llvm_unreachable("must return from switch");
}
// Emit an MSVC intrinsic. Assumes that arguments have *not* been evaluated.
Value *CodeGenFunction::EmitMSVCBuiltinExpr(MSVCIntrin BuiltinID,
const CallExpr *E) {
switch (BuiltinID) {
case MSVCIntrin::_BitScanForward:
case MSVCIntrin::_BitScanReverse: {
Address IndexAddress(EmitPointerWithAlignment(E->getArg(0)));
Value *ArgValue = EmitScalarExpr(E->getArg(1));
llvm::Type *ArgType = ArgValue->getType();
llvm::Type *IndexType =
IndexAddress.getPointer()->getType()->getPointerElementType();
llvm::Type *ResultType = ConvertType(E->getType());
Value *ArgZero = llvm::Constant::getNullValue(ArgType);
Value *ResZero = llvm::Constant::getNullValue(ResultType);
Value *ResOne = llvm::ConstantInt::get(ResultType, 1);
BasicBlock *Begin = Builder.GetInsertBlock();
BasicBlock *End = createBasicBlock("bitscan_end", this->CurFn);
Builder.SetInsertPoint(End);
PHINode *Result = Builder.CreatePHI(ResultType, 2, "bitscan_result");
Builder.SetInsertPoint(Begin);
Value *IsZero = Builder.CreateICmpEQ(ArgValue, ArgZero);
BasicBlock *NotZero = createBasicBlock("bitscan_not_zero", this->CurFn);
Builder.CreateCondBr(IsZero, End, NotZero);
Result->addIncoming(ResZero, Begin);
Builder.SetInsertPoint(NotZero);
if (BuiltinID == MSVCIntrin::_BitScanForward) {
Function *F = CGM.getIntrinsic(Intrinsic::cttz, ArgType);
Value *ZeroCount = Builder.CreateCall(F, {ArgValue, Builder.getTrue()});
ZeroCount = Builder.CreateIntCast(ZeroCount, IndexType, false);
Builder.CreateStore(ZeroCount, IndexAddress, false);
} else {
unsigned ArgWidth = cast<llvm::IntegerType>(ArgType)->getBitWidth();
Value *ArgTypeLastIndex = llvm::ConstantInt::get(IndexType, ArgWidth - 1);
Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ArgType);
Value *ZeroCount = Builder.CreateCall(F, {ArgValue, Builder.getTrue()});
ZeroCount = Builder.CreateIntCast(ZeroCount, IndexType, false);
Value *Index = Builder.CreateNSWSub(ArgTypeLastIndex, ZeroCount);
Builder.CreateStore(Index, IndexAddress, false);
}
Builder.CreateBr(End);
Result->addIncoming(ResOne, NotZero);
Builder.SetInsertPoint(End);
return Result;
}
case MSVCIntrin::_InterlockedAnd:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::And, E);
case MSVCIntrin::_InterlockedExchange:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Xchg, E);
case MSVCIntrin::_InterlockedExchangeAdd:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Add, E);
case MSVCIntrin::_InterlockedExchangeSub:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Sub, E);
case MSVCIntrin::_InterlockedOr:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Or, E);
case MSVCIntrin::_InterlockedXor:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Xor, E);
case MSVCIntrin::_InterlockedExchangeAdd_acq:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Add, E,
AtomicOrdering::Acquire);
case MSVCIntrin::_InterlockedExchangeAdd_rel:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Add, E,
AtomicOrdering::Release);
case MSVCIntrin::_InterlockedExchangeAdd_nf:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Add, E,
AtomicOrdering::Monotonic);
case MSVCIntrin::_InterlockedExchange_acq:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Xchg, E,
AtomicOrdering::Acquire);
case MSVCIntrin::_InterlockedExchange_rel:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Xchg, E,
AtomicOrdering::Release);
case MSVCIntrin::_InterlockedExchange_nf:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Xchg, E,
AtomicOrdering::Monotonic);
case MSVCIntrin::_InterlockedCompareExchange_acq:
return EmitAtomicCmpXchgForMSIntrin(*this, E, AtomicOrdering::Acquire);
case MSVCIntrin::_InterlockedCompareExchange_rel:
return EmitAtomicCmpXchgForMSIntrin(*this, E, AtomicOrdering::Release);
case MSVCIntrin::_InterlockedCompareExchange_nf:
return EmitAtomicCmpXchgForMSIntrin(*this, E, AtomicOrdering::Monotonic);
case MSVCIntrin::_InterlockedCompareExchange128:
return EmitAtomicCmpXchg128ForMSIntrin(
*this, E, AtomicOrdering::SequentiallyConsistent);
case MSVCIntrin::_InterlockedCompareExchange128_acq:
return EmitAtomicCmpXchg128ForMSIntrin(*this, E, AtomicOrdering::Acquire);
case MSVCIntrin::_InterlockedCompareExchange128_rel:
return EmitAtomicCmpXchg128ForMSIntrin(*this, E, AtomicOrdering::Release);
case MSVCIntrin::_InterlockedCompareExchange128_nf:
return EmitAtomicCmpXchg128ForMSIntrin(*this, E, AtomicOrdering::Monotonic);
case MSVCIntrin::_InterlockedOr_acq:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Or, E,
AtomicOrdering::Acquire);
case MSVCIntrin::_InterlockedOr_rel:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Or, E,
AtomicOrdering::Release);
case MSVCIntrin::_InterlockedOr_nf:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Or, E,
AtomicOrdering::Monotonic);
case MSVCIntrin::_InterlockedXor_acq:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Xor, E,
AtomicOrdering::Acquire);
case MSVCIntrin::_InterlockedXor_rel:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Xor, E,
AtomicOrdering::Release);
case MSVCIntrin::_InterlockedXor_nf:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::Xor, E,
AtomicOrdering::Monotonic);
case MSVCIntrin::_InterlockedAnd_acq:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::And, E,
AtomicOrdering::Acquire);
case MSVCIntrin::_InterlockedAnd_rel:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::And, E,
AtomicOrdering::Release);
case MSVCIntrin::_InterlockedAnd_nf:
return MakeBinaryAtomicValue(*this, AtomicRMWInst::And, E,
AtomicOrdering::Monotonic);
case MSVCIntrin::_InterlockedIncrement_acq:
return EmitAtomicIncrementValue(*this, E, AtomicOrdering::Acquire);
case MSVCIntrin::_InterlockedIncrement_rel:
return EmitAtomicIncrementValue(*this, E, AtomicOrdering::Release);
case MSVCIntrin::_InterlockedIncrement_nf:
return EmitAtomicIncrementValue(*this, E, AtomicOrdering::Monotonic);
case MSVCIntrin::_InterlockedDecrement_acq:
return EmitAtomicDecrementValue(*this, E, AtomicOrdering::Acquire);
case MSVCIntrin::_InterlockedDecrement_rel:
return EmitAtomicDecrementValue(*this, E, AtomicOrdering::Release);
case MSVCIntrin::_InterlockedDecrement_nf:
return EmitAtomicDecrementValue(*this, E, AtomicOrdering::Monotonic);
case MSVCIntrin::_InterlockedDecrement:
return EmitAtomicDecrementValue(*this, E);
case MSVCIntrin::_InterlockedIncrement:
return EmitAtomicIncrementValue(*this, E);
case MSVCIntrin::__fastfail: {
// Request immediate process termination from the kernel. The instruction
// sequences to do this are documented on MSDN:
// https://msdn.microsoft.com/en-us/library/dn774154.aspx
llvm::Triple::ArchType ISA = getTarget().getTriple().getArch();
StringRef Asm, Constraints;
switch (ISA) {
default:
ErrorUnsupported(E, "__fastfail call for this architecture");
break;
case llvm::Triple::x86:
case llvm::Triple::x86_64:
Asm = "int $$0x29";
Constraints = "{cx}";
break;
case llvm::Triple::thumb:
Asm = "udf #251";
Constraints = "{r0}";
break;
case llvm::Triple::aarch64:
Asm = "brk #0xF003";
Constraints = "{w0}";
}
llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, {Int32Ty}, false);
llvm::InlineAsm *IA =
llvm::InlineAsm::get(FTy, Asm, Constraints, /*hasSideEffects=*/true);
llvm::AttributeList NoReturnAttr = llvm::AttributeList::get(
getLLVMContext(), llvm::AttributeList::FunctionIndex,
llvm::Attribute::NoReturn);
llvm::CallInst *CI = Builder.CreateCall(IA, EmitScalarExpr(E->getArg(0)));
CI->setAttributes(NoReturnAttr);
return CI;
}
}
llvm_unreachable("Incorrect MSVC intrinsic!");
}
namespace {
// ARC cleanup for __builtin_os_log_format
struct CallObjCArcUse final : EHScopeStack::Cleanup {
CallObjCArcUse(llvm::Value *object) : object(object) {}
llvm::Value *object;
void Emit(CodeGenFunction &CGF, Flags flags) override {
CGF.EmitARCIntrinsicUse(object);
}
};
}
Value *CodeGenFunction::EmitCheckedArgForBuiltin(const Expr *E,
BuiltinCheckKind Kind) {
assert((Kind == BCK_CLZPassedZero || Kind == BCK_CTZPassedZero)
&& "Unsupported builtin check kind");
Value *ArgValue = EmitScalarExpr(E);
if (!SanOpts.has(SanitizerKind::Builtin) || !getTarget().isCLZForZeroUndef())
return ArgValue;
SanitizerScope SanScope(this);
Value *Cond = Builder.CreateICmpNE(
ArgValue, llvm::Constant::getNullValue(ArgValue->getType()));
EmitCheck(std::make_pair(Cond, SanitizerKind::Builtin),
SanitizerHandler::InvalidBuiltin,
{EmitCheckSourceLocation(E->getExprLoc()),
llvm::ConstantInt::get(Builder.getInt8Ty(), Kind)},
None);
return ArgValue;
}
/// Get the argument type for arguments to os_log_helper.
static CanQualType getOSLogArgType(ASTContext &C, int Size) {
QualType UnsignedTy = C.getIntTypeForBitwidth(Size * 8, /*Signed=*/false);
return C.getCanonicalType(UnsignedTy);
}
llvm::Function *CodeGenFunction::generateBuiltinOSLogHelperFunction(
const analyze_os_log::OSLogBufferLayout &Layout,
CharUnits BufferAlignment) {
ASTContext &Ctx = getContext();
llvm::SmallString<64> Name;
{
raw_svector_ostream OS(Name);
OS << "__os_log_helper";
OS << "_" << BufferAlignment.getQuantity();
OS << "_" << int(Layout.getSummaryByte());
OS << "_" << int(Layout.getNumArgsByte());
for (const auto &Item : Layout.Items)
OS << "_" << int(Item.getSizeByte()) << "_"
<< int(Item.getDescriptorByte());
}
if (llvm::Function *F = CGM.getModule().getFunction(Name))
return F;
llvm::SmallVector<QualType, 4> ArgTys;
FunctionArgList Args;
Args.push_back(ImplicitParamDecl::Create(
Ctx, nullptr, SourceLocation(), &Ctx.Idents.get("buffer"), Ctx.VoidPtrTy,
ImplicitParamDecl::Other));
ArgTys.emplace_back(Ctx.VoidPtrTy);
for (unsigned int I = 0, E = Layout.Items.size(); I < E; ++I) {
char Size = Layout.Items[I].getSizeByte();
if (!Size)
continue;
QualType ArgTy = getOSLogArgType(Ctx, Size);
Args.push_back(ImplicitParamDecl::Create(
Ctx, nullptr, SourceLocation(),
&Ctx.Idents.get(std::string("arg") + llvm::to_string(I)), ArgTy,
ImplicitParamDecl::Other));
ArgTys.emplace_back(ArgTy);
}
QualType ReturnTy = Ctx.VoidTy;
QualType FuncionTy = Ctx.getFunctionType(ReturnTy, ArgTys, {});
// The helper function has linkonce_odr linkage to enable the linker to merge
// identical functions. To ensure the merging always happens, 'noinline' is
// attached to the function when compiling with -Oz.
const CGFunctionInfo &FI =
CGM.getTypes().arrangeBuiltinFunctionDeclaration(ReturnTy, Args);
llvm::FunctionType *FuncTy = CGM.getTypes().GetFunctionType(FI);
llvm::Function *Fn = llvm::Function::Create(
FuncTy, llvm::GlobalValue::LinkOnceODRLinkage, Name, &CGM.getModule());
Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);
CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, Fn);
CGM.SetLLVMFunctionAttributesForDefinition(nullptr, Fn);
Fn->setDoesNotThrow();
// Attach 'noinline' at -Oz.
if (CGM.getCodeGenOpts().OptimizeSize == 2)
Fn->addFnAttr(llvm::Attribute::NoInline);
auto NL = ApplyDebugLocation::CreateEmpty(*this);
IdentifierInfo *II = &Ctx.Idents.get(Name);
FunctionDecl *FD = FunctionDecl::Create(
Ctx, Ctx.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II,
FuncionTy, nullptr, SC_PrivateExtern, false, false);
// Avoid generating debug location info for the function.
FD->setImplicit();
StartFunction(FD, ReturnTy, Fn, FI, Args);
// Create a scope with an artificial location for the body of this function.
auto AL = ApplyDebugLocation::CreateArtificial(*this);
CharUnits Offset;
Address BufAddr(Builder.CreateLoad(GetAddrOfLocalVar(Args[0]), "buf"),
BufferAlignment);
Builder.CreateStore(Builder.getInt8(Layout.getSummaryByte()),
Builder.CreateConstByteGEP(BufAddr, Offset++, "summary"));
Builder.CreateStore(Builder.getInt8(Layout.getNumArgsByte()),
Builder.CreateConstByteGEP(BufAddr, Offset++, "numArgs"));
unsigned I = 1;
for (const auto &Item : Layout.Items) {
Builder.CreateStore(
Builder.getInt8(Item.getDescriptorByte()),
Builder.CreateConstByteGEP(BufAddr, Offset++, "argDescriptor"));
Builder.CreateStore(
Builder.getInt8(Item.getSizeByte()),
Builder.CreateConstByteGEP(BufAddr, Offset++, "argSize"));
CharUnits Size = Item.size();
if (!Size.getQuantity())
continue;
Address Arg = GetAddrOfLocalVar(Args[I]);
Address Addr = Builder.CreateConstByteGEP(BufAddr, Offset, "argData");
Addr = Builder.CreateBitCast(Addr, Arg.getPointer()->getType(),
"argDataCast");
Builder.CreateStore(Builder.CreateLoad(Arg), Addr);
Offset += Size;
++I;
}
FinishFunction();
return Fn;
}
RValue CodeGenFunction::emitBuiltinOSLogFormat(const CallExpr &E) {
assert(E.getNumArgs() >= 2 &&
"__builtin_os_log_format takes at least 2 arguments");
ASTContext &Ctx = getContext();
analyze_os_log::OSLogBufferLayout Layout;
analyze_os_log::computeOSLogBufferLayout(Ctx, &E, Layout);
Address BufAddr = EmitPointerWithAlignment(E.getArg(0));
llvm::SmallVector<llvm::Value *, 4> RetainableOperands;
// Ignore argument 1, the format string. It is not currently used.
CallArgList Args;
Args.add(RValue::get(BufAddr.getPointer()), Ctx.VoidPtrTy);
for (const auto &Item : Layout.Items) {
int Size = Item.getSizeByte();
if (!Size)
continue;
llvm::Value *ArgVal;
if (Item.getKind() == analyze_os_log::OSLogBufferItem::MaskKind) {
uint64_t Val = 0;
for (unsigned I = 0, E = Item.getMaskType().size(); I < E; ++I)
Val |= ((uint64_t)Item.getMaskType()[I]) << I * 8;
ArgVal = llvm::Constant::getIntegerValue(Int64Ty, llvm::APInt(64, Val));
} else if (const Expr *TheExpr = Item.getExpr()) {
ArgVal = EmitScalarExpr(TheExpr, /*Ignore*/ false);
// If a temporary object that requires destruction after the full
// expression is passed, push a lifetime-extended cleanup to extend its
// lifetime to the end of the enclosing block scope.
auto LifetimeExtendObject = [&](const Expr *E) {
E = E->IgnoreParenCasts();
// Extend lifetimes of objects returned by function calls and message
// sends.
// FIXME: We should do this in other cases in which temporaries are
// created including arguments of non-ARC types (e.g., C++
// temporaries).
if (isa<CallExpr>(E) || isa<ObjCMessageExpr>(E))
return true;
return false;
};
if (TheExpr->getType()->isObjCRetainableType() &&
getLangOpts().ObjCAutoRefCount && LifetimeExtendObject(TheExpr)) {
assert(getEvaluationKind(TheExpr->getType()) == TEK_Scalar &&
"Only scalar can be a ObjC retainable type");
if (!isa<Constant>(ArgVal)) {
CleanupKind Cleanup = getARCCleanupKind();
QualType Ty = TheExpr->getType();
Address Alloca = Address::invalid();
Address Addr = CreateMemTemp(Ty, "os.log.arg", &Alloca);
ArgVal = EmitARCRetain(Ty, ArgVal);
Builder.CreateStore(ArgVal, Addr);
pushLifetimeExtendedDestroy(Cleanup, Alloca, Ty,
CodeGenFunction::destroyARCStrongPrecise,
Cleanup & EHCleanup);
// Push a clang.arc.use call to ensure ARC optimizer knows that the
// argument has to be alive.
if (CGM.getCodeGenOpts().OptimizationLevel != 0)
pushCleanupAfterFullExpr<CallObjCArcUse>(Cleanup, ArgVal);
}
}
} else {
ArgVal = Builder.getInt32(Item.getConstValue().getQuantity());
}
unsigned ArgValSize =
CGM.getDataLayout().getTypeSizeInBits(ArgVal->getType());
llvm::IntegerType *IntTy = llvm::Type::getIntNTy(getLLVMContext(),
ArgValSize);
ArgVal = Builder.CreateBitOrPointerCast(ArgVal, IntTy);
CanQualType ArgTy = getOSLogArgType(Ctx, Size);
// If ArgVal has type x86_fp80, zero-extend ArgVal.
ArgVal = Builder.CreateZExtOrBitCast(ArgVal, ConvertType(ArgTy));
Args.add(RValue::get(ArgVal), ArgTy);
}
const CGFunctionInfo &FI =
CGM.getTypes().arrangeBuiltinFunctionCall(Ctx.VoidTy, Args);
llvm::Function *F = CodeGenFunction(CGM).generateBuiltinOSLogHelperFunction(
Layout, BufAddr.getAlignment());
EmitCall(FI, CGCallee::forDirect(F), ReturnValueSlot(), Args);
return RValue::get(BufAddr.getPointer());
}
static bool isSpecialUnsignedMultiplySignedResult(
unsigned BuiltinID, WidthAndSignedness Op1Info, WidthAndSignedness Op2Info,
WidthAndSignedness ResultInfo) {
return BuiltinID == Builtin::BI__builtin_mul_overflow &&
Op1Info.Width == Op2Info.Width && Op2Info.Width == ResultInfo.Width &&
!Op1Info.Signed && !Op2Info.Signed && ResultInfo.Signed;
}
static RValue EmitCheckedUnsignedMultiplySignedResult(
CodeGenFunction &CGF, const clang::Expr *Op1, WidthAndSignedness Op1Info,
const clang::Expr *Op2, WidthAndSignedness Op2Info,
const clang::Expr *ResultArg, QualType ResultQTy,
WidthAndSignedness ResultInfo) {
assert(isSpecialUnsignedMultiplySignedResult(
Builtin::BI__builtin_mul_overflow, Op1Info, Op2Info, ResultInfo) &&
"Cannot specialize this multiply");
llvm::Value *V1 = CGF.EmitScalarExpr(Op1);
llvm::Value *V2 = CGF.EmitScalarExpr(Op2);
llvm::Value *HasOverflow;
llvm::Value *Result = EmitOverflowIntrinsic(
CGF, llvm::Intrinsic::umul_with_overflow, V1, V2, HasOverflow);
// The intrinsic call will detect overflow when the value is > UINT_MAX,
// however, since the original builtin had a signed result, we need to report
// an overflow when the result is greater than INT_MAX.
auto IntMax = llvm::APInt::getSignedMaxValue(ResultInfo.Width);
llvm::Value *IntMaxValue = llvm::ConstantInt::get(Result->getType(), IntMax);
llvm::Value *IntMaxOverflow = CGF.Builder.CreateICmpUGT(Result, IntMaxValue);
HasOverflow = CGF.Builder.CreateOr(HasOverflow, IntMaxOverflow);
bool isVolatile =
ResultArg->getType()->getPointeeType().isVolatileQualified();
Address ResultPtr = CGF.EmitPointerWithAlignment(ResultArg);
CGF.Builder.CreateStore(CGF.EmitToMemory(Result, ResultQTy), ResultPtr,
isVolatile);
return RValue::get(HasOverflow);
}
/// Determine if a binop is a checked mixed-sign multiply we can specialize.
static bool isSpecialMixedSignMultiply(unsigned BuiltinID,
WidthAndSignedness Op1Info,
WidthAndSignedness Op2Info,
WidthAndSignedness ResultInfo) {
return BuiltinID == Builtin::BI__builtin_mul_overflow &&
std::max(Op1Info.Width, Op2Info.Width) >= ResultInfo.Width &&
Op1Info.Signed != Op2Info.Signed;
}
/// Emit a checked mixed-sign multiply. This is a cheaper specialization of
/// the generic checked-binop irgen.
static RValue
EmitCheckedMixedSignMultiply(CodeGenFunction &CGF, const clang::Expr *Op1,
WidthAndSignedness Op1Info, const clang::Expr *Op2,
WidthAndSignedness Op2Info,
const clang::Expr *ResultArg, QualType ResultQTy,
WidthAndSignedness ResultInfo) {
assert(isSpecialMixedSignMultiply(Builtin::BI__builtin_mul_overflow, Op1Info,
Op2Info, ResultInfo) &&
"Not a mixed-sign multipliction we can specialize");
// Emit the signed and unsigned operands.
const clang::Expr *SignedOp = Op1Info.Signed ? Op1 : Op2;
const clang::Expr *UnsignedOp = Op1Info.Signed ? Op2 : Op1;
llvm::Value *Signed = CGF.EmitScalarExpr(SignedOp);
llvm::Value *Unsigned = CGF.EmitScalarExpr(UnsignedOp);
unsigned SignedOpWidth = Op1Info.Signed ? Op1Info.Width : Op2Info.Width;
unsigned UnsignedOpWidth = Op1Info.Signed ? Op2Info.Width : Op1Info.Width;
// One of the operands may be smaller than the other. If so, [s|z]ext it.
if (SignedOpWidth < UnsignedOpWidth)
Signed = CGF.Builder.CreateSExt(Signed, Unsigned->getType(), "op.sext");
if (UnsignedOpWidth < SignedOpWidth)
Unsigned = CGF.Builder.CreateZExt(Unsigned, Signed->getType(), "op.zext");
llvm::Type *OpTy = Signed->getType();
llvm::Value *Zero = llvm::Constant::getNullValue(OpTy);
Address ResultPtr = CGF.EmitPointerWithAlignment(ResultArg);
llvm::Type *ResTy = ResultPtr.getElementType();
unsigned OpWidth = std::max(Op1Info.Width, Op2Info.Width);
// Take the absolute value of the signed operand.
llvm::Value *IsNegative = CGF.Builder.CreateICmpSLT(Signed, Zero);
llvm::Value *AbsOfNegative = CGF.Builder.CreateSub(Zero, Signed);
llvm::Value *AbsSigned =
CGF.Builder.CreateSelect(IsNegative, AbsOfNegative, Signed);
// Perform a checked unsigned multiplication.
llvm::Value *UnsignedOverflow;
llvm::Value *UnsignedResult =
EmitOverflowIntrinsic(CGF, llvm::Intrinsic::umul_with_overflow, AbsSigned,
Unsigned, UnsignedOverflow);
llvm::Value *Overflow, *Result;
if (ResultInfo.Signed) {
// Signed overflow occurs if the result is greater than INT_MAX or lesser
// than INT_MIN, i.e when |Result| > (INT_MAX + IsNegative).
auto IntMax =
llvm::APInt::getSignedMaxValue(ResultInfo.Width).zextOrSelf(OpWidth);
llvm::Value *MaxResult =
CGF.Builder.CreateAdd(llvm::ConstantInt::get(OpTy, IntMax),
CGF.Builder.CreateZExt(IsNegative, OpTy));
llvm::Value *SignedOverflow =
CGF.Builder.CreateICmpUGT(UnsignedResult, MaxResult);
Overflow = CGF.Builder.CreateOr(UnsignedOverflow, SignedOverflow);
// Prepare the signed result (possibly by negating it).
llvm::Value *NegativeResult = CGF.Builder.CreateNeg(UnsignedResult);
llvm::Value *SignedResult =
CGF.Builder.CreateSelect(IsNegative, NegativeResult, UnsignedResult);
Result = CGF.Builder.CreateTrunc(SignedResult, ResTy);
} else {
// Unsigned overflow occurs if the result is < 0 or greater than UINT_MAX.
llvm::Value *Underflow = CGF.Builder.CreateAnd(
IsNegative, CGF.Builder.CreateIsNotNull(UnsignedResult));
Overflow = CGF.Builder.CreateOr(UnsignedOverflow, Underflow);
if (ResultInfo.Width < OpWidth) {
auto IntMax =
llvm::APInt::getMaxValue(ResultInfo.Width).zext(OpWidth);
llvm::Value *TruncOverflow = CGF.Builder.CreateICmpUGT(
UnsignedResult, llvm::ConstantInt::get(OpTy, IntMax));
Overflow = CGF.Builder.CreateOr(Overflow, TruncOverflow);
}
// Negate the product if it would be negative in infinite precision.
Result = CGF.Builder.CreateSelect(
IsNegative, CGF.Builder.CreateNeg(UnsignedResult), UnsignedResult);
Result = CGF.Builder.CreateTrunc(Result, ResTy);
}
assert(Overflow && Result && "Missing overflow or result");
bool isVolatile =
ResultArg->getType()->getPointeeType().isVolatileQualified();
CGF.Builder.CreateStore(CGF.EmitToMemory(Result, ResultQTy), ResultPtr,
isVolatile);
return RValue::get(Overflow);
}
static llvm::Value *dumpRecord(CodeGenFunction &CGF, QualType RType,
Value *&RecordPtr, CharUnits Align,
llvm::FunctionCallee Func, int Lvl) {
ASTContext &Context = CGF.getContext();
RecordDecl *RD = RType->castAs<RecordType>()->getDecl()->getDefinition();
std::string Pad = std::string(Lvl * 4, ' ');
Value *GString =
CGF.Builder.CreateGlobalStringPtr(RType.getAsString() + " {\n");
Value *Res = CGF.Builder.CreateCall(Func, {GString});
static llvm::DenseMap<QualType, const char *> Types;
if (Types.empty()) {
Types[Context.CharTy] = "%c";
Types[Context.BoolTy] = "%d";
Types[Context.SignedCharTy] = "%hhd";
Types[Context.UnsignedCharTy] = "%hhu";
Types[Context.IntTy] = "%d";
Types[Context.UnsignedIntTy] = "%u";
Types[Context.LongTy] = "%ld";
Types[Context.UnsignedLongTy] = "%lu";
Types[Context.LongLongTy] = "%lld";
Types[Context.UnsignedLongLongTy] = "%llu";
Types[Context.ShortTy] = "%hd";
Types[Context.UnsignedShortTy] = "%hu";
Types[Context.VoidPtrTy] = "%p";
Types[Context.FloatTy] = "%f";
Types[Context.DoubleTy] = "%f";
Types[Context.LongDoubleTy] = "%Lf";
Types[Context.getPointerType(Context.CharTy)] = "%s";
Types[Context.getPointerType(Context.getConstType(Context.CharTy))] = "%s";
}
for (const auto *FD : RD->fields()) {
Value *FieldPtr = RecordPtr;
if (RD->isUnion())
FieldPtr = CGF.Builder.CreatePointerCast(
FieldPtr, CGF.ConvertType(Context.getPointerType(FD->getType())));
else
FieldPtr = CGF.Builder.CreateStructGEP(CGF.ConvertType(RType), FieldPtr,
FD->getFieldIndex());
GString = CGF.Builder.CreateGlobalStringPtr(
llvm::Twine(Pad)
.concat(FD->getType().getAsString())
.concat(llvm::Twine(' '))
.concat(FD->getNameAsString())
.concat(" : ")
.str());
Value *TmpRes = CGF.Builder.CreateCall(Func, {GString});
Res = CGF.Builder.CreateAdd(Res, TmpRes);
QualType CanonicalType =
FD->getType().getUnqualifiedType().getCanonicalType();
// We check whether we are in a recursive type
if (CanonicalType->isRecordType()) {
TmpRes = dumpRecord(CGF, CanonicalType, FieldPtr, Align, Func, Lvl + 1);
Res = CGF.Builder.CreateAdd(TmpRes, Res);
continue;
}
// We try to determine the best format to print the current field
llvm::Twine Format = Types.find(CanonicalType) == Types.end()
? Types[Context.VoidPtrTy]
: Types[CanonicalType];
Address FieldAddress = Address(FieldPtr, Align);
FieldPtr = CGF.Builder.CreateLoad(FieldAddress);
// FIXME Need to handle bitfield here
GString = CGF.Builder.CreateGlobalStringPtr(
Format.concat(llvm::Twine('\n')).str());
TmpRes = CGF.Builder.CreateCall(Func, {GString, FieldPtr});
Res = CGF.Builder.CreateAdd(Res, TmpRes);
}
GString = CGF.Builder.CreateGlobalStringPtr(Pad + "}\n");
Value *TmpRes = CGF.Builder.CreateCall(Func, {GString});
Res = CGF.Builder.CreateAdd(Res, TmpRes);
return Res;
}
static bool
TypeRequiresBuiltinLaunderImp(const ASTContext &Ctx, QualType Ty,
llvm::SmallPtrSetImpl<const Decl *> &Seen) {
if (const auto *Arr = Ctx.getAsArrayType(Ty))
Ty = Ctx.getBaseElementType(Arr);
const auto *Record = Ty->getAsCXXRecordDecl();
if (!Record)
return false;
// We've already checked this type, or are in the process of checking it.
if (!Seen.insert(Record).second)
return false;
assert(Record->hasDefinition() &&
"Incomplete types should already be diagnosed");
if (Record->isDynamicClass())
return true;
for (FieldDecl *F : Record->fields()) {
if (TypeRequiresBuiltinLaunderImp(Ctx, F->getType(), Seen))
return true;
}
return false;
}
/// Determine if the specified type requires laundering by checking if it is a
/// dynamic class type or contains a subobject which is a dynamic class type.
static bool TypeRequiresBuiltinLaunder(CodeGenModule &CGM, QualType Ty) {
if (!CGM.getCodeGenOpts().StrictVTablePointers)
return false;
llvm::SmallPtrSet<const Decl *, 16> Seen;
return TypeRequiresBuiltinLaunderImp(CGM.getContext(), Ty, Seen);
}
RValue CodeGenFunction::emitRotate(const CallExpr *E, bool IsRotateRight) {
llvm::Value *Src = EmitScalarExpr(E->getArg(0));
llvm::Value *ShiftAmt = EmitScalarExpr(E->getArg(1));
// The builtin's shift arg may have a different type than the source arg and
// result, but the LLVM intrinsic uses the same type for all values.
llvm::Type *Ty = Src->getType();
ShiftAmt = Builder.CreateIntCast(ShiftAmt, Ty, false);
// Rotate is a special case of LLVM funnel shift - 1st 2 args are the same.
unsigned IID = IsRotateRight ? Intrinsic::fshr : Intrinsic::fshl;
Function *F = CGM.getIntrinsic(IID, Ty);
return RValue::get(Builder.CreateCall(F, { Src, Src, ShiftAmt }));
}
RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
const CallExpr *E,
ReturnValueSlot ReturnValue) {
const FunctionDecl *FD = GD.getDecl()->getAsFunction();
// See if we can constant fold this builtin. If so, don't emit it at all.
Expr::EvalResult Result;
if (E->EvaluateAsRValue(Result, CGM.getContext()) &&
!Result.hasSideEffects()) {
if (Result.Val.isInt())
return RValue::get(llvm::ConstantInt::get(getLLVMContext(),
Result.Val.getInt()));
if (Result.Val.isFloat())
return RValue::get(llvm::ConstantFP::get(getLLVMContext(),
Result.Val.getFloat()));
}
// If the builtin has been declared explicitly with an assembler label,
// disable the specialized emitting below. Ideally we should communicate the
// rename in IR, or at least avoid generating the intrinsic calls that are
// likely to get lowered to the renamed library functions.
const unsigned BuiltinIDIfNoAsmLabel =
FD->hasAttr<AsmLabelAttr>() ? 0 : BuiltinID;
// There are LLVM math intrinsics/instructions corresponding to math library
// functions except the LLVM op will never set errno while the math library
// might. Also, math builtins have the same semantics as their math library
// twins. Thus, we can transform math library and builtin calls to their
// LLVM counterparts if the call is marked 'const' (known to never set errno).
if (FD->hasAttr<ConstAttr>()) {
switch (BuiltinIDIfNoAsmLabel) {
case Builtin::BIceil:
case Builtin::BIceilf:
case Builtin::BIceill:
case Builtin::BI__builtin_ceil:
case Builtin::BI__builtin_ceilf:
case Builtin::BI__builtin_ceilf16:
case Builtin::BI__builtin_ceill:
case Builtin::BI__builtin_ceilf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::ceil,
Intrinsic::experimental_constrained_ceil));
case Builtin::BIcopysign:
case Builtin::BIcopysignf:
case Builtin::BIcopysignl:
case Builtin::BI__builtin_copysign:
case Builtin::BI__builtin_copysignf:
case Builtin::BI__builtin_copysignf16:
case Builtin::BI__builtin_copysignl:
case Builtin::BI__builtin_copysignf128:
return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::copysign));
case Builtin::BIcos:
case Builtin::BIcosf:
case Builtin::BIcosl:
case Builtin::BI__builtin_cos:
case Builtin::BI__builtin_cosf:
case Builtin::BI__builtin_cosf16:
case Builtin::BI__builtin_cosl:
case Builtin::BI__builtin_cosf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::cos,
Intrinsic::experimental_constrained_cos));
case Builtin::BIexp:
case Builtin::BIexpf:
case Builtin::BIexpl:
case Builtin::BI__builtin_exp:
case Builtin::BI__builtin_expf:
case Builtin::BI__builtin_expf16:
case Builtin::BI__builtin_expl:
case Builtin::BI__builtin_expf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::exp,
Intrinsic::experimental_constrained_exp));
case Builtin::BIexp2:
case Builtin::BIexp2f:
case Builtin::BIexp2l:
case Builtin::BI__builtin_exp2:
case Builtin::BI__builtin_exp2f:
case Builtin::BI__builtin_exp2f16:
case Builtin::BI__builtin_exp2l:
case Builtin::BI__builtin_exp2f128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::exp2,
Intrinsic::experimental_constrained_exp2));
case Builtin::BIfabs:
case Builtin::BIfabsf:
case Builtin::BIfabsl:
case Builtin::BI__builtin_fabs:
case Builtin::BI__builtin_fabsf:
case Builtin::BI__builtin_fabsf16:
case Builtin::BI__builtin_fabsl:
case Builtin::BI__builtin_fabsf128:
return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::fabs));
case Builtin::BIfloor:
case Builtin::BIfloorf:
case Builtin::BIfloorl:
case Builtin::BI__builtin_floor:
case Builtin::BI__builtin_floorf:
case Builtin::BI__builtin_floorf16:
case Builtin::BI__builtin_floorl:
case Builtin::BI__builtin_floorf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::floor,
Intrinsic::experimental_constrained_floor));
case Builtin::BIfma:
case Builtin::BIfmaf:
case Builtin::BIfmal:
case Builtin::BI__builtin_fma:
case Builtin::BI__builtin_fmaf:
case Builtin::BI__builtin_fmaf16:
case Builtin::BI__builtin_fmal:
case Builtin::BI__builtin_fmaf128:
return RValue::get(emitTernaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::fma,
Intrinsic::experimental_constrained_fma));
case Builtin::BIfmax:
case Builtin::BIfmaxf:
case Builtin::BIfmaxl:
case Builtin::BI__builtin_fmax:
case Builtin::BI__builtin_fmaxf:
case Builtin::BI__builtin_fmaxf16:
case Builtin::BI__builtin_fmaxl:
case Builtin::BI__builtin_fmaxf128:
return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::maxnum,
Intrinsic::experimental_constrained_maxnum));
case Builtin::BIfmin:
case Builtin::BIfminf:
case Builtin::BIfminl:
case Builtin::BI__builtin_fmin:
case Builtin::BI__builtin_fminf:
case Builtin::BI__builtin_fminf16:
case Builtin::BI__builtin_fminl:
case Builtin::BI__builtin_fminf128:
return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::minnum,
Intrinsic::experimental_constrained_minnum));
// fmod() is a special-case. It maps to the frem instruction rather than an
// LLVM intrinsic.
case Builtin::BIfmod:
case Builtin::BIfmodf:
case Builtin::BIfmodl:
case Builtin::BI__builtin_fmod:
case Builtin::BI__builtin_fmodf:
case Builtin::BI__builtin_fmodf16:
case Builtin::BI__builtin_fmodl:
case Builtin::BI__builtin_fmodf128: {
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(*this, E);
Value *Arg1 = EmitScalarExpr(E->getArg(0));
Value *Arg2 = EmitScalarExpr(E->getArg(1));
return RValue::get(Builder.CreateFRem(Arg1, Arg2, "fmod"));
}
case Builtin::BIlog:
case Builtin::BIlogf:
case Builtin::BIlogl:
case Builtin::BI__builtin_log:
case Builtin::BI__builtin_logf:
case Builtin::BI__builtin_logf16:
case Builtin::BI__builtin_logl:
case Builtin::BI__builtin_logf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::log,
Intrinsic::experimental_constrained_log));
case Builtin::BIlog10:
case Builtin::BIlog10f:
case Builtin::BIlog10l:
case Builtin::BI__builtin_log10:
case Builtin::BI__builtin_log10f:
case Builtin::BI__builtin_log10f16:
case Builtin::BI__builtin_log10l:
case Builtin::BI__builtin_log10f128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::log10,
Intrinsic::experimental_constrained_log10));
case Builtin::BIlog2:
case Builtin::BIlog2f:
case Builtin::BIlog2l:
case Builtin::BI__builtin_log2:
case Builtin::BI__builtin_log2f:
case Builtin::BI__builtin_log2f16:
case Builtin::BI__builtin_log2l:
case Builtin::BI__builtin_log2f128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::log2,
Intrinsic::experimental_constrained_log2));
case Builtin::BInearbyint:
case Builtin::BInearbyintf:
case Builtin::BInearbyintl:
case Builtin::BI__builtin_nearbyint:
case Builtin::BI__builtin_nearbyintf:
case Builtin::BI__builtin_nearbyintl:
case Builtin::BI__builtin_nearbyintf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::nearbyint,
Intrinsic::experimental_constrained_nearbyint));
case Builtin::BIpow:
case Builtin::BIpowf:
case Builtin::BIpowl:
case Builtin::BI__builtin_pow:
case Builtin::BI__builtin_powf:
case Builtin::BI__builtin_powf16:
case Builtin::BI__builtin_powl:
case Builtin::BI__builtin_powf128:
return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::pow,
Intrinsic::experimental_constrained_pow));
case Builtin::BIrint:
case Builtin::BIrintf:
case Builtin::BIrintl:
case Builtin::BI__builtin_rint:
case Builtin::BI__builtin_rintf:
case Builtin::BI__builtin_rintf16:
case Builtin::BI__builtin_rintl:
case Builtin::BI__builtin_rintf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::rint,
Intrinsic::experimental_constrained_rint));
case Builtin::BIround:
case Builtin::BIroundf:
case Builtin::BIroundl:
case Builtin::BI__builtin_round:
case Builtin::BI__builtin_roundf:
case Builtin::BI__builtin_roundf16:
case Builtin::BI__builtin_roundl:
case Builtin::BI__builtin_roundf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::round,
Intrinsic::experimental_constrained_round));
case Builtin::BIsin:
case Builtin::BIsinf:
case Builtin::BIsinl:
case Builtin::BI__builtin_sin:
case Builtin::BI__builtin_sinf:
case Builtin::BI__builtin_sinf16:
case Builtin::BI__builtin_sinl:
case Builtin::BI__builtin_sinf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::sin,
Intrinsic::experimental_constrained_sin));
case Builtin::BIsqrt:
case Builtin::BIsqrtf:
case Builtin::BIsqrtl:
case Builtin::BI__builtin_sqrt:
case Builtin::BI__builtin_sqrtf:
case Builtin::BI__builtin_sqrtf16:
case Builtin::BI__builtin_sqrtl:
case Builtin::BI__builtin_sqrtf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::sqrt,
Intrinsic::experimental_constrained_sqrt));
case Builtin::BItrunc:
case Builtin::BItruncf:
case Builtin::BItruncl:
case Builtin::BI__builtin_trunc:
case Builtin::BI__builtin_truncf:
case Builtin::BI__builtin_truncf16:
case Builtin::BI__builtin_truncl:
case Builtin::BI__builtin_truncf128:
return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
Intrinsic::trunc,
Intrinsic::experimental_constrained_trunc));
case Builtin::BIlround:
case Builtin::BIlroundf:
case Builtin::BIlroundl:
case Builtin::BI__builtin_lround:
case Builtin::BI__builtin_lroundf:
case Builtin::BI__builtin_lroundl:
case Builtin::BI__builtin_lroundf128:
return RValue::get(emitMaybeConstrainedFPToIntRoundBuiltin(
*this, E, Intrinsic::lround,
Intrinsic::experimental_constrained_lround));
case Builtin::BIllround:
case Builtin::BIllroundf:
case Builtin::BIllroundl:
case Builtin::BI__builtin_llround:
case Builtin::BI__builtin_llroundf:
case Builtin::BI__builtin_llroundl:
case Builtin::BI__builtin_llroundf128:
return RValue::get(emitMaybeConstrainedFPToIntRoundBuiltin(
*this, E, Intrinsic::llround,
Intrinsic::experimental_constrained_llround));
case Builtin::BIlrint:
case Builtin::BIlrintf:
case Builtin::BIlrintl:
case Builtin::BI__builtin_lrint:
case Builtin::BI__builtin_lrintf:
case Builtin::BI__builtin_lrintl:
case Builtin::BI__builtin_lrintf128:
return RValue::get(emitMaybeConstrainedFPToIntRoundBuiltin(
*this, E, Intrinsic::lrint,
Intrinsic::experimental_constrained_lrint));
case Builtin::BIllrint:
case Builtin::BIllrintf:
case Builtin::BIllrintl:
case Builtin::BI__builtin_llrint:
case Builtin::BI__builtin_llrintf:
case Builtin::BI__builtin_llrintl:
case Builtin::BI__builtin_llrintf128:
return RValue::get(emitMaybeConstrainedFPToIntRoundBuiltin(
*this, E, Intrinsic::llrint,
Intrinsic::experimental_constrained_llrint));
default:
break;
}
}
switch (BuiltinIDIfNoAsmLabel) {
default: break;
case Builtin::BI__builtin___CFStringMakeConstantString:
case Builtin::BI__builtin___NSStringMakeConstantString:
return RValue::get(ConstantEmitter(*this).emitAbstract(E, E->getType()));
case Builtin::BI__builtin_stdarg_start:
case Builtin::BI__builtin_va_start:
case Builtin::BI__va_start:
case Builtin::BI__builtin_va_end:
return RValue::get(
EmitVAStartEnd(BuiltinID == Builtin::BI__va_start
? EmitScalarExpr(E->getArg(0))
: EmitVAListRef(E->getArg(0)).getPointer(),
BuiltinID != Builtin::BI__builtin_va_end));
case Builtin::BI__builtin_va_copy: {
Value *DstPtr = EmitVAListRef(E->getArg(0)).getPointer();
Value *SrcPtr = EmitVAListRef(E->getArg(1)).getPointer();
llvm::Type *Type = Int8PtrTy;
DstPtr = Builder.CreateBitCast(DstPtr, Type);
SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
return RValue::get(Builder.CreateCall(CGM.getIntrinsic(Intrinsic::vacopy),
{DstPtr, SrcPtr}));
}
case Builtin::BI__builtin_abs:
case Builtin::BI__builtin_labs:
case Builtin::BI__builtin_llabs: {
// X < 0 ? -X : X
// The negation has 'nsw' because abs of INT_MIN is undefined.
Value *ArgValue = EmitScalarExpr(E->getArg(0));
Value *NegOp = Builder.CreateNSWNeg(ArgValue, "neg");
Constant *Zero = llvm::Constant::getNullValue(ArgValue->getType());
Value *CmpResult = Builder.CreateICmpSLT(ArgValue, Zero, "abscond");
Value *Result = Builder.CreateSelect(CmpResult, NegOp, ArgValue, "abs");
return RValue::get(Result);
}
case Builtin::BI__builtin_complex: {
Value *Real = EmitScalarExpr(E->getArg(0));
Value *Imag = EmitScalarExpr(E->getArg(1));
return RValue::getComplex({Real, Imag});
}
case Builtin::BI__builtin_conj:
case Builtin::BI__builtin_conjf:
case Builtin::BI__builtin_conjl:
case Builtin::BIconj:
case Builtin::BIconjf:
case Builtin::BIconjl: {
ComplexPairTy ComplexVal = EmitComplexExpr(E->getArg(0));
Value *Real = ComplexVal.first;
Value *Imag = ComplexVal.second;
Imag = Builder.CreateFNeg(Imag, "neg");
return RValue::getComplex(std::make_pair(Real, Imag));
}
case Builtin::BI__builtin_creal:
case Builtin::BI__builtin_crealf:
case Builtin::BI__builtin_creall:
case Builtin::BIcreal:
case Builtin::BIcrealf:
case Builtin::BIcreall: {
ComplexPairTy ComplexVal = EmitComplexExpr(E->getArg(0));
return RValue::get(ComplexVal.first);
}
case Builtin::BI__builtin_dump_struct: {
llvm::Type *LLVMIntTy = getTypes().ConvertType(getContext().IntTy);
llvm::FunctionType *LLVMFuncType = llvm::FunctionType::get(
LLVMIntTy, {llvm::Type::getInt8PtrTy(getLLVMContext())}, true);
Value *Func = EmitScalarExpr(E->getArg(1)->IgnoreImpCasts());
CharUnits Arg0Align = EmitPointerWithAlignment(E->getArg(0)).getAlignment();
const Expr *Arg0 = E->getArg(0)->IgnoreImpCasts();
QualType Arg0Type = Arg0->getType()->getPointeeType();
Value *RecordPtr = EmitScalarExpr(Arg0);
Value *Res = dumpRecord(*this, Arg0Type, RecordPtr, Arg0Align,
{LLVMFuncType, Func}, 0);
return RValue::get(Res);
}
case Builtin::BI__builtin_preserve_access_index: {
// Only enabled preserved access index region when debuginfo
// is available as debuginfo is needed to preserve user-level
// access pattern.
if (!getDebugInfo()) {
CGM.Error(E->getExprLoc(), "using builtin_preserve_access_index() without -g");
return RValue::get(EmitScalarExpr(E->getArg(0)));
}
// Nested builtin_preserve_access_index() not supported
if (IsInPreservedAIRegion) {
CGM.Error(E->getExprLoc(), "nested builtin_preserve_access_index() not supported");
return RValue::get(EmitScalarExpr(E->getArg(0)));
}
IsInPreservedAIRegion = true;
Value *Res = EmitScalarExpr(E->getArg(0));
IsInPreservedAIRegion = false;
return RValue::get(Res);
}
case Builtin::BI__builtin_cimag:
case Builtin::BI__builtin_cimagf:
case Builtin::BI__builtin_cimagl:
case Builtin::BIcimag:
case Builtin::BIcimagf:
case Builtin::BIcimagl: {
ComplexPairTy ComplexVal = EmitComplexExpr(E->getArg(0));
return RValue::get(ComplexVal.second);
}
case Builtin::BI__builtin_clrsb:
case Builtin::BI__builtin_clrsbl:
case Builtin::BI__builtin_clrsbll: {
// clrsb(x) -> clz(x < 0 ? ~x : x) - 1 or
Value *ArgValue = EmitScalarExpr(E->getArg(0));
llvm::Type *ArgType = ArgValue->getType();
Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ArgType);
llvm::Type *ResultType = ConvertType(E->getType());
Value *Zero = llvm::Constant::getNullValue(ArgType);
Value *IsNeg = Builder.CreateICmpSLT(ArgValue, Zero, "isneg");
Value *Inverse = Builder.CreateNot(ArgValue, "not");
Value *Tmp = Builder.CreateSelect(IsNeg, Inverse, ArgValue);
Value *Ctlz = Builder.CreateCall(F, {Tmp, Builder.getFalse()});
Value *Result = Builder.CreateSub(Ctlz, llvm::ConstantInt::get(ArgType, 1));
Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
"cast");
return RValue::get(Result);
}
case Builtin::BI__builtin_ctzs:
case Builtin::BI__builtin_ctz:
case Builtin::BI__builtin_ctzl:
case Builtin::BI__builtin_ctzll: {
Value *ArgValue = EmitCheckedArgForBuiltin(E->getArg(0), BCK_CTZPassedZero);
llvm::Type *ArgType = ArgValue->getType();
Function *F = CGM.getIntrinsic(Intrinsic::cttz, ArgType);
llvm::Type *ResultType = ConvertType(E->getType());
Value *ZeroUndef = Builder.getInt1(getTarget().isCLZForZeroUndef());
Value *Result = Builder.CreateCall(F, {ArgValue, ZeroUndef});
if (Result->getType() != ResultType)
Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
"cast");
return RValue::get(Result);
}
case Builtin::BI__builtin_clzs:
case Builtin::BI__builtin_clz:
case Builtin::BI__builtin_clzl:
case Builtin::BI__builtin_clzll: {
Value *ArgValue = EmitCheckedArgForBuiltin(E->getArg(0), BCK_CLZPassedZero);
llvm::Type *ArgType = ArgValue->getType();
Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ArgType);
llvm::Type *ResultType = ConvertType(E->getType());
Value *ZeroUndef = Builder.getInt1(getTarget().isCLZForZeroUndef());
Value *Result = Builder.CreateCall(F, {ArgValue, ZeroUndef});
if (Result->getType() != ResultType)
Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
"cast");
return RValue::get(Result);
}
case Builtin::BI__builtin_ffs:
case Builtin::BI__builtin_ffsl:
case Builtin::BI__builtin_ffsll: {
// ffs(x) -> x ? cttz(x) + 1 : 0
Value *ArgValue = EmitScalarExpr(E->getArg(0));
llvm::Type *ArgType = ArgValue->getType();
Function *F = CGM.getIntrinsic(Intrinsic::cttz, ArgType);
llvm::Type *ResultType = ConvertType(E->getType());
Value *Tmp =
Builder.CreateAdd(Builder.CreateCall(F, {ArgValue, Builder.getTrue()}),
llvm::ConstantInt::get(ArgType, 1));
Value *Zero = llvm::Constant::getNullValue(ArgType);
Value *IsZero = Builder.CreateICmpEQ(ArgValue, Zero, "iszero");
Value *Result = Builder.CreateSelect(IsZero, Zero, Tmp, "ffs");
if (Result->getType() != ResultType)
Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
"cast");
return RValue::get(Result);
}
case Builtin::BI__builtin_parity:
case Builtin::BI__builtin_parityl:
case Builtin::BI__builtin_parityll: {
// parity(x) -> ctpop(x) & 1
Value *ArgValue = EmitScalarExpr(E->getArg(0));
llvm::Type *ArgType = ArgValue->getType();
Function *F = CGM.getIntrinsic(Intrinsic::ctpop, ArgType);
llvm::Type *ResultType = ConvertType(E->getType());
Value *Tmp = Builder.CreateCall(F, ArgValue);
Value *Result = Builder.CreateAnd(Tmp, llvm::ConstantInt::get(ArgType, 1));
if (Result->getType() != ResultType)
Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
"cast");
return RValue::get(Result);
}
case Builtin::BI__lzcnt16:
case Builtin::BI__lzcnt:
case Builtin::BI__lzcnt64: {
Value *ArgValue = EmitScalarExpr(E->getArg(0));
llvm::Type *ArgType = ArgValue->getType();
Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ArgType);
llvm::Type *ResultType = ConvertType(E->getType());
Value *Result = Builder.CreateCall(F, {ArgValue, Builder.getFalse()});
if (Result->getType() != ResultType)
Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
"cast");
return RValue::get(Result);
}
case Builtin::BI__popcnt16:
case Builtin::BI__popcnt:
case Builtin::BI__popcnt64:
case Builtin::BI__builtin_popcount:
case Builtin::BI__builtin_popcountl:
case Builtin::BI__builtin_popcountll: {
Value *ArgValue = EmitScalarExpr(E->getArg(0));
llvm::Type *ArgType = ArgValue->getType();
Function *F = CGM.getIntrinsic(Intrinsic::ctpop, ArgType);
llvm::Type *ResultType = ConvertType(E->getType());
Value *Result = Builder.CreateCall(F, ArgValue);
if (Result->getType() != ResultType)
Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
"cast");
return RValue::get(Result);
}
case Builtin::BI__builtin_unpredictable: {
// Always return the argument of __builtin_unpredictable. LLVM does not
// handle this builtin. Metadata for this builtin should be added directly
// to instructions such as branches or switches that use it.
return RValue::get(EmitScalarExpr(E->getArg(0)));
}
case Builtin::BI__builtin_expect: {
Value *ArgValue = EmitScalarExpr(E->getArg(0));
llvm::Type *ArgType = ArgValue->getType();
Value *ExpectedValue = EmitScalarExpr(E->getArg(1));
// Don't generate llvm.expect on -O0 as the backend won't use it for
// anything.
// Note, we still IRGen ExpectedValue because it could have side-effects.
if (CGM.getCodeGenOpts().OptimizationLevel == 0)
return RValue::get(ArgValue);
Function *FnExpect = CGM.getIntrinsic(Intrinsic::expect, ArgType);
Value *Result =
Builder.CreateCall(FnExpect, {ArgValue, ExpectedValue}, "expval");
return RValue::get(Result);
}
case Builtin::BI__builtin_expect_with_probability: {
Value *ArgValue = EmitScalarExpr(E->getArg(0));
llvm::Type *ArgType = ArgValue->getType();
Value *ExpectedValue = EmitScalarExpr(E->getArg(1));
llvm::APFloat Probability(0.0);
const Expr *ProbArg = E->getArg(2);
bool EvalSucceed = ProbArg->EvaluateAsFloat(Probability, CGM.getContext());
assert(EvalSucceed && "probability should be able to evaluate as float");
(void)EvalSucceed;
bool LoseInfo = false;
Probability.convert(llvm::APFloat::IEEEdouble(),
llvm::RoundingMode::Dynamic, &LoseInfo);
llvm::Type *Ty = ConvertType(ProbArg->getType());
Constant *Confidence = ConstantFP::get(Ty, Probability);
// Don't generate llvm.expect.with.probability on -O0 as the backend
// won't use it for anything.
// Note, we still IRGen ExpectedValue because it could have side-effects.
if (CGM.getCodeGenOpts().OptimizationLevel == 0)
return RValue::get(ArgValue);
Function *FnExpect =
CGM.getIntrinsic(Intrinsic::expect_with_probability, ArgType);
Value *Result = Builder.CreateCall(
FnExpect, {ArgValue, ExpectedValue, Confidence}, "expval");
return RValue::get(Result);
}
case Builtin::BI__builtin_assume_aligned: {
const Expr *Ptr = E->getArg(0);
Value *PtrValue = EmitScalarExpr(Ptr);
Value *OffsetValue =
(E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) : nullptr;
Value *AlignmentValue = EmitScalarExpr(E->getArg(1));
ConstantInt *AlignmentCI = cast<ConstantInt>(AlignmentValue);
if (AlignmentCI->getValue().ugt(llvm::Value::MaximumAlignment))
AlignmentCI = ConstantInt::get(AlignmentCI->getType(),
llvm::Value::MaximumAlignment);
emitAlignmentAssumption(PtrValue, Ptr,
/*The expr loc is sufficient.*/ SourceLocation(),
AlignmentCI, OffsetValue);
return RValue::get(PtrValue);
}
case Builtin::BI__assume:
case Builtin::BI__builtin_assume: {
if (E->getArg(0)->HasSideEffects(getContext()))
return RValue::get(nullptr);
Value *ArgValue = EmitScalarExpr(E->getArg(0));
Function *FnAssume = CGM.getIntrinsic(Intrinsic::assume);
return RValue::get(Builder.CreateCall(FnAssume, ArgValue));
}
case Builtin::BI__builtin_bswap16:
case Builtin::BI__builtin_bswap32:
case Builtin::BI__builtin_bswap64: {
return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::bswap));
}
case Builtin::BI__builtin_bitreverse8:
case Builtin::BI__builtin_bitreverse16:
case Builtin::BI__builtin_bitreverse32:
case Builtin::BI__builtin_bitreverse64: {
return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::bitreverse));
}
case Builtin::BI__builtin_rotateleft8:
case Builtin::BI__builtin_rotateleft16:
case Builtin::BI__builtin_rotateleft32:
case Builtin::BI__builtin_rotateleft64:
case Builtin::BI_rotl8: // Microsoft variants of rotate left
case Builtin::BI_rotl16:
case Builtin::BI_rotl:
case Builtin::BI_lrotl:
case Builtin::BI_rotl64:
return emitRotate(E, false);
case Builtin::BI__builtin_rotateright8:
case Builtin::BI__builtin_rotateright16:
case Builtin::BI__builtin_rotateright32:
case Builtin::BI__builtin_rotateright64:
case Builtin::BI_rotr8: // Microsoft variants of rotate right
case Builtin::BI_rotr16:
case Builtin::BI_rotr:
case Builtin::BI_lrotr:
case Builtin::BI_rotr64:
return emitRotate(E, true);
case Builtin::BI__builtin_constant_p: {
llvm::Type *ResultType = ConvertType(E->getType());
const Expr *Arg = E->getArg(0);
QualType ArgType = Arg->getType();
// FIXME: The allowance for Obj-C pointers and block pointers is historical
// and likely a mistake.
if (!ArgType->isIntegralOrEnumerationType() && !ArgType->isFloatingType() &&
!ArgType->isObjCObjectPointerType() && !ArgType->isBlockPointerType())
// Per the GCC documentation, only numeric constants are recognized after
// inlining.
return RValue::get(ConstantInt::get(ResultType, 0));
if (Arg->HasSideEffects(getContext()))
// The argument is unevaluated, so be conservative if it might have
// side-effects.
return RValue::get(ConstantInt::get(ResultType, 0));
Value *ArgValue = EmitScalarExpr(Arg);
if (ArgType->isObjCObjectPointerType()) {
// Convert Objective-C objects to id because we cannot distinguish between
// LLVM types for Obj-C classes as they are opaque.
ArgType = CGM.getContext().getObjCIdType();
ArgValue = Builder.CreateBitCast(ArgValue, ConvertType(ArgType));
}
Function *F =
CGM.getIntrinsic(Intrinsic::is_constant, ConvertType(ArgType));
Value *Result = Builder.CreateCall(F, ArgValue);
if (Result->getType() != ResultType)
Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/false);
return RValue::get(Result);
}
case Builtin::BI__builtin_dynamic_object_size:
case Builtin::BI__builtin_object_size: {
unsigned Type =
E->getArg(1)->EvaluateKnownConstInt(getContext()).getZExtValue();
auto *ResType = cast<llvm::IntegerType>(ConvertType(E->getType()));
// We pass this builtin onto the optimizer so that it can figure out the
// object size in more complex cases.
bool IsDynamic = BuiltinID == Builtin::BI__builtin_dynamic_object_size;
return RValue::get(emitBuiltinObjectSize(E->getArg(0), Type, ResType,
/*EmittedE=*/nullptr, IsDynamic));
}
case Builtin::BI__builtin_prefetch: {
Value *Locality, *RW, *Address = EmitScalarExpr(E->getArg(0));
// FIXME: Technically these constants should of type 'int', yes?
RW = (E->getNumArgs() > 1) ? EmitScalarExpr(E->getArg(1)) :
llvm::ConstantInt::get(Int32Ty, 0);
Locality = (E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) :
llvm::ConstantInt::get(Int32Ty, 3);
Value *Data = llvm::ConstantInt::get(Int32Ty, 1);
Function *F = CGM.getIntrinsic(Intrinsic::prefetch, Address->getType());
return RValue::get(Builder.CreateCall(F, {Address, RW, Locality, Data}));
}
case Builtin::BI__builtin_readcyclecounter: {
Function *F = CGM.getIntrinsic(Intrinsic::readcyclecounter);
return RValue::get(Builder.CreateCall(F));
}
case Builtin::BI__builtin___clear_cache: {
Value *Begin = EmitScalarExpr(E->getArg(0));
Value *End = EmitScalarExpr(E->getArg(1));
Function *F = CGM.getIntrinsic(Intrinsic::clear_cache);
return RValue::get(Builder.CreateCall(F, {Begin, End}));
}
case Builtin::BI__builtin_trap:
return RValue::get(EmitTrapCall(Intrinsic::trap));
case Builtin::BI__debugbreak:
return RValue::get(EmitTrapCall(Intrinsic::debugtrap));
case Builtin::BI__builtin_unreachable: {
EmitUnreachable(E->getExprLoc());
// We do need to preserve an insertion point.
EmitBlock(createBasicBlock("unreachable.cont"));
return RValue::get(nullptr);
}
case Builtin::BI__builtin_powi:
case Builtin::BI__builtin_powif:
case Builtin::BI__builtin_powil:
return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(
*this, E, Intrinsic::powi, Intrinsic::experimental_constrained_powi));
case Builtin::BI__builtin_isgreater:
case Builtin::BI__builtin_isgreaterequal:
case Builtin::BI__builtin_isless:
case Builtin::BI__builtin_islessequal:
case Builtin::BI__builtin_islessgreater:
case Builtin::BI__builtin_isunordered: {
// Ordered comparisons: we know the arguments to these are matching scalar
// floating point values.
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(*this, E);
// FIXME: for strictfp/IEEE-754 we need to not trap on SNaN here.
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
switch (BuiltinID) {
default: llvm_unreachable("Unknown ordered comparison");
case Builtin::BI__builtin_isgreater:
LHS = Builder.CreateFCmpOGT(LHS, RHS, "cmp");
break;
case Builtin::BI__builtin_isgreaterequal:
LHS = Builder.CreateFCmpOGE(LHS, RHS, "cmp");
break;
case Builtin::BI__builtin_isless:
LHS = Builder.CreateFCmpOLT(LHS, RHS, "cmp");
break;
case Builtin::BI__builtin_islessequal:
LHS = Builder.CreateFCmpOLE(LHS, RHS, "cmp");
break;
case Builtin::BI__builtin_islessgreater:
LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
break;
case Builtin::BI__builtin_isunordered:
LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
break;
}
// ZExt bool to int type.
return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType())));
}
case Builtin::BI__builtin_isnan: {
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(*this, E);
// FIXME: for strictfp/IEEE-754 we need to not trap on SNaN here.
Value *V = EmitScalarExpr(E->getArg(0));
V = Builder.CreateFCmpUNO(V, V, "cmp");
return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
}
case Builtin::BI__builtin_matrix_transpose: {
const auto *MatrixTy = E->getArg(0)->getType()->getAs<ConstantMatrixType>();
Value *MatValue = EmitScalarExpr(E->getArg(0));
MatrixBuilder<CGBuilderTy> MB(Builder);
Value *Result = MB.CreateMatrixTranspose(MatValue, MatrixTy->getNumRows(),
MatrixTy->getNumColumns());
return RValue::get(Result);
}
case Builtin::BI__builtin_matrix_column_major_load: {
MatrixBuilder<CGBuilderTy> MB(Builder);
// Emit everything that isn't dependent on the first parameter type
Value *Stride = EmitScalarExpr(E->getArg(3));
const auto *ResultTy = E->getType()->getAs<ConstantMatrixType>();
auto *PtrTy = E->getArg(0)->getType()->getAs<PointerType>();
assert(PtrTy && "arg0 must be of pointer type");
bool IsVolatile = PtrTy->getPointeeType().isVolatileQualified();
Address Src = EmitPointerWithAlignment(E->getArg(0));
EmitNonNullArgCheck(RValue::get(Src.getPointer()), E->getArg(0)->getType(),
E->getArg(0)->getExprLoc(), FD, 0);
Value *Result = MB.CreateColumnMajorLoad(
Src.getPointer(), Align(Src.getAlignment().getQuantity()), Stride,
IsVolatile, ResultTy->getNumRows(), ResultTy->getNumColumns(),
"matrix");
return RValue::get(Result);
}
case Builtin::BI__builtin_matrix_column_major_store: {
MatrixBuilder<CGBuilderTy> MB(Builder);
Value *Matrix = EmitScalarExpr(E->getArg(0));
Address Dst = EmitPointerWithAlignment(E->getArg(1));
Value *Stride = EmitScalarExpr(E->getArg(2));
const auto *MatrixTy = E->getArg(0)->getType()->getAs<ConstantMatrixType>();
auto *PtrTy = E->getArg(1)->getType()->getAs<PointerType>();
assert(PtrTy && "arg1 must be of pointer type");
bool IsVolatile = PtrTy->getPointeeType().isVolatileQualified();
EmitNonNullArgCheck(RValue::get(Dst.getPointer()), E->getArg(1)->getType(),
E->getArg(1)->getExprLoc(), FD, 0);
Value *Result = MB.CreateColumnMajorStore(
Matrix, Dst.getPointer(), Align(Dst.getAlignment().getQuantity()),
Stride, IsVolatile, MatrixTy->getNumRows(), MatrixTy->getNumColumns());
return RValue::get(Result);
}
case Builtin::BIfinite:
case Builtin::BI__finite:
case Builtin::BIfinitef:
case Builtin::BI__finitef:
case Builtin::BIfinitel:
case Builtin::BI__finitel:
case Builtin::BI__builtin_isinf:
case Builtin::BI__builtin_isfinite: {
// isinf(x) --> fabs(x) == infinity
// isfinite(x) --> fabs(x) != infinity
// x != NaN via the ordered compare in either case.
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(*this, E);
// FIXME: for strictfp/IEEE-754 we need to not trap on SNaN here.
Value *V = EmitScalarExpr(E->getArg(0));
Value *Fabs = EmitFAbs(*this, V);
Constant *Infinity = ConstantFP::getInfinity(V->getType());
CmpInst::Predicate Pred = (BuiltinID == Builtin::BI__builtin_isinf)
? CmpInst::FCMP_OEQ
: CmpInst::FCMP_ONE;
Value *FCmp = Builder.CreateFCmp(Pred, Fabs, Infinity, "cmpinf");
return RValue::get(Builder.CreateZExt(FCmp, ConvertType(E->getType())));
}
case Builtin::BI__builtin_isinf_sign: {
// isinf_sign(x) -> fabs(x) == infinity ? (signbit(x) ? -1 : 1) : 0
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(*this, E);
// FIXME: for strictfp/IEEE-754 we need to not trap on SNaN here.
Value *Arg = EmitScalarExpr(E->getArg(0));
Value *AbsArg = EmitFAbs(*this, Arg);
Value *IsInf = Builder.CreateFCmpOEQ(
AbsArg, ConstantFP::getInfinity(Arg->getType()), "isinf");
Value *IsNeg = EmitSignBit(*this, Arg);
llvm::Type *IntTy = ConvertType(E->getType());
Value *Zero = Constant::getNullValue(IntTy);
Value *One = ConstantInt::get(IntTy, 1);
Value *NegativeOne = ConstantInt::get(IntTy, -1);
Value *SignResult = Builder.CreateSelect(IsNeg, NegativeOne, One);
Value *Result = Builder.CreateSelect(IsInf, SignResult, Zero);
return RValue::get(Result);
}
case Builtin::BI__builtin_isnormal: {
// isnormal(x) --> x == x && fabsf(x) < infinity && fabsf(x) >= float_min
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(*this, E);
// FIXME: for strictfp/IEEE-754 we need to not trap on SNaN here.
Value *V = EmitScalarExpr(E->getArg(0));
Value *Eq = Builder.CreateFCmpOEQ(V, V, "iseq");
Value *Abs = EmitFAbs(*this, V);
Value *IsLessThanInf =
Builder.CreateFCmpULT(Abs, ConstantFP::getInfinity(V->getType()),"isinf");
APFloat Smallest = APFloat::getSmallestNormalized(
getContext().getFloatTypeSemantics(E->getArg(0)->getType()));
Value *IsNormal =
Builder.CreateFCmpUGE(Abs, ConstantFP::get(V->getContext(), Smallest),
"isnormal");
V = Builder.CreateAnd(Eq, IsLessThanInf, "and");
V = Builder.CreateAnd(V, IsNormal, "and");
return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType())));
}
case Builtin::BI__builtin_flt_rounds: {
Function *F = CGM.getIntrinsic(Intrinsic::flt_rounds);
llvm::Type *ResultType = ConvertType(E->getType());
Value *Result = Builder.CreateCall(F);
if (Result->getType() != ResultType)
Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
"cast");
return RValue::get(Result);
}
case Builtin::BI__builtin_fpclassify: {
CodeGenFunction::CGFPOptionsRAII FPOptsRAII(*this, E);
// FIXME: for strictfp/IEEE-754 we need to not trap on SNaN here.
Value *V = EmitScalarExpr(E->getArg(5));
llvm::Type *Ty = ConvertType(E->getArg(5)->getType());
// Create Result
BasicBlock *Begin = Builder.GetInsertBlock();
BasicBlock *End = createBasicBlock("fpclassify_end", this->CurFn);
Builder.SetInsertPoint(End);
PHINode *Result =
Builder.CreatePHI(ConvertType(E->getArg(0)->getType()), 4,
"fpclassify_result");
// if (V==0) return FP_ZERO
Builder.SetInsertPoint(Begin);
Value *IsZero = Builder.CreateFCmpOEQ(V, Constant::getNullValue(Ty),
"iszero");
Value *ZeroLiteral = EmitScalarExpr(E->getArg(4));
BasicBlock *NotZero = createBasicBlock("fpclassify_not_zero", this->CurFn);
Builder.CreateCondBr(IsZero, End, NotZero);
Result->addIncoming(ZeroLiteral, Begin);
// if (V != V) return FP_NAN
Builder.SetInsertPoint(NotZero);
Value *IsNan = Builder.CreateFCmpUNO(V, V, "cmp");
Value *NanLiteral = EmitScalarExpr(E->getArg(0));
BasicBlock *NotNan = createBasicBlock("fpclassify_not_nan", this->CurFn);
Builder.CreateCondBr(IsNan, End, NotNan);
Result->addIncoming(NanLiteral, NotZero);
// if (fabs(V) == infinity) return FP_INFINITY
Builder.SetInsertPoint(NotNan);
Value *VAbs = EmitFAbs(*this, V);
Value *IsInf =
Builder.CreateFCmpOEQ(VAbs, ConstantFP::getInfinity(V->getType()),
"isinf");
Value *InfLiteral = EmitScalarExpr(E->getArg(1));
BasicBlock *NotInf = createBasicBlock("fpclassify_not_inf", this->CurFn);
Builder.CreateCondBr(IsInf, End, NotInf);
Result->addIncoming(InfLiteral, NotNan);
// if (fabs(V) >= MIN_NORMAL) return FP_NORMAL else FP_SUBNORMAL
Builder.SetInsertPoint(NotInf);
APFloat Smallest = APFloat::getSmallestNormalized(
getContext().getFloatTypeSemantics(E->getArg(5)->getType()));
Value *IsNormal =
Builder.CreateFCmpUGE(VAbs, ConstantFP::get(V->getContext(), Smallest),
"isnormal");
Value *NormalResult =
Builder.CreateSelect(IsNormal, EmitScalarExpr(E->getArg(2)),
EmitScalarExpr(E->getArg(3)));
Builder.CreateBr(End);
Result->addIncoming(NormalResult, NotInf);
// return Result
Builder.SetInsertPoint(End);
return RValue::get(Result);
}
case Builtin::BIalloca:
case Builtin::BI_alloca:
case Builtin::BI__builtin_alloca: {
Value *Size = EmitScalarExpr(E->getArg(0));
const TargetInfo &TI = getContext().getTargetInfo();
// The alignment of the alloca should correspond to __BIGGEST_ALIGNMENT__.
const Align SuitableAlignmentInBytes =
CGM.getContext()
.toCharUnitsFromBits(TI.getSuitableAlign())
.getAsAlign();
AllocaInst *AI = Builder.CreateAlloca(Builder.getInt8Ty(), Size);
AI->setAlignment(SuitableAlignmentInBytes);
initializeAlloca(*this, AI, Size, SuitableAlignmentInBytes);
return RValue::get(AI);
}
case Builtin::BI__builtin_alloca_with_align: {
Value *Size = EmitScalarExpr(E->getArg(0));
Value *AlignmentInBitsValue = EmitScalarExpr(E->getArg(1));
auto *AlignmentInBitsCI = cast<ConstantInt>(AlignmentInBitsValue);
unsigned AlignmentInBits = AlignmentInBitsCI->getZExtValue();
const Align AlignmentInBytes =
CGM.getContext().toCharUnitsFromBits(AlignmentInBits).getAsAlign();
AllocaInst *AI = Builder.CreateAlloca(Builder.getInt8Ty(), Size);
AI->setAlignment(AlignmentInBytes);
initializeAlloca(*this, AI, Size, AlignmentInBytes);
return RValue::get(AI);
}
case Builtin::BIbzero:
case Builtin::BI__builtin_bzero: {
Address Dest = EmitPointerWithAlignment(E->getArg(0));
Value *SizeVal = EmitScalarExpr(E->getArg(1));
EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
E->getArg(0)->getExprLoc(), FD, 0);
Builder.CreateMemSet(Dest, Builder.getInt8(0), SizeVal, false);
return RValue::get(nullptr);
}
case Builtin::BImemcpy:
case Builtin::BI__builtin_memcpy:
case Builtin::BImempcpy:
case Builtin::BI__builtin_mempcpy: {
Address Dest = EmitPointerWithAlignment(E->getArg(0));
Address Src = EmitPointerWithAlignment(E->getArg(1));
Value *SizeVal = EmitScalarExpr(E->getArg(2));
EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
E->getArg(0)->getExprLoc(), FD, 0);
EmitNonNullArgCheck(RValue::get(Src.getPointer()), E->getArg(1)->getType(),
E->getArg(1)->getExprLoc(), FD, 1);
Builder.CreateMemCpy(Dest, Src, SizeVal, false);
if (BuiltinID == Builtin::BImempcpy ||
BuiltinID == Builtin::BI__builtin_mempcpy)
return RValue::get(Builder.CreateInBoundsGEP(Dest.getPointer(), SizeVal));
else
return RValue::get(Dest.getPointer());
}
case Builtin::BI__builtin_memcpy_inline: {
Address Dest = EmitPointerWithAlignment(E->getArg(0));
Address Src = EmitPointerWithAlignment(E->getArg(1));
uint64_t Size =
E->getArg(2)->EvaluateKnownConstInt(getContext()).getZExtValue();
EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
E->getArg(0)->getExprLoc(), FD, 0);
EmitNonNullArgCheck(RValue::get(Src.getPointer()), E->getArg(1)->getType(),
E->getArg(1)->getExprLoc(), FD, 1);
Builder.CreateMemCpyInline(Dest, Src, Size);
return RValue::get(nullptr);
}
case Builtin::BI__builtin_char_memchr:
BuiltinID = Builtin::BI__builtin_memchr;
break;
case Builtin::BI__builtin___memcpy_chk: {
// fold __builtin_memcpy_chk(x, y, cst1, cst2) to memcpy iff cst1<=cst2.
Expr::EvalResult SizeResult, DstSizeResult;
if (!E->getArg(2)->EvaluateAsInt(SizeResult, CGM.getContext()) ||
!E->getArg(3)->EvaluateAsInt(DstSizeResult, CGM.getContext()))
break;
llvm::APSInt Size = SizeResult.Val.getInt();
llvm::APSInt DstSize = DstSizeResult.Val.getInt();
if (Size.ugt(DstSize))
break;
Address Dest = EmitPointerWithAlignment(E->getArg(0));
Address Src = EmitPointerWithAlignment(E->getArg(1));
Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
Builder.CreateMemCpy(Dest, Src, SizeVal, false);
return RValue::get(Dest.getPointer());
}
case Builtin::BI__builtin_objc_memmove_collectable: {
Address DestAddr = EmitPointerWithAlignment(E->getArg(0));
Address SrcAddr = EmitPointerWithAlignment(E->getArg(1));
Value *SizeVal = EmitScalarExpr(E->getArg(2));
CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this,
DestAddr, SrcAddr, SizeVal);
return RValue::get(DestAddr.getPointer());
}
case Builtin::BI__builtin___memmove_chk: {
// fold __builtin_memmove_chk(x, y, cst1, cst2) to memmove iff cst1<=cst2.
Expr::EvalResult SizeResult, DstSizeResult;
if (!E->getArg(2)->EvaluateAsInt(SizeResult, CGM.getContext()) ||
!E->getArg(3)->EvaluateAsInt(DstSizeResult, CGM.getContext()))
break;
llvm::APSInt Size = SizeResult.Val.getInt();
llvm::APSInt DstSize = DstSizeResult.Val.getInt();
if (Size.ugt(DstSize))
break;
Address Dest = EmitPointerWithAlignment(E->getArg(0));
Address Src = EmitPointerWithAlignment(E->getArg(1));
Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
Builder.CreateMemMove(Dest, Src, SizeVal, false);
return RValue::get(Dest.getPointer());
}
case Builtin::BImemmove:
case Builtin::BI__builtin_memmove: {
Address Dest = EmitPointerWithAlignment(E->getArg(0));
Address Src = EmitPointerWithAlignment(E->getArg(1));
Value *SizeVal = EmitScalarExpr(E->getArg(2));
EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
E->getArg(0)->getExprLoc(), FD, 0);
EmitNonNullArgCheck(RValue::get(Src.getPointer()), E->getArg(1)->getType(),
E->getArg(1)->getExprLoc(), FD, 1);
Builder.CreateMemMove(Dest, Src, SizeVal, false);
return RValue::get(Dest.getPointer());
}
case Builtin::BImemset:
case Builtin::BI__builtin_memset: {
Address Dest = EmitPointerWithAlignment(E->getArg(0));
Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
Builder.getInt8Ty());
Value *SizeVal = EmitScalarExpr(E->getArg(2));
EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
E->getArg(0)->getExprLoc(), FD, 0);
Builder.CreateMemSet(Dest, ByteVal, SizeVal, false);
return RValue::get(Dest.getPointer());
}
case Builtin::BI__builtin___memset_chk: {
// fold __builtin_memset_chk(x, y, cst1, cst2) to memset iff cst1<=cst2.
Expr::EvalResult SizeResult, DstSizeResult;
if (!E->getArg(2)->EvaluateAsInt(SizeResult, CGM.getContext()) ||
!E->getArg(3)->EvaluateAsInt(DstSizeResult, CGM.getContext()))
break;
llvm::APSInt Size = SizeResult.Val.getInt();
llvm::APSInt DstSize = DstSizeResult.Val.getInt();
if (Size.ugt(DstSize))
break;
Address Dest = EmitPointerWithAlignment(E->getArg(0));
Value *ByteVal = Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
Builder.getInt8Ty());
Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
Builder.CreateMemSet(Dest, ByteVal, SizeVal, false);
return RValue::get(Dest.getPointer());
}
case Builtin::BI__builtin_wmemcmp: {
// The MSVC runtime library does not provide a definition of wmemcmp, so we
// need an inline implementation.
if (!getTarget().getTriple().isOSMSVCRT())
break;
llvm::Type *WCharTy = ConvertType(getContext().WCharTy);
Value *Dst = EmitScalarExpr(E->getArg(0));
Value *Src = EmitScalarExpr(E->getArg(1));
Value *Size = EmitScalarExpr(E->getArg(2));
BasicBlock *Entry = Builder.GetInsertBlock();
BasicBlock *CmpGT = createBasicBlock("wmemcmp.gt");
BasicBlock *CmpLT = createBasicBlock("wmemcmp.lt");
BasicBlock *Next = createBasicBlock("wmemcmp.next");
BasicBlock *Exit = createBasicBlock("wmemcmp.exit");
Value *SizeEq0 = Builder.CreateICmpEQ(Size, ConstantInt::get(SizeTy, 0));
Builder.CreateCondBr(SizeEq0, Exit, CmpGT);
EmitBlock(CmpGT);
PHINode *DstPhi = Builder.CreatePHI(Dst->getType(), 2);
DstPhi->addIncoming(Dst, Entry);
PHINode *SrcPhi = Builder.CreatePHI(Src->getType(), 2);
SrcPhi->addIncoming(Src, Entry);
PHINode *SizePhi = Builder.CreatePHI(SizeTy, 2);
SizePhi->addIncoming(Size, Entry);
CharUnits WCharAlign =
getContext().getTypeAlignInChars(getContext().WCharTy);
Value *DstCh = Builder.CreateAlignedLoad(WCharTy, DstPhi, WCharAlign);
Value *SrcCh = Builder.CreateAlignedLoad(WCharTy, SrcPhi, WCharAlign);
Value *DstGtSrc = Builder.CreateICmpUGT(DstCh, SrcCh);
Builder.CreateCondBr(DstGtSrc, Exit, CmpLT);
EmitBlock(CmpLT);
Value *DstLtSrc = Builder.CreateICmpULT(DstCh, SrcCh);
Builder.CreateCondBr(DstLtSrc, Exit, Next);
EmitBlock(Next);
Value *NextDst = Builder.CreateConstInBoundsGEP1_32(WCharTy, DstPhi, 1);
Value *NextSrc = Builder.CreateConstInBoundsGEP1_32(WCharTy, SrcPhi, 1);
Value *NextSize = Builder.CreateSub(SizePhi, ConstantInt::get(SizeTy, 1));
Value *NextSizeEq0 =
Builder.CreateICmpEQ(NextSize, ConstantInt::get(SizeTy, 0));
Builder.CreateCondBr(NextSizeEq0, Exit, CmpGT);
DstPhi->addIncoming(NextDst, Next);
SrcPhi->addIncoming(NextSrc, Next);
SizePhi->addIncoming(NextSize, Next);
EmitBlock(Exit);
PHINode *Ret = Builder.CreatePHI(IntTy, 4);
Ret->addIncoming(ConstantInt::get(IntTy, 0), Entry);
Ret->addIncoming(ConstantInt::get(IntTy, 1), CmpGT);
Ret->addIncoming(ConstantInt::get(IntTy, -1), CmpLT);
Ret->addIncoming(ConstantInt::get(IntTy, 0), Next);
return RValue::get(Ret);
}
case Builtin::BI__builtin_dwarf_cfa: {
// The offset in bytes from the first argument to the CFA.
//
// Why on earth is this in the frontend? Is there any reason at
// all that the backend can't reasonably determine this while
// lowering llvm.eh.dwarf.cfa()?
//
// TODO: If there's a satisfactory reason, add a target hook for
// this instead of hard-coding 0, which is correct for most targets.
int32_t Offset = 0;
Function *F = CGM.getIntrinsic(Intrinsic::eh_dwarf_cfa);
return RValue::get(Builder.CreateCall(F,
llvm::ConstantInt::get(Int32Ty, Offset)));
}
case Builtin::BI__builtin_return_address: {
Value *Depth = ConstantEmitter(*this).emitAbstract(E->getArg(0),
getContext().UnsignedIntTy);
Function *F = CGM.getIntrinsic(Intrinsic::returnaddress);
return RValue::get(Builder.CreateCall(F, Depth));
}
case Builtin::BI_ReturnAddress: {
Function *F = CGM.getIntrinsic(Intrinsic::returnaddress);
return RValue::get(Builder.CreateCall(F, Builder.getInt32(0)));
}
case Builtin::BI__builtin_frame_address: {
Value *Depth = ConstantEmitter(*this).emitAbstract(E->getArg(0),
getContext().UnsignedIntTy);
Function *F = CGM.getIntrinsic(Intrinsic::frameaddress, AllocaInt8PtrTy);
return RValue::get(Builder.CreateCall(F, Depth));
}
case Builtin::BI__builtin_extract_return_addr: {
Value *Address = EmitScalarExpr(E->getArg(0));
Value *Result = getTargetHooks().decodeReturnAddress(*this, Address);
return RValue::get(Result);
}
case Builtin::BI__builtin_frob_return_addr: {
Value *Address = EmitScalarExpr(E->getArg(0));
Value *Result = getTargetHooks().encodeReturnAddress(*this, Address);
return RValue::get(Result);
}
case Builtin::BI__builtin_dwarf_sp_column: {
llvm::IntegerType *Ty
= cast<llvm::IntegerType>(ConvertType(E->getType()));
int Column = getTargetHooks().getDwarfEHStackPointer(CGM);
if (Column == -1) {
CGM.ErrorUnsupported(E, "__builtin_dwarf_sp_column");
return RValue::get(llvm::UndefValue::get(Ty));
}
return RValue::get(llvm::ConstantInt::get(Ty, Column, true));
}
case Builtin::BI__builtin_init_dwarf_reg_size_table: {
Value *Address = EmitScalarExpr(E->getArg(0));
if (getTargetHooks().initDwarfEHRegSizeTable(*this, Address))
CGM.ErrorUnsupported(E, "__builtin_init_dwarf_reg_size_table");
return RValue::get(llvm::UndefValue::get(ConvertType(E->getType())));
}
case Builtin::BI__builtin_eh_return: {
Value *Int = EmitScalarExpr(E->getArg(0));
Value *Ptr = EmitScalarExpr(E->getArg(1));
llvm::IntegerType *IntTy = cast<llvm::IntegerType>(Int->getType());
assert((IntTy->getBitWidth() == 32 || IntTy->getBitWidth() == 64) &&
"LLVM's __builtin_eh_return only supports 32- and 64-bit variants");
Function *F =
CGM.getIntrinsic(IntTy->getBitWidth() == 32 ? Intrinsic::eh_return_i32
: Intrinsic::eh_return_i64);
Builder.CreateCall(F, {Int, Ptr});
Builder.CreateUnreachable();
// We do need to preserve an insertion point.
EmitBlock(createBasicBlock("builtin_eh_return.cont"));
return RValue::get(nullptr);
}
case Builtin::BI__builtin_unwind_init: {
Function *F = CGM.getIntrinsic(Intrinsic::eh_unwind_init);
return RValue::get(Builder.CreateCall(F));
}
case Builtin::BI__builtin_extend_pointer: {
// Extends a pointer to the size of an _Unwind_Word, which is
// uint64_t on all platforms. Generally this gets poked into a
// register and eventually used as an address, so if the
// addressing registers are wider than pointers and the platform
// doesn't implicitly ignore high-order bits when doing
// addressing, we need to make sure we zext / sext based on
// the platform's expectations.
//
// See: http://gcc.gnu.org/ml/gcc-bugs/2002-02/msg00237.html
// Cast the pointer to intptr_t.
Value *Ptr = EmitScalarExpr(E->getArg(0));
Value *Result = Builder.CreatePtrToInt(Ptr, IntPtrTy, "extend.cast");
// If that's 64 bits, we're done.
if (IntPtrTy->getBitWidth() == 64)
return RValue::get(Result);
// Otherwise, ask the codegen data what to do.
if (getTargetHooks().extendPointerWithSExt())
return RValue::get(Builder.CreateSExt(Result, Int64Ty, "extend.sext"));
else
return RValue::get(Builder.CreateZExt(Result, Int64Ty, "extend.zext"));
}
case Builtin::BI__builtin_setjmp: {
// Buffer is a void**.
Address Buf = EmitPointerWithAlignment(E->getArg(0));
// Store the frame pointer to the setjmp buffer.
Value *FrameAddr = Builder.CreateCall(
CGM.getIntrinsic(Intrinsic::frameaddress, AllocaInt8PtrTy),
ConstantInt::get(Int32Ty, 0));
Builder.CreateStore(FrameAddr, Buf);
// Store the stack pointer to the setjmp buffer.
Value *StackAddr =
Builder.CreateCall(CGM.getIntrinsic(Intrinsic::stacksave));
Address StackSaveSlot = Builder.CreateConstInBoundsGEP(Buf, 2);
Builder.CreateStore(StackAddr, StackSaveSlot);
// Call LLVM's EH setjmp, which is lightweight.
Function *F = CGM.getIntrinsic(Intrinsic::eh_sjlj_setjmp);
Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
return RValue::get(Builder.CreateCall(F, Buf.getPointer()));
}
case Builtin::BI__builtin_longjmp: {
Value *Buf = EmitScalarExpr(E->getArg(0));
Buf = Builder.CreateBitCast(Buf, Int8PtrTy);
// Call LLVM's EH longjmp, which is lightweight.
Builder.CreateCall(CGM.getIntrinsic(Intrinsic::eh_sjlj_longjmp), Buf);
// longjmp doesn't return; mark this as unreachable.
Builder.CreateUnreachable();
// We do need to preserve an insertion point.
EmitBlock(createBasicBlock("longjmp.cont"));
return RValue::get(nullptr);
}
case Builtin::BI__builtin_launder: {
const Expr *Arg = E->getArg(0);
QualType ArgTy = Arg->getType()->getPointeeType();
Value *Ptr = EmitScalarExpr(Arg);
if (TypeRequiresBuiltinLaunder(CGM, ArgTy))
Ptr = Builder.CreateLaunderInvariantGroup(Ptr);
return RValue::get(Ptr);
}
case Builtin::BI__sync_fetch_and_add:
case Builtin::BI__sync_fetch_and_sub:
case Builtin::BI__sync_fetch_and_or:
case Builtin::BI__sync_fetch_and_and:
case Builtin::BI__sync_fetch_and_xor:
case Builtin::BI__sync_fetch_and_nand:
case Builtin::BI__sync_add_and_fetch:
case Builtin::BI__sync_sub_and_fetch:
case Builtin::BI__sync_and_and_fetch:
case Builtin::BI__sync_or_and_fetch:
case Builtin::BI__sync_xor_and_fetch:
case Builtin::BI__sync_nand_and_fetch:
case Builtin::BI__sync_val_compare_and_swap:
case Builtin::BI__sync_bool_compare_and_swap:
case Builtin::BI__sync_lock_test_and_set:
case Builtin::BI__sync_lock_release:
case Builtin::BI__sync_swap:
llvm_unreachable("Shouldn't make it through sema");
case Builtin::BI__sync_fetch_and_add_1:
case Builtin::BI__sync_fetch_and_add_2:
case Builtin::BI__sync_fetch_and_add_4:
case Builtin::BI__sync_fetch_and_add_8:
case Builtin::BI__sync_fetch_and_add_16:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::Add, E);
case Builtin::BI__sync_fetch_and_sub_1:
case Builtin::BI__sync_fetch_and_sub_2:
case Builtin::BI__sync_fetch_and_sub_4:
case Builtin::BI__sync_fetch_and_sub_8:
case Builtin::BI__sync_fetch_and_sub_16:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::Sub, E);
case Builtin::BI__sync_fetch_and_or_1:
case Builtin::BI__sync_fetch_and_or_2:
case Builtin::BI__sync_fetch_and_or_4:
case Builtin::BI__sync_fetch_and_or_8:
case Builtin::BI__sync_fetch_and_or_16:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::Or, E);
case Builtin::BI__sync_fetch_and_and_1:
case Builtin::BI__sync_fetch_and_and_2:
case Builtin::BI__sync_fetch_and_and_4:
case Builtin::BI__sync_fetch_and_and_8:
case Builtin::BI__sync_fetch_and_and_16:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::And, E);
case Builtin::BI__sync_fetch_and_xor_1:
case Builtin::BI__sync_fetch_and_xor_2:
case Builtin::BI__sync_fetch_and_xor_4:
case Builtin::BI__sync_fetch_and_xor_8:
case Builtin::BI__sync_fetch_and_xor_16:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::Xor, E);
case Builtin::BI__sync_fetch_and_nand_1:
case Builtin::BI__sync_fetch_and_nand_2:
case Builtin::BI__sync_fetch_and_nand_4:
case Builtin::BI__sync_fetch_and_nand_8:
case Builtin::BI__sync_fetch_and_nand_16:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::Nand, E);
// Clang extensions: not overloaded yet.
case Builtin::BI__sync_fetch_and_min:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::Min, E);
case Builtin::BI__sync_fetch_and_max:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::Max, E);
case Builtin::BI__sync_fetch_and_umin:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::UMin, E);
case Builtin::BI__sync_fetch_and_umax:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::UMax, E);
case Builtin::BI__sync_add_and_fetch_1:
case Builtin::BI__sync_add_and_fetch_2:
case Builtin::BI__sync_add_and_fetch_4:
case Builtin::BI__sync_add_and_fetch_8:
case Builtin::BI__sync_add_and_fetch_16:
return EmitBinaryAtomicPost(*this, llvm::AtomicRMWInst::Add, E,
llvm::Instruction::Add);
case Builtin::BI__sync_sub_and_fetch_1:
case Builtin::BI__sync_sub_and_fetch_2:
case Builtin::BI__sync_sub_and_fetch_4:
case Builtin::BI__sync_sub_and_fetch_8:
case Builtin::BI__sync_sub_and_fetch_16:
return EmitBinaryAtomicPost(*this, llvm::AtomicRMWInst::Sub, E,
llvm::Instruction::Sub);
case Builtin::BI__sync_and_and_fetch_1:
case Builtin::BI__sync_and_and_fetch_2:
case Builtin::BI__sync_and_and_fetch_4:
case Builtin::BI__sync_and_and_fetch_8:
case Builtin::BI__sync_and_and_fetch_16:
return EmitBinaryAtomicPost(*this, llvm::AtomicRMWInst::And, E,
llvm::Instruction::And);
case Builtin::BI__sync_or_and_fetch_1:
case Builtin::BI__sync_or_and_fetch_2:
case Builtin::BI__sync_or_and_fetch_4:
case Builtin::BI__sync_or_and_fetch_8:
case Builtin::BI__sync_or_and_fetch_16:
return EmitBinaryAtomicPost(*this, llvm::AtomicRMWInst::Or, E,
llvm::Instruction::Or);
case Builtin::BI__sync_xor_and_fetch_1:
case Builtin::BI__sync_xor_and_fetch_2:
case Builtin::BI__sync_xor_and_fetch_4:
case Builtin::BI__sync_xor_and_fetch_8:
case Builtin::BI__sync_xor_and_fetch_16:
return EmitBinaryAtomicPost(*this, llvm::AtomicRMWInst::Xor, E,
llvm::Instruction::Xor);
case Builtin::BI__sync_nand_and_fetch_1:
case Builtin::BI__sync_nand_and_fetch_2:
case Builtin::BI__sync_nand_and_fetch_4:
case Builtin::BI__sync_nand_and_fetch_8:
case Builtin::BI__sync_nand_and_fetch_16:
return EmitBinaryAtomicPost(*this, llvm::AtomicRMWInst::Nand, E,
llvm::Instruction::And, true);
case Builtin::BI__sync_val_compare_and_swap_1:
case Builtin::BI__sync_val_compare_and_swap_2:
case Builtin::BI__sync_val_compare_and_swap_4:
case Builtin::BI__sync_val_compare_and_swap_8:
case Builtin::BI__sync_val_compare_and_swap_16:
return RValue::get(MakeAtomicCmpXchgValue(*this, E, false));
case Builtin::BI__sync_bool_compare_and_swap_1:
case Builtin::BI__sync_bool_compare_and_swap_2:
case Builtin::BI__sync_bool_compare_and_swap_4:
case Builtin::BI__sync_bool_compare_and_swap_8:
case Builtin::BI__sync_bool_compare_and_swap_16:
return RValue::get(MakeAtomicCmpXchgValue(*this, E, true));
case Builtin::BI__sync_swap_1:
case Builtin::BI__sync_swap_2:
case Builtin::BI__sync_swap_4:
case Builtin::BI__sync_swap_8:
case Builtin::BI__sync_swap_16:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::Xchg, E);
case Builtin::BI__sync_lock_test_and_set_1:
case Builtin::BI__sync_lock_test_and_set_2:
case Builtin::BI__sync_lock_test_and_set_4:
case Builtin::BI__sync_lock_test_and_set_8:
case Builtin::BI__sync_lock_test_and_set_16:
return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::Xchg, E);
case Builtin::BI__sync_lock_release_1:
case Builtin::BI__sync_lock_release_2:
case Builtin::BI__sync_lock_release_4:
case Builtin::BI__sync_lock_release_8:
case Builtin::BI__sync_lock_release_16: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
QualType ElTy = E->getArg(0)->getType()->getPointeeType();
CharUnits StoreSize = getContext().getTypeSizeInChars(ElTy);
llvm::Type *ITy = llvm::IntegerType::get(getLLVMContext(),
StoreSize.getQuantity() * 8);
Ptr = Builder.CreateBitCast(Ptr, ITy->getPointerTo());
llvm::StoreInst *Store =
Builder.CreateAlignedStore(llvm::Constant::getNullValue(ITy), Ptr,
StoreSize);
Store->setAtomic(llvm::AtomicOrdering::Release);
return RValue::get(nullptr);
}
case Builtin::BI__sync_synchronize: {
// We assume this is supposed to correspond to a C++0x-style
// sequentially-consistent fence (i.e. this is only usable for
// synchronization, not device I/O or anything like that). This intrinsic
// is really badly designed in the sense that in theory, there isn't
// any way to safely use it... but in practice, it mostly works
// to use it with non-atomic loads and stores to get acquire/release
// semantics.
Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent);
return RValue::get(nullptr);
}
case Builtin::BI__builtin_nontemporal_load:
return RValue::get(EmitNontemporalLoad(*this, E));
case Builtin::BI__builtin_nontemporal_store:
return RValue::get(EmitNontemporalStore(*this, E));
case Builtin::BI__c11_atomic_is_lock_free:
case Builtin::BI__atomic_is_lock_free: {
// Call "bool __atomic_is_lock_free(size_t size, void *ptr)". For the
// __c11 builtin, ptr is 0 (indicating a properly-aligned object), since
// _Atomic(T) is always properly-aligned.
const char *LibCallName = "__atomic_is_lock_free";
CallArgList Args;
Args.add(RValue::get(EmitScalarExpr(E->getArg(0))),
getContext().getSizeType());
if (BuiltinID == Builtin::BI__atomic_is_lock_free)
Args.add(RValue::get(EmitScalarExpr(E->getArg(1))),
getContext().VoidPtrTy);
else
Args.add(RValue::get(llvm::Constant::getNullValue(VoidPtrTy)),
getContext().VoidPtrTy);
const CGFunctionInfo &FuncInfo =
CGM.getTypes().arrangeBuiltinFunctionCall(E->getType(), Args);
llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FuncInfo);
llvm::FunctionCallee Func = CGM.CreateRuntimeFunction(FTy, LibCallName);
return EmitCall(FuncInfo, CGCallee::forDirect(Func),
ReturnValueSlot(), Args);
}
case Builtin::BI__atomic_test_and_set: {
// Look at the argument type to determine whether this is a volatile
// operation. The parameter type is always volatile.
QualType PtrTy = E->getArg(0)->IgnoreImpCasts()->getType();
bool Volatile =
PtrTy->castAs<PointerType>()->getPointeeType().isVolatileQualified();
Value *Ptr = EmitScalarExpr(E->getArg(0));
unsigned AddrSpace = Ptr->getType()->getPointerAddressSpace();
Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
Value *NewVal = Builder.getInt8(1);
Value *Order = EmitScalarExpr(E->getArg(1));
if (isa<llvm::ConstantInt>(Order)) {
int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
AtomicRMWInst *Result = nullptr;
switch (ord) {
case 0: // memory_order_relaxed
default: // invalid order
Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg, Ptr, NewVal,
llvm::AtomicOrdering::Monotonic);
break;
case 1: // memory_order_consume
case 2: // memory_order_acquire
Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg, Ptr, NewVal,
llvm::AtomicOrdering::Acquire);
break;
case 3: // memory_order_release
Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg, Ptr, NewVal,
llvm::AtomicOrdering::Release);
break;
case 4: // memory_order_acq_rel
Result = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg, Ptr, NewVal,
llvm::AtomicOrdering::AcquireRelease);
break;
case 5: // memory_order_seq_cst
Result = Builder.CreateAtomicRMW(
llvm::AtomicRMWInst::Xchg, Ptr, NewVal,
llvm::AtomicOrdering::SequentiallyConsistent);
break;
}
Result->setVolatile(Volatile);
return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
}
llvm::BasicBlock *ContBB = createBasicBlock("atomic.continue", CurFn);
llvm::BasicBlock *BBs[5] = {
createBasicBlock("monotonic", CurFn),
createBasicBlock("acquire", CurFn),
createBasicBlock("release", CurFn),
createBasicBlock("acqrel", CurFn),
createBasicBlock("seqcst", CurFn)
};
llvm::AtomicOrdering Orders[5] = {
llvm::AtomicOrdering::Monotonic, llvm::AtomicOrdering::Acquire,
llvm::AtomicOrdering::Release, llvm::AtomicOrdering::AcquireRelease,
llvm::AtomicOrdering::SequentiallyConsistent};
Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
Builder.SetInsertPoint(ContBB);
PHINode *Result = Builder.CreatePHI(Int8Ty, 5, "was_set");
for (unsigned i = 0; i < 5; ++i) {
Builder.SetInsertPoint(BBs[i]);
AtomicRMWInst *RMW = Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
Ptr, NewVal, Orders[i]);
RMW->setVolatile(Volatile);
Result->addIncoming(RMW, BBs[i]);
Builder.CreateBr(ContBB);
}
SI->addCase(Builder.getInt32(0), BBs[0]);
SI->addCase(Builder.getInt32(1), BBs[1]);
SI->addCase(Builder.getInt32(2), BBs[1]);
SI->addCase(Builder.getInt32(3), BBs[2]);
SI->addCase(Builder.getInt32(4), BBs[3]);
SI->addCase(Builder.getInt32(5), BBs[4]);
Builder.SetInsertPoint(ContBB);
return RValue::get(Builder.CreateIsNotNull(Result, "tobool"));
}
case Builtin::BI__atomic_clear: {
QualType PtrTy = E->getArg(0)->IgnoreImpCasts()->getType();
bool Volatile =
PtrTy->castAs<PointerType>()->getPointeeType().isVolatileQualified();
Address Ptr = EmitPointerWithAlignment(E->getArg(0));
unsigned AddrSpace = Ptr.getPointer()->getType()->getPointerAddressSpace();
Ptr = Builder.CreateBitCast(Ptr, Int8Ty->getPointerTo(AddrSpace));
Value *NewVal = Builder.getInt8(0);
Value *Order = EmitScalarExpr(E->getArg(1));
if (isa<llvm::ConstantInt>(Order)) {
int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
switch (ord) {
case 0: // memory_order_relaxed
default: // invalid order
Store->setOrdering(llvm::AtomicOrdering::Monotonic);
break;
case 3: // memory_order_release
Store->setOrdering(llvm::AtomicOrdering::Release);
break;
case 5: // memory_order_seq_cst
Store->setOrdering(llvm::AtomicOrdering::SequentiallyConsistent);
break;
}
return RValue::get(nullptr);
}
llvm::BasicBlock *ContBB = createBasicBlock("atomic.continue", CurFn);
llvm::BasicBlock *BBs[3] = {
createBasicBlock("monotonic", CurFn),
createBasicBlock("release", CurFn),
createBasicBlock("seqcst", CurFn)
};
llvm::AtomicOrdering Orders[3] = {
llvm::AtomicOrdering::Monotonic, llvm::AtomicOrdering::Release,
llvm::AtomicOrdering::SequentiallyConsistent};
Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
llvm::SwitchInst *SI = Builder.CreateSwitch(Order, BBs[0]);
for (unsigned i = 0; i < 3; ++i) {
Builder.SetInsertPoint(BBs[i]);
StoreInst *Store = Builder.CreateStore(NewVal, Ptr, Volatile);
Store->setOrdering(Orders[i]);
Builder.CreateBr(ContBB);
}
SI->addCase(Builder.getInt32(0), BBs[0]);
SI->addCase(Builder.getInt32(3), BBs[1]);
SI->addCase(Builder.getInt32(5), BBs[2]);
Builder.SetInsertPoint(ContBB);
return RValue::get(nullptr);
}
case Builtin::BI__atomic_thread_fence:
case Builtin::BI__atomic_signal_fence:
case Builtin::BI__c11_atomic_thread_fence:
case Builtin::BI__c11_atomic_signal_fence: {
llvm::SyncScope::ID SSID;
if (BuiltinID == Builtin::BI__atomic_signal_fence ||
BuiltinID == Builtin::BI__c11_atomic_signal_fence)
SSID = llvm::SyncScope::SingleThread;
else
SSID = llvm::SyncScope::System;
Value *Order = EmitScalarExpr(E->getArg(0));
if (isa<llvm::ConstantInt>(Order)) {
int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
switch (ord) {
case 0: // memory_order_relaxed
default: // invalid order
break;
case 1: // memory_order_consume
case 2: // memory_order_acquire
Builder.CreateFence(llvm::AtomicOrdering::Acquire, SSID);
break;
case 3: // memory_order_release
Builder.CreateFence(llvm::AtomicOrdering::Release, SSID);
break;
case 4: // memory_order_acq_rel
Builder.CreateFence(llvm::AtomicOrdering::AcquireRelease, SSID);
break;
case 5: // memory_order_seq_cst
Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent, SSID);
break;
}
return RValue::get(nullptr);
}
llvm::BasicBlock *AcquireBB, *ReleaseBB, *AcqRelBB, *SeqCstBB;
AcquireBB = createBasicBlock("acquire", CurFn);
ReleaseBB = createBasicBlock("release", CurFn);
AcqRelBB = createBasicBlock("acqrel", CurFn);
SeqCstBB = createBasicBlock("seqcst", CurFn);
llvm::BasicBlock *ContBB = createBasicBlock("atomic.continue", CurFn);
Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
llvm::SwitchInst *SI = Builder.CreateSwitch(Order, ContBB);
Builder.SetInsertPoint(AcquireBB);
Builder.CreateFence(llvm::AtomicOrdering::Acquire, SSID);
Builder.CreateBr(ContBB);
SI->addCase(Builder.getInt32(1), AcquireBB);
SI->addCase(Builder.getInt32(2), AcquireBB);
Builder.SetInsertPoint(ReleaseBB);
Builder.CreateFence(llvm::AtomicOrdering::Release, SSID);
Builder.CreateBr(ContBB);
SI->addCase(Builder.getInt32(3), ReleaseBB);
Builder.SetInsertPoint(AcqRelBB);
Builder.CreateFence(llvm::AtomicOrdering::AcquireRelease, SSID);
Builder.CreateBr(ContBB);
SI->addCase(Builder.getInt32(4), AcqRelBB);
Builder.SetInsertPoint(SeqCstBB);
Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent, SSID);
Builder.CreateBr(ContBB);
SI->addCase(Builder.getInt32(5), SeqCstBB);
Builder.SetInsertPoint(ContBB);
return RValue::get(nullptr);
}
case Builtin::BI__builtin_signbit:
case Builtin::BI__builtin_signbitf:
case Builtin::BI__builtin_signbitl: {
return RValue::get(
Builder.CreateZExt(EmitSignBit(*this, EmitScalarExpr(E->getArg(0))),
ConvertType(E->getType())));
}
case Builtin::BI__warn_memset_zero_len:
return RValue::getIgnored();
case Builtin::BI__annotation: {
// Re-encode each wide string to UTF8 and make an MDString.
SmallVector<Metadata *, 1> Strings;
for (const Expr *Arg : E->arguments()) {
const auto *Str = cast<StringLiteral>(Arg->IgnoreParenCasts());
assert(Str->getCharByteWidth() == 2);
StringRef WideBytes = Str->getBytes();
std::string StrUtf8;
if (!convertUTF16ToUTF8String(
makeArrayRef(WideBytes.data(), WideBytes.size()), StrUtf8)) {
CGM.ErrorUnsupported(E, "non-UTF16 __annotation argument");
continue;
}
Strings.push_back(llvm::MDString::get(getLLVMContext(), StrUtf8));
}
// Build and MDTuple of MDStrings and emit the intrinsic call.
llvm::Function *F =
CGM.getIntrinsic(llvm::Intrinsic::codeview_annotation, {});
MDTuple *StrTuple = MDTuple::get(getLLVMContext(), Strings);
Builder.CreateCall(F, MetadataAsValue::get(getLLVMContext(), StrTuple));
return RValue::getIgnored();
}
case Builtin::BI__builtin_annotation: {
llvm::Value *AnnVal = EmitScalarExpr(E->getArg(0));
llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::annotation,
AnnVal->getType());
// Get the annotation string, go through casts. Sema requires this to be a
// non-wide string literal, potentially casted, so the cast<> is safe.
const Expr *AnnotationStrExpr = E->getArg(1)->IgnoreParenCasts();
StringRef Str = cast<StringLiteral>(AnnotationStrExpr)->getString();
return RValue::get(
EmitAnnotationCall(F, AnnVal, Str, E->getExprLoc(), nullptr));
}
case Builtin::BI__builtin_addcb:
case Builtin::BI__builtin_addcs:
case Builtin::BI__builtin_addc:
case Builtin::BI__builtin_addcl:
case Builtin::BI__builtin_addcll:
case Builtin::BI__builtin_subcb:
case Builtin::BI__builtin_subcs:
case Builtin::BI__builtin_subc:
case Builtin::BI__builtin_subcl:
case Builtin::BI__builtin_subcll: {
// We translate all of these builtins from expressions of the form:
// int x = ..., y = ..., carryin = ..., carryout, result;
// result = __builtin_addc(x, y, carryin, &carryout);
//
// to LLVM IR of the form:
//
// %tmp1 = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %x, i32 %y)
// %tmpsum1 = extractvalue {i32, i1} %tmp1, 0
// %carry1 = extractvalue {i32, i1} %tmp1, 1
// %tmp2 = call {i32, i1} @llvm.uadd.with.overflow.i32(i32 %tmpsum1,
// i32 %carryin)
// %result = extractvalue {i32, i1} %tmp2, 0
// %carry2 = extractvalue {i32, i1} %tmp2, 1
// %tmp3 = or i1 %carry1, %carry2
// %tmp4 = zext i1 %tmp3 to i32
// store i32 %tmp4, i32* %carryout
// Scalarize our inputs.
llvm::Value *X = EmitScalarExpr(E->getArg(0));
llvm::Value *Y = EmitScalarExpr(E->getArg(1));
llvm::Value *Carryin = EmitScalarExpr(E->getArg(2));
Address CarryOutPtr = EmitPointerWithAlignment(E->getArg(3));
// Decide if we are lowering to a uadd.with.overflow or usub.with.overflow.
llvm::Intrinsic::ID IntrinsicId;
switch (BuiltinID) {
default: llvm_unreachable("Unknown multiprecision builtin id.");
case Builtin::BI__builtin_addcb:
case Builtin::BI__builtin_addcs:
case Builtin::BI__builtin_addc:
case Builtin::BI__builtin_addcl:
case Builtin::BI__builtin_addcll:
IntrinsicId = llvm::Intrinsic::uadd_with_overflow;
break;
case Builtin::BI__builtin_subcb:
case Builtin::BI__builtin_subcs:
case Builtin::BI__builtin_subc:
case Builtin::BI__builtin_subcl:
case Builtin::BI__builtin_subcll:
IntrinsicId = llvm::Intrinsic::usub_with_overflow;
break;
}
// Construct our resulting LLVM IR expression.
llvm::Value *Carry1;
llvm::Value *Sum1 = EmitOverflowIntrinsic(*this, IntrinsicId,
X, Y, Carry1);
llvm::Value *Carry2;
llvm::Value *Sum2 = EmitOverflowIntrinsic(*this, IntrinsicId,
Sum1, Carryin, Carry2);
llvm::Value *CarryOut = Builder.CreateZExt(Builder.CreateOr(Carry1, Carry2),
X->getType());
Builder.CreateStore(CarryOut, CarryOutPtr);
return RValue::get(Sum2);
}
case Builtin::BI__builtin_add_overflow:
case Builtin::BI__builtin_sub_overflow:
case Builtin::BI__builtin_mul_overflow: {
const clang::Expr *LeftArg = E->getArg(0);
const clang::Expr *RightArg = E->getArg(1);
const clang::Expr *ResultArg = E->getArg(2);
clang::QualType ResultQTy =
ResultArg->getType()->castAs<PointerType>()->getPointeeType();
WidthAndSignedness LeftInfo =
getIntegerWidthAndSignedness(CGM.getContext(), LeftArg->getType());
WidthAndSignedness RightInfo =
getIntegerWidthAndSignedness(CGM.getContext(), RightArg->getType());
WidthAndSignedness ResultInfo =
getIntegerWidthAndSignedness(CGM.getContext(), ResultQTy);
// Handle mixed-sign multiplication as a special case, because adding
// runtime or backend support for our generic irgen would be too expensive.
if (isSpecialMixedSignMultiply(BuiltinID, LeftInfo, RightInfo, ResultInfo))
return EmitCheckedMixedSignMultiply(*this, LeftArg, LeftInfo, RightArg,
RightInfo, ResultArg, ResultQTy,
ResultInfo);
if (isSpecialUnsignedMultiplySignedResult(BuiltinID, LeftInfo, RightInfo,
ResultInfo))
return EmitCheckedUnsignedMultiplySignedResult(
*this, LeftArg, LeftInfo, RightArg, RightInfo, ResultArg, ResultQTy,
ResultInfo);
WidthAndSignedness EncompassingInfo =
EncompassingIntegerType({LeftInfo, RightInfo, ResultInfo});
llvm::Type *EncompassingLLVMTy =
llvm::IntegerType::get(CGM.getLLVMContext(), EncompassingInfo.Width);
llvm::Type *ResultLLVMTy = CGM.getTypes().ConvertType(ResultQTy);
llvm::Intrinsic::ID IntrinsicId;
switch (BuiltinID) {
default:
llvm_unreachable("Unknown overflow builtin id.");
case Builtin::BI__builtin_add_overflow:
IntrinsicId = EncompassingInfo.Signed
? llvm::Intrinsic::sadd_with_overflow
: llvm::Intrinsic::uadd_with_overflow;
break;
case Builtin::BI__builtin_sub_overflow:
IntrinsicId = EncompassingInfo.Signed
? llvm::Intrinsic::ssub_with_overflow
: llvm::Intrinsic::usub_with_overflow;
break;
case Builtin::BI__builtin_mul_overflow:
IntrinsicId = EncompassingInfo.Signed
? llvm::Intrinsic::smul_with_overflow
: llvm::Intrinsic::umul_with_overflow;
break;
}
llvm::Value *Left = EmitScalarExpr(LeftArg);
llvm::Value *Right = EmitScalarExpr(RightArg);
Address ResultPtr = EmitPointerWithAlignment(ResultArg);
// Extend each operand to the encompassing type.
Left = Builder.CreateIntCast(Left, EncompassingLLVMTy, LeftInfo.Signed);
Right = Builder.CreateIntCast(Right, EncompassingLLVMTy, RightInfo.Signed);
// Perform the operation on the extended values.
llvm::Value *Overflow, *Result;
Result = EmitOverflowIntrinsic(*this, IntrinsicId, Left, Right, Overflow);
if (EncompassingInfo.Width > ResultInfo.Width) {
// The encompassing type is wider than the result type, so we need to
// truncate it.
llvm::Value *ResultTrunc = Builder.CreateTrunc(Result, ResultLLVMTy);
// To see if the truncation caused an overflow, we will extend
// the result and then compare it to the original result.
llvm::Value *ResultTruncExt = Builder.CreateIntCast(
ResultTrunc, EncompassingLLVMTy, ResultInfo.Signed);
llvm::Value *TruncationOverflow =
Builder.CreateICmpNE(Result, ResultTruncExt);
Overflow = Builder.CreateOr(Overflow, TruncationOverflow);
Result = ResultTrunc;
}
// Finally, store the result using the pointer.
bool isVolatile =
ResultArg->getType()->getPointeeType().isVolatileQualified();
Builder.CreateStore(EmitToMemory(Result, ResultQTy), ResultPtr, isVolatile);
return RValue::get(Overflow);
}
case Builtin::BI__builtin_uadd_overflow:
case Builtin::BI__builtin_uaddl_overflow:
case Builtin::BI__builtin_uaddll_overflow:
case Builtin::BI__builtin_usub_overflow:
case Builtin::BI__builtin_usubl_overflow:
case Builtin::BI__builtin_usubll_overflow:
case Builtin::BI__builtin_umul_overflow:
case Builtin::BI__builtin_umull_overflow:
case Builtin::BI__builtin_umulll_overflow:
case Builtin::BI__builtin_sadd_overflow:
case Builtin::BI__builtin_saddl_overflow:
case Builtin::BI__builtin_saddll_overflow:
case Builtin::BI__builtin_ssub_overflow:
case Builtin::BI__builtin_ssubl_overflow:
case Builtin::BI__builtin_ssubll_overflow:
case Builtin::BI__builtin_smul_overflow:
case Builtin::BI__builtin_smull_overflow:
case Builtin::BI__builtin_smulll_overflow: {
// We translate all of these builtins directly to the relevant llvm IR node.
// Scalarize our inputs.
llvm::Value *X = EmitScalarExpr(E->getArg(0));
llvm::Value *Y = EmitScalarExpr(E->getArg(1));
Address SumOutPtr = EmitPointerWithAlignment(E->getArg(2));
// Decide which of the overflow intrinsics we are lowering to:
llvm::Intrinsic::ID IntrinsicId;
switch (BuiltinID) {
default: llvm_unreachable("Unknown overflow builtin id.");
case Builtin::BI__builtin_uadd_overflow:
case Builtin::BI__builtin_uaddl_overflow:
case Builtin::BI__builtin_uaddll_overflow:
IntrinsicId = llvm::Intrinsic::uadd_with_overflow;
break;
case Builtin::BI__builtin_usub_overflow:
case Builtin::BI__builtin_usubl_overflow:
case Builtin::BI__builtin_usubll_overflow:
IntrinsicId = llvm::Intrinsic::usub_with_overflow;
break;
case Builtin::BI__builtin_umul_overflow:
case Builtin::BI__builtin_umull_overflow:
case Builtin::BI__builtin_umulll_overflow:
IntrinsicId = llvm::Intrinsic::umul_with_overflow;
break;
case Builtin::BI__builtin_sadd_overflow:
case Builtin::BI__builtin_saddl_overflow:
case Builtin::BI__builtin_saddll_overflow:
IntrinsicId = llvm::Intrinsic::sadd_with_overflow;
break;
case Builtin::BI__builtin_ssub_overflow:
case Builtin::BI__builtin_ssubl_overflow:
case Builtin::BI__builtin_ssubll_overflow:
IntrinsicId = llvm::Intrinsic::ssub_with_overflow;
break;
case Builtin::BI__builtin_smul_overflow:
case Builtin::BI__builtin_smull_overflow:
case Builtin::BI__builtin_smulll_overflow:
IntrinsicId = llvm::Intrinsic::smul_with_overflow;
break;
}
llvm::Value *Carry;
llvm::Value *Sum = EmitOverflowIntrinsic(*this, IntrinsicId, X, Y, Carry);
Builder.CreateStore(Sum, SumOutPtr);
return RValue::get(Carry);
}
case Builtin::BI__builtin_addressof:
return RValue::get(EmitLValue(E->getArg(0)).getPointer(*this));
case Builtin::BI__builtin_operator_new:
return EmitBuiltinNewDeleteCall(
E->getCallee()->getType()->castAs<FunctionProtoType>(), E, false);
case Builtin::BI__builtin_operator_delete:
return EmitBuiltinNewDeleteCall(
E->getCallee()->getType()->castAs<FunctionProtoType>(), E, true);
case Builtin::BI__builtin_is_aligned:
return EmitBuiltinIsAligned(E);
case Builtin::BI__builtin_align_up:
return EmitBuiltinAlignTo(E, true);
case Builtin::BI__builtin_align_down:
return EmitBuiltinAlignTo(E, false);
case Builtin::BI__noop:
// __noop always evaluates to an integer literal zero.
return RValue::get(ConstantInt::get(IntTy, 0));
case Builtin::BI__builtin_call_with_static_chain: {
const CallExpr *Call = cast<CallExpr>(E->getArg(0));
const Expr *Chain = E->getArg(1);
return EmitCall(Call->getCallee()->getType(),
EmitCallee(Call->getCallee()), Call, ReturnValue,
EmitScalarExpr(Chain));
}
case Builtin::BI_InterlockedExchange8:
case Builtin::BI_InterlockedExchange16:
case Builtin::BI_InterlockedExchange:
case Builtin::BI_InterlockedExchangePointer:
return RValue::get(
EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedExchange, E));
case Builtin::BI_InterlockedCompareExchangePointer:
case Builtin::BI_InterlockedCompareExchangePointer_nf: {
llvm::Type *RTy;
llvm::IntegerType *IntType =
IntegerType::get(getLLVMContext(),
getContext().getTypeSize(E->getType()));
llvm::Type *IntPtrType = IntType->getPointerTo();
llvm::Value *Destination =
Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), IntPtrType);
llvm::Value *Exchange = EmitScalarExpr(E->getArg(1));
RTy = Exchange->getType();
Exchange = Builder.CreatePtrToInt(Exchange, IntType);
llvm::Value *Comparand =
Builder.CreatePtrToInt(EmitScalarExpr(E->getArg(2)), IntType);
auto Ordering =
BuiltinID == Builtin::BI_InterlockedCompareExchangePointer_nf ?
AtomicOrdering::Monotonic : AtomicOrdering::SequentiallyConsistent;
auto Result = Builder.CreateAtomicCmpXchg(Destination, Comparand, Exchange,
Ordering, Ordering);
Result->setVolatile(true);
return RValue::get(Builder.CreateIntToPtr(Builder.CreateExtractValue(Result,
0),
RTy));
}
case Builtin::BI_InterlockedCompareExchange8:
case Builtin::BI_InterlockedCompareExchange16:
case Builtin::BI_InterlockedCompareExchange:
case Builtin::BI_InterlockedCompareExchange64:
return RValue::get(EmitAtomicCmpXchgForMSIntrin(*this, E));
case Builtin::BI_InterlockedIncrement16:
case Builtin::BI_InterlockedIncrement:
return RValue::get(
EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedIncrement, E));
case Builtin::BI_InterlockedDecrement16:
case Builtin::BI_InterlockedDecrement:
return RValue::get(
EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedDecrement, E));
case Builtin::BI_InterlockedAnd8:
case Builtin::BI_InterlockedAnd16:
case Builtin::BI_InterlockedAnd:
return RValue::get(EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedAnd, E));
case Builtin::BI_InterlockedExchangeAdd8:
case Builtin::BI_InterlockedExchangeAdd16:
case Builtin::BI_InterlockedExchangeAdd:
return RValue::get(
EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedExchangeAdd, E));
case Builtin::BI_InterlockedExchangeSub8:
case Builtin::BI_InterlockedExchangeSub16:
case Builtin::BI_InterlockedExchangeSub:
return RValue::get(
EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedExchangeSub, E));
case Builtin::BI_InterlockedOr8:
case Builtin::BI_InterlockedOr16:
case Builtin::BI_InterlockedOr:
return RValue::get(EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedOr, E));
case Builtin::BI_InterlockedXor8:
case Builtin::BI_InterlockedXor16:
case Builtin::BI_InterlockedXor:
return RValue::get(EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedXor, E));
case Builtin::BI_bittest64:
case Builtin::BI_bittest:
case Builtin::BI_bittestandcomplement64:
case Builtin::BI_bittestandcomplement:
case Builtin::BI_bittestandreset64:
case Builtin::BI_bittestandreset:
case Builtin::BI_bittestandset64:
case Builtin::BI_bittestandset:
case Builtin::BI_interlockedbittestandreset:
case Builtin::BI_interlockedbittestandreset64:
case Builtin::BI_interlockedbittestandset64:
case Builtin::BI_interlockedbittestandset:
case Builtin::BI_interlockedbittestandset_acq:
case Builtin::BI_interlockedbittestandset_rel:
case Builtin::BI_interlockedbittestandset_nf:
case Builtin::BI_interlockedbittestandreset_acq:
case Builtin::BI_interlockedbittestandreset_rel:
case Builtin::BI_interlockedbittestandreset_nf:
return RValue::get(EmitBitTestIntrinsic(*this, BuiltinID, E));
// These builtins exist to emit regular volatile loads and stores not
// affected by the -fms-volatile setting.
case Builtin::BI__iso_volatile_load8:
case Builtin::BI__iso_volatile_load16:
case Builtin::BI__iso_volatile_load32:
case Builtin::BI__iso_volatile_load64:
return RValue::get(EmitISOVolatileLoad(*this, E));
case Builtin::BI__iso_volatile_store8:
case Builtin::BI__iso_volatile_store16:
case Builtin::BI__iso_volatile_store32:
case Builtin::BI__iso_volatile_store64:
return RValue::get(EmitISOVolatileStore(*this, E));
case Builtin::BI__builtin_ptrauth_sign_constant:
return RValue::get(ConstantEmitter(*this).emitAbstract(E, E->getType()));
case Builtin::BI__builtin_ptrauth_auth:
case Builtin::BI__builtin_ptrauth_auth_and_resign:
case Builtin::BI__builtin_ptrauth_blend_discriminator:
case Builtin::BI__builtin_ptrauth_sign_generic_data:
case Builtin::BI__builtin_ptrauth_sign_unauthenticated:
case Builtin::BI__builtin_ptrauth_strip: {
// Emit the arguments.
SmallVector<llvm::Value*, 5> args;
for (auto argExpr : E->arguments())
args.push_back(EmitScalarExpr(argExpr));
// Cast the value to intptr_t, saving its original type.
llvm::Type *origValueType = args[0]->getType();
if (origValueType->isPointerTy())
args[0] = Builder.CreatePtrToInt(args[0], IntPtrTy);
switch (BuiltinID) {
case Builtin::BI__builtin_ptrauth_auth_and_resign:
if (args[4]->getType()->isPointerTy())
args[4] = Builder.CreatePtrToInt(args[4], IntPtrTy);
LLVM_FALLTHROUGH;
case Builtin::BI__builtin_ptrauth_auth:
case Builtin::BI__builtin_ptrauth_sign_constant:
case Builtin::BI__builtin_ptrauth_sign_unauthenticated:
if (args[2]->getType()->isPointerTy())
args[2] = Builder.CreatePtrToInt(args[2], IntPtrTy);
break;
case Builtin::BI__builtin_ptrauth_sign_generic_data:
if (args[1]->getType()->isPointerTy())
args[1] = Builder.CreatePtrToInt(args[1], IntPtrTy);
break;
case Builtin::BI__builtin_ptrauth_blend_discriminator:
case Builtin::BI__builtin_ptrauth_strip:
break;
}
// Call the intrinsic.
auto intrinsicID = [&]() -> unsigned {
switch (BuiltinID) {
case Builtin::BI__builtin_ptrauth_auth:
return llvm::Intrinsic::ptrauth_auth;
case Builtin::BI__builtin_ptrauth_auth_and_resign:
return llvm::Intrinsic::ptrauth_resign;
case Builtin::BI__builtin_ptrauth_blend_discriminator:
return llvm::Intrinsic::ptrauth_blend;
case Builtin::BI__builtin_ptrauth_sign_generic_data:
return llvm::Intrinsic::ptrauth_sign_generic;
case Builtin::BI__builtin_ptrauth_sign_constant:
case Builtin::BI__builtin_ptrauth_sign_unauthenticated:
return llvm::Intrinsic::ptrauth_sign;
case Builtin::BI__builtin_ptrauth_strip:
return llvm::Intrinsic::ptrauth_strip;
}
llvm_unreachable("bad ptrauth intrinsic");
}();
auto intrinsic = CGM.getIntrinsic(intrinsicID, { IntPtrTy });
llvm::Value *result = EmitRuntimeCall(intrinsic, args);
if (BuiltinID != Builtin::BI__builtin_ptrauth_sign_generic_data &&
BuiltinID != Builtin::BI__builtin_ptrauth_blend_discriminator &&
origValueType->isPointerTy()) {
result = Builder.CreateIntToPtr(result, origValueType);
}
return RValue::get(result);
}
case Builtin::BI__exception_code:
case Builtin::BI_exception_code:
return RValue::get(EmitSEHExceptionCode());
case Builtin::BI__exception_info:
case Builtin::BI_exception_info:
return RValue::get(EmitSEHExceptionInfo());
case Builtin::BI__abnormal_termination:
case Builtin::BI_abnormal_termination:
return RValue::get(EmitSEHAbnormalTermination());
case Builtin::BI_setjmpex:
if (getTarget().getTriple().isOSMSVCRT() && E->getNumArgs() == 1 &&
E->getArg(0)->getType()->isPointerType())
return EmitMSVCRTSetJmp(*this, MSVCSetJmpKind::_setjmpex, E);
break;
case Builtin::BI_setjmp:
if (getTarget().getTriple().isOSMSVCRT() && E->getNumArgs() == 1 &&
E->getArg(0)->getType()->isPointerType()) {
if (getTarget().getTriple().getArch() == llvm::Triple::x86)
return EmitMSVCRTSetJmp(*this, MSVCSetJmpKind::_setjmp3, E);
else if (getTarget().getTriple().getArch() == llvm::Triple::aarch64)
return EmitMSVCRTSetJmp(*this, MSVCSetJmpKind::_setjmpex, E);
return EmitMSVCRTSetJmp(*this, MSVCSetJmpKind::_setjmp, E);
}
break;
case Builtin::BI__GetExceptionInfo: {
if (llvm::GlobalVariable *GV =
CGM.getCXXABI().getThrowInfo(FD->getParamDecl(0)->getType()))
return RValue::get(llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy));
break;
}
case Builtin::BI__fastfail:
return RValue::get(EmitMSVCBuiltinExpr(MSVCIntrin::__fastfail, E));
case Builtin::BI__builtin_coro_size: {
auto & Context = getContext();
auto SizeTy = Context.getSizeType();
auto T = Builder.getIntNTy(Context.getTypeSize(SizeTy));
Function *F = CGM.getIntrinsic(Intrinsic::coro_size, T);
return RValue::get(Builder.CreateCall(F));
}
case Builtin::BI__builtin_coro_id:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_id);
case Builtin::BI__builtin_coro_promise:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_promise);
case Builtin::BI__builtin_coro_resume:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_resume);
case Builtin::BI__builtin_coro_frame:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_frame);
case Builtin::BI__builtin_coro_noop:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_noop);
case Builtin::BI__builtin_coro_free:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_free);
case Builtin::BI__builtin_coro_destroy:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_destroy);
case Builtin::BI__builtin_coro_done:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_done);
case Builtin::BI__builtin_coro_alloc:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_alloc);
case Builtin::BI__builtin_coro_begin:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_begin);
case Builtin::BI__builtin_coro_end:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_end);
case Builtin::BI__builtin_coro_suspend:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_suspend);
case Builtin::BI__builtin_coro_param:
return EmitCoroutineIntrinsic(E, Intrinsic::coro_param);
// OpenCL v2.0 s6.13.16.2, Built-in pipe read and write functions
case Builtin::BIread_pipe:
case Builtin::BIwrite_pipe: {
Value *Arg0 = EmitScalarExpr(E->getArg(0)),
*Arg1 = EmitScalarExpr(E->getArg(1));
CGOpenCLRuntime OpenCLRT(CGM);
Value *PacketSize = OpenCLRT.getPipeElemSize(E->getArg(0));
Value *PacketAlign = OpenCLRT.getPipeElemAlign(E->getArg(0));
// Type of the generic packet parameter.
unsigned GenericAS =
getContext().getTargetAddressSpace(LangAS::opencl_generic);
llvm::Type *I8PTy = llvm::PointerType::get(
llvm::Type::getInt8Ty(getLLVMContext()), GenericAS);
// Testing which overloaded version we should generate the call for.
if (2U == E->getNumArgs()) {
const char *Name = (BuiltinID == Builtin::BIread_pipe) ? "__read_pipe_2"
: "__write_pipe_2";
// Creating a generic function type to be able to call with any builtin or
// user defined type.
llvm::Type *ArgTys[] = {Arg0->getType(), I8PTy, Int32Ty, Int32Ty};
llvm::FunctionType *FTy = llvm::FunctionType::get(
Int32Ty, llvm::ArrayRef<llvm::Type *>(ArgTys), false);
Value *BCast = Builder.CreatePointerCast(Arg1, I8PTy);
return RValue::get(
EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name),
{Arg0, BCast, PacketSize, PacketAlign}));
} else {
assert(4 == E->getNumArgs() &&
"Illegal number of parameters to pipe function");
const char *Name = (BuiltinID == Builtin::BIread_pipe) ? "__read_pipe_4"
: "__write_pipe_4";
llvm::Type *ArgTys[] = {Arg0->getType(), Arg1->getType(), Int32Ty, I8PTy,
Int32Ty, Int32Ty};
Value *Arg2 = EmitScalarExpr(E->getArg(2)),
*Arg3 = EmitScalarExpr(E->getArg(3));
llvm::FunctionType *FTy = llvm::FunctionType::get(
Int32Ty, llvm::ArrayRef<llvm::Type *>(ArgTys), false);
Value *BCast = Builder.CreatePointerCast(Arg3, I8PTy);
// We know the third argument is an integer type, but we may need to cast
// it to i32.
if (Arg2->getType() != Int32Ty)
Arg2 = Builder.CreateZExtOrTrunc(Arg2, Int32Ty);
return RValue::get(
EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name),
{Arg0, Arg1, Arg2, BCast, PacketSize, PacketAlign}));
}
}
// OpenCL v2.0 s6.13.16 ,s9.17.3.5 - Built-in pipe reserve read and write
// functions
case Builtin::BIreserve_read_pipe:
case Builtin::BIreserve_write_pipe:
case Builtin::BIwork_group_reserve_read_pipe:
case Builtin::BIwork_group_reserve_write_pipe:
case Builtin::BIsub_group_reserve_read_pipe:
case Builtin::BIsub_group_reserve_write_pipe: {
// Composing the mangled name for the function.
const char *Name;
if (BuiltinID == Builtin::BIreserve_read_pipe)
Name = "__reserve_read_pipe";
else if (BuiltinID == Builtin::BIreserve_write_pipe)
Name = "__reserve_write_pipe";
else if (BuiltinID == Builtin::BIwork_group_reserve_read_pipe)
Name = "__work_group_reserve_read_pipe";
else if (BuiltinID == Builtin::BIwork_group_reserve_write_pipe)
Name = "__work_group_reserve_write_pipe";
else if (BuiltinID == Builtin::BIsub_group_reserve_read_pipe)
Name = "__sub_group_reserve_read_pipe";
else
Name = "__sub_group_reserve_write_pipe";
Value *Arg0 = EmitScalarExpr(E->getArg(0)),
*Arg1 = EmitScalarExpr(E->getArg(1));
llvm::Type *ReservedIDTy = ConvertType(getContext().OCLReserveIDTy);
CGOpenCLRuntime OpenCLRT(CGM);
Value *PacketSize = OpenCLRT.getPipeElemSize(E->getArg(0));
Value *PacketAlign = OpenCLRT.getPipeElemAlign(E->getArg(0));
// Building the generic function prototype.
llvm::Type *ArgTys[] = {Arg0->getType(), Int32Ty, Int32Ty, Int32Ty};
llvm::FunctionType *FTy = llvm::FunctionType::get(
ReservedIDTy, llvm::ArrayRef<llvm::Type *>(ArgTys), false);
// We know the second argument is an integer type, but we may need to cast
// it to i32.
if (Arg1->getType() != Int32Ty)
Arg1 = Builder.CreateZExtOrTrunc(Arg1, Int32Ty);
return RValue::get(EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name),
{Arg0, Arg1, PacketSize, PacketAlign}));
}
// OpenCL v2.0 s6.13.16, s9.17.3.5 - Built-in pipe commit read and write
// functions
case Builtin::BIcommit_read_pipe:
case Builtin::BIcommit_write_pipe:
case Builtin::BIwork_group_commit_read_pipe:
case Builtin::BIwork_group_commit_write_pipe:
case Builtin::BIsub_group_commit_read_pipe:
case Builtin::BIsub_group_commit_write_pipe: {
const char *Name;
if (BuiltinID == Builtin::BIcommit_read_pipe)
Name = "__commit_read_pipe";
else if (BuiltinID == Builtin::BIcommit_write_pipe)
Name = "__commit_write_pipe";
else if (BuiltinID == Builtin::BIwork_group_commit_read_pipe)
Name = "__work_group_commit_read_pipe";
else if (BuiltinID == Builtin::BIwork_group_commit_write_pipe)
Name = "__work_group_commit_write_pipe";
else if (BuiltinID == Builtin::BIsub_group_commit_read_pipe)
Name = "__sub_group_commit_read_pipe";
else
Name = "__sub_group_commit_write_pipe";
Value *Arg0 = EmitScalarExpr(E->getArg(0)),
*Arg1 = EmitScalarExpr(E->getArg(1));
CGOpenCLRuntime OpenCLRT(CGM);
Value *PacketSize = OpenCLRT.getPipeElemSize(E->getArg(0));
Value *PacketAlign = OpenCLRT.getPipeElemAlign(E->getArg(0));
// Building the generic function prototype.
llvm::Type *ArgTys[] = {Arg0->getType(), Arg1->getType(), Int32Ty, Int32Ty};
llvm::FunctionType *FTy =
llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()),
llvm::ArrayRef<llvm::Type *>(ArgTys), false);
return RValue::get(EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name),
{Arg0, Arg1, PacketSize, PacketAlign}));
}
// OpenCL v2.0 s6.13.16.4 Built-in pipe query functions
case Builtin::BIget_pipe_num_packets:
case Builtin::BIget_pipe_max_packets: {
const char *BaseName;
const auto *PipeTy = E->getArg(0)->getType()->castAs<PipeType>();
if (BuiltinID == Builtin::BIget_pipe_num_packets)
BaseName = "__get_pipe_num_packets";
else
BaseName = "__get_pipe_max_packets";
std::string Name = std::string(BaseName) +
std::string(PipeTy->isReadOnly() ? "_ro" : "_wo");
// Building the generic function prototype.
Value *Arg0 = EmitScalarExpr(E->getArg(0));
CGOpenCLRuntime OpenCLRT(CGM);
Value *PacketSize = OpenCLRT.getPipeElemSize(E->getArg(0));
Value *PacketAlign = OpenCLRT.getPipeElemAlign(E->getArg(0));
llvm::Type *ArgTys[] = {Arg0->getType(), Int32Ty, Int32Ty};
llvm::FunctionType *FTy = llvm::FunctionType::get(
Int32Ty, llvm::ArrayRef<llvm::Type *>(ArgTys), false);
return RValue::get(EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name),
{Arg0, PacketSize, PacketAlign}));
}
// OpenCL v2.0 s6.13.9 - Address space qualifier functions.
case Builtin::BIto_global:
case Builtin::BIto_local:
case Builtin::BIto_private: {
auto Arg0 = EmitScalarExpr(E->getArg(0));
auto NewArgT = llvm::PointerType::get(Int8Ty,
CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic));
auto NewRetT = llvm::PointerType::get(Int8Ty,
CGM.getContext().getTargetAddressSpace(
E->getType()->getPointeeType().getAddressSpace()));
auto FTy = llvm::FunctionType::get(NewRetT, {NewArgT}, false);
llvm::Value *NewArg;
if (Arg0->getType()->getPointerAddressSpace() !=
NewArgT->getPointerAddressSpace())
NewArg = Builder.CreateAddrSpaceCast(Arg0, NewArgT);
else
NewArg = Builder.CreateBitOrPointerCast(Arg0, NewArgT);
auto NewName = std::string("__") + E->getDirectCallee()->getName().str();
auto NewCall =
EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, NewName), {NewArg});
return RValue::get(Builder.CreateBitOrPointerCast(NewCall,
ConvertType(E->getType())));
}
// OpenCL v2.0, s6.13.17 - Enqueue kernel function.
// It contains four different overload formats specified in Table 6.13.17.1.
case Builtin::BIenqueue_kernel: {
StringRef Name; // Generated function call name
unsigned NumArgs = E->getNumArgs();
llvm::Type *QueueTy = ConvertType(getContext().OCLQueueTy);
llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
getContext().getTargetAddressSpace(LangAS::opencl_generic));
llvm::Value *Queue = EmitScalarExpr(E->getArg(0));
llvm::Value *Flags = EmitScalarExpr(E->getArg(1));
LValue NDRangeL = EmitAggExprToLValue(E->getArg(2));
llvm::Value *Range = NDRangeL.getAddress(*this).getPointer();
llvm::Type *RangeTy = NDRangeL.getAddress(*this).getType();
if (NumArgs == 4) {
// The most basic form of the call with parameters:
// queue_t, kernel_enqueue_flags_t, ndrange_t, block(void)
Name = "__enqueue_kernel_basic";
llvm::Type *ArgTys[] = {QueueTy, Int32Ty, RangeTy, GenericVoidPtrTy,
GenericVoidPtrTy};
llvm::FunctionType *FTy = llvm::FunctionType::get(
Int32Ty, llvm::ArrayRef<llvm::Type *>(ArgTys), false);
auto Info =
CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(3));
llvm::Value *Kernel =
Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
llvm::Value *Block =
Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
AttrBuilder B;
B.addByValAttr(NDRangeL.getAddress(*this).getElementType());
llvm::AttributeList ByValAttrSet =
llvm::AttributeList::get(CGM.getModule().getContext(), 3U, B);
auto RTCall =
EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name, ByValAttrSet),
{Queue, Flags, Range, Kernel, Block});
RTCall->setAttributes(ByValAttrSet);
return RValue::get(RTCall);
}
assert(NumArgs >= 5 && "Invalid enqueue_kernel signature");
// Create a temporary array to hold the sizes of local pointer arguments
// for the block. \p First is the position of the first size argument.
auto CreateArrayForSizeVar = [=](unsigned First)
-> std::tuple<llvm::Value *, llvm::Value *, llvm::Value *> {
llvm::APInt ArraySize(32, NumArgs - First);
QualType SizeArrayTy = getContext().getConstantArrayType(
getContext().getSizeType(), ArraySize, nullptr, ArrayType::Normal,
/*IndexTypeQuals=*/0);
auto Tmp = CreateMemTemp(SizeArrayTy, "block_sizes");
llvm::Value *TmpPtr = Tmp.getPointer();
llvm::Value *TmpSize = EmitLifetimeStart(
CGM.getDataLayout().getTypeAllocSize(Tmp.getElementType()), TmpPtr);
llvm::Value *ElemPtr;
// Each of the following arguments specifies the size of the corresponding
// argument passed to the enqueued block.
auto *Zero = llvm::ConstantInt::get(IntTy, 0);
for (unsigned I = First; I < NumArgs; ++I) {
auto *Index = llvm::ConstantInt::get(IntTy, I - First);
auto *GEP = Builder.CreateGEP(TmpPtr, {Zero, Index});
if (I == First)
ElemPtr = GEP;
auto *V =
Builder.CreateZExtOrTrunc(EmitScalarExpr(E->getArg(I)), SizeTy);
Builder.CreateAlignedStore(
V, GEP, CGM.getDataLayout().getPrefTypeAlign(SizeTy));
}
return std::tie(ElemPtr, TmpSize, TmpPtr);
};
// Could have events and/or varargs.
if (E->getArg(3)->getType()->isBlockPointerType()) {
// No events passed, but has variadic arguments.
Name = "__enqueue_kernel_varargs";
auto Info =
CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(3));
llvm::Value *Kernel =
Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
auto *Block = Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
llvm::Value *ElemPtr, *TmpSize, *TmpPtr;
std::tie(ElemPtr, TmpSize, TmpPtr) = CreateArrayForSizeVar(4);
// Create a vector of the arguments, as well as a constant value to
// express to the runtime the number of variadic arguments.
llvm::Value *const Args[] = {Queue, Flags,
Range, Kernel,
Block, ConstantInt::get(IntTy, NumArgs - 4),
ElemPtr};
llvm::Type *const ArgTys[] = {
QueueTy, IntTy, RangeTy, GenericVoidPtrTy,
GenericVoidPtrTy, IntTy, ElemPtr->getType()};
llvm::FunctionType *FTy = llvm::FunctionType::get(Int32Ty, ArgTys, false);
auto Call = RValue::get(
EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name), Args));
if (TmpSize)
EmitLifetimeEnd(TmpSize, TmpPtr);
return Call;
}
// Any calls now have event arguments passed.
if (NumArgs >= 7) {
llvm::Type *EventTy = ConvertType(getContext().OCLClkEventTy);
llvm::PointerType *EventPtrTy = EventTy->getPointerTo(
CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic));
llvm::Value *NumEvents =
Builder.CreateZExtOrTrunc(EmitScalarExpr(E->getArg(3)), Int32Ty);
// Since SemaOpenCLBuiltinEnqueueKernel allows fifth and sixth arguments
// to be a null pointer constant (including `0` literal), we can take it
// into account and emit null pointer directly.
llvm::Value *EventWaitList = nullptr;
if (E->getArg(4)->isNullPointerConstant(
getContext(), Expr::NPC_ValueDependentIsNotNull)) {
EventWaitList = llvm::ConstantPointerNull::get(EventPtrTy);
} else {
EventWaitList = E->getArg(4)->getType()->isArrayType()
? EmitArrayToPointerDecay(E->getArg(4)).getPointer()
: EmitScalarExpr(E->getArg(4));
// Convert to generic address space.
EventWaitList = Builder.CreatePointerCast(EventWaitList, EventPtrTy);
}
llvm::Value *EventRet = nullptr;
if (E->getArg(5)->isNullPointerConstant(
getContext(), Expr::NPC_ValueDependentIsNotNull)) {
EventRet = llvm::ConstantPointerNull::get(EventPtrTy);
} else {
EventRet =
Builder.CreatePointerCast(EmitScalarExpr(E->getArg(5)), EventPtrTy);
}
auto Info =
CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(6));
llvm::Value *Kernel =
Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
llvm::Value *Block =
Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
std::vector<llvm::Type *> ArgTys = {
QueueTy, Int32Ty, RangeTy, Int32Ty,
EventPtrTy, EventPtrTy, GenericVoidPtrTy, GenericVoidPtrTy};
std::vector<llvm::Value *> Args = {Queue, Flags, Range,
NumEvents, EventWaitList, EventRet,
Kernel, Block};
if (NumArgs == 7) {
// Has events but no variadics.
Name = "__enqueue_kernel_basic_events";
llvm::FunctionType *FTy = llvm::FunctionType::get(
Int32Ty, llvm::ArrayRef<llvm::Type *>(ArgTys), false);
return RValue::get(
EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name),
llvm::ArrayRef<llvm::Value *>(Args)));
}
// Has event info and variadics
// Pass the number of variadics to the runtime function too.
Args.push_back(ConstantInt::get(Int32Ty, NumArgs - 7));
ArgTys.push_back(Int32Ty);
Name = "__enqueue_kernel_events_varargs";
llvm::Value *ElemPtr, *TmpSize, *TmpPtr;
std::tie(ElemPtr, TmpSize, TmpPtr) = CreateArrayForSizeVar(7);
Args.push_back(ElemPtr);
ArgTys.push_back(ElemPtr->getType());
llvm::FunctionType *FTy = llvm::FunctionType::get(
Int32Ty, llvm::ArrayRef<llvm::Type *>(ArgTys), false);
auto Call =
RValue::get(EmitRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name),
llvm::ArrayRef<llvm::Value *>(Args)));
if (TmpSize)
EmitLifetimeEnd(TmpSize, TmpPtr);
return Call;
}
LLVM_FALLTHROUGH;
}
// OpenCL v2.0 s6.13.17.6 - Kernel query functions need bitcast of block
// parameter.
case Builtin::BIget_kernel_work_group_size: {
llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
getContext().getTargetAddressSpace(LangAS::opencl_generic));
auto Info =
CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(0));
Value *Kernel = Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
Value *Arg = Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
return RValue::get(EmitRuntimeCall(
CGM.CreateRuntimeFunction(
llvm::FunctionType::get(IntTy, {GenericVoidPtrTy, GenericVoidPtrTy},
false),
"__get_kernel_work_group_size_impl"),
{Kernel, Arg}));
}
case Builtin::BIget_kernel_preferred_work_group_size_multiple: {
llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
getContext().getTargetAddressSpace(LangAS::opencl_generic));
auto Info =
CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(0));
Value *Kernel = Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
Value *Arg = Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
return RValue::get(EmitRuntimeCall(
CGM.CreateRuntimeFunction(
llvm::FunctionType::get(IntTy, {GenericVoidPtrTy, GenericVoidPtrTy},
false),
"__get_kernel_preferred_work_group_size_multiple_impl"),
{Kernel, Arg}));
}
case Builtin::BIget_kernel_max_sub_group_size_for_ndrange:
case Builtin::BIget_kernel_sub_group_count_for_ndrange: {
llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
getContext().getTargetAddressSpace(LangAS::opencl_generic));
LValue NDRangeL = EmitAggExprToLValue(E->getArg(0));
llvm::Value *NDRange = NDRangeL.getAddress(*this).getPointer();
auto Info =
CGM.getOpenCLRuntime().emitOpenCLEnqueuedBlock(*this, E->getArg(1));
Value *Kernel = Builder.CreatePointerCast(Info.Kernel, GenericVoidPtrTy);
Value *Block = Builder.CreatePointerCast(Info.BlockArg, GenericVoidPtrTy);
const char *Name =
BuiltinID == Builtin::BIget_kernel_max_sub_group_size_for_ndrange
? "__get_kernel_max_sub_group_size_for_ndrange_impl"
: "__get_kernel_sub_group_count_for_ndrange_impl";
return RValue::get(EmitRuntimeCall(
CGM.CreateRuntimeFunction(
llvm::FunctionType::get(
IntTy, {NDRange->getType(), GenericVoidPtrTy, GenericVoidPtrTy},
false),
Name),
{NDRange, Kernel, Block}));
}
case Builtin::BI__builtin_store_half:
case Builtin::BI__builtin_store_halff: {
Value *Val = EmitScalarExpr(E->getArg(0));
Address Address = EmitPointerWithAlignment(E->getArg(1));
Value *HalfVal = Builder.CreateFPTrunc(Val, Builder.getHalfTy());
return RValue::get(Builder.CreateStore(HalfVal, Address));
}
case Builtin::BI__builtin_load_half: {
Address Address = EmitPointerWithAlignment(E->getArg(0));
Value *HalfVal = Builder.CreateLoad(Address);
return RValue::get(Builder.CreateFPExt(HalfVal, Builder.getDoubleTy()));
}
case Builtin::BI__builtin_load_halff: {
Address Address = EmitPointerWithAlignment(E->getArg(0));
Value *HalfVal = Builder.CreateLoad(Address);
return RValue::get(Builder.CreateFPExt(HalfVal, Builder.getFloatTy()));
}
case Builtin::BIprintf:
if (getTarget().getTriple().isNVPTX())
return EmitNVPTXDevicePrintfCallExpr(E, ReturnValue);
if (getTarget().getTriple().getArch() == Triple::amdgcn &&
getLangOpts().HIP)
return EmitAMDGPUDevicePrintfCallExpr(E, ReturnValue);
break;
case Builtin::BI__builtin_canonicalize:
case Builtin::BI__builtin_canonicalizef:
case Builtin::BI__builtin_canonicalizef16:
case Builtin::BI__builtin_canonicalizel:
return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::canonicalize));
case Builtin::BI__builtin_thread_pointer: {
if (!getContext().getTargetInfo().isTLSSupported())
CGM.ErrorUnsupported(E, "__builtin_thread_pointer");
// Fall through - it's already mapped to the intrinsic by GCCBuiltin.
break;
}
case Builtin::BI__builtin_os_log_format:
return emitBuiltinOSLogFormat(*E);
case Builtin::BI__xray_customevent: {
if (!ShouldXRayInstrumentFunction())
return RValue::getIgnored();
if (!CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
XRayInstrKind::Custom))
return RValue::getIgnored();
if (const auto *XRayAttr = CurFuncDecl->getAttr<XRayInstrumentAttr>())
if (XRayAttr->neverXRayInstrument() && !AlwaysEmitXRayCustomEvents())
return RValue::getIgnored();
Function *F = CGM.getIntrinsic(Intrinsic::xray_customevent);
auto FTy = F->getFunctionType();
auto Arg0 = E->getArg(0);
auto Arg0Val = EmitScalarExpr(Arg0);
auto Arg0Ty = Arg0->getType();
auto PTy0 = FTy->getParamType(0);
if (PTy0 != Arg0Val->getType()) {
if (Arg0Ty->isArrayType())
Arg0Val = EmitArrayToPointerDecay(Arg0).getPointer();
else
Arg0Val = Builder.CreatePointerCast(Arg0Val, PTy0);
}
auto Arg1 = EmitScalarExpr(E->getArg(1));
auto PTy1 = FTy->getParamType(1);
if (PTy1 != Arg1->getType())
Arg1 = Builder.CreateTruncOrBitCast(Arg1, PTy1);
return RValue::get(Builder.CreateCall(F, {Arg0Val, Arg1}));
}
case Builtin::BI__xray_typedevent: {
// TODO: There should be a way to always emit events even if the current
// function is not instrumented. Losing events in a stream can cripple
// a trace.
if (!ShouldXRayInstrumentFunction())
return RValue::getIgnored();
if (!CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
XRayInstrKind::Typed))
return RValue::getIgnored();
if (const auto *XRayAttr = CurFuncDecl->getAttr<XRayInstrumentAttr>())
if (XRayAttr->neverXRayInstrument() && !AlwaysEmitXRayTypedEvents())
return RValue::getIgnored();
Function *F = CGM.getIntrinsic(Intrinsic::xray_typedevent);
auto FTy = F->getFunctionType();
auto Arg0 = EmitScalarExpr(E->getArg(0));
auto PTy0 = FTy->getParamType(0);
if (PTy0 != Arg0->getType())
Arg0 = Builder.CreateTruncOrBitCast(Arg0, PTy0);
auto Arg1 = E->getArg(1);
auto Arg1Val = EmitScalarExpr(Arg1);
auto Arg1Ty = Arg1->getType();
auto PTy1 = FTy->getParamType(1);
if (PTy1 != Arg1Val->getType()) {
if (Arg1Ty->isArrayType())
Arg1Val = EmitArrayToPointerDecay(Arg1).getPointer();
else
Arg1Val = Builder.CreatePointerCast(Arg1Val, PTy1);
}
auto Arg2 = EmitScalarExpr(E->getArg(2));
auto PTy2 = FTy->getParamType(2);
if (PTy2 != Arg2->getType())
Arg2 = Builder.CreateTruncOrBitCast(Arg2, PTy2);
return RValue::get(Builder.CreateCall(F, {Arg0, Arg1Val, Arg2}));
}
case Builtin::BI__builtin_ms_va_start:
case Builtin::BI__builtin_ms_va_end:
return RValue::get(
EmitVAStartEnd(EmitMSVAListRef(E->getArg(0)).getPointer(),
BuiltinID == Builtin::BI__builtin_ms_va_start));
case Builtin::BI__builtin_ms_va_copy: {
// Lower this manually. We can't reliably determine whether or not any
// given va_copy() is for a Win64 va_list from the calling convention
// alone, because it's legal to do this from a System V ABI function.
// With opaque pointer types, we won't have enough information in LLVM
// IR to determine this from the argument types, either. Best to do it
// now, while we have enough information.
Address DestAddr = EmitMSVAListRef(E->getArg(0));
Address SrcAddr = EmitMSVAListRef(E->getArg(1));
llvm::Type *BPP = Int8PtrPtrTy;
DestAddr = Address(Builder.CreateBitCast(DestAddr.getPointer(), BPP, "cp"),
DestAddr.getAlignment());
SrcAddr = Address(Builder.CreateBitCast(SrcAddr.getPointer(), BPP, "ap"),
SrcAddr.getAlignment());
Value *ArgPtr = Builder.CreateLoad(SrcAddr, "ap.val");
return RValue::get(Builder.CreateStore(ArgPtr, DestAddr));
}
}
// If this is an alias for a lib function (e.g. __builtin_sin), emit
// the call using the normal call path, but using the unmangled
// version of the function name.
if (getContext().BuiltinInfo.isLibFunction(BuiltinID))
return emitLibraryCall(*this, FD, E,
CGM.getBuiltinLibFunction(FD, BuiltinID));
// If this is a predefined lib function (e.g. malloc), emit the call
// using exactly the normal call path.
if (getContext().BuiltinInfo.isPredefinedLibFunction(BuiltinID))
return emitLibraryCall(*this, FD, E,
CGM.getRawFunctionPointer(FD));
// Check that a call to a target specific builtin has the correct target
// features.
// This is down here to avoid non-target specific builtins, however, if
// generic builtins start to require generic target features then we
// can move this up to the beginning of the function.
checkTargetFeatures(E, FD);
if (unsigned VectorWidth = getContext().BuiltinInfo.getRequiredVectorWidth(BuiltinID))
LargestVectorWidth = std::max(LargestVectorWidth, VectorWidth);
// See if we have a target specific intrinsic.
const char *Name = getContext().BuiltinInfo.getName(BuiltinID);
Intrinsic::ID IntrinsicID = Intrinsic::not_intrinsic;
StringRef Prefix =
llvm::Triple::getArchTypePrefix(getTarget().getTriple().getArch());
if (!Prefix.empty()) {
IntrinsicID = Intrinsic::getIntrinsicForGCCBuiltin(Prefix.data(), Name);
// NOTE we don't need to perform a compatibility flag check here since the
// intrinsics are declared in Builtins*.def via LANGBUILTIN which filter the
// MS builtins via ALL_MS_LANGUAGES and are filtered earlier.
if (IntrinsicID == Intrinsic::not_intrinsic)
IntrinsicID = Intrinsic::getIntrinsicForMSBuiltin(Prefix.data(), Name);
}
if (IntrinsicID != Intrinsic::not_intrinsic) {
SmallVector<Value*, 16> Args;
// Find out if any arguments are required to be integer constant
// expressions.
unsigned ICEArguments = 0;
ASTContext::GetBuiltinTypeError Error;
getContext().GetBuiltinType(BuiltinID, Error, &ICEArguments);
assert(Error == ASTContext::GE_None && "Should not codegen an error");
Function *F = CGM.getIntrinsic(IntrinsicID);
llvm::FunctionType *FTy = F->getFunctionType();
for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
Value *ArgValue;
// If this is a normal argument, just emit it as a scalar.
if ((ICEArguments & (1 << i)) == 0) {
ArgValue = EmitScalarExpr(E->getArg(i));
} else {
// If this is required to be a constant, constant fold it so that we
// know that the generated intrinsic gets a ConstantInt.
ArgValue = llvm::ConstantInt::get(
getLLVMContext(),
*E->getArg(i)->getIntegerConstantExpr(getContext()));
}
// If the intrinsic arg type is different from the builtin arg type
// we need to do a bit cast.
llvm::Type *PTy = FTy->getParamType(i);
if (PTy != ArgValue->getType()) {
// XXX - vector of pointers?
if (auto *PtrTy = dyn_cast<llvm::PointerType>(PTy)) {
if (PtrTy->getAddressSpace() !=
ArgValue->getType()->getPointerAddressSpace()) {
ArgValue = Builder.CreateAddrSpaceCast(
ArgValue,
ArgValue->getType()->getPointerTo(PtrTy->getAddressSpace()));
}
}
assert(PTy->canLosslesslyBitCastTo(FTy->getParamType(i)) &&
"Must be able to losslessly bit cast to param");
ArgValue = Builder.CreateBitCast(ArgValue, PTy);
}
Args.push_back(ArgValue);
}
Value *V = Builder.CreateCall(F, Args);
QualType BuiltinRetType = E->getType();
llvm::Type *RetTy = VoidTy;
if (!BuiltinRetType->isVoidType())
RetTy = ConvertType(BuiltinRetType);
if (RetTy != V->getType()) {
// XXX - vector of pointers?
if (auto *PtrTy = dyn_cast<llvm::PointerType>(RetTy)) {
if (PtrTy->getAddressSpace() != V->getType()->getPointerAddressSpace()) {
V = Builder.CreateAddrSpaceCast(
V, V->getType()->getPointerTo(PtrTy->getAddressSpace()));
}
}
assert(V->getType()->canLosslesslyBitCastTo(RetTy) &&
"Must be able to losslessly bit cast result type");
V = Builder.CreateBitCast(V, RetTy);
}
return RValue::get(V);
}
// Some target-specific builtins can have aggregate return values, e.g.
// __builtin_arm_mve_vld2q_u32. So if the result is an aggregate, force
// ReturnValue to be non-null, so that the target-specific emission code can
// always just emit into it.
TypeEvaluationKind EvalKind = getEvaluationKind(E->getType());
if (EvalKind == TEK_Aggregate && ReturnValue.isNull()) {
Address DestPtr = CreateMemTemp(E->getType(), "agg.tmp");
ReturnValue = ReturnValueSlot(DestPtr, false);
}
// Now see if we can emit a target-specific builtin.
if (Value *V = EmitTargetBuiltinExpr(BuiltinID, E, ReturnValue)) {
switch (EvalKind) {
case TEK_Scalar:
return RValue::get(V);
case TEK_Aggregate:
return RValue::getAggregate(ReturnValue.getValue(),
ReturnValue.isVolatile());
case TEK_Complex:
llvm_unreachable("No current target builtin returns complex");
}
llvm_unreachable("Bad evaluation kind in EmitBuiltinExpr");
}
ErrorUnsupported(E, "builtin function");
// Unknown builtin, for now just dump it out and return undef.
return GetUndefRValue(E->getType());
}
static Value *EmitTargetArchBuiltinExpr(CodeGenFunction *CGF,
unsigned BuiltinID, const CallExpr *E,
ReturnValueSlot ReturnValue,
llvm::Triple::ArchType Arch) {
switch (Arch) {
case llvm::Triple::arm:
case llvm::Triple::armeb:
case llvm::Triple::thumb:
case llvm::Triple::thumbeb:
return CGF->EmitARMBuiltinExpr(BuiltinID, E, ReturnValue, Arch);
case llvm::Triple::aarch64:
case llvm::Triple::aarch64_32:
case llvm::Triple::aarch64_be:
return CGF->EmitAArch64BuiltinExpr(BuiltinID, E, Arch);
case llvm::Triple::bpfeb:
case llvm::Triple::bpfel:
return CGF->EmitBPFBuiltinExpr(BuiltinID, E);
case llvm::Triple::x86:
case llvm::Triple::x86_64:
return CGF->EmitX86BuiltinExpr(BuiltinID, E);
case llvm::Triple::ppc:
case llvm::Triple::ppcle:
case llvm::Triple::ppc64:
case llvm::Triple::ppc64le:
return CGF->EmitPPCBuiltinExpr(BuiltinID, E);
case llvm::Triple::r600:
case llvm::Triple::amdgcn:
return CGF->EmitAMDGPUBuiltinExpr(BuiltinID, E);
case llvm::Triple::systemz:
return CGF->EmitSystemZBuiltinExpr(BuiltinID, E);
case llvm::Triple::nvptx:
case llvm::Triple::nvptx64:
return CGF->EmitNVPTXBuiltinExpr(BuiltinID, E);
case llvm::Triple::wasm32:
case llvm::Triple::wasm64:
return CGF->EmitWebAssemblyBuiltinExpr(BuiltinID, E);
case llvm::Triple::hexagon:
return CGF->EmitHexagonBuiltinExpr(BuiltinID, E);
default:
return nullptr;
}
}
Value *CodeGenFunction::EmitTargetBuiltinExpr(unsigned BuiltinID,
const CallExpr *E,
ReturnValueSlot ReturnValue) {
if (getContext().BuiltinInfo.isAuxBuiltinID(BuiltinID)) {
assert(getContext().getAuxTargetInfo() && "Missing aux target info");
return EmitTargetArchBuiltinExpr(
this, getContext().BuiltinInfo.getAuxBuiltinID(BuiltinID), E,
ReturnValue, getContext().getAuxTargetInfo()->getTriple().getArch());
}
return EmitTargetArchBuiltinExpr(this, BuiltinID, E, ReturnValue,
getTarget().getTriple().getArch());
}
static llvm::FixedVectorType *GetNeonType(CodeGenFunction *CGF,
NeonTypeFlags TypeFlags,
bool HasLegalHalfType = true,
bool V1Ty = false,
bool AllowBFloatArgsAndRet = true) {
int IsQuad = TypeFlags.isQuad();
switch (TypeFlags.getEltType()) {
case NeonTypeFlags::Int8:
case NeonTypeFlags::Poly8:
return llvm::FixedVectorType::get(CGF->Int8Ty, V1Ty ? 1 : (8 << IsQuad));
case NeonTypeFlags::Int16:
case NeonTypeFlags::Poly16:
return llvm::FixedVectorType::get(CGF->Int16Ty, V1Ty ? 1 : (4 << IsQuad));
case NeonTypeFlags::BFloat16:
if (AllowBFloatArgsAndRet)
return llvm::FixedVectorType::get(CGF->BFloatTy, V1Ty ? 1 : (4 << IsQuad));
else
return llvm::FixedVectorType::get(CGF->Int16Ty, V1Ty ? 1 : (4 << IsQuad));
case NeonTypeFlags::Float16:
if (HasLegalHalfType)
return llvm::FixedVectorType::get(CGF->HalfTy, V1Ty ? 1 : (4 << IsQuad));
else
return llvm::FixedVectorType::get(CGF->Int16Ty, V1Ty ? 1 : (4 << IsQuad));
case NeonTypeFlags::Int32:
return llvm::FixedVectorType::get(CGF->Int32Ty, V1Ty ? 1 : (2 << IsQuad));
case NeonTypeFlags::Int64:
case NeonTypeFlags::Poly64:
return llvm::FixedVectorType::get(CGF->Int64Ty, V1Ty ? 1 : (1 << IsQuad));
case NeonTypeFlags::Poly128:
// FIXME: i128 and f128 doesn't get fully support in Clang and llvm.
// There is a lot of i128 and f128 API missing.
// so we use v16i8 to represent poly128 and get pattern matched.
return llvm::FixedVectorType::get(CGF->Int8Ty, 16);
case NeonTypeFlags::Float32:
return llvm::FixedVectorType::get(CGF->FloatTy, V1Ty ? 1 : (2 << IsQuad));
case NeonTypeFlags::Float64:
return llvm::FixedVectorType::get(CGF->DoubleTy, V1Ty ? 1 : (1 << IsQuad));
}
llvm_unreachable("Unknown vector element type!");
}
static llvm::VectorType *GetFloatNeonType(CodeGenFunction *CGF,
NeonTypeFlags IntTypeFlags) {
int IsQuad = IntTypeFlags.isQuad();
switch (IntTypeFlags.getEltType()) {
case NeonTypeFlags::Int16:
return llvm::FixedVectorType::get(CGF->HalfTy, (4 << IsQuad));
case NeonTypeFlags::Int32:
return llvm::FixedVectorType::get(CGF->FloatTy, (2 << IsQuad));
case NeonTypeFlags::Int64:
return llvm::FixedVectorType::get(CGF->DoubleTy, (1 << IsQuad));
default:
llvm_unreachable("Type can't be converted to floating-point!");
}
}
Value *CodeGenFunction::EmitNeonSplat(Value *V, Constant *C,
const ElementCount &Count) {
Value *SV = llvm::ConstantVector::getSplat(Count, C);
return Builder.CreateShuffleVector(V, V, SV, "lane");
}
Value *CodeGenFunction::EmitNeonSplat(Value *V, Constant *C) {
ElementCount EC = cast<llvm::VectorType>(V->getType())->getElementCount();
return EmitNeonSplat(V, C, EC);
}
Value *CodeGenFunction::EmitNeonCall(Function *F, SmallVectorImpl<Value*> &Ops,
const char *name,
unsigned shift, bool rightshift) {
unsigned j = 0;
for (Function::const_arg_iterator ai = F->arg_begin(), ae = F->arg_end();
ai != ae; ++ai, ++j) {
if (F->isConstrainedFPIntrinsic())
if (ai->getType()->isMetadataTy())
continue;
if (shift > 0 && shift == j)
Ops[j] = EmitNeonShiftVector(Ops[j], ai->getType(), rightshift);
else
Ops[j] = Builder.CreateBitCast(Ops[j], ai->getType(), name);
}
if (F->isConstrainedFPIntrinsic())
return Builder.CreateConstrainedFPCall(F, Ops, name);
else
return Builder.CreateCall(F, Ops, name);
}
Value *CodeGenFunction::EmitNeonShiftVector(Value *V, llvm::Type *Ty,
bool neg) {
int SV = cast<ConstantInt>(V)->getSExtValue();
return ConstantInt::get(Ty, neg ? -SV : SV);
}
// Right-shift a vector by a constant.
Value *CodeGenFunction::EmitNeonRShiftImm(Value *Vec, Value *Shift,
llvm::Type *Ty, bool usgn,
const char *name) {
llvm::VectorType *VTy = cast<llvm::VectorType>(Ty);
int ShiftAmt = cast<ConstantInt>(Shift)->getSExtValue();
int EltSize = VTy->getScalarSizeInBits();
Vec = Builder.CreateBitCast(Vec, Ty);
// lshr/ashr are undefined when the shift amount is equal to the vector
// element size.
if (ShiftAmt == EltSize) {
if (usgn) {
// Right-shifting an unsigned value by its size yields 0.
return llvm::ConstantAggregateZero::get(VTy);
} else {
// Right-shifting a signed value by its size is equivalent
// to a shift of size-1.
--ShiftAmt;
Shift = ConstantInt::get(VTy->getElementType(), ShiftAmt);
}
}
Shift = EmitNeonShiftVector(Shift, Ty, false);
if (usgn)
return Builder.CreateLShr(Vec, Shift, name);
else
return Builder.CreateAShr(Vec, Shift, name);
}
enum {
AddRetType = (1 << 0),
Add1ArgType = (1 << 1),
Add2ArgTypes = (1 << 2),
VectorizeRetType = (1 << 3),
VectorizeArgTypes = (1 << 4),
InventFloatType = (1 << 5),
UnsignedAlts = (1 << 6),
Use64BitVectors = (1 << 7),
Use128BitVectors = (1 << 8),
Vectorize1ArgType = Add1ArgType | VectorizeArgTypes,
VectorRet = AddRetType | VectorizeRetType,
VectorRetGetArgs01 =
AddRetType | Add2ArgTypes | VectorizeRetType | VectorizeArgTypes,
FpCmpzModifiers =
AddRetType | VectorizeRetType | Add1ArgType | InventFloatType
};
namespace {
struct ARMVectorIntrinsicInfo {
const char *NameHint;
unsigned BuiltinID;
unsigned LLVMIntrinsic;
unsigned AltLLVMIntrinsic;
uint64_t TypeModifier;
bool operator<(unsigned RHSBuiltinID) const {
return BuiltinID < RHSBuiltinID;
}
bool operator<(const ARMVectorIntrinsicInfo &TE) const {
return BuiltinID < TE.BuiltinID;
}
};
} // end anonymous namespace
#define NEONMAP0(NameBase) \
{ #NameBase, NEON::BI__builtin_neon_ ## NameBase, 0, 0, 0 }
#define NEONMAP1(NameBase, LLVMIntrinsic, TypeModifier) \
{ #NameBase, NEON:: BI__builtin_neon_ ## NameBase, \
Intrinsic::LLVMIntrinsic, 0, TypeModifier }
#define NEONMAP2(NameBase, LLVMIntrinsic, AltLLVMIntrinsic, TypeModifier) \
{ #NameBase, NEON:: BI__builtin_neon_ ## NameBase, \
Intrinsic::LLVMIntrinsic, Intrinsic::AltLLVMIntrinsic, \
TypeModifier }
static const ARMVectorIntrinsicInfo ARMSIMDIntrinsicMap [] = {
NEONMAP1(__a32_vcvt_bf16_v, arm_neon_vcvtfp2bf, 0),
NEONMAP0(splat_lane_v),
NEONMAP0(splat_laneq_v),
NEONMAP0(splatq_lane_v),
NEONMAP0(splatq_laneq_v),
NEONMAP2(vabd_v, arm_neon_vabdu, arm_neon_vabds, Add1ArgType | UnsignedAlts),
NEONMAP2(vabdq_v, arm_neon_vabdu, arm_neon_vabds, Add1ArgType | UnsignedAlts),
NEONMAP1(vabs_v, arm_neon_vabs, 0),
NEONMAP1(vabsq_v, arm_neon_vabs, 0),
NEONMAP0(vaddhn_v),
NEONMAP1(vaesdq_v, arm_neon_aesd, 0),
NEONMAP1(vaeseq_v, arm_neon_aese, 0),
NEONMAP1(vaesimcq_v, arm_neon_aesimc, 0),
NEONMAP1(vaesmcq_v, arm_neon_aesmc, 0),
NEONMAP1(vbfdot_v, arm_neon_bfdot, 0),
NEONMAP1(vbfdotq_v, arm_neon_bfdot, 0),
NEONMAP1(vbfmlalbq_v, arm_neon_bfmlalb, 0),
NEONMAP1(vbfmlaltq_v, arm_neon_bfmlalt, 0),
NEONMAP1(vbfmmlaq_v, arm_neon_bfmmla, 0),
NEONMAP1(vbsl_v, arm_neon_vbsl, AddRetType),
NEONMAP1(vbslq_v, arm_neon_vbsl, AddRetType),
NEONMAP1(vcadd_rot270_v, arm_neon_vcadd_rot270, Add1ArgType),
NEONMAP1(vcadd_rot90_v, arm_neon_vcadd_rot90, Add1ArgType),
NEONMAP1(vcaddq_rot270_v, arm_neon_vcadd_rot270, Add1ArgType),
NEONMAP1(vcaddq_rot90_v, arm_neon_vcadd_rot90, Add1ArgType),
NEONMAP1(vcage_v, arm_neon_vacge, 0),
NEONMAP1(vcageq_v, arm_neon_vacge, 0),
NEONMAP1(vcagt_v, arm_neon_vacgt, 0),
NEONMAP1(vcagtq_v, arm_neon_vacgt, 0),
NEONMAP1(vcale_v, arm_neon_vacge, 0),
NEONMAP1(vcaleq_v, arm_neon_vacge, 0),
NEONMAP1(vcalt_v, arm_neon_vacgt, 0),
NEONMAP1(vcaltq_v, arm_neon_vacgt, 0),
NEONMAP0(vceqz_v),
NEONMAP0(vceqzq_v),
NEONMAP0(vcgez_v),
NEONMAP0(vcgezq_v),
NEONMAP0(vcgtz_v),
NEONMAP0(vcgtzq_v),
NEONMAP0(vclez_v),
NEONMAP0(vclezq_v),
NEONMAP1(vcls_v, arm_neon_vcls, Add1ArgType),
NEONMAP1(vclsq_v, arm_neon_vcls, Add1ArgType),
NEONMAP0(vcltz_v),
NEONMAP0(vcltzq_v),
NEONMAP1(vclz_v, ctlz, Add1ArgType),
NEONMAP1(vclzq_v, ctlz, Add1ArgType),
NEONMAP1(vcnt_v, ctpop, Add1ArgType),
NEONMAP1(vcntq_v, ctpop, Add1ArgType),
NEONMAP1(vcvt_f16_f32, arm_neon_vcvtfp2hf, 0),
NEONMAP0(vcvt_f16_v),
NEONMAP1(vcvt_f32_f16, arm_neon_vcvthf2fp, 0),
NEONMAP0(vcvt_f32_v),
NEONMAP2(vcvt_n_f16_v, arm_neon_vcvtfxu2fp, arm_neon_vcvtfxs2fp, 0),
NEONMAP2(vcvt_n_f32_v, arm_neon_vcvtfxu2fp, arm_neon_vcvtfxs2fp, 0),
NEONMAP1(vcvt_n_s16_v, arm_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvt_n_s32_v, arm_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvt_n_s64_v, arm_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvt_n_u16_v, arm_neon_vcvtfp2fxu, 0),
NEONMAP1(vcvt_n_u32_v, arm_neon_vcvtfp2fxu, 0),
NEONMAP1(vcvt_n_u64_v, arm_neon_vcvtfp2fxu, 0),
NEONMAP0(vcvt_s16_v),
NEONMAP0(vcvt_s32_v),
NEONMAP0(vcvt_s64_v),
NEONMAP0(vcvt_u16_v),
NEONMAP0(vcvt_u32_v),
NEONMAP0(vcvt_u64_v),
NEONMAP1(vcvta_s16_v, arm_neon_vcvtas, 0),
NEONMAP1(vcvta_s32_v, arm_neon_vcvtas, 0),
NEONMAP1(vcvta_s64_v, arm_neon_vcvtas, 0),
NEONMAP1(vcvta_u16_v, arm_neon_vcvtau, 0),
NEONMAP1(vcvta_u32_v, arm_neon_vcvtau, 0),
NEONMAP1(vcvta_u64_v, arm_neon_vcvtau, 0),
NEONMAP1(vcvtaq_s16_v, arm_neon_vcvtas, 0),
NEONMAP1(vcvtaq_s32_v, arm_neon_vcvtas, 0),
NEONMAP1(vcvtaq_s64_v, arm_neon_vcvtas, 0),
NEONMAP1(vcvtaq_u16_v, arm_neon_vcvtau, 0),
NEONMAP1(vcvtaq_u32_v, arm_neon_vcvtau, 0),
NEONMAP1(vcvtaq_u64_v, arm_neon_vcvtau, 0),
NEONMAP1(vcvth_bf16_f32, arm_neon_vcvtbfp2bf, 0),
NEONMAP1(vcvtm_s16_v, arm_neon_vcvtms, 0),
NEONMAP1(vcvtm_s32_v, arm_neon_vcvtms, 0),
NEONMAP1(vcvtm_s64_v, arm_neon_vcvtms, 0),
NEONMAP1(vcvtm_u16_v, arm_neon_vcvtmu, 0),
NEONMAP1(vcvtm_u32_v, arm_neon_vcvtmu, 0),
NEONMAP1(vcvtm_u64_v, arm_neon_vcvtmu, 0),
NEONMAP1(vcvtmq_s16_v, arm_neon_vcvtms, 0),
NEONMAP1(vcvtmq_s32_v, arm_neon_vcvtms, 0),
NEONMAP1(vcvtmq_s64_v, arm_neon_vcvtms, 0),
NEONMAP1(vcvtmq_u16_v, arm_neon_vcvtmu, 0),
NEONMAP1(vcvtmq_u32_v, arm_neon_vcvtmu, 0),
NEONMAP1(vcvtmq_u64_v, arm_neon_vcvtmu, 0),
NEONMAP1(vcvtn_s16_v, arm_neon_vcvtns, 0),
NEONMAP1(vcvtn_s32_v, arm_neon_vcvtns, 0),
NEONMAP1(vcvtn_s64_v, arm_neon_vcvtns, 0),
NEONMAP1(vcvtn_u16_v, arm_neon_vcvtnu, 0),
NEONMAP1(vcvtn_u32_v, arm_neon_vcvtnu, 0),
NEONMAP1(vcvtn_u64_v, arm_neon_vcvtnu, 0),
NEONMAP1(vcvtnq_s16_v, arm_neon_vcvtns, 0),
NEONMAP1(vcvtnq_s32_v, arm_neon_vcvtns, 0),
NEONMAP1(vcvtnq_s64_v, arm_neon_vcvtns, 0),
NEONMAP1(vcvtnq_u16_v, arm_neon_vcvtnu, 0),
NEONMAP1(vcvtnq_u32_v, arm_neon_vcvtnu, 0),
NEONMAP1(vcvtnq_u64_v, arm_neon_vcvtnu, 0),
NEONMAP1(vcvtp_s16_v, arm_neon_vcvtps, 0),
NEONMAP1(vcvtp_s32_v, arm_neon_vcvtps, 0),
NEONMAP1(vcvtp_s64_v, arm_neon_vcvtps, 0),
NEONMAP1(vcvtp_u16_v, arm_neon_vcvtpu, 0),
NEONMAP1(vcvtp_u32_v, arm_neon_vcvtpu, 0),
NEONMAP1(vcvtp_u64_v, arm_neon_vcvtpu, 0),
NEONMAP1(vcvtpq_s16_v, arm_neon_vcvtps, 0),
NEONMAP1(vcvtpq_s32_v, arm_neon_vcvtps, 0),
NEONMAP1(vcvtpq_s64_v, arm_neon_vcvtps, 0),
NEONMAP1(vcvtpq_u16_v, arm_neon_vcvtpu, 0),
NEONMAP1(vcvtpq_u32_v, arm_neon_vcvtpu, 0),
NEONMAP1(vcvtpq_u64_v, arm_neon_vcvtpu, 0),
NEONMAP0(vcvtq_f16_v),
NEONMAP0(vcvtq_f32_v),
NEONMAP2(vcvtq_n_f16_v, arm_neon_vcvtfxu2fp, arm_neon_vcvtfxs2fp, 0),
NEONMAP2(vcvtq_n_f32_v, arm_neon_vcvtfxu2fp, arm_neon_vcvtfxs2fp, 0),
NEONMAP1(vcvtq_n_s16_v, arm_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvtq_n_s32_v, arm_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvtq_n_s64_v, arm_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvtq_n_u16_v, arm_neon_vcvtfp2fxu, 0),
NEONMAP1(vcvtq_n_u32_v, arm_neon_vcvtfp2fxu, 0),
NEONMAP1(vcvtq_n_u64_v, arm_neon_vcvtfp2fxu, 0),
NEONMAP0(vcvtq_s16_v),
NEONMAP0(vcvtq_s32_v),
NEONMAP0(vcvtq_s64_v),
NEONMAP0(vcvtq_u16_v),
NEONMAP0(vcvtq_u32_v),
NEONMAP0(vcvtq_u64_v),
NEONMAP2(vdot_v, arm_neon_udot, arm_neon_sdot, 0),
NEONMAP2(vdotq_v, arm_neon_udot, arm_neon_sdot, 0),
NEONMAP0(vext_v),
NEONMAP0(vextq_v),
NEONMAP0(vfma_v),
NEONMAP0(vfmaq_v),
NEONMAP2(vhadd_v, arm_neon_vhaddu, arm_neon_vhadds, Add1ArgType | UnsignedAlts),
NEONMAP2(vhaddq_v, arm_neon_vhaddu, arm_neon_vhadds, Add1ArgType | UnsignedAlts),
NEONMAP2(vhsub_v, arm_neon_vhsubu, arm_neon_vhsubs, Add1ArgType | UnsignedAlts),
NEONMAP2(vhsubq_v, arm_neon_vhsubu, arm_neon_vhsubs, Add1ArgType | UnsignedAlts),
NEONMAP0(vld1_dup_v),
NEONMAP1(vld1_v, arm_neon_vld1, 0),
NEONMAP1(vld1_x2_v, arm_neon_vld1x2, 0),
NEONMAP1(vld1_x3_v, arm_neon_vld1x3, 0),
NEONMAP1(vld1_x4_v, arm_neon_vld1x4, 0),
NEONMAP0(vld1q_dup_v),
NEONMAP1(vld1q_v, arm_neon_vld1, 0),
NEONMAP1(vld1q_x2_v, arm_neon_vld1x2, 0),
NEONMAP1(vld1q_x3_v, arm_neon_vld1x3, 0),
NEONMAP1(vld1q_x4_v, arm_neon_vld1x4, 0),
NEONMAP1(vld2_dup_v, arm_neon_vld2dup, 0),
NEONMAP1(vld2_lane_v, arm_neon_vld2lane, 0),
NEONMAP1(vld2_v, arm_neon_vld2, 0),
NEONMAP1(vld2q_dup_v, arm_neon_vld2dup, 0),
NEONMAP1(vld2q_lane_v, arm_neon_vld2lane, 0),
NEONMAP1(vld2q_v, arm_neon_vld2, 0),
NEONMAP1(vld3_dup_v, arm_neon_vld3dup, 0),
NEONMAP1(vld3_lane_v, arm_neon_vld3lane, 0),
NEONMAP1(vld3_v, arm_neon_vld3, 0),
NEONMAP1(vld3q_dup_v, arm_neon_vld3dup, 0),
NEONMAP1(vld3q_lane_v, arm_neon_vld3lane, 0),
NEONMAP1(vld3q_v, arm_neon_vld3, 0),
NEONMAP1(vld4_dup_v, arm_neon_vld4dup, 0),
NEONMAP1(vld4_lane_v, arm_neon_vld4lane, 0),
NEONMAP1(vld4_v, arm_neon_vld4, 0),
NEONMAP1(vld4q_dup_v, arm_neon_vld4dup, 0),
NEONMAP1(vld4q_lane_v, arm_neon_vld4lane, 0),
NEONMAP1(vld4q_v, arm_neon_vld4, 0),
NEONMAP2(vmax_v, arm_neon_vmaxu, arm_neon_vmaxs, Add1ArgType | UnsignedAlts),
NEONMAP1(vmaxnm_v, arm_neon_vmaxnm, Add1ArgType),
NEONMAP1(vmaxnmq_v, arm_neon_vmaxnm, Add1ArgType),
NEONMAP2(vmaxq_v, arm_neon_vmaxu, arm_neon_vmaxs, Add1ArgType | UnsignedAlts),
NEONMAP2(vmin_v, arm_neon_vminu, arm_neon_vmins, Add1ArgType | UnsignedAlts),
NEONMAP1(vminnm_v, arm_neon_vminnm, Add1ArgType),
NEONMAP1(vminnmq_v, arm_neon_vminnm, Add1ArgType),
NEONMAP2(vminq_v, arm_neon_vminu, arm_neon_vmins, Add1ArgType | UnsignedAlts),
NEONMAP2(vmmlaq_v, arm_neon_ummla, arm_neon_smmla, 0),
NEONMAP0(vmovl_v),
NEONMAP0(vmovn_v),
NEONMAP1(vmul_v, arm_neon_vmulp, Add1ArgType),
NEONMAP0(vmull_v),
NEONMAP1(vmulq_v, arm_neon_vmulp, Add1ArgType),
NEONMAP2(vpadal_v, arm_neon_vpadalu, arm_neon_vpadals, UnsignedAlts),
NEONMAP2(vpadalq_v, arm_neon_vpadalu, arm_neon_vpadals, UnsignedAlts),
NEONMAP1(vpadd_v, arm_neon_vpadd, Add1ArgType),
NEONMAP2(vpaddl_v, arm_neon_vpaddlu, arm_neon_vpaddls, UnsignedAlts),
NEONMAP2(vpaddlq_v, arm_neon_vpaddlu, arm_neon_vpaddls, UnsignedAlts),
NEONMAP1(vpaddq_v, arm_neon_vpadd, Add1ArgType),
NEONMAP2(vpmax_v, arm_neon_vpmaxu, arm_neon_vpmaxs, Add1ArgType | UnsignedAlts),
NEONMAP2(vpmin_v, arm_neon_vpminu, arm_neon_vpmins, Add1ArgType | UnsignedAlts),
NEONMAP1(vqabs_v, arm_neon_vqabs, Add1ArgType),
NEONMAP1(vqabsq_v, arm_neon_vqabs, Add1ArgType),
NEONMAP2(vqadd_v, uadd_sat, sadd_sat, Add1ArgType | UnsignedAlts),
NEONMAP2(vqaddq_v, uadd_sat, sadd_sat, Add1ArgType | UnsignedAlts),
NEONMAP2(vqdmlal_v, arm_neon_vqdmull, sadd_sat, 0),
NEONMAP2(vqdmlsl_v, arm_neon_vqdmull, ssub_sat, 0),
NEONMAP1(vqdmulh_v, arm_neon_vqdmulh, Add1ArgType),
NEONMAP1(vqdmulhq_v, arm_neon_vqdmulh, Add1ArgType),
NEONMAP1(vqdmull_v, arm_neon_vqdmull, Add1ArgType),
NEONMAP2(vqmovn_v, arm_neon_vqmovnu, arm_neon_vqmovns, Add1ArgType | UnsignedAlts),
NEONMAP1(vqmovun_v, arm_neon_vqmovnsu, Add1ArgType),
NEONMAP1(vqneg_v, arm_neon_vqneg, Add1ArgType),
NEONMAP1(vqnegq_v, arm_neon_vqneg, Add1ArgType),
NEONMAP1(vqrdmulh_v, arm_neon_vqrdmulh, Add1ArgType),
NEONMAP1(vqrdmulhq_v, arm_neon_vqrdmulh, Add1ArgType),
NEONMAP2(vqrshl_v, arm_neon_vqrshiftu, arm_neon_vqrshifts, Add1ArgType | UnsignedAlts),
NEONMAP2(vqrshlq_v, arm_neon_vqrshiftu, arm_neon_vqrshifts, Add1ArgType | UnsignedAlts),
NEONMAP2(vqshl_n_v, arm_neon_vqshiftu, arm_neon_vqshifts, UnsignedAlts),
NEONMAP2(vqshl_v, arm_neon_vqshiftu, arm_neon_vqshifts, Add1ArgType | UnsignedAlts),
NEONMAP2(vqshlq_n_v, arm_neon_vqshiftu, arm_neon_vqshifts, UnsignedAlts),
NEONMAP2(vqshlq_v, arm_neon_vqshiftu, arm_neon_vqshifts, Add1ArgType | UnsignedAlts),
NEONMAP1(vqshlu_n_v, arm_neon_vqshiftsu, 0),
NEONMAP1(vqshluq_n_v, arm_neon_vqshiftsu, 0),
NEONMAP2(vqsub_v, usub_sat, ssub_sat, Add1ArgType | UnsignedAlts),
NEONMAP2(vqsubq_v, usub_sat, ssub_sat, Add1ArgType | UnsignedAlts),
NEONMAP1(vraddhn_v, arm_neon_vraddhn, Add1ArgType),
NEONMAP2(vrecpe_v, arm_neon_vrecpe, arm_neon_vrecpe, 0),
NEONMAP2(vrecpeq_v, arm_neon_vrecpe, arm_neon_vrecpe, 0),
NEONMAP1(vrecps_v, arm_neon_vrecps, Add1ArgType),
NEONMAP1(vrecpsq_v, arm_neon_vrecps, Add1ArgType),
NEONMAP2(vrhadd_v, arm_neon_vrhaddu, arm_neon_vrhadds, Add1ArgType | UnsignedAlts),
NEONMAP2(vrhaddq_v, arm_neon_vrhaddu, arm_neon_vrhadds, Add1ArgType | UnsignedAlts),
NEONMAP1(vrnd_v, arm_neon_vrintz, Add1ArgType),
NEONMAP1(vrnda_v, arm_neon_vrinta, Add1ArgType),
NEONMAP1(vrndaq_v, arm_neon_vrinta, Add1ArgType),
NEONMAP0(vrndi_v),
NEONMAP0(vrndiq_v),
NEONMAP1(vrndm_v, arm_neon_vrintm, Add1ArgType),
NEONMAP1(vrndmq_v, arm_neon_vrintm, Add1ArgType),
NEONMAP1(vrndn_v, arm_neon_vrintn, Add1ArgType),
NEONMAP1(vrndnq_v, arm_neon_vrintn, Add1ArgType),
NEONMAP1(vrndp_v, arm_neon_vrintp, Add1ArgType),
NEONMAP1(vrndpq_v, arm_neon_vrintp, Add1ArgType),
NEONMAP1(vrndq_v, arm_neon_vrintz, Add1ArgType),
NEONMAP1(vrndx_v, arm_neon_vrintx, Add1ArgType),
NEONMAP1(vrndxq_v, arm_neon_vrintx, Add1ArgType),
NEONMAP2(vrshl_v, arm_neon_vrshiftu, arm_neon_vrshifts, Add1ArgType | UnsignedAlts),
NEONMAP2(vrshlq_v, arm_neon_vrshiftu, arm_neon_vrshifts, Add1ArgType | UnsignedAlts),
NEONMAP2(vrshr_n_v, arm_neon_vrshiftu, arm_neon_vrshifts, UnsignedAlts),
NEONMAP2(vrshrq_n_v, arm_neon_vrshiftu, arm_neon_vrshifts, UnsignedAlts),
NEONMAP2(vrsqrte_v, arm_neon_vrsqrte, arm_neon_vrsqrte, 0),
NEONMAP2(vrsqrteq_v, arm_neon_vrsqrte, arm_neon_vrsqrte, 0),
NEONMAP1(vrsqrts_v, arm_neon_vrsqrts, Add1ArgType),
NEONMAP1(vrsqrtsq_v, arm_neon_vrsqrts, Add1ArgType),
NEONMAP1(vrsubhn_v, arm_neon_vrsubhn, Add1ArgType),
NEONMAP1(vsha1su0q_v, arm_neon_sha1su0, 0),
NEONMAP1(vsha1su1q_v, arm_neon_sha1su1, 0),
NEONMAP1(vsha256h2q_v, arm_neon_sha256h2, 0),
NEONMAP1(vsha256hq_v, arm_neon_sha256h, 0),
NEONMAP1(vsha256su0q_v, arm_neon_sha256su0, 0),
NEONMAP1(vsha256su1q_v, arm_neon_sha256su1, 0),
NEONMAP0(vshl_n_v),
NEONMAP2(vshl_v, arm_neon_vshiftu, arm_neon_vshifts, Add1ArgType | UnsignedAlts),
NEONMAP0(vshll_n_v),
NEONMAP0(vshlq_n_v),
NEONMAP2(vshlq_v, arm_neon_vshiftu, arm_neon_vshifts, Add1ArgType | UnsignedAlts),
NEONMAP0(vshr_n_v),
NEONMAP0(vshrn_n_v),
NEONMAP0(vshrq_n_v),
NEONMAP1(vst1_v, arm_neon_vst1, 0),
NEONMAP1(vst1_x2_v, arm_neon_vst1x2, 0),
NEONMAP1(vst1_x3_v, arm_neon_vst1x3, 0),
NEONMAP1(vst1_x4_v, arm_neon_vst1x4, 0),
NEONMAP1(vst1q_v, arm_neon_vst1, 0),
NEONMAP1(vst1q_x2_v, arm_neon_vst1x2, 0),
NEONMAP1(vst1q_x3_v, arm_neon_vst1x3, 0),
NEONMAP1(vst1q_x4_v, arm_neon_vst1x4, 0),
NEONMAP1(vst2_lane_v, arm_neon_vst2lane, 0),
NEONMAP1(vst2_v, arm_neon_vst2, 0),
NEONMAP1(vst2q_lane_v, arm_neon_vst2lane, 0),
NEONMAP1(vst2q_v, arm_neon_vst2, 0),
NEONMAP1(vst3_lane_v, arm_neon_vst3lane, 0),
NEONMAP1(vst3_v, arm_neon_vst3, 0),
NEONMAP1(vst3q_lane_v, arm_neon_vst3lane, 0),
NEONMAP1(vst3q_v, arm_neon_vst3, 0),
NEONMAP1(vst4_lane_v, arm_neon_vst4lane, 0),
NEONMAP1(vst4_v, arm_neon_vst4, 0),
NEONMAP1(vst4q_lane_v, arm_neon_vst4lane, 0),
NEONMAP1(vst4q_v, arm_neon_vst4, 0),
NEONMAP0(vsubhn_v),
NEONMAP0(vtrn_v),
NEONMAP0(vtrnq_v),
NEONMAP0(vtst_v),
NEONMAP0(vtstq_v),
NEONMAP1(vusdot_v, arm_neon_usdot, 0),
NEONMAP1(vusdotq_v, arm_neon_usdot, 0),
NEONMAP1(vusmmlaq_v, arm_neon_usmmla, 0),
NEONMAP0(vuzp_v),
NEONMAP0(vuzpq_v),
NEONMAP0(vzip_v),
NEONMAP0(vzipq_v)
};
static const ARMVectorIntrinsicInfo AArch64SIMDIntrinsicMap[] = {
NEONMAP1(__a64_vcvtq_low_bf16_v, aarch64_neon_bfcvtn, 0),
NEONMAP0(splat_lane_v),
NEONMAP0(splat_laneq_v),
NEONMAP0(splatq_lane_v),
NEONMAP0(splatq_laneq_v),
NEONMAP1(vabs_v, aarch64_neon_abs, 0),
NEONMAP1(vabsq_v, aarch64_neon_abs, 0),
NEONMAP0(vaddhn_v),
NEONMAP1(vaesdq_v, aarch64_crypto_aesd, 0),
NEONMAP1(vaeseq_v, aarch64_crypto_aese, 0),
NEONMAP1(vaesimcq_v, aarch64_crypto_aesimc, 0),
NEONMAP1(vaesmcq_v, aarch64_crypto_aesmc, 0),
NEONMAP1(vbfdot_v, aarch64_neon_bfdot, 0),
NEONMAP1(vbfdotq_v, aarch64_neon_bfdot, 0),
NEONMAP1(vbfmlalbq_v, aarch64_neon_bfmlalb, 0),
NEONMAP1(vbfmlaltq_v, aarch64_neon_bfmlalt, 0),
NEONMAP1(vbfmmlaq_v, aarch64_neon_bfmmla, 0),
NEONMAP1(vcadd_rot270_v, aarch64_neon_vcadd_rot270, Add1ArgType),
NEONMAP1(vcadd_rot90_v, aarch64_neon_vcadd_rot90, Add1ArgType),
NEONMAP1(vcaddq_rot270_v, aarch64_neon_vcadd_rot270, Add1ArgType),
NEONMAP1(vcaddq_rot90_v, aarch64_neon_vcadd_rot90, Add1ArgType),
NEONMAP1(vcage_v, aarch64_neon_facge, 0),
NEONMAP1(vcageq_v, aarch64_neon_facge, 0),
NEONMAP1(vcagt_v, aarch64_neon_facgt, 0),
NEONMAP1(vcagtq_v, aarch64_neon_facgt, 0),
NEONMAP1(vcale_v, aarch64_neon_facge, 0),
NEONMAP1(vcaleq_v, aarch64_neon_facge, 0),
NEONMAP1(vcalt_v, aarch64_neon_facgt, 0),
NEONMAP1(vcaltq_v, aarch64_neon_facgt, 0),
NEONMAP0(vceqz_v),
NEONMAP0(vceqzq_v),
NEONMAP0(vcgez_v),
NEONMAP0(vcgezq_v),
NEONMAP0(vcgtz_v),
NEONMAP0(vcgtzq_v),
NEONMAP0(vclez_v),
NEONMAP0(vclezq_v),
NEONMAP1(vcls_v, aarch64_neon_cls, Add1ArgType),
NEONMAP1(vclsq_v, aarch64_neon_cls, Add1ArgType),
NEONMAP0(vcltz_v),
NEONMAP0(vcltzq_v),
NEONMAP1(vclz_v, ctlz, Add1ArgType),
NEONMAP1(vclzq_v, ctlz, Add1ArgType),
NEONMAP1(vcmla_rot180_v, aarch64_neon_vcmla_rot180, Add1ArgType),
NEONMAP1(vcmla_rot270_v, aarch64_neon_vcmla_rot270, Add1ArgType),
NEONMAP1(vcmla_rot90_v, aarch64_neon_vcmla_rot90, Add1ArgType),
NEONMAP1(vcmla_v, aarch64_neon_vcmla_rot0, Add1ArgType),
NEONMAP1(vcmlaq_rot180_v, aarch64_neon_vcmla_rot180, Add1ArgType),
NEONMAP1(vcmlaq_rot270_v, aarch64_neon_vcmla_rot270, Add1ArgType),
NEONMAP1(vcmlaq_rot90_v, aarch64_neon_vcmla_rot90, Add1ArgType),
NEONMAP1(vcmlaq_v, aarch64_neon_vcmla_rot0, Add1ArgType),
NEONMAP1(vcnt_v, ctpop, Add1ArgType),
NEONMAP1(vcntq_v, ctpop, Add1ArgType),
NEONMAP1(vcvt_f16_f32, aarch64_neon_vcvtfp2hf, 0),
NEONMAP0(vcvt_f16_v),
NEONMAP1(vcvt_f32_f16, aarch64_neon_vcvthf2fp, 0),
NEONMAP0(vcvt_f32_v),
NEONMAP2(vcvt_n_f16_v, aarch64_neon_vcvtfxu2fp, aarch64_neon_vcvtfxs2fp, 0),
NEONMAP2(vcvt_n_f32_v, aarch64_neon_vcvtfxu2fp, aarch64_neon_vcvtfxs2fp, 0),
NEONMAP2(vcvt_n_f64_v, aarch64_neon_vcvtfxu2fp, aarch64_neon_vcvtfxs2fp, 0),
NEONMAP1(vcvt_n_s16_v, aarch64_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvt_n_s32_v, aarch64_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvt_n_s64_v, aarch64_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvt_n_u16_v, aarch64_neon_vcvtfp2fxu, 0),
NEONMAP1(vcvt_n_u32_v, aarch64_neon_vcvtfp2fxu, 0),
NEONMAP1(vcvt_n_u64_v, aarch64_neon_vcvtfp2fxu, 0),
NEONMAP0(vcvtq_f16_v),
NEONMAP0(vcvtq_f32_v),
NEONMAP1(vcvtq_high_bf16_v, aarch64_neon_bfcvtn2, 0),
NEONMAP2(vcvtq_n_f16_v, aarch64_neon_vcvtfxu2fp, aarch64_neon_vcvtfxs2fp, 0),
NEONMAP2(vcvtq_n_f32_v, aarch64_neon_vcvtfxu2fp, aarch64_neon_vcvtfxs2fp, 0),
NEONMAP2(vcvtq_n_f64_v, aarch64_neon_vcvtfxu2fp, aarch64_neon_vcvtfxs2fp, 0),
NEONMAP1(vcvtq_n_s16_v, aarch64_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvtq_n_s32_v, aarch64_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvtq_n_s64_v, aarch64_neon_vcvtfp2fxs, 0),
NEONMAP1(vcvtq_n_u16_v, aarch64_neon_vcvtfp2fxu, 0),
NEONMAP1(vcvtq_n_u32_v, aarch64_neon_vcvtfp2fxu, 0),
NEONMAP1(vcvtq_n_u64_v, aarch64_neon_vcvtfp2fxu, 0),
NEONMAP1(vcvtx_f32_v, aarch64_neon_fcvtxn, AddRetType | Add1ArgType),
NEONMAP2(vdot_v, aarch64_neon_udot, aarch64_neon_sdot, 0),
NEONMAP2(vdotq_v, aarch64_neon_udot, aarch64_neon_sdot, 0),
NEONMAP0(vext_v),
NEONMAP0(vextq_v),
NEONMAP0(vfma_v),
NEONMAP0(vfmaq_v),
NEONMAP1(vfmlal_high_v, aarch64_neon_fmlal2, 0),
NEONMAP1(vfmlal_low_v, aarch64_neon_fmlal, 0),
NEONMAP1(vfmlalq_high_v, aarch64_neon_fmlal2, 0),
NEONMAP1(vfmlalq_low_v, aarch64_neon_fmlal, 0),
NEONMAP1(vfmlsl_high_v, aarch64_neon_fmlsl2, 0),
NEONMAP1(vfmlsl_low_v, aarch64_neon_fmlsl, 0),
NEONMAP1(vfmlslq_high_v, aarch64_neon_fmlsl2, 0),
NEONMAP1(vfmlslq_low_v, aarch64_neon_fmlsl, 0),
NEONMAP2(vhadd_v, aarch64_neon_uhadd, aarch64_neon_shadd, Add1ArgType | UnsignedAlts),
NEONMAP2(vhaddq_v, aarch64_neon_uhadd, aarch64_neon_shadd, Add1ArgType | UnsignedAlts),
NEONMAP2(vhsub_v, aarch64_neon_uhsub, aarch64_neon_shsub, Add1ArgType | UnsignedAlts),
NEONMAP2(vhsubq_v, aarch64_neon_uhsub, aarch64_neon_shsub, Add1ArgType | UnsignedAlts),
NEONMAP1(vld1_x2_v, aarch64_neon_ld1x2, 0),
NEONMAP1(vld1_x3_v, aarch64_neon_ld1x3, 0),
NEONMAP1(vld1_x4_v, aarch64_neon_ld1x4, 0),
NEONMAP1(vld1q_x2_v, aarch64_neon_ld1x2, 0),
NEONMAP1(vld1q_x3_v, aarch64_neon_ld1x3, 0),
NEONMAP1(vld1q_x4_v, aarch64_neon_ld1x4, 0),
NEONMAP2(vmmlaq_v, aarch64_neon_ummla, aarch64_neon_smmla, 0),
NEONMAP0(vmovl_v),
NEONMAP0(vmovn_v),
NEONMAP1(vmul_v, aarch64_neon_pmul, Add1ArgType),
NEONMAP1(vmulq_v, aarch64_neon_pmul, Add1ArgType),
NEONMAP1(vpadd_v, aarch64_neon_addp, Add1ArgType),
NEONMAP2(vpaddl_v, aarch64_neon_uaddlp, aarch64_neon_saddlp, UnsignedAlts),
NEONMAP2(vpaddlq_v, aarch64_neon_uaddlp, aarch64_neon_saddlp, UnsignedAlts),
NEONMAP1(vpaddq_v, aarch64_neon_addp, Add1ArgType),
NEONMAP1(vqabs_v, aarch64_neon_sqabs, Add1ArgType),
NEONMAP1(vqabsq_v, aarch64_neon_sqabs, Add1ArgType),
NEONMAP2(vqadd_v, aarch64_neon_uqadd, aarch64_neon_sqadd, Add1ArgType | UnsignedAlts),
NEONMAP2(vqaddq_v, aarch64_neon_uqadd, aarch64_neon_sqadd, Add1ArgType | UnsignedAlts),
NEONMAP2(vqdmlal_v, aarch64_neon_sqdmull, aarch64_neon_sqadd, 0),
NEONMAP2(vqdmlsl_v, aarch64_neon_sqdmull, aarch64_neon_sqsub, 0),
NEONMAP1(vqdmulh_lane_v, aarch64_neon_sqdmulh_lane, 0),
NEONMAP1(vqdmulh_laneq_v, aarch64_neon_sqdmulh_laneq, 0),
NEONMAP1(vqdmulh_v, aarch64_neon_sqdmulh, Add1ArgType),
NEONMAP1(vqdmulhq_lane_v, aarch64_neon_sqdmulh_lane, 0),
NEONMAP1(vqdmulhq_laneq_v, aarch64_neon_sqdmulh_laneq, 0),
NEONMAP1(vqdmulhq_v, aarch64_neon_sqdmulh, Add1ArgType),
NEONMAP1(vqdmull_v, aarch64_neon_sqdmull, Add1ArgType),
NEONMAP2(vqmovn_v, aarch64_neon_uqxtn, aarch64_neon_sqxtn, Add1ArgType | UnsignedAlts),
NEONMAP1(vqmovun_v, aarch64_neon_sqxtun, Add1ArgType),
NEONMAP1(vqneg_v, aarch64_neon_sqneg, Add1ArgType),
NEONMAP1(vqnegq_v, aarch64_neon_sqneg, Add1ArgType),
NEONMAP1(vqrdmulh_lane_v, aarch64_neon_sqrdmulh_lane, 0),
NEONMAP1(vqrdmulh_laneq_v, aarch64_neon_sqrdmulh_laneq, 0),
NEONMAP1(vqrdmulh_v, aarch64_neon_sqrdmulh, Add1ArgType),
NEONMAP1(vqrdmulhq_lane_v, aarch64_neon_sqrdmulh_lane, 0),
NEONMAP1(vqrdmulhq_laneq_v, aarch64_neon_sqrdmulh_laneq, 0),
NEONMAP1(vqrdmulhq_v, aarch64_neon_sqrdmulh, Add1ArgType),
NEONMAP2(vqrshl_v, aarch64_neon_uqrshl, aarch64_neon_sqrshl, Add1ArgType | UnsignedAlts),
NEONMAP2(vqrshlq_v, aarch64_neon_uqrshl, aarch64_neon_sqrshl, Add1ArgType | UnsignedAlts),
NEONMAP2(vqshl_n_v, aarch64_neon_uqshl, aarch64_neon_sqshl, UnsignedAlts),
NEONMAP2(vqshl_v, aarch64_neon_uqshl, aarch64_neon_sqshl, Add1ArgType | UnsignedAlts),
NEONMAP2(vqshlq_n_v, aarch64_neon_uqshl, aarch64_neon_sqshl,UnsignedAlts),
NEONMAP2(vqshlq_v, aarch64_neon_uqshl, aarch64_neon_sqshl, Add1ArgType | UnsignedAlts),
NEONMAP1(vqshlu_n_v, aarch64_neon_sqshlu, 0),
NEONMAP1(vqshluq_n_v, aarch64_neon_sqshlu, 0),
NEONMAP2(vqsub_v, aarch64_neon_uqsub, aarch64_neon_sqsub, Add1ArgType | UnsignedAlts),
NEONMAP2(vqsubq_v, aarch64_neon_uqsub, aarch64_neon_sqsub, Add1ArgType | UnsignedAlts),
NEONMAP1(vraddhn_v, aarch64_neon_raddhn, Add1ArgType),
NEONMAP2(vrecpe_v, aarch64_neon_frecpe, aarch64_neon_urecpe, 0),
NEONMAP2(vrecpeq_v, aarch64_neon_frecpe, aarch64_neon_urecpe, 0),
NEONMAP1(vrecps_v, aarch64_neon_frecps, Add1ArgType),
NEONMAP1(vrecpsq_v, aarch64_neon_frecps, Add1ArgType),
NEONMAP2(vrhadd_v, aarch64_neon_urhadd, aarch64_neon_srhadd, Add1ArgType | UnsignedAlts),
NEONMAP2(vrhaddq_v, aarch64_neon_urhadd, aarch64_neon_srhadd, Add1ArgType | UnsignedAlts),
NEONMAP0(vrndi_v),
NEONMAP0(vrndiq_v),
NEONMAP2(vrshl_v, aarch64_neon_urshl, aarch64_neon_srshl, Add1ArgType | UnsignedAlts),
NEONMAP2(vrshlq_v, aarch64_neon_urshl, aarch64_neon_srshl, Add1ArgType | UnsignedAlts),
NEONMAP2(vrshr_n_v, aarch64_neon_urshl, aarch64_neon_srshl, UnsignedAlts),
NEONMAP2(vrshrq_n_v, aarch64_neon_urshl, aarch64_neon_srshl, UnsignedAlts),
NEONMAP2(vrsqrte_v, aarch64_neon_frsqrte, aarch64_neon_ursqrte, 0),
NEONMAP2(vrsqrteq_v, aarch64_neon_frsqrte, aarch64_neon_ursqrte, 0),
NEONMAP1(vrsqrts_v, aarch64_neon_frsqrts, Add1ArgType),
NEONMAP1(vrsqrtsq_v, aarch64_neon_frsqrts, Add1ArgType),
NEONMAP1(vrsubhn_v, aarch64_neon_rsubhn, Add1ArgType),
NEONMAP1(vsha1su0q_v, aarch64_crypto_sha1su0, 0),
NEONMAP1(vsha1su1q_v, aarch64_crypto_sha1su1, 0),
NEONMAP1(vsha256h2q_v, aarch64_crypto_sha256h2, 0),
NEONMAP1(vsha256hq_v, aarch64_crypto_sha256h, 0),
NEONMAP1(vsha256su0q_v, aarch64_crypto_sha256su0, 0),
NEONMAP1(vsha256su1q_v, aarch64_crypto_sha256su1, 0),
NEONMAP0(vshl_n_v),
NEONMAP2(vshl_v, aarch64_neon_ushl, aarch64_neon_sshl, Add1ArgType | UnsignedAlts),
NEONMAP0(vshll_n_v),
NEONMAP0(vshlq_n_v),
NEONMAP2(vshlq_v, aarch64_neon_ushl, aarch64_neon_sshl, Add1ArgType | UnsignedAlts),
NEONMAP0(vshr_n_v),
NEONMAP0(vshrn_n_v),
NEONMAP0(vshrq_n_v),
NEONMAP1(vst1_x2_v, aarch64_neon_st1x2, 0),
NEONMAP1(vst1_x3_v, aarch64_neon_st1x3, 0),
NEONMAP1(vst1_x4_v, aarch64_neon_st1x4, 0),
NEONMAP1(vst1q_x2_v, aarch64_neon_st1x2, 0),
NEONMAP1(vst1q_x3_v, aarch64_neon_st1x3, 0),
NEONMAP1(vst1q_x4_v, aarch64_neon_st1x4, 0),
NEONMAP0(vsubhn_v),
NEONMAP0(vtst_v),
NEONMAP0(vtstq_v),
NEONMAP1(vusdot_v, aarch64_neon_usdot, 0),
NEONMAP1(vusdotq_v, aarch64_neon_usdot, 0),
NEONMAP1(vusmmlaq_v, aarch64_neon_usmmla, 0),
};
static const ARMVectorIntrinsicInfo AArch64SISDIntrinsicMap[] = {
NEONMAP1(vabdd_f64, aarch64_sisd_fabd, Add1ArgType),
NEONMAP1(vabds_f32, aarch64_sisd_fabd, Add1ArgType),
NEONMAP1(vabsd_s64, aarch64_neon_abs, Add1ArgType),
NEONMAP1(vaddlv_s32, aarch64_neon_saddlv, AddRetType | Add1ArgType),
NEONMAP1(vaddlv_u32, aarch64_neon_uaddlv, AddRetType | Add1ArgType),
NEONMAP1(vaddlvq_s32, aarch64_neon_saddlv, AddRetType | Add1ArgType),
NEONMAP1(vaddlvq_u32, aarch64_neon_uaddlv, AddRetType | Add1ArgType),
NEONMAP1(vaddv_f32, aarch64_neon_faddv, AddRetType | Add1ArgType),
NEONMAP1(vaddv_s32, aarch64_neon_saddv, AddRetType | Add1ArgType),
NEONMAP1(vaddv_u32, aarch64_neon_uaddv, AddRetType | Add1ArgType),
NEONMAP1(vaddvq_f32, aarch64_neon_faddv, AddRetType | Add1ArgType),
NEONMAP1(vaddvq_f64, aarch64_neon_faddv, AddRetType | Add1ArgType),
NEONMAP1(vaddvq_s32, aarch64_neon_saddv, AddRetType | Add1ArgType),
NEONMAP1(vaddvq_s64, aarch64_neon_saddv, AddRetType | Add1ArgType),
NEONMAP1(vaddvq_u32, aarch64_neon_uaddv, AddRetType | Add1ArgType),
NEONMAP1(vaddvq_u64, aarch64_neon_uaddv, AddRetType | Add1ArgType),
NEONMAP1(vcaged_f64, aarch64_neon_facge, AddRetType | Add1ArgType),
NEONMAP1(vcages_f32, aarch64_neon_facge, AddRetType | Add1ArgType),
NEONMAP1(vcagtd_f64, aarch64_neon_facgt, AddRetType | Add1ArgType),
NEONMAP1(vcagts_f32, aarch64_neon_facgt, AddRetType | Add1ArgType),
NEONMAP1(vcaled_f64, aarch64_neon_facge, AddRetType | Add1ArgType),
NEONMAP1(vcales_f32, aarch64_neon_facge, AddRetType | Add1ArgType),
NEONMAP1(vcaltd_f64, aarch64_neon_facgt, AddRetType | Add1ArgType),
NEONMAP1(vcalts_f32, aarch64_neon_facgt, AddRetType | Add1ArgType),
NEONMAP1(vcvtad_s64_f64, aarch64_neon_fcvtas, AddRetType | Add1ArgType),
NEONMAP1(vcvtad_u64_f64, aarch64_neon_fcvtau, AddRetType | Add1ArgType),
NEONMAP1(vcvtas_s32_f32, aarch64_neon_fcvtas, AddRetType | Add1ArgType),
NEONMAP1(vcvtas_u32_f32, aarch64_neon_fcvtau, AddRetType | Add1ArgType),
NEONMAP1(vcvtd_n_f64_s64, aarch64_neon_vcvtfxs2fp, AddRetType | Add1ArgType),
NEONMAP1(vcvtd_n_f64_u64, aarch64_neon_vcvtfxu2fp, AddRetType | Add1ArgType),
NEONMAP1(vcvtd_n_s64_f64, aarch64_neon_vcvtfp2fxs, AddRetType | Add1ArgType),
NEONMAP1(vcvtd_n_u64_f64, aarch64_neon_vcvtfp2fxu, AddRetType | Add1ArgType),
NEONMAP1(vcvtd_s64_f64, aarch64_neon_fcvtzs, AddRetType | Add1ArgType),
NEONMAP1(vcvtd_u64_f64, aarch64_neon_fcvtzu, AddRetType | Add1ArgType),
NEONMAP1(vcvth_bf16_f32, aarch64_neon_bfcvt, 0),
NEONMAP1(vcvtmd_s64_f64, aarch64_neon_fcvtms, AddRetType | Add1ArgType),
NEONMAP1(vcvtmd_u64_f64, aarch64_neon_fcvtmu, AddRetType | Add1ArgType),
NEONMAP1(vcvtms_s32_f32, aarch64_neon_fcvtms, AddRetType | Add1ArgType),
NEONMAP1(vcvtms_u32_f32, aarch64_neon_fcvtmu, AddRetType | Add1ArgType),
NEONMAP1(vcvtnd_s64_f64, aarch64_neon_fcvtns, AddRetType | Add1ArgType),
NEONMAP1(vcvtnd_u64_f64, aarch64_neon_fcvtnu, AddRetType | Add1ArgType),
NEONMAP1(vcvtns_s32_f32, aarch64_neon_fcvtns, AddRetType | Add1ArgType),
NEONMAP1(vcvtns_u32_f32, aarch64_neon_fcvtnu, AddRetType | Add1ArgType),
NEONMAP1(vcvtpd_s64_f64, aarch64_neon_fcvtps, AddRetType | Add1ArgType),
NEONMAP1(vcvtpd_u64_f64, aarch64_neon_fcvtpu, AddRetType | Add1ArgType),
NEONMAP1(vcvtps_s32_f32, aarch64_neon_fcvtps, AddRetType | Add1ArgType),
NEONMAP1(vcvtps_u32_f32, aarch64_neon_fcvtpu, AddRetType | Add1ArgType),
NEONMAP1(vcvts_n_f32_s32, aarch64_neon_vcvtfxs2fp, AddRetType | Add1ArgType),
NEONMAP1(vcvts_n_f32_u32, aarch64_neon_vcvtfxu2fp, AddRetType | Add1ArgType),
NEONMAP1(vcvts_n_s32_f32, aarch64_neon_vcvtfp2fxs, AddRetType | Add1ArgType),
NEONMAP1(vcvts_n_u32_f32, aarch64_neon_vcvtfp2fxu, AddRetType | Add1ArgType),
NEONMAP1(vcvts_s32_f32, aarch64_neon_fcvtzs, AddRetType | Add1ArgType),
NEONMAP1(vcvts_u32_f32, aarch64_neon_fcvtzu, AddRetType | Add1ArgType),
NEONMAP1(vcvtxd_f32_f64, aarch64_sisd_fcvtxn, 0),
NEONMAP1(vmaxnmv_f32, aarch64_neon_fmaxnmv, AddRetType | Add1ArgType),
NEONMAP1(vmaxnmvq_f32, aarch64_neon_fmaxnmv, AddRetType | Add1ArgType),
NEONMAP1(vmaxnmvq_f64, aarch64_neon_fmaxnmv, AddRetType | Add1ArgType),
NEONMAP1(vmaxv_f32, aarch64_neon_fmaxv, AddRetType | Add1ArgType),
NEONMAP1(vmaxv_s32, aarch64_neon_smaxv, AddRetType | Add1ArgType),
NEONMAP1(vmaxv_u32, aarch64_neon_umaxv, AddRetType | Add1ArgType),
NEONMAP1(vmaxvq_f32, aarch64_neon_fmaxv, AddRetType | Add1ArgType),
NEONMAP1(vmaxvq_f64, aarch64_neon_fmaxv, AddRetType | Add1ArgType),
NEONMAP1(vmaxvq_s32, aarch64_neon_smaxv, AddRetType | Add1ArgType),
NEONMAP1(vmaxvq_u32, aarch64_neon_umaxv, AddRetType | Add1ArgType),
NEONMAP1(vminnmv_f32, aarch64_neon_fminnmv, AddRetType | Add1ArgType),
NEONMAP1(vminnmvq_f32, aarch64_neon_fminnmv, AddRetType | Add1ArgType),
NEONMAP1(vminnmvq_f64, aarch64_neon_fminnmv, AddRetType | Add1ArgType),
NEONMAP1(vminv_f32, aarch64_neon_fminv, AddRetType | Add1ArgType),
NEONMAP1(vminv_s32, aarch64_neon_sminv, AddRetType | Add1ArgType),
NEONMAP1(vminv_u32, aarch64_neon_uminv, AddRetType | Add1ArgType),
NEONMAP1(vminvq_f32, aarch64_neon_fminv, AddRetType | Add1ArgType),
NEONMAP1(vminvq_f64, aarch64_neon_fminv, AddRetType | Add1ArgType),
NEONMAP1(vminvq_s32, aarch64_neon_sminv, AddRetType | Add1ArgType),
NEONMAP1(vminvq_u32, aarch64_neon_uminv, AddRetType | Add1ArgType),
NEONMAP1(vmull_p64, aarch64_neon_pmull64, 0),
NEONMAP1(vmulxd_f64, aarch64_neon_fmulx, Add1ArgType),
NEONMAP1(vmulxs_f32, aarch64_neon_fmulx, Add1ArgType),
NEONMAP1(vpaddd_s64, aarch64_neon_uaddv, AddRetType | Add1ArgType),
NEONMAP1(vpaddd_u64, aarch64_neon_uaddv, AddRetType | Add1ArgType),
NEONMAP1(vpmaxnmqd_f64, aarch64_neon_fmaxnmv, AddRetType | Add1ArgType),
NEONMAP1(vpmaxnms_f32, aarch64_neon_fmaxnmv, AddRetType | Add1ArgType),
NEONMAP1(vpmaxqd_f64, aarch64_neon_fmaxv, AddRetType | Add1ArgType),
NEONMAP1(vpmaxs_f32, aarch64_neon_fmaxv, AddRetType | Add1ArgType),
NEONMAP1(vpminnmqd_f64, aarch64_neon_fminnmv, AddRetType | Add1ArgType),
NEONMAP1(vpminnms_f32, aarch64_neon_fminnmv, AddRetType | Add1ArgType),
NEONMAP1(vpminqd_f64, aarch64_neon_fminv, AddRetType | Add1ArgType),
NEONMAP1(vpmins_f32, aarch64_neon_fminv, AddRetType | Add1ArgType),
NEONMAP1(vqabsb_s8, aarch64_neon_sqabs, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqabsd_s64, aarch64_neon_sqabs, Add1ArgType),
NEONMAP1(vqabsh_s16, aarch64_neon_sqabs, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqabss_s32, aarch64_neon_sqabs, Add1ArgType),
NEONMAP1(vqaddb_s8, aarch64_neon_sqadd, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqaddb_u8, aarch64_neon_uqadd, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqaddd_s64, aarch64_neon_sqadd, Add1ArgType),
NEONMAP1(vqaddd_u64, aarch64_neon_uqadd, Add1ArgType),
NEONMAP1(vqaddh_s16, aarch64_neon_sqadd, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqaddh_u16, aarch64_neon_uqadd, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqadds_s32, aarch64_neon_sqadd, Add1ArgType),
NEONMAP1(vqadds_u32, aarch64_neon_uqadd, Add1ArgType),
NEONMAP1(vqdmulhh_s16, aarch64_neon_sqdmulh, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqdmulhs_s32, aarch64_neon_sqdmulh, Add1ArgType),
NEONMAP1(vqdmullh_s16, aarch64_neon_sqdmull, VectorRet | Use128BitVectors),
NEONMAP1(vqdmulls_s32, aarch64_neon_sqdmulls_scalar, 0),
NEONMAP1(vqmovnd_s64, aarch64_neon_scalar_sqxtn, AddRetType | Add1ArgType),
NEONMAP1(vqmovnd_u64, aarch64_neon_scalar_uqxtn, AddRetType | Add1ArgType),
NEONMAP1(vqmovnh_s16, aarch64_neon_sqxtn, VectorRet | Use64BitVectors),
NEONMAP1(vqmovnh_u16, aarch64_neon_uqxtn, VectorRet | Use64BitVectors),
NEONMAP1(vqmovns_s32, aarch64_neon_sqxtn, VectorRet | Use64BitVectors),
NEONMAP1(vqmovns_u32, aarch64_neon_uqxtn, VectorRet | Use64BitVectors),
NEONMAP1(vqmovund_s64, aarch64_neon_scalar_sqxtun, AddRetType | Add1ArgType),
NEONMAP1(vqmovunh_s16, aarch64_neon_sqxtun, VectorRet | Use64BitVectors),
NEONMAP1(vqmovuns_s32, aarch64_neon_sqxtun, VectorRet | Use64BitVectors),
NEONMAP1(vqnegb_s8, aarch64_neon_sqneg, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqnegd_s64, aarch64_neon_sqneg, Add1ArgType),
NEONMAP1(vqnegh_s16, aarch64_neon_sqneg, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqnegs_s32, aarch64_neon_sqneg, Add1ArgType),
NEONMAP1(vqrdmulhh_s16, aarch64_neon_sqrdmulh, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqrdmulhs_s32, aarch64_neon_sqrdmulh, Add1ArgType),
NEONMAP1(vqrshlb_s8, aarch64_neon_sqrshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqrshlb_u8, aarch64_neon_uqrshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqrshld_s64, aarch64_neon_sqrshl, Add1ArgType),
NEONMAP1(vqrshld_u64, aarch64_neon_uqrshl, Add1ArgType),
NEONMAP1(vqrshlh_s16, aarch64_neon_sqrshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqrshlh_u16, aarch64_neon_uqrshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqrshls_s32, aarch64_neon_sqrshl, Add1ArgType),
NEONMAP1(vqrshls_u32, aarch64_neon_uqrshl, Add1ArgType),
NEONMAP1(vqrshrnd_n_s64, aarch64_neon_sqrshrn, AddRetType),
NEONMAP1(vqrshrnd_n_u64, aarch64_neon_uqrshrn, AddRetType),
NEONMAP1(vqrshrnh_n_s16, aarch64_neon_sqrshrn, VectorRet | Use64BitVectors),
NEONMAP1(vqrshrnh_n_u16, aarch64_neon_uqrshrn, VectorRet | Use64BitVectors),
NEONMAP1(vqrshrns_n_s32, aarch64_neon_sqrshrn, VectorRet | Use64BitVectors),
NEONMAP1(vqrshrns_n_u32, aarch64_neon_uqrshrn, VectorRet | Use64BitVectors),
NEONMAP1(vqrshrund_n_s64, aarch64_neon_sqrshrun, AddRetType),
NEONMAP1(vqrshrunh_n_s16, aarch64_neon_sqrshrun, VectorRet | Use64BitVectors),
NEONMAP1(vqrshruns_n_s32, aarch64_neon_sqrshrun, VectorRet | Use64BitVectors),
NEONMAP1(vqshlb_n_s8, aarch64_neon_sqshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqshlb_n_u8, aarch64_neon_uqshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqshlb_s8, aarch64_neon_sqshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqshlb_u8, aarch64_neon_uqshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqshld_s64, aarch64_neon_sqshl, Add1ArgType),
NEONMAP1(vqshld_u64, aarch64_neon_uqshl, Add1ArgType),
NEONMAP1(vqshlh_n_s16, aarch64_neon_sqshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqshlh_n_u16, aarch64_neon_uqshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqshlh_s16, aarch64_neon_sqshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqshlh_u16, aarch64_neon_uqshl, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqshls_n_s32, aarch64_neon_sqshl, Add1ArgType),
NEONMAP1(vqshls_n_u32, aarch64_neon_uqshl, Add1ArgType),
NEONMAP1(vqshls_s32, aarch64_neon_sqshl, Add1ArgType),
NEONMAP1(vqshls_u32, aarch64_neon_uqshl, Add1ArgType),
NEONMAP1(vqshlub_n_s8, aarch64_neon_sqshlu, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqshluh_n_s16, aarch64_neon_sqshlu, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqshlus_n_s32, aarch64_neon_sqshlu, Add1ArgType),
NEONMAP1(vqshrnd_n_s64, aarch64_neon_sqshrn, AddRetType),
NEONMAP1(vqshrnd_n_u64, aarch64_neon_uqshrn, AddRetType),
NEONMAP1(vqshrnh_n_s16, aarch64_neon_sqshrn, VectorRet | Use64BitVectors),
NEONMAP1(vqshrnh_n_u16, aarch64_neon_uqshrn, VectorRet | Use64BitVectors),
NEONMAP1(vqshrns_n_s32, aarch64_neon_sqshrn, VectorRet | Use64BitVectors),
NEONMAP1(vqshrns_n_u32, aarch64_neon_uqshrn, VectorRet | Use64BitVectors),
NEONMAP1(vqshrund_n_s64, aarch64_neon_sqshrun, AddRetType),
NEONMAP1(vqshrunh_n_s16, aarch64_neon_sqshrun, VectorRet | Use64BitVectors),
NEONMAP1(vqshruns_n_s32, aarch64_neon_sqshrun, VectorRet | Use64BitVectors),
NEONMAP1(vqsubb_s8, aarch64_neon_sqsub, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqsubb_u8, aarch64_neon_uqsub, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqsubd_s64, aarch64_neon_sqsub, Add1ArgType),
NEONMAP1(vqsubd_u64, aarch64_neon_uqsub, Add1ArgType),
NEONMAP1(vqsubh_s16, aarch64_neon_sqsub, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqsubh_u16, aarch64_neon_uqsub, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vqsubs_s32, aarch64_neon_sqsub, Add1ArgType),
NEONMAP1(vqsubs_u32, aarch64_neon_uqsub, Add1ArgType),
NEONMAP1(vrecped_f64, aarch64_neon_frecpe, Add1ArgType),
NEONMAP1(vrecpes_f32, aarch64_neon_frecpe, Add1ArgType),
NEONMAP1(vrecpxd_f64, aarch64_neon_frecpx, Add1ArgType),
NEONMAP1(vrecpxs_f32, aarch64_neon_frecpx, Add1ArgType),
NEONMAP1(vrshld_s64, aarch64_neon_srshl, Add1ArgType),
NEONMAP1(vrshld_u64, aarch64_neon_urshl, Add1ArgType),
NEONMAP1(vrsqrted_f64, aarch64_neon_frsqrte, Add1ArgType),
NEONMAP1(vrsqrtes_f32, aarch64_neon_frsqrte, Add1ArgType),
NEONMAP1(vrsqrtsd_f64, aarch64_neon_frsqrts, Add1ArgType),
NEONMAP1(vrsqrtss_f32, aarch64_neon_frsqrts, Add1ArgType),
NEONMAP1(vsha1cq_u32, aarch64_crypto_sha1c, 0),
NEONMAP1(vsha1h_u32, aarch64_crypto_sha1h, 0),
NEONMAP1(vsha1mq_u32, aarch64_crypto_sha1m, 0),
NEONMAP1(vsha1pq_u32, aarch64_crypto_sha1p, 0),
NEONMAP1(vshld_s64, aarch64_neon_sshl, Add1ArgType),
NEONMAP1(vshld_u64, aarch64_neon_ushl, Add1ArgType),
NEONMAP1(vslid_n_s64, aarch64_neon_vsli, Vectorize1ArgType),
NEONMAP1(vslid_n_u64, aarch64_neon_vsli, Vectorize1ArgType),
NEONMAP1(vsqaddb_u8, aarch64_neon_usqadd, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vsqaddd_u64, aarch64_neon_usqadd, Add1ArgType),
NEONMAP1(vsqaddh_u16, aarch64_neon_usqadd, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vsqadds_u32, aarch64_neon_usqadd, Add1ArgType),
NEONMAP1(vsrid_n_s64, aarch64_neon_vsri, Vectorize1ArgType),
NEONMAP1(vsrid_n_u64, aarch64_neon_vsri, Vectorize1ArgType),
NEONMAP1(vuqaddb_s8, aarch64_neon_suqadd, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vuqaddd_s64, aarch64_neon_suqadd, Add1ArgType),
NEONMAP1(vuqaddh_s16, aarch64_neon_suqadd, Vectorize1ArgType | Use64BitVectors),
NEONMAP1(vuqadds_s32, aarch64_neon_suqadd, Add1ArgType),
// FP16 scalar intrinisics go here.
NEONMAP1(vabdh_f16, aarch64_sisd_fabd, Add1ArgType),
NEONMAP1(vcvtah_s32_f16, aarch64_neon_fcvtas, AddRetType | Add1ArgType),
NEONMAP1(vcvtah_s64_f16, aarch64_neon_fcvtas, AddRetType | Add1ArgType),
NEONMAP1(vcvtah_u32_f16, aarch64_neon_fcvtau, AddRetType | Add1ArgType),
NEONMAP1(vcvtah_u64_f16, aarch64_neon_fcvtau, AddRetType | Add1ArgType),
NEONMAP1(vcvth_n_f16_s32, aarch64_neon_vcvtfxs2fp, AddRetType | Add1ArgType),
NEONMAP1(vcvth_n_f16_s64, aarch64_neon_vcvtfxs2fp, AddRetType | Add1ArgType),
NEONMAP1(vcvth_n_f16_u32, aarch64_neon_vcvtfxu2fp, AddRetType | Add1ArgType),
NEONMAP1(vcvth_n_f16_u64, aarch64_neon_vcvtfxu2fp, AddRetType | Add1ArgType),
NEONMAP1(vcvth_n_s32_f16, aarch64_neon_vcvtfp2fxs, AddRetType | Add1ArgType),
NEONMAP1(vcvth_n_s64_f16, aarch64_neon_vcvtfp2fxs, AddRetType | Add1ArgType),
NEONMAP1(vcvth_n_u32_f16, aarch64_neon_vcvtfp2fxu, AddRetType | Add1ArgType),
NEONMAP1(vcvth_n_u64_f16, aarch64_neon_vcvtfp2fxu, AddRetType | Add1ArgType),
NEONMAP1(vcvth_s32_f16, aarch64_neon_fcvtzs, AddRetType | Add1ArgType),
NEONMAP1(vcvth_s64_f16, aarch64_neon_fcvtzs, AddRetType | Add1ArgType),
NEONMAP1(vcvth_u32_f16, aarch64_neon_fcvtzu, AddRetType | Add1ArgType),
NEONMAP1(vcvth_u64_f16, aarch64_neon_fcvtzu, AddRetType | Add1ArgType),
NEONMAP1(vcvtmh_s32_f16, aarch64_neon_fcvtms, AddRetType | Add1ArgType),
NEONMAP1(vcvtmh_s64_f16, aarch64_neon_fcvtms, AddRetType | Add1ArgType),
NEONMAP1(vcvtmh_u32_f16, aarch64_neon_fcvtmu, AddRetType | Add1ArgType),
NEONMAP1(vcvtmh_u64_f16, aarch64_neon_fcvtmu, AddRetType | Add1ArgType),
NEONMAP1(vcvtnh_s32_f16, aarch64_neon_fcvtns, AddRetType | Add1ArgType),
NEONMAP1(vcvtnh_s64_f16, aarch64_neon_fcvtns, AddRetType | Add1ArgType),
NEONMAP1(vcvtnh_u32_f16, aarch64_neon_fcvtnu, AddRetType | Add1ArgType),
NEONMAP1(vcvtnh_u64_f16, aarch64_neon_fcvtnu, AddRetType | Add1ArgType),
NEONMAP1(vcvtph_s32_f16, aarch64_neon_fcvtps, AddRetType | Add1ArgType),
NEONMAP1(vcvtph_s64_f16, aarch64_neon_fcvtps, AddRetType | Add1ArgType),
NEONMAP1(vcvtph_u32_f16, aarch64_neon_fcvtpu, AddRetType | Add1ArgType),
NEONMAP1(vcvtph_u64_f16, aarch64_neon_fcvtpu, AddRetType | Add1ArgType),
NEONMAP1(vmulxh_f16, aarch64_neon_fmulx, Add1ArgType),
NEONMAP1(vrecpeh_f16, aarch64_neon_frecpe, Add1ArgType),
NEONMAP1(vrecpxh_f16, aarch64_neon_frecpx, Add1ArgType),
NEONMAP1(vrsqrteh_f16, aarch64_neon_frsqrte, Add1ArgType),
NEONMAP1(vrsqrtsh_f16, aarch64_neon_frsqrts, Add1ArgType),
};
#undef NEONMAP0
#undef NEONMAP1
#undef NEONMAP2
#define SVEMAP1(NameBase, LLVMIntrinsic, TypeModifier) \
{ \
#NameBase, SVE::BI__builtin_sve_##NameBase, Intrinsic::LLVMIntrinsic, 0, \
TypeModifier \
}
#define SVEMAP2(NameBase, TypeModifier) \
{ #NameBase, SVE::BI__builtin_sve_##NameBase, 0, 0, TypeModifier }
static const ARMVectorIntrinsicInfo AArch64SVEIntrinsicMap[] = {
#define GET_SVE_LLVM_INTRINSIC_MAP
#include "clang/Basic/arm_sve_builtin_cg.inc"
#undef GET_SVE_LLVM_INTRINSIC_MAP
};
#undef SVEMAP1
#undef SVEMAP2
static bool NEONSIMDIntrinsicsProvenSorted = false;
static bool AArch64SIMDIntrinsicsProvenSorted = false;
static bool AArch64SISDIntrinsicsProvenSorted = false;
static bool AArch64SVEIntrinsicsProvenSorted = false;
static const ARMVectorIntrinsicInfo *
findARMVectorIntrinsicInMap(ArrayRef<ARMVectorIntrinsicInfo> IntrinsicMap,
unsigned BuiltinID, bool &MapProvenSorted) {
#ifndef NDEBUG
if (!MapProvenSorted) {
assert(llvm::is_sorted(IntrinsicMap));
MapProvenSorted = true;
}
#endif
const ARMVectorIntrinsicInfo *Builtin =
llvm::lower_bound(IntrinsicMap, BuiltinID);
if (Builtin != IntrinsicMap.end() && Builtin->BuiltinID == BuiltinID)
return Builtin;
return nullptr;
}
Function *CodeGenFunction::LookupNeonLLVMIntrinsic(unsigned IntrinsicID,
unsigned Modifier,
llvm::Type *ArgType,
const CallExpr *E) {
int VectorSize = 0;
if (Modifier & Use64BitVectors)
VectorSize = 64;
else if (Modifier & Use128BitVectors)
VectorSize = 128;
// Return type.
SmallVector<llvm::Type *, 3> Tys;
if (Modifier & AddRetType) {
llvm::Type *Ty = ConvertType(E->getCallReturnType(getContext()));
if (Modifier & VectorizeRetType)
Ty = llvm::FixedVectorType::get(
Ty, VectorSize ? VectorSize / Ty->getPrimitiveSizeInBits() : 1);
Tys.push_back(Ty);
}
// Arguments.
if (Modifier & VectorizeArgTypes) {
int Elts = VectorSize ? VectorSize / ArgType->getPrimitiveSizeInBits() : 1;
ArgType = llvm::FixedVectorType::get(ArgType, Elts);
}
if (Modifier & (Add1ArgType | Add2ArgTypes))
Tys.push_back(ArgType);
if (Modifier & Add2ArgTypes)
Tys.push_back(ArgType);
if (Modifier & InventFloatType)
Tys.push_back(FloatTy);
return CGM.getIntrinsic(IntrinsicID, Tys);
}
static Value *EmitCommonNeonSISDBuiltinExpr(
CodeGenFunction &CGF, const ARMVectorIntrinsicInfo &SISDInfo,
SmallVectorImpl<Value *> &Ops, const CallExpr *E) {
unsigned BuiltinID = SISDInfo.BuiltinID;
unsigned int Int = SISDInfo.LLVMIntrinsic;
unsigned Modifier = SISDInfo.TypeModifier;
const char *s = SISDInfo.NameHint;
switch (BuiltinID) {
case NEON::BI__builtin_neon_vcled_s64:
case NEON::BI__builtin_neon_vcled_u64:
case NEON::BI__builtin_neon_vcles_f32:
case NEON::BI__builtin_neon_vcled_f64:
case NEON::BI__builtin_neon_vcltd_s64:
case NEON::BI__builtin_neon_vcltd_u64:
case NEON::BI__builtin_neon_vclts_f32:
case NEON::BI__builtin_neon_vcltd_f64:
case NEON::BI__builtin_neon_vcales_f32:
case NEON::BI__builtin_neon_vcaled_f64:
case NEON::BI__builtin_neon_vcalts_f32:
case NEON::BI__builtin_neon_vcaltd_f64:
// Only one direction of comparisons actually exist, cmle is actually a cmge
// with swapped operands. The table gives us the right intrinsic but we
// still need to do the swap.
std::swap(Ops[0], Ops[1]);
break;
}
assert(Int && "Generic code assumes a valid intrinsic");
// Determine the type(s) of this overloaded AArch64 intrinsic.
const Expr *Arg = E->getArg(0);
llvm::Type *ArgTy = CGF.ConvertType(Arg->getType());
Function *F = CGF.LookupNeonLLVMIntrinsic(Int, Modifier, ArgTy, E);
int j = 0;
ConstantInt *C0 = ConstantInt::get(CGF.SizeTy, 0);
for (Function::const_arg_iterator ai = F->arg_begin(), ae = F->arg_end();
ai != ae; ++ai, ++j) {
llvm::Type *ArgTy = ai->getType();
if (Ops[j]->getType()->getPrimitiveSizeInBits() ==
ArgTy->getPrimitiveSizeInBits())
continue;
assert(ArgTy->isVectorTy() && !Ops[j]->getType()->isVectorTy());
// The constant argument to an _n_ intrinsic always has Int32Ty, so truncate
// it before inserting.
Ops[j] = CGF.Builder.CreateTruncOrBitCast(
Ops[j], cast<llvm::VectorType>(ArgTy)->getElementType());
Ops[j] =
CGF.Builder.CreateInsertElement(UndefValue::get(ArgTy), Ops[j], C0);
}
Value *Result = CGF.EmitNeonCall(F, Ops, s);
llvm::Type *ResultType = CGF.ConvertType(E->getType());
if (ResultType->getPrimitiveSizeInBits().getFixedSize() <
Result->getType()->getPrimitiveSizeInBits().getFixedSize())
return CGF.Builder.CreateExtractElement(Result, C0);
return CGF.Builder.CreateBitCast(Result, ResultType, s);
}
Value *CodeGenFunction::EmitCommonNeonBuiltinExpr(
unsigned BuiltinID, unsigned LLVMIntrinsic, unsigned AltLLVMIntrinsic,
const char *NameHint, unsigned Modifier, const CallExpr *E,
SmallVectorImpl<llvm::Value *> &Ops, Address PtrOp0, Address PtrOp1,
llvm::Triple::ArchType Arch) {
// Get the last argument, which specifies the vector type.
const Expr *Arg = E->getArg(E->getNumArgs() - 1);
Optional<llvm::APSInt> NeonTypeConst =
Arg->getIntegerConstantExpr(getContext());
if (!NeonTypeConst)
return nullptr;
// Determine the type of this overloaded NEON intrinsic.
NeonTypeFlags Type(NeonTypeConst->getZExtValue());
bool Usgn = Type.isUnsigned();
bool Quad = Type.isQuad();
const bool HasLegalHalfType = getTarget().hasLegalHalfType();
const bool AllowBFloatArgsAndRet =
getTargetHooks().getABIInfo().allowBFloatArgsAndRet();
llvm::FixedVectorType *VTy =
GetNeonType(this, Type, HasLegalHalfType, false, AllowBFloatArgsAndRet);
llvm::Type *Ty = VTy;
if (!Ty)
return nullptr;
auto getAlignmentValue32 = [&](Address addr) -> Value* {
return Builder.getInt32(addr.getAlignment().getQuantity());
};
unsigned Int = LLVMIntrinsic;
if ((Modifier & UnsignedAlts) && !Usgn)
Int = AltLLVMIntrinsic;
switch (BuiltinID) {
default: break;
case NEON::BI__builtin_neon_splat_lane_v:
case NEON::BI__builtin_neon_splat_laneq_v:
case NEON::BI__builtin_neon_splatq_lane_v:
case NEON::BI__builtin_neon_splatq_laneq_v: {
auto NumElements = VTy->getElementCount();
if (BuiltinID == NEON::BI__builtin_neon_splatq_lane_v)
NumElements = NumElements * 2;
if (BuiltinID == NEON::BI__builtin_neon_splat_laneq_v)
NumElements = NumElements.divideCoefficientBy(2);
Ops[0] = Builder.CreateBitCast(Ops[0], VTy);
return EmitNeonSplat(Ops[0], cast<ConstantInt>(Ops[1]), NumElements);
}
case NEON::BI__builtin_neon_vpadd_v:
case NEON::BI__builtin_neon_vpaddq_v:
// We don't allow fp/int overloading of intrinsics.
if (VTy->getElementType()->isFloatingPointTy() &&
Int == Intrinsic::aarch64_neon_addp)
Int = Intrinsic::aarch64_neon_faddp;
break;
case NEON::BI__builtin_neon_vabs_v:
case NEON::BI__builtin_neon_vabsq_v:
if (VTy->getElementType()->isFloatingPointTy())
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::fabs, Ty), Ops, "vabs");
return EmitNeonCall(CGM.getIntrinsic(LLVMIntrinsic, Ty), Ops, "vabs");
case NEON::BI__builtin_neon_vaddhn_v: {
llvm::FixedVectorType *SrcTy =
llvm::FixedVectorType::getExtendedElementVectorType(VTy);
// %sum = add <4 x i32> %lhs, %rhs
Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
Ops[1] = Builder.CreateBitCast(Ops[1], SrcTy);
Ops[0] = Builder.CreateAdd(Ops[0], Ops[1], "vaddhn");
// %high = lshr <4 x i32> %sum, <i32 16, i32 16, i32 16, i32 16>
Constant *ShiftAmt =
ConstantInt::get(SrcTy, SrcTy->getScalarSizeInBits() / 2);
Ops[0] = Builder.CreateLShr(Ops[0], ShiftAmt, "vaddhn");
// %res = trunc <4 x i32> %high to <4 x i16>
return Builder.CreateTrunc(Ops[0], VTy, "vaddhn");
}
case NEON::BI__builtin_neon_vcale_v:
case NEON::BI__builtin_neon_vcaleq_v:
case NEON::BI__builtin_neon_vcalt_v:
case NEON::BI__builtin_neon_vcaltq_v:
std::swap(Ops[0], Ops[1]);
LLVM_FALLTHROUGH;
case NEON::BI__builtin_neon_vcage_v:
case NEON::BI__builtin_neon_vcageq_v:
case NEON::BI__builtin_neon_vcagt_v:
case NEON::BI__builtin_neon_vcagtq_v: {
llvm::Type *Ty;
switch (VTy->getScalarSizeInBits()) {
default: llvm_unreachable("unexpected type");
case 32:
Ty = FloatTy;
break;
case 64:
Ty = DoubleTy;
break;
case 16:
Ty = HalfTy;
break;
}
auto *VecFlt = llvm::FixedVectorType::get(Ty, VTy->getNumElements());
llvm::Type *Tys[] = { VTy, VecFlt };
Function *F = CGM.getIntrinsic(LLVMIntrinsic, Tys);
return EmitNeonCall(F, Ops, NameHint);
}
case NEON::BI__builtin_neon_vceqz_v:
case NEON::BI__builtin_neon_vceqzq_v:
return EmitAArch64CompareBuiltinExpr(Ops[0], Ty, ICmpInst::FCMP_OEQ,
ICmpInst::ICMP_EQ, "vceqz");
case NEON::BI__builtin_neon_vcgez_v:
case NEON::BI__builtin_neon_vcgezq_v:
return EmitAArch64CompareBuiltinExpr(Ops[0], Ty, ICmpInst::FCMP_OGE,
ICmpInst::ICMP_SGE, "vcgez");
case NEON::BI__builtin_neon_vclez_v:
case NEON::BI__builtin_neon_vclezq_v:
return EmitAArch64CompareBuiltinExpr(Ops[0], Ty, ICmpInst::FCMP_OLE,
ICmpInst::ICMP_SLE, "vclez");
case NEON::BI__builtin_neon_vcgtz_v:
case NEON::BI__builtin_neon_vcgtzq_v:
return EmitAArch64CompareBuiltinExpr(Ops[0], Ty, ICmpInst::FCMP_OGT,
ICmpInst::ICMP_SGT, "vcgtz");
case NEON::BI__builtin_neon_vcltz_v:
case NEON::BI__builtin_neon_vcltzq_v:
return EmitAArch64CompareBuiltinExpr(Ops[0], Ty, ICmpInst::FCMP_OLT,
ICmpInst::ICMP_SLT, "vcltz");
case NEON::BI__builtin_neon_vclz_v:
case NEON::BI__builtin_neon_vclzq_v:
// We generate target-independent intrinsic, which needs a second argument
// for whether or not clz of zero is undefined; on ARM it isn't.
Ops.push_back(Builder.getInt1(getTarget().isCLZForZeroUndef()));
break;
case NEON::BI__builtin_neon_vcvt_f32_v:
case NEON::BI__builtin_neon_vcvtq_f32_v:
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ty = GetNeonType(this, NeonTypeFlags(NeonTypeFlags::Float32, false, Quad),
HasLegalHalfType);
return Usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
: Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
case NEON::BI__builtin_neon_vcvt_f16_v:
case NEON::BI__builtin_neon_vcvtq_f16_v:
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ty = GetNeonType(this, NeonTypeFlags(NeonTypeFlags::Float16, false, Quad),
HasLegalHalfType);
return Usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
: Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
case NEON::BI__builtin_neon_vcvt_n_f16_v:
case NEON::BI__builtin_neon_vcvt_n_f32_v:
case NEON::BI__builtin_neon_vcvt_n_f64_v:
case NEON::BI__builtin_neon_vcvtq_n_f16_v:
case NEON::BI__builtin_neon_vcvtq_n_f32_v:
case NEON::BI__builtin_neon_vcvtq_n_f64_v: {
llvm::Type *Tys[2] = { GetFloatNeonType(this, Type), Ty };
Int = Usgn ? LLVMIntrinsic : AltLLVMIntrinsic;
Function *F = CGM.getIntrinsic(Int, Tys);
return EmitNeonCall(F, Ops, "vcvt_n");
}
case NEON::BI__builtin_neon_vcvt_n_s16_v:
case NEON::BI__builtin_neon_vcvt_n_s32_v:
case NEON::BI__builtin_neon_vcvt_n_u16_v:
case NEON::BI__builtin_neon_vcvt_n_u32_v:
case NEON::BI__builtin_neon_vcvt_n_s64_v:
case NEON::BI__builtin_neon_vcvt_n_u64_v:
case NEON::BI__builtin_neon_vcvtq_n_s16_v:
case NEON::BI__builtin_neon_vcvtq_n_s32_v:
case NEON::BI__builtin_neon_vcvtq_n_u16_v:
case NEON::BI__builtin_neon_vcvtq_n_u32_v:
case NEON::BI__builtin_neon_vcvtq_n_s64_v:
case NEON::BI__builtin_neon_vcvtq_n_u64_v: {
llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
Function *F = CGM.getIntrinsic(LLVMIntrinsic, Tys);
return EmitNeonCall(F, Ops, "vcvt_n");
}
case NEON::BI__builtin_neon_vcvt_s32_v:
case NEON::BI__builtin_neon_vcvt_u32_v:
case NEON::BI__builtin_neon_vcvt_s64_v:
case NEON::BI__builtin_neon_vcvt_u64_v:
case NEON::BI__builtin_neon_vcvt_s16_v:
case NEON::BI__builtin_neon_vcvt_u16_v:
case NEON::BI__builtin_neon_vcvtq_s32_v:
case NEON::BI__builtin_neon_vcvtq_u32_v:
case NEON::BI__builtin_neon_vcvtq_s64_v:
case NEON::BI__builtin_neon_vcvtq_u64_v:
case NEON::BI__builtin_neon_vcvtq_s16_v:
case NEON::BI__builtin_neon_vcvtq_u16_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], GetFloatNeonType(this, Type));
return Usgn ? Builder.CreateFPToUI(Ops[0], Ty, "vcvt")
: Builder.CreateFPToSI(Ops[0], Ty, "vcvt");
}
case NEON::BI__builtin_neon_vcvta_s16_v:
case NEON::BI__builtin_neon_vcvta_s32_v:
case NEON::BI__builtin_neon_vcvta_s64_v:
case NEON::BI__builtin_neon_vcvta_u16_v:
case NEON::BI__builtin_neon_vcvta_u32_v:
case NEON::BI__builtin_neon_vcvta_u64_v:
case NEON::BI__builtin_neon_vcvtaq_s16_v:
case NEON::BI__builtin_neon_vcvtaq_s32_v:
case NEON::BI__builtin_neon_vcvtaq_s64_v:
case NEON::BI__builtin_neon_vcvtaq_u16_v:
case NEON::BI__builtin_neon_vcvtaq_u32_v:
case NEON::BI__builtin_neon_vcvtaq_u64_v:
case NEON::BI__builtin_neon_vcvtn_s16_v:
case NEON::BI__builtin_neon_vcvtn_s32_v:
case NEON::BI__builtin_neon_vcvtn_s64_v:
case NEON::BI__builtin_neon_vcvtn_u16_v:
case NEON::BI__builtin_neon_vcvtn_u32_v:
case NEON::BI__builtin_neon_vcvtn_u64_v:
case NEON::BI__builtin_neon_vcvtnq_s16_v:
case NEON::BI__builtin_neon_vcvtnq_s32_v:
case NEON::BI__builtin_neon_vcvtnq_s64_v:
case NEON::BI__builtin_neon_vcvtnq_u16_v:
case NEON::BI__builtin_neon_vcvtnq_u32_v:
case NEON::BI__builtin_neon_vcvtnq_u64_v:
case NEON::BI__builtin_neon_vcvtp_s16_v:
case NEON::BI__builtin_neon_vcvtp_s32_v:
case NEON::BI__builtin_neon_vcvtp_s64_v:
case NEON::BI__builtin_neon_vcvtp_u16_v:
case NEON::BI__builtin_neon_vcvtp_u32_v:
case NEON::BI__builtin_neon_vcvtp_u64_v:
case NEON::BI__builtin_neon_vcvtpq_s16_v:
case NEON::BI__builtin_neon_vcvtpq_s32_v:
case NEON::BI__builtin_neon_vcvtpq_s64_v:
case NEON::BI__builtin_neon_vcvtpq_u16_v:
case NEON::BI__builtin_neon_vcvtpq_u32_v:
case NEON::BI__builtin_neon_vcvtpq_u64_v:
case NEON::BI__builtin_neon_vcvtm_s16_v:
case NEON::BI__builtin_neon_vcvtm_s32_v:
case NEON::BI__builtin_neon_vcvtm_s64_v:
case NEON::BI__builtin_neon_vcvtm_u16_v:
case NEON::BI__builtin_neon_vcvtm_u32_v:
case NEON::BI__builtin_neon_vcvtm_u64_v:
case NEON::BI__builtin_neon_vcvtmq_s16_v:
case NEON::BI__builtin_neon_vcvtmq_s32_v:
case NEON::BI__builtin_neon_vcvtmq_s64_v:
case NEON::BI__builtin_neon_vcvtmq_u16_v:
case NEON::BI__builtin_neon_vcvtmq_u32_v:
case NEON::BI__builtin_neon_vcvtmq_u64_v: {
llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
return EmitNeonCall(CGM.getIntrinsic(LLVMIntrinsic, Tys), Ops, NameHint);
}
case NEON::BI__builtin_neon_vcvtx_f32_v: {
llvm::Type *Tys[2] = { VTy->getTruncatedElementVectorType(VTy), Ty};
return EmitNeonCall(CGM.getIntrinsic(LLVMIntrinsic, Tys), Ops, NameHint);
}
case NEON::BI__builtin_neon_vext_v:
case NEON::BI__builtin_neon_vextq_v: {
int CV = cast<ConstantInt>(Ops[2])->getSExtValue();
SmallVector<int, 16> Indices;
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i)
Indices.push_back(i+CV);
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
return Builder.CreateShuffleVector(Ops[0], Ops[1], Indices, "vext");
}
case NEON::BI__builtin_neon_vfma_v:
case NEON::BI__builtin_neon_vfmaq_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
// NEON intrinsic puts accumulator first, unlike the LLVM fma.
return emitCallMaybeConstrainedFPBuiltin(
*this, Intrinsic::fma, Intrinsic::experimental_constrained_fma, Ty,
{Ops[1], Ops[2], Ops[0]});
}
case NEON::BI__builtin_neon_vld1_v:
case NEON::BI__builtin_neon_vld1q_v: {
llvm::Type *Tys[] = {Ty, Int8PtrTy};
Ops.push_back(getAlignmentValue32(PtrOp0));
return EmitNeonCall(CGM.getIntrinsic(LLVMIntrinsic, Tys), Ops, "vld1");
}
case NEON::BI__builtin_neon_vld1_x2_v:
case NEON::BI__builtin_neon_vld1q_x2_v:
case NEON::BI__builtin_neon_vld1_x3_v:
case NEON::BI__builtin_neon_vld1q_x3_v:
case NEON::BI__builtin_neon_vld1_x4_v:
case NEON::BI__builtin_neon_vld1q_x4_v: {
llvm::Type *PTy = llvm::PointerType::getUnqual(VTy->getElementType());
Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
llvm::Type *Tys[2] = { VTy, PTy };
Function *F = CGM.getIntrinsic(LLVMIntrinsic, Tys);
Ops[1] = Builder.CreateCall(F, Ops[1], "vld1xN");
Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vld2_v:
case NEON::BI__builtin_neon_vld2q_v:
case NEON::BI__builtin_neon_vld3_v:
case NEON::BI__builtin_neon_vld3q_v:
case NEON::BI__builtin_neon_vld4_v:
case NEON::BI__builtin_neon_vld4q_v:
case NEON::BI__builtin_neon_vld2_dup_v:
case NEON::BI__builtin_neon_vld2q_dup_v:
case NEON::BI__builtin_neon_vld3_dup_v:
case NEON::BI__builtin_neon_vld3q_dup_v:
case NEON::BI__builtin_neon_vld4_dup_v:
case NEON::BI__builtin_neon_vld4q_dup_v: {
llvm::Type *Tys[] = {Ty, Int8PtrTy};
Function *F = CGM.getIntrinsic(LLVMIntrinsic, Tys);
Value *Align = getAlignmentValue32(PtrOp1);
Ops[1] = Builder.CreateCall(F, {Ops[1], Align}, NameHint);
Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vld1_dup_v:
case NEON::BI__builtin_neon_vld1q_dup_v: {
Value *V = UndefValue::get(Ty);
Ty = llvm::PointerType::getUnqual(VTy->getElementType());
PtrOp0 = Builder.CreateBitCast(PtrOp0, Ty);
LoadInst *Ld = Builder.CreateLoad(PtrOp0);
llvm::Constant *CI = ConstantInt::get(SizeTy, 0);
Ops[0] = Builder.CreateInsertElement(V, Ld, CI);
return EmitNeonSplat(Ops[0], CI);
}
case NEON::BI__builtin_neon_vld2_lane_v:
case NEON::BI__builtin_neon_vld2q_lane_v:
case NEON::BI__builtin_neon_vld3_lane_v:
case NEON::BI__builtin_neon_vld3q_lane_v:
case NEON::BI__builtin_neon_vld4_lane_v:
case NEON::BI__builtin_neon_vld4q_lane_v: {
llvm::Type *Tys[] = {Ty, Int8PtrTy};
Function *F = CGM.getIntrinsic(LLVMIntrinsic, Tys);
for (unsigned I = 2; I < Ops.size() - 1; ++I)
Ops[I] = Builder.CreateBitCast(Ops[I], Ty);
Ops.push_back(getAlignmentValue32(PtrOp1));
Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), NameHint);
Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vmovl_v: {
llvm::FixedVectorType *DTy =
llvm::FixedVectorType::getTruncatedElementVectorType(VTy);
Ops[0] = Builder.CreateBitCast(Ops[0], DTy);
if (Usgn)
return Builder.CreateZExt(Ops[0], Ty, "vmovl");
return Builder.CreateSExt(Ops[0], Ty, "vmovl");
}
case NEON::BI__builtin_neon_vmovn_v: {
llvm::FixedVectorType *QTy =
llvm::FixedVectorType::getExtendedElementVectorType(VTy);
Ops[0] = Builder.CreateBitCast(Ops[0], QTy);
return Builder.CreateTrunc(Ops[0], Ty, "vmovn");
}
case NEON::BI__builtin_neon_vmull_v:
// FIXME: the integer vmull operations could be emitted in terms of pure
// LLVM IR (2 exts followed by a mul). Unfortunately LLVM has a habit of
// hoisting the exts outside loops. Until global ISel comes along that can
// see through such movement this leads to bad CodeGen. So we need an
// intrinsic for now.
Int = Usgn ? Intrinsic::arm_neon_vmullu : Intrinsic::arm_neon_vmulls;
Int = Type.isPoly() ? (unsigned)Intrinsic::arm_neon_vmullp : Int;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vmull");
case NEON::BI__builtin_neon_vpadal_v:
case NEON::BI__builtin_neon_vpadalq_v: {
// The source operand type has twice as many elements of half the size.
unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
llvm::Type *EltTy =
llvm::IntegerType::get(getLLVMContext(), EltBits / 2);
auto *NarrowTy =
llvm::FixedVectorType::get(EltTy, VTy->getNumElements() * 2);
llvm::Type *Tys[2] = { Ty, NarrowTy };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, NameHint);
}
case NEON::BI__builtin_neon_vpaddl_v:
case NEON::BI__builtin_neon_vpaddlq_v: {
// The source operand type has twice as many elements of half the size.
unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits();
llvm::Type *EltTy = llvm::IntegerType::get(getLLVMContext(), EltBits / 2);
auto *NarrowTy =
llvm::FixedVectorType::get(EltTy, VTy->getNumElements() * 2);
llvm::Type *Tys[2] = { Ty, NarrowTy };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vpaddl");
}
case NEON::BI__builtin_neon_vqdmlal_v:
case NEON::BI__builtin_neon_vqdmlsl_v: {
SmallVector<Value *, 2> MulOps(Ops.begin() + 1, Ops.end());
Ops[1] =
EmitNeonCall(CGM.getIntrinsic(LLVMIntrinsic, Ty), MulOps, "vqdmlal");
Ops.resize(2);
return EmitNeonCall(CGM.getIntrinsic(AltLLVMIntrinsic, Ty), Ops, NameHint);
}
case NEON::BI__builtin_neon_vqdmulhq_lane_v:
case NEON::BI__builtin_neon_vqdmulh_lane_v:
case NEON::BI__builtin_neon_vqrdmulhq_lane_v:
case NEON::BI__builtin_neon_vqrdmulh_lane_v: {
auto *RTy = cast<llvm::FixedVectorType>(Ty);
if (BuiltinID == NEON::BI__builtin_neon_vqdmulhq_lane_v ||
BuiltinID == NEON::BI__builtin_neon_vqrdmulhq_lane_v)
RTy = llvm::FixedVectorType::get(RTy->getElementType(),
RTy->getNumElements() * 2);
llvm::Type *Tys[2] = {
RTy, GetNeonType(this, NeonTypeFlags(Type.getEltType(), false,
/*isQuad*/ false))};
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, NameHint);
}
case NEON::BI__builtin_neon_vqdmulhq_laneq_v:
case NEON::BI__builtin_neon_vqdmulh_laneq_v:
case NEON::BI__builtin_neon_vqrdmulhq_laneq_v:
case NEON::BI__builtin_neon_vqrdmulh_laneq_v: {
llvm::Type *Tys[2] = {
Ty, GetNeonType(this, NeonTypeFlags(Type.getEltType(), false,
/*isQuad*/ true))};
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, NameHint);
}
case NEON::BI__builtin_neon_vqshl_n_v:
case NEON::BI__builtin_neon_vqshlq_n_v:
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vqshl_n",
1, false);
case NEON::BI__builtin_neon_vqshlu_n_v:
case NEON::BI__builtin_neon_vqshluq_n_v:
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vqshlu_n",
1, false);
case NEON::BI__builtin_neon_vrecpe_v:
case NEON::BI__builtin_neon_vrecpeq_v:
case NEON::BI__builtin_neon_vrsqrte_v:
case NEON::BI__builtin_neon_vrsqrteq_v:
Int = Ty->isFPOrFPVectorTy() ? LLVMIntrinsic : AltLLVMIntrinsic;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, NameHint);
case NEON::BI__builtin_neon_vrndi_v:
case NEON::BI__builtin_neon_vrndiq_v:
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_nearbyint
: Intrinsic::nearbyint;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, NameHint);
case NEON::BI__builtin_neon_vrshr_n_v:
case NEON::BI__builtin_neon_vrshrq_n_v:
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vrshr_n",
1, true);
case NEON::BI__builtin_neon_vshl_n_v:
case NEON::BI__builtin_neon_vshlq_n_v:
Ops[1] = EmitNeonShiftVector(Ops[1], Ty, false);
return Builder.CreateShl(Builder.CreateBitCast(Ops[0],Ty), Ops[1],
"vshl_n");
case NEON::BI__builtin_neon_vshll_n_v: {
llvm::FixedVectorType *SrcTy =
llvm::FixedVectorType::getTruncatedElementVectorType(VTy);
Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
if (Usgn)
Ops[0] = Builder.CreateZExt(Ops[0], VTy);
else
Ops[0] = Builder.CreateSExt(Ops[0], VTy);
Ops[1] = EmitNeonShiftVector(Ops[1], VTy, false);
return Builder.CreateShl(Ops[0], Ops[1], "vshll_n");
}
case NEON::BI__builtin_neon_vshrn_n_v: {
llvm::FixedVectorType *SrcTy =
llvm::FixedVectorType::getExtendedElementVectorType(VTy);
Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
Ops[1] = EmitNeonShiftVector(Ops[1], SrcTy, false);
if (Usgn)
Ops[0] = Builder.CreateLShr(Ops[0], Ops[1]);
else
Ops[0] = Builder.CreateAShr(Ops[0], Ops[1]);
return Builder.CreateTrunc(Ops[0], Ty, "vshrn_n");
}
case NEON::BI__builtin_neon_vshr_n_v:
case NEON::BI__builtin_neon_vshrq_n_v:
return EmitNeonRShiftImm(Ops[0], Ops[1], Ty, Usgn, "vshr_n");
case NEON::BI__builtin_neon_vst1_v:
case NEON::BI__builtin_neon_vst1q_v:
case NEON::BI__builtin_neon_vst2_v:
case NEON::BI__builtin_neon_vst2q_v:
case NEON::BI__builtin_neon_vst3_v:
case NEON::BI__builtin_neon_vst3q_v:
case NEON::BI__builtin_neon_vst4_v:
case NEON::BI__builtin_neon_vst4q_v:
case NEON::BI__builtin_neon_vst2_lane_v:
case NEON::BI__builtin_neon_vst2q_lane_v:
case NEON::BI__builtin_neon_vst3_lane_v:
case NEON::BI__builtin_neon_vst3q_lane_v:
case NEON::BI__builtin_neon_vst4_lane_v:
case NEON::BI__builtin_neon_vst4q_lane_v: {
llvm::Type *Tys[] = {Int8PtrTy, Ty};
Ops.push_back(getAlignmentValue32(PtrOp0));
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "");
}
case NEON::BI__builtin_neon_vst1_x2_v:
case NEON::BI__builtin_neon_vst1q_x2_v:
case NEON::BI__builtin_neon_vst1_x3_v:
case NEON::BI__builtin_neon_vst1q_x3_v:
case NEON::BI__builtin_neon_vst1_x4_v:
case NEON::BI__builtin_neon_vst1q_x4_v: {
llvm::Type *PTy = llvm::PointerType::getUnqual(VTy->getElementType());
// TODO: Currently in AArch32 mode the pointer operand comes first, whereas
// in AArch64 it comes last. We may want to stick to one or another.
if (Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_be ||
Arch == llvm::Triple::aarch64_32) {
llvm::Type *Tys[2] = { VTy, PTy };
std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end());
return EmitNeonCall(CGM.getIntrinsic(LLVMIntrinsic, Tys), Ops, "");
}
llvm::Type *Tys[2] = { PTy, VTy };
return EmitNeonCall(CGM.getIntrinsic(LLVMIntrinsic, Tys), Ops, "");
}
case NEON::BI__builtin_neon_vsubhn_v: {
llvm::FixedVectorType *SrcTy =
llvm::FixedVectorType::getExtendedElementVectorType(VTy);
// %sum = add <4 x i32> %lhs, %rhs
Ops[0] = Builder.CreateBitCast(Ops[0], SrcTy);
Ops[1] = Builder.CreateBitCast(Ops[1], SrcTy);
Ops[0] = Builder.CreateSub(Ops[0], Ops[1], "vsubhn");
// %high = lshr <4 x i32> %sum, <i32 16, i32 16, i32 16, i32 16>
Constant *ShiftAmt =
ConstantInt::get(SrcTy, SrcTy->getScalarSizeInBits() / 2);
Ops[0] = Builder.CreateLShr(Ops[0], ShiftAmt, "vsubhn");
// %res = trunc <4 x i32> %high to <4 x i16>
return Builder.CreateTrunc(Ops[0], VTy, "vsubhn");
}
case NEON::BI__builtin_neon_vtrn_v:
case NEON::BI__builtin_neon_vtrnq_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Value *SV = nullptr;
for (unsigned vi = 0; vi != 2; ++vi) {
SmallVector<int, 16> Indices;
for (unsigned i = 0, e = VTy->getNumElements(); i != e; i += 2) {
Indices.push_back(i+vi);
Indices.push_back(i+e+vi);
}
Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vtrn");
SV = Builder.CreateDefaultAlignedStore(SV, Addr);
}
return SV;
}
case NEON::BI__builtin_neon_vtst_v:
case NEON::BI__builtin_neon_vtstq_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
Ops[0] = Builder.CreateICmp(ICmpInst::ICMP_NE, Ops[0],
ConstantAggregateZero::get(Ty));
return Builder.CreateSExt(Ops[0], Ty, "vtst");
}
case NEON::BI__builtin_neon_vuzp_v:
case NEON::BI__builtin_neon_vuzpq_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Value *SV = nullptr;
for (unsigned vi = 0; vi != 2; ++vi) {
SmallVector<int, 16> Indices;
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i)
Indices.push_back(2*i+vi);
Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vuzp");
SV = Builder.CreateDefaultAlignedStore(SV, Addr);
}
return SV;
}
case NEON::BI__builtin_neon_vzip_v:
case NEON::BI__builtin_neon_vzipq_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Value *SV = nullptr;
for (unsigned vi = 0; vi != 2; ++vi) {
SmallVector<int, 16> Indices;
for (unsigned i = 0, e = VTy->getNumElements(); i != e; i += 2) {
Indices.push_back((i + vi*e) >> 1);
Indices.push_back(((i + vi*e) >> 1)+e);
}
Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vzip");
SV = Builder.CreateDefaultAlignedStore(SV, Addr);
}
return SV;
}
case NEON::BI__builtin_neon_vdot_v:
case NEON::BI__builtin_neon_vdotq_v: {
auto *InputTy =
llvm::FixedVectorType::get(Int8Ty, Ty->getPrimitiveSizeInBits() / 8);
llvm::Type *Tys[2] = { Ty, InputTy };
Int = Usgn ? LLVMIntrinsic : AltLLVMIntrinsic;
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vdot");
}
case NEON::BI__builtin_neon_vfmlal_low_v:
case NEON::BI__builtin_neon_vfmlalq_low_v: {
auto *InputTy =
llvm::FixedVectorType::get(HalfTy, Ty->getPrimitiveSizeInBits() / 16);
llvm::Type *Tys[2] = { Ty, InputTy };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vfmlal_low");
}
case NEON::BI__builtin_neon_vfmlsl_low_v:
case NEON::BI__builtin_neon_vfmlslq_low_v: {
auto *InputTy =
llvm::FixedVectorType::get(HalfTy, Ty->getPrimitiveSizeInBits() / 16);
llvm::Type *Tys[2] = { Ty, InputTy };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vfmlsl_low");
}
case NEON::BI__builtin_neon_vfmlal_high_v:
case NEON::BI__builtin_neon_vfmlalq_high_v: {
auto *InputTy =
llvm::FixedVectorType::get(HalfTy, Ty->getPrimitiveSizeInBits() / 16);
llvm::Type *Tys[2] = { Ty, InputTy };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vfmlal_high");
}
case NEON::BI__builtin_neon_vfmlsl_high_v:
case NEON::BI__builtin_neon_vfmlslq_high_v: {
auto *InputTy =
llvm::FixedVectorType::get(HalfTy, Ty->getPrimitiveSizeInBits() / 16);
llvm::Type *Tys[2] = { Ty, InputTy };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vfmlsl_high");
}
case NEON::BI__builtin_neon_vmmlaq_v: {
auto *InputTy =
llvm::FixedVectorType::get(Int8Ty, Ty->getPrimitiveSizeInBits() / 8);
llvm::Type *Tys[2] = { Ty, InputTy };
Int = Usgn ? LLVMIntrinsic : AltLLVMIntrinsic;
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmmla");
}
case NEON::BI__builtin_neon_vusmmlaq_v: {
auto *InputTy =
llvm::FixedVectorType::get(Int8Ty, Ty->getPrimitiveSizeInBits() / 8);
llvm::Type *Tys[2] = { Ty, InputTy };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vusmmla");
}
case NEON::BI__builtin_neon_vusdot_v:
case NEON::BI__builtin_neon_vusdotq_v: {
auto *InputTy =
llvm::FixedVectorType::get(Int8Ty, Ty->getPrimitiveSizeInBits() / 8);
llvm::Type *Tys[2] = { Ty, InputTy };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vusdot");
}
case NEON::BI__builtin_neon_vbfdot_v:
case NEON::BI__builtin_neon_vbfdotq_v: {
llvm::Type *InputTy =
llvm::FixedVectorType::get(BFloatTy, Ty->getPrimitiveSizeInBits() / 16);
llvm::Type *Tys[2] = { Ty, InputTy };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vbfdot");
}
case NEON::BI__builtin_neon___a32_vcvt_bf16_v: {
llvm::Type *Tys[1] = { Ty };
Function *F = CGM.getIntrinsic(Int, Tys);
return EmitNeonCall(F, Ops, "vcvtfp2bf");
}
}
assert(Int && "Expected valid intrinsic number");
// Determine the type(s) of this overloaded AArch64 intrinsic.
Function *F = LookupNeonLLVMIntrinsic(Int, Modifier, Ty, E);
Value *Result = EmitNeonCall(F, Ops, NameHint);
llvm::Type *ResultType = ConvertType(E->getType());
// AArch64 intrinsic one-element vector type cast to
// scalar type expected by the builtin
return Builder.CreateBitCast(Result, ResultType, NameHint);
}
Value *CodeGenFunction::EmitAArch64CompareBuiltinExpr(
Value *Op, llvm::Type *Ty, const CmpInst::Predicate Fp,
const CmpInst::Predicate Ip, const Twine &Name) {
llvm::Type *OTy = Op->getType();
// FIXME: this is utterly horrific. We should not be looking at previous
// codegen context to find out what needs doing. Unfortunately TableGen
// currently gives us exactly the same calls for vceqz_f32 and vceqz_s32
// (etc).
if (BitCastInst *BI = dyn_cast<BitCastInst>(Op))
OTy = BI->getOperand(0)->getType();
Op = Builder.CreateBitCast(Op, OTy);
if (OTy->getScalarType()->isFloatingPointTy()) {
Op = Builder.CreateFCmp(Fp, Op, Constant::getNullValue(OTy));
} else {
Op = Builder.CreateICmp(Ip, Op, Constant::getNullValue(OTy));
}
return Builder.CreateSExt(Op, Ty, Name);
}
static Value *packTBLDVectorList(CodeGenFunction &CGF, ArrayRef<Value *> Ops,
Value *ExtOp, Value *IndexOp,
llvm::Type *ResTy, unsigned IntID,
const char *Name) {
SmallVector<Value *, 2> TblOps;
if (ExtOp)
TblOps.push_back(ExtOp);
// Build a vector containing sequential number like (0, 1, 2, ..., 15)
SmallVector<int, 16> Indices;
auto *TblTy = cast<llvm::FixedVectorType>(Ops[0]->getType());
for (unsigned i = 0, e = TblTy->getNumElements(); i != e; ++i) {
Indices.push_back(2*i);
Indices.push_back(2*i+1);
}
int PairPos = 0, End = Ops.size() - 1;
while (PairPos < End) {
TblOps.push_back(CGF.Builder.CreateShuffleVector(Ops[PairPos],
Ops[PairPos+1], Indices,
Name));
PairPos += 2;
}
// If there's an odd number of 64-bit lookup table, fill the high 64-bit
// of the 128-bit lookup table with zero.
if (PairPos == End) {
Value *ZeroTbl = ConstantAggregateZero::get(TblTy);
TblOps.push_back(CGF.Builder.CreateShuffleVector(Ops[PairPos],
ZeroTbl, Indices, Name));
}
Function *TblF;
TblOps.push_back(IndexOp);
TblF = CGF.CGM.getIntrinsic(IntID, ResTy);
return CGF.EmitNeonCall(TblF, TblOps, Name);
}
Value *CodeGenFunction::GetValueForARMHint(unsigned BuiltinID) {
unsigned Value;
switch (BuiltinID) {
default:
return nullptr;
case ARM::BI__builtin_arm_nop:
Value = 0;
break;
case ARM::BI__builtin_arm_yield:
case ARM::BI__yield:
Value = 1;
break;
case ARM::BI__builtin_arm_wfe:
case ARM::BI__wfe:
Value = 2;
break;
case ARM::BI__builtin_arm_wfi:
case ARM::BI__wfi:
Value = 3;
break;
case ARM::BI__builtin_arm_sev:
case ARM::BI__sev:
Value = 4;
break;
case ARM::BI__builtin_arm_sevl:
case ARM::BI__sevl:
Value = 5;
break;
}
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_hint),
llvm::ConstantInt::get(Int32Ty, Value));
}
enum SpecialRegisterAccessKind {
NormalRead,
VolatileRead,
Write,
};
// Generates the IR for the read/write special register builtin,
// ValueType is the type of the value that is to be written or read,
// RegisterType is the type of the register being written to or read from.
static Value *EmitSpecialRegisterBuiltin(CodeGenFunction &CGF,
const CallExpr *E,
llvm::Type *RegisterType,
llvm::Type *ValueType,
SpecialRegisterAccessKind AccessKind,
StringRef SysReg = "") {
// write and register intrinsics only support 32 and 64 bit operations.
assert((RegisterType->isIntegerTy(32) || RegisterType->isIntegerTy(64))
&& "Unsupported size for register.");
CodeGen::CGBuilderTy &Builder = CGF.Builder;
CodeGen::CodeGenModule &CGM = CGF.CGM;
LLVMContext &Context = CGM.getLLVMContext();
if (SysReg.empty()) {
const Expr *SysRegStrExpr = E->getArg(0)->IgnoreParenCasts();
SysReg = cast<clang::StringLiteral>(SysRegStrExpr)->getString();
}
llvm::Metadata *Ops[] = { llvm::MDString::get(Context, SysReg) };
llvm::MDNode *RegName = llvm::MDNode::get(Context, Ops);
llvm::Value *Metadata = llvm::MetadataAsValue::get(Context, RegName);
llvm::Type *Types[] = { RegisterType };
bool MixedTypes = RegisterType->isIntegerTy(64) && ValueType->isIntegerTy(32);
assert(!(RegisterType->isIntegerTy(32) && ValueType->isIntegerTy(64))
&& "Can't fit 64-bit value in 32-bit register");
if (AccessKind != Write) {
assert(AccessKind == NormalRead || AccessKind == VolatileRead);
llvm::Function *F = CGM.getIntrinsic(
AccessKind == VolatileRead ? llvm::Intrinsic::read_volatile_register
: llvm::Intrinsic::read_register,
Types);
llvm::Value *Call = Builder.CreateCall(F, Metadata);
if (MixedTypes)
// Read into 64 bit register and then truncate result to 32 bit.
return Builder.CreateTrunc(Call, ValueType);
if (ValueType->isPointerTy())
// Have i32/i64 result (Call) but want to return a VoidPtrTy (i8*).
return Builder.CreateIntToPtr(Call, ValueType);
return Call;
}
llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::write_register, Types);
llvm::Value *ArgValue = CGF.EmitScalarExpr(E->getArg(1));
if (MixedTypes) {
// Extend 32 bit write value to 64 bit to pass to write.
ArgValue = Builder.CreateZExt(ArgValue, RegisterType);
return Builder.CreateCall(F, { Metadata, ArgValue });
}
if (ValueType->isPointerTy()) {
// Have VoidPtrTy ArgValue but want to return an i32/i64.
ArgValue = Builder.CreatePtrToInt(ArgValue, RegisterType);
return Builder.CreateCall(F, { Metadata, ArgValue });
}
return Builder.CreateCall(F, { Metadata, ArgValue });
}
/// Return true if BuiltinID is an overloaded Neon intrinsic with an extra
/// argument that specifies the vector type.
static bool HasExtraNeonArgument(unsigned BuiltinID) {
switch (BuiltinID) {
default: break;
case NEON::BI__builtin_neon_vget_lane_i8:
case NEON::BI__builtin_neon_vget_lane_i16:
case NEON::BI__builtin_neon_vget_lane_bf16:
case NEON::BI__builtin_neon_vget_lane_i32:
case NEON::BI__builtin_neon_vget_lane_i64:
case NEON::BI__builtin_neon_vget_lane_f32:
case NEON::BI__builtin_neon_vgetq_lane_i8:
case NEON::BI__builtin_neon_vgetq_lane_i16:
case NEON::BI__builtin_neon_vgetq_lane_bf16:
case NEON::BI__builtin_neon_vgetq_lane_i32:
case NEON::BI__builtin_neon_vgetq_lane_i64:
case NEON::BI__builtin_neon_vgetq_lane_f32:
case NEON::BI__builtin_neon_vduph_lane_bf16:
case NEON::BI__builtin_neon_vduph_laneq_bf16:
case NEON::BI__builtin_neon_vset_lane_i8:
case NEON::BI__builtin_neon_vset_lane_i16:
case NEON::BI__builtin_neon_vset_lane_bf16:
case NEON::BI__builtin_neon_vset_lane_i32:
case NEON::BI__builtin_neon_vset_lane_i64:
case NEON::BI__builtin_neon_vset_lane_f32:
case NEON::BI__builtin_neon_vsetq_lane_i8:
case NEON::BI__builtin_neon_vsetq_lane_i16:
case NEON::BI__builtin_neon_vsetq_lane_bf16:
case NEON::BI__builtin_neon_vsetq_lane_i32:
case NEON::BI__builtin_neon_vsetq_lane_i64:
case NEON::BI__builtin_neon_vsetq_lane_f32:
case NEON::BI__builtin_neon_vsha1h_u32:
case NEON::BI__builtin_neon_vsha1cq_u32:
case NEON::BI__builtin_neon_vsha1pq_u32:
case NEON::BI__builtin_neon_vsha1mq_u32:
case NEON::BI__builtin_neon_vcvth_bf16_f32:
case clang::ARM::BI_MoveToCoprocessor:
case clang::ARM::BI_MoveToCoprocessor2:
return false;
}
return true;
}
Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID,
const CallExpr *E,
ReturnValueSlot ReturnValue,
llvm::Triple::ArchType Arch) {
if (auto Hint = GetValueForARMHint(BuiltinID))
return Hint;
if (BuiltinID == ARM::BI__emit) {
bool IsThumb = getTarget().getTriple().getArch() == llvm::Triple::thumb;
llvm::FunctionType *FTy =
llvm::FunctionType::get(VoidTy, /*Variadic=*/false);
Expr::EvalResult Result;
if (!E->getArg(0)->EvaluateAsInt(Result, CGM.getContext()))
llvm_unreachable("Sema will ensure that the parameter is constant");
llvm::APSInt Value = Result.Val.getInt();
uint64_t ZExtValue = Value.zextOrTrunc(IsThumb ? 16 : 32).getZExtValue();
llvm::InlineAsm *Emit =
IsThumb ? InlineAsm::get(FTy, ".inst.n 0x" + utohexstr(ZExtValue), "",
/*hasSideEffects=*/true)
: InlineAsm::get(FTy, ".inst 0x" + utohexstr(ZExtValue), "",
/*hasSideEffects=*/true);
return Builder.CreateCall(Emit);
}
if (BuiltinID == ARM::BI__builtin_arm_dbg) {
Value *Option = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_dbg), Option);
}
if (BuiltinID == ARM::BI__builtin_arm_prefetch) {
Value *Address = EmitScalarExpr(E->getArg(0));
Value *RW = EmitScalarExpr(E->getArg(1));
Value *IsData = EmitScalarExpr(E->getArg(2));
// Locality is not supported on ARM target
Value *Locality = llvm::ConstantInt::get(Int32Ty, 3);
Function *F = CGM.getIntrinsic(Intrinsic::prefetch, Address->getType());
return Builder.CreateCall(F, {Address, RW, Locality, IsData});
}
if (BuiltinID == ARM::BI__builtin_arm_rbit) {
llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(
CGM.getIntrinsic(Intrinsic::bitreverse, Arg->getType()), Arg, "rbit");
}
if (BuiltinID == ARM::BI__builtin_arm_cls) {
llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_cls), Arg, "cls");
}
if (BuiltinID == ARM::BI__builtin_arm_cls64) {
llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_cls64), Arg,
"cls");
}
if (BuiltinID == ARM::BI__clear_cache) {
assert(E->getNumArgs() == 2 && "__clear_cache takes 2 arguments");
const FunctionDecl *FD = E->getDirectCallee();
Value *Ops[2];
for (unsigned i = 0; i < 2; i++)
Ops[i] = EmitScalarExpr(E->getArg(i));
llvm::Type *Ty = CGM.getTypes().ConvertType(FD->getType());
llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);
StringRef Name = FD->getName();
return EmitNounwindRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name), Ops);
}
if (BuiltinID == ARM::BI__builtin_arm_mcrr ||
BuiltinID == ARM::BI__builtin_arm_mcrr2) {
Function *F;
switch (BuiltinID) {
default: llvm_unreachable("unexpected builtin");
case ARM::BI__builtin_arm_mcrr:
F = CGM.getIntrinsic(Intrinsic::arm_mcrr);
break;
case ARM::BI__builtin_arm_mcrr2:
F = CGM.getIntrinsic(Intrinsic::arm_mcrr2);
break;
}
// MCRR{2} instruction has 5 operands but
// the intrinsic has 4 because Rt and Rt2
// are represented as a single unsigned 64
// bit integer in the intrinsic definition
// but internally it's represented as 2 32
// bit integers.
Value *Coproc = EmitScalarExpr(E->getArg(0));
Value *Opc1 = EmitScalarExpr(E->getArg(1));
Value *RtAndRt2 = EmitScalarExpr(E->getArg(2));
Value *CRm = EmitScalarExpr(E->getArg(3));
Value *C1 = llvm::ConstantInt::get(Int64Ty, 32);
Value *Rt = Builder.CreateTruncOrBitCast(RtAndRt2, Int32Ty);
Value *Rt2 = Builder.CreateLShr(RtAndRt2, C1);
Rt2 = Builder.CreateTruncOrBitCast(Rt2, Int32Ty);
return Builder.CreateCall(F, {Coproc, Opc1, Rt, Rt2, CRm});
}
if (BuiltinID == ARM::BI__builtin_arm_mrrc ||
BuiltinID == ARM::BI__builtin_arm_mrrc2) {
Function *F;
switch (BuiltinID) {
default: llvm_unreachable("unexpected builtin");
case ARM::BI__builtin_arm_mrrc:
F = CGM.getIntrinsic(Intrinsic::arm_mrrc);
break;
case ARM::BI__builtin_arm_mrrc2:
F = CGM.getIntrinsic(Intrinsic::arm_mrrc2);
break;
}
Value *Coproc = EmitScalarExpr(E->getArg(0));
Value *Opc1 = EmitScalarExpr(E->getArg(1));
Value *CRm = EmitScalarExpr(E->getArg(2));
Value *RtAndRt2 = Builder.CreateCall(F, {Coproc, Opc1, CRm});
// Returns an unsigned 64 bit integer, represented
// as two 32 bit integers.
Value *Rt = Builder.CreateExtractValue(RtAndRt2, 1);
Value *Rt1 = Builder.CreateExtractValue(RtAndRt2, 0);
Rt = Builder.CreateZExt(Rt, Int64Ty);
Rt1 = Builder.CreateZExt(Rt1, Int64Ty);
Value *ShiftCast = llvm::ConstantInt::get(Int64Ty, 32);
RtAndRt2 = Builder.CreateShl(Rt, ShiftCast, "shl", true);
RtAndRt2 = Builder.CreateOr(RtAndRt2, Rt1);
return Builder.CreateBitCast(RtAndRt2, ConvertType(E->getType()));
}
if (BuiltinID == ARM::BI__builtin_arm_ldrexd ||
((BuiltinID == ARM::BI__builtin_arm_ldrex ||
BuiltinID == ARM::BI__builtin_arm_ldaex) &&
getContext().getTypeSize(E->getType()) == 64) ||
BuiltinID == ARM::BI__ldrexd) {
Function *F;
switch (BuiltinID) {
default: llvm_unreachable("unexpected builtin");
case ARM::BI__builtin_arm_ldaex:
F = CGM.getIntrinsic(Intrinsic::arm_ldaexd);
break;
case ARM::BI__builtin_arm_ldrexd:
case ARM::BI__builtin_arm_ldrex:
case ARM::BI__ldrexd:
F = CGM.getIntrinsic(Intrinsic::arm_ldrexd);
break;
}
Value *LdPtr = EmitScalarExpr(E->getArg(0));
Value *Val = Builder.CreateCall(F, Builder.CreateBitCast(LdPtr, Int8PtrTy),
"ldrexd");
Value *Val0 = Builder.CreateExtractValue(Val, 1);
Value *Val1 = Builder.CreateExtractValue(Val, 0);
Val0 = Builder.CreateZExt(Val0, Int64Ty);
Val1 = Builder.CreateZExt(Val1, Int64Ty);
Value *ShiftCst = llvm::ConstantInt::get(Int64Ty, 32);
Val = Builder.CreateShl(Val0, ShiftCst, "shl", true /* nuw */);
Val = Builder.CreateOr(Val, Val1);
return Builder.CreateBitCast(Val, ConvertType(E->getType()));
}
if (BuiltinID == ARM::BI__builtin_arm_ldrex ||
BuiltinID == ARM::BI__builtin_arm_ldaex) {
Value *LoadAddr = EmitScalarExpr(E->getArg(0));
QualType Ty = E->getType();
llvm::Type *RealResTy = ConvertType(Ty);
llvm::Type *PtrTy = llvm::IntegerType::get(
getLLVMContext(), getContext().getTypeSize(Ty))->getPointerTo();
LoadAddr = Builder.CreateBitCast(LoadAddr, PtrTy);
Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI__builtin_arm_ldaex
? Intrinsic::arm_ldaex
: Intrinsic::arm_ldrex,
PtrTy);
Value *Val = Builder.CreateCall(F, LoadAddr, "ldrex");
if (RealResTy->isPointerTy())
return Builder.CreateIntToPtr(Val, RealResTy);
else {
llvm::Type *IntResTy = llvm::IntegerType::get(
getLLVMContext(), CGM.getDataLayout().getTypeSizeInBits(RealResTy));
Val = Builder.CreateTruncOrBitCast(Val, IntResTy);
return Builder.CreateBitCast(Val, RealResTy);
}
}
if (BuiltinID == ARM::BI__builtin_arm_strexd ||
((BuiltinID == ARM::BI__builtin_arm_stlex ||
BuiltinID == ARM::BI__builtin_arm_strex) &&
getContext().getTypeSize(E->getArg(0)->getType()) == 64)) {
Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI__builtin_arm_stlex
? Intrinsic::arm_stlexd
: Intrinsic::arm_strexd);
llvm::Type *STy = llvm::StructType::get(Int32Ty, Int32Ty);
Address Tmp = CreateMemTemp(E->getArg(0)->getType());
Value *Val = EmitScalarExpr(E->getArg(0));
Builder.CreateStore(Val, Tmp);
Address LdPtr = Builder.CreateBitCast(Tmp,llvm::PointerType::getUnqual(STy));
Val = Builder.CreateLoad(LdPtr);
Value *Arg0 = Builder.CreateExtractValue(Val, 0);
Value *Arg1 = Builder.CreateExtractValue(Val, 1);
Value *StPtr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)), Int8PtrTy);
return Builder.CreateCall(F, {Arg0, Arg1, StPtr}, "strexd");
}
if (BuiltinID == ARM::BI__builtin_arm_strex ||
BuiltinID == ARM::BI__builtin_arm_stlex) {
Value *StoreVal = EmitScalarExpr(E->getArg(0));
Value *StoreAddr = EmitScalarExpr(E->getArg(1));
QualType Ty = E->getArg(0)->getType();
llvm::Type *StoreTy = llvm::IntegerType::get(getLLVMContext(),
getContext().getTypeSize(Ty));
StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
if (StoreVal->getType()->isPointerTy())
StoreVal = Builder.CreatePtrToInt(StoreVal, Int32Ty);
else {
llvm::Type *IntTy = llvm::IntegerType::get(
getLLVMContext(),
CGM.getDataLayout().getTypeSizeInBits(StoreVal->getType()));
StoreVal = Builder.CreateBitCast(StoreVal, IntTy);
StoreVal = Builder.CreateZExtOrBitCast(StoreVal, Int32Ty);
}
Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI__builtin_arm_stlex
? Intrinsic::arm_stlex
: Intrinsic::arm_strex,
StoreAddr->getType());
return Builder.CreateCall(F, {StoreVal, StoreAddr}, "strex");
}
if (BuiltinID == ARM::BI__builtin_arm_clrex) {
Function *F = CGM.getIntrinsic(Intrinsic::arm_clrex);
return Builder.CreateCall(F);
}
// CRC32
Intrinsic::ID CRCIntrinsicID = Intrinsic::not_intrinsic;
switch (BuiltinID) {
case ARM::BI__builtin_arm_crc32b:
CRCIntrinsicID = Intrinsic::arm_crc32b; break;
case ARM::BI__builtin_arm_crc32cb:
CRCIntrinsicID = Intrinsic::arm_crc32cb; break;
case ARM::BI__builtin_arm_crc32h:
CRCIntrinsicID = Intrinsic::arm_crc32h; break;
case ARM::BI__builtin_arm_crc32ch:
CRCIntrinsicID = Intrinsic::arm_crc32ch; break;
case ARM::BI__builtin_arm_crc32w:
case ARM::BI__builtin_arm_crc32d:
CRCIntrinsicID = Intrinsic::arm_crc32w; break;
case ARM::BI__builtin_arm_crc32cw:
case ARM::BI__builtin_arm_crc32cd:
CRCIntrinsicID = Intrinsic::arm_crc32cw; break;
}
if (CRCIntrinsicID != Intrinsic::not_intrinsic) {
Value *Arg0 = EmitScalarExpr(E->getArg(0));
Value *Arg1 = EmitScalarExpr(E->getArg(1));
// crc32{c,}d intrinsics are implemnted as two calls to crc32{c,}w
// intrinsics, hence we need different codegen for these cases.
if (BuiltinID == ARM::BI__builtin_arm_crc32d ||
BuiltinID == ARM::BI__builtin_arm_crc32cd) {
Value *C1 = llvm::ConstantInt::get(Int64Ty, 32);
Value *Arg1a = Builder.CreateTruncOrBitCast(Arg1, Int32Ty);
Value *Arg1b = Builder.CreateLShr(Arg1, C1);
Arg1b = Builder.CreateTruncOrBitCast(Arg1b, Int32Ty);
Function *F = CGM.getIntrinsic(CRCIntrinsicID);
Value *Res = Builder.CreateCall(F, {Arg0, Arg1a});
return Builder.CreateCall(F, {Res, Arg1b});
} else {
Arg1 = Builder.CreateZExtOrBitCast(Arg1, Int32Ty);
Function *F = CGM.getIntrinsic(CRCIntrinsicID);
return Builder.CreateCall(F, {Arg0, Arg1});
}
}
if (BuiltinID == ARM::BI__builtin_arm_rsr ||
BuiltinID == ARM::BI__builtin_arm_rsr64 ||
BuiltinID == ARM::BI__builtin_arm_rsrp ||
BuiltinID == ARM::BI__builtin_arm_wsr ||
BuiltinID == ARM::BI__builtin_arm_wsr64 ||
BuiltinID == ARM::BI__builtin_arm_wsrp) {
SpecialRegisterAccessKind AccessKind = Write;
if (BuiltinID == ARM::BI__builtin_arm_rsr ||
BuiltinID == ARM::BI__builtin_arm_rsr64 ||
BuiltinID == ARM::BI__builtin_arm_rsrp)
AccessKind = VolatileRead;
bool IsPointerBuiltin = BuiltinID == ARM::BI__builtin_arm_rsrp ||
BuiltinID == ARM::BI__builtin_arm_wsrp;
bool Is64Bit = BuiltinID == ARM::BI__builtin_arm_rsr64 ||
BuiltinID == ARM::BI__builtin_arm_wsr64;
llvm::Type *ValueType;
llvm::Type *RegisterType;
if (IsPointerBuiltin) {
ValueType = VoidPtrTy;
RegisterType = Int32Ty;
} else if (Is64Bit) {
ValueType = RegisterType = Int64Ty;
} else {
ValueType = RegisterType = Int32Ty;
}
return EmitSpecialRegisterBuiltin(*this, E, RegisterType, ValueType,
AccessKind);
}
// Handle MSVC intrinsics before argument evaluation to prevent double
// evaluation.
if (Optional<MSVCIntrin> MsvcIntId = translateArmToMsvcIntrin(BuiltinID))
return EmitMSVCBuiltinExpr(*MsvcIntId, E);
// Deal with MVE builtins
if (Value *Result = EmitARMMVEBuiltinExpr(BuiltinID, E, ReturnValue, Arch))
return Result;
// Handle CDE builtins
if (Value *Result = EmitARMCDEBuiltinExpr(BuiltinID, E, ReturnValue, Arch))
return Result;
// Find out if any arguments are required to be integer constant
// expressions.
unsigned ICEArguments = 0;
ASTContext::GetBuiltinTypeError Error;
getContext().GetBuiltinType(BuiltinID, Error, &ICEArguments);
assert(Error == ASTContext::GE_None && "Should not codegen an error");
auto getAlignmentValue32 = [&](Address addr) -> Value* {
return Builder.getInt32(addr.getAlignment().getQuantity());
};
Address PtrOp0 = Address::invalid();
Address PtrOp1 = Address::invalid();
SmallVector<Value*, 4> Ops;
bool HasExtraArg = HasExtraNeonArgument(BuiltinID);
unsigned NumArgs = E->getNumArgs() - (HasExtraArg ? 1 : 0);
for (unsigned i = 0, e = NumArgs; i != e; i++) {
if (i == 0) {
switch (BuiltinID) {
case NEON::BI__builtin_neon_vld1_v:
case NEON::BI__builtin_neon_vld1q_v:
case NEON::BI__builtin_neon_vld1q_lane_v:
case NEON::BI__builtin_neon_vld1_lane_v:
case NEON::BI__builtin_neon_vld1_dup_v:
case NEON::BI__builtin_neon_vld1q_dup_v:
case NEON::BI__builtin_neon_vst1_v:
case NEON::BI__builtin_neon_vst1q_v:
case NEON::BI__builtin_neon_vst1q_lane_v:
case NEON::BI__builtin_neon_vst1_lane_v:
case NEON::BI__builtin_neon_vst2_v:
case NEON::BI__builtin_neon_vst2q_v:
case NEON::BI__builtin_neon_vst2_lane_v:
case NEON::BI__builtin_neon_vst2q_lane_v:
case NEON::BI__builtin_neon_vst3_v:
case NEON::BI__builtin_neon_vst3q_v:
case NEON::BI__builtin_neon_vst3_lane_v:
case NEON::BI__builtin_neon_vst3q_lane_v:
case NEON::BI__builtin_neon_vst4_v:
case NEON::BI__builtin_neon_vst4q_v:
case NEON::BI__builtin_neon_vst4_lane_v:
case NEON::BI__builtin_neon_vst4q_lane_v:
// Get the alignment for the argument in addition to the value;
// we'll use it later.
PtrOp0 = EmitPointerWithAlignment(E->getArg(0));
Ops.push_back(PtrOp0.getPointer());
continue;
}
}
if (i == 1) {
switch (BuiltinID) {
case NEON::BI__builtin_neon_vld2_v:
case NEON::BI__builtin_neon_vld2q_v:
case NEON::BI__builtin_neon_vld3_v:
case NEON::BI__builtin_neon_vld3q_v:
case NEON::BI__builtin_neon_vld4_v:
case NEON::BI__builtin_neon_vld4q_v:
case NEON::BI__builtin_neon_vld2_lane_v:
case NEON::BI__builtin_neon_vld2q_lane_v:
case NEON::BI__builtin_neon_vld3_lane_v:
case NEON::BI__builtin_neon_vld3q_lane_v:
case NEON::BI__builtin_neon_vld4_lane_v:
case NEON::BI__builtin_neon_vld4q_lane_v:
case NEON::BI__builtin_neon_vld2_dup_v:
case NEON::BI__builtin_neon_vld2q_dup_v:
case NEON::BI__builtin_neon_vld3_dup_v:
case NEON::BI__builtin_neon_vld3q_dup_v:
case NEON::BI__builtin_neon_vld4_dup_v:
case NEON::BI__builtin_neon_vld4q_dup_v:
// Get the alignment for the argument in addition to the value;
// we'll use it later.
PtrOp1 = EmitPointerWithAlignment(E->getArg(1));
Ops.push_back(PtrOp1.getPointer());
continue;
}
}
if ((ICEArguments & (1 << i)) == 0) {
Ops.push_back(EmitScalarExpr(E->getArg(i)));
} else {
// If this is required to be a constant, constant fold it so that we know
// that the generated intrinsic gets a ConstantInt.
Ops.push_back(llvm::ConstantInt::get(
getLLVMContext(),
*E->getArg(i)->getIntegerConstantExpr(getContext())));
}
}
switch (BuiltinID) {
default: break;
case NEON::BI__builtin_neon_vget_lane_i8:
case NEON::BI__builtin_neon_vget_lane_i16:
case NEON::BI__builtin_neon_vget_lane_i32:
case NEON::BI__builtin_neon_vget_lane_i64:
case NEON::BI__builtin_neon_vget_lane_bf16:
case NEON::BI__builtin_neon_vget_lane_f32:
case NEON::BI__builtin_neon_vgetq_lane_i8:
case NEON::BI__builtin_neon_vgetq_lane_i16:
case NEON::BI__builtin_neon_vgetq_lane_i32:
case NEON::BI__builtin_neon_vgetq_lane_i64:
case NEON::BI__builtin_neon_vgetq_lane_bf16:
case NEON::BI__builtin_neon_vgetq_lane_f32:
case NEON::BI__builtin_neon_vduph_lane_bf16:
case NEON::BI__builtin_neon_vduph_laneq_bf16:
return Builder.CreateExtractElement(Ops[0], Ops[1], "vget_lane");
case NEON::BI__builtin_neon_vrndns_f32: {
Value *Arg = EmitScalarExpr(E->getArg(0));
llvm::Type *Tys[] = {Arg->getType()};
Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vrintn, Tys);
return Builder.CreateCall(F, {Arg}, "vrndn"); }
case NEON::BI__builtin_neon_vset_lane_i8:
case NEON::BI__builtin_neon_vset_lane_i16:
case NEON::BI__builtin_neon_vset_lane_i32:
case NEON::BI__builtin_neon_vset_lane_i64:
case NEON::BI__builtin_neon_vset_lane_bf16:
case NEON::BI__builtin_neon_vset_lane_f32:
case NEON::BI__builtin_neon_vsetq_lane_i8:
case NEON::BI__builtin_neon_vsetq_lane_i16:
case NEON::BI__builtin_neon_vsetq_lane_i32:
case NEON::BI__builtin_neon_vsetq_lane_i64:
case NEON::BI__builtin_neon_vsetq_lane_bf16:
case NEON::BI__builtin_neon_vsetq_lane_f32:
return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
case NEON::BI__builtin_neon_vsha1h_u32:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_sha1h), Ops,
"vsha1h");
case NEON::BI__builtin_neon_vsha1cq_u32:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_sha1c), Ops,
"vsha1h");
case NEON::BI__builtin_neon_vsha1pq_u32:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_sha1p), Ops,
"vsha1h");
case NEON::BI__builtin_neon_vsha1mq_u32:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_sha1m), Ops,
"vsha1h");
case NEON::BI__builtin_neon_vcvth_bf16_f32: {
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vcvtbfp2bf), Ops,
"vcvtbfp2bf");
}
// The ARM _MoveToCoprocessor builtins put the input register value as
// the first argument, but the LLVM intrinsic expects it as the third one.
case ARM::BI_MoveToCoprocessor:
case ARM::BI_MoveToCoprocessor2: {
Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI_MoveToCoprocessor ?
Intrinsic::arm_mcr : Intrinsic::arm_mcr2);
return Builder.CreateCall(F, {Ops[1], Ops[2], Ops[0],
Ops[3], Ops[4], Ops[5]});
}
}
// Get the last argument, which specifies the vector type.
assert(HasExtraArg);
const Expr *Arg = E->getArg(E->getNumArgs()-1);
Optional<llvm::APSInt> Result = Arg->getIntegerConstantExpr(getContext());
if (!Result)
return nullptr;
if (BuiltinID == ARM::BI__builtin_arm_vcvtr_f ||
BuiltinID == ARM::BI__builtin_arm_vcvtr_d) {
// Determine the overloaded type of this builtin.
llvm::Type *Ty;
if (BuiltinID == ARM::BI__builtin_arm_vcvtr_f)
Ty = FloatTy;
else
Ty = DoubleTy;
// Determine whether this is an unsigned conversion or not.
bool usgn = Result->getZExtValue() == 1;
unsigned Int = usgn ? Intrinsic::arm_vcvtru : Intrinsic::arm_vcvtr;
// Call the appropriate intrinsic.
Function *F = CGM.getIntrinsic(Int, Ty);
return Builder.CreateCall(F, Ops, "vcvtr");
}
// Determine the type of this overloaded NEON intrinsic.
NeonTypeFlags Type = Result->getZExtValue();
bool usgn = Type.isUnsigned();
bool rightShift = false;
llvm::FixedVectorType *VTy =
GetNeonType(this, Type, getTarget().hasLegalHalfType(), false,
getTarget().hasBFloat16Type());
llvm::Type *Ty = VTy;
if (!Ty)
return nullptr;
// Many NEON builtins have identical semantics and uses in ARM and
// AArch64. Emit these in a single function.
auto IntrinsicMap = makeArrayRef(ARMSIMDIntrinsicMap);
const ARMVectorIntrinsicInfo *Builtin = findARMVectorIntrinsicInMap(
IntrinsicMap, BuiltinID, NEONSIMDIntrinsicsProvenSorted);
if (Builtin)
return EmitCommonNeonBuiltinExpr(
Builtin->BuiltinID, Builtin->LLVMIntrinsic, Builtin->AltLLVMIntrinsic,
Builtin->NameHint, Builtin->TypeModifier, E, Ops, PtrOp0, PtrOp1, Arch);
unsigned Int;
switch (BuiltinID) {
default: return nullptr;
case NEON::BI__builtin_neon_vld1q_lane_v:
// Handle 64-bit integer elements as a special case. Use shuffles of
// one-element vectors to avoid poor code for i64 in the backend.
if (VTy->getElementType()->isIntegerTy(64)) {
// Extract the other lane.
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
int Lane = cast<ConstantInt>(Ops[2])->getZExtValue();
Value *SV = llvm::ConstantVector::get(ConstantInt::get(Int32Ty, 1-Lane));
Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV);
// Load the value as a one-element vector.
Ty = llvm::FixedVectorType::get(VTy->getElementType(), 1);
llvm::Type *Tys[] = {Ty, Int8PtrTy};
Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vld1, Tys);
Value *Align = getAlignmentValue32(PtrOp0);
Value *Ld = Builder.CreateCall(F, {Ops[0], Align});
// Combine them.
int Indices[] = {1 - Lane, Lane};
return Builder.CreateShuffleVector(Ops[1], Ld, Indices, "vld1q_lane");
}
LLVM_FALLTHROUGH;
case NEON::BI__builtin_neon_vld1_lane_v: {
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
PtrOp0 = Builder.CreateElementBitCast(PtrOp0, VTy->getElementType());
Value *Ld = Builder.CreateLoad(PtrOp0);
return Builder.CreateInsertElement(Ops[1], Ld, Ops[2], "vld1_lane");
}
case NEON::BI__builtin_neon_vqrshrn_n_v:
Int =
usgn ? Intrinsic::arm_neon_vqrshiftnu : Intrinsic::arm_neon_vqrshiftns;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vqrshrn_n",
1, true);
case NEON::BI__builtin_neon_vqrshrun_n_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vqrshiftnsu, Ty),
Ops, "vqrshrun_n", 1, true);
case NEON::BI__builtin_neon_vqshrn_n_v:
Int = usgn ? Intrinsic::arm_neon_vqshiftnu : Intrinsic::arm_neon_vqshiftns;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vqshrn_n",
1, true);
case NEON::BI__builtin_neon_vqshrun_n_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vqshiftnsu, Ty),
Ops, "vqshrun_n", 1, true);
case NEON::BI__builtin_neon_vrecpe_v:
case NEON::BI__builtin_neon_vrecpeq_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vrecpe, Ty),
Ops, "vrecpe");
case NEON::BI__builtin_neon_vrshrn_n_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vrshiftn, Ty),
Ops, "vrshrn_n", 1, true);
case NEON::BI__builtin_neon_vrsra_n_v:
case NEON::BI__builtin_neon_vrsraq_n_v:
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = EmitNeonShiftVector(Ops[2], Ty, true);
Int = usgn ? Intrinsic::arm_neon_vrshiftu : Intrinsic::arm_neon_vrshifts;
Ops[1] = Builder.CreateCall(CGM.getIntrinsic(Int, Ty), {Ops[1], Ops[2]});
return Builder.CreateAdd(Ops[0], Ops[1], "vrsra_n");
case NEON::BI__builtin_neon_vsri_n_v:
case NEON::BI__builtin_neon_vsriq_n_v:
rightShift = true;
LLVM_FALLTHROUGH;
case NEON::BI__builtin_neon_vsli_n_v:
case NEON::BI__builtin_neon_vsliq_n_v:
Ops[2] = EmitNeonShiftVector(Ops[2], Ty, rightShift);
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vshiftins, Ty),
Ops, "vsli_n");
case NEON::BI__builtin_neon_vsra_n_v:
case NEON::BI__builtin_neon_vsraq_n_v:
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ops[1] = EmitNeonRShiftImm(Ops[1], Ops[2], Ty, usgn, "vsra_n");
return Builder.CreateAdd(Ops[0], Ops[1]);
case NEON::BI__builtin_neon_vst1q_lane_v:
// Handle 64-bit integer elements as a special case. Use a shuffle to get
// a one-element vector and avoid poor code for i64 in the backend.
if (VTy->getElementType()->isIntegerTy(64)) {
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Value *SV = llvm::ConstantVector::get(cast<llvm::Constant>(Ops[2]));
Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV);
Ops[2] = getAlignmentValue32(PtrOp0);
llvm::Type *Tys[] = {Int8PtrTy, Ops[1]->getType()};
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::arm_neon_vst1,
Tys), Ops);
}
LLVM_FALLTHROUGH;
case NEON::BI__builtin_neon_vst1_lane_v: {
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2]);
Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
auto St = Builder.CreateStore(Ops[1], Builder.CreateBitCast(PtrOp0, Ty));
return St;
}
case NEON::BI__builtin_neon_vtbl1_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbl1),
Ops, "vtbl1");
case NEON::BI__builtin_neon_vtbl2_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbl2),
Ops, "vtbl2");
case NEON::BI__builtin_neon_vtbl3_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbl3),
Ops, "vtbl3");
case NEON::BI__builtin_neon_vtbl4_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbl4),
Ops, "vtbl4");
case NEON::BI__builtin_neon_vtbx1_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbx1),
Ops, "vtbx1");
case NEON::BI__builtin_neon_vtbx2_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbx2),
Ops, "vtbx2");
case NEON::BI__builtin_neon_vtbx3_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbx3),
Ops, "vtbx3");
case NEON::BI__builtin_neon_vtbx4_v:
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::arm_neon_vtbx4),
Ops, "vtbx4");
}
}
template<typename Integer>
static Integer GetIntegerConstantValue(const Expr *E, ASTContext &Context) {
return E->getIntegerConstantExpr(Context)->getExtValue();
}
static llvm::Value *SignOrZeroExtend(CGBuilderTy &Builder, llvm::Value *V,
llvm::Type *T, bool Unsigned) {
// Helper function called by Tablegen-constructed ARM MVE builtin codegen,
// which finds it convenient to specify signed/unsigned as a boolean flag.
return Unsigned ? Builder.CreateZExt(V, T) : Builder.CreateSExt(V, T);
}
static llvm::Value *MVEImmediateShr(CGBuilderTy &Builder, llvm::Value *V,
uint32_t Shift, bool Unsigned) {
// MVE helper function for integer shift right. This must handle signed vs
// unsigned, and also deal specially with the case where the shift count is
// equal to the lane size. In LLVM IR, an LShr with that parameter would be
// undefined behavior, but in MVE it's legal, so we must convert it to code
// that is not undefined in IR.
unsigned LaneBits = cast<llvm::VectorType>(V->getType())
->getElementType()
->getPrimitiveSizeInBits();
if (Shift == LaneBits) {
// An unsigned shift of the full lane size always generates zero, so we can
// simply emit a zero vector. A signed shift of the full lane size does the
// same thing as shifting by one bit fewer.
if (Unsigned)
return llvm::Constant::getNullValue(V->getType());
else
--Shift;
}
return Unsigned ? Builder.CreateLShr(V, Shift) : Builder.CreateAShr(V, Shift);
}
static llvm::Value *ARMMVEVectorSplat(CGBuilderTy &Builder, llvm::Value *V) {
// MVE-specific helper function for a vector splat, which infers the element
// count of the output vector by knowing that MVE vectors are all 128 bits
// wide.
unsigned Elements = 128 / V->getType()->getPrimitiveSizeInBits();
return Builder.CreateVectorSplat(Elements, V);
}
static llvm::Value *ARMMVEVectorReinterpret(CGBuilderTy &Builder,
CodeGenFunction *CGF,
llvm::Value *V,
llvm::Type *DestType) {
// Convert one MVE vector type into another by reinterpreting its in-register
// format.
//
// Little-endian, this is identical to a bitcast (which reinterprets the
// memory format). But big-endian, they're not necessarily the same, because
// the register and memory formats map to each other differently depending on
// the lane size.
//
// We generate a bitcast whenever we can (if we're little-endian, or if the
// lane sizes are the same anyway). Otherwise we fall back to an IR intrinsic
// that performs the different kind of reinterpretation.
if (CGF->getTarget().isBigEndian() &&
V->getType()->getScalarSizeInBits() != DestType->getScalarSizeInBits()) {
return Builder.CreateCall(
CGF->CGM.getIntrinsic(Intrinsic::arm_mve_vreinterpretq,
{DestType, V->getType()}),
V);
} else {
return Builder.CreateBitCast(V, DestType);
}
}
static llvm::Value *VectorUnzip(CGBuilderTy &Builder, llvm::Value *V, bool Odd) {
// Make a shufflevector that extracts every other element of a vector (evens
// or odds, as desired).
SmallVector<int, 16> Indices;
unsigned InputElements =
cast<llvm::FixedVectorType>(V->getType())->getNumElements();
for (unsigned i = 0; i < InputElements; i += 2)
Indices.push_back(i + Odd);
return Builder.CreateShuffleVector(V, Indices);
}
static llvm::Value *VectorZip(CGBuilderTy &Builder, llvm::Value *V0,
llvm::Value *V1) {
// Make a shufflevector that interleaves two vectors element by element.
assert(V0->getType() == V1->getType() && "Can't zip different vector types");
SmallVector<int, 16> Indices;
unsigned InputElements =
cast<llvm::FixedVectorType>(V0->getType())->getNumElements();
for (unsigned i = 0; i < InputElements; i++) {
Indices.push_back(i);
Indices.push_back(i + InputElements);
}
return Builder.CreateShuffleVector(V0, V1, Indices);
}
template<unsigned HighBit, unsigned OtherBits>
static llvm::Value *ARMMVEConstantSplat(CGBuilderTy &Builder, llvm::Type *VT) {
// MVE-specific helper function to make a vector splat of a constant such as
// UINT_MAX or INT_MIN, in which all bits below the highest one are equal.
llvm::Type *T = cast<llvm::VectorType>(VT)->getElementType();
unsigned LaneBits = T->getPrimitiveSizeInBits();
uint32_t Value = HighBit << (LaneBits - 1);
if (OtherBits)
Value |= (1UL << (LaneBits - 1)) - 1;
llvm::Value *Lane = llvm::ConstantInt::get(T, Value);
return ARMMVEVectorSplat(Builder, Lane);
}
static llvm::Value *ARMMVEVectorElementReverse(CGBuilderTy &Builder,
llvm::Value *V,
unsigned ReverseWidth) {
// MVE-specific helper function which reverses the elements of a
// vector within every (ReverseWidth)-bit collection of lanes.
SmallVector<int, 16> Indices;
unsigned LaneSize = V->getType()->getScalarSizeInBits();
unsigned Elements = 128 / LaneSize;
unsigned Mask = ReverseWidth / LaneSize - 1;
for (unsigned i = 0; i < Elements; i++)
Indices.push_back(i ^ Mask);
return Builder.CreateShuffleVector(V, Indices);
}
Value *CodeGenFunction::EmitARMMVEBuiltinExpr(unsigned BuiltinID,
const CallExpr *E,
ReturnValueSlot ReturnValue,
llvm::Triple::ArchType Arch) {
enum class CustomCodeGen { VLD24, VST24 } CustomCodeGenType;
Intrinsic::ID IRIntr;
unsigned NumVectors;
// Code autogenerated by Tablegen will handle all the simple builtins.
switch (BuiltinID) {
#include "clang/Basic/arm_mve_builtin_cg.inc"
// If we didn't match an MVE builtin id at all, go back to the
// main EmitARMBuiltinExpr.
default:
return nullptr;
}
// Anything that breaks from that switch is an MVE builtin that
// needs handwritten code to generate.
switch (CustomCodeGenType) {
case CustomCodeGen::VLD24: {
llvm::SmallVector<Value *, 4> Ops;
llvm::SmallVector<llvm::Type *, 4> Tys;
auto MvecCType = E->getType();
auto MvecLType = ConvertType(MvecCType);
assert(MvecLType->isStructTy() &&
"Return type for vld[24]q should be a struct");
assert(MvecLType->getStructNumElements() == 1 &&
"Return-type struct for vld[24]q should have one element");
auto MvecLTypeInner = MvecLType->getStructElementType(0);
assert(MvecLTypeInner->isArrayTy() &&
"Return-type struct for vld[24]q should contain an array");
assert(MvecLTypeInner->getArrayNumElements() == NumVectors &&
"Array member of return-type struct vld[24]q has wrong length");
auto VecLType = MvecLTypeInner->getArrayElementType();
Tys.push_back(VecLType);
auto Addr = E->getArg(0);
Ops.push_back(EmitScalarExpr(Addr));
Tys.push_back(ConvertType(Addr->getType()));
Function *F = CGM.getIntrinsic(IRIntr, makeArrayRef(Tys));
Value *LoadResult = Builder.CreateCall(F, Ops);
Value *MvecOut = UndefValue::get(MvecLType);
for (unsigned i = 0; i < NumVectors; ++i) {
Value *Vec = Builder.CreateExtractValue(LoadResult, i);
MvecOut = Builder.CreateInsertValue(MvecOut, Vec, {0, i});
}
if (ReturnValue.isNull())
return MvecOut;
else
return Builder.CreateStore(MvecOut, ReturnValue.getValue());
}
case CustomCodeGen::VST24: {
llvm::SmallVector<Value *, 4> Ops;
llvm::SmallVector<llvm::Type *, 4> Tys;
auto Addr = E->getArg(0);
Ops.push_back(EmitScalarExpr(Addr));
Tys.push_back(ConvertType(Addr->getType()));
auto MvecCType = E->getArg(1)->getType();
auto MvecLType = ConvertType(MvecCType);
assert(MvecLType->isStructTy() && "Data type for vst2q should be a struct");
assert(MvecLType->getStructNumElements() == 1 &&
"Data-type struct for vst2q should have one element");
auto MvecLTypeInner = MvecLType->getStructElementType(0);
assert(MvecLTypeInner->isArrayTy() &&
"Data-type struct for vst2q should contain an array");
assert(MvecLTypeInner->getArrayNumElements() == NumVectors &&
"Array member of return-type struct vld[24]q has wrong length");
auto VecLType = MvecLTypeInner->getArrayElementType();
Tys.push_back(VecLType);
AggValueSlot MvecSlot = CreateAggTemp(MvecCType);
EmitAggExpr(E->getArg(1), MvecSlot);
auto Mvec = Builder.CreateLoad(MvecSlot.getAddress());
for (unsigned i = 0; i < NumVectors; i++)
Ops.push_back(Builder.CreateExtractValue(Mvec, {0, i}));
Function *F = CGM.getIntrinsic(IRIntr, makeArrayRef(Tys));
Value *ToReturn = nullptr;
for (unsigned i = 0; i < NumVectors; i++) {
Ops.push_back(llvm::ConstantInt::get(Int32Ty, i));
ToReturn = Builder.CreateCall(F, Ops);
Ops.pop_back();
}
return ToReturn;
}
}
llvm_unreachable("unknown custom codegen type.");
}
Value *CodeGenFunction::EmitARMCDEBuiltinExpr(unsigned BuiltinID,
const CallExpr *E,
ReturnValueSlot ReturnValue,
llvm::Triple::ArchType Arch) {
switch (BuiltinID) {
default:
return nullptr;
#include "clang/Basic/arm_cde_builtin_cg.inc"
}
}
static Value *EmitAArch64TblBuiltinExpr(CodeGenFunction &CGF, unsigned BuiltinID,
const CallExpr *E,
SmallVectorImpl<Value *> &Ops,
llvm::Triple::ArchType Arch) {
unsigned int Int = 0;
const char *s = nullptr;
switch (BuiltinID) {
default:
return nullptr;
case NEON::BI__builtin_neon_vtbl1_v:
case NEON::BI__builtin_neon_vqtbl1_v:
case NEON::BI__builtin_neon_vqtbl1q_v:
case NEON::BI__builtin_neon_vtbl2_v:
case NEON::BI__builtin_neon_vqtbl2_v:
case NEON::BI__builtin_neon_vqtbl2q_v:
case NEON::BI__builtin_neon_vtbl3_v:
case NEON::BI__builtin_neon_vqtbl3_v:
case NEON::BI__builtin_neon_vqtbl3q_v:
case NEON::BI__builtin_neon_vtbl4_v:
case NEON::BI__builtin_neon_vqtbl4_v:
case NEON::BI__builtin_neon_vqtbl4q_v:
break;
case NEON::BI__builtin_neon_vtbx1_v:
case NEON::BI__builtin_neon_vqtbx1_v:
case NEON::BI__builtin_neon_vqtbx1q_v:
case NEON::BI__builtin_neon_vtbx2_v:
case NEON::BI__builtin_neon_vqtbx2_v:
case NEON::BI__builtin_neon_vqtbx2q_v:
case NEON::BI__builtin_neon_vtbx3_v:
case NEON::BI__builtin_neon_vqtbx3_v:
case NEON::BI__builtin_neon_vqtbx3q_v:
case NEON::BI__builtin_neon_vtbx4_v:
case NEON::BI__builtin_neon_vqtbx4_v:
case NEON::BI__builtin_neon_vqtbx4q_v:
break;
}
assert(E->getNumArgs() >= 3);
// Get the last argument, which specifies the vector type.
const Expr *Arg = E->getArg(E->getNumArgs() - 1);
Optional<llvm::APSInt> Result = Arg->getIntegerConstantExpr(CGF.getContext());
if (!Result)
return nullptr;
// Determine the type of this overloaded NEON intrinsic.
NeonTypeFlags Type = Result->getZExtValue();
llvm::FixedVectorType *Ty = GetNeonType(&CGF, Type);
if (!Ty)
return nullptr;
CodeGen::CGBuilderTy &Builder = CGF.Builder;
// AArch64 scalar builtins are not overloaded, they do not have an extra
// argument that specifies the vector type, need to handle each case.
switch (BuiltinID) {
case NEON::BI__builtin_neon_vtbl1_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(0, 1), nullptr,
Ops[1], Ty, Intrinsic::aarch64_neon_tbl1,
"vtbl1");
}
case NEON::BI__builtin_neon_vtbl2_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(0, 2), nullptr,
Ops[2], Ty, Intrinsic::aarch64_neon_tbl1,
"vtbl1");
}
case NEON::BI__builtin_neon_vtbl3_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(0, 3), nullptr,
Ops[3], Ty, Intrinsic::aarch64_neon_tbl2,
"vtbl2");
}
case NEON::BI__builtin_neon_vtbl4_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(0, 4), nullptr,
Ops[4], Ty, Intrinsic::aarch64_neon_tbl2,
"vtbl2");
}
case NEON::BI__builtin_neon_vtbx1_v: {
Value *TblRes =
packTBLDVectorList(CGF, makeArrayRef(Ops).slice(1, 1), nullptr, Ops[2],
Ty, Intrinsic::aarch64_neon_tbl1, "vtbl1");
llvm::Constant *EightV = ConstantInt::get(Ty, 8);
Value *CmpRes = Builder.CreateICmp(ICmpInst::ICMP_UGE, Ops[2], EightV);
CmpRes = Builder.CreateSExt(CmpRes, Ty);
Value *EltsFromInput = Builder.CreateAnd(CmpRes, Ops[0]);
Value *EltsFromTbl = Builder.CreateAnd(Builder.CreateNot(CmpRes), TblRes);
return Builder.CreateOr(EltsFromInput, EltsFromTbl, "vtbx");
}
case NEON::BI__builtin_neon_vtbx2_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(1, 2), Ops[0],
Ops[3], Ty, Intrinsic::aarch64_neon_tbx1,
"vtbx1");
}
case NEON::BI__builtin_neon_vtbx3_v: {
Value *TblRes =
packTBLDVectorList(CGF, makeArrayRef(Ops).slice(1, 3), nullptr, Ops[4],
Ty, Intrinsic::aarch64_neon_tbl2, "vtbl2");
llvm::Constant *TwentyFourV = ConstantInt::get(Ty, 24);
Value *CmpRes = Builder.CreateICmp(ICmpInst::ICMP_UGE, Ops[4],
TwentyFourV);
CmpRes = Builder.CreateSExt(CmpRes, Ty);
Value *EltsFromInput = Builder.CreateAnd(CmpRes, Ops[0]);
Value *EltsFromTbl = Builder.CreateAnd(Builder.CreateNot(CmpRes), TblRes);
return Builder.CreateOr(EltsFromInput, EltsFromTbl, "vtbx");
}
case NEON::BI__builtin_neon_vtbx4_v: {
return packTBLDVectorList(CGF, makeArrayRef(Ops).slice(1, 4), Ops[0],
Ops[5], Ty, Intrinsic::aarch64_neon_tbx2,
"vtbx2");
}
case NEON::BI__builtin_neon_vqtbl1_v:
case NEON::BI__builtin_neon_vqtbl1q_v:
Int = Intrinsic::aarch64_neon_tbl1; s = "vtbl1"; break;
case NEON::BI__builtin_neon_vqtbl2_v:
case NEON::BI__builtin_neon_vqtbl2q_v: {
Int = Intrinsic::aarch64_neon_tbl2; s = "vtbl2"; break;
case NEON::BI__builtin_neon_vqtbl3_v:
case NEON::BI__builtin_neon_vqtbl3q_v:
Int = Intrinsic::aarch64_neon_tbl3; s = "vtbl3"; break;
case NEON::BI__builtin_neon_vqtbl4_v:
case NEON::BI__builtin_neon_vqtbl4q_v:
Int = Intrinsic::aarch64_neon_tbl4; s = "vtbl4"; break;
case NEON::BI__builtin_neon_vqtbx1_v:
case NEON::BI__builtin_neon_vqtbx1q_v:
Int = Intrinsic::aarch64_neon_tbx1; s = "vtbx1"; break;
case NEON::BI__builtin_neon_vqtbx2_v:
case NEON::BI__builtin_neon_vqtbx2q_v:
Int = Intrinsic::aarch64_neon_tbx2; s = "vtbx2"; break;
case NEON::BI__builtin_neon_vqtbx3_v:
case NEON::BI__builtin_neon_vqtbx3q_v:
Int = Intrinsic::aarch64_neon_tbx3; s = "vtbx3"; break;
case NEON::BI__builtin_neon_vqtbx4_v:
case NEON::BI__builtin_neon_vqtbx4q_v:
Int = Intrinsic::aarch64_neon_tbx4; s = "vtbx4"; break;
}
}
if (!Int)
return nullptr;
Function *F = CGF.CGM.getIntrinsic(Int, Ty);
return CGF.EmitNeonCall(F, Ops, s);
}
Value *CodeGenFunction::vectorWrapScalar16(Value *Op) {
auto *VTy = llvm::FixedVectorType::get(Int16Ty, 4);
Op = Builder.CreateBitCast(Op, Int16Ty);
Value *V = UndefValue::get(VTy);
llvm::Constant *CI = ConstantInt::get(SizeTy, 0);
Op = Builder.CreateInsertElement(V, Op, CI);
return Op;
}
/// SVEBuiltinMemEltTy - Returns the memory element type for this memory
/// access builtin. Only required if it can't be inferred from the base pointer
/// operand.
llvm::Type *CodeGenFunction::SVEBuiltinMemEltTy(SVETypeFlags TypeFlags) {
switch (TypeFlags.getMemEltType()) {
case SVETypeFlags::MemEltTyDefault:
return getEltType(TypeFlags);
case SVETypeFlags::MemEltTyInt8:
return Builder.getInt8Ty();
case SVETypeFlags::MemEltTyInt16:
return Builder.getInt16Ty();
case SVETypeFlags::MemEltTyInt32:
return Builder.getInt32Ty();
case SVETypeFlags::MemEltTyInt64:
return Builder.getInt64Ty();
}
llvm_unreachable("Unknown MemEltType");
}
llvm::Type *CodeGenFunction::getEltType(SVETypeFlags TypeFlags) {
switch (TypeFlags.getEltType()) {
default:
llvm_unreachable("Invalid SVETypeFlag!");
case SVETypeFlags::EltTyInt8:
return Builder.getInt8Ty();
case SVETypeFlags::EltTyInt16:
return Builder.getInt16Ty();
case SVETypeFlags::EltTyInt32:
return Builder.getInt32Ty();
case SVETypeFlags::EltTyInt64:
return Builder.getInt64Ty();
case SVETypeFlags::EltTyFloat16:
return Builder.getHalfTy();
case SVETypeFlags::EltTyFloat32:
return Builder.getFloatTy();
case SVETypeFlags::EltTyFloat64:
return Builder.getDoubleTy();
case SVETypeFlags::EltTyBFloat16:
return Builder.getBFloatTy();
case SVETypeFlags::EltTyBool8:
case SVETypeFlags::EltTyBool16:
case SVETypeFlags::EltTyBool32:
case SVETypeFlags::EltTyBool64:
return Builder.getInt1Ty();
}
}
// Return the llvm predicate vector type corresponding to the specified element
// TypeFlags.
llvm::ScalableVectorType *
CodeGenFunction::getSVEPredType(SVETypeFlags TypeFlags) {
switch (TypeFlags.getEltType()) {
default: llvm_unreachable("Unhandled SVETypeFlag!");
case SVETypeFlags::EltTyInt8:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 16);
case SVETypeFlags::EltTyInt16:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 8);
case SVETypeFlags::EltTyInt32:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 4);
case SVETypeFlags::EltTyInt64:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 2);
case SVETypeFlags::EltTyBFloat16:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 8);
case SVETypeFlags::EltTyFloat16:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 8);
case SVETypeFlags::EltTyFloat32:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 4);
case SVETypeFlags::EltTyFloat64:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 2);
case SVETypeFlags::EltTyBool8:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 16);
case SVETypeFlags::EltTyBool16:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 8);
case SVETypeFlags::EltTyBool32:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 4);
case SVETypeFlags::EltTyBool64:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 2);
}
}
// Return the llvm vector type corresponding to the specified element TypeFlags.
llvm::ScalableVectorType *
CodeGenFunction::getSVEType(const SVETypeFlags &TypeFlags) {
switch (TypeFlags.getEltType()) {
default:
llvm_unreachable("Invalid SVETypeFlag!");
case SVETypeFlags::EltTyInt8:
return llvm::ScalableVectorType::get(Builder.getInt8Ty(), 16);
case SVETypeFlags::EltTyInt16:
return llvm::ScalableVectorType::get(Builder.getInt16Ty(), 8);
case SVETypeFlags::EltTyInt32:
return llvm::ScalableVectorType::get(Builder.getInt32Ty(), 4);
case SVETypeFlags::EltTyInt64:
return llvm::ScalableVectorType::get(Builder.getInt64Ty(), 2);
case SVETypeFlags::EltTyFloat16:
return llvm::ScalableVectorType::get(Builder.getHalfTy(), 8);
case SVETypeFlags::EltTyBFloat16:
return llvm::ScalableVectorType::get(Builder.getBFloatTy(), 8);
case SVETypeFlags::EltTyFloat32:
return llvm::ScalableVectorType::get(Builder.getFloatTy(), 4);
case SVETypeFlags::EltTyFloat64:
return llvm::ScalableVectorType::get(Builder.getDoubleTy(), 2);
case SVETypeFlags::EltTyBool8:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 16);
case SVETypeFlags::EltTyBool16:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 8);
case SVETypeFlags::EltTyBool32:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 4);
case SVETypeFlags::EltTyBool64:
return llvm::ScalableVectorType::get(Builder.getInt1Ty(), 2);
}
}
llvm::Value *CodeGenFunction::EmitSVEAllTruePred(SVETypeFlags TypeFlags) {
Function *Ptrue =
CGM.getIntrinsic(Intrinsic::aarch64_sve_ptrue, getSVEPredType(TypeFlags));
return Builder.CreateCall(Ptrue, {Builder.getInt32(/*SV_ALL*/ 31)});
}
constexpr unsigned SVEBitsPerBlock = 128;
static llvm::ScalableVectorType *getSVEVectorForElementType(llvm::Type *EltTy) {
unsigned NumElts = SVEBitsPerBlock / EltTy->getScalarSizeInBits();
return llvm::ScalableVectorType::get(EltTy, NumElts);
}
// Reinterpret the input predicate so that it can be used to correctly isolate
// the elements of the specified datatype.
Value *CodeGenFunction::EmitSVEPredicateCast(Value *Pred,
llvm::ScalableVectorType *VTy) {
auto *RTy = llvm::VectorType::get(IntegerType::get(getLLVMContext(), 1), VTy);
if (Pred->getType() == RTy)
return Pred;
unsigned IntID;
llvm::Type *IntrinsicTy;
switch (VTy->getMinNumElements()) {
default:
llvm_unreachable("unsupported element count!");
case 2:
case 4:
case 8:
IntID = Intrinsic::aarch64_sve_convert_from_svbool;
IntrinsicTy = RTy;
break;
case 16:
IntID = Intrinsic::aarch64_sve_convert_to_svbool;
IntrinsicTy = Pred->getType();
break;
}
Function *F = CGM.getIntrinsic(IntID, IntrinsicTy);
Value *C = Builder.CreateCall(F, Pred);
assert(C->getType() == RTy && "Unexpected return type!");
return C;
}
Value *CodeGenFunction::EmitSVEGatherLoad(SVETypeFlags TypeFlags,
SmallVectorImpl<Value *> &Ops,
unsigned IntID) {
auto *ResultTy = getSVEType(TypeFlags);
auto *OverloadedTy =
llvm::ScalableVectorType::get(SVEBuiltinMemEltTy(TypeFlags), ResultTy);
// At the ACLE level there's only one predicate type, svbool_t, which is
// mapped to <n x 16 x i1>. However, this might be incompatible with the
// actual type being loaded. For example, when loading doubles (i64) the
// predicated should be <n x 2 x i1> instead. At the IR level the type of
// the predicate and the data being loaded must match. Cast accordingly.
Ops[0] = EmitSVEPredicateCast(Ops[0], OverloadedTy);
Function *F = nullptr;
if (Ops[1]->getType()->isVectorTy())
// This is the "vector base, scalar offset" case. In order to uniquely
// map this built-in to an LLVM IR intrinsic, we need both the return type
// and the type of the vector base.
F = CGM.getIntrinsic(IntID, {OverloadedTy, Ops[1]->getType()});
else
// This is the "scalar base, vector offset case". The type of the offset
// is encoded in the name of the intrinsic. We only need to specify the
// return type in order to uniquely map this built-in to an LLVM IR
// intrinsic.
F = CGM.getIntrinsic(IntID, OverloadedTy);
// Pass 0 when the offset is missing. This can only be applied when using
// the "vector base" addressing mode for which ACLE allows no offset. The
// corresponding LLVM IR always requires an offset.
if (Ops.size() == 2) {
assert(Ops[1]->getType()->isVectorTy() && "Scalar base requires an offset");
Ops.push_back(ConstantInt::get(Int64Ty, 0));
}
// For "vector base, scalar index" scale the index so that it becomes a
// scalar offset.
if (!TypeFlags.isByteIndexed() && Ops[1]->getType()->isVectorTy()) {
unsigned BytesPerElt =
OverloadedTy->getElementType()->getScalarSizeInBits() / 8;
Value *Scale = ConstantInt::get(Int64Ty, BytesPerElt);
Ops[2] = Builder.CreateMul(Ops[2], Scale);
}
Value *Call = Builder.CreateCall(F, Ops);
// The following sext/zext is only needed when ResultTy != OverloadedTy. In
// other cases it's folded into a nop.
return TypeFlags.isZExtReturn() ? Builder.CreateZExt(Call, ResultTy)
: Builder.CreateSExt(Call, ResultTy);
}
Value *CodeGenFunction::EmitSVEScatterStore(SVETypeFlags TypeFlags,
SmallVectorImpl<Value *> &Ops,
unsigned IntID) {
auto *SrcDataTy = getSVEType(TypeFlags);
auto *OverloadedTy =
llvm::ScalableVectorType::get(SVEBuiltinMemEltTy(TypeFlags), SrcDataTy);
// In ACLE the source data is passed in the last argument, whereas in LLVM IR
// it's the first argument. Move it accordingly.
Ops.insert(Ops.begin(), Ops.pop_back_val());
Function *F = nullptr;
if (Ops[2]->getType()->isVectorTy())
// This is the "vector base, scalar offset" case. In order to uniquely
// map this built-in to an LLVM IR intrinsic, we need both the return type
// and the type of the vector base.
F = CGM.getIntrinsic(IntID, {OverloadedTy, Ops[2]->getType()});
else
// This is the "scalar base, vector offset case". The type of the offset
// is encoded in the name of the intrinsic. We only need to specify the
// return type in order to uniquely map this built-in to an LLVM IR
// intrinsic.
F = CGM.getIntrinsic(IntID, OverloadedTy);
// Pass 0 when the offset is missing. This can only be applied when using
// the "vector base" addressing mode for which ACLE allows no offset. The
// corresponding LLVM IR always requires an offset.
if (Ops.size() == 3) {
assert(Ops[1]->getType()->isVectorTy() && "Scalar base requires an offset");
Ops.push_back(ConstantInt::get(Int64Ty, 0));
}
// Truncation is needed when SrcDataTy != OverloadedTy. In other cases it's
// folded into a nop.
Ops[0] = Builder.CreateTrunc(Ops[0], OverloadedTy);
// At the ACLE level there's only one predicate type, svbool_t, which is
// mapped to <n x 16 x i1>. However, this might be incompatible with the
// actual type being stored. For example, when storing doubles (i64) the
// predicated should be <n x 2 x i1> instead. At the IR level the type of
// the predicate and the data being stored must match. Cast accordingly.
Ops[1] = EmitSVEPredicateCast(Ops[1], OverloadedTy);
// For "vector base, scalar index" scale the index so that it becomes a
// scalar offset.
if (!TypeFlags.isByteIndexed() && Ops[2]->getType()->isVectorTy()) {
unsigned BytesPerElt =
OverloadedTy->getElementType()->getScalarSizeInBits() / 8;
Value *Scale = ConstantInt::get(Int64Ty, BytesPerElt);
Ops[3] = Builder.CreateMul(Ops[3], Scale);
}
return Builder.CreateCall(F, Ops);
}
Value *CodeGenFunction::EmitSVEGatherPrefetch(SVETypeFlags TypeFlags,
SmallVectorImpl<Value *> &Ops,
unsigned IntID) {
// The gather prefetches are overloaded on the vector input - this can either
// be the vector of base addresses or vector of offsets.
auto *OverloadedTy = dyn_cast<llvm::ScalableVectorType>(Ops[1]->getType());
if (!OverloadedTy)
OverloadedTy = cast<llvm::ScalableVectorType>(Ops[2]->getType());
// Cast the predicate from svbool_t to the right number of elements.
Ops[0] = EmitSVEPredicateCast(Ops[0], OverloadedTy);
// vector + imm addressing modes
if (Ops[1]->getType()->isVectorTy()) {
if (Ops.size() == 3) {
// Pass 0 for 'vector+imm' when the index is omitted.
Ops.push_back(ConstantInt::get(Int64Ty, 0));
// The sv_prfop is the last operand in the builtin and IR intrinsic.
std::swap(Ops[2], Ops[3]);
} else {
// Index needs to be passed as scaled offset.
llvm::Type *MemEltTy = SVEBuiltinMemEltTy(TypeFlags);
unsigned BytesPerElt = MemEltTy->getPrimitiveSizeInBits() / 8;
Value *Scale = ConstantInt::get(Int64Ty, BytesPerElt);
Ops[2] = Builder.CreateMul(Ops[2], Scale);
}
}
Function *F = CGM.getIntrinsic(IntID, OverloadedTy);
return Builder.CreateCall(F, Ops);
}
Value *CodeGenFunction::EmitSVEStructLoad(SVETypeFlags TypeFlags,
SmallVectorImpl<Value*> &Ops,
unsigned IntID) {
llvm::ScalableVectorType *VTy = getSVEType(TypeFlags);
auto VecPtrTy = llvm::PointerType::getUnqual(VTy);
auto EltPtrTy = llvm::PointerType::getUnqual(VTy->getElementType());
unsigned N;
switch (IntID) {
case Intrinsic::aarch64_sve_ld2:
N = 2;
break;
case Intrinsic::aarch64_sve_ld3:
N = 3;
break;
case Intrinsic::aarch64_sve_ld4:
N = 4;
break;
default:
llvm_unreachable("unknown intrinsic!");
}
auto RetTy = llvm::VectorType::get(VTy->getElementType(),
VTy->getElementCount() * N);
Value *Predicate = EmitSVEPredicateCast(Ops[0], VTy);
Value *BasePtr= Builder.CreateBitCast(Ops[1], VecPtrTy);
Value *Offset = Ops.size() > 2 ? Ops[2] : Builder.getInt32(0);
BasePtr = Builder.CreateGEP(VTy, BasePtr, Offset);
BasePtr = Builder.CreateBitCast(BasePtr, EltPtrTy);
Function *F = CGM.getIntrinsic(IntID, {RetTy, Predicate->getType()});
return Builder.CreateCall(F, { Predicate, BasePtr });
}
Value *CodeGenFunction::EmitSVEStructStore(SVETypeFlags TypeFlags,
SmallVectorImpl<Value*> &Ops,
unsigned IntID) {
llvm::ScalableVectorType *VTy = getSVEType(TypeFlags);
auto VecPtrTy = llvm::PointerType::getUnqual(VTy);
auto EltPtrTy = llvm::PointerType::getUnqual(VTy->getElementType());
unsigned N;
switch (IntID) {
case Intrinsic::aarch64_sve_st2:
N = 2;
break;
case Intrinsic::aarch64_sve_st3:
N = 3;
break;
case Intrinsic::aarch64_sve_st4:
N = 4;
break;
default:
llvm_unreachable("unknown intrinsic!");
}
auto TupleTy =
llvm::VectorType::get(VTy->getElementType(), VTy->getElementCount() * N);
Value *Predicate = EmitSVEPredicateCast(Ops[0], VTy);
Value *BasePtr = Builder.CreateBitCast(Ops[1], VecPtrTy);
Value *Offset = Ops.size() > 3 ? Ops[2] : Builder.getInt32(0);
Value *Val = Ops.back();
BasePtr = Builder.CreateGEP(VTy, BasePtr, Offset);
BasePtr = Builder.CreateBitCast(BasePtr, EltPtrTy);
// The llvm.aarch64.sve.st2/3/4 intrinsics take legal part vectors, so we
// need to break up the tuple vector.
SmallVector<llvm::Value*, 5> Operands;
Function *FExtr =
CGM.getIntrinsic(Intrinsic::aarch64_sve_tuple_get, {VTy, TupleTy});
for (unsigned I = 0; I < N; ++I)
Operands.push_back(Builder.CreateCall(FExtr, {Val, Builder.getInt32(I)}));
Operands.append({Predicate, BasePtr});
Function *F = CGM.getIntrinsic(IntID, { VTy });
return Builder.CreateCall(F, Operands);
}
// SVE2's svpmullb and svpmullt builtins are similar to the svpmullb_pair and
// svpmullt_pair intrinsics, with the exception that their results are bitcast
// to a wider type.
Value *CodeGenFunction::EmitSVEPMull(SVETypeFlags TypeFlags,
SmallVectorImpl<Value *> &Ops,
unsigned BuiltinID) {
// Splat scalar operand to vector (intrinsics with _n infix)
if (TypeFlags.hasSplatOperand()) {
unsigned OpNo = TypeFlags.getSplatOperand();
Ops[OpNo] = EmitSVEDupX(Ops[OpNo]);
}
// The pair-wise function has a narrower overloaded type.
Function *F = CGM.getIntrinsic(BuiltinID, Ops[0]->getType());
Value *Call = Builder.CreateCall(F, {Ops[0], Ops[1]});
// Now bitcast to the wider result type.
llvm::ScalableVectorType *Ty = getSVEType(TypeFlags);
return EmitSVEReinterpret(Call, Ty);
}
Value *CodeGenFunction::EmitSVEMovl(SVETypeFlags TypeFlags,
ArrayRef<Value *> Ops, unsigned BuiltinID) {
llvm::Type *OverloadedTy = getSVEType(TypeFlags);
Function *F = CGM.getIntrinsic(BuiltinID, OverloadedTy);
return Builder.CreateCall(F, {Ops[0], Builder.getInt32(0)});
}
Value *CodeGenFunction::EmitSVEPrefetchLoad(SVETypeFlags TypeFlags,
SmallVectorImpl<Value *> &Ops,
unsigned BuiltinID) {
auto *MemEltTy = SVEBuiltinMemEltTy(TypeFlags);
auto *VectorTy = getSVEVectorForElementType(MemEltTy);
auto *MemoryTy = llvm::ScalableVectorType::get(MemEltTy, VectorTy);
Value *Predicate = EmitSVEPredicateCast(Ops[0], MemoryTy);
Value *BasePtr = Ops[1];
// Implement the index operand if not omitted.
if (Ops.size() > 3) {
BasePtr = Builder.CreateBitCast(BasePtr, MemoryTy->getPointerTo());
BasePtr = Builder.CreateGEP(MemoryTy, BasePtr, Ops[2]);
}
// Prefetch intriniscs always expect an i8*
BasePtr = Builder.CreateBitCast(BasePtr, llvm::PointerType::getUnqual(Int8Ty));
Value *PrfOp = Ops.back();
Function *F = CGM.getIntrinsic(BuiltinID, Predicate->getType());
return Builder.CreateCall(F, {Predicate, BasePtr, PrfOp});
}
Value *CodeGenFunction::EmitSVEMaskedLoad(const CallExpr *E,
llvm::Type *ReturnTy,
SmallVectorImpl<Value *> &Ops,
unsigned BuiltinID,
bool IsZExtReturn) {
QualType LangPTy = E->getArg(1)->getType();
llvm::Type *MemEltTy = CGM.getTypes().ConvertType(
LangPTy->getAs<PointerType>()->getPointeeType());
// The vector type that is returned may be different from the
// eventual type loaded from memory.
auto VectorTy = cast<llvm::ScalableVectorType>(ReturnTy);
auto MemoryTy = llvm::ScalableVectorType::get(MemEltTy, VectorTy);
Value *Predicate = EmitSVEPredicateCast(Ops[0], MemoryTy);
Value *BasePtr = Builder.CreateBitCast(Ops[1], MemoryTy->getPointerTo());
Value *Offset = Ops.size() > 2 ? Ops[2] : Builder.getInt32(0);
BasePtr = Builder.CreateGEP(MemoryTy, BasePtr, Offset);
BasePtr = Builder.CreateBitCast(BasePtr, MemEltTy->getPointerTo());
Function *F = CGM.getIntrinsic(BuiltinID, MemoryTy);
Value *Load = Builder.CreateCall(F, {Predicate, BasePtr});
return IsZExtReturn ? Builder.CreateZExt(Load, VectorTy)
: Builder.CreateSExt(Load, VectorTy);
}
Value *CodeGenFunction::EmitSVEMaskedStore(const CallExpr *E,
SmallVectorImpl<Value *> &Ops,
unsigned BuiltinID) {
QualType LangPTy = E->getArg(1)->getType();
llvm::Type *MemEltTy = CGM.getTypes().ConvertType(
LangPTy->getAs<PointerType>()->getPointeeType());
// The vector type that is stored may be different from the
// eventual type stored to memory.
auto VectorTy = cast<llvm::ScalableVectorType>(Ops.back()->getType());
auto MemoryTy = llvm::ScalableVectorType::get(MemEltTy, VectorTy);
Value *Predicate = EmitSVEPredicateCast(Ops[0], MemoryTy);
Value *BasePtr = Builder.CreateBitCast(Ops[1], MemoryTy->getPointerTo());
Value *Offset = Ops.size() == 4 ? Ops[2] : Builder.getInt32(0);
BasePtr = Builder.CreateGEP(MemoryTy, BasePtr, Offset);
// Last value is always the data
llvm::Value *Val = Builder.CreateTrunc(Ops.back(), MemoryTy);
BasePtr = Builder.CreateBitCast(BasePtr, MemEltTy->getPointerTo());
Function *F = CGM.getIntrinsic(BuiltinID, MemoryTy);
return Builder.CreateCall(F, {Val, Predicate, BasePtr});
}
// Limit the usage of scalable llvm IR generated by the ACLE by using the
// sve dup.x intrinsic instead of IRBuilder::CreateVectorSplat.
Value *CodeGenFunction::EmitSVEDupX(Value *Scalar, llvm::Type *Ty) {
auto F = CGM.getIntrinsic(Intrinsic::aarch64_sve_dup_x, Ty);
return Builder.CreateCall(F, Scalar);
}
Value *CodeGenFunction::EmitSVEDupX(Value* Scalar) {
return EmitSVEDupX(Scalar, getSVEVectorForElementType(Scalar->getType()));
}
Value *CodeGenFunction::EmitSVEReinterpret(Value *Val, llvm::Type *Ty) {
// FIXME: For big endian this needs an additional REV, or needs a separate
// intrinsic that is code-generated as a no-op, because the LLVM bitcast
// instruction is defined as 'bitwise' equivalent from memory point of
// view (when storing/reloading), whereas the svreinterpret builtin
// implements bitwise equivalent cast from register point of view.
// LLVM CodeGen for a bitcast must add an explicit REV for big-endian.
return Builder.CreateBitCast(Val, Ty);
}
static void InsertExplicitZeroOperand(CGBuilderTy &Builder, llvm::Type *Ty,
SmallVectorImpl<Value *> &Ops) {
auto *SplatZero = Constant::getNullValue(Ty);
Ops.insert(Ops.begin(), SplatZero);
}
static void InsertExplicitUndefOperand(CGBuilderTy &Builder, llvm::Type *Ty,
SmallVectorImpl<Value *> &Ops) {
auto *SplatUndef = UndefValue::get(Ty);
Ops.insert(Ops.begin(), SplatUndef);
}
SmallVector<llvm::Type *, 2> CodeGenFunction::getSVEOverloadTypes(
SVETypeFlags TypeFlags, llvm::Type *ResultType, ArrayRef<Value *> Ops) {
if (TypeFlags.isOverloadNone())
return {};
llvm::Type *DefaultType = getSVEType(TypeFlags);
if (TypeFlags.isOverloadWhile())
return {DefaultType, Ops[1]->getType()};
if (TypeFlags.isOverloadWhileRW())
return {getSVEPredType(TypeFlags), Ops[0]->getType()};
if (TypeFlags.isOverloadCvt() || TypeFlags.isTupleSet())
return {Ops[0]->getType(), Ops.back()->getType()};
if (TypeFlags.isTupleCreate() || TypeFlags.isTupleGet())
return {ResultType, Ops[0]->getType()};
assert(TypeFlags.isOverloadDefault() && "Unexpected value for overloads");
return {DefaultType};
}
Value *CodeGenFunction::EmitAArch64SVEBuiltinExpr(unsigned BuiltinID,
const CallExpr *E) {
// Find out if any arguments are required to be integer constant expressions.
unsigned ICEArguments = 0;
ASTContext::GetBuiltinTypeError Error;
getContext().GetBuiltinType(BuiltinID, Error, &ICEArguments);
assert(Error == ASTContext::GE_None && "Should not codegen an error");
llvm::Type *Ty = ConvertType(E->getType());
if (BuiltinID >= SVE::BI__builtin_sve_reinterpret_s8_s8 &&
BuiltinID <= SVE::BI__builtin_sve_reinterpret_f64_f64) {
Value *Val = EmitScalarExpr(E->getArg(0));
return EmitSVEReinterpret(Val, Ty);
}
llvm::SmallVector<Value *, 4> Ops;
for (unsigned i = 0, e = E->getNumArgs(); i != e; i++) {
if ((ICEArguments & (1 << i)) == 0)
Ops.push_back(EmitScalarExpr(E->getArg(i)));
else {
// If this is required to be a constant, constant fold it so that we know
// that the generated intrinsic gets a ConstantInt.
Optional<llvm::APSInt> Result =
E->getArg(i)->getIntegerConstantExpr(getContext());
assert(Result && "Expected argument to be a constant");
// Immediates for SVE llvm intrinsics are always 32bit. We can safely
// truncate because the immediate has been range checked and no valid
// immediate requires more than a handful of bits.
*Result = Result->extOrTrunc(32);
Ops.push_back(llvm::ConstantInt::get(getLLVMContext(), *Result));
}
}
auto *Builtin = findARMVectorIntrinsicInMap(AArch64SVEIntrinsicMap, BuiltinID,
AArch64SVEIntrinsicsProvenSorted);
SVETypeFlags TypeFlags(Builtin->TypeModifier);
if (TypeFlags.isLoad())
return EmitSVEMaskedLoad(E, Ty, Ops, Builtin->LLVMIntrinsic,
TypeFlags.isZExtReturn());
else if (TypeFlags.isStore())
return EmitSVEMaskedStore(E, Ops, Builtin->LLVMIntrinsic);
else if (TypeFlags.isGatherLoad())
return EmitSVEGatherLoad(TypeFlags, Ops, Builtin->LLVMIntrinsic);
else if (TypeFlags.isScatterStore())
return EmitSVEScatterStore(TypeFlags, Ops, Builtin->LLVMIntrinsic);
else if (TypeFlags.isPrefetch())
return EmitSVEPrefetchLoad(TypeFlags, Ops, Builtin->LLVMIntrinsic);
else if (TypeFlags.isGatherPrefetch())
return EmitSVEGatherPrefetch(TypeFlags, Ops, Builtin->LLVMIntrinsic);
else if (TypeFlags.isStructLoad())
return EmitSVEStructLoad(TypeFlags, Ops, Builtin->LLVMIntrinsic);
else if (TypeFlags.isStructStore())
return EmitSVEStructStore(TypeFlags, Ops, Builtin->LLVMIntrinsic);
else if (TypeFlags.isUndef())
return UndefValue::get(Ty);
else if (Builtin->LLVMIntrinsic != 0) {
if (TypeFlags.getMergeType() == SVETypeFlags::MergeZeroExp)
InsertExplicitZeroOperand(Builder, Ty, Ops);
if (TypeFlags.getMergeType() == SVETypeFlags::MergeAnyExp)
InsertExplicitUndefOperand(Builder, Ty, Ops);
// Some ACLE builtins leave out the argument to specify the predicate
// pattern, which is expected to be expanded to an SV_ALL pattern.
if (TypeFlags.isAppendSVALL())
Ops.push_back(Builder.getInt32(/*SV_ALL*/ 31));
if (TypeFlags.isInsertOp1SVALL())
Ops.insert(&Ops[1], Builder.getInt32(/*SV_ALL*/ 31));
// Predicates must match the main datatype.
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
if (auto PredTy = dyn_cast<llvm::VectorType>(Ops[i]->getType()))
if (PredTy->getElementType()->isIntegerTy(1))
Ops[i] = EmitSVEPredicateCast(Ops[i], getSVEType(TypeFlags));
// Splat scalar operand to vector (intrinsics with _n infix)
if (TypeFlags.hasSplatOperand()) {
unsigned OpNo = TypeFlags.getSplatOperand();
Ops[OpNo] = EmitSVEDupX(Ops[OpNo]);
}
if (TypeFlags.isReverseCompare())
std::swap(Ops[1], Ops[2]);
if (TypeFlags.isReverseUSDOT())
std::swap(Ops[1], Ops[2]);
// Predicated intrinsics with _z suffix need a select w/ zeroinitializer.
if (TypeFlags.getMergeType() == SVETypeFlags::MergeZero) {
llvm::Type *OpndTy = Ops[1]->getType();
auto *SplatZero = Constant::getNullValue(OpndTy);
Function *Sel = CGM.getIntrinsic(Intrinsic::aarch64_sve_sel, OpndTy);
Ops[1] = Builder.CreateCall(Sel, {Ops[0], Ops[1], SplatZero});
}
Function *F = CGM.getIntrinsic(Builtin->LLVMIntrinsic,
getSVEOverloadTypes(TypeFlags, Ty, Ops));
Value *Call = Builder.CreateCall(F, Ops);
// Predicate results must be converted to svbool_t.
if (auto PredTy = dyn_cast<llvm::VectorType>(Call->getType()))
if (PredTy->getScalarType()->isIntegerTy(1))
Call = EmitSVEPredicateCast(Call, cast<llvm::ScalableVectorType>(Ty));
return Call;
}
switch (BuiltinID) {
default:
return nullptr;
case SVE::BI__builtin_sve_svmov_b_z: {
// svmov_b_z(pg, op) <=> svand_b_z(pg, op, op)
SVETypeFlags TypeFlags(Builtin->TypeModifier);
llvm::Type* OverloadedTy = getSVEType(TypeFlags);
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_sve_and_z, OverloadedTy);
return Builder.CreateCall(F, {Ops[0], Ops[1], Ops[1]});
}
case SVE::BI__builtin_sve_svnot_b_z: {
// svnot_b_z(pg, op) <=> sveor_b_z(pg, op, pg)
SVETypeFlags TypeFlags(Builtin->TypeModifier);
llvm::Type* OverloadedTy = getSVEType(TypeFlags);
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_sve_eor_z, OverloadedTy);
return Builder.CreateCall(F, {Ops[0], Ops[1], Ops[0]});
}
case SVE::BI__builtin_sve_svmovlb_u16:
case SVE::BI__builtin_sve_svmovlb_u32:
case SVE::BI__builtin_sve_svmovlb_u64:
return EmitSVEMovl(TypeFlags, Ops, Intrinsic::aarch64_sve_ushllb);
case SVE::BI__builtin_sve_svmovlb_s16:
case SVE::BI__builtin_sve_svmovlb_s32:
case SVE::BI__builtin_sve_svmovlb_s64:
return EmitSVEMovl(TypeFlags, Ops, Intrinsic::aarch64_sve_sshllb);
case SVE::BI__builtin_sve_svmovlt_u16:
case SVE::BI__builtin_sve_svmovlt_u32:
case SVE::BI__builtin_sve_svmovlt_u64:
return EmitSVEMovl(TypeFlags, Ops, Intrinsic::aarch64_sve_ushllt);
case SVE::BI__builtin_sve_svmovlt_s16:
case SVE::BI__builtin_sve_svmovlt_s32:
case SVE::BI__builtin_sve_svmovlt_s64:
return EmitSVEMovl(TypeFlags, Ops, Intrinsic::aarch64_sve_sshllt);
case SVE::BI__builtin_sve_svpmullt_u16:
case SVE::BI__builtin_sve_svpmullt_u64:
case SVE::BI__builtin_sve_svpmullt_n_u16:
case SVE::BI__builtin_sve_svpmullt_n_u64:
return EmitSVEPMull(TypeFlags, Ops, Intrinsic::aarch64_sve_pmullt_pair);
case SVE::BI__builtin_sve_svpmullb_u16:
case SVE::BI__builtin_sve_svpmullb_u64:
case SVE::BI__builtin_sve_svpmullb_n_u16:
case SVE::BI__builtin_sve_svpmullb_n_u64:
return EmitSVEPMull(TypeFlags, Ops, Intrinsic::aarch64_sve_pmullb_pair);
case SVE::BI__builtin_sve_svdup_n_b8:
case SVE::BI__builtin_sve_svdup_n_b16:
case SVE::BI__builtin_sve_svdup_n_b32:
case SVE::BI__builtin_sve_svdup_n_b64: {
Value *CmpNE =
Builder.CreateICmpNE(Ops[0], Constant::getNullValue(Ops[0]->getType()));
llvm::ScalableVectorType *OverloadedTy = getSVEType(TypeFlags);
Value *Dup = EmitSVEDupX(CmpNE, OverloadedTy);
return EmitSVEPredicateCast(Dup, cast<llvm::ScalableVectorType>(Ty));
}
case SVE::BI__builtin_sve_svdupq_n_b8:
case SVE::BI__builtin_sve_svdupq_n_b16:
case SVE::BI__builtin_sve_svdupq_n_b32:
case SVE::BI__builtin_sve_svdupq_n_b64:
case SVE::BI__builtin_sve_svdupq_n_u8:
case SVE::BI__builtin_sve_svdupq_n_s8:
case SVE::BI__builtin_sve_svdupq_n_u64:
case SVE::BI__builtin_sve_svdupq_n_f64:
case SVE::BI__builtin_sve_svdupq_n_s64:
case SVE::BI__builtin_sve_svdupq_n_u16:
case SVE::BI__builtin_sve_svdupq_n_f16:
case SVE::BI__builtin_sve_svdupq_n_bf16:
case SVE::BI__builtin_sve_svdupq_n_s16:
case SVE::BI__builtin_sve_svdupq_n_u32:
case SVE::BI__builtin_sve_svdupq_n_f32:
case SVE::BI__builtin_sve_svdupq_n_s32: {
// These builtins are implemented by storing each element to an array and using
// ld1rq to materialize a vector.
unsigned NumOpnds = Ops.size();
bool IsBoolTy =
cast<llvm::VectorType>(Ty)->getElementType()->isIntegerTy(1);
// For svdupq_n_b* the element type of is an integer of type 128/numelts,
// so that the compare can use the width that is natural for the expected
// number of predicate lanes.
llvm::Type *EltTy = Ops[0]->getType();
if (IsBoolTy)
EltTy = IntegerType::get(getLLVMContext(), SVEBitsPerBlock / NumOpnds);
Address Alloca = CreateTempAlloca(llvm::ArrayType::get(EltTy, NumOpnds),
CharUnits::fromQuantity(16));
for (unsigned I = 0; I < NumOpnds; ++I)
Builder.CreateDefaultAlignedStore(
IsBoolTy ? Builder.CreateZExt(Ops[I], EltTy) : Ops[I],
Builder.CreateGEP(Alloca.getPointer(),
{Builder.getInt64(0), Builder.getInt64(I)}));
SVETypeFlags TypeFlags(Builtin->TypeModifier);
Value *Pred = EmitSVEAllTruePred(TypeFlags);
llvm::Type *OverloadedTy = getSVEVectorForElementType(EltTy);
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_sve_ld1rq, OverloadedTy);
Value *Alloca0 = Builder.CreateGEP(
Alloca.getPointer(), {Builder.getInt64(0), Builder.getInt64(0)});
Value *LD1RQ = Builder.CreateCall(F, {Pred, Alloca0});
if (!IsBoolTy)
return LD1RQ;
// For svdupq_n_b* we need to add an additional 'cmpne' with '0'.
F = CGM.getIntrinsic(NumOpnds == 2 ? Intrinsic::aarch64_sve_cmpne
: Intrinsic::aarch64_sve_cmpne_wide,
OverloadedTy);
Value *Call =
Builder.CreateCall(F, {Pred, LD1RQ, EmitSVEDupX(Builder.getInt64(0))});
return EmitSVEPredicateCast(Call, cast<llvm::ScalableVectorType>(Ty));
}
case SVE::BI__builtin_sve_svpfalse_b:
return ConstantInt::getFalse(Ty);
case SVE::BI__builtin_sve_svlen_bf16:
case SVE::BI__builtin_sve_svlen_f16:
case SVE::BI__builtin_sve_svlen_f32:
case SVE::BI__builtin_sve_svlen_f64:
case SVE::BI__builtin_sve_svlen_s8:
case SVE::BI__builtin_sve_svlen_s16:
case SVE::BI__builtin_sve_svlen_s32:
case SVE::BI__builtin_sve_svlen_s64:
case SVE::BI__builtin_sve_svlen_u8:
case SVE::BI__builtin_sve_svlen_u16:
case SVE::BI__builtin_sve_svlen_u32:
case SVE::BI__builtin_sve_svlen_u64: {
SVETypeFlags TF(Builtin->TypeModifier);
auto VTy = cast<llvm::VectorType>(getSVEType(TF));
auto *NumEls =
llvm::ConstantInt::get(Ty, VTy->getElementCount().getKnownMinValue());
Function *F = CGM.getIntrinsic(Intrinsic::vscale, Ty);
return Builder.CreateMul(NumEls, Builder.CreateCall(F));
}
case SVE::BI__builtin_sve_svtbl2_u8:
case SVE::BI__builtin_sve_svtbl2_s8:
case SVE::BI__builtin_sve_svtbl2_u16:
case SVE::BI__builtin_sve_svtbl2_s16:
case SVE::BI__builtin_sve_svtbl2_u32:
case SVE::BI__builtin_sve_svtbl2_s32:
case SVE::BI__builtin_sve_svtbl2_u64:
case SVE::BI__builtin_sve_svtbl2_s64:
case SVE::BI__builtin_sve_svtbl2_f16:
case SVE::BI__builtin_sve_svtbl2_bf16:
case SVE::BI__builtin_sve_svtbl2_f32:
case SVE::BI__builtin_sve_svtbl2_f64: {
SVETypeFlags TF(Builtin->TypeModifier);
auto VTy = cast<llvm::VectorType>(getSVEType(TF));
auto TupleTy = llvm::VectorType::getDoubleElementsVectorType(VTy);
Function *FExtr =
CGM.getIntrinsic(Intrinsic::aarch64_sve_tuple_get, {VTy, TupleTy});
Value *V0 = Builder.CreateCall(FExtr, {Ops[0], Builder.getInt32(0)});
Value *V1 = Builder.CreateCall(FExtr, {Ops[0], Builder.getInt32(1)});
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_sve_tbl2, VTy);
return Builder.CreateCall(F, {V0, V1, Ops[1]});
}
}
/// Should not happen
return nullptr;
}
Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID,
const CallExpr *E,
llvm::Triple::ArchType Arch) {
if (BuiltinID >= AArch64::FirstSVEBuiltin &&
BuiltinID <= AArch64::LastSVEBuiltin)
return EmitAArch64SVEBuiltinExpr(BuiltinID, E);
unsigned HintID = static_cast<unsigned>(-1);
switch (BuiltinID) {
default: break;
case AArch64::BI__builtin_arm_nop:
HintID = 0;
break;
case AArch64::BI__builtin_arm_yield:
case AArch64::BI__yield:
HintID = 1;
break;
case AArch64::BI__builtin_arm_wfe:
case AArch64::BI__wfe:
HintID = 2;
break;
case AArch64::BI__builtin_arm_wfi:
case AArch64::BI__wfi:
HintID = 3;
break;
case AArch64::BI__builtin_arm_sev:
case AArch64::BI__sev:
HintID = 4;
break;
case AArch64::BI__builtin_arm_sevl:
case AArch64::BI__sevl:
HintID = 5;
break;
}
if (HintID != static_cast<unsigned>(-1)) {
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_hint);
return Builder.CreateCall(F, llvm::ConstantInt::get(Int32Ty, HintID));
}
if (BuiltinID == AArch64::BI__builtin_arm_prefetch) {
Value *Address = EmitScalarExpr(E->getArg(0));
Value *RW = EmitScalarExpr(E->getArg(1));
Value *CacheLevel = EmitScalarExpr(E->getArg(2));
Value *RetentionPolicy = EmitScalarExpr(E->getArg(3));
Value *IsData = EmitScalarExpr(E->getArg(4));
Value *Locality = nullptr;
if (cast<llvm::ConstantInt>(RetentionPolicy)->isZero()) {
// Temporal fetch, needs to convert cache level to locality.
Locality = llvm::ConstantInt::get(Int32Ty,
-cast<llvm::ConstantInt>(CacheLevel)->getValue() + 3);
} else {
// Streaming fetch.
Locality = llvm::ConstantInt::get(Int32Ty, 0);
}
// FIXME: We need AArch64 specific LLVM intrinsic if we want to specify
// PLDL3STRM or PLDL2STRM.
Function *F = CGM.getIntrinsic(Intrinsic::prefetch, Address->getType());
return Builder.CreateCall(F, {Address, RW, Locality, IsData});
}
if (BuiltinID == AArch64::BI__builtin_arm_rbit) {
assert((getContext().getTypeSize(E->getType()) == 32) &&
"rbit of unusual size!");
llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(
CGM.getIntrinsic(Intrinsic::bitreverse, Arg->getType()), Arg, "rbit");
}
if (BuiltinID == AArch64::BI__builtin_arm_rbit64) {
assert((getContext().getTypeSize(E->getType()) == 64) &&
"rbit of unusual size!");
llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(
CGM.getIntrinsic(Intrinsic::bitreverse, Arg->getType()), Arg, "rbit");
}
if (BuiltinID == AArch64::BI__builtin_arm_cls) {
llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::aarch64_cls), Arg,
"cls");
}
if (BuiltinID == AArch64::BI__builtin_arm_cls64) {
llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::aarch64_cls64), Arg,
"cls");
}
if (BuiltinID == AArch64::BI__builtin_arm_jcvt) {
assert((getContext().getTypeSize(E->getType()) == 32) &&
"__jcvt of unusual size!");
llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(
CGM.getIntrinsic(Intrinsic::aarch64_fjcvtzs), Arg);
}
if (BuiltinID == AArch64::BI__clear_cache) {
assert(E->getNumArgs() == 2 && "__clear_cache takes 2 arguments");
const FunctionDecl *FD = E->getDirectCallee();
Value *Ops[2];
for (unsigned i = 0; i < 2; i++)
Ops[i] = EmitScalarExpr(E->getArg(i));
llvm::Type *Ty = CGM.getTypes().ConvertType(FD->getType());
llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);
StringRef Name = FD->getName();
return EmitNounwindRuntimeCall(CGM.CreateRuntimeFunction(FTy, Name), Ops);
}
if ((BuiltinID == AArch64::BI__builtin_arm_ldrex ||
BuiltinID == AArch64::BI__builtin_arm_ldaex) &&
getContext().getTypeSize(E->getType()) == 128) {
Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_ldaex
? Intrinsic::aarch64_ldaxp
: Intrinsic::aarch64_ldxp);
Value *LdPtr = EmitScalarExpr(E->getArg(0));
Value *Val = Builder.CreateCall(F, Builder.CreateBitCast(LdPtr, Int8PtrTy),
"ldxp");
Value *Val0 = Builder.CreateExtractValue(Val, 1);
Value *Val1 = Builder.CreateExtractValue(Val, 0);
llvm::Type *Int128Ty = llvm::IntegerType::get(getLLVMContext(), 128);
Val0 = Builder.CreateZExt(Val0, Int128Ty);
Val1 = Builder.CreateZExt(Val1, Int128Ty);
Value *ShiftCst = llvm::ConstantInt::get(Int128Ty, 64);
Val = Builder.CreateShl(Val0, ShiftCst, "shl", true /* nuw */);
Val = Builder.CreateOr(Val, Val1);
return Builder.CreateBitCast(Val, ConvertType(E->getType()));
} else if (BuiltinID == AArch64::BI__builtin_arm_ldrex ||
BuiltinID == AArch64::BI__builtin_arm_ldaex) {
Value *LoadAddr = EmitScalarExpr(E->getArg(0));
QualType Ty = E->getType();
llvm::Type *RealResTy = ConvertType(Ty);
llvm::Type *PtrTy = llvm::IntegerType::get(
getLLVMContext(), getContext().getTypeSize(Ty))->getPointerTo();
LoadAddr = Builder.CreateBitCast(LoadAddr, PtrTy);
Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_ldaex
? Intrinsic::aarch64_ldaxr
: Intrinsic::aarch64_ldxr,
PtrTy);
Value *Val = Builder.CreateCall(F, LoadAddr, "ldxr");
if (RealResTy->isPointerTy())
return Builder.CreateIntToPtr(Val, RealResTy);
llvm::Type *IntResTy = llvm::IntegerType::get(
getLLVMContext(), CGM.getDataLayout().getTypeSizeInBits(RealResTy));
Val = Builder.CreateTruncOrBitCast(Val, IntResTy);
return Builder.CreateBitCast(Val, RealResTy);
}
if ((BuiltinID == AArch64::BI__builtin_arm_strex ||
BuiltinID == AArch64::BI__builtin_arm_stlex) &&
getContext().getTypeSize(E->getArg(0)->getType()) == 128) {
Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_stlex
? Intrinsic::aarch64_stlxp
: Intrinsic::aarch64_stxp);
llvm::Type *STy = llvm::StructType::get(Int64Ty, Int64Ty);
Address Tmp = CreateMemTemp(E->getArg(0)->getType());
EmitAnyExprToMem(E->getArg(0), Tmp, Qualifiers(), /*init*/ true);
Tmp = Builder.CreateBitCast(Tmp, llvm::PointerType::getUnqual(STy));
llvm::Value *Val = Builder.CreateLoad(Tmp);
Value *Arg0 = Builder.CreateExtractValue(Val, 0);
Value *Arg1 = Builder.CreateExtractValue(Val, 1);
Value *StPtr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)),
Int8PtrTy);
return Builder.CreateCall(F, {Arg0, Arg1, StPtr}, "stxp");
}
if (BuiltinID == AArch64::BI__builtin_arm_strex ||
BuiltinID == AArch64::BI__builtin_arm_stlex) {
Value *StoreVal = EmitScalarExpr(E->getArg(0));
Value *StoreAddr = EmitScalarExpr(E->getArg(1));
QualType Ty = E->getArg(0)->getType();
llvm::Type *StoreTy = llvm::IntegerType::get(getLLVMContext(),
getContext().getTypeSize(Ty));
StoreAddr = Builder.CreateBitCast(StoreAddr, StoreTy->getPointerTo());
if (StoreVal->getType()->isPointerTy())
StoreVal = Builder.CreatePtrToInt(StoreVal, Int64Ty);
else {
llvm::Type *IntTy = llvm::IntegerType::get(
getLLVMContext(),
CGM.getDataLayout().getTypeSizeInBits(StoreVal->getType()));
StoreVal = Builder.CreateBitCast(StoreVal, IntTy);
StoreVal = Builder.CreateZExtOrBitCast(StoreVal, Int64Ty);
}
Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_stlex
? Intrinsic::aarch64_stlxr
: Intrinsic::aarch64_stxr,
StoreAddr->getType());
return Builder.CreateCall(F, {StoreVal, StoreAddr}, "stxr");
}
if (BuiltinID == AArch64::BI__getReg) {
Expr::EvalResult Result;
if (!E->getArg(0)->EvaluateAsInt(Result, CGM.getContext()))
llvm_unreachable("Sema will ensure that the parameter is constant");
llvm::APSInt Value = Result.Val.getInt();
LLVMContext &Context = CGM.getLLVMContext();
std::string Reg = Value == 31 ? "sp" : "x" + Value.toString(10);
llvm::Metadata *Ops[] = {llvm::MDString::get(Context, Reg)};
llvm::MDNode *RegName = llvm::MDNode::get(Context, Ops);
llvm::Value *Metadata = llvm::MetadataAsValue::get(Context, RegName);
llvm::Function *F =
CGM.getIntrinsic(llvm::Intrinsic::read_register, {Int64Ty});
return Builder.CreateCall(F, Metadata);
}
if (BuiltinID == AArch64::BI__builtin_arm_clrex) {
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_clrex);
return Builder.CreateCall(F);
}
if (BuiltinID == AArch64::BI_ReadWriteBarrier)
return Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent,
llvm::SyncScope::SingleThread);
// CRC32
Intrinsic::ID CRCIntrinsicID = Intrinsic::not_intrinsic;
switch (BuiltinID) {
case AArch64::BI__builtin_arm_crc32b:
CRCIntrinsicID = Intrinsic::aarch64_crc32b; break;
case AArch64::BI__builtin_arm_crc32cb:
CRCIntrinsicID = Intrinsic::aarch64_crc32cb; break;
case AArch64::BI__builtin_arm_crc32h:
CRCIntrinsicID = Intrinsic::aarch64_crc32h; break;
case AArch64::BI__builtin_arm_crc32ch:
CRCIntrinsicID = Intrinsic::aarch64_crc32ch; break;
case AArch64::BI__builtin_arm_crc32w:
CRCIntrinsicID = Intrinsic::aarch64_crc32w; break;
case AArch64::BI__builtin_arm_crc32cw:
CRCIntrinsicID = Intrinsic::aarch64_crc32cw; break;
case AArch64::BI__builtin_arm_crc32d:
CRCIntrinsicID = Intrinsic::aarch64_crc32x; break;
case AArch64::BI__builtin_arm_crc32cd:
CRCIntrinsicID = Intrinsic::aarch64_crc32cx; break;
}
if (CRCIntrinsicID != Intrinsic::not_intrinsic) {
Value *Arg0 = EmitScalarExpr(E->getArg(0));
Value *Arg1 = EmitScalarExpr(E->getArg(1));
Function *F = CGM.getIntrinsic(CRCIntrinsicID);
llvm::Type *DataTy = F->getFunctionType()->getParamType(1);
Arg1 = Builder.CreateZExtOrBitCast(Arg1, DataTy);
return Builder.CreateCall(F, {Arg0, Arg1});
}
// Memory Tagging Extensions (MTE) Intrinsics
Intrinsic::ID MTEIntrinsicID = Intrinsic::not_intrinsic;
switch (BuiltinID) {
case AArch64::BI__builtin_arm_irg:
MTEIntrinsicID = Intrinsic::aarch64_irg; break;
case AArch64::BI__builtin_arm_addg:
MTEIntrinsicID = Intrinsic::aarch64_addg; break;
case AArch64::BI__builtin_arm_gmi:
MTEIntrinsicID = Intrinsic::aarch64_gmi; break;
case AArch64::BI__builtin_arm_ldg:
MTEIntrinsicID = Intrinsic::aarch64_ldg; break;
case AArch64::BI__builtin_arm_stg:
MTEIntrinsicID = Intrinsic::aarch64_stg; break;
case AArch64::BI__builtin_arm_subp:
MTEIntrinsicID = Intrinsic::aarch64_subp; break;
}
if (MTEIntrinsicID != Intrinsic::not_intrinsic) {
llvm::Type *T = ConvertType(E->getType());
if (MTEIntrinsicID == Intrinsic::aarch64_irg) {
Value *Pointer = EmitScalarExpr(E->getArg(0));
Value *Mask = EmitScalarExpr(E->getArg(1));
Pointer = Builder.CreatePointerCast(Pointer, Int8PtrTy);
Mask = Builder.CreateZExt(Mask, Int64Ty);
Value *RV = Builder.CreateCall(
CGM.getIntrinsic(MTEIntrinsicID), {Pointer, Mask});
return Builder.CreatePointerCast(RV, T);
}
if (MTEIntrinsicID == Intrinsic::aarch64_addg) {
Value *Pointer = EmitScalarExpr(E->getArg(0));
Value *TagOffset = EmitScalarExpr(E->getArg(1));
Pointer = Builder.CreatePointerCast(Pointer, Int8PtrTy);
TagOffset = Builder.CreateZExt(TagOffset, Int64Ty);
Value *RV = Builder.CreateCall(
CGM.getIntrinsic(MTEIntrinsicID), {Pointer, TagOffset});
return Builder.CreatePointerCast(RV, T);
}
if (MTEIntrinsicID == Intrinsic::aarch64_gmi) {
Value *Pointer = EmitScalarExpr(E->getArg(0));
Value *ExcludedMask = EmitScalarExpr(E->getArg(1));
ExcludedMask = Builder.CreateZExt(ExcludedMask, Int64Ty);
Pointer = Builder.CreatePointerCast(Pointer, Int8PtrTy);
return Builder.CreateCall(
CGM.getIntrinsic(MTEIntrinsicID), {Pointer, ExcludedMask});
}
// Although it is possible to supply a different return
// address (first arg) to this intrinsic, for now we set
// return address same as input address.
if (MTEIntrinsicID == Intrinsic::aarch64_ldg) {
Value *TagAddress = EmitScalarExpr(E->getArg(0));
TagAddress = Builder.CreatePointerCast(TagAddress, Int8PtrTy);
Value *RV = Builder.CreateCall(
CGM.getIntrinsic(MTEIntrinsicID), {TagAddress, TagAddress});
return Builder.CreatePointerCast(RV, T);
}
// Although it is possible to supply a different tag (to set)
// to this intrinsic (as first arg), for now we supply
// the tag that is in input address arg (common use case).
if (MTEIntrinsicID == Intrinsic::aarch64_stg) {
Value *TagAddress = EmitScalarExpr(E->getArg(0));
TagAddress = Builder.CreatePointerCast(TagAddress, Int8PtrTy);
return Builder.CreateCall(
CGM.getIntrinsic(MTEIntrinsicID), {TagAddress, TagAddress});
}
if (MTEIntrinsicID == Intrinsic::aarch64_subp) {
Value *PointerA = EmitScalarExpr(E->getArg(0));
Value *PointerB = EmitScalarExpr(E->getArg(1));
PointerA = Builder.CreatePointerCast(PointerA, Int8PtrTy);
PointerB = Builder.CreatePointerCast(PointerB, Int8PtrTy);
return Builder.CreateCall(
CGM.getIntrinsic(MTEIntrinsicID), {PointerA, PointerB});
}
}
if (BuiltinID == AArch64::BI__builtin_arm_rsr ||
BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
BuiltinID == AArch64::BI__builtin_arm_rsrp ||
BuiltinID == AArch64::BI__builtin_arm_wsr ||
BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
BuiltinID == AArch64::BI__builtin_arm_wsrp) {
SpecialRegisterAccessKind AccessKind = Write;
if (BuiltinID == AArch64::BI__builtin_arm_rsr ||
BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
BuiltinID == AArch64::BI__builtin_arm_rsrp)
AccessKind = VolatileRead;
bool IsPointerBuiltin = BuiltinID == AArch64::BI__builtin_arm_rsrp ||
BuiltinID == AArch64::BI__builtin_arm_wsrp;
bool Is64Bit = BuiltinID != AArch64::BI__builtin_arm_rsr &&
BuiltinID != AArch64::BI__builtin_arm_wsr;
llvm::Type *ValueType;
llvm::Type *RegisterType = Int64Ty;
if (IsPointerBuiltin) {
ValueType = VoidPtrTy;
} else if (Is64Bit) {
ValueType = Int64Ty;
} else {
ValueType = Int32Ty;
}
return EmitSpecialRegisterBuiltin(*this, E, RegisterType, ValueType,
AccessKind);
}
if (BuiltinID == AArch64::BI_ReadStatusReg ||
BuiltinID == AArch64::BI_WriteStatusReg) {
LLVMContext &Context = CGM.getLLVMContext();
unsigned SysReg =
E->getArg(0)->EvaluateKnownConstInt(getContext()).getZExtValue();
std::string SysRegStr;
llvm::raw_string_ostream(SysRegStr) <<
((1 << 1) | ((SysReg >> 14) & 1)) << ":" <<
((SysReg >> 11) & 7) << ":" <<
((SysReg >> 7) & 15) << ":" <<
((SysReg >> 3) & 15) << ":" <<
( SysReg & 7);
llvm::Metadata *Ops[] = { llvm::MDString::get(Context, SysRegStr) };
llvm::MDNode *RegName = llvm::MDNode::get(Context, Ops);
llvm::Value *Metadata = llvm::MetadataAsValue::get(Context, RegName);
llvm::Type *RegisterType = Int64Ty;
llvm::Type *Types[] = { RegisterType };
if (BuiltinID == AArch64::BI_ReadStatusReg) {
llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::read_register, Types);
return Builder.CreateCall(F, Metadata);
}
llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::write_register, Types);
llvm::Value *ArgValue = EmitScalarExpr(E->getArg(1));
return Builder.CreateCall(F, { Metadata, ArgValue });
}
if (BuiltinID == AArch64::BI_AddressOfReturnAddress) {
llvm::Function *F =
CGM.getIntrinsic(Intrinsic::addressofreturnaddress, AllocaInt8PtrTy);
return Builder.CreateCall(F);
}
if (BuiltinID == AArch64::BI__builtin_sponentry) {
llvm::Function *F = CGM.getIntrinsic(Intrinsic::sponentry, AllocaInt8PtrTy);
return Builder.CreateCall(F);
}
// Handle MSVC intrinsics before argument evaluation to prevent double
// evaluation.
if (Optional<MSVCIntrin> MsvcIntId = translateAarch64ToMsvcIntrin(BuiltinID))
return EmitMSVCBuiltinExpr(*MsvcIntId, E);
// Find out if any arguments are required to be integer constant
// expressions.
unsigned ICEArguments = 0;
ASTContext::GetBuiltinTypeError Error;
getContext().GetBuiltinType(BuiltinID, Error, &ICEArguments);
assert(Error == ASTContext::GE_None && "Should not codegen an error");
llvm::SmallVector<Value*, 4> Ops;
Address PtrOp0 = Address::invalid();
for (unsigned i = 0, e = E->getNumArgs() - 1; i != e; i++) {
if (i == 0) {
switch (BuiltinID) {
case NEON::BI__builtin_neon_vld1_v:
case NEON::BI__builtin_neon_vld1q_v:
case NEON::BI__builtin_neon_vld1_dup_v:
case NEON::BI__builtin_neon_vld1q_dup_v:
case NEON::BI__builtin_neon_vld1_lane_v:
case NEON::BI__builtin_neon_vld1q_lane_v:
case NEON::BI__builtin_neon_vst1_v:
case NEON::BI__builtin_neon_vst1q_v:
case NEON::BI__builtin_neon_vst1_lane_v:
case NEON::BI__builtin_neon_vst1q_lane_v:
// Get the alignment for the argument in addition to the value;
// we'll use it later.
PtrOp0 = EmitPointerWithAlignment(E->getArg(0));
Ops.push_back(PtrOp0.getPointer());
continue;
}
}
if ((ICEArguments & (1 << i)) == 0) {
Ops.push_back(EmitScalarExpr(E->getArg(i)));
} else {
// If this is required to be a constant, constant fold it so that we know
// that the generated intrinsic gets a ConstantInt.
Ops.push_back(llvm::ConstantInt::get(
getLLVMContext(),
*E->getArg(i)->getIntegerConstantExpr(getContext())));
}
}
auto SISDMap = makeArrayRef(AArch64SISDIntrinsicMap);
const ARMVectorIntrinsicInfo *Builtin = findARMVectorIntrinsicInMap(
SISDMap, BuiltinID, AArch64SISDIntrinsicsProvenSorted);
if (Builtin) {
Ops.push_back(EmitScalarExpr(E->getArg(E->getNumArgs() - 1)));
Value *Result = EmitCommonNeonSISDBuiltinExpr(*this, *Builtin, Ops, E);
assert(Result && "SISD intrinsic should have been handled");
return Result;
}
const Expr *Arg = E->getArg(E->getNumArgs()-1);
NeonTypeFlags Type(0);
if (Optional<llvm::APSInt> Result = Arg->getIntegerConstantExpr(getContext()))
// Determine the type of this overloaded NEON intrinsic.
Type = NeonTypeFlags(Result->getZExtValue());
bool usgn = Type.isUnsigned();
bool quad = Type.isQuad();
// Handle non-overloaded intrinsics first.
switch (BuiltinID) {
default: break;
case NEON::BI__builtin_neon_vabsh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(0)));
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::fabs, HalfTy), Ops, "vabs");
case NEON::BI__builtin_neon_vldrq_p128: {
llvm::Type *Int128Ty = llvm::Type::getIntNTy(getLLVMContext(), 128);
llvm::Type *Int128PTy = llvm::PointerType::get(Int128Ty, 0);
Value *Ptr = Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), Int128PTy);
return Builder.CreateAlignedLoad(Int128Ty, Ptr,
CharUnits::fromQuantity(16));
}
case NEON::BI__builtin_neon_vstrq_p128: {
llvm::Type *Int128PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), 128);
Value *Ptr = Builder.CreateBitCast(Ops[0], Int128PTy);
return Builder.CreateDefaultAlignedStore(EmitScalarExpr(E->getArg(1)), Ptr);
}
case NEON::BI__builtin_neon_vcvts_f32_u32:
case NEON::BI__builtin_neon_vcvtd_f64_u64:
usgn = true;
LLVM_FALLTHROUGH;
case NEON::BI__builtin_neon_vcvts_f32_s32:
case NEON::BI__builtin_neon_vcvtd_f64_s64: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
bool Is64 = Ops[0]->getType()->getPrimitiveSizeInBits() == 64;
llvm::Type *InTy = Is64 ? Int64Ty : Int32Ty;
llvm::Type *FTy = Is64 ? DoubleTy : FloatTy;
Ops[0] = Builder.CreateBitCast(Ops[0], InTy);
if (usgn)
return Builder.CreateUIToFP(Ops[0], FTy);
return Builder.CreateSIToFP(Ops[0], FTy);
}
case NEON::BI__builtin_neon_vcvth_f16_u16:
case NEON::BI__builtin_neon_vcvth_f16_u32:
case NEON::BI__builtin_neon_vcvth_f16_u64:
usgn = true;
LLVM_FALLTHROUGH;
case NEON::BI__builtin_neon_vcvth_f16_s16:
case NEON::BI__builtin_neon_vcvth_f16_s32:
case NEON::BI__builtin_neon_vcvth_f16_s64: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
llvm::Type *FTy = HalfTy;
llvm::Type *InTy;
if (Ops[0]->getType()->getPrimitiveSizeInBits() == 64)
InTy = Int64Ty;
else if (Ops[0]->getType()->getPrimitiveSizeInBits() == 32)
InTy = Int32Ty;
else
InTy = Int16Ty;
Ops[0] = Builder.CreateBitCast(Ops[0], InTy);
if (usgn)
return Builder.CreateUIToFP(Ops[0], FTy);
return Builder.CreateSIToFP(Ops[0], FTy);
}
case NEON::BI__builtin_neon_vcvtah_u16_f16:
case NEON::BI__builtin_neon_vcvtmh_u16_f16:
case NEON::BI__builtin_neon_vcvtnh_u16_f16:
case NEON::BI__builtin_neon_vcvtph_u16_f16:
case NEON::BI__builtin_neon_vcvth_u16_f16:
case NEON::BI__builtin_neon_vcvtah_s16_f16:
case NEON::BI__builtin_neon_vcvtmh_s16_f16:
case NEON::BI__builtin_neon_vcvtnh_s16_f16:
case NEON::BI__builtin_neon_vcvtph_s16_f16:
case NEON::BI__builtin_neon_vcvth_s16_f16: {
unsigned Int;
llvm::Type* InTy = Int32Ty;
llvm::Type* FTy = HalfTy;
llvm::Type *Tys[2] = {InTy, FTy};
Ops.push_back(EmitScalarExpr(E->getArg(0)));
switch (BuiltinID) {
default: llvm_unreachable("missing builtin ID in switch!");
case NEON::BI__builtin_neon_vcvtah_u16_f16:
Int = Intrinsic::aarch64_neon_fcvtau; break;
case NEON::BI__builtin_neon_vcvtmh_u16_f16:
Int = Intrinsic::aarch64_neon_fcvtmu; break;
case NEON::BI__builtin_neon_vcvtnh_u16_f16:
Int = Intrinsic::aarch64_neon_fcvtnu; break;
case NEON::BI__builtin_neon_vcvtph_u16_f16:
Int = Intrinsic::aarch64_neon_fcvtpu; break;
case NEON::BI__builtin_neon_vcvth_u16_f16:
Int = Intrinsic::aarch64_neon_fcvtzu; break;
case NEON::BI__builtin_neon_vcvtah_s16_f16:
Int = Intrinsic::aarch64_neon_fcvtas; break;
case NEON::BI__builtin_neon_vcvtmh_s16_f16:
Int = Intrinsic::aarch64_neon_fcvtms; break;
case NEON::BI__builtin_neon_vcvtnh_s16_f16:
Int = Intrinsic::aarch64_neon_fcvtns; break;
case NEON::BI__builtin_neon_vcvtph_s16_f16:
Int = Intrinsic::aarch64_neon_fcvtps; break;
case NEON::BI__builtin_neon_vcvth_s16_f16:
Int = Intrinsic::aarch64_neon_fcvtzs; break;
}
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "fcvt");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vcaleh_f16:
case NEON::BI__builtin_neon_vcalth_f16:
case NEON::BI__builtin_neon_vcageh_f16:
case NEON::BI__builtin_neon_vcagth_f16: {
unsigned Int;
llvm::Type* InTy = Int32Ty;
llvm::Type* FTy = HalfTy;
llvm::Type *Tys[2] = {InTy, FTy};
Ops.push_back(EmitScalarExpr(E->getArg(1)));
switch (BuiltinID) {
default: llvm_unreachable("missing builtin ID in switch!");
case NEON::BI__builtin_neon_vcageh_f16:
Int = Intrinsic::aarch64_neon_facge; break;
case NEON::BI__builtin_neon_vcagth_f16:
Int = Intrinsic::aarch64_neon_facgt; break;
case NEON::BI__builtin_neon_vcaleh_f16:
Int = Intrinsic::aarch64_neon_facge; std::swap(Ops[0], Ops[1]); break;
case NEON::BI__builtin_neon_vcalth_f16:
Int = Intrinsic::aarch64_neon_facgt; std::swap(Ops[0], Ops[1]); break;
}
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "facg");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vcvth_n_s16_f16:
case NEON::BI__builtin_neon_vcvth_n_u16_f16: {
unsigned Int;
llvm::Type* InTy = Int32Ty;
llvm::Type* FTy = HalfTy;
llvm::Type *Tys[2] = {InTy, FTy};
Ops.push_back(EmitScalarExpr(E->getArg(1)));
switch (BuiltinID) {
default: llvm_unreachable("missing builtin ID in switch!");
case NEON::BI__builtin_neon_vcvth_n_s16_f16:
Int = Intrinsic::aarch64_neon_vcvtfp2fxs; break;
case NEON::BI__builtin_neon_vcvth_n_u16_f16:
Int = Intrinsic::aarch64_neon_vcvtfp2fxu; break;
}
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "fcvth_n");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vcvth_n_f16_s16:
case NEON::BI__builtin_neon_vcvth_n_f16_u16: {
unsigned Int;
llvm::Type* FTy = HalfTy;
llvm::Type* InTy = Int32Ty;
llvm::Type *Tys[2] = {FTy, InTy};
Ops.push_back(EmitScalarExpr(E->getArg(1)));
switch (BuiltinID) {
default: llvm_unreachable("missing builtin ID in switch!");
case NEON::BI__builtin_neon_vcvth_n_f16_s16:
Int = Intrinsic::aarch64_neon_vcvtfxs2fp;
Ops[0] = Builder.CreateSExt(Ops[0], InTy, "sext");
break;
case NEON::BI__builtin_neon_vcvth_n_f16_u16:
Int = Intrinsic::aarch64_neon_vcvtfxu2fp;
Ops[0] = Builder.CreateZExt(Ops[0], InTy);
break;
}
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "fcvth_n");
}
case NEON::BI__builtin_neon_vpaddd_s64: {
auto *Ty = llvm::FixedVectorType::get(Int64Ty, 2);
Value *Vec = EmitScalarExpr(E->getArg(0));
// The vector is v2f64, so make sure it's bitcast to that.
Vec = Builder.CreateBitCast(Vec, Ty, "v2i64");
llvm::Value *Idx0 = llvm::ConstantInt::get(SizeTy, 0);
llvm::Value *Idx1 = llvm::ConstantInt::get(SizeTy, 1);
Value *Op0 = Builder.CreateExtractElement(Vec, Idx0, "lane0");
Value *Op1 = Builder.CreateExtractElement(Vec, Idx1, "lane1");
// Pairwise addition of a v2f64 into a scalar f64.
return Builder.CreateAdd(Op0, Op1, "vpaddd");
}
case NEON::BI__builtin_neon_vpaddd_f64: {
auto *Ty = llvm::FixedVectorType::get(DoubleTy, 2);
Value *Vec = EmitScalarExpr(E->getArg(0));
// The vector is v2f64, so make sure it's bitcast to that.
Vec = Builder.CreateBitCast(Vec, Ty, "v2f64");
llvm::Value *Idx0 = llvm::ConstantInt::get(SizeTy, 0);
llvm::Value *Idx1 = llvm::ConstantInt::get(SizeTy, 1);
Value *Op0 = Builder.CreateExtractElement(Vec, Idx0, "lane0");
Value *Op1 = Builder.CreateExtractElement(Vec, Idx1, "lane1");
// Pairwise addition of a v2f64 into a scalar f64.
return Builder.CreateFAdd(Op0, Op1, "vpaddd");
}
case NEON::BI__builtin_neon_vpadds_f32: {
auto *Ty = llvm::FixedVectorType::get(FloatTy, 2);
Value *Vec = EmitScalarExpr(E->getArg(0));
// The vector is v2f32, so make sure it's bitcast to that.
Vec = Builder.CreateBitCast(Vec, Ty, "v2f32");
llvm::Value *Idx0 = llvm::ConstantInt::get(SizeTy, 0);
llvm::Value *Idx1 = llvm::ConstantInt::get(SizeTy, 1);
Value *Op0 = Builder.CreateExtractElement(Vec, Idx0, "lane0");
Value *Op1 = Builder.CreateExtractElement(Vec, Idx1, "lane1");
// Pairwise addition of a v2f32 into a scalar f32.
return Builder.CreateFAdd(Op0, Op1, "vpaddd");
}
case NEON::BI__builtin_neon_vceqzd_s64:
case NEON::BI__builtin_neon_vceqzd_f64:
case NEON::BI__builtin_neon_vceqzs_f32:
case NEON::BI__builtin_neon_vceqzh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(0)));
return EmitAArch64CompareBuiltinExpr(
Ops[0], ConvertType(E->getCallReturnType(getContext())),
ICmpInst::FCMP_OEQ, ICmpInst::ICMP_EQ, "vceqz");
case NEON::BI__builtin_neon_vcgezd_s64:
case NEON::BI__builtin_neon_vcgezd_f64:
case NEON::BI__builtin_neon_vcgezs_f32:
case NEON::BI__builtin_neon_vcgezh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(0)));
return EmitAArch64CompareBuiltinExpr(
Ops[0], ConvertType(E->getCallReturnType(getContext())),
ICmpInst::FCMP_OGE, ICmpInst::ICMP_SGE, "vcgez");
case NEON::BI__builtin_neon_vclezd_s64:
case NEON::BI__builtin_neon_vclezd_f64:
case NEON::BI__builtin_neon_vclezs_f32:
case NEON::BI__builtin_neon_vclezh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(0)));
return EmitAArch64CompareBuiltinExpr(
Ops[0], ConvertType(E->getCallReturnType(getContext())),
ICmpInst::FCMP_OLE, ICmpInst::ICMP_SLE, "vclez");
case NEON::BI__builtin_neon_vcgtzd_s64:
case NEON::BI__builtin_neon_vcgtzd_f64:
case NEON::BI__builtin_neon_vcgtzs_f32:
case NEON::BI__builtin_neon_vcgtzh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(0)));
return EmitAArch64CompareBuiltinExpr(
Ops[0], ConvertType(E->getCallReturnType(getContext())),
ICmpInst::FCMP_OGT, ICmpInst::ICMP_SGT, "vcgtz");
case NEON::BI__builtin_neon_vcltzd_s64:
case NEON::BI__builtin_neon_vcltzd_f64:
case NEON::BI__builtin_neon_vcltzs_f32:
case NEON::BI__builtin_neon_vcltzh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(0)));
return EmitAArch64CompareBuiltinExpr(
Ops[0], ConvertType(E->getCallReturnType(getContext())),
ICmpInst::FCMP_OLT, ICmpInst::ICMP_SLT, "vcltz");
case NEON::BI__builtin_neon_vceqzd_u64: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
Ops[0] =
Builder.CreateICmpEQ(Ops[0], llvm::Constant::getNullValue(Int64Ty));
return Builder.CreateSExt(Ops[0], Int64Ty, "vceqzd");
}
case NEON::BI__builtin_neon_vceqd_f64:
case NEON::BI__builtin_neon_vcled_f64:
case NEON::BI__builtin_neon_vcltd_f64:
case NEON::BI__builtin_neon_vcged_f64:
case NEON::BI__builtin_neon_vcgtd_f64: {
llvm::CmpInst::Predicate P;
switch (BuiltinID) {
default: llvm_unreachable("missing builtin ID in switch!");
case NEON::BI__builtin_neon_vceqd_f64: P = llvm::FCmpInst::FCMP_OEQ; break;
case NEON::BI__builtin_neon_vcled_f64: P = llvm::FCmpInst::FCMP_OLE; break;
case NEON::BI__builtin_neon_vcltd_f64: P = llvm::FCmpInst::FCMP_OLT; break;
case NEON::BI__builtin_neon_vcged_f64: P = llvm::FCmpInst::FCMP_OGE; break;
case NEON::BI__builtin_neon_vcgtd_f64: P = llvm::FCmpInst::FCMP_OGT; break;
}
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
Ops[1] = Builder.CreateBitCast(Ops[1], DoubleTy);
Ops[0] = Builder.CreateFCmp(P, Ops[0], Ops[1]);
return Builder.CreateSExt(Ops[0], Int64Ty, "vcmpd");
}
case NEON::BI__builtin_neon_vceqs_f32:
case NEON::BI__builtin_neon_vcles_f32:
case NEON::BI__builtin_neon_vclts_f32:
case NEON::BI__builtin_neon_vcges_f32:
case NEON::BI__builtin_neon_vcgts_f32: {
llvm::CmpInst::Predicate P;
switch (BuiltinID) {
default: llvm_unreachable("missing builtin ID in switch!");
case NEON::BI__builtin_neon_vceqs_f32: P = llvm::FCmpInst::FCMP_OEQ; break;
case NEON::BI__builtin_neon_vcles_f32: P = llvm::FCmpInst::FCMP_OLE; break;
case NEON::BI__builtin_neon_vclts_f32: P = llvm::FCmpInst::FCMP_OLT; break;
case NEON::BI__builtin_neon_vcges_f32: P = llvm::FCmpInst::FCMP_OGE; break;
case NEON::BI__builtin_neon_vcgts_f32: P = llvm::FCmpInst::FCMP_OGT; break;
}
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Ops[0] = Builder.CreateBitCast(Ops[0], FloatTy);
Ops[1] = Builder.CreateBitCast(Ops[1], FloatTy);
Ops[0] = Builder.CreateFCmp(P, Ops[0], Ops[1]);
return Builder.CreateSExt(Ops[0], Int32Ty, "vcmpd");
}
case NEON::BI__builtin_neon_vceqh_f16:
case NEON::BI__builtin_neon_vcleh_f16:
case NEON::BI__builtin_neon_vclth_f16:
case NEON::BI__builtin_neon_vcgeh_f16:
case NEON::BI__builtin_neon_vcgth_f16: {
llvm::CmpInst::Predicate P;
switch (BuiltinID) {
default: llvm_unreachable("missing builtin ID in switch!");
case NEON::BI__builtin_neon_vceqh_f16: P = llvm::FCmpInst::FCMP_OEQ; break;
case NEON::BI__builtin_neon_vcleh_f16: P = llvm::FCmpInst::FCMP_OLE; break;
case NEON::BI__builtin_neon_vclth_f16: P = llvm::FCmpInst::FCMP_OLT; break;
case NEON::BI__builtin_neon_vcgeh_f16: P = llvm::FCmpInst::FCMP_OGE; break;
case NEON::BI__builtin_neon_vcgth_f16: P = llvm::FCmpInst::FCMP_OGT; break;
}
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Ops[0] = Builder.CreateBitCast(Ops[0], HalfTy);
Ops[1] = Builder.CreateBitCast(Ops[1], HalfTy);
Ops[0] = Builder.CreateFCmp(P, Ops[0], Ops[1]);
return Builder.CreateSExt(Ops[0], Int16Ty, "vcmpd");
}
case NEON::BI__builtin_neon_vceqd_s64:
case NEON::BI__builtin_neon_vceqd_u64:
case NEON::BI__builtin_neon_vcgtd_s64:
case NEON::BI__builtin_neon_vcgtd_u64:
case NEON::BI__builtin_neon_vcltd_s64:
case NEON::BI__builtin_neon_vcltd_u64:
case NEON::BI__builtin_neon_vcged_u64:
case NEON::BI__builtin_neon_vcged_s64:
case NEON::BI__builtin_neon_vcled_u64:
case NEON::BI__builtin_neon_vcled_s64: {
llvm::CmpInst::Predicate P;
switch (BuiltinID) {
default: llvm_unreachable("missing builtin ID in switch!");
case NEON::BI__builtin_neon_vceqd_s64:
case NEON::BI__builtin_neon_vceqd_u64:P = llvm::ICmpInst::ICMP_EQ;break;
case NEON::BI__builtin_neon_vcgtd_s64:P = llvm::ICmpInst::ICMP_SGT;break;
case NEON::BI__builtin_neon_vcgtd_u64:P = llvm::ICmpInst::ICMP_UGT;break;
case NEON::BI__builtin_neon_vcltd_s64:P = llvm::ICmpInst::ICMP_SLT;break;
case NEON::BI__builtin_neon_vcltd_u64:P = llvm::ICmpInst::ICMP_ULT;break;
case NEON::BI__builtin_neon_vcged_u64:P = llvm::ICmpInst::ICMP_UGE;break;
case NEON::BI__builtin_neon_vcged_s64:P = llvm::ICmpInst::ICMP_SGE;break;
case NEON::BI__builtin_neon_vcled_u64:P = llvm::ICmpInst::ICMP_ULE;break;
case NEON::BI__builtin_neon_vcled_s64:P = llvm::ICmpInst::ICMP_SLE;break;
}
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
Ops[0] = Builder.CreateICmp(P, Ops[0], Ops[1]);
return Builder.CreateSExt(Ops[0], Int64Ty, "vceqd");
}
case NEON::BI__builtin_neon_vtstd_s64:
case NEON::BI__builtin_neon_vtstd_u64: {
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Ops[0] = Builder.CreateBitCast(Ops[0], Int64Ty);
Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
Ops[0] = Builder.CreateICmp(ICmpInst::ICMP_NE, Ops[0],
llvm::Constant::getNullValue(Int64Ty));
return Builder.CreateSExt(Ops[0], Int64Ty, "vtstd");
}
case NEON::BI__builtin_neon_vset_lane_i8:
case NEON::BI__builtin_neon_vset_lane_i16:
case NEON::BI__builtin_neon_vset_lane_i32:
case NEON::BI__builtin_neon_vset_lane_i64:
case NEON::BI__builtin_neon_vset_lane_bf16:
case NEON::BI__builtin_neon_vset_lane_f32:
case NEON::BI__builtin_neon_vsetq_lane_i8:
case NEON::BI__builtin_neon_vsetq_lane_i16:
case NEON::BI__builtin_neon_vsetq_lane_i32:
case NEON::BI__builtin_neon_vsetq_lane_i64:
case NEON::BI__builtin_neon_vsetq_lane_bf16:
case NEON::BI__builtin_neon_vsetq_lane_f32:
Ops.push_back(EmitScalarExpr(E->getArg(2)));
return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
case NEON::BI__builtin_neon_vset_lane_f64:
// The vector type needs a cast for the v1f64 variant.
Ops[1] =
Builder.CreateBitCast(Ops[1], llvm::FixedVectorType::get(DoubleTy, 1));
Ops.push_back(EmitScalarExpr(E->getArg(2)));
return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
case NEON::BI__builtin_neon_vsetq_lane_f64:
// The vector type needs a cast for the v2f64 variant.
Ops[1] =
Builder.CreateBitCast(Ops[1], llvm::FixedVectorType::get(DoubleTy, 2));
Ops.push_back(EmitScalarExpr(E->getArg(2)));
return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vset_lane");
case NEON::BI__builtin_neon_vget_lane_i8:
case NEON::BI__builtin_neon_vdupb_lane_i8:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int8Ty, 8));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vget_lane");
case NEON::BI__builtin_neon_vgetq_lane_i8:
case NEON::BI__builtin_neon_vdupb_laneq_i8:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int8Ty, 16));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vgetq_lane");
case NEON::BI__builtin_neon_vget_lane_i16:
case NEON::BI__builtin_neon_vduph_lane_i16:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int16Ty, 4));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vget_lane");
case NEON::BI__builtin_neon_vgetq_lane_i16:
case NEON::BI__builtin_neon_vduph_laneq_i16:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int16Ty, 8));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vgetq_lane");
case NEON::BI__builtin_neon_vget_lane_i32:
case NEON::BI__builtin_neon_vdups_lane_i32:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int32Ty, 2));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vget_lane");
case NEON::BI__builtin_neon_vdups_lane_f32:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(FloatTy, 2));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vdups_lane");
case NEON::BI__builtin_neon_vgetq_lane_i32:
case NEON::BI__builtin_neon_vdups_laneq_i32:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int32Ty, 4));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vgetq_lane");
case NEON::BI__builtin_neon_vget_lane_i64:
case NEON::BI__builtin_neon_vdupd_lane_i64:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int64Ty, 1));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vget_lane");
case NEON::BI__builtin_neon_vdupd_lane_f64:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(DoubleTy, 1));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vdupd_lane");
case NEON::BI__builtin_neon_vgetq_lane_i64:
case NEON::BI__builtin_neon_vdupd_laneq_i64:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int64Ty, 2));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vgetq_lane");
case NEON::BI__builtin_neon_vget_lane_f32:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(FloatTy, 2));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vget_lane");
case NEON::BI__builtin_neon_vget_lane_f64:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(DoubleTy, 1));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vget_lane");
case NEON::BI__builtin_neon_vgetq_lane_f32:
case NEON::BI__builtin_neon_vdups_laneq_f32:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(FloatTy, 4));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vgetq_lane");
case NEON::BI__builtin_neon_vgetq_lane_f64:
case NEON::BI__builtin_neon_vdupd_laneq_f64:
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(DoubleTy, 2));
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vgetq_lane");
case NEON::BI__builtin_neon_vaddh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(1)));
return Builder.CreateFAdd(Ops[0], Ops[1], "vaddh");
case NEON::BI__builtin_neon_vsubh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(1)));
return Builder.CreateFSub(Ops[0], Ops[1], "vsubh");
case NEON::BI__builtin_neon_vmulh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(1)));
return Builder.CreateFMul(Ops[0], Ops[1], "vmulh");
case NEON::BI__builtin_neon_vdivh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(1)));
return Builder.CreateFDiv(Ops[0], Ops[1], "vdivh");
case NEON::BI__builtin_neon_vfmah_f16:
// NEON intrinsic puts accumulator first, unlike the LLVM fma.
return emitCallMaybeConstrainedFPBuiltin(
*this, Intrinsic::fma, Intrinsic::experimental_constrained_fma, HalfTy,
{EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2)), Ops[0]});
case NEON::BI__builtin_neon_vfmsh_f16: {
// FIXME: This should be an fneg instruction:
Value *Zero = llvm::ConstantFP::getZeroValueForNegation(HalfTy);
Value* Sub = Builder.CreateFSub(Zero, EmitScalarExpr(E->getArg(1)), "vsubh");
// NEON intrinsic puts accumulator first, unlike the LLVM fma.
return emitCallMaybeConstrainedFPBuiltin(
*this, Intrinsic::fma, Intrinsic::experimental_constrained_fma, HalfTy,
{Sub, EmitScalarExpr(E->getArg(2)), Ops[0]});
}
case NEON::BI__builtin_neon_vaddd_s64:
case NEON::BI__builtin_neon_vaddd_u64:
return Builder.CreateAdd(Ops[0], EmitScalarExpr(E->getArg(1)), "vaddd");
case NEON::BI__builtin_neon_vsubd_s64:
case NEON::BI__builtin_neon_vsubd_u64:
return Builder.CreateSub(Ops[0], EmitScalarExpr(E->getArg(1)), "vsubd");
case NEON::BI__builtin_neon_vqdmlalh_s16:
case NEON::BI__builtin_neon_vqdmlslh_s16: {
SmallVector<Value *, 2> ProductOps;
ProductOps.push_back(vectorWrapScalar16(Ops[1]));
ProductOps.push_back(vectorWrapScalar16(EmitScalarExpr(E->getArg(2))));
auto *VTy = llvm::FixedVectorType::get(Int32Ty, 4);
Ops[1] = EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_sqdmull, VTy),
ProductOps, "vqdmlXl");
Constant *CI = ConstantInt::get(SizeTy, 0);
Ops[1] = Builder.CreateExtractElement(Ops[1], CI, "lane0");
unsigned AccumInt = BuiltinID == NEON::BI__builtin_neon_vqdmlalh_s16
? Intrinsic::aarch64_neon_sqadd
: Intrinsic::aarch64_neon_sqsub;
return EmitNeonCall(CGM.getIntrinsic(AccumInt, Int32Ty), Ops, "vqdmlXl");
}
case NEON::BI__builtin_neon_vqshlud_n_s64: {
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Ops[1] = Builder.CreateZExt(Ops[1], Int64Ty);
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_sqshlu, Int64Ty),
Ops, "vqshlu_n");
}
case NEON::BI__builtin_neon_vqshld_n_u64:
case NEON::BI__builtin_neon_vqshld_n_s64: {
unsigned Int = BuiltinID == NEON::BI__builtin_neon_vqshld_n_u64
? Intrinsic::aarch64_neon_uqshl
: Intrinsic::aarch64_neon_sqshl;
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Ops[1] = Builder.CreateZExt(Ops[1], Int64Ty);
return EmitNeonCall(CGM.getIntrinsic(Int, Int64Ty), Ops, "vqshl_n");
}
case NEON::BI__builtin_neon_vrshrd_n_u64:
case NEON::BI__builtin_neon_vrshrd_n_s64: {
unsigned Int = BuiltinID == NEON::BI__builtin_neon_vrshrd_n_u64
? Intrinsic::aarch64_neon_urshl
: Intrinsic::aarch64_neon_srshl;
Ops.push_back(EmitScalarExpr(E->getArg(1)));
int SV = cast<ConstantInt>(Ops[1])->getSExtValue();
Ops[1] = ConstantInt::get(Int64Ty, -SV);
return EmitNeonCall(CGM.getIntrinsic(Int, Int64Ty), Ops, "vrshr_n");
}
case NEON::BI__builtin_neon_vrsrad_n_u64:
case NEON::BI__builtin_neon_vrsrad_n_s64: {
unsigned Int = BuiltinID == NEON::BI__builtin_neon_vrsrad_n_u64
? Intrinsic::aarch64_neon_urshl
: Intrinsic::aarch64_neon_srshl;
Ops[1] = Builder.CreateBitCast(Ops[1], Int64Ty);
Ops.push_back(Builder.CreateNeg(EmitScalarExpr(E->getArg(2))));
Ops[1] = Builder.CreateCall(CGM.getIntrinsic(Int, Int64Ty),
{Ops[1], Builder.CreateSExt(Ops[2], Int64Ty)});
return Builder.CreateAdd(Ops[0], Builder.CreateBitCast(Ops[1], Int64Ty));
}
case NEON::BI__builtin_neon_vshld_n_s64:
case NEON::BI__builtin_neon_vshld_n_u64: {
llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
return Builder.CreateShl(
Ops[0], ConstantInt::get(Int64Ty, Amt->getZExtValue()), "shld_n");
}
case NEON::BI__builtin_neon_vshrd_n_s64: {
llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
return Builder.CreateAShr(
Ops[0], ConstantInt::get(Int64Ty, std::min(static_cast<uint64_t>(63),
Amt->getZExtValue())),
"shrd_n");
}
case NEON::BI__builtin_neon_vshrd_n_u64: {
llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
uint64_t ShiftAmt = Amt->getZExtValue();
// Right-shifting an unsigned value by its size yields 0.
if (ShiftAmt == 64)
return ConstantInt::get(Int64Ty, 0);
return Builder.CreateLShr(Ops[0], ConstantInt::get(Int64Ty, ShiftAmt),
"shrd_n");
}
case NEON::BI__builtin_neon_vsrad_n_s64: {
llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(2)));
Ops[1] = Builder.CreateAShr(
Ops[1], ConstantInt::get(Int64Ty, std::min(static_cast<uint64_t>(63),
Amt->getZExtValue())),
"shrd_n");
return Builder.CreateAdd(Ops[0], Ops[1]);
}
case NEON::BI__builtin_neon_vsrad_n_u64: {
llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(2)));
uint64_t ShiftAmt = Amt->getZExtValue();
// Right-shifting an unsigned value by its size yields 0.
// As Op + 0 = Op, return Ops[0] directly.
if (ShiftAmt == 64)
return Ops[0];
Ops[1] = Builder.CreateLShr(Ops[1], ConstantInt::get(Int64Ty, ShiftAmt),
"shrd_n");
return Builder.CreateAdd(Ops[0], Ops[1]);
}
case NEON::BI__builtin_neon_vqdmlalh_lane_s16:
case NEON::BI__builtin_neon_vqdmlalh_laneq_s16:
case NEON::BI__builtin_neon_vqdmlslh_lane_s16:
case NEON::BI__builtin_neon_vqdmlslh_laneq_s16: {
Ops[2] = Builder.CreateExtractElement(Ops[2], EmitScalarExpr(E->getArg(3)),
"lane");
SmallVector<Value *, 2> ProductOps;
ProductOps.push_back(vectorWrapScalar16(Ops[1]));
ProductOps.push_back(vectorWrapScalar16(Ops[2]));
auto *VTy = llvm::FixedVectorType::get(Int32Ty, 4);
Ops[1] = EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_sqdmull, VTy),
ProductOps, "vqdmlXl");
Constant *CI = ConstantInt::get(SizeTy, 0);
Ops[1] = Builder.CreateExtractElement(Ops[1], CI, "lane0");
Ops.pop_back();
unsigned AccInt = (BuiltinID == NEON::BI__builtin_neon_vqdmlalh_lane_s16 ||
BuiltinID == NEON::BI__builtin_neon_vqdmlalh_laneq_s16)
? Intrinsic::aarch64_neon_sqadd
: Intrinsic::aarch64_neon_sqsub;
return EmitNeonCall(CGM.getIntrinsic(AccInt, Int32Ty), Ops, "vqdmlXl");
}
case NEON::BI__builtin_neon_vqdmlals_s32:
case NEON::BI__builtin_neon_vqdmlsls_s32: {
SmallVector<Value *, 2> ProductOps;
ProductOps.push_back(Ops[1]);
ProductOps.push_back(EmitScalarExpr(E->getArg(2)));
Ops[1] =
EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_sqdmulls_scalar),
ProductOps, "vqdmlXl");
unsigned AccumInt = BuiltinID == NEON::BI__builtin_neon_vqdmlals_s32
? Intrinsic::aarch64_neon_sqadd
: Intrinsic::aarch64_neon_sqsub;
return EmitNeonCall(CGM.getIntrinsic(AccumInt, Int64Ty), Ops, "vqdmlXl");
}
case NEON::BI__builtin_neon_vqdmlals_lane_s32:
case NEON::BI__builtin_neon_vqdmlals_laneq_s32:
case NEON::BI__builtin_neon_vqdmlsls_lane_s32:
case NEON::BI__builtin_neon_vqdmlsls_laneq_s32: {
Ops[2] = Builder.CreateExtractElement(Ops[2], EmitScalarExpr(E->getArg(3)),
"lane");
SmallVector<Value *, 2> ProductOps;
ProductOps.push_back(Ops[1]);
ProductOps.push_back(Ops[2]);
Ops[1] =
EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_sqdmulls_scalar),
ProductOps, "vqdmlXl");
Ops.pop_back();
unsigned AccInt = (BuiltinID == NEON::BI__builtin_neon_vqdmlals_lane_s32 ||
BuiltinID == NEON::BI__builtin_neon_vqdmlals_laneq_s32)
? Intrinsic::aarch64_neon_sqadd
: Intrinsic::aarch64_neon_sqsub;
return EmitNeonCall(CGM.getIntrinsic(AccInt, Int64Ty), Ops, "vqdmlXl");
}
case NEON::BI__builtin_neon_vget_lane_bf16:
case NEON::BI__builtin_neon_vduph_lane_bf16:
case NEON::BI__builtin_neon_vduph_lane_f16: {
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vget_lane");
}
case NEON::BI__builtin_neon_vgetq_lane_bf16:
case NEON::BI__builtin_neon_vduph_laneq_bf16:
case NEON::BI__builtin_neon_vduph_laneq_f16: {
return Builder.CreateExtractElement(Ops[0], EmitScalarExpr(E->getArg(1)),
"vgetq_lane");
}
case AArch64::BI_InterlockedAdd: {
Value *Arg0 = EmitScalarExpr(E->getArg(0));
Value *Arg1 = EmitScalarExpr(E->getArg(1));
AtomicRMWInst *RMWI = Builder.CreateAtomicRMW(
AtomicRMWInst::Add, Arg0, Arg1,
llvm::AtomicOrdering::SequentiallyConsistent);
return Builder.CreateAdd(RMWI, Arg1);
}
}
llvm::FixedVectorType *VTy = GetNeonType(this, Type);
llvm::Type *Ty = VTy;
if (!Ty)
return nullptr;
// Not all intrinsics handled by the common case work for AArch64 yet, so only
// defer to common code if it's been added to our special map.
Builtin = findARMVectorIntrinsicInMap(AArch64SIMDIntrinsicMap, BuiltinID,
AArch64SIMDIntrinsicsProvenSorted);
if (Builtin)
return EmitCommonNeonBuiltinExpr(
Builtin->BuiltinID, Builtin->LLVMIntrinsic, Builtin->AltLLVMIntrinsic,
Builtin->NameHint, Builtin->TypeModifier, E, Ops,
/*never use addresses*/ Address::invalid(), Address::invalid(), Arch);
if (Value *V = EmitAArch64TblBuiltinExpr(*this, BuiltinID, E, Ops, Arch))
return V;
unsigned Int;
switch (BuiltinID) {
default: return nullptr;
case NEON::BI__builtin_neon_vbsl_v:
case NEON::BI__builtin_neon_vbslq_v: {
llvm::Type *BitTy = llvm::VectorType::getInteger(VTy);
Ops[0] = Builder.CreateBitCast(Ops[0], BitTy, "vbsl");
Ops[1] = Builder.CreateBitCast(Ops[1], BitTy, "vbsl");
Ops[2] = Builder.CreateBitCast(Ops[2], BitTy, "vbsl");
Ops[1] = Builder.CreateAnd(Ops[0], Ops[1], "vbsl");
Ops[2] = Builder.CreateAnd(Builder.CreateNot(Ops[0]), Ops[2], "vbsl");
Ops[0] = Builder.CreateOr(Ops[1], Ops[2], "vbsl");
return Builder.CreateBitCast(Ops[0], Ty);
}
case NEON::BI__builtin_neon_vfma_lane_v:
case NEON::BI__builtin_neon_vfmaq_lane_v: { // Only used for FP types
// The ARM builtins (and instructions) have the addend as the first
// operand, but the 'fma' intrinsics have it last. Swap it around here.
Value *Addend = Ops[0];
Value *Multiplicand = Ops[1];
Value *LaneSource = Ops[2];
Ops[0] = Multiplicand;
Ops[1] = LaneSource;
Ops[2] = Addend;
// Now adjust things to handle the lane access.
auto *SourceTy = BuiltinID == NEON::BI__builtin_neon_vfmaq_lane_v
? llvm::FixedVectorType::get(VTy->getElementType(),
VTy->getNumElements() / 2)
: VTy;
llvm::Constant *cst = cast<Constant>(Ops[3]);
Value *SV = llvm::ConstantVector::getSplat(VTy->getElementCount(), cst);
Ops[1] = Builder.CreateBitCast(Ops[1], SourceTy);
Ops[1] = Builder.CreateShuffleVector(Ops[1], Ops[1], SV, "lane");
Ops.pop_back();
Int = Builder.getIsFPConstrained() ? Intrinsic::experimental_constrained_fma
: Intrinsic::fma;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "fmla");
}
case NEON::BI__builtin_neon_vfma_laneq_v: {
auto *VTy = cast<llvm::FixedVectorType>(Ty);
// v1f64 fma should be mapped to Neon scalar f64 fma
if (VTy && VTy->getElementType() == DoubleTy) {
Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
Ops[1] = Builder.CreateBitCast(Ops[1], DoubleTy);
llvm::FixedVectorType *VTy =
GetNeonType(this, NeonTypeFlags(NeonTypeFlags::Float64, false, true));
Ops[2] = Builder.CreateBitCast(Ops[2], VTy);
Ops[2] = Builder.CreateExtractElement(Ops[2], Ops[3], "extract");
Value *Result;
Result = emitCallMaybeConstrainedFPBuiltin(
*this, Intrinsic::fma, Intrinsic::experimental_constrained_fma,
DoubleTy, {Ops[1], Ops[2], Ops[0]});
return Builder.CreateBitCast(Result, Ty);
}
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
auto *STy = llvm::FixedVectorType::get(VTy->getElementType(),
VTy->getNumElements() * 2);
Ops[2] = Builder.CreateBitCast(Ops[2], STy);
Value *SV = llvm::ConstantVector::getSplat(VTy->getElementCount(),
cast<ConstantInt>(Ops[3]));
Ops[2] = Builder.CreateShuffleVector(Ops[2], Ops[2], SV, "lane");
return emitCallMaybeConstrainedFPBuiltin(
*this, Intrinsic::fma, Intrinsic::experimental_constrained_fma, Ty,
{Ops[2], Ops[1], Ops[0]});
}
case NEON::BI__builtin_neon_vfmaq_laneq_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Ops[2] = EmitNeonSplat(Ops[2], cast<ConstantInt>(Ops[3]));
return emitCallMaybeConstrainedFPBuiltin(
*this, Intrinsic::fma, Intrinsic::experimental_constrained_fma, Ty,
{Ops[2], Ops[1], Ops[0]});
}
case NEON::BI__builtin_neon_vfmah_lane_f16:
case NEON::BI__builtin_neon_vfmas_lane_f32:
case NEON::BI__builtin_neon_vfmah_laneq_f16:
case NEON::BI__builtin_neon_vfmas_laneq_f32:
case NEON::BI__builtin_neon_vfmad_lane_f64:
case NEON::BI__builtin_neon_vfmad_laneq_f64: {
Ops.push_back(EmitScalarExpr(E->getArg(3)));
llvm::Type *Ty = ConvertType(E->getCallReturnType(getContext()));
Ops[2] = Builder.CreateExtractElement(Ops[2], Ops[3], "extract");
return emitCallMaybeConstrainedFPBuiltin(
*this, Intrinsic::fma, Intrinsic::experimental_constrained_fma, Ty,
{Ops[1], Ops[2], Ops[0]});
}
case NEON::BI__builtin_neon_vmull_v:
// FIXME: improve sharing scheme to cope with 3 alternative LLVM intrinsics.
Int = usgn ? Intrinsic::aarch64_neon_umull : Intrinsic::aarch64_neon_smull;
if (Type.isPoly()) Int = Intrinsic::aarch64_neon_pmull;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vmull");
case NEON::BI__builtin_neon_vmax_v:
case NEON::BI__builtin_neon_vmaxq_v:
// FIXME: improve sharing scheme to cope with 3 alternative LLVM intrinsics.
Int = usgn ? Intrinsic::aarch64_neon_umax : Intrinsic::aarch64_neon_smax;
if (Ty->isFPOrFPVectorTy()) Int = Intrinsic::aarch64_neon_fmax;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vmax");
case NEON::BI__builtin_neon_vmaxh_f16: {
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Int = Intrinsic::aarch64_neon_fmax;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vmax");
}
case NEON::BI__builtin_neon_vmin_v:
case NEON::BI__builtin_neon_vminq_v:
// FIXME: improve sharing scheme to cope with 3 alternative LLVM intrinsics.
Int = usgn ? Intrinsic::aarch64_neon_umin : Intrinsic::aarch64_neon_smin;
if (Ty->isFPOrFPVectorTy()) Int = Intrinsic::aarch64_neon_fmin;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vmin");
case NEON::BI__builtin_neon_vminh_f16: {
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Int = Intrinsic::aarch64_neon_fmin;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vmin");
}
case NEON::BI__builtin_neon_vabd_v:
case NEON::BI__builtin_neon_vabdq_v:
// FIXME: improve sharing scheme to cope with 3 alternative LLVM intrinsics.
Int = usgn ? Intrinsic::aarch64_neon_uabd : Intrinsic::aarch64_neon_sabd;
if (Ty->isFPOrFPVectorTy()) Int = Intrinsic::aarch64_neon_fabd;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vabd");
case NEON::BI__builtin_neon_vpadal_v:
case NEON::BI__builtin_neon_vpadalq_v: {
unsigned ArgElts = VTy->getNumElements();
llvm::IntegerType *EltTy = cast<IntegerType>(VTy->getElementType());
unsigned BitWidth = EltTy->getBitWidth();
auto *ArgTy = llvm::FixedVectorType::get(
llvm::IntegerType::get(getLLVMContext(), BitWidth / 2), 2 * ArgElts);
llvm::Type* Tys[2] = { VTy, ArgTy };
Int = usgn ? Intrinsic::aarch64_neon_uaddlp : Intrinsic::aarch64_neon_saddlp;
SmallVector<llvm::Value*, 1> TmpOps;
TmpOps.push_back(Ops[1]);
Function *F = CGM.getIntrinsic(Int, Tys);
llvm::Value *tmp = EmitNeonCall(F, TmpOps, "vpadal");
llvm::Value *addend = Builder.CreateBitCast(Ops[0], tmp->getType());
return Builder.CreateAdd(tmp, addend);
}
case NEON::BI__builtin_neon_vpmin_v:
case NEON::BI__builtin_neon_vpminq_v:
// FIXME: improve sharing scheme to cope with 3 alternative LLVM intrinsics.
Int = usgn ? Intrinsic::aarch64_neon_uminp : Intrinsic::aarch64_neon_sminp;
if (Ty->isFPOrFPVectorTy()) Int = Intrinsic::aarch64_neon_fminp;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vpmin");
case NEON::BI__builtin_neon_vpmax_v:
case NEON::BI__builtin_neon_vpmaxq_v:
// FIXME: improve sharing scheme to cope with 3 alternative LLVM intrinsics.
Int = usgn ? Intrinsic::aarch64_neon_umaxp : Intrinsic::aarch64_neon_smaxp;
if (Ty->isFPOrFPVectorTy()) Int = Intrinsic::aarch64_neon_fmaxp;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vpmax");
case NEON::BI__builtin_neon_vminnm_v:
case NEON::BI__builtin_neon_vminnmq_v:
Int = Intrinsic::aarch64_neon_fminnm;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vminnm");
case NEON::BI__builtin_neon_vminnmh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Int = Intrinsic::aarch64_neon_fminnm;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vminnm");
case NEON::BI__builtin_neon_vmaxnm_v:
case NEON::BI__builtin_neon_vmaxnmq_v:
Int = Intrinsic::aarch64_neon_fmaxnm;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vmaxnm");
case NEON::BI__builtin_neon_vmaxnmh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(1)));
Int = Intrinsic::aarch64_neon_fmaxnm;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vmaxnm");
case NEON::BI__builtin_neon_vrecpss_f32: {
Ops.push_back(EmitScalarExpr(E->getArg(1)));
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_frecps, FloatTy),
Ops, "vrecps");
}
case NEON::BI__builtin_neon_vrecpsd_f64:
Ops.push_back(EmitScalarExpr(E->getArg(1)));
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_frecps, DoubleTy),
Ops, "vrecps");
case NEON::BI__builtin_neon_vrecpsh_f16:
Ops.push_back(EmitScalarExpr(E->getArg(1)));
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_frecps, HalfTy),
Ops, "vrecps");
case NEON::BI__builtin_neon_vqshrun_n_v:
Int = Intrinsic::aarch64_neon_sqshrun;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vqshrun_n");
case NEON::BI__builtin_neon_vqrshrun_n_v:
Int = Intrinsic::aarch64_neon_sqrshrun;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vqrshrun_n");
case NEON::BI__builtin_neon_vqshrn_n_v:
Int = usgn ? Intrinsic::aarch64_neon_uqshrn : Intrinsic::aarch64_neon_sqshrn;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vqshrn_n");
case NEON::BI__builtin_neon_vrshrn_n_v:
Int = Intrinsic::aarch64_neon_rshrn;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vrshrn_n");
case NEON::BI__builtin_neon_vqrshrn_n_v:
Int = usgn ? Intrinsic::aarch64_neon_uqrshrn : Intrinsic::aarch64_neon_sqrshrn;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vqrshrn_n");
case NEON::BI__builtin_neon_vrndah_f16: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_round
: Intrinsic::round;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vrnda");
}
case NEON::BI__builtin_neon_vrnda_v:
case NEON::BI__builtin_neon_vrndaq_v: {
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_round
: Intrinsic::round;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vrnda");
}
case NEON::BI__builtin_neon_vrndih_f16: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_nearbyint
: Intrinsic::nearbyint;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vrndi");
}
case NEON::BI__builtin_neon_vrndmh_f16: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_floor
: Intrinsic::floor;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vrndm");
}
case NEON::BI__builtin_neon_vrndm_v:
case NEON::BI__builtin_neon_vrndmq_v: {
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_floor
: Intrinsic::floor;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vrndm");
}
case NEON::BI__builtin_neon_vrndnh_f16: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Int = Intrinsic::aarch64_neon_frintn;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vrndn");
}
case NEON::BI__builtin_neon_vrndn_v:
case NEON::BI__builtin_neon_vrndnq_v: {
Int = Intrinsic::aarch64_neon_frintn;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vrndn");
}
case NEON::BI__builtin_neon_vrndns_f32: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Int = Intrinsic::aarch64_neon_frintn;
return EmitNeonCall(CGM.getIntrinsic(Int, FloatTy), Ops, "vrndn");
}
case NEON::BI__builtin_neon_vrndph_f16: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_ceil
: Intrinsic::ceil;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vrndp");
}
case NEON::BI__builtin_neon_vrndp_v:
case NEON::BI__builtin_neon_vrndpq_v: {
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_ceil
: Intrinsic::ceil;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vrndp");
}
case NEON::BI__builtin_neon_vrndxh_f16: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_rint
: Intrinsic::rint;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vrndx");
}
case NEON::BI__builtin_neon_vrndx_v:
case NEON::BI__builtin_neon_vrndxq_v: {
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_rint
: Intrinsic::rint;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vrndx");
}
case NEON::BI__builtin_neon_vrndh_f16: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_trunc
: Intrinsic::trunc;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vrndz");
}
case NEON::BI__builtin_neon_vrnd_v:
case NEON::BI__builtin_neon_vrndq_v: {
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_trunc
: Intrinsic::trunc;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vrndz");
}
case NEON::BI__builtin_neon_vcvt_f64_v:
case NEON::BI__builtin_neon_vcvtq_f64_v:
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ty = GetNeonType(this, NeonTypeFlags(NeonTypeFlags::Float64, false, quad));
return usgn ? Builder.CreateUIToFP(Ops[0], Ty, "vcvt")
: Builder.CreateSIToFP(Ops[0], Ty, "vcvt");
case NEON::BI__builtin_neon_vcvt_f64_f32: {
assert(Type.getEltType() == NeonTypeFlags::Float64 && quad &&
"unexpected vcvt_f64_f32 builtin");
NeonTypeFlags SrcFlag = NeonTypeFlags(NeonTypeFlags::Float32, false, false);
Ops[0] = Builder.CreateBitCast(Ops[0], GetNeonType(this, SrcFlag));
return Builder.CreateFPExt(Ops[0], Ty, "vcvt");
}
case NEON::BI__builtin_neon_vcvt_f32_f64: {
assert(Type.getEltType() == NeonTypeFlags::Float32 &&
"unexpected vcvt_f32_f64 builtin");
NeonTypeFlags SrcFlag = NeonTypeFlags(NeonTypeFlags::Float64, false, true);
Ops[0] = Builder.CreateBitCast(Ops[0], GetNeonType(this, SrcFlag));
return Builder.CreateFPTrunc(Ops[0], Ty, "vcvt");
}
case NEON::BI__builtin_neon_vcvt_s32_v:
case NEON::BI__builtin_neon_vcvt_u32_v:
case NEON::BI__builtin_neon_vcvt_s64_v:
case NEON::BI__builtin_neon_vcvt_u64_v:
case NEON::BI__builtin_neon_vcvt_s16_v:
case NEON::BI__builtin_neon_vcvt_u16_v:
case NEON::BI__builtin_neon_vcvtq_s32_v:
case NEON::BI__builtin_neon_vcvtq_u32_v:
case NEON::BI__builtin_neon_vcvtq_s64_v:
case NEON::BI__builtin_neon_vcvtq_u64_v:
case NEON::BI__builtin_neon_vcvtq_s16_v:
case NEON::BI__builtin_neon_vcvtq_u16_v: {
Int =
usgn ? Intrinsic::aarch64_neon_fcvtzu : Intrinsic::aarch64_neon_fcvtzs;
llvm::Type *Tys[2] = {Ty, GetFloatNeonType(this, Type)};
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vcvtz");
}
case NEON::BI__builtin_neon_vcvta_s16_v:
case NEON::BI__builtin_neon_vcvta_u16_v:
case NEON::BI__builtin_neon_vcvta_s32_v:
case NEON::BI__builtin_neon_vcvtaq_s16_v:
case NEON::BI__builtin_neon_vcvtaq_s32_v:
case NEON::BI__builtin_neon_vcvta_u32_v:
case NEON::BI__builtin_neon_vcvtaq_u16_v:
case NEON::BI__builtin_neon_vcvtaq_u32_v:
case NEON::BI__builtin_neon_vcvta_s64_v:
case NEON::BI__builtin_neon_vcvtaq_s64_v:
case NEON::BI__builtin_neon_vcvta_u64_v:
case NEON::BI__builtin_neon_vcvtaq_u64_v: {
Int = usgn ? Intrinsic::aarch64_neon_fcvtau : Intrinsic::aarch64_neon_fcvtas;
llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vcvta");
}
case NEON::BI__builtin_neon_vcvtm_s16_v:
case NEON::BI__builtin_neon_vcvtm_s32_v:
case NEON::BI__builtin_neon_vcvtmq_s16_v:
case NEON::BI__builtin_neon_vcvtmq_s32_v:
case NEON::BI__builtin_neon_vcvtm_u16_v:
case NEON::BI__builtin_neon_vcvtm_u32_v:
case NEON::BI__builtin_neon_vcvtmq_u16_v:
case NEON::BI__builtin_neon_vcvtmq_u32_v:
case NEON::BI__builtin_neon_vcvtm_s64_v:
case NEON::BI__builtin_neon_vcvtmq_s64_v:
case NEON::BI__builtin_neon_vcvtm_u64_v:
case NEON::BI__builtin_neon_vcvtmq_u64_v: {
Int = usgn ? Intrinsic::aarch64_neon_fcvtmu : Intrinsic::aarch64_neon_fcvtms;
llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vcvtm");
}
case NEON::BI__builtin_neon_vcvtn_s16_v:
case NEON::BI__builtin_neon_vcvtn_s32_v:
case NEON::BI__builtin_neon_vcvtnq_s16_v:
case NEON::BI__builtin_neon_vcvtnq_s32_v:
case NEON::BI__builtin_neon_vcvtn_u16_v:
case NEON::BI__builtin_neon_vcvtn_u32_v:
case NEON::BI__builtin_neon_vcvtnq_u16_v:
case NEON::BI__builtin_neon_vcvtnq_u32_v:
case NEON::BI__builtin_neon_vcvtn_s64_v:
case NEON::BI__builtin_neon_vcvtnq_s64_v:
case NEON::BI__builtin_neon_vcvtn_u64_v:
case NEON::BI__builtin_neon_vcvtnq_u64_v: {
Int = usgn ? Intrinsic::aarch64_neon_fcvtnu : Intrinsic::aarch64_neon_fcvtns;
llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vcvtn");
}
case NEON::BI__builtin_neon_vcvtp_s16_v:
case NEON::BI__builtin_neon_vcvtp_s32_v:
case NEON::BI__builtin_neon_vcvtpq_s16_v:
case NEON::BI__builtin_neon_vcvtpq_s32_v:
case NEON::BI__builtin_neon_vcvtp_u16_v:
case NEON::BI__builtin_neon_vcvtp_u32_v:
case NEON::BI__builtin_neon_vcvtpq_u16_v:
case NEON::BI__builtin_neon_vcvtpq_u32_v:
case NEON::BI__builtin_neon_vcvtp_s64_v:
case NEON::BI__builtin_neon_vcvtpq_s64_v:
case NEON::BI__builtin_neon_vcvtp_u64_v:
case NEON::BI__builtin_neon_vcvtpq_u64_v: {
Int = usgn ? Intrinsic::aarch64_neon_fcvtpu : Intrinsic::aarch64_neon_fcvtps;
llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vcvtp");
}
case NEON::BI__builtin_neon_vmulx_v:
case NEON::BI__builtin_neon_vmulxq_v: {
Int = Intrinsic::aarch64_neon_fmulx;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vmulx");
}
case NEON::BI__builtin_neon_vmulxh_lane_f16:
case NEON::BI__builtin_neon_vmulxh_laneq_f16: {
// vmulx_lane should be mapped to Neon scalar mulx after
// extracting the scalar element
Ops.push_back(EmitScalarExpr(E->getArg(2)));
Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2], "extract");
Ops.pop_back();
Int = Intrinsic::aarch64_neon_fmulx;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vmulx");
}
case NEON::BI__builtin_neon_vmul_lane_v:
case NEON::BI__builtin_neon_vmul_laneq_v: {
// v1f64 vmul_lane should be mapped to Neon scalar mul lane
bool Quad = false;
if (BuiltinID == NEON::BI__builtin_neon_vmul_laneq_v)
Quad = true;
Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
llvm::FixedVectorType *VTy =
GetNeonType(this, NeonTypeFlags(NeonTypeFlags::Float64, false, Quad));
Ops[1] = Builder.CreateBitCast(Ops[1], VTy);
Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2], "extract");
Value *Result = Builder.CreateFMul(Ops[0], Ops[1]);
return Builder.CreateBitCast(Result, Ty);
}
case NEON::BI__builtin_neon_vnegd_s64:
return Builder.CreateNeg(EmitScalarExpr(E->getArg(0)), "vnegd");
case NEON::BI__builtin_neon_vnegh_f16:
return Builder.CreateFNeg(EmitScalarExpr(E->getArg(0)), "vnegh");
case NEON::BI__builtin_neon_vpmaxnm_v:
case NEON::BI__builtin_neon_vpmaxnmq_v: {
Int = Intrinsic::aarch64_neon_fmaxnmp;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vpmaxnm");
}
case NEON::BI__builtin_neon_vpminnm_v:
case NEON::BI__builtin_neon_vpminnmq_v: {
Int = Intrinsic::aarch64_neon_fminnmp;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vpminnm");
}
case NEON::BI__builtin_neon_vsqrth_f16: {
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_sqrt
: Intrinsic::sqrt;
return EmitNeonCall(CGM.getIntrinsic(Int, HalfTy), Ops, "vsqrt");
}
case NEON::BI__builtin_neon_vsqrt_v:
case NEON::BI__builtin_neon_vsqrtq_v: {
Int = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_sqrt
: Intrinsic::sqrt;
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vsqrt");
}
case NEON::BI__builtin_neon_vrbit_v:
case NEON::BI__builtin_neon_vrbitq_v: {
Int = Intrinsic::aarch64_neon_rbit;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vrbit");
}
case NEON::BI__builtin_neon_vaddv_u8:
// FIXME: These are handled by the AArch64 scalar code.
usgn = true;
LLVM_FALLTHROUGH;
case NEON::BI__builtin_neon_vaddv_s8: {
Int = usgn ? Intrinsic::aarch64_neon_uaddv : Intrinsic::aarch64_neon_saddv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddv");
return Builder.CreateTrunc(Ops[0], Int8Ty);
}
case NEON::BI__builtin_neon_vaddv_u16:
usgn = true;
LLVM_FALLTHROUGH;
case NEON::BI__builtin_neon_vaddv_s16: {
Int = usgn ? Intrinsic::aarch64_neon_uaddv : Intrinsic::aarch64_neon_saddv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vaddvq_u8:
usgn = true;
LLVM_FALLTHROUGH;
case NEON::BI__builtin_neon_vaddvq_s8: {
Int = usgn ? Intrinsic::aarch64_neon_uaddv : Intrinsic::aarch64_neon_saddv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 16);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddv");
return Builder.CreateTrunc(Ops[0], Int8Ty);
}
case NEON::BI__builtin_neon_vaddvq_u16:
usgn = true;
LLVM_FALLTHROUGH;
case NEON::BI__builtin_neon_vaddvq_s16: {
Int = usgn ? Intrinsic::aarch64_neon_uaddv : Intrinsic::aarch64_neon_saddv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vmaxv_u8: {
Int = Intrinsic::aarch64_neon_umaxv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxv");
return Builder.CreateTrunc(Ops[0], Int8Ty);
}
case NEON::BI__builtin_neon_vmaxv_u16: {
Int = Intrinsic::aarch64_neon_umaxv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vmaxvq_u8: {
Int = Intrinsic::aarch64_neon_umaxv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 16);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxv");
return Builder.CreateTrunc(Ops[0], Int8Ty);
}
case NEON::BI__builtin_neon_vmaxvq_u16: {
Int = Intrinsic::aarch64_neon_umaxv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vmaxv_s8: {
Int = Intrinsic::aarch64_neon_smaxv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxv");
return Builder.CreateTrunc(Ops[0], Int8Ty);
}
case NEON::BI__builtin_neon_vmaxv_s16: {
Int = Intrinsic::aarch64_neon_smaxv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vmaxvq_s8: {
Int = Intrinsic::aarch64_neon_smaxv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 16);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxv");
return Builder.CreateTrunc(Ops[0], Int8Ty);
}
case NEON::BI__builtin_neon_vmaxvq_s16: {
Int = Intrinsic::aarch64_neon_smaxv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vmaxv_f16: {
Int = Intrinsic::aarch64_neon_fmaxv;
Ty = HalfTy;
VTy = llvm::FixedVectorType::get(HalfTy, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxv");
return Builder.CreateTrunc(Ops[0], HalfTy);
}
case NEON::BI__builtin_neon_vmaxvq_f16: {
Int = Intrinsic::aarch64_neon_fmaxv;
Ty = HalfTy;
VTy = llvm::FixedVectorType::get(HalfTy, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxv");
return Builder.CreateTrunc(Ops[0], HalfTy);
}
case NEON::BI__builtin_neon_vminv_u8: {
Int = Intrinsic::aarch64_neon_uminv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminv");
return Builder.CreateTrunc(Ops[0], Int8Ty);
}
case NEON::BI__builtin_neon_vminv_u16: {
Int = Intrinsic::aarch64_neon_uminv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vminvq_u8: {
Int = Intrinsic::aarch64_neon_uminv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 16);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminv");
return Builder.CreateTrunc(Ops[0], Int8Ty);
}
case NEON::BI__builtin_neon_vminvq_u16: {
Int = Intrinsic::aarch64_neon_uminv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vminv_s8: {
Int = Intrinsic::aarch64_neon_sminv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminv");
return Builder.CreateTrunc(Ops[0], Int8Ty);
}
case NEON::BI__builtin_neon_vminv_s16: {
Int = Intrinsic::aarch64_neon_sminv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vminvq_s8: {
Int = Intrinsic::aarch64_neon_sminv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 16);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminv");
return Builder.CreateTrunc(Ops[0], Int8Ty);
}
case NEON::BI__builtin_neon_vminvq_s16: {
Int = Intrinsic::aarch64_neon_sminv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vminv_f16: {
Int = Intrinsic::aarch64_neon_fminv;
Ty = HalfTy;
VTy = llvm::FixedVectorType::get(HalfTy, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminv");
return Builder.CreateTrunc(Ops[0], HalfTy);
}
case NEON::BI__builtin_neon_vminvq_f16: {
Int = Intrinsic::aarch64_neon_fminv;
Ty = HalfTy;
VTy = llvm::FixedVectorType::get(HalfTy, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminv");
return Builder.CreateTrunc(Ops[0], HalfTy);
}
case NEON::BI__builtin_neon_vmaxnmv_f16: {
Int = Intrinsic::aarch64_neon_fmaxnmv;
Ty = HalfTy;
VTy = llvm::FixedVectorType::get(HalfTy, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxnmv");
return Builder.CreateTrunc(Ops[0], HalfTy);
}
case NEON::BI__builtin_neon_vmaxnmvq_f16: {
Int = Intrinsic::aarch64_neon_fmaxnmv;
Ty = HalfTy;
VTy = llvm::FixedVectorType::get(HalfTy, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vmaxnmv");
return Builder.CreateTrunc(Ops[0], HalfTy);
}
case NEON::BI__builtin_neon_vminnmv_f16: {
Int = Intrinsic::aarch64_neon_fminnmv;
Ty = HalfTy;
VTy = llvm::FixedVectorType::get(HalfTy, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminnmv");
return Builder.CreateTrunc(Ops[0], HalfTy);
}
case NEON::BI__builtin_neon_vminnmvq_f16: {
Int = Intrinsic::aarch64_neon_fminnmv;
Ty = HalfTy;
VTy = llvm::FixedVectorType::get(HalfTy, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vminnmv");
return Builder.CreateTrunc(Ops[0], HalfTy);
}
case NEON::BI__builtin_neon_vmul_n_f64: {
Ops[0] = Builder.CreateBitCast(Ops[0], DoubleTy);
Value *RHS = Builder.CreateBitCast(EmitScalarExpr(E->getArg(1)), DoubleTy);
return Builder.CreateFMul(Ops[0], RHS);
}
case NEON::BI__builtin_neon_vaddlv_u8: {
Int = Intrinsic::aarch64_neon_uaddlv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddlv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vaddlv_u16: {
Int = Intrinsic::aarch64_neon_uaddlv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddlv");
}
case NEON::BI__builtin_neon_vaddlvq_u8: {
Int = Intrinsic::aarch64_neon_uaddlv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 16);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddlv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vaddlvq_u16: {
Int = Intrinsic::aarch64_neon_uaddlv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddlv");
}
case NEON::BI__builtin_neon_vaddlv_s8: {
Int = Intrinsic::aarch64_neon_saddlv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddlv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vaddlv_s16: {
Int = Intrinsic::aarch64_neon_saddlv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 4);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddlv");
}
case NEON::BI__builtin_neon_vaddlvq_s8: {
Int = Intrinsic::aarch64_neon_saddlv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int8Ty, 16);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
Ops[0] = EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddlv");
return Builder.CreateTrunc(Ops[0], Int16Ty);
}
case NEON::BI__builtin_neon_vaddlvq_s16: {
Int = Intrinsic::aarch64_neon_saddlv;
Ty = Int32Ty;
VTy = llvm::FixedVectorType::get(Int16Ty, 8);
llvm::Type *Tys[2] = { Ty, VTy };
Ops.push_back(EmitScalarExpr(E->getArg(0)));
return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, "vaddlv");
}
case NEON::BI__builtin_neon_vsri_n_v:
case NEON::BI__builtin_neon_vsriq_n_v: {
Int = Intrinsic::aarch64_neon_vsri;
llvm::Function *Intrin = CGM.getIntrinsic(Int, Ty);
return EmitNeonCall(Intrin, Ops, "vsri_n");
}
case NEON::BI__builtin_neon_vsli_n_v:
case NEON::BI__builtin_neon_vsliq_n_v: {
Int = Intrinsic::aarch64_neon_vsli;
llvm::Function *Intrin = CGM.getIntrinsic(Int, Ty);
return EmitNeonCall(Intrin, Ops, "vsli_n");
}
case NEON::BI__builtin_neon_vsra_n_v:
case NEON::BI__builtin_neon_vsraq_n_v:
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ops[1] = EmitNeonRShiftImm(Ops[1], Ops[2], Ty, usgn, "vsra_n");
return Builder.CreateAdd(Ops[0], Ops[1]);
case NEON::BI__builtin_neon_vrsra_n_v:
case NEON::BI__builtin_neon_vrsraq_n_v: {
Int = usgn ? Intrinsic::aarch64_neon_urshl : Intrinsic::aarch64_neon_srshl;
SmallVector<llvm::Value*,2> TmpOps;
TmpOps.push_back(Ops[1]);
TmpOps.push_back(Ops[2]);
Function* F = CGM.getIntrinsic(Int, Ty);
llvm::Value *tmp = EmitNeonCall(F, TmpOps, "vrshr_n", 1, true);
Ops[0] = Builder.CreateBitCast(Ops[0], VTy);
return Builder.CreateAdd(Ops[0], tmp);
}
case NEON::BI__builtin_neon_vld1_v:
case NEON::BI__builtin_neon_vld1q_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(VTy));
return Builder.CreateAlignedLoad(VTy, Ops[0], PtrOp0.getAlignment());
}
case NEON::BI__builtin_neon_vst1_v:
case NEON::BI__builtin_neon_vst1q_v:
Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(VTy));
Ops[1] = Builder.CreateBitCast(Ops[1], VTy);
return Builder.CreateAlignedStore(Ops[1], Ops[0], PtrOp0.getAlignment());
case NEON::BI__builtin_neon_vld1_lane_v:
case NEON::BI__builtin_neon_vld1q_lane_v: {
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ty = llvm::PointerType::getUnqual(VTy->getElementType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ops[0] = Builder.CreateAlignedLoad(VTy->getElementType(), Ops[0],
PtrOp0.getAlignment());
return Builder.CreateInsertElement(Ops[1], Ops[0], Ops[2], "vld1_lane");
}
case NEON::BI__builtin_neon_vld1_dup_v:
case NEON::BI__builtin_neon_vld1q_dup_v: {
Value *V = UndefValue::get(Ty);
Ty = llvm::PointerType::getUnqual(VTy->getElementType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
Ops[0] = Builder.CreateAlignedLoad(VTy->getElementType(), Ops[0],
PtrOp0.getAlignment());
llvm::Constant *CI = ConstantInt::get(Int32Ty, 0);
Ops[0] = Builder.CreateInsertElement(V, Ops[0], CI);
return EmitNeonSplat(Ops[0], CI);
}
case NEON::BI__builtin_neon_vst1_lane_v:
case NEON::BI__builtin_neon_vst1q_lane_v:
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[1] = Builder.CreateExtractElement(Ops[1], Ops[2]);
Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
return Builder.CreateAlignedStore(Ops[1], Builder.CreateBitCast(Ops[0], Ty),
PtrOp0.getAlignment());
case NEON::BI__builtin_neon_vld2_v:
case NEON::BI__builtin_neon_vld2q_v: {
llvm::Type *PTy = llvm::PointerType::getUnqual(VTy);
Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
llvm::Type *Tys[2] = { VTy, PTy };
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld2, Tys);
Ops[1] = Builder.CreateCall(F, Ops[1], "vld2");
Ops[0] = Builder.CreateBitCast(Ops[0],
llvm::PointerType::getUnqual(Ops[1]->getType()));
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vld3_v:
case NEON::BI__builtin_neon_vld3q_v: {
llvm::Type *PTy = llvm::PointerType::getUnqual(VTy);
Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
llvm::Type *Tys[2] = { VTy, PTy };
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld3, Tys);
Ops[1] = Builder.CreateCall(F, Ops[1], "vld3");
Ops[0] = Builder.CreateBitCast(Ops[0],
llvm::PointerType::getUnqual(Ops[1]->getType()));
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vld4_v:
case NEON::BI__builtin_neon_vld4q_v: {
llvm::Type *PTy = llvm::PointerType::getUnqual(VTy);
Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
llvm::Type *Tys[2] = { VTy, PTy };
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld4, Tys);
Ops[1] = Builder.CreateCall(F, Ops[1], "vld4");
Ops[0] = Builder.CreateBitCast(Ops[0],
llvm::PointerType::getUnqual(Ops[1]->getType()));
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vld2_dup_v:
case NEON::BI__builtin_neon_vld2q_dup_v: {
llvm::Type *PTy =
llvm::PointerType::getUnqual(VTy->getElementType());
Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
llvm::Type *Tys[2] = { VTy, PTy };
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld2r, Tys);
Ops[1] = Builder.CreateCall(F, Ops[1], "vld2");
Ops[0] = Builder.CreateBitCast(Ops[0],
llvm::PointerType::getUnqual(Ops[1]->getType()));
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vld3_dup_v:
case NEON::BI__builtin_neon_vld3q_dup_v: {
llvm::Type *PTy =
llvm::PointerType::getUnqual(VTy->getElementType());
Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
llvm::Type *Tys[2] = { VTy, PTy };
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld3r, Tys);
Ops[1] = Builder.CreateCall(F, Ops[1], "vld3");
Ops[0] = Builder.CreateBitCast(Ops[0],
llvm::PointerType::getUnqual(Ops[1]->getType()));
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vld4_dup_v:
case NEON::BI__builtin_neon_vld4q_dup_v: {
llvm::Type *PTy =
llvm::PointerType::getUnqual(VTy->getElementType());
Ops[1] = Builder.CreateBitCast(Ops[1], PTy);
llvm::Type *Tys[2] = { VTy, PTy };
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld4r, Tys);
Ops[1] = Builder.CreateCall(F, Ops[1], "vld4");
Ops[0] = Builder.CreateBitCast(Ops[0],
llvm::PointerType::getUnqual(Ops[1]->getType()));
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vld2_lane_v:
case NEON::BI__builtin_neon_vld2q_lane_v: {
llvm::Type *Tys[2] = { VTy, Ops[1]->getType() };
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld2lane, Tys);
std::rotate(Ops.begin() + 1, Ops.begin() + 2, Ops.end());
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Ops[3] = Builder.CreateZExt(Ops[3], Int64Ty);
Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld2_lane");
Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vld3_lane_v:
case NEON::BI__builtin_neon_vld3q_lane_v: {
llvm::Type *Tys[2] = { VTy, Ops[1]->getType() };
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld3lane, Tys);
std::rotate(Ops.begin() + 1, Ops.begin() + 2, Ops.end());
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
Ops[4] = Builder.CreateZExt(Ops[4], Int64Ty);
Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld3_lane");
Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vld4_lane_v:
case NEON::BI__builtin_neon_vld4q_lane_v: {
llvm::Type *Tys[2] = { VTy, Ops[1]->getType() };
Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld4lane, Tys);
std::rotate(Ops.begin() + 1, Ops.begin() + 2, Ops.end());
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Ops[3] = Builder.CreateBitCast(Ops[3], Ty);
Ops[4] = Builder.CreateBitCast(Ops[4], Ty);
Ops[5] = Builder.CreateZExt(Ops[5], Int64Ty);
Ops[1] = Builder.CreateCall(F, makeArrayRef(Ops).slice(1), "vld4_lane");
Ty = llvm::PointerType::getUnqual(Ops[1]->getType());
Ops[0] = Builder.CreateBitCast(Ops[0], Ty);
return Builder.CreateDefaultAlignedStore(Ops[1], Ops[0]);
}
case NEON::BI__builtin_neon_vst2_v:
case NEON::BI__builtin_neon_vst2q_v: {
std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end());
llvm::Type *Tys[2] = { VTy, Ops[2]->getType() };
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_st2, Tys),
Ops, "");
}
case NEON::BI__builtin_neon_vst2_lane_v:
case NEON::BI__builtin_neon_vst2q_lane_v: {
std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end());
Ops[2] = Builder.CreateZExt(Ops[2], Int64Ty);
llvm::Type *Tys[2] = { VTy, Ops[3]->getType() };
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_st2lane, Tys),
Ops, "");
}
case NEON::BI__builtin_neon_vst3_v:
case NEON::BI__builtin_neon_vst3q_v: {
std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end());
llvm::Type *Tys[2] = { VTy, Ops[3]->getType() };
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_st3, Tys),
Ops, "");
}
case NEON::BI__builtin_neon_vst3_lane_v:
case NEON::BI__builtin_neon_vst3q_lane_v: {
std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end());
Ops[3] = Builder.CreateZExt(Ops[3], Int64Ty);
llvm::Type *Tys[2] = { VTy, Ops[4]->getType() };
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_st3lane, Tys),
Ops, "");
}
case NEON::BI__builtin_neon_vst4_v:
case NEON::BI__builtin_neon_vst4q_v: {
std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end());
llvm::Type *Tys[2] = { VTy, Ops[4]->getType() };
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_st4, Tys),
Ops, "");
}
case NEON::BI__builtin_neon_vst4_lane_v:
case NEON::BI__builtin_neon_vst4q_lane_v: {
std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end());
Ops[4] = Builder.CreateZExt(Ops[4], Int64Ty);
llvm::Type *Tys[2] = { VTy, Ops[5]->getType() };
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_st4lane, Tys),
Ops, "");
}
case NEON::BI__builtin_neon_vtrn_v:
case NEON::BI__builtin_neon_vtrnq_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Value *SV = nullptr;
for (unsigned vi = 0; vi != 2; ++vi) {
SmallVector<int, 16> Indices;
for (unsigned i = 0, e = VTy->getNumElements(); i != e; i += 2) {
Indices.push_back(i+vi);
Indices.push_back(i+e+vi);
}
Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vtrn");
SV = Builder.CreateDefaultAlignedStore(SV, Addr);
}
return SV;
}
case NEON::BI__builtin_neon_vuzp_v:
case NEON::BI__builtin_neon_vuzpq_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Value *SV = nullptr;
for (unsigned vi = 0; vi != 2; ++vi) {
SmallVector<int, 16> Indices;
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i)
Indices.push_back(2*i+vi);
Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vuzp");
SV = Builder.CreateDefaultAlignedStore(SV, Addr);
}
return SV;
}
case NEON::BI__builtin_neon_vzip_v:
case NEON::BI__builtin_neon_vzipq_v: {
Ops[0] = Builder.CreateBitCast(Ops[0], llvm::PointerType::getUnqual(Ty));
Ops[1] = Builder.CreateBitCast(Ops[1], Ty);
Ops[2] = Builder.CreateBitCast(Ops[2], Ty);
Value *SV = nullptr;
for (unsigned vi = 0; vi != 2; ++vi) {
SmallVector<int, 16> Indices;
for (unsigned i = 0, e = VTy->getNumElements(); i != e; i += 2) {
Indices.push_back((i + vi*e) >> 1);
Indices.push_back(((i + vi*e) >> 1)+e);
}
Value *Addr = Builder.CreateConstInBoundsGEP1_32(Ty, Ops[0], vi);
SV = Builder.CreateShuffleVector(Ops[1], Ops[2], Indices, "vzip");
SV = Builder.CreateDefaultAlignedStore(SV, Addr);
}
return SV;
}
case NEON::BI__builtin_neon_vqtbl1q_v: {
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_tbl1, Ty),
Ops, "vtbl1");
}
case NEON::BI__builtin_neon_vqtbl2q_v: {
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_tbl2, Ty),
Ops, "vtbl2");
}
case NEON::BI__builtin_neon_vqtbl3q_v: {
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_tbl3, Ty),
Ops, "vtbl3");
}
case NEON::BI__builtin_neon_vqtbl4q_v: {
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_tbl4, Ty),
Ops, "vtbl4");
}
case NEON::BI__builtin_neon_vqtbx1q_v: {
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_tbx1, Ty),
Ops, "vtbx1");
}
case NEON::BI__builtin_neon_vqtbx2q_v: {
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_tbx2, Ty),
Ops, "vtbx2");
}
case NEON::BI__builtin_neon_vqtbx3q_v: {
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_tbx3, Ty),
Ops, "vtbx3");
}
case NEON::BI__builtin_neon_vqtbx4q_v: {
return EmitNeonCall(CGM.getIntrinsic(Intrinsic::aarch64_neon_tbx4, Ty),
Ops, "vtbx4");
}
case NEON::BI__builtin_neon_vsqadd_v:
case NEON::BI__builtin_neon_vsqaddq_v: {
Int = Intrinsic::aarch64_neon_usqadd;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vsqadd");
}
case NEON::BI__builtin_neon_vuqadd_v:
case NEON::BI__builtin_neon_vuqaddq_v: {
Int = Intrinsic::aarch64_neon_suqadd;
return EmitNeonCall(CGM.getIntrinsic(Int, Ty), Ops, "vuqadd");
}
}
}
Value *CodeGenFunction::EmitBPFBuiltinExpr(unsigned BuiltinID,
const CallExpr *E) {
assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||
BuiltinID == BPF::BI__builtin_btf_type_id ||
BuiltinID == BPF::BI__builtin_preserve_type_info ||
BuiltinID == BPF::BI__builtin_preserve_enum_value) &&
"unexpected BPF builtin");
// A sequence number, injected into IR builtin functions, to
// prevent CSE given the only difference of the funciton
// may just be the debuginfo metadata.
static uint32_t BuiltinSeqNum;
switch (BuiltinID) {
default:
llvm_unreachable("Unexpected BPF builtin");
case BPF::BI__builtin_preserve_field_info: {
const Expr *Arg = E->getArg(0);
bool IsBitField = Arg->IgnoreParens()->getObjectKind() == OK_BitField;
if (!getDebugInfo()) {
CGM.Error(E->getExprLoc(),
"using __builtin_preserve_field_info() without -g");
return IsBitField ? EmitLValue(Arg).getBitFieldPointer()
: EmitLValue(Arg).getPointer(*this);
}
// Enable underlying preserve_*_access_index() generation.
bool OldIsInPreservedAIRegion = IsInPreservedAIRegion;
IsInPreservedAIRegion = true;
Value *FieldAddr = IsBitField ? EmitLValue(Arg).getBitFieldPointer()
: EmitLValue(Arg).getPointer(*this);
IsInPreservedAIRegion = OldIsInPreservedAIRegion;
ConstantInt *C = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
Value *InfoKind = ConstantInt::get(Int64Ty, C->getSExtValue());
// Built the IR for the preserve_field_info intrinsic.
llvm::Function *FnGetFieldInfo = llvm::Intrinsic::getDeclaration(
&CGM.getModule(), llvm::Intrinsic::bpf_preserve_field_info,
{FieldAddr->getType()});
return Builder.CreateCall(FnGetFieldInfo, {FieldAddr, InfoKind});
}
case BPF::BI__builtin_btf_type_id:
case BPF::BI__builtin_preserve_type_info: {
if (!getDebugInfo()) {
CGM.Error(E->getExprLoc(), "using builtin function without -g");
return nullptr;
}
const Expr *Arg0 = E->getArg(0);
llvm::DIType *DbgInfo = getDebugInfo()->getOrCreateStandaloneType(
Arg0->getType(), Arg0->getExprLoc());
ConstantInt *Flag = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
Value *FlagValue = ConstantInt::get(Int64Ty, Flag->getSExtValue());
Value *SeqNumVal = ConstantInt::get(Int32Ty, BuiltinSeqNum++);
llvm::Function *FnDecl;
if (BuiltinID == BPF::BI__builtin_btf_type_id)
FnDecl = llvm::Intrinsic::getDeclaration(
&CGM.getModule(), llvm::Intrinsic::bpf_btf_type_id, {});
else
FnDecl = llvm::Intrinsic::getDeclaration(
&CGM.getModule(), llvm::Intrinsic::bpf_preserve_type_info, {});
CallInst *Fn = Builder.CreateCall(FnDecl, {SeqNumVal, FlagValue});
Fn->setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
return Fn;
}
case BPF::BI__builtin_preserve_enum_value: {
if (!getDebugInfo()) {
CGM.Error(E->getExprLoc(), "using builtin function without -g");
return nullptr;
}
const Expr *Arg0 = E->getArg(0);
llvm::DIType *DbgInfo = getDebugInfo()->getOrCreateStandaloneType(
Arg0->getType(), Arg0->getExprLoc());
// Find enumerator
const auto *UO = cast<UnaryOperator>(Arg0->IgnoreParens());
const auto *CE = cast<CStyleCastExpr>(UO->getSubExpr());
const auto *DR = cast<DeclRefExpr>(CE->getSubExpr());
const auto *Enumerator = cast<EnumConstantDecl>(DR->getDecl());
auto &InitVal = Enumerator->getInitVal();
std::string InitValStr;
if (InitVal.isNegative() || InitVal > uint64_t(INT64_MAX))
InitValStr = std::to_string(InitVal.getSExtValue());
else
InitValStr = std::to_string(InitVal.getZExtValue());
std::string EnumStr = Enumerator->getNameAsString() + ":" + InitValStr;
Value *EnumStrVal = Builder.CreateGlobalStringPtr(EnumStr);
ConstantInt *Flag = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
Value *FlagValue = ConstantInt::get(Int64Ty, Flag->getSExtValue());
Value *SeqNumVal = ConstantInt::get(Int32Ty, BuiltinSeqNum++);
llvm::Function *IntrinsicFn = llvm::Intrinsic::getDeclaration(
&CGM.getModule(), llvm::Intrinsic::bpf_preserve_enum_value, {});
CallInst *Fn =
Builder.CreateCall(IntrinsicFn, {SeqNumVal, EnumStrVal, FlagValue});
Fn->setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
return Fn;
}
}
}
llvm::Value *CodeGenFunction::
BuildVector(ArrayRef<llvm::Value*> Ops) {
assert((Ops.size() & (Ops.size() - 1)) == 0 &&
"Not a power-of-two sized vector!");
bool AllConstants = true;
for (unsigned i = 0, e = Ops.size(); i != e && AllConstants; ++i)
AllConstants &= isa<Constant>(Ops[i]);
// If this is a constant vector, create a ConstantVector.
if (AllConstants) {
SmallVector<llvm::Constant*, 16> CstOps;
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
CstOps.push_back(cast<Constant>(Ops[i]));
return llvm::ConstantVector::get(CstOps);
}
// Otherwise, insertelement the values to build the vector.
Value *Result = llvm::UndefValue::get(
llvm::FixedVectorType::get(Ops[0]->getType(), Ops.size()));
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
Result = Builder.CreateInsertElement(Result, Ops[i], Builder.getInt32(i));
return Result;
}
// Convert the mask from an integer type to a vector of i1.
static Value *getMaskVecValue(CodeGenFunction &CGF, Value *Mask,
unsigned NumElts) {
auto *MaskTy = llvm::FixedVectorType::get(
CGF.Builder.getInt1Ty(),
cast<IntegerType>(Mask->getType())->getBitWidth());
Value *MaskVec = CGF.Builder.CreateBitCast(Mask, MaskTy);
// If we have less than 8 elements, then the starting mask was an i8 and
// we need to extract down to the right number of elements.
if (NumElts < 8) {
int Indices[4];
for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = i;
MaskVec = CGF.Builder.CreateShuffleVector(MaskVec, MaskVec,
makeArrayRef(Indices, NumElts),
"extract");
}
return MaskVec;
}
static Value *EmitX86MaskedStore(CodeGenFunction &CGF, ArrayRef<Value *> Ops,
Align Alignment) {
// Cast the pointer to right type.
Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
llvm::PointerType::getUnqual(Ops[1]->getType()));
Value *MaskVec = getMaskVecValue(
CGF, Ops[2],
cast<llvm::FixedVectorType>(Ops[1]->getType())->getNumElements());
return CGF.Builder.CreateMaskedStore(Ops[1], Ptr, Alignment, MaskVec);
}
static Value *EmitX86MaskedLoad(CodeGenFunction &CGF, ArrayRef<Value *> Ops,
Align Alignment) {
// Cast the pointer to right type.
Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
llvm::PointerType::getUnqual(Ops[1]->getType()));
Value *MaskVec = getMaskVecValue(
CGF, Ops[2],
cast<llvm::FixedVectorType>(Ops[1]->getType())->getNumElements());
return CGF.Builder.CreateMaskedLoad(Ptr, Alignment, MaskVec, Ops[1]);
}
static Value *EmitX86ExpandLoad(CodeGenFunction &CGF,
ArrayRef<Value *> Ops) {
auto *ResultTy = cast<llvm::VectorType>(Ops[1]->getType());
llvm::Type *PtrTy = ResultTy->getElementType();
// Cast the pointer to element type.
Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
llvm::PointerType::getUnqual(PtrTy));
Value *MaskVec = getMaskVecValue(
CGF, Ops[2], cast<FixedVectorType>(ResultTy)->getNumElements());
llvm::Function *F = CGF.CGM.getIntrinsic(Intrinsic::masked_expandload,
ResultTy);
return CGF.Builder.CreateCall(F, { Ptr, MaskVec, Ops[1] });
}
static Value *EmitX86CompressExpand(CodeGenFunction &CGF,
ArrayRef<Value *> Ops,
bool IsCompress) {
auto *ResultTy = cast<llvm::FixedVectorType>(Ops[1]->getType());
Value *MaskVec = getMaskVecValue(CGF, Ops[2], ResultTy->getNumElements());
Intrinsic::ID IID = IsCompress ? Intrinsic::x86_avx512_mask_compress
: Intrinsic::x86_avx512_mask_expand;
llvm::Function *F = CGF.CGM.getIntrinsic(IID, ResultTy);
return CGF.Builder.CreateCall(F, { Ops[0], Ops[1], MaskVec });
}
static Value *EmitX86CompressStore(CodeGenFunction &CGF,
ArrayRef<Value *> Ops) {
auto *ResultTy = cast<llvm::FixedVectorType>(Ops[1]->getType());
llvm::Type *PtrTy = ResultTy->getElementType();
// Cast the pointer to element type.
Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
llvm::PointerType::getUnqual(PtrTy));
Value *MaskVec = getMaskVecValue(CGF, Ops[2], ResultTy->getNumElements());
llvm::Function *F = CGF.CGM.getIntrinsic(Intrinsic::masked_compressstore,
ResultTy);
return CGF.Builder.CreateCall(F, { Ops[1], Ptr, MaskVec });
}
static Value *EmitX86MaskLogic(CodeGenFunction &CGF, Instruction::BinaryOps Opc,
ArrayRef<Value *> Ops,
bool InvertLHS = false) {
unsigned NumElts = Ops[0]->getType()->getIntegerBitWidth();
Value *LHS = getMaskVecValue(CGF, Ops[0], NumElts);
Value *RHS = getMaskVecValue(CGF, Ops[1], NumElts);
if (InvertLHS)
LHS = CGF.Builder.CreateNot(LHS);
return CGF.Builder.CreateBitCast(CGF.Builder.CreateBinOp(Opc, LHS, RHS),
Ops[0]->getType());
}
static Value *EmitX86FunnelShift(CodeGenFunction &CGF, Value *Op0, Value *Op1,
Value *Amt, bool IsRight) {
llvm::Type *Ty = Op0->getType();
// Amount may be scalar immediate, in which case create a splat vector.
// Funnel shifts amounts are treated as modulo and types are all power-of-2 so
// we only care about the lowest log2 bits anyway.
if (Amt->getType() != Ty) {
unsigned NumElts = cast<llvm::FixedVectorType>(Ty)->getNumElements();
Amt = CGF.Builder.CreateIntCast(Amt, Ty->getScalarType(), false);
Amt = CGF.Builder.CreateVectorSplat(NumElts, Amt);
}
unsigned IID = IsRight ? Intrinsic::fshr : Intrinsic::fshl;
Function *F = CGF.CGM.getIntrinsic(IID, Ty);
return CGF.Builder.CreateCall(F, {Op0, Op1, Amt});
}
static Value *EmitX86vpcom(CodeGenFunction &CGF, ArrayRef<Value *> Ops,
bool IsSigned) {
Value *Op0 = Ops[0];
Value *Op1 = Ops[1];
llvm::Type *Ty = Op0->getType();
uint64_t Imm = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0x7;
CmpInst::Predicate Pred;
switch (Imm) {
case 0x0:
Pred = IsSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
break;
case 0x1:
Pred = IsSigned ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE;
break;
case 0x2:
Pred = IsSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
break;
case 0x3:
Pred = IsSigned ? ICmpInst::ICMP_SGE : ICmpInst::ICMP_UGE;
break;
case 0x4:
Pred = ICmpInst::ICMP_EQ;
break;
case 0x5:
Pred = ICmpInst::ICMP_NE;
break;
case 0x6:
return llvm::Constant::getNullValue(Ty); // FALSE
case 0x7:
return llvm::Constant::getAllOnesValue(Ty); // TRUE
default:
llvm_unreachable("Unexpected XOP vpcom/vpcomu predicate");
}
Value *Cmp = CGF.Builder.CreateICmp(Pred, Op0, Op1);
Value *Res = CGF.Builder.CreateSExt(Cmp, Ty);
return Res;
}
static Value *EmitX86Select(CodeGenFunction &CGF,
Value *Mask, Value *Op0, Value *Op1) {
// If the mask is all ones just return first argument.
if (const auto *C = dyn_cast<Constant>(Mask))
if (C->isAllOnesValue())
return Op0;
Mask = getMaskVecValue(
CGF, Mask, cast<llvm::FixedVectorType>(Op0->getType())->getNumElements());
return CGF.Builder.CreateSelect(Mask, Op0, Op1);
}
static Value *EmitX86ScalarSelect(CodeGenFunction &CGF,
Value *Mask, Value *Op0, Value *Op1) {
// If the mask is all ones just return first argument.
if (const auto *C = dyn_cast<Constant>(Mask))
if (C->isAllOnesValue())
return Op0;
auto *MaskTy = llvm::FixedVectorType::get(
CGF.Builder.getInt1Ty(), Mask->getType()->getIntegerBitWidth());
Mask = CGF.Builder.CreateBitCast(Mask, MaskTy);
Mask = CGF.Builder.CreateExtractElement(Mask, (uint64_t)0);
return CGF.Builder.CreateSelect(Mask, Op0, Op1);
}
static Value *EmitX86MaskedCompareResult(CodeGenFunction &CGF, Value *Cmp,
unsigned NumElts, Value *MaskIn) {
if (MaskIn) {
const auto *C = dyn_cast<Constant>(MaskIn);
if (!C || !C->isAllOnesValue())
Cmp = CGF.Builder.CreateAnd(Cmp, getMaskVecValue(CGF, MaskIn, NumElts));
}
if (NumElts < 8) {
int Indices[8];
for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = i;
for (unsigned i = NumElts; i != 8; ++i)
Indices[i] = i % NumElts + NumElts;
Cmp = CGF.Builder.CreateShuffleVector(
Cmp, llvm::Constant::getNullValue(Cmp->getType()), Indices);
}
return CGF.Builder.CreateBitCast(Cmp,
IntegerType::get(CGF.getLLVMContext(),
std::max(NumElts, 8U)));
}
static Value *EmitX86MaskedCompare(CodeGenFunction &CGF, unsigned CC,
bool Signed, ArrayRef<Value *> Ops) {
assert((Ops.size() == 2 || Ops.size() == 4) &&
"Unexpected number of arguments");
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
Value *Cmp;
if (CC == 3) {
Cmp = Constant::getNullValue(
llvm::FixedVectorType::get(CGF.Builder.getInt1Ty(), NumElts));
} else if (CC == 7) {
Cmp = Constant::getAllOnesValue(
llvm::FixedVectorType::get(CGF.Builder.getInt1Ty(), NumElts));
} else {
ICmpInst::Predicate Pred;
switch (CC) {
default: llvm_unreachable("Unknown condition code");
case 0: Pred = ICmpInst::ICMP_EQ; break;
case 1: Pred = Signed ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT; break;
case 2: Pred = Signed ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE; break;
case 4: Pred = ICmpInst::ICMP_NE; break;
case 5: Pred = Signed ? ICmpInst::ICMP_SGE : ICmpInst::ICMP_UGE; break;
case 6: Pred = Signed ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT; break;
}
Cmp = CGF.Builder.CreateICmp(Pred, Ops[0], Ops[1]);
}
Value *MaskIn = nullptr;
if (Ops.size() == 4)
MaskIn = Ops[3];
return EmitX86MaskedCompareResult(CGF, Cmp, NumElts, MaskIn);
}
static Value *EmitX86ConvertToMask(CodeGenFunction &CGF, Value *In) {
Value *Zero = Constant::getNullValue(In->getType());
return EmitX86MaskedCompare(CGF, 1, true, { In, Zero });
}
static Value *EmitX86ConvertIntToFp(CodeGenFunction &CGF,
ArrayRef<Value *> Ops, bool IsSigned) {
unsigned Rnd = cast<llvm::ConstantInt>(Ops[3])->getZExtValue();
llvm::Type *Ty = Ops[1]->getType();
Value *Res;
if (Rnd != 4) {
Intrinsic::ID IID = IsSigned ? Intrinsic::x86_avx512_sitofp_round
: Intrinsic::x86_avx512_uitofp_round;
Function *F = CGF.CGM.getIntrinsic(IID, { Ty, Ops[0]->getType() });
Res = CGF.Builder.CreateCall(F, { Ops[0], Ops[3] });
} else {
Res = IsSigned ? CGF.Builder.CreateSIToFP(Ops[0], Ty)
: CGF.Builder.CreateUIToFP(Ops[0], Ty);
}
return EmitX86Select(CGF, Ops[2], Res, Ops[1]);
}
// Lowers X86 FMA intrinsics to IR.
static Value *EmitX86FMAExpr(CodeGenFunction &CGF, ArrayRef<Value *> Ops,
unsigned BuiltinID, bool IsAddSub) {
bool Subtract = false;
Intrinsic::ID IID = Intrinsic::not_intrinsic;
switch (BuiltinID) {
default: break;
case clang::X86::BI__builtin_ia32_vfmsubps512_mask3:
Subtract = true;
LLVM_FALLTHROUGH;
case clang::X86::BI__builtin_ia32_vfmaddps512_mask:
case clang::X86::BI__builtin_ia32_vfmaddps512_maskz:
case clang::X86::BI__builtin_ia32_vfmaddps512_mask3:
IID = llvm::Intrinsic::x86_avx512_vfmadd_ps_512; break;
case clang::X86::BI__builtin_ia32_vfmsubpd512_mask3:
Subtract = true;
LLVM_FALLTHROUGH;
case clang::X86::BI__builtin_ia32_vfmaddpd512_mask:
case clang::X86::BI__builtin_ia32_vfmaddpd512_maskz:
case clang::X86::BI__builtin_ia32_vfmaddpd512_mask3:
IID = llvm::Intrinsic::x86_avx512_vfmadd_pd_512; break;
case clang::X86::BI__builtin_ia32_vfmsubaddps512_mask3:
Subtract = true;
LLVM_FALLTHROUGH;
case clang::X86::BI__builtin_ia32_vfmaddsubps512_mask:
case clang::X86::BI__builtin_ia32_vfmaddsubps512_maskz:
case clang::X86::BI__builtin_ia32_vfmaddsubps512_mask3:
IID = llvm::Intrinsic::x86_avx512_vfmaddsub_ps_512;
break;
case clang::X86::BI__builtin_ia32_vfmsubaddpd512_mask3:
Subtract = true;
LLVM_FALLTHROUGH;
case clang::X86::BI__builtin_ia32_vfmaddsubpd512_mask:
case clang::X86::BI__builtin_ia32_vfmaddsubpd512_maskz:
case clang::X86::BI__builtin_ia32_vfmaddsubpd512_mask3:
IID = llvm::Intrinsic::x86_avx512_vfmaddsub_pd_512;
break;
}
Value *A = Ops[0];
Value *B = Ops[1];
Value *C = Ops[2];
if (Subtract)
C = CGF.Builder.CreateFNeg(C);
Value *Res;
// Only handle in case of _MM_FROUND_CUR_DIRECTION/4 (no rounding).
if (IID != Intrinsic::not_intrinsic &&
(cast<llvm::ConstantInt>(Ops.back())->getZExtValue() != (uint64_t)4 ||
IsAddSub)) {
Function *Intr = CGF.CGM.getIntrinsic(IID);
Res = CGF.Builder.CreateCall(Intr, {A, B, C, Ops.back() });
} else {
llvm::Type *Ty = A->getType();
Function *FMA;
if (CGF.Builder.getIsFPConstrained()) {
FMA = CGF.CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, Ty);
Res = CGF.Builder.CreateConstrainedFPCall(FMA, {A, B, C});
} else {
FMA = CGF.CGM.getIntrinsic(Intrinsic::fma, Ty);
Res = CGF.Builder.CreateCall(FMA, {A, B, C});
}
}
// Handle any required masking.
Value *MaskFalseVal = nullptr;
switch (BuiltinID) {
case clang::X86::BI__builtin_ia32_vfmaddps512_mask:
case clang::X86::BI__builtin_ia32_vfmaddpd512_mask:
case clang::X86::BI__builtin_ia32_vfmaddsubps512_mask:
case clang::X86::BI__builtin_ia32_vfmaddsubpd512_mask:
MaskFalseVal = Ops[0];
break;
case clang::X86::BI__builtin_ia32_vfmaddps512_maskz:
case clang::X86::BI__builtin_ia32_vfmaddpd512_maskz:
case clang::X86::BI__builtin_ia32_vfmaddsubps512_maskz:
case clang::X86::BI__builtin_ia32_vfmaddsubpd512_maskz:
MaskFalseVal = Constant::getNullValue(Ops[0]->getType());
break;
case clang::X86::BI__builtin_ia32_vfmsubps512_mask3:
case clang::X86::BI__builtin_ia32_vfmaddps512_mask3:
case clang::X86::BI__builtin_ia32_vfmsubpd512_mask3:
case clang::X86::BI__builtin_ia32_vfmaddpd512_mask3:
case clang::X86::BI__builtin_ia32_vfmsubaddps512_mask3:
case clang::X86::BI__builtin_ia32_vfmaddsubps512_mask3:
case clang::X86::BI__builtin_ia32_vfmsubaddpd512_mask3:
case clang::X86::BI__builtin_ia32_vfmaddsubpd512_mask3:
MaskFalseVal = Ops[2];
break;
}
if (MaskFalseVal)
return EmitX86Select(CGF, Ops[3], Res, MaskFalseVal);
return Res;
}
static Value *
EmitScalarFMAExpr(CodeGenFunction &CGF, MutableArrayRef<Value *> Ops,
Value *Upper, bool ZeroMask = false, unsigned PTIdx = 0,
bool NegAcc = false) {
unsigned Rnd = 4;
if (Ops.size() > 4)
Rnd = cast<llvm::ConstantInt>(Ops[4])->getZExtValue();
if (NegAcc)
Ops[2] = CGF.Builder.CreateFNeg(Ops[2]);
Ops[0] = CGF.Builder.CreateExtractElement(Ops[0], (uint64_t)0);
Ops[1] = CGF.Builder.CreateExtractElement(Ops[1], (uint64_t)0);
Ops[2] = CGF.Builder.CreateExtractElement(Ops[2], (uint64_t)0);
Value *Res;
if (Rnd != 4) {
Intrinsic::ID IID = Ops[0]->getType()->getPrimitiveSizeInBits() == 32 ?
Intrinsic::x86_avx512_vfmadd_f32 :
Intrinsic::x86_avx512_vfmadd_f64;
Res = CGF.Builder.CreateCall(CGF.CGM.getIntrinsic(IID),
{Ops[0], Ops[1], Ops[2], Ops[4]});
} else if (CGF.Builder.getIsFPConstrained()) {
Function *FMA = CGF.CGM.getIntrinsic(
Intrinsic::experimental_constrained_fma, Ops[0]->getType());
Res = CGF.Builder.CreateConstrainedFPCall(FMA, Ops.slice(0, 3));
} else {
Function *FMA = CGF.CGM.getIntrinsic(Intrinsic::fma, Ops[0]->getType());
Res = CGF.Builder.CreateCall(FMA, Ops.slice(0, 3));
}
// If we have more than 3 arguments, we need to do masking.
if (Ops.size() > 3) {
Value *PassThru = ZeroMask ? Constant::getNullValue(Res->getType())
: Ops[PTIdx];
// If we negated the accumulator and the its the PassThru value we need to
// bypass the negate. Conveniently Upper should be the same thing in this
// case.
if (NegAcc && PTIdx == 2)
PassThru = CGF.Builder.CreateExtractElement(Upper, (uint64_t)0);
Res = EmitX86ScalarSelect(CGF, Ops[3], Res, PassThru);
}
return CGF.Builder.CreateInsertElement(Upper, Res, (uint64_t)0);
}
static Value *EmitX86Muldq(CodeGenFunction &CGF, bool IsSigned,
ArrayRef<Value *> Ops) {
llvm::Type *Ty = Ops[0]->getType();
// Arguments have a vXi32 type so cast to vXi64.
Ty = llvm::FixedVectorType::get(CGF.Int64Ty,
Ty->getPrimitiveSizeInBits() / 64);
Value *LHS = CGF.Builder.CreateBitCast(Ops[0], Ty);
Value *RHS = CGF.Builder.CreateBitCast(Ops[1], Ty);
if (IsSigned) {
// Shift left then arithmetic shift right.
Constant *ShiftAmt = ConstantInt::get(Ty, 32);
LHS = CGF.Builder.CreateShl(LHS, ShiftAmt);
LHS = CGF.Builder.CreateAShr(LHS, ShiftAmt);
RHS = CGF.Builder.CreateShl(RHS, ShiftAmt);
RHS = CGF.Builder.CreateAShr(RHS, ShiftAmt);
} else {
// Clear the upper bits.
Constant *Mask = ConstantInt::get(Ty, 0xffffffff);
LHS = CGF.Builder.CreateAnd(LHS, Mask);
RHS = CGF.Builder.CreateAnd(RHS, Mask);
}
return CGF.Builder.CreateMul(LHS, RHS);
}
// Emit a masked pternlog intrinsic. This only exists because the header has to
// use a macro and we aren't able to pass the input argument to a pternlog
// builtin and a select builtin without evaluating it twice.
static Value *EmitX86Ternlog(CodeGenFunction &CGF, bool ZeroMask,
ArrayRef<Value *> Ops) {
llvm::Type *Ty = Ops[0]->getType();
unsigned VecWidth = Ty->getPrimitiveSizeInBits();
unsigned EltWidth = Ty->getScalarSizeInBits();
Intrinsic::ID IID;
if (VecWidth == 128 && EltWidth == 32)
IID = Intrinsic::x86_avx512_pternlog_d_128;
else if (VecWidth == 256 && EltWidth == 32)
IID = Intrinsic::x86_avx512_pternlog_d_256;
else if (VecWidth == 512 && EltWidth == 32)
IID = Intrinsic::x86_avx512_pternlog_d_512;
else if (VecWidth == 128 && EltWidth == 64)
IID = Intrinsic::x86_avx512_pternlog_q_128;
else if (VecWidth == 256 && EltWidth == 64)
IID = Intrinsic::x86_avx512_pternlog_q_256;
else if (VecWidth == 512 && EltWidth == 64)
IID = Intrinsic::x86_avx512_pternlog_q_512;
else
llvm_unreachable("Unexpected intrinsic");
Value *Ternlog = CGF.Builder.CreateCall(CGF.CGM.getIntrinsic(IID),
Ops.drop_back());
Value *PassThru = ZeroMask ? ConstantAggregateZero::get(Ty) : Ops[0];
return EmitX86Select(CGF, Ops[4], Ternlog, PassThru);
}
static Value *EmitX86SExtMask(CodeGenFunction &CGF, Value *Op,
llvm::Type *DstTy) {
unsigned NumberOfElements =
cast<llvm::FixedVectorType>(DstTy)->getNumElements();
Value *Mask = getMaskVecValue(CGF, Op, NumberOfElements);
return CGF.Builder.CreateSExt(Mask, DstTy, "vpmovm2");
}
// Emit binary intrinsic with the same type used in result/args.
static Value *EmitX86BinaryIntrinsic(CodeGenFunction &CGF,
ArrayRef<Value *> Ops, Intrinsic::ID IID) {
llvm::Function *F = CGF.CGM.getIntrinsic(IID, Ops[0]->getType());
return CGF.Builder.CreateCall(F, {Ops[0], Ops[1]});
}
Value *CodeGenFunction::EmitX86CpuIs(const CallExpr *E) {
const Expr *CPUExpr = E->getArg(0)->IgnoreParenCasts();
StringRef CPUStr = cast<clang::StringLiteral>(CPUExpr)->getString();
return EmitX86CpuIs(CPUStr);
}
// Convert F16 halfs to floats.
static Value *EmitX86CvtF16ToFloatExpr(CodeGenFunction &CGF,
ArrayRef<Value *> Ops,
llvm::Type *DstTy) {
assert((Ops.size() == 1 || Ops.size() == 3 || Ops.size() == 4) &&
"Unknown cvtph2ps intrinsic");
// If the SAE intrinsic doesn't use default rounding then we can't upgrade.
if (Ops.size() == 4 && cast<llvm::ConstantInt>(Ops[3])->getZExtValue() != 4) {
Function *F =
CGF.CGM.getIntrinsic(Intrinsic::x86_avx512_mask_vcvtph2ps_512);
return CGF.Builder.CreateCall(F, {Ops[0], Ops[1], Ops[2], Ops[3]});
}
unsigned NumDstElts = cast<llvm::FixedVectorType>(DstTy)->getNumElements();
Value *Src = Ops[0];
// Extract the subvector.
if (NumDstElts !=
cast<llvm::FixedVectorType>(Src->getType())->getNumElements()) {
assert(NumDstElts == 4 && "Unexpected vector size");
Src = CGF.Builder.CreateShuffleVector(Src, ArrayRef<int>{0, 1, 2, 3});
}
// Bitcast from vXi16 to vXf16.
auto *HalfTy = llvm::FixedVectorType::get(
llvm::Type::getHalfTy(CGF.getLLVMContext()), NumDstElts);
Src = CGF.Builder.CreateBitCast(Src, HalfTy);
// Perform the fp-extension.
Value *Res = CGF.Builder.CreateFPExt(Src, DstTy, "cvtph2ps");
if (Ops.size() >= 3)
Res = EmitX86Select(CGF, Ops[2], Res, Ops[1]);
return Res;
}
// Convert a BF16 to a float.
static Value *EmitX86CvtBF16ToFloatExpr(CodeGenFunction &CGF,
const CallExpr *E,
ArrayRef<Value *> Ops) {
llvm::Type *Int32Ty = CGF.Builder.getInt32Ty();
Value *ZeroExt = CGF.Builder.CreateZExt(Ops[0], Int32Ty);
Value *Shl = CGF.Builder.CreateShl(ZeroExt, 16);
llvm::Type *ResultType = CGF.ConvertType(E->getType());
Value *BitCast = CGF.Builder.CreateBitCast(Shl, ResultType);
return BitCast;
}
Value *CodeGenFunction::EmitX86CpuIs(StringRef CPUStr) {
llvm::Type *Int32Ty = Builder.getInt32Ty();
// Matching the struct layout from the compiler-rt/libgcc structure that is
// filled in:
// unsigned int __cpu_vendor;
// unsigned int __cpu_type;
// unsigned int __cpu_subtype;
// unsigned int __cpu_features[1];
llvm::Type *STy = llvm::StructType::get(Int32Ty, Int32Ty, Int32Ty,
llvm::ArrayType::get(Int32Ty, 1));
// Grab the global __cpu_model.
llvm::Constant *CpuModel = CGM.CreateRuntimeVariable(STy, "__cpu_model");
cast<llvm::GlobalValue>(CpuModel)->setDSOLocal(true);
// Calculate the index needed to access the correct field based on the
// range. Also adjust the expected value.
unsigned Index;
unsigned Value;
std::tie(Index, Value) = StringSwitch<std::pair<unsigned, unsigned>>(CPUStr)
#define X86_VENDOR(ENUM, STRING) \
.Case(STRING, {0u, static_cast<unsigned>(llvm::X86::ENUM)})
#define X86_CPU_TYPE_ALIAS(ENUM, ALIAS) \
.Case(ALIAS, {1u, static_cast<unsigned>(llvm::X86::ENUM)})
#define X86_CPU_TYPE(ENUM, STR) \
.Case(STR, {1u, static_cast<unsigned>(llvm::X86::ENUM)})
#define X86_CPU_SUBTYPE(ENUM, STR) \
.Case(STR, {2u, static_cast<unsigned>(llvm::X86::ENUM)})
#include "llvm/Support/X86TargetParser.def"
.Default({0, 0});
assert(Value != 0 && "Invalid CPUStr passed to CpuIs");
// Grab the appropriate field from __cpu_model.
llvm::Value *Idxs[] = {ConstantInt::get(Int32Ty, 0),
ConstantInt::get(Int32Ty, Index)};
llvm::Value *CpuValue = Builder.CreateGEP(STy, CpuModel, Idxs);
CpuValue = Builder.CreateAlignedLoad(CpuValue, CharUnits::fromQuantity(4));
// Check the value of the field against the requested value.
return Builder.CreateICmpEQ(CpuValue,
llvm::ConstantInt::get(Int32Ty, Value));
}
Value *CodeGenFunction::EmitX86CpuSupports(const CallExpr *E) {
const Expr *FeatureExpr = E->getArg(0)->IgnoreParenCasts();
StringRef FeatureStr = cast<StringLiteral>(FeatureExpr)->getString();
return EmitX86CpuSupports(FeatureStr);
}
uint64_t
CodeGenFunction::GetX86CpuSupportsMask(ArrayRef<StringRef> FeatureStrs) {
// Processor features and mapping to processor feature value.
uint64_t FeaturesMask = 0;
for (const StringRef &FeatureStr : FeatureStrs) {
unsigned Feature =
StringSwitch<unsigned>(FeatureStr)
#define X86_FEATURE_COMPAT(ENUM, STR) .Case(STR, llvm::X86::FEATURE_##ENUM)
#include "llvm/Support/X86TargetParser.def"
;
FeaturesMask |= (1ULL << Feature);
}
return FeaturesMask;
}
Value *CodeGenFunction::EmitX86CpuSupports(ArrayRef<StringRef> FeatureStrs) {
return EmitX86CpuSupports(GetX86CpuSupportsMask(FeatureStrs));
}
llvm::Value *CodeGenFunction::EmitX86CpuSupports(uint64_t FeaturesMask) {
uint32_t Features1 = Lo_32(FeaturesMask);
uint32_t Features2 = Hi_32(FeaturesMask);
Value *Result = Builder.getTrue();
if (Features1 != 0) {
// Matching the struct layout from the compiler-rt/libgcc structure that is
// filled in:
// unsigned int __cpu_vendor;
// unsigned int __cpu_type;
// unsigned int __cpu_subtype;
// unsigned int __cpu_features[1];
llvm::Type *STy = llvm::StructType::get(Int32Ty, Int32Ty, Int32Ty,
llvm::ArrayType::get(Int32Ty, 1));
// Grab the global __cpu_model.
llvm::Constant *CpuModel = CGM.CreateRuntimeVariable(STy, "__cpu_model");
cast<llvm::GlobalValue>(CpuModel)->setDSOLocal(true);
// Grab the first (0th) element from the field __cpu_features off of the
// global in the struct STy.
Value *Idxs[] = {Builder.getInt32(0), Builder.getInt32(3),
Builder.getInt32(0)};
Value *CpuFeatures = Builder.CreateGEP(STy, CpuModel, Idxs);
Value *Features =
Builder.CreateAlignedLoad(CpuFeatures, CharUnits::fromQuantity(4));
// Check the value of the bit corresponding to the feature requested.
Value *Mask = Builder.getInt32(Features1);
Value *Bitset = Builder.CreateAnd(Features, Mask);
Value *Cmp = Builder.CreateICmpEQ(Bitset, Mask);
Result = Builder.CreateAnd(Result, Cmp);
}
if (Features2 != 0) {
llvm::Constant *CpuFeatures2 = CGM.CreateRuntimeVariable(Int32Ty,
"__cpu_features2");
cast<llvm::GlobalValue>(CpuFeatures2)->setDSOLocal(true);
Value *Features =
Builder.CreateAlignedLoad(CpuFeatures2, CharUnits::fromQuantity(4));
// Check the value of the bit corresponding to the feature requested.
Value *Mask = Builder.getInt32(Features2);
Value *Bitset = Builder.CreateAnd(Features, Mask);
Value *Cmp = Builder.CreateICmpEQ(Bitset, Mask);
Result = Builder.CreateAnd(Result, Cmp);
}
return Result;
}
Value *CodeGenFunction::EmitX86CpuInit() {
llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy,
/*Variadic*/ false);
llvm::FunctionCallee Func =
CGM.CreateRuntimeFunction(FTy, "__cpu_indicator_init");
cast<llvm::GlobalValue>(Func.getCallee())->setDSOLocal(true);
cast<llvm::GlobalValue>(Func.getCallee())
->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
return Builder.CreateCall(Func);
}
Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
const CallExpr *E) {
if (BuiltinID == X86::BI__builtin_cpu_is)
return EmitX86CpuIs(E);
if (BuiltinID == X86::BI__builtin_cpu_supports)
return EmitX86CpuSupports(E);
if (BuiltinID == X86::BI__builtin_cpu_init)
return EmitX86CpuInit();
// Handle MSVC intrinsics before argument evaluation to prevent double
// evaluation.
if (Optional<MSVCIntrin> MsvcIntId = translateX86ToMsvcIntrin(BuiltinID))
return EmitMSVCBuiltinExpr(*MsvcIntId, E);
SmallVector<Value*, 4> Ops;
bool IsMaskFCmp = false;
// Find out if any arguments are required to be integer constant expressions.
unsigned ICEArguments = 0;
ASTContext::GetBuiltinTypeError Error;
getContext().GetBuiltinType(BuiltinID, Error, &ICEArguments);
assert(Error == ASTContext::GE_None && "Should not codegen an error");
for (unsigned i = 0, e = E->getNumArgs(); i != e; i++) {
// If this is a normal argument, just emit it as a scalar.
if ((ICEArguments & (1 << i)) == 0) {
Ops.push_back(EmitScalarExpr(E->getArg(i)));
continue;
}
// If this is required to be a constant, constant fold it so that we know
// that the generated intrinsic gets a ConstantInt.
Ops.push_back(llvm::ConstantInt::get(
getLLVMContext(), *E->getArg(i)->getIntegerConstantExpr(getContext())));
}
// These exist so that the builtin that takes an immediate can be bounds
// checked by clang to avoid passing bad immediates to the backend. Since
// AVX has a larger immediate than SSE we would need separate builtins to
// do the different bounds checking. Rather than create a clang specific
// SSE only builtin, this implements eight separate builtins to match gcc
// implementation.
auto getCmpIntrinsicCall = [this, &Ops](Intrinsic::ID ID, unsigned Imm) {
Ops.push_back(llvm::ConstantInt::get(Int8Ty, Imm));
llvm::Function *F = CGM.getIntrinsic(ID);
return Builder.CreateCall(F, Ops);
};
// For the vector forms of FP comparisons, translate the builtins directly to
// IR.
// TODO: The builtins could be removed if the SSE header files used vector
// extension comparisons directly (vector ordered/unordered may need
// additional support via __builtin_isnan()).
auto getVectorFCmpIR = [this, &Ops](CmpInst::Predicate Pred,
bool IsSignaling) {
Value *Cmp;
if (IsSignaling)
Cmp = Builder.CreateFCmpS(Pred, Ops[0], Ops[1]);
else
Cmp = Builder.CreateFCmp(Pred, Ops[0], Ops[1]);
llvm::VectorType *FPVecTy = cast<llvm::VectorType>(Ops[0]->getType());
llvm::VectorType *IntVecTy = llvm::VectorType::getInteger(FPVecTy);
Value *Sext = Builder.CreateSExt(Cmp, IntVecTy);
return Builder.CreateBitCast(Sext, FPVecTy);
};
switch (BuiltinID) {
default: return nullptr;
case X86::BI_mm_prefetch: {
Value *Address = Ops[0];
ConstantInt *C = cast<ConstantInt>(Ops[1]);
Value *RW = ConstantInt::get(Int32Ty, (C->getZExtValue() >> 2) & 0x1);
Value *Locality = ConstantInt::get(Int32Ty, C->getZExtValue() & 0x3);
Value *Data = ConstantInt::get(Int32Ty, 1);
Function *F = CGM.getIntrinsic(Intrinsic::prefetch, Address->getType());
return Builder.CreateCall(F, {Address, RW, Locality, Data});
}
case X86::BI_mm_clflush: {
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse2_clflush),
Ops[0]);
}
case X86::BI_mm_lfence: {
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse2_lfence));
}
case X86::BI_mm_mfence: {
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse2_mfence));
}
case X86::BI_mm_sfence: {
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_sfence));
}
case X86::BI_mm_pause: {
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse2_pause));
}
case X86::BI__rdtsc: {
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_rdtsc));
}
case X86::BI__builtin_ia32_rdtscp: {
Value *Call = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_rdtscp));
Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 1),
Ops[0]);
return Builder.CreateExtractValue(Call, 0);
}
case X86::BI__builtin_ia32_lzcnt_u16:
case X86::BI__builtin_ia32_lzcnt_u32:
case X86::BI__builtin_ia32_lzcnt_u64: {
Function *F = CGM.getIntrinsic(Intrinsic::ctlz, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0], Builder.getInt1(false)});
}
case X86::BI__builtin_ia32_tzcnt_u16:
case X86::BI__builtin_ia32_tzcnt_u32:
case X86::BI__builtin_ia32_tzcnt_u64: {
Function *F = CGM.getIntrinsic(Intrinsic::cttz, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0], Builder.getInt1(false)});
}
case X86::BI__builtin_ia32_undef128:
case X86::BI__builtin_ia32_undef256:
case X86::BI__builtin_ia32_undef512:
// The x86 definition of "undef" is not the same as the LLVM definition
// (PR32176). We leave optimizing away an unnecessary zero constant to the
// IR optimizer and backend.
// TODO: If we had a "freeze" IR instruction to generate a fixed undef
// value, we should use that here instead of a zero.
return llvm::Constant::getNullValue(ConvertType(E->getType()));
case X86::BI__builtin_ia32_vec_init_v8qi:
case X86::BI__builtin_ia32_vec_init_v4hi:
case X86::BI__builtin_ia32_vec_init_v2si:
return Builder.CreateBitCast(BuildVector(Ops),
llvm::Type::getX86_MMXTy(getLLVMContext()));
case X86::BI__builtin_ia32_vec_ext_v2si:
case X86::BI__builtin_ia32_vec_ext_v16qi:
case X86::BI__builtin_ia32_vec_ext_v8hi:
case X86::BI__builtin_ia32_vec_ext_v4si:
case X86::BI__builtin_ia32_vec_ext_v4sf:
case X86::BI__builtin_ia32_vec_ext_v2di:
case X86::BI__builtin_ia32_vec_ext_v32qi:
case X86::BI__builtin_ia32_vec_ext_v16hi:
case X86::BI__builtin_ia32_vec_ext_v8si:
case X86::BI__builtin_ia32_vec_ext_v4di: {
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
uint64_t Index = cast<ConstantInt>(Ops[1])->getZExtValue();
Index &= NumElts - 1;
// These builtins exist so we can ensure the index is an ICE and in range.
// Otherwise we could just do this in the header file.
return Builder.CreateExtractElement(Ops[0], Index);
}
case X86::BI__builtin_ia32_vec_set_v16qi:
case X86::BI__builtin_ia32_vec_set_v8hi:
case X86::BI__builtin_ia32_vec_set_v4si:
case X86::BI__builtin_ia32_vec_set_v2di:
case X86::BI__builtin_ia32_vec_set_v32qi:
case X86::BI__builtin_ia32_vec_set_v16hi:
case X86::BI__builtin_ia32_vec_set_v8si:
case X86::BI__builtin_ia32_vec_set_v4di: {
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
unsigned Index = cast<ConstantInt>(Ops[2])->getZExtValue();
Index &= NumElts - 1;
// These builtins exist so we can ensure the index is an ICE and in range.
// Otherwise we could just do this in the header file.
return Builder.CreateInsertElement(Ops[0], Ops[1], Index);
}
case X86::BI_mm_setcsr:
case X86::BI__builtin_ia32_ldmxcsr: {
Address Tmp = CreateMemTemp(E->getArg(0)->getType());
Builder.CreateStore(Ops[0], Tmp);
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
Builder.CreateBitCast(Tmp.getPointer(), Int8PtrTy));
}
case X86::BI_mm_getcsr:
case X86::BI__builtin_ia32_stmxcsr: {
Address Tmp = CreateMemTemp(E->getType());
Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
Builder.CreateBitCast(Tmp.getPointer(), Int8PtrTy));
return Builder.CreateLoad(Tmp, "stmxcsr");
}
case X86::BI__builtin_ia32_xsave:
case X86::BI__builtin_ia32_xsave64:
case X86::BI__builtin_ia32_xrstor:
case X86::BI__builtin_ia32_xrstor64:
case X86::BI__builtin_ia32_xsaveopt:
case X86::BI__builtin_ia32_xsaveopt64:
case X86::BI__builtin_ia32_xrstors:
case X86::BI__builtin_ia32_xrstors64:
case X86::BI__builtin_ia32_xsavec:
case X86::BI__builtin_ia32_xsavec64:
case X86::BI__builtin_ia32_xsaves:
case X86::BI__builtin_ia32_xsaves64:
case X86::BI__builtin_ia32_xsetbv:
case X86::BI_xsetbv: {
Intrinsic::ID ID;
#define INTRINSIC_X86_XSAVE_ID(NAME) \
case X86::BI__builtin_ia32_##NAME: \
ID = Intrinsic::x86_##NAME; \
break
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
INTRINSIC_X86_XSAVE_ID(xsave);
INTRINSIC_X86_XSAVE_ID(xsave64);
INTRINSIC_X86_XSAVE_ID(xrstor);
INTRINSIC_X86_XSAVE_ID(xrstor64);
INTRINSIC_X86_XSAVE_ID(xsaveopt);
INTRINSIC_X86_XSAVE_ID(xsaveopt64);
INTRINSIC_X86_XSAVE_ID(xrstors);
INTRINSIC_X86_XSAVE_ID(xrstors64);
INTRINSIC_X86_XSAVE_ID(xsavec);
INTRINSIC_X86_XSAVE_ID(xsavec64);
INTRINSIC_X86_XSAVE_ID(xsaves);
INTRINSIC_X86_XSAVE_ID(xsaves64);
INTRINSIC_X86_XSAVE_ID(xsetbv);
case X86::BI_xsetbv:
ID = Intrinsic::x86_xsetbv;
break;
}
#undef INTRINSIC_X86_XSAVE_ID
Value *Mhi = Builder.CreateTrunc(
Builder.CreateLShr(Ops[1], ConstantInt::get(Int64Ty, 32)), Int32Ty);
Value *Mlo = Builder.CreateTrunc(Ops[1], Int32Ty);
Ops[1] = Mhi;
Ops.push_back(Mlo);
return Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
}
case X86::BI__builtin_ia32_xgetbv:
case X86::BI_xgetbv:
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_xgetbv), Ops);
case X86::BI__builtin_ia32_storedqudi128_mask:
case X86::BI__builtin_ia32_storedqusi128_mask:
case X86::BI__builtin_ia32_storedquhi128_mask:
case X86::BI__builtin_ia32_storedquqi128_mask:
case X86::BI__builtin_ia32_storeupd128_mask:
case X86::BI__builtin_ia32_storeups128_mask:
case X86::BI__builtin_ia32_storedqudi256_mask:
case X86::BI__builtin_ia32_storedqusi256_mask:
case X86::BI__builtin_ia32_storedquhi256_mask:
case X86::BI__builtin_ia32_storedquqi256_mask:
case X86::BI__builtin_ia32_storeupd256_mask:
case X86::BI__builtin_ia32_storeups256_mask:
case X86::BI__builtin_ia32_storedqudi512_mask:
case X86::BI__builtin_ia32_storedqusi512_mask:
case X86::BI__builtin_ia32_storedquhi512_mask:
case X86::BI__builtin_ia32_storedquqi512_mask:
case X86::BI__builtin_ia32_storeupd512_mask:
case X86::BI__builtin_ia32_storeups512_mask:
return EmitX86MaskedStore(*this, Ops, Align(1));
case X86::BI__builtin_ia32_storess128_mask:
case X86::BI__builtin_ia32_storesd128_mask:
return EmitX86MaskedStore(*this, Ops, Align(1));
case X86::BI__builtin_ia32_vpopcntb_128:
case X86::BI__builtin_ia32_vpopcntd_128:
case X86::BI__builtin_ia32_vpopcntq_128:
case X86::BI__builtin_ia32_vpopcntw_128:
case X86::BI__builtin_ia32_vpopcntb_256:
case X86::BI__builtin_ia32_vpopcntd_256:
case X86::BI__builtin_ia32_vpopcntq_256:
case X86::BI__builtin_ia32_vpopcntw_256:
case X86::BI__builtin_ia32_vpopcntb_512:
case X86::BI__builtin_ia32_vpopcntd_512:
case X86::BI__builtin_ia32_vpopcntq_512:
case X86::BI__builtin_ia32_vpopcntw_512: {
llvm::Type *ResultType = ConvertType(E->getType());
llvm::Function *F = CGM.getIntrinsic(Intrinsic::ctpop, ResultType);
return Builder.CreateCall(F, Ops);
}
case X86::BI__builtin_ia32_cvtmask2b128:
case X86::BI__builtin_ia32_cvtmask2b256:
case X86::BI__builtin_ia32_cvtmask2b512:
case X86::BI__builtin_ia32_cvtmask2w128:
case X86::BI__builtin_ia32_cvtmask2w256:
case X86::BI__builtin_ia32_cvtmask2w512:
case X86::BI__builtin_ia32_cvtmask2d128:
case X86::BI__builtin_ia32_cvtmask2d256:
case X86::BI__builtin_ia32_cvtmask2d512:
case X86::BI__builtin_ia32_cvtmask2q128:
case X86::BI__builtin_ia32_cvtmask2q256:
case X86::BI__builtin_ia32_cvtmask2q512:
return EmitX86SExtMask(*this, Ops[0], ConvertType(E->getType()));
case X86::BI__builtin_ia32_cvtb2mask128:
case X86::BI__builtin_ia32_cvtb2mask256:
case X86::BI__builtin_ia32_cvtb2mask512:
case X86::BI__builtin_ia32_cvtw2mask128:
case X86::BI__builtin_ia32_cvtw2mask256:
case X86::BI__builtin_ia32_cvtw2mask512:
case X86::BI__builtin_ia32_cvtd2mask128:
case X86::BI__builtin_ia32_cvtd2mask256:
case X86::BI__builtin_ia32_cvtd2mask512:
case X86::BI__builtin_ia32_cvtq2mask128:
case X86::BI__builtin_ia32_cvtq2mask256:
case X86::BI__builtin_ia32_cvtq2mask512:
return EmitX86ConvertToMask(*this, Ops[0]);
case X86::BI__builtin_ia32_cvtdq2ps512_mask:
case X86::BI__builtin_ia32_cvtqq2ps512_mask:
case X86::BI__builtin_ia32_cvtqq2pd512_mask:
return EmitX86ConvertIntToFp(*this, Ops, /*IsSigned*/true);
case X86::BI__builtin_ia32_cvtudq2ps512_mask:
case X86::BI__builtin_ia32_cvtuqq2ps512_mask:
case X86::BI__builtin_ia32_cvtuqq2pd512_mask:
return EmitX86ConvertIntToFp(*this, Ops, /*IsSigned*/false);
case X86::BI__builtin_ia32_vfmaddss3:
case X86::BI__builtin_ia32_vfmaddsd3:
case X86::BI__builtin_ia32_vfmaddss3_mask:
case X86::BI__builtin_ia32_vfmaddsd3_mask:
return EmitScalarFMAExpr(*this, Ops, Ops[0]);
case X86::BI__builtin_ia32_vfmaddss:
case X86::BI__builtin_ia32_vfmaddsd:
return EmitScalarFMAExpr(*this, Ops,
Constant::getNullValue(Ops[0]->getType()));
case X86::BI__builtin_ia32_vfmaddss3_maskz:
case X86::BI__builtin_ia32_vfmaddsd3_maskz:
return EmitScalarFMAExpr(*this, Ops, Ops[0], /*ZeroMask*/true);
case X86::BI__builtin_ia32_vfmaddss3_mask3:
case X86::BI__builtin_ia32_vfmaddsd3_mask3:
return EmitScalarFMAExpr(*this, Ops, Ops[2], /*ZeroMask*/false, 2);
case X86::BI__builtin_ia32_vfmsubss3_mask3:
case X86::BI__builtin_ia32_vfmsubsd3_mask3:
return EmitScalarFMAExpr(*this, Ops, Ops[2], /*ZeroMask*/false, 2,
/*NegAcc*/true);
case X86::BI__builtin_ia32_vfmaddps:
case X86::BI__builtin_ia32_vfmaddpd:
case X86::BI__builtin_ia32_vfmaddps256:
case X86::BI__builtin_ia32_vfmaddpd256:
case X86::BI__builtin_ia32_vfmaddps512_mask:
case X86::BI__builtin_ia32_vfmaddps512_maskz:
case X86::BI__builtin_ia32_vfmaddps512_mask3:
case X86::BI__builtin_ia32_vfmsubps512_mask3:
case X86::BI__builtin_ia32_vfmaddpd512_mask:
case X86::BI__builtin_ia32_vfmaddpd512_maskz:
case X86::BI__builtin_ia32_vfmaddpd512_mask3:
case X86::BI__builtin_ia32_vfmsubpd512_mask3:
return EmitX86FMAExpr(*this, Ops, BuiltinID, /*IsAddSub*/false);
case X86::BI__builtin_ia32_vfmaddsubps512_mask:
case X86::BI__builtin_ia32_vfmaddsubps512_maskz:
case X86::BI__builtin_ia32_vfmaddsubps512_mask3:
case X86::BI__builtin_ia32_vfmsubaddps512_mask3:
case X86::BI__builtin_ia32_vfmaddsubpd512_mask:
case X86::BI__builtin_ia32_vfmaddsubpd512_maskz:
case X86::BI__builtin_ia32_vfmaddsubpd512_mask3:
case X86::BI__builtin_ia32_vfmsubaddpd512_mask3:
return EmitX86FMAExpr(*this, Ops, BuiltinID, /*IsAddSub*/true);
case X86::BI__builtin_ia32_movdqa32store128_mask:
case X86::BI__builtin_ia32_movdqa64store128_mask:
case X86::BI__builtin_ia32_storeaps128_mask:
case X86::BI__builtin_ia32_storeapd128_mask:
case X86::BI__builtin_ia32_movdqa32store256_mask:
case X86::BI__builtin_ia32_movdqa64store256_mask:
case X86::BI__builtin_ia32_storeaps256_mask:
case X86::BI__builtin_ia32_storeapd256_mask:
case X86::BI__builtin_ia32_movdqa32store512_mask:
case X86::BI__builtin_ia32_movdqa64store512_mask:
case X86::BI__builtin_ia32_storeaps512_mask:
case X86::BI__builtin_ia32_storeapd512_mask:
return EmitX86MaskedStore(
*this, Ops,
getContext().getTypeAlignInChars(E->getArg(1)->getType()).getAsAlign());
case X86::BI__builtin_ia32_loadups128_mask:
case X86::BI__builtin_ia32_loadups256_mask:
case X86::BI__builtin_ia32_loadups512_mask:
case X86::BI__builtin_ia32_loadupd128_mask:
case X86::BI__builtin_ia32_loadupd256_mask:
case X86::BI__builtin_ia32_loadupd512_mask:
case X86::BI__builtin_ia32_loaddquqi128_mask:
case X86::BI__builtin_ia32_loaddquqi256_mask:
case X86::BI__builtin_ia32_loaddquqi512_mask:
case X86::BI__builtin_ia32_loaddquhi128_mask:
case X86::BI__builtin_ia32_loaddquhi256_mask:
case X86::BI__builtin_ia32_loaddquhi512_mask:
case X86::BI__builtin_ia32_loaddqusi128_mask:
case X86::BI__builtin_ia32_loaddqusi256_mask:
case X86::BI__builtin_ia32_loaddqusi512_mask:
case X86::BI__builtin_ia32_loaddqudi128_mask:
case X86::BI__builtin_ia32_loaddqudi256_mask:
case X86::BI__builtin_ia32_loaddqudi512_mask:
return EmitX86MaskedLoad(*this, Ops, Align(1));
case X86::BI__builtin_ia32_loadss128_mask:
case X86::BI__builtin_ia32_loadsd128_mask:
return EmitX86MaskedLoad(*this, Ops, Align(1));
case X86::BI__builtin_ia32_loadaps128_mask:
case X86::BI__builtin_ia32_loadaps256_mask:
case X86::BI__builtin_ia32_loadaps512_mask:
case X86::BI__builtin_ia32_loadapd128_mask:
case X86::BI__builtin_ia32_loadapd256_mask:
case X86::BI__builtin_ia32_loadapd512_mask:
case X86::BI__builtin_ia32_movdqa32load128_mask:
case X86::BI__builtin_ia32_movdqa32load256_mask:
case X86::BI__builtin_ia32_movdqa32load512_mask:
case X86::BI__builtin_ia32_movdqa64load128_mask:
case X86::BI__builtin_ia32_movdqa64load256_mask:
case X86::BI__builtin_ia32_movdqa64load512_mask:
return EmitX86MaskedLoad(
*this, Ops,
getContext().getTypeAlignInChars(E->getArg(1)->getType()).getAsAlign());
case X86::BI__builtin_ia32_expandloaddf128_mask:
case X86::BI__builtin_ia32_expandloaddf256_mask:
case X86::BI__builtin_ia32_expandloaddf512_mask:
case X86::BI__builtin_ia32_expandloadsf128_mask:
case X86::BI__builtin_ia32_expandloadsf256_mask:
case X86::BI__builtin_ia32_expandloadsf512_mask:
case X86::BI__builtin_ia32_expandloaddi128_mask:
case X86::BI__builtin_ia32_expandloaddi256_mask:
case X86::BI__builtin_ia32_expandloaddi512_mask:
case X86::BI__builtin_ia32_expandloadsi128_mask:
case X86::BI__builtin_ia32_expandloadsi256_mask:
case X86::BI__builtin_ia32_expandloadsi512_mask:
case X86::BI__builtin_ia32_expandloadhi128_mask:
case X86::BI__builtin_ia32_expandloadhi256_mask:
case X86::BI__builtin_ia32_expandloadhi512_mask:
case X86::BI__builtin_ia32_expandloadqi128_mask:
case X86::BI__builtin_ia32_expandloadqi256_mask:
case X86::BI__builtin_ia32_expandloadqi512_mask:
return EmitX86ExpandLoad(*this, Ops);
case X86::BI__builtin_ia32_compressstoredf128_mask:
case X86::BI__builtin_ia32_compressstoredf256_mask:
case X86::BI__builtin_ia32_compressstoredf512_mask:
case X86::BI__builtin_ia32_compressstoresf128_mask:
case X86::BI__builtin_ia32_compressstoresf256_mask:
case X86::BI__builtin_ia32_compressstoresf512_mask:
case X86::BI__builtin_ia32_compressstoredi128_mask:
case X86::BI__builtin_ia32_compressstoredi256_mask:
case X86::BI__builtin_ia32_compressstoredi512_mask:
case X86::BI__builtin_ia32_compressstoresi128_mask:
case X86::BI__builtin_ia32_compressstoresi256_mask:
case X86::BI__builtin_ia32_compressstoresi512_mask:
case X86::BI__builtin_ia32_compressstorehi128_mask:
case X86::BI__builtin_ia32_compressstorehi256_mask:
case X86::BI__builtin_ia32_compressstorehi512_mask:
case X86::BI__builtin_ia32_compressstoreqi128_mask:
case X86::BI__builtin_ia32_compressstoreqi256_mask:
case X86::BI__builtin_ia32_compressstoreqi512_mask:
return EmitX86CompressStore(*this, Ops);
case X86::BI__builtin_ia32_expanddf128_mask:
case X86::BI__builtin_ia32_expanddf256_mask:
case X86::BI__builtin_ia32_expanddf512_mask:
case X86::BI__builtin_ia32_expandsf128_mask:
case X86::BI__builtin_ia32_expandsf256_mask:
case X86::BI__builtin_ia32_expandsf512_mask:
case X86::BI__builtin_ia32_expanddi128_mask:
case X86::BI__builtin_ia32_expanddi256_mask:
case X86::BI__builtin_ia32_expanddi512_mask:
case X86::BI__builtin_ia32_expandsi128_mask:
case X86::BI__builtin_ia32_expandsi256_mask:
case X86::BI__builtin_ia32_expandsi512_mask:
case X86::BI__builtin_ia32_expandhi128_mask:
case X86::BI__builtin_ia32_expandhi256_mask:
case X86::BI__builtin_ia32_expandhi512_mask:
case X86::BI__builtin_ia32_expandqi128_mask:
case X86::BI__builtin_ia32_expandqi256_mask:
case X86::BI__builtin_ia32_expandqi512_mask:
return EmitX86CompressExpand(*this, Ops, /*IsCompress*/false);
case X86::BI__builtin_ia32_compressdf128_mask:
case X86::BI__builtin_ia32_compressdf256_mask:
case X86::BI__builtin_ia32_compressdf512_mask:
case X86::BI__builtin_ia32_compresssf128_mask:
case X86::BI__builtin_ia32_compresssf256_mask:
case X86::BI__builtin_ia32_compresssf512_mask:
case X86::BI__builtin_ia32_compressdi128_mask:
case X86::BI__builtin_ia32_compressdi256_mask:
case X86::BI__builtin_ia32_compressdi512_mask:
case X86::BI__builtin_ia32_compresssi128_mask:
case X86::BI__builtin_ia32_compresssi256_mask:
case X86::BI__builtin_ia32_compresssi512_mask:
case X86::BI__builtin_ia32_compresshi128_mask:
case X86::BI__builtin_ia32_compresshi256_mask:
case X86::BI__builtin_ia32_compresshi512_mask:
case X86::BI__builtin_ia32_compressqi128_mask:
case X86::BI__builtin_ia32_compressqi256_mask:
case X86::BI__builtin_ia32_compressqi512_mask:
return EmitX86CompressExpand(*this, Ops, /*IsCompress*/true);
case X86::BI__builtin_ia32_gather3div2df:
case X86::BI__builtin_ia32_gather3div2di:
case X86::BI__builtin_ia32_gather3div4df:
case X86::BI__builtin_ia32_gather3div4di:
case X86::BI__builtin_ia32_gather3div4sf:
case X86::BI__builtin_ia32_gather3div4si:
case X86::BI__builtin_ia32_gather3div8sf:
case X86::BI__builtin_ia32_gather3div8si:
case X86::BI__builtin_ia32_gather3siv2df:
case X86::BI__builtin_ia32_gather3siv2di:
case X86::BI__builtin_ia32_gather3siv4df:
case X86::BI__builtin_ia32_gather3siv4di:
case X86::BI__builtin_ia32_gather3siv4sf:
case X86::BI__builtin_ia32_gather3siv4si:
case X86::BI__builtin_ia32_gather3siv8sf:
case X86::BI__builtin_ia32_gather3siv8si:
case X86::BI__builtin_ia32_gathersiv8df:
case X86::BI__builtin_ia32_gathersiv16sf:
case X86::BI__builtin_ia32_gatherdiv8df:
case X86::BI__builtin_ia32_gatherdiv16sf:
case X86::BI__builtin_ia32_gathersiv8di:
case X86::BI__builtin_ia32_gathersiv16si:
case X86::BI__builtin_ia32_gatherdiv8di:
case X86::BI__builtin_ia32_gatherdiv16si: {
Intrinsic::ID IID;
switch (BuiltinID) {
default: llvm_unreachable("Unexpected builtin");
case X86::BI__builtin_ia32_gather3div2df:
IID = Intrinsic::x86_avx512_mask_gather3div2_df;
break;
case X86::BI__builtin_ia32_gather3div2di:
IID = Intrinsic::x86_avx512_mask_gather3div2_di;
break;
case X86::BI__builtin_ia32_gather3div4df:
IID = Intrinsic::x86_avx512_mask_gather3div4_df;
break;
case X86::BI__builtin_ia32_gather3div4di:
IID = Intrinsic::x86_avx512_mask_gather3div4_di;
break;
case X86::BI__builtin_ia32_gather3div4sf:
IID = Intrinsic::x86_avx512_mask_gather3div4_sf;
break;
case X86::BI__builtin_ia32_gather3div4si:
IID = Intrinsic::x86_avx512_mask_gather3div4_si;
break;
case X86::BI__builtin_ia32_gather3div8sf:
IID = Intrinsic::x86_avx512_mask_gather3div8_sf;
break;
case X86::BI__builtin_ia32_gather3div8si:
IID = Intrinsic::x86_avx512_mask_gather3div8_si;
break;
case X86::BI__builtin_ia32_gather3siv2df:
IID = Intrinsic::x86_avx512_mask_gather3siv2_df;
break;
case X86::BI__builtin_ia32_gather3siv2di:
IID = Intrinsic::x86_avx512_mask_gather3siv2_di;
break;
case X86::BI__builtin_ia32_gather3siv4df:
IID = Intrinsic::x86_avx512_mask_gather3siv4_df;
break;
case X86::BI__builtin_ia32_gather3siv4di:
IID = Intrinsic::x86_avx512_mask_gather3siv4_di;
break;
case X86::BI__builtin_ia32_gather3siv4sf:
IID = Intrinsic::x86_avx512_mask_gather3siv4_sf;
break;
case X86::BI__builtin_ia32_gather3siv4si:
IID = Intrinsic::x86_avx512_mask_gather3siv4_si;
break;
case X86::BI__builtin_ia32_gather3siv8sf:
IID = Intrinsic::x86_avx512_mask_gather3siv8_sf;
break;
case X86::BI__builtin_ia32_gather3siv8si:
IID = Intrinsic::x86_avx512_mask_gather3siv8_si;
break;
case X86::BI__builtin_ia32_gathersiv8df:
IID = Intrinsic::x86_avx512_mask_gather_dpd_512;
break;
case X86::BI__builtin_ia32_gathersiv16sf:
IID = Intrinsic::x86_avx512_mask_gather_dps_512;
break;
case X86::BI__builtin_ia32_gatherdiv8df:
IID = Intrinsic::x86_avx512_mask_gather_qpd_512;
break;
case X86::BI__builtin_ia32_gatherdiv16sf:
IID = Intrinsic::x86_avx512_mask_gather_qps_512;
break;
case X86::BI__builtin_ia32_gathersiv8di:
IID = Intrinsic::x86_avx512_mask_gather_dpq_512;
break;
case X86::BI__builtin_ia32_gathersiv16si:
IID = Intrinsic::x86_avx512_mask_gather_dpi_512;
break;
case X86::BI__builtin_ia32_gatherdiv8di:
IID = Intrinsic::x86_avx512_mask_gather_qpq_512;
break;
case X86::BI__builtin_ia32_gatherdiv16si:
IID = Intrinsic::x86_avx512_mask_gather_qpi_512;
break;
}
unsigned MinElts = std::min(
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements(),
cast<llvm::FixedVectorType>(Ops[2]->getType())->getNumElements());
Ops[3] = getMaskVecValue(*this, Ops[3], MinElts);
Function *Intr = CGM.getIntrinsic(IID);
return Builder.CreateCall(Intr, Ops);
}
case X86::BI__builtin_ia32_scattersiv8df:
case X86::BI__builtin_ia32_scattersiv16sf:
case X86::BI__builtin_ia32_scatterdiv8df:
case X86::BI__builtin_ia32_scatterdiv16sf:
case X86::BI__builtin_ia32_scattersiv8di:
case X86::BI__builtin_ia32_scattersiv16si:
case X86::BI__builtin_ia32_scatterdiv8di:
case X86::BI__builtin_ia32_scatterdiv16si:
case X86::BI__builtin_ia32_scatterdiv2df:
case X86::BI__builtin_ia32_scatterdiv2di:
case X86::BI__builtin_ia32_scatterdiv4df:
case X86::BI__builtin_ia32_scatterdiv4di:
case X86::BI__builtin_ia32_scatterdiv4sf:
case X86::BI__builtin_ia32_scatterdiv4si:
case X86::BI__builtin_ia32_scatterdiv8sf:
case X86::BI__builtin_ia32_scatterdiv8si:
case X86::BI__builtin_ia32_scattersiv2df:
case X86::BI__builtin_ia32_scattersiv2di:
case X86::BI__builtin_ia32_scattersiv4df:
case X86::BI__builtin_ia32_scattersiv4di:
case X86::BI__builtin_ia32_scattersiv4sf:
case X86::BI__builtin_ia32_scattersiv4si:
case X86::BI__builtin_ia32_scattersiv8sf:
case X86::BI__builtin_ia32_scattersiv8si: {
Intrinsic::ID IID;
switch (BuiltinID) {
default: llvm_unreachable("Unexpected builtin");
case X86::BI__builtin_ia32_scattersiv8df:
IID = Intrinsic::x86_avx512_mask_scatter_dpd_512;
break;
case X86::BI__builtin_ia32_scattersiv16sf:
IID = Intrinsic::x86_avx512_mask_scatter_dps_512;
break;
case X86::BI__builtin_ia32_scatterdiv8df:
IID = Intrinsic::x86_avx512_mask_scatter_qpd_512;
break;
case X86::BI__builtin_ia32_scatterdiv16sf:
IID = Intrinsic::x86_avx512_mask_scatter_qps_512;
break;
case X86::BI__builtin_ia32_scattersiv8di:
IID = Intrinsic::x86_avx512_mask_scatter_dpq_512;
break;
case X86::BI__builtin_ia32_scattersiv16si:
IID = Intrinsic::x86_avx512_mask_scatter_dpi_512;
break;
case X86::BI__builtin_ia32_scatterdiv8di:
IID = Intrinsic::x86_avx512_mask_scatter_qpq_512;
break;
case X86::BI__builtin_ia32_scatterdiv16si:
IID = Intrinsic::x86_avx512_mask_scatter_qpi_512;
break;
case X86::BI__builtin_ia32_scatterdiv2df:
IID = Intrinsic::x86_avx512_mask_scatterdiv2_df;
break;
case X86::BI__builtin_ia32_scatterdiv2di:
IID = Intrinsic::x86_avx512_mask_scatterdiv2_di;
break;
case X86::BI__builtin_ia32_scatterdiv4df:
IID = Intrinsic::x86_avx512_mask_scatterdiv4_df;
break;
case X86::BI__builtin_ia32_scatterdiv4di:
IID = Intrinsic::x86_avx512_mask_scatterdiv4_di;
break;
case X86::BI__builtin_ia32_scatterdiv4sf:
IID = Intrinsic::x86_avx512_mask_scatterdiv4_sf;
break;
case X86::BI__builtin_ia32_scatterdiv4si:
IID = Intrinsic::x86_avx512_mask_scatterdiv4_si;
break;
case X86::BI__builtin_ia32_scatterdiv8sf:
IID = Intrinsic::x86_avx512_mask_scatterdiv8_sf;
break;
case X86::BI__builtin_ia32_scatterdiv8si:
IID = Intrinsic::x86_avx512_mask_scatterdiv8_si;
break;
case X86::BI__builtin_ia32_scattersiv2df:
IID = Intrinsic::x86_avx512_mask_scattersiv2_df;
break;
case X86::BI__builtin_ia32_scattersiv2di:
IID = Intrinsic::x86_avx512_mask_scattersiv2_di;
break;
case X86::BI__builtin_ia32_scattersiv4df:
IID = Intrinsic::x86_avx512_mask_scattersiv4_df;
break;
case X86::BI__builtin_ia32_scattersiv4di:
IID = Intrinsic::x86_avx512_mask_scattersiv4_di;
break;
case X86::BI__builtin_ia32_scattersiv4sf:
IID = Intrinsic::x86_avx512_mask_scattersiv4_sf;
break;
case X86::BI__builtin_ia32_scattersiv4si:
IID = Intrinsic::x86_avx512_mask_scattersiv4_si;
break;
case X86::BI__builtin_ia32_scattersiv8sf:
IID = Intrinsic::x86_avx512_mask_scattersiv8_sf;
break;
case X86::BI__builtin_ia32_scattersiv8si:
IID = Intrinsic::x86_avx512_mask_scattersiv8_si;
break;
}
unsigned MinElts = std::min(
cast<llvm::FixedVectorType>(Ops[2]->getType())->getNumElements(),
cast<llvm::FixedVectorType>(Ops[3]->getType())->getNumElements());
Ops[1] = getMaskVecValue(*this, Ops[1], MinElts);
Function *Intr = CGM.getIntrinsic(IID);
return Builder.CreateCall(Intr, Ops);
}
case X86::BI__builtin_ia32_vextractf128_pd256:
case X86::BI__builtin_ia32_vextractf128_ps256:
case X86::BI__builtin_ia32_vextractf128_si256:
case X86::BI__builtin_ia32_extract128i256:
case X86::BI__builtin_ia32_extractf64x4_mask:
case X86::BI__builtin_ia32_extractf32x4_mask:
case X86::BI__builtin_ia32_extracti64x4_mask:
case X86::BI__builtin_ia32_extracti32x4_mask:
case X86::BI__builtin_ia32_extractf32x8_mask:
case X86::BI__builtin_ia32_extracti32x8_mask:
case X86::BI__builtin_ia32_extractf32x4_256_mask:
case X86::BI__builtin_ia32_extracti32x4_256_mask:
case X86::BI__builtin_ia32_extractf64x2_256_mask:
case X86::BI__builtin_ia32_extracti64x2_256_mask:
case X86::BI__builtin_ia32_extractf64x2_512_mask:
case X86::BI__builtin_ia32_extracti64x2_512_mask: {
auto *DstTy = cast<llvm::FixedVectorType>(ConvertType(E->getType()));
unsigned NumElts = DstTy->getNumElements();
unsigned SrcNumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
unsigned SubVectors = SrcNumElts / NumElts;
unsigned Index = cast<ConstantInt>(Ops[1])->getZExtValue();
assert(llvm::isPowerOf2_32(SubVectors) && "Expected power of 2 subvectors");
Index &= SubVectors - 1; // Remove any extra bits.
Index *= NumElts;
int Indices[16];
for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = i + Index;
Value *Res = Builder.CreateShuffleVector(Ops[0],
makeArrayRef(Indices, NumElts),
"extract");
if (Ops.size() == 4)
Res = EmitX86Select(*this, Ops[3], Res, Ops[2]);
return Res;
}
case X86::BI__builtin_ia32_vinsertf128_pd256:
case X86::BI__builtin_ia32_vinsertf128_ps256:
case X86::BI__builtin_ia32_vinsertf128_si256:
case X86::BI__builtin_ia32_insert128i256:
case X86::BI__builtin_ia32_insertf64x4:
case X86::BI__builtin_ia32_insertf32x4:
case X86::BI__builtin_ia32_inserti64x4:
case X86::BI__builtin_ia32_inserti32x4:
case X86::BI__builtin_ia32_insertf32x8:
case X86::BI__builtin_ia32_inserti32x8:
case X86::BI__builtin_ia32_insertf32x4_256:
case X86::BI__builtin_ia32_inserti32x4_256:
case X86::BI__builtin_ia32_insertf64x2_256:
case X86::BI__builtin_ia32_inserti64x2_256:
case X86::BI__builtin_ia32_insertf64x2_512:
case X86::BI__builtin_ia32_inserti64x2_512: {
unsigned DstNumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
unsigned SrcNumElts =
cast<llvm::FixedVectorType>(Ops[1]->getType())->getNumElements();
unsigned SubVectors = DstNumElts / SrcNumElts;
unsigned Index = cast<ConstantInt>(Ops[2])->getZExtValue();
assert(llvm::isPowerOf2_32(SubVectors) && "Expected power of 2 subvectors");
Index &= SubVectors - 1; // Remove any extra bits.
Index *= SrcNumElts;
int Indices[16];
for (unsigned i = 0; i != DstNumElts; ++i)
Indices[i] = (i >= SrcNumElts) ? SrcNumElts + (i % SrcNumElts) : i;
Value *Op1 = Builder.CreateShuffleVector(Ops[1],
makeArrayRef(Indices, DstNumElts),
"widen");
for (unsigned i = 0; i != DstNumElts; ++i) {
if (i >= Index && i < (Index + SrcNumElts))
Indices[i] = (i - Index) + DstNumElts;
else
Indices[i] = i;
}
return Builder.CreateShuffleVector(Ops[0], Op1,
makeArrayRef(Indices, DstNumElts),
"insert");
}
case X86::BI__builtin_ia32_pmovqd512_mask:
case X86::BI__builtin_ia32_pmovwb512_mask: {
Value *Res = Builder.CreateTrunc(Ops[0], Ops[1]->getType());
return EmitX86Select(*this, Ops[2], Res, Ops[1]);
}
case X86::BI__builtin_ia32_pmovdb512_mask:
case X86::BI__builtin_ia32_pmovdw512_mask:
case X86::BI__builtin_ia32_pmovqw512_mask: {
if (const auto *C = dyn_cast<Constant>(Ops[2]))
if (C->isAllOnesValue())
return Builder.CreateTrunc(Ops[0], Ops[1]->getType());
Intrinsic::ID IID;
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
case X86::BI__builtin_ia32_pmovdb512_mask:
IID = Intrinsic::x86_avx512_mask_pmov_db_512;
break;
case X86::BI__builtin_ia32_pmovdw512_mask:
IID = Intrinsic::x86_avx512_mask_pmov_dw_512;
break;
case X86::BI__builtin_ia32_pmovqw512_mask:
IID = Intrinsic::x86_avx512_mask_pmov_qw_512;
break;
}
Function *Intr = CGM.getIntrinsic(IID);
return Builder.CreateCall(Intr, Ops);
}
case X86::BI__builtin_ia32_pblendw128:
case X86::BI__builtin_ia32_blendpd:
case X86::BI__builtin_ia32_blendps:
case X86::BI__builtin_ia32_blendpd256:
case X86::BI__builtin_ia32_blendps256:
case X86::BI__builtin_ia32_pblendw256:
case X86::BI__builtin_ia32_pblendd128:
case X86::BI__builtin_ia32_pblendd256: {
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
unsigned Imm = cast<llvm::ConstantInt>(Ops[2])->getZExtValue();
int Indices[16];
// If there are more than 8 elements, the immediate is used twice so make
// sure we handle that.
for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = ((Imm >> (i % 8)) & 0x1) ? NumElts + i : i;
return Builder.CreateShuffleVector(Ops[0], Ops[1],
makeArrayRef(Indices, NumElts),
"blend");
}
case X86::BI__builtin_ia32_pshuflw:
case X86::BI__builtin_ia32_pshuflw256:
case X86::BI__builtin_ia32_pshuflw512: {
uint32_t Imm = cast<llvm::ConstantInt>(Ops[1])->getZExtValue();
auto *Ty = cast<llvm::FixedVectorType>(Ops[0]->getType());
unsigned NumElts = Ty->getNumElements();
// Splat the 8-bits of immediate 4 times to help the loop wrap around.
Imm = (Imm & 0xff) * 0x01010101;
int Indices[32];
for (unsigned l = 0; l != NumElts; l += 8) {
for (unsigned i = 0; i != 4; ++i) {
Indices[l + i] = l + (Imm & 3);
Imm >>= 2;
}
for (unsigned i = 4; i != 8; ++i)
Indices[l + i] = l + i;
}
return Builder.CreateShuffleVector(Ops[0], makeArrayRef(Indices, NumElts),
"pshuflw");
}
case X86::BI__builtin_ia32_pshufhw:
case X86::BI__builtin_ia32_pshufhw256:
case X86::BI__builtin_ia32_pshufhw512: {
uint32_t Imm = cast<llvm::ConstantInt>(Ops[1])->getZExtValue();
auto *Ty = cast<llvm::FixedVectorType>(Ops[0]->getType());
unsigned NumElts = Ty->getNumElements();
// Splat the 8-bits of immediate 4 times to help the loop wrap around.
Imm = (Imm & 0xff) * 0x01010101;
int Indices[32];
for (unsigned l = 0; l != NumElts; l += 8) {
for (unsigned i = 0; i != 4; ++i)
Indices[l + i] = l + i;
for (unsigned i = 4; i != 8; ++i) {
Indices[l + i] = l + 4 + (Imm & 3);
Imm >>= 2;
}
}
return Builder.CreateShuffleVector(Ops[0], makeArrayRef(Indices, NumElts),
"pshufhw");
}
case X86::BI__builtin_ia32_pshufd:
case X86::BI__builtin_ia32_pshufd256:
case X86::BI__builtin_ia32_pshufd512:
case X86::BI__builtin_ia32_vpermilpd:
case X86::BI__builtin_ia32_vpermilps:
case X86::BI__builtin_ia32_vpermilpd256:
case X86::BI__builtin_ia32_vpermilps256:
case X86::BI__builtin_ia32_vpermilpd512:
case X86::BI__builtin_ia32_vpermilps512: {
uint32_t Imm = cast<llvm::ConstantInt>(Ops[1])->getZExtValue();
auto *Ty = cast<llvm::FixedVectorType>(Ops[0]->getType());
unsigned NumElts = Ty->getNumElements();
unsigned NumLanes = Ty->getPrimitiveSizeInBits() / 128;
unsigned NumLaneElts = NumElts / NumLanes;
// Splat the 8-bits of immediate 4 times to help the loop wrap around.
Imm = (Imm & 0xff) * 0x01010101;
int Indices[16];
for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
for (unsigned i = 0; i != NumLaneElts; ++i) {
Indices[i + l] = (Imm % NumLaneElts) + l;
Imm /= NumLaneElts;
}
}
return Builder.CreateShuffleVector(Ops[0], makeArrayRef(Indices, NumElts),
"permil");
}
case X86::BI__builtin_ia32_shufpd:
case X86::BI__builtin_ia32_shufpd256:
case X86::BI__builtin_ia32_shufpd512:
case X86::BI__builtin_ia32_shufps:
case X86::BI__builtin_ia32_shufps256:
case X86::BI__builtin_ia32_shufps512: {
uint32_t Imm = cast<llvm::ConstantInt>(Ops[2])->getZExtValue();
auto *Ty = cast<llvm::FixedVectorType>(Ops[0]->getType());
unsigned NumElts = Ty->getNumElements();
unsigned NumLanes = Ty->getPrimitiveSizeInBits() / 128;
unsigned NumLaneElts = NumElts / NumLanes;
// Splat the 8-bits of immediate 4 times to help the loop wrap around.
Imm = (Imm & 0xff) * 0x01010101;
int Indices[16];
for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
for (unsigned i = 0; i != NumLaneElts; ++i) {
unsigned Index = Imm % NumLaneElts;
Imm /= NumLaneElts;
if (i >= (NumLaneElts / 2))
Index += NumElts;
Indices[l + i] = l + Index;
}
}
return Builder.CreateShuffleVector(Ops[0], Ops[1],
makeArrayRef(Indices, NumElts),
"shufp");
}
case X86::BI__builtin_ia32_permdi256:
case X86::BI__builtin_ia32_permdf256:
case X86::BI__builtin_ia32_permdi512:
case X86::BI__builtin_ia32_permdf512: {
unsigned Imm = cast<llvm::ConstantInt>(Ops[1])->getZExtValue();
auto *Ty = cast<llvm::FixedVectorType>(Ops[0]->getType());
unsigned NumElts = Ty->getNumElements();
// These intrinsics operate on 256-bit lanes of four 64-bit elements.
int Indices[8];
for (unsigned l = 0; l != NumElts; l += 4)
for (unsigned i = 0; i != 4; ++i)
Indices[l + i] = l + ((Imm >> (2 * i)) & 0x3);
return Builder.CreateShuffleVector(Ops[0], makeArrayRef(Indices, NumElts),
"perm");
}
case X86::BI__builtin_ia32_palignr128:
case X86::BI__builtin_ia32_palignr256:
case X86::BI__builtin_ia32_palignr512: {
unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0xff;
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
assert(NumElts % 16 == 0);
// If palignr is shifting the pair of vectors more than the size of two
// lanes, emit zero.
if (ShiftVal >= 32)
return llvm::Constant::getNullValue(ConvertType(E->getType()));
// If palignr is shifting the pair of input vectors more than one lane,
// but less than two lanes, convert to shifting in zeroes.
if (ShiftVal > 16) {
ShiftVal -= 16;
Ops[1] = Ops[0];
Ops[0] = llvm::Constant::getNullValue(Ops[0]->getType());
}
int Indices[64];
// 256-bit palignr operates on 128-bit lanes so we need to handle that
for (unsigned l = 0; l != NumElts; l += 16) {
for (unsigned i = 0; i != 16; ++i) {
unsigned Idx = ShiftVal + i;
if (Idx >= 16)
Idx += NumElts - 16; // End of lane, switch operand.
Indices[l + i] = Idx + l;
}
}
return Builder.CreateShuffleVector(Ops[1], Ops[0],
makeArrayRef(Indices, NumElts),
"palignr");
}
case X86::BI__builtin_ia32_alignd128:
case X86::BI__builtin_ia32_alignd256:
case X86::BI__builtin_ia32_alignd512:
case X86::BI__builtin_ia32_alignq128:
case X86::BI__builtin_ia32_alignq256:
case X86::BI__builtin_ia32_alignq512: {
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0xff;
// Mask the shift amount to width of two vectors.
ShiftVal &= (2 * NumElts) - 1;
int Indices[16];
for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = i + ShiftVal;
return Builder.CreateShuffleVector(Ops[1], Ops[0],
makeArrayRef(Indices, NumElts),
"valign");
}
case X86::BI__builtin_ia32_shuf_f32x4_256:
case X86::BI__builtin_ia32_shuf_f64x2_256:
case X86::BI__builtin_ia32_shuf_i32x4_256:
case X86::BI__builtin_ia32_shuf_i64x2_256:
case X86::BI__builtin_ia32_shuf_f32x4:
case X86::BI__builtin_ia32_shuf_f64x2:
case X86::BI__builtin_ia32_shuf_i32x4:
case X86::BI__builtin_ia32_shuf_i64x2: {
unsigned Imm = cast<llvm::ConstantInt>(Ops[2])->getZExtValue();
auto *Ty = cast<llvm::FixedVectorType>(Ops[0]->getType());
unsigned NumElts = Ty->getNumElements();
unsigned NumLanes = Ty->getPrimitiveSizeInBits() == 512 ? 4 : 2;
unsigned NumLaneElts = NumElts / NumLanes;
int Indices[16];
for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
unsigned Index = (Imm % NumLanes) * NumLaneElts;
Imm /= NumLanes; // Discard the bits we just used.
if (l >= (NumElts / 2))
Index += NumElts; // Switch to other source.
for (unsigned i = 0; i != NumLaneElts; ++i) {
Indices[l + i] = Index + i;
}
}
return Builder.CreateShuffleVector(Ops[0], Ops[1],
makeArrayRef(Indices, NumElts),
"shuf");
}
case X86::BI__builtin_ia32_vperm2f128_pd256:
case X86::BI__builtin_ia32_vperm2f128_ps256:
case X86::BI__builtin_ia32_vperm2f128_si256:
case X86::BI__builtin_ia32_permti256: {
unsigned Imm = cast<llvm::ConstantInt>(Ops[2])->getZExtValue();
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
// This takes a very simple approach since there are two lanes and a
// shuffle can have 2 inputs. So we reserve the first input for the first
// lane and the second input for the second lane. This may result in
// duplicate sources, but this can be dealt with in the backend.
Value *OutOps[2];
int Indices[8];
for (unsigned l = 0; l != 2; ++l) {
// Determine the source for this lane.
if (Imm & (1 << ((l * 4) + 3)))
OutOps[l] = llvm::ConstantAggregateZero::get(Ops[0]->getType());
else if (Imm & (1 << ((l * 4) + 1)))
OutOps[l] = Ops[1];
else
OutOps[l] = Ops[0];
for (unsigned i = 0; i != NumElts/2; ++i) {
// Start with ith element of the source for this lane.
unsigned Idx = (l * NumElts) + i;
// If bit 0 of the immediate half is set, switch to the high half of
// the source.
if (Imm & (1 << (l * 4)))
Idx += NumElts/2;
Indices[(l * (NumElts/2)) + i] = Idx;
}
}
return Builder.CreateShuffleVector(OutOps[0], OutOps[1],
makeArrayRef(Indices, NumElts),
"vperm");
}
case X86::BI__builtin_ia32_pslldqi128_byteshift:
case X86::BI__builtin_ia32_pslldqi256_byteshift:
case X86::BI__builtin_ia32_pslldqi512_byteshift: {
unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[1])->getZExtValue() & 0xff;
auto *ResultType = cast<llvm::FixedVectorType>(Ops[0]->getType());
// Builtin type is vXi64 so multiply by 8 to get bytes.
unsigned NumElts = ResultType->getNumElements() * 8;
// If pslldq is shifting the vector more than 15 bytes, emit zero.
if (ShiftVal >= 16)
return llvm::Constant::getNullValue(ResultType);
int Indices[64];
// 256/512-bit pslldq operates on 128-bit lanes so we need to handle that
for (unsigned l = 0; l != NumElts; l += 16) {
for (unsigned i = 0; i != 16; ++i) {
unsigned Idx = NumElts + i - ShiftVal;
if (Idx < NumElts) Idx -= NumElts - 16; // end of lane, switch operand.
Indices[l + i] = Idx + l;
}
}
auto *VecTy = llvm::FixedVectorType::get(Int8Ty, NumElts);
Value *Cast = Builder.CreateBitCast(Ops[0], VecTy, "cast");
Value *Zero = llvm::Constant::getNullValue(VecTy);
Value *SV = Builder.CreateShuffleVector(Zero, Cast,
makeArrayRef(Indices, NumElts),
"pslldq");
return Builder.CreateBitCast(SV, Ops[0]->getType(), "cast");
}
case X86::BI__builtin_ia32_psrldqi128_byteshift:
case X86::BI__builtin_ia32_psrldqi256_byteshift:
case X86::BI__builtin_ia32_psrldqi512_byteshift: {
unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[1])->getZExtValue() & 0xff;
auto *ResultType = cast<llvm::FixedVectorType>(Ops[0]->getType());
// Builtin type is vXi64 so multiply by 8 to get bytes.
unsigned NumElts = ResultType->getNumElements() * 8;
// If psrldq is shifting the vector more than 15 bytes, emit zero.
if (ShiftVal >= 16)
return llvm::Constant::getNullValue(ResultType);
int Indices[64];
// 256/512-bit psrldq operates on 128-bit lanes so we need to handle that
for (unsigned l = 0; l != NumElts; l += 16) {
for (unsigned i = 0; i != 16; ++i) {
unsigned Idx = i + ShiftVal;
if (Idx >= 16) Idx += NumElts - 16; // end of lane, switch operand.
Indices[l + i] = Idx + l;
}
}
auto *VecTy = llvm::FixedVectorType::get(Int8Ty, NumElts);
Value *Cast = Builder.CreateBitCast(Ops[0], VecTy, "cast");
Value *Zero = llvm::Constant::getNullValue(VecTy);
Value *SV = Builder.CreateShuffleVector(Cast, Zero,
makeArrayRef(Indices, NumElts),
"psrldq");
return Builder.CreateBitCast(SV, ResultType, "cast");
}
case X86::BI__builtin_ia32_kshiftliqi:
case X86::BI__builtin_ia32_kshiftlihi:
case X86::BI__builtin_ia32_kshiftlisi:
case X86::BI__builtin_ia32_kshiftlidi: {
unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[1])->getZExtValue() & 0xff;
unsigned NumElts = Ops[0]->getType()->getIntegerBitWidth();
if (ShiftVal >= NumElts)
return llvm::Constant::getNullValue(Ops[0]->getType());
Value *In = getMaskVecValue(*this, Ops[0], NumElts);
int Indices[64];
for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = NumElts + i - ShiftVal;
Value *Zero = llvm::Constant::getNullValue(In->getType());
Value *SV = Builder.CreateShuffleVector(Zero, In,
makeArrayRef(Indices, NumElts),
"kshiftl");
return Builder.CreateBitCast(SV, Ops[0]->getType());
}
case X86::BI__builtin_ia32_kshiftriqi:
case X86::BI__builtin_ia32_kshiftrihi:
case X86::BI__builtin_ia32_kshiftrisi:
case X86::BI__builtin_ia32_kshiftridi: {
unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[1])->getZExtValue() & 0xff;
unsigned NumElts = Ops[0]->getType()->getIntegerBitWidth();
if (ShiftVal >= NumElts)
return llvm::Constant::getNullValue(Ops[0]->getType());
Value *In = getMaskVecValue(*this, Ops[0], NumElts);
int Indices[64];
for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = i + ShiftVal;
Value *Zero = llvm::Constant::getNullValue(In->getType());
Value *SV = Builder.CreateShuffleVector(In, Zero,
makeArrayRef(Indices, NumElts),
"kshiftr");
return Builder.CreateBitCast(SV, Ops[0]->getType());
}
case X86::BI__builtin_ia32_movnti:
case X86::BI__builtin_ia32_movnti64:
case X86::BI__builtin_ia32_movntsd:
case X86::BI__builtin_ia32_movntss: {
llvm::MDNode *Node = llvm::MDNode::get(
getLLVMContext(), llvm::ConstantAsMetadata::get(Builder.getInt32(1)));
Value *Ptr = Ops[0];
Value *Src = Ops[1];
// Extract the 0'th element of the source vector.
if (BuiltinID == X86::BI__builtin_ia32_movntsd ||
BuiltinID == X86::BI__builtin_ia32_movntss)
Src = Builder.CreateExtractElement(Src, (uint64_t)0, "extract");
// Convert the type of the pointer to a pointer to the stored type.
Value *BC = Builder.CreateBitCast(
Ptr, llvm::PointerType::getUnqual(Src->getType()), "cast");
// Unaligned nontemporal store of the scalar value.
StoreInst *SI = Builder.CreateDefaultAlignedStore(Src, BC);
SI->setMetadata(CGM.getModule().getMDKindID("nontemporal"), Node);
SI->setAlignment(llvm::Align(1));
return SI;
}
// Rotate is a special case of funnel shift - 1st 2 args are the same.
case X86::BI__builtin_ia32_vprotb:
case X86::BI__builtin_ia32_vprotw:
case X86::BI__builtin_ia32_vprotd:
case X86::BI__builtin_ia32_vprotq:
case X86::BI__builtin_ia32_vprotbi:
case X86::BI__builtin_ia32_vprotwi:
case X86::BI__builtin_ia32_vprotdi:
case X86::BI__builtin_ia32_vprotqi:
case X86::BI__builtin_ia32_prold128:
case X86::BI__builtin_ia32_prold256:
case X86::BI__builtin_ia32_prold512:
case X86::BI__builtin_ia32_prolq128:
case X86::BI__builtin_ia32_prolq256:
case X86::BI__builtin_ia32_prolq512:
case X86::BI__builtin_ia32_prolvd128:
case X86::BI__builtin_ia32_prolvd256:
case X86::BI__builtin_ia32_prolvd512:
case X86::BI__builtin_ia32_prolvq128:
case X86::BI__builtin_ia32_prolvq256:
case X86::BI__builtin_ia32_prolvq512:
return EmitX86FunnelShift(*this, Ops[0], Ops[0], Ops[1], false);
case X86::BI__builtin_ia32_prord128:
case X86::BI__builtin_ia32_prord256:
case X86::BI__builtin_ia32_prord512:
case X86::BI__builtin_ia32_prorq128:
case X86::BI__builtin_ia32_prorq256:
case X86::BI__builtin_ia32_prorq512:
case X86::BI__builtin_ia32_prorvd128:
case X86::BI__builtin_ia32_prorvd256:
case X86::BI__builtin_ia32_prorvd512:
case X86::BI__builtin_ia32_prorvq128:
case X86::BI__builtin_ia32_prorvq256:
case X86::BI__builtin_ia32_prorvq512:
return EmitX86FunnelShift(*this, Ops[0], Ops[0], Ops[1], true);
case X86::BI__builtin_ia32_selectb_128:
case X86::BI__builtin_ia32_selectb_256:
case X86::BI__builtin_ia32_selectb_512:
case X86::BI__builtin_ia32_selectw_128:
case X86::BI__builtin_ia32_selectw_256:
case X86::BI__builtin_ia32_selectw_512:
case X86::BI__builtin_ia32_selectd_128:
case X86::BI__builtin_ia32_selectd_256:
case X86::BI__builtin_ia32_selectd_512:
case X86::BI__builtin_ia32_selectq_128:
case X86::BI__builtin_ia32_selectq_256:
case X86::BI__builtin_ia32_selectq_512:
case X86::BI__builtin_ia32_selectps_128:
case X86::BI__builtin_ia32_selectps_256:
case X86::BI__builtin_ia32_selectps_512:
case X86::BI__builtin_ia32_selectpd_128:
case X86::BI__builtin_ia32_selectpd_256:
case X86::BI__builtin_ia32_selectpd_512:
return EmitX86Select(*this, Ops[0], Ops[1], Ops[2]);
case X86::BI__builtin_ia32_selectss_128:
case X86::BI__builtin_ia32_selectsd_128: {
Value *A = Builder.CreateExtractElement(Ops[1], (uint64_t)0);
Value *B = Builder.CreateExtractElement(Ops[2], (uint64_t)0);
A = EmitX86ScalarSelect(*this, Ops[0], A, B);
return Builder.CreateInsertElement(Ops[1], A, (uint64_t)0);
}
case X86::BI__builtin_ia32_cmpb128_mask:
case X86::BI__builtin_ia32_cmpb256_mask:
case X86::BI__builtin_ia32_cmpb512_mask:
case X86::BI__builtin_ia32_cmpw128_mask:
case X86::BI__builtin_ia32_cmpw256_mask:
case X86::BI__builtin_ia32_cmpw512_mask:
case X86::BI__builtin_ia32_cmpd128_mask:
case X86::BI__builtin_ia32_cmpd256_mask:
case X86::BI__builtin_ia32_cmpd512_mask:
case X86::BI__builtin_ia32_cmpq128_mask:
case X86::BI__builtin_ia32_cmpq256_mask:
case X86::BI__builtin_ia32_cmpq512_mask: {
unsigned CC = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0x7;
return EmitX86MaskedCompare(*this, CC, true, Ops);
}
case X86::BI__builtin_ia32_ucmpb128_mask:
case X86::BI__builtin_ia32_ucmpb256_mask:
case X86::BI__builtin_ia32_ucmpb512_mask:
case X86::BI__builtin_ia32_ucmpw128_mask:
case X86::BI__builtin_ia32_ucmpw256_mask:
case X86::BI__builtin_ia32_ucmpw512_mask:
case X86::BI__builtin_ia32_ucmpd128_mask:
case X86::BI__builtin_ia32_ucmpd256_mask:
case X86::BI__builtin_ia32_ucmpd512_mask:
case X86::BI__builtin_ia32_ucmpq128_mask:
case X86::BI__builtin_ia32_ucmpq256_mask:
case X86::BI__builtin_ia32_ucmpq512_mask: {
unsigned CC = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0x7;
return EmitX86MaskedCompare(*this, CC, false, Ops);
}
case X86::BI__builtin_ia32_vpcomb:
case X86::BI__builtin_ia32_vpcomw:
case X86::BI__builtin_ia32_vpcomd:
case X86::BI__builtin_ia32_vpcomq:
return EmitX86vpcom(*this, Ops, true);
case X86::BI__builtin_ia32_vpcomub:
case X86::BI__builtin_ia32_vpcomuw:
case X86::BI__builtin_ia32_vpcomud:
case X86::BI__builtin_ia32_vpcomuq:
return EmitX86vpcom(*this, Ops, false);
case X86::BI__builtin_ia32_kortestcqi:
case X86::BI__builtin_ia32_kortestchi:
case X86::BI__builtin_ia32_kortestcsi:
case X86::BI__builtin_ia32_kortestcdi: {
Value *Or = EmitX86MaskLogic(*this, Instruction::Or, Ops);
Value *C = llvm::Constant::getAllOnesValue(Ops[0]->getType());
Value *Cmp = Builder.CreateICmpEQ(Or, C);
return Builder.CreateZExt(Cmp, ConvertType(E->getType()));
}
case X86::BI__builtin_ia32_kortestzqi:
case X86::BI__builtin_ia32_kortestzhi:
case X86::BI__builtin_ia32_kortestzsi:
case X86::BI__builtin_ia32_kortestzdi: {
Value *Or = EmitX86MaskLogic(*this, Instruction::Or, Ops);
Value *C = llvm::Constant::getNullValue(Ops[0]->getType());
Value *Cmp = Builder.CreateICmpEQ(Or, C);
return Builder.CreateZExt(Cmp, ConvertType(E->getType()));
}
case X86::BI__builtin_ia32_ktestcqi:
case X86::BI__builtin_ia32_ktestzqi:
case X86::BI__builtin_ia32_ktestchi:
case X86::BI__builtin_ia32_ktestzhi:
case X86::BI__builtin_ia32_ktestcsi:
case X86::BI__builtin_ia32_ktestzsi:
case X86::BI__builtin_ia32_ktestcdi:
case X86::BI__builtin_ia32_ktestzdi: {
Intrinsic::ID IID;
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
case X86::BI__builtin_ia32_ktestcqi:
IID = Intrinsic::x86_avx512_ktestc_b;
break;
case X86::BI__builtin_ia32_ktestzqi:
IID = Intrinsic::x86_avx512_ktestz_b;
break;
case X86::BI__builtin_ia32_ktestchi:
IID = Intrinsic::x86_avx512_ktestc_w;
break;
case X86::BI__builtin_ia32_ktestzhi:
IID = Intrinsic::x86_avx512_ktestz_w;
break;
case X86::BI__builtin_ia32_ktestcsi:
IID = Intrinsic::x86_avx512_ktestc_d;
break;
case X86::BI__builtin_ia32_ktestzsi:
IID = Intrinsic::x86_avx512_ktestz_d;
break;
case X86::BI__builtin_ia32_ktestcdi:
IID = Intrinsic::x86_avx512_ktestc_q;
break;
case X86::BI__builtin_ia32_ktestzdi:
IID = Intrinsic::x86_avx512_ktestz_q;
break;
}
unsigned NumElts = Ops[0]->getType()->getIntegerBitWidth();
Value *LHS = getMaskVecValue(*this, Ops[0], NumElts);
Value *RHS = getMaskVecValue(*this, Ops[1], NumElts);
Function *Intr = CGM.getIntrinsic(IID);
return Builder.CreateCall(Intr, {LHS, RHS});
}
case X86::BI__builtin_ia32_kaddqi:
case X86::BI__builtin_ia32_kaddhi:
case X86::BI__builtin_ia32_kaddsi:
case X86::BI__builtin_ia32_kadddi: {
Intrinsic::ID IID;
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
case X86::BI__builtin_ia32_kaddqi:
IID = Intrinsic::x86_avx512_kadd_b;
break;
case X86::BI__builtin_ia32_kaddhi:
IID = Intrinsic::x86_avx512_kadd_w;
break;
case X86::BI__builtin_ia32_kaddsi:
IID = Intrinsic::x86_avx512_kadd_d;
break;
case X86::BI__builtin_ia32_kadddi:
IID = Intrinsic::x86_avx512_kadd_q;
break;
}
unsigned NumElts = Ops[0]->getType()->getIntegerBitWidth();
Value *LHS = getMaskVecValue(*this, Ops[0], NumElts);
Value *RHS = getMaskVecValue(*this, Ops[1], NumElts);
Function *Intr = CGM.getIntrinsic(IID);
Value *Res = Builder.CreateCall(Intr, {LHS, RHS});
return Builder.CreateBitCast(Res, Ops[0]->getType());
}
case X86::BI__builtin_ia32_kandqi:
case X86::BI__builtin_ia32_kandhi:
case X86::BI__builtin_ia32_kandsi:
case X86::BI__builtin_ia32_kanddi:
return EmitX86MaskLogic(*this, Instruction::And, Ops);
case X86::BI__builtin_ia32_kandnqi:
case X86::BI__builtin_ia32_kandnhi:
case X86::BI__builtin_ia32_kandnsi:
case X86::BI__builtin_ia32_kandndi:
return EmitX86MaskLogic(*this, Instruction::And, Ops, true);
case X86::BI__builtin_ia32_korqi:
case X86::BI__builtin_ia32_korhi:
case X86::BI__builtin_ia32_korsi:
case X86::BI__builtin_ia32_kordi:
return EmitX86MaskLogic(*this, Instruction::Or, Ops);
case X86::BI__builtin_ia32_kxnorqi:
case X86::BI__builtin_ia32_kxnorhi:
case X86::BI__builtin_ia32_kxnorsi:
case X86::BI__builtin_ia32_kxnordi:
return EmitX86MaskLogic(*this, Instruction::Xor, Ops, true);
case X86::BI__builtin_ia32_kxorqi:
case X86::BI__builtin_ia32_kxorhi:
case X86::BI__builtin_ia32_kxorsi:
case X86::BI__builtin_ia32_kxordi:
return EmitX86MaskLogic(*this, Instruction::Xor, Ops);
case X86::BI__builtin_ia32_knotqi:
case X86::BI__builtin_ia32_knothi:
case X86::BI__builtin_ia32_knotsi:
case X86::BI__builtin_ia32_knotdi: {
unsigned NumElts = Ops[0]->getType()->getIntegerBitWidth();
Value *Res = getMaskVecValue(*this, Ops[0], NumElts);
return Builder.CreateBitCast(Builder.CreateNot(Res),
Ops[0]->getType());
}
case X86::BI__builtin_ia32_kmovb:
case X86::BI__builtin_ia32_kmovw:
case X86::BI__builtin_ia32_kmovd:
case X86::BI__builtin_ia32_kmovq: {
// Bitcast to vXi1 type and then back to integer. This gets the mask
// register type into the IR, but might be optimized out depending on
// what's around it.
unsigned NumElts = Ops[0]->getType()->getIntegerBitWidth();
Value *Res = getMaskVecValue(*this, Ops[0], NumElts);
return Builder.CreateBitCast(Res, Ops[0]->getType());
}
case X86::BI__builtin_ia32_kunpckdi:
case X86::BI__builtin_ia32_kunpcksi:
case X86::BI__builtin_ia32_kunpckhi: {
unsigned NumElts = Ops[0]->getType()->getIntegerBitWidth();
Value *LHS = getMaskVecValue(*this, Ops[0], NumElts);
Value *RHS = getMaskVecValue(*this, Ops[1], NumElts);
int Indices[64];
for (unsigned i = 0; i != NumElts; ++i)
Indices[i] = i;
// First extract half of each vector. This gives better codegen than
// doing it in a single shuffle.
LHS = Builder.CreateShuffleVector(LHS, LHS,
makeArrayRef(Indices, NumElts / 2));
RHS = Builder.CreateShuffleVector(RHS, RHS,
makeArrayRef(Indices, NumElts / 2));
// Concat the vectors.
// NOTE: Operands are swapped to match the intrinsic definition.
Value *Res = Builder.CreateShuffleVector(RHS, LHS,
makeArrayRef(Indices, NumElts));
return Builder.CreateBitCast(Res, Ops[0]->getType());
}
case X86::BI__builtin_ia32_vplzcntd_128:
case X86::BI__builtin_ia32_vplzcntd_256:
case X86::BI__builtin_ia32_vplzcntd_512:
case X86::BI__builtin_ia32_vplzcntq_128:
case X86::BI__builtin_ia32_vplzcntq_256:
case X86::BI__builtin_ia32_vplzcntq_512: {
Function *F = CGM.getIntrinsic(Intrinsic::ctlz, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0],Builder.getInt1(false)});
}
case X86::BI__builtin_ia32_sqrtss:
case X86::BI__builtin_ia32_sqrtsd: {
Value *A = Builder.CreateExtractElement(Ops[0], (uint64_t)0);
Function *F;
if (Builder.getIsFPConstrained()) {
F = CGM.getIntrinsic(Intrinsic::experimental_constrained_sqrt,
A->getType());
A = Builder.CreateConstrainedFPCall(F, {A});
} else {
F = CGM.getIntrinsic(Intrinsic::sqrt, A->getType());
A = Builder.CreateCall(F, {A});
}
return Builder.CreateInsertElement(Ops[0], A, (uint64_t)0);
}
case X86::BI__builtin_ia32_sqrtsd_round_mask:
case X86::BI__builtin_ia32_sqrtss_round_mask: {
unsigned CC = cast<llvm::ConstantInt>(Ops[4])->getZExtValue();
// Support only if the rounding mode is 4 (AKA CUR_DIRECTION),
// otherwise keep the intrinsic.
if (CC != 4) {
Intrinsic::ID IID = BuiltinID == X86::BI__builtin_ia32_sqrtsd_round_mask ?
Intrinsic::x86_avx512_mask_sqrt_sd :
Intrinsic::x86_avx512_mask_sqrt_ss;
return Builder.CreateCall(CGM.getIntrinsic(IID), Ops);
}
Value *A = Builder.CreateExtractElement(Ops[1], (uint64_t)0);
Function *F;
if (Builder.getIsFPConstrained()) {
F = CGM.getIntrinsic(Intrinsic::experimental_constrained_sqrt,
A->getType());
A = Builder.CreateConstrainedFPCall(F, A);
} else {
F = CGM.getIntrinsic(Intrinsic::sqrt, A->getType());
A = Builder.CreateCall(F, A);
}
Value *Src = Builder.CreateExtractElement(Ops[2], (uint64_t)0);
A = EmitX86ScalarSelect(*this, Ops[3], A, Src);
return Builder.CreateInsertElement(Ops[0], A, (uint64_t)0);
}
case X86::BI__builtin_ia32_sqrtpd256:
case X86::BI__builtin_ia32_sqrtpd:
case X86::BI__builtin_ia32_sqrtps256:
case X86::BI__builtin_ia32_sqrtps:
case X86::BI__builtin_ia32_sqrtps512:
case X86::BI__builtin_ia32_sqrtpd512: {
if (Ops.size() == 2) {
unsigned CC = cast<llvm::ConstantInt>(Ops[1])->getZExtValue();
// Support only if the rounding mode is 4 (AKA CUR_DIRECTION),
// otherwise keep the intrinsic.
if (CC != 4) {
Intrinsic::ID IID = BuiltinID == X86::BI__builtin_ia32_sqrtps512 ?
Intrinsic::x86_avx512_sqrt_ps_512 :
Intrinsic::x86_avx512_sqrt_pd_512;
return Builder.CreateCall(CGM.getIntrinsic(IID), Ops);
}
}
if (Builder.getIsFPConstrained()) {
Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_sqrt,
Ops[0]->getType());
return Builder.CreateConstrainedFPCall(F, Ops[0]);
} else {
Function *F = CGM.getIntrinsic(Intrinsic::sqrt, Ops[0]->getType());
return Builder.CreateCall(F, Ops[0]);
}
}
case X86::BI__builtin_ia32_pabsb128:
case X86::BI__builtin_ia32_pabsw128:
case X86::BI__builtin_ia32_pabsd128:
case X86::BI__builtin_ia32_pabsb256:
case X86::BI__builtin_ia32_pabsw256:
case X86::BI__builtin_ia32_pabsd256:
case X86::BI__builtin_ia32_pabsq128:
case X86::BI__builtin_ia32_pabsq256:
case X86::BI__builtin_ia32_pabsb512:
case X86::BI__builtin_ia32_pabsw512:
case X86::BI__builtin_ia32_pabsd512:
case X86::BI__builtin_ia32_pabsq512: {
Function *F = CGM.getIntrinsic(Intrinsic::abs, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0], Builder.getInt1(false)});
}
case X86::BI__builtin_ia32_pmaxsb128:
case X86::BI__builtin_ia32_pmaxsw128:
case X86::BI__builtin_ia32_pmaxsd128:
case X86::BI__builtin_ia32_pmaxsq128:
case X86::BI__builtin_ia32_pmaxsb256:
case X86::BI__builtin_ia32_pmaxsw256:
case X86::BI__builtin_ia32_pmaxsd256:
case X86::BI__builtin_ia32_pmaxsq256:
case X86::BI__builtin_ia32_pmaxsb512:
case X86::BI__builtin_ia32_pmaxsw512:
case X86::BI__builtin_ia32_pmaxsd512:
case X86::BI__builtin_ia32_pmaxsq512:
return EmitX86BinaryIntrinsic(*this, Ops, Intrinsic::smax);
case X86::BI__builtin_ia32_pmaxub128:
case X86::BI__builtin_ia32_pmaxuw128:
case X86::BI__builtin_ia32_pmaxud128:
case X86::BI__builtin_ia32_pmaxuq128:
case X86::BI__builtin_ia32_pmaxub256:
case X86::BI__builtin_ia32_pmaxuw256:
case X86::BI__builtin_ia32_pmaxud256:
case X86::BI__builtin_ia32_pmaxuq256:
case X86::BI__builtin_ia32_pmaxub512:
case X86::BI__builtin_ia32_pmaxuw512:
case X86::BI__builtin_ia32_pmaxud512:
case X86::BI__builtin_ia32_pmaxuq512:
return EmitX86BinaryIntrinsic(*this, Ops, Intrinsic::umax);
case X86::BI__builtin_ia32_pminsb128:
case X86::BI__builtin_ia32_pminsw128:
case X86::BI__builtin_ia32_pminsd128:
case X86::BI__builtin_ia32_pminsq128:
case X86::BI__builtin_ia32_pminsb256:
case X86::BI__builtin_ia32_pminsw256:
case X86::BI__builtin_ia32_pminsd256:
case X86::BI__builtin_ia32_pminsq256:
case X86::BI__builtin_ia32_pminsb512:
case X86::BI__builtin_ia32_pminsw512:
case X86::BI__builtin_ia32_pminsd512:
case X86::BI__builtin_ia32_pminsq512:
return EmitX86BinaryIntrinsic(*this, Ops, Intrinsic::smin);
case X86::BI__builtin_ia32_pminub128:
case X86::BI__builtin_ia32_pminuw128:
case X86::BI__builtin_ia32_pminud128:
case X86::BI__builtin_ia32_pminuq128:
case X86::BI__builtin_ia32_pminub256:
case X86::BI__builtin_ia32_pminuw256:
case X86::BI__builtin_ia32_pminud256:
case X86::BI__builtin_ia32_pminuq256:
case X86::BI__builtin_ia32_pminub512:
case X86::BI__builtin_ia32_pminuw512:
case X86::BI__builtin_ia32_pminud512:
case X86::BI__builtin_ia32_pminuq512:
return EmitX86BinaryIntrinsic(*this, Ops, Intrinsic::umin);
case X86::BI__builtin_ia32_pmuludq128:
case X86::BI__builtin_ia32_pmuludq256:
case X86::BI__builtin_ia32_pmuludq512:
return EmitX86Muldq(*this, /*IsSigned*/false, Ops);
case X86::BI__builtin_ia32_pmuldq128:
case X86::BI__builtin_ia32_pmuldq256:
case X86::BI__builtin_ia32_pmuldq512:
return EmitX86Muldq(*this, /*IsSigned*/true, Ops);
case X86::BI__builtin_ia32_pternlogd512_mask:
case X86::BI__builtin_ia32_pternlogq512_mask:
case X86::BI__builtin_ia32_pternlogd128_mask:
case X86::BI__builtin_ia32_pternlogd256_mask:
case X86::BI__builtin_ia32_pternlogq128_mask:
case X86::BI__builtin_ia32_pternlogq256_mask:
return EmitX86Ternlog(*this, /*ZeroMask*/false, Ops);
case X86::BI__builtin_ia32_pternlogd512_maskz:
case X86::BI__builtin_ia32_pternlogq512_maskz:
case X86::BI__builtin_ia32_pternlogd128_maskz:
case X86::BI__builtin_ia32_pternlogd256_maskz:
case X86::BI__builtin_ia32_pternlogq128_maskz:
case X86::BI__builtin_ia32_pternlogq256_maskz:
return EmitX86Ternlog(*this, /*ZeroMask*/true, Ops);
case X86::BI__builtin_ia32_vpshldd128:
case X86::BI__builtin_ia32_vpshldd256:
case X86::BI__builtin_ia32_vpshldd512:
case X86::BI__builtin_ia32_vpshldq128:
case X86::BI__builtin_ia32_vpshldq256:
case X86::BI__builtin_ia32_vpshldq512:
case X86::BI__builtin_ia32_vpshldw128:
case X86::BI__builtin_ia32_vpshldw256:
case X86::BI__builtin_ia32_vpshldw512:
return EmitX86FunnelShift(*this, Ops[0], Ops[1], Ops[2], false);
case X86::BI__builtin_ia32_vpshrdd128:
case X86::BI__builtin_ia32_vpshrdd256:
case X86::BI__builtin_ia32_vpshrdd512:
case X86::BI__builtin_ia32_vpshrdq128:
case X86::BI__builtin_ia32_vpshrdq256:
case X86::BI__builtin_ia32_vpshrdq512:
case X86::BI__builtin_ia32_vpshrdw128:
case X86::BI__builtin_ia32_vpshrdw256:
case X86::BI__builtin_ia32_vpshrdw512:
// Ops 0 and 1 are swapped.
return EmitX86FunnelShift(*this, Ops[1], Ops[0], Ops[2], true);
case X86::BI__builtin_ia32_vpshldvd128:
case X86::BI__builtin_ia32_vpshldvd256:
case X86::BI__builtin_ia32_vpshldvd512:
case X86::BI__builtin_ia32_vpshldvq128:
case X86::BI__builtin_ia32_vpshldvq256:
case X86::BI__builtin_ia32_vpshldvq512:
case X86::BI__builtin_ia32_vpshldvw128:
case X86::BI__builtin_ia32_vpshldvw256:
case X86::BI__builtin_ia32_vpshldvw512:
return EmitX86FunnelShift(*this, Ops[0], Ops[1], Ops[2], false);
case X86::BI__builtin_ia32_vpshrdvd128:
case X86::BI__builtin_ia32_vpshrdvd256:
case X86::BI__builtin_ia32_vpshrdvd512:
case X86::BI__builtin_ia32_vpshrdvq128:
case X86::BI__builtin_ia32_vpshrdvq256:
case X86::BI__builtin_ia32_vpshrdvq512:
case X86::BI__builtin_ia32_vpshrdvw128:
case X86::BI__builtin_ia32_vpshrdvw256:
case X86::BI__builtin_ia32_vpshrdvw512:
// Ops 0 and 1 are swapped.
return EmitX86FunnelShift(*this, Ops[1], Ops[0], Ops[2], true);
// Reductions
case X86::BI__builtin_ia32_reduce_add_d512:
case X86::BI__builtin_ia32_reduce_add_q512: {
Function *F =
CGM.getIntrinsic(Intrinsic::vector_reduce_add, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0]});
}
case X86::BI__builtin_ia32_reduce_and_d512:
case X86::BI__builtin_ia32_reduce_and_q512: {
Function *F =
CGM.getIntrinsic(Intrinsic::vector_reduce_and, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0]});
}
case X86::BI__builtin_ia32_reduce_fadd_pd512:
case X86::BI__builtin_ia32_reduce_fadd_ps512: {
Function *F =
CGM.getIntrinsic(Intrinsic::vector_reduce_fadd, Ops[1]->getType());
return Builder.CreateCall(F, {Ops[0], Ops[1]});
}
case X86::BI__builtin_ia32_reduce_fmul_pd512:
case X86::BI__builtin_ia32_reduce_fmul_ps512: {
Function *F =
CGM.getIntrinsic(Intrinsic::vector_reduce_fmul, Ops[1]->getType());
return Builder.CreateCall(F, {Ops[0], Ops[1]});
}
case X86::BI__builtin_ia32_reduce_mul_d512:
case X86::BI__builtin_ia32_reduce_mul_q512: {
Function *F =
CGM.getIntrinsic(Intrinsic::vector_reduce_mul, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0]});
}
case X86::BI__builtin_ia32_reduce_or_d512:
case X86::BI__builtin_ia32_reduce_or_q512: {
Function *F =
CGM.getIntrinsic(Intrinsic::vector_reduce_or, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0]});
}
case X86::BI__builtin_ia32_reduce_smax_d512:
case X86::BI__builtin_ia32_reduce_smax_q512: {
Function *F =
CGM.getIntrinsic(Intrinsic::vector_reduce_smax, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0]});
}
case X86::BI__builtin_ia32_reduce_smin_d512:
case X86::BI__builtin_ia32_reduce_smin_q512: {
Function *F =
CGM.getIntrinsic(Intrinsic::vector_reduce_smin, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0]});
}
case X86::BI__builtin_ia32_reduce_umax_d512:
case X86::BI__builtin_ia32_reduce_umax_q512: {
Function *F =
CGM.getIntrinsic(Intrinsic::vector_reduce_umax, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0]});
}
case X86::BI__builtin_ia32_reduce_umin_d512:
case X86::BI__builtin_ia32_reduce_umin_q512: {
Function *F =
CGM.getIntrinsic(Intrinsic::vector_reduce_umin, Ops[0]->getType());
return Builder.CreateCall(F, {Ops[0]});
}
// 3DNow!
case X86::BI__builtin_ia32_pswapdsf:
case X86::BI__builtin_ia32_pswapdsi: {
llvm::Type *MMXTy = llvm::Type::getX86_MMXTy(getLLVMContext());
Ops[0] = Builder.CreateBitCast(Ops[0], MMXTy, "cast");
llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_3dnowa_pswapd);
return Builder.CreateCall(F, Ops, "pswapd");
}
case X86::BI__builtin_ia32_rdrand16_step:
case X86::BI__builtin_ia32_rdrand32_step:
case X86::BI__builtin_ia32_rdrand64_step:
case X86::BI__builtin_ia32_rdseed16_step:
case X86::BI__builtin_ia32_rdseed32_step:
case X86::BI__builtin_ia32_rdseed64_step: {
Intrinsic::ID ID;
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
case X86::BI__builtin_ia32_rdrand16_step:
ID = Intrinsic::x86_rdrand_16;
break;
case X86::BI__builtin_ia32_rdrand32_step:
ID = Intrinsic::x86_rdrand_32;
break;
case X86::BI__builtin_ia32_rdrand64_step:
ID = Intrinsic::x86_rdrand_64;
break;
case X86::BI__builtin_ia32_rdseed16_step:
ID = Intrinsic::x86_rdseed_16;
break;
case X86::BI__builtin_ia32_rdseed32_step:
ID = Intrinsic::x86_rdseed_32;
break;
case X86::BI__builtin_ia32_rdseed64_step:
ID = Intrinsic::x86_rdseed_64;
break;
}
Value *Call = Builder.CreateCall(CGM.getIntrinsic(ID));
Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 0),
Ops[0]);
return Builder.CreateExtractValue(Call, 1);
}
case X86::BI__builtin_ia32_addcarryx_u32:
case X86::BI__builtin_ia32_addcarryx_u64:
case X86::BI__builtin_ia32_subborrow_u32:
case X86::BI__builtin_ia32_subborrow_u64: {
Intrinsic::ID IID;
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
case X86::BI__builtin_ia32_addcarryx_u32:
IID = Intrinsic::x86_addcarry_32;
break;
case X86::BI__builtin_ia32_addcarryx_u64:
IID = Intrinsic::x86_addcarry_64;
break;
case X86::BI__builtin_ia32_subborrow_u32:
IID = Intrinsic::x86_subborrow_32;
break;
case X86::BI__builtin_ia32_subborrow_u64:
IID = Intrinsic::x86_subborrow_64;
break;
}
Value *Call = Builder.CreateCall(CGM.getIntrinsic(IID),
{ Ops[0], Ops[1], Ops[2] });
Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 1),
Ops[3]);
return Builder.CreateExtractValue(Call, 0);
}
case X86::BI__builtin_ia32_fpclassps128_mask:
case X86::BI__builtin_ia32_fpclassps256_mask:
case X86::BI__builtin_ia32_fpclassps512_mask:
case X86::BI__builtin_ia32_fpclasspd128_mask:
case X86::BI__builtin_ia32_fpclasspd256_mask:
case X86::BI__builtin_ia32_fpclasspd512_mask: {
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
Value *MaskIn = Ops[2];
Ops.erase(&Ops[2]);
Intrinsic::ID ID;
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
case X86::BI__builtin_ia32_fpclassps128_mask:
ID = Intrinsic::x86_avx512_fpclass_ps_128;
break;
case X86::BI__builtin_ia32_fpclassps256_mask:
ID = Intrinsic::x86_avx512_fpclass_ps_256;
break;
case X86::BI__builtin_ia32_fpclassps512_mask:
ID = Intrinsic::x86_avx512_fpclass_ps_512;
break;
case X86::BI__builtin_ia32_fpclasspd128_mask:
ID = Intrinsic::x86_avx512_fpclass_pd_128;
break;
case X86::BI__builtin_ia32_fpclasspd256_mask:
ID = Intrinsic::x86_avx512_fpclass_pd_256;
break;
case X86::BI__builtin_ia32_fpclasspd512_mask:
ID = Intrinsic::x86_avx512_fpclass_pd_512;
break;
}
Value *Fpclass = Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
return EmitX86MaskedCompareResult(*this, Fpclass, NumElts, MaskIn);
}
case X86::BI__builtin_ia32_vp2intersect_q_512:
case X86::BI__builtin_ia32_vp2intersect_q_256:
case X86::BI__builtin_ia32_vp2intersect_q_128:
case X86::BI__builtin_ia32_vp2intersect_d_512:
case X86::BI__builtin_ia32_vp2intersect_d_256:
case X86::BI__builtin_ia32_vp2intersect_d_128: {
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
Intrinsic::ID ID;
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
case X86::BI__builtin_ia32_vp2intersect_q_512:
ID = Intrinsic::x86_avx512_vp2intersect_q_512;
break;
case X86::BI__builtin_ia32_vp2intersect_q_256:
ID = Intrinsic::x86_avx512_vp2intersect_q_256;
break;
case X86::BI__builtin_ia32_vp2intersect_q_128:
ID = Intrinsic::x86_avx512_vp2intersect_q_128;
break;
case X86::BI__builtin_ia32_vp2intersect_d_512:
ID = Intrinsic::x86_avx512_vp2intersect_d_512;
break;
case X86::BI__builtin_ia32_vp2intersect_d_256:
ID = Intrinsic::x86_avx512_vp2intersect_d_256;
break;
case X86::BI__builtin_ia32_vp2intersect_d_128:
ID = Intrinsic::x86_avx512_vp2intersect_d_128;
break;
}
Value *Call = Builder.CreateCall(CGM.getIntrinsic(ID), {Ops[0], Ops[1]});
Value *Result = Builder.CreateExtractValue(Call, 0);
Result = EmitX86MaskedCompareResult(*this, Result, NumElts, nullptr);
Builder.CreateDefaultAlignedStore(Result, Ops[2]);
Result = Builder.CreateExtractValue(Call, 1);
Result = EmitX86MaskedCompareResult(*this, Result, NumElts, nullptr);
return Builder.CreateDefaultAlignedStore(Result, Ops[3]);
}
case X86::BI__builtin_ia32_vpmultishiftqb128:
case X86::BI__builtin_ia32_vpmultishiftqb256:
case X86::BI__builtin_ia32_vpmultishiftqb512: {
Intrinsic::ID ID;
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
case X86::BI__builtin_ia32_vpmultishiftqb128:
ID = Intrinsic::x86_avx512_pmultishift_qb_128;
break;
case X86::BI__builtin_ia32_vpmultishiftqb256:
ID = Intrinsic::x86_avx512_pmultishift_qb_256;
break;
case X86::BI__builtin_ia32_vpmultishiftqb512:
ID = Intrinsic::x86_avx512_pmultishift_qb_512;
break;
}
return Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
}
case X86::BI__builtin_ia32_vpshufbitqmb128_mask:
case X86::BI__builtin_ia32_vpshufbitqmb256_mask:
case X86::BI__builtin_ia32_vpshufbitqmb512_mask: {
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
Value *MaskIn = Ops[2];
Ops.erase(&Ops[2]);
Intrinsic::ID ID;
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
case X86::BI__builtin_ia32_vpshufbitqmb128_mask:
ID = Intrinsic::x86_avx512_vpshufbitqmb_128;
break;
case X86::BI__builtin_ia32_vpshufbitqmb256_mask:
ID = Intrinsic::x86_avx512_vpshufbitqmb_256;
break;
case X86::BI__builtin_ia32_vpshufbitqmb512_mask:
ID = Intrinsic::x86_avx512_vpshufbitqmb_512;
break;
}
Value *Shufbit = Builder.CreateCall(CGM.getIntrinsic(ID), Ops);
return EmitX86MaskedCompareResult(*this, Shufbit, NumElts, MaskIn);
}
// packed comparison intrinsics
case X86::BI__builtin_ia32_cmpeqps:
case X86::BI__builtin_ia32_cmpeqpd:
return getVectorFCmpIR(CmpInst::FCMP_OEQ, /*IsSignaling*/false);
case X86::BI__builtin_ia32_cmpltps:
case X86::BI__builtin_ia32_cmpltpd:
return getVectorFCmpIR(CmpInst::FCMP_OLT, /*IsSignaling*/true);
case X86::BI__builtin_ia32_cmpleps:
case X86::BI__builtin_ia32_cmplepd:
return getVectorFCmpIR(CmpInst::FCMP_OLE, /*IsSignaling*/true);
case X86::BI__builtin_ia32_cmpunordps:
case X86::BI__builtin_ia32_cmpunordpd:
return getVectorFCmpIR(CmpInst::FCMP_UNO, /*IsSignaling*/false);
case X86::BI__builtin_ia32_cmpneqps:
case X86::BI__builtin_ia32_cmpneqpd:
return getVectorFCmpIR(CmpInst::FCMP_UNE, /*IsSignaling*/false);
case X86::BI__builtin_ia32_cmpnltps:
case X86::BI__builtin_ia32_cmpnltpd:
return getVectorFCmpIR(CmpInst::FCMP_UGE, /*IsSignaling*/true);
case X86::BI__builtin_ia32_cmpnleps:
case X86::BI__builtin_ia32_cmpnlepd:
return getVectorFCmpIR(CmpInst::FCMP_UGT, /*IsSignaling*/true);
case X86::BI__builtin_ia32_cmpordps:
case X86::BI__builtin_ia32_cmpordpd:
return getVectorFCmpIR(CmpInst::FCMP_ORD, /*IsSignaling*/false);
case X86::BI__builtin_ia32_cmpps128_mask:
case X86::BI__builtin_ia32_cmpps256_mask:
case X86::BI__builtin_ia32_cmpps512_mask:
case X86::BI__builtin_ia32_cmppd128_mask:
case X86::BI__builtin_ia32_cmppd256_mask:
case X86::BI__builtin_ia32_cmppd512_mask:
IsMaskFCmp = true;
LLVM_FALLTHROUGH;
case X86::BI__builtin_ia32_cmpps:
case X86::BI__builtin_ia32_cmpps256:
case X86::BI__builtin_ia32_cmppd:
case X86::BI__builtin_ia32_cmppd256: {
// Lowering vector comparisons to fcmp instructions, while
// ignoring signalling behaviour requested
// ignoring rounding mode requested
// This is is only possible as long as FENV_ACCESS is not implemented.
// See also: https://reviews.llvm.org/D45616
// The third argument is the comparison condition, and integer in the
// range [0, 31]
unsigned CC = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0x1f;
// Lowering to IR fcmp instruction.
// Ignoring requested signaling behaviour,
// e.g. both _CMP_GT_OS & _CMP_GT_OQ are translated to FCMP_OGT.
FCmpInst::Predicate Pred;
bool IsSignaling;
// Predicates for 16-31 repeat the 0-15 predicates. Only the signalling
// behavior is inverted. We'll handle that after the switch.
switch (CC & 0xf) {
case 0x00: Pred = FCmpInst::FCMP_OEQ; IsSignaling = false; break;
case 0x01: Pred = FCmpInst::FCMP_OLT; IsSignaling = true; break;
case 0x02: Pred = FCmpInst::FCMP_OLE; IsSignaling = true; break;
case 0x03: Pred = FCmpInst::FCMP_UNO; IsSignaling = false; break;
case 0x04: Pred = FCmpInst::FCMP_UNE; IsSignaling = false; break;
case 0x05: Pred = FCmpInst::FCMP_UGE; IsSignaling = true; break;
case 0x06: Pred = FCmpInst::FCMP_UGT; IsSignaling = true; break;
case 0x07: Pred = FCmpInst::FCMP_ORD; IsSignaling = false; break;
case 0x08: Pred = FCmpInst::FCMP_UEQ; IsSignaling = false; break;
case 0x09: Pred = FCmpInst::FCMP_ULT; IsSignaling = true; break;
case 0x0a: Pred = FCmpInst::FCMP_ULE; IsSignaling = true; break;
case 0x0b: Pred = FCmpInst::FCMP_FALSE; IsSignaling = false; break;
case 0x0c: Pred = FCmpInst::FCMP_ONE; IsSignaling = false; break;
case 0x0d: Pred = FCmpInst::FCMP_OGE; IsSignaling = true; break;
case 0x0e: Pred = FCmpInst::FCMP_OGT; IsSignaling = true; break;
case 0x0f: Pred = FCmpInst::FCMP_TRUE; IsSignaling = false; break;
default: llvm_unreachable("Unhandled CC");
}
// Invert the signalling behavior for 16-31.
if (CC & 0x10)
IsSignaling = !IsSignaling;
// If the predicate is true or false and we're using constrained intrinsics,
// we don't have a compare intrinsic we can use. Just use the legacy X86
// specific intrinsic.
// If the intrinsic is mask enabled and we're using constrained intrinsics,
// use the legacy X86 specific intrinsic.
if (Builder.getIsFPConstrained() &&
(Pred == FCmpInst::FCMP_TRUE || Pred == FCmpInst::FCMP_FALSE ||
IsMaskFCmp)) {
Intrinsic::ID IID;
switch (BuiltinID) {
default: llvm_unreachable("Unexpected builtin");
case X86::BI__builtin_ia32_cmpps:
IID = Intrinsic::x86_sse_cmp_ps;
break;
case X86::BI__builtin_ia32_cmpps256:
IID = Intrinsic::x86_avx_cmp_ps_256;
break;
case X86::BI__builtin_ia32_cmppd:
IID = Intrinsic::x86_sse2_cmp_pd;
break;
case X86::BI__builtin_ia32_cmppd256:
IID = Intrinsic::x86_avx_cmp_pd_256;
break;
case X86::BI__builtin_ia32_cmpps512_mask:
IID = Intrinsic::x86_avx512_mask_cmp_ps_512;
break;
case X86::BI__builtin_ia32_cmppd512_mask:
IID = Intrinsic::x86_avx512_mask_cmp_pd_512;
break;
case X86::BI__builtin_ia32_cmpps128_mask:
IID = Intrinsic::x86_avx512_mask_cmp_ps_128;
break;
case X86::BI__builtin_ia32_cmpps256_mask:
IID = Intrinsic::x86_avx512_mask_cmp_ps_256;
break;
case X86::BI__builtin_ia32_cmppd128_mask:
IID = Intrinsic::x86_avx512_mask_cmp_pd_128;
break;
case X86::BI__builtin_ia32_cmppd256_mask:
IID = Intrinsic::x86_avx512_mask_cmp_pd_256;
break;
}
Function *Intr = CGM.getIntrinsic(IID);
if (IsMaskFCmp) {
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
Ops[3] = getMaskVecValue(*this, Ops[3], NumElts);
Value *Cmp = Builder.CreateCall(Intr, Ops);
return EmitX86MaskedCompareResult(*this, Cmp, NumElts, nullptr);
}
return Builder.CreateCall(Intr, Ops);
}
// Builtins without the _mask suffix return a vector of integers
// of the same width as the input vectors
if (IsMaskFCmp) {
// We ignore SAE if strict FP is disabled. We only keep precise
// exception behavior under strict FP.
unsigned NumElts =
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements();
Value *Cmp;
if (IsSignaling)
Cmp = Builder.CreateFCmpS(Pred, Ops[0], Ops[1]);
else
Cmp = Builder.CreateFCmp(Pred, Ops[0], Ops[1]);
return EmitX86MaskedCompareResult(*this, Cmp, NumElts, Ops[3]);
}
return getVectorFCmpIR(Pred, IsSignaling);
}
// SSE scalar comparison intrinsics
case X86::BI__builtin_ia32_cmpeqss:
return getCmpIntrinsicCall(Intrinsic::x86_sse_cmp_ss, 0);
case X86::BI__builtin_ia32_cmpltss:
return getCmpIntrinsicCall(Intrinsic::x86_sse_cmp_ss, 1);
case X86::BI__builtin_ia32_cmpless:
return getCmpIntrinsicCall(Intrinsic::x86_sse_cmp_ss, 2);
case X86::BI__builtin_ia32_cmpunordss:
return getCmpIntrinsicCall(Intrinsic::x86_sse_cmp_ss, 3);
case X86::BI__builtin_ia32_cmpneqss:
return getCmpIntrinsicCall(Intrinsic::x86_sse_cmp_ss, 4);
case X86::BI__builtin_ia32_cmpnltss:
return getCmpIntrinsicCall(Intrinsic::x86_sse_cmp_ss, 5);
case X86::BI__builtin_ia32_cmpnless:
return getCmpIntrinsicCall(Intrinsic::x86_sse_cmp_ss, 6);
case X86::BI__builtin_ia32_cmpordss:
return getCmpIntrinsicCall(Intrinsic::x86_sse_cmp_ss, 7);
case X86::BI__builtin_ia32_cmpeqsd:
return getCmpIntrinsicCall(Intrinsic::x86_sse2_cmp_sd, 0);
case X86::BI__builtin_ia32_cmpltsd:
return getCmpIntrinsicCall(Intrinsic::x86_sse2_cmp_sd, 1);
case X86::BI__builtin_ia32_cmplesd:
return getCmpIntrinsicCall(Intrinsic::x86_sse2_cmp_sd, 2);
case X86::BI__builtin_ia32_cmpunordsd:
return getCmpIntrinsicCall(Intrinsic::x86_sse2_cmp_sd, 3);
case X86::BI__builtin_ia32_cmpneqsd:
return getCmpIntrinsicCall(Intrinsic::x86_sse2_cmp_sd, 4);
case X86::BI__builtin_ia32_cmpnltsd:
return getCmpIntrinsicCall(Intrinsic::x86_sse2_cmp_sd, 5);
case X86::BI__builtin_ia32_cmpnlesd:
return getCmpIntrinsicCall(Intrinsic::x86_sse2_cmp_sd, 6);
case X86::BI__builtin_ia32_cmpordsd:
return getCmpIntrinsicCall(Intrinsic::x86_sse2_cmp_sd, 7);
// f16c half2float intrinsics
case X86::BI__builtin_ia32_vcvtph2ps:
case X86::BI__builtin_ia32_vcvtph2ps256:
case X86::BI__builtin_ia32_vcvtph2ps_mask:
case X86::BI__builtin_ia32_vcvtph2ps256_mask:
case X86::BI__builtin_ia32_vcvtph2ps512_mask:
return EmitX86CvtF16ToFloatExpr(*this, Ops, ConvertType(E->getType()));
// AVX512 bf16 intrinsics
case X86::BI__builtin_ia32_cvtneps2bf16_128_mask: {
Ops[2] = getMaskVecValue(
*this, Ops[2],
cast<llvm::FixedVectorType>(Ops[0]->getType())->getNumElements());
Intrinsic::ID IID = Intrinsic::x86_avx512bf16_mask_cvtneps2bf16_128;
return Builder.CreateCall(CGM.getIntrinsic(IID), Ops);
}
case X86::BI__builtin_ia32_cvtsbf162ss_32:
return EmitX86CvtBF16ToFloatExpr(*this, E, Ops);
case X86::BI__builtin_ia32_cvtneps2bf16_256_mask:
case X86::BI__builtin_ia32_cvtneps2bf16_512_mask: {
Intrinsic::ID IID;
switch (BuiltinID) {
default: llvm_unreachable("Unsupported intrinsic!");
case X86::BI__builtin_ia32_cvtneps2bf16_256_mask:
IID = Intrinsic::x86_avx512bf16_cvtneps2bf16_256;
break;
case X86::BI__builtin_ia32_cvtneps2bf16_512_mask:
IID = Intrinsic::x86_avx512bf16_cvtneps2bf16_512;
break;
}
Value *Res = Builder.CreateCall(CGM.getIntrinsic(IID), Ops[0]);
return EmitX86Select(*this, Ops[2], Res, Ops[1]);
}
case X86::BI__emul:
case X86::BI__emulu: {
llvm::Type *Int64Ty = llvm::IntegerType::get(getLLVMContext(), 64);
bool isSigned = (BuiltinID == X86::BI__emul);
Value *LHS = Builder.CreateIntCast(Ops[0], Int64Ty, isSigned);
Value *RHS = Builder.CreateIntCast(Ops[1], Int64Ty, isSigned);
return Builder.CreateMul(LHS, RHS, "", !isSigned, isSigned);
}
case X86::BI__mulh:
case X86::BI__umulh:
case X86::BI_mul128:
case X86::BI_umul128: {
llvm::Type *ResType = ConvertType(E->getType());
llvm::Type *Int128Ty = llvm::IntegerType::get(getLLVMContext(), 128);
bool IsSigned = (BuiltinID == X86::BI__mulh || BuiltinID == X86::BI_mul128);
Value *LHS = Builder.CreateIntCast(Ops[0], Int128Ty, IsSigned);
Value *RHS = Builder.CreateIntCast(Ops[1], Int128Ty, IsSigned);
Value *MulResult, *HigherBits;
if (IsSigned) {
MulResult = Builder.CreateNSWMul(LHS, RHS);
HigherBits = Builder.CreateAShr(MulResult, 64);
} else {
MulResult = Builder.CreateNUWMul(LHS, RHS);
HigherBits = Builder.CreateLShr(MulResult, 64);
}
HigherBits = Builder.CreateIntCast(HigherBits, ResType, IsSigned);
if (BuiltinID == X86::BI__mulh || BuiltinID == X86::BI__umulh)
return HigherBits;
Address HighBitsAddress = EmitPointerWithAlignment(E->getArg(2));
Builder.CreateStore(HigherBits, HighBitsAddress);
return Builder.CreateIntCast(MulResult, ResType, IsSigned);
}
case X86::BI__faststorefence: {
return Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent,
llvm::SyncScope::System);
}
case X86::BI__shiftleft128:
case X86::BI__shiftright128: {
llvm::Function *F = CGM.getIntrinsic(
BuiltinID == X86::BI__shiftleft128 ? Intrinsic::fshl : Intrinsic::fshr,
Int64Ty);
// Flip low/high ops and zero-extend amount to matching type.
// shiftleft128(Low, High, Amt) -> fshl(High, Low, Amt)
// shiftright128(Low, High, Amt) -> fshr(High, Low, Amt)
std::swap(Ops[0], Ops[1]);
Ops[2] = Builder.CreateZExt(Ops[2], Int64Ty);
return Builder.CreateCall(F, Ops);
}
case X86::BI_ReadWriteBarrier:
case X86::BI_ReadBarrier:
case X86::BI_WriteBarrier: {
return Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent,
llvm::SyncScope::SingleThread);
}
case X86::BI_AddressOfReturnAddress: {
Function *F =
CGM.getIntrinsic(Intrinsic::addressofreturnaddress, AllocaInt8PtrTy);
return Builder.CreateCall(F);
}
case X86::BI__stosb: {
// We treat __stosb as a volatile memset - it may not generate "rep stosb"
// instruction, but it will create a memset that won't be optimized away.
return Builder.CreateMemSet(Ops[0], Ops[1], Ops[2], Align(1), true);
}
case X86::BI__ud2:
// llvm.trap makes a ud2a instruction on x86.
return EmitTrapCall(Intrinsic::trap);
case X86::BI__int2c: {
// This syscall signals a driver assertion failure in x86 NT kernels.
llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
llvm::InlineAsm *IA =
llvm::InlineAsm::get(FTy, "int $$0x2c", "", /*hasSideEffects=*/true);
llvm::AttributeList NoReturnAttr = llvm::AttributeList::get(
getLLVMContext(), llvm::AttributeList::FunctionIndex,
llvm::Attribute::NoReturn);
llvm::CallInst *CI = Builder.CreateCall(IA);
CI->setAttributes(NoReturnAttr);
return CI;
}
case X86::BI__readfsbyte:
case X86::BI__readfsword:
case X86::BI__readfsdword:
case X86::BI__readfsqword: {
llvm::Type *IntTy = ConvertType(E->getType());
Value *Ptr =
Builder.CreateIntToPtr(Ops[0], llvm::PointerType::get(IntTy, 257));
LoadInst *Load = Builder.CreateAlignedLoad(
IntTy, Ptr, getContext().getTypeAlignInChars(E->getType()));
Load->setVolatile(true);
return Load;
}
case X86::BI__readgsbyte:
case X86::BI__readgsword:
case X86::BI__readgsdword:
case X86::BI__readgsqword: {
llvm::Type *IntTy = ConvertType(E->getType());
Value *Ptr =
Builder.CreateIntToPtr(Ops[0], llvm::PointerType::get(IntTy, 256));
LoadInst *Load = Builder.CreateAlignedLoad(
IntTy, Ptr, getContext().getTypeAlignInChars(E->getType()));
Load->setVolatile(true);
return Load;
}
case X86::BI__builtin_ia32_paddsb512:
case X86::BI__builtin_ia32_paddsw512:
case X86::BI__builtin_ia32_paddsb256:
case X86::BI__builtin_ia32_paddsw256:
case X86::BI__builtin_ia32_paddsb128:
case X86::BI__builtin_ia32_paddsw128:
return EmitX86BinaryIntrinsic(*this, Ops, Intrinsic::sadd_sat);
case X86::BI__builtin_ia32_paddusb512:
case X86::BI__builtin_ia32_paddusw512:
case X86::BI__builtin_ia32_paddusb256:
case X86::BI__builtin_ia32_paddusw256:
case X86::BI__builtin_ia32_paddusb128:
case X86::BI__builtin_ia32_paddusw128:
return EmitX86BinaryIntrinsic(*this, Ops, Intrinsic::uadd_sat);
case X86::BI__builtin_ia32_psubsb512:
case X86::BI__builtin_ia32_psubsw512:
case X86::BI__builtin_ia32_psubsb256:
case X86::BI__builtin_ia32_psubsw256:
case X86::BI__builtin_ia32_psubsb128:
case X86::BI__builtin_ia32_psubsw128:
return EmitX86BinaryIntrinsic(*this, Ops, Intrinsic::ssub_sat);
case X86::BI__builtin_ia32_psubusb512:
case X86::BI__builtin_ia32_psubusw512:
case X86::BI__builtin_ia32_psubusb256:
case X86::BI__builtin_ia32_psubusw256:
case X86::BI__builtin_ia32_psubusb128:
case X86::BI__builtin_ia32_psubusw128:
return EmitX86BinaryIntrinsic(*this, Ops, Intrinsic::usub_sat);
case X86::BI__builtin_ia32_encodekey128_u32: {
Intrinsic::ID IID = Intrinsic::x86_encodekey128;
Value *Call = Builder.CreateCall(CGM.getIntrinsic(IID), {Ops[0], Ops[1]});
for (int i = 0; i < 6; ++i) {
Value *Extract = Builder.CreateExtractValue(Call, i + 1);
Value *Ptr = Builder.CreateConstGEP1_32(Ops[2], i * 16);
Ptr = Builder.CreateBitCast(
Ptr, llvm::PointerType::getUnqual(Extract->getType()));
Builder.CreateAlignedStore(Extract, Ptr, Align(1));
}
return Builder.CreateExtractValue(Call, 0);
}
case X86::BI__builtin_ia32_encodekey256_u32: {
Intrinsic::ID IID = Intrinsic::x86_encodekey256;
Value *Call =
Builder.CreateCall(CGM.getIntrinsic(IID), {Ops[0], Ops[1], Ops[2]});
for (int i = 0; i < 7; ++i) {
Value *Extract = Builder.CreateExtractValue(Call, i + 1);
Value *Ptr = Builder.CreateConstGEP1_32(Ops[3], i * 16);
Ptr = Builder.CreateBitCast(
Ptr, llvm::PointerType::getUnqual(Extract->getType()));
Builder.CreateAlignedStore(Extract, Ptr, Align(1));
}
return Builder.CreateExtractValue(Call, 0);
}
case X86::BI__builtin_ia32_aesenc128kl_u8:
case X86::BI__builtin_ia32_aesdec128kl_u8:
case X86::BI__builtin_ia32_aesenc256kl_u8:
case X86::BI__builtin_ia32_aesdec256kl_u8: {
Intrinsic::ID IID;
switch (BuiltinID) {
default: llvm_unreachable("Unexpected builtin");
case X86::BI__builtin_ia32_aesenc128kl_u8:
IID = Intrinsic::x86_aesenc128kl;
break;
case X86::BI__builtin_ia32_aesdec128kl_u8:
IID = Intrinsic::x86_aesdec128kl;
break;
case X86::BI__builtin_ia32_aesenc256kl_u8:
IID = Intrinsic::x86_aesenc256kl;
break;
case X86::BI__builtin_ia32_aesdec256kl_u8:
IID = Intrinsic::x86_aesdec256kl;
break;
}
Value *Call = Builder.CreateCall(CGM.getIntrinsic(IID), {Ops[1], Ops[2]});
Builder.CreateDefaultAlignedStore(Builder.CreateExtractValue(Call, 1),
Ops[0]);
return Builder.CreateExtractValue(Call, 0);
}
case X86::BI__builtin_ia32_aesencwide128kl_u8:
case X86::BI__builtin_ia32_aesdecwide128kl_u8:
case X86::BI__builtin_ia32_aesencwide256kl_u8:
case X86::BI__builtin_ia32_aesdecwide256kl_u8: {
Intrinsic::ID IID;
switch (BuiltinID) {
case X86::BI__builtin_ia32_aesencwide128kl_u8:
IID = Intrinsic::x86_aesencwide128kl;
break;
case X86::BI__builtin_ia32_aesdecwide128kl_u8:
IID = Intrinsic::x86_aesdecwide128kl;
break;
case X86::BI__builtin_ia32_aesencwide256kl_u8:
IID = Intrinsic::x86_aesencwide256kl;
break;
case X86::BI__builtin_ia32_aesdecwide256kl_u8:
IID = Intrinsic::x86_aesdecwide256kl;
break;
}
Value *InOps[9];
InOps[0] = Ops[2];
for (int i = 0; i != 8; ++i) {
Value *Ptr = Builder.CreateConstGEP1_32(Ops[1], i);
InOps[i + 1] = Builder.CreateAlignedLoad(Ptr, Align(16));
}
Value *Call = Builder.CreateCall(CGM.getIntrinsic(IID), InOps);
for (int i = 0; i != 8; ++i) {
Value *Extract = Builder.CreateExtractValue(Call, i + 1);
Value *Ptr = Builder.CreateConstGEP1_32(Ops[0], i);
Builder.CreateAlignedStore(Extract, Ptr, Align(16));
}
return Builder.CreateExtractValue(Call, 0);
}
}
}
Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID,
const CallExpr *E) {
SmallVector<Value*, 4> Ops;
for (unsigned i = 0, e = E->getNumArgs(); i != e; i++)
Ops.push_back(EmitScalarExpr(E->getArg(i)));
Intrinsic::ID ID = Intrinsic::not_intrinsic;
switch (BuiltinID) {
default: return nullptr;
// __builtin_ppc_get_timebase is GCC 4.8+'s PowerPC-specific name for what we
// call __builtin_readcyclecounter.
case PPC::BI__builtin_ppc_get_timebase:
return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::readcyclecounter));
// vec_ld, vec_xl_be, vec_lvsl, vec_lvsr
case PPC::BI__builtin_altivec_lvx:
case PPC::BI__builtin_altivec_lvxl:
case PPC::BI__builtin_altivec_lvebx:
case PPC::BI__builtin_altivec_lvehx:
case PPC::BI__builtin_altivec_lvewx:
case PPC::BI__builtin_altivec_lvsl:
case PPC::BI__builtin_altivec_lvsr:
case PPC::BI__builtin_vsx_lxvd2x:
case PPC::BI__builtin_vsx_lxvw4x:
case PPC::BI__builtin_vsx_lxvd2x_be:
case PPC::BI__builtin_vsx_lxvw4x_be:
case PPC::BI__builtin_vsx_lxvl:
case PPC::BI__builtin_vsx_lxvll:
{
if(BuiltinID == PPC::BI__builtin_vsx_lxvl ||
BuiltinID == PPC::BI__builtin_vsx_lxvll){
Ops[0] = Builder.CreateBitCast(Ops[0], Int8PtrTy);
}else {
Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
Ops[0] = Builder.CreateGEP(Ops[1], Ops[0]);
Ops.pop_back();
}
switch (BuiltinID) {
default: llvm_unreachable("Unsupported ld/lvsl/lvsr intrinsic!");
case PPC::BI__builtin_altivec_lvx:
ID = Intrinsic::ppc_altivec_lvx;
break;
case PPC::BI__builtin_altivec_lvxl:
ID = Intrinsic::ppc_altivec_lvxl;
break;
case PPC::BI__builtin_altivec_lvebx:
ID = Intrinsic::ppc_altivec_lvebx;
break;
case PPC::BI__builtin_altivec_lvehx:
ID = Intrinsic::ppc_altivec_lvehx;
break;
case PPC::BI__builtin_altivec_lvewx:
ID = Intrinsic::ppc_altivec_lvewx;
break;
case PPC::BI__builtin_altivec_lvsl:
ID = Intrinsic::ppc_altivec_lvsl;
break;
case PPC::BI__builtin_altivec_lvsr:
ID = Intrinsic::ppc_altivec_lvsr;
break;
case PPC::BI__builtin_vsx_lxvd2x:
ID = Intrinsic::ppc_vsx_lxvd2x;
break;
case PPC::BI__builtin_vsx_lxvw4x:
ID = Intrinsic::ppc_vsx_lxvw4x;
break;
case PPC::BI__builtin_vsx_lxvd2x_be:
ID = Intrinsic::ppc_vsx_lxvd2x_be;
break;
case PPC::BI__builtin_vsx_lxvw4x_be:
ID = Intrinsic::ppc_vsx_lxvw4x_be;
break;
case PPC::BI__builtin_vsx_lxvl:
ID = Intrinsic::ppc_vsx_lxvl;
break;
case PPC::BI__builtin_vsx_lxvll:
ID = Intrinsic::ppc_vsx_lxvll;
break;
}
llvm::Function *F = CGM.getIntrinsic(ID);
return Builder.CreateCall(F, Ops, "");
}
// vec_st, vec_xst_be
case PPC::BI__builtin_altivec_stvx:
case PPC::BI__builtin_altivec_stvxl:
case PPC::BI__builtin_altivec_stvebx:
case PPC::BI__builtin_altivec_stvehx:
case PPC::BI__builtin_altivec_stvewx:
case PPC::BI__builtin_vsx_stxvd2x:
case PPC::BI__builtin_vsx_stxvw4x:
case PPC::BI__builtin_vsx_stxvd2x_be:
case PPC::BI__builtin_vsx_stxvw4x_be:
case PPC::BI__builtin_vsx_stxvl:
case PPC::BI__builtin_vsx_stxvll:
{
if(BuiltinID == PPC::BI__builtin_vsx_stxvl ||
BuiltinID == PPC::BI__builtin_vsx_stxvll ){
Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
}else {
Ops[2] = Builder.CreateBitCast(Ops[2], Int8PtrTy);
Ops[1] = Builder.CreateGEP(Ops[2], Ops[1]);
Ops.pop_back();
}
switch (BuiltinID) {
default: llvm_unreachable("Unsupported st intrinsic!");
case PPC::BI__builtin_altivec_stvx:
ID = Intrinsic::ppc_altivec_stvx;
break;
case PPC::BI__builtin_altivec_stvxl:
ID = Intrinsic::ppc_altivec_stvxl;
break;
case PPC::BI__builtin_altivec_stvebx:
ID = Intrinsic::ppc_altivec_stvebx;
break;
case PPC::BI__builtin_altivec_stvehx:
ID = Intrinsic::ppc_altivec_stvehx;
break;
case PPC::BI__builtin_altivec_stvewx:
ID = Intrinsic::ppc_altivec_stvewx;
break;
case PPC::BI__builtin_vsx_stxvd2x:
ID = Intrinsic::ppc_vsx_stxvd2x;
break;
case PPC::BI__builtin_vsx_stxvw4x:
ID = Intrinsic::ppc_vsx_stxvw4x;
break;
case PPC::BI__builtin_vsx_stxvd2x_be:
ID = Intrinsic::ppc_vsx_stxvd2x_be;
break;
case PPC::BI__builtin_vsx_stxvw4x_be:
ID = Intrinsic::ppc_vsx_stxvw4x_be;
break;
case PPC::BI__builtin_vsx_stxvl:
ID = Intrinsic::ppc_vsx_stxvl;
break;
case PPC::BI__builtin_vsx_stxvll:
ID = Intrinsic::ppc_vsx_stxvll;
break;
}
llvm::Function *F = CGM.getIntrinsic(ID);
return Builder.CreateCall(F, Ops, "");
}
// Square root
case PPC::BI__builtin_vsx_xvsqrtsp:
case PPC::BI__builtin_vsx_xvsqrtdp: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
if (Builder.getIsFPConstrained()) {
llvm::Function *F = CGM.getIntrinsic(
Intrinsic::experimental_constrained_sqrt, ResultType);
return Builder.CreateConstrainedFPCall(F, X);
} else {
llvm::Function *F = CGM.getIntrinsic(Intrinsic::sqrt, ResultType);
return Builder.CreateCall(F, X);
}
}
// Count leading zeros
case PPC::BI__builtin_altivec_vclzb:
case PPC::BI__builtin_altivec_vclzh:
case PPC::BI__builtin_altivec_vclzw:
case PPC::BI__builtin_altivec_vclzd: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ResultType);
return Builder.CreateCall(F, {X, Undef});
}
case PPC::BI__builtin_altivec_vctzb:
case PPC::BI__builtin_altivec_vctzh:
case PPC::BI__builtin_altivec_vctzw:
case PPC::BI__builtin_altivec_vctzd: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
Function *F = CGM.getIntrinsic(Intrinsic::cttz, ResultType);
return Builder.CreateCall(F, {X, Undef});
}
case PPC::BI__builtin_altivec_vec_replace_elt:
case PPC::BI__builtin_altivec_vec_replace_unaligned: {
// The third argument of vec_replace_elt and vec_replace_unaligned must
// be a compile time constant and will be emitted either to the vinsw
// or vinsd instruction.
ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[2]);
assert(ArgCI &&
"Third Arg to vinsw/vinsd intrinsic must be a constant integer!");
llvm::Type *ResultType = ConvertType(E->getType());
llvm::Function *F = nullptr;
Value *Call = nullptr;
int64_t ConstArg = ArgCI->getSExtValue();
unsigned ArgWidth = Ops[1]->getType()->getPrimitiveSizeInBits();
bool Is32Bit = false;
assert((ArgWidth == 32 || ArgWidth == 64) && "Invalid argument width");
// The input to vec_replace_elt is an element index, not a byte index.
if (BuiltinID == PPC::BI__builtin_altivec_vec_replace_elt)
ConstArg *= ArgWidth / 8;
if (ArgWidth == 32) {
Is32Bit = true;
// When the second argument is 32 bits, it can either be an integer or
// a float. The vinsw intrinsic is used in this case.
F = CGM.getIntrinsic(Intrinsic::ppc_altivec_vinsw);
// Fix the constant according to endianess.
if (getTarget().isLittleEndian())
ConstArg = 12 - ConstArg;
} else {
// When the second argument is 64 bits, it can either be a long long or
// a double. The vinsd intrinsic is used in this case.
F = CGM.getIntrinsic(Intrinsic::ppc_altivec_vinsd);
// Fix the constant for little endian.
if (getTarget().isLittleEndian())
ConstArg = 8 - ConstArg;
}
Ops[2] = ConstantInt::getSigned(Int32Ty, ConstArg);
// Depending on ArgWidth, the input vector could be a float or a double.
// If the input vector is a float type, bitcast the inputs to integers. Or,
// if the input vector is a double, bitcast the inputs to 64-bit integers.
if (!Ops[1]->getType()->isIntegerTy(ArgWidth)) {
Ops[0] = Builder.CreateBitCast(
Ops[0], Is32Bit ? llvm::FixedVectorType::get(Int32Ty, 4)
: llvm::FixedVectorType::get(Int64Ty, 2));
Ops[1] = Builder.CreateBitCast(Ops[1], Is32Bit ? Int32Ty : Int64Ty);
}
// Emit the call to vinsw or vinsd.
Call = Builder.CreateCall(F, Ops);
// Depending on the builtin, bitcast to the approriate result type.
if (BuiltinID == PPC::BI__builtin_altivec_vec_replace_elt &&
!Ops[1]->getType()->isIntegerTy())
return Builder.CreateBitCast(Call, ResultType);
else if (BuiltinID == PPC::BI__builtin_altivec_vec_replace_elt &&
Ops[1]->getType()->isIntegerTy())
return Call;
else
return Builder.CreateBitCast(Call,
llvm::FixedVectorType::get(Int8Ty, 16));
}
case PPC::BI__builtin_altivec_vpopcntb:
case PPC::BI__builtin_altivec_vpopcnth:
case PPC::BI__builtin_altivec_vpopcntw:
case PPC::BI__builtin_altivec_vpopcntd: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
llvm::Function *F = CGM.getIntrinsic(Intrinsic::ctpop, ResultType);
return Builder.CreateCall(F, X);
}
// Copy sign
case PPC::BI__builtin_vsx_xvcpsgnsp:
case PPC::BI__builtin_vsx_xvcpsgndp: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Y = EmitScalarExpr(E->getArg(1));
ID = Intrinsic::copysign;
llvm::Function *F = CGM.getIntrinsic(ID, ResultType);
return Builder.CreateCall(F, {X, Y});
}
// Rounding/truncation
case PPC::BI__builtin_vsx_xvrspip:
case PPC::BI__builtin_vsx_xvrdpip:
case PPC::BI__builtin_vsx_xvrdpim:
case PPC::BI__builtin_vsx_xvrspim:
case PPC::BI__builtin_vsx_xvrdpi:
case PPC::BI__builtin_vsx_xvrspi:
case PPC::BI__builtin_vsx_xvrdpic:
case PPC::BI__builtin_vsx_xvrspic:
case PPC::BI__builtin_vsx_xvrdpiz:
case PPC::BI__builtin_vsx_xvrspiz: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
if (BuiltinID == PPC::BI__builtin_vsx_xvrdpim ||
BuiltinID == PPC::BI__builtin_vsx_xvrspim)
ID = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_floor
: Intrinsic::floor;
else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpi ||
BuiltinID == PPC::BI__builtin_vsx_xvrspi)
ID = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_round
: Intrinsic::round;
else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpic ||
BuiltinID == PPC::BI__builtin_vsx_xvrspic)
ID = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_rint
: Intrinsic::rint;
else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpip ||
BuiltinID == PPC::BI__builtin_vsx_xvrspip)
ID = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_ceil
: Intrinsic::ceil;
else if (BuiltinID == PPC::BI__builtin_vsx_xvrdpiz ||
BuiltinID == PPC::BI__builtin_vsx_xvrspiz)
ID = Builder.getIsFPConstrained()
? Intrinsic::experimental_constrained_trunc
: Intrinsic::trunc;
llvm::Function *F = CGM.getIntrinsic(ID, ResultType);
return Builder.getIsFPConstrained() ? Builder.CreateConstrainedFPCall(F, X)
: Builder.CreateCall(F, X);
}
// Absolute value
case PPC::BI__builtin_vsx_xvabsdp:
case PPC::BI__builtin_vsx_xvabssp: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
llvm::Function *F = CGM.getIntrinsic(Intrinsic::fabs, ResultType);
return Builder.CreateCall(F, X);
}
// FMA variations
case PPC::BI__builtin_vsx_xvmaddadp:
case PPC::BI__builtin_vsx_xvmaddasp:
case PPC::BI__builtin_vsx_xvnmaddadp:
case PPC::BI__builtin_vsx_xvnmaddasp:
case PPC::BI__builtin_vsx_xvmsubadp:
case PPC::BI__builtin_vsx_xvmsubasp:
case PPC::BI__builtin_vsx_xvnmsubadp:
case PPC::BI__builtin_vsx_xvnmsubasp: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Y = EmitScalarExpr(E->getArg(1));
Value *Z = EmitScalarExpr(E->getArg(2));
llvm::Function *F;
if (Builder.getIsFPConstrained())
F = CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, ResultType);
else
F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
switch (BuiltinID) {
case PPC::BI__builtin_vsx_xvmaddadp:
case PPC::BI__builtin_vsx_xvmaddasp:
if (Builder.getIsFPConstrained())
return Builder.CreateConstrainedFPCall(F, {X, Y, Z});
else
return Builder.CreateCall(F, {X, Y, Z});
case PPC::BI__builtin_vsx_xvnmaddadp:
case PPC::BI__builtin_vsx_xvnmaddasp:
if (Builder.getIsFPConstrained())
return Builder.CreateFNeg(
Builder.CreateConstrainedFPCall(F, {X, Y, Z}), "neg");
else
return Builder.CreateFNeg(Builder.CreateCall(F, {X, Y, Z}), "neg");
case PPC::BI__builtin_vsx_xvmsubadp:
case PPC::BI__builtin_vsx_xvmsubasp:
if (Builder.getIsFPConstrained())
return Builder.CreateConstrainedFPCall(
F, {X, Y, Builder.CreateFNeg(Z, "neg")});
else
return Builder.CreateCall(F, {X, Y, Builder.CreateFNeg(Z, "neg")});
case PPC::BI__builtin_vsx_xvnmsubadp:
case PPC::BI__builtin_vsx_xvnmsubasp:
if (Builder.getIsFPConstrained())
return Builder.CreateFNeg(
Builder.CreateConstrainedFPCall(
F, {X, Y, Builder.CreateFNeg(Z, "neg")}),
"neg");
else
return Builder.CreateFNeg(
Builder.CreateCall(F, {X, Y, Builder.CreateFNeg(Z, "neg")}),
"neg");
}
llvm_unreachable("Unknown FMA operation");
return nullptr; // Suppress no-return warning
}
case PPC::BI__builtin_vsx_insertword: {
llvm::Function *F = CGM.getIntrinsic(Intrinsic::ppc_vsx_xxinsertw);
// Third argument is a compile time constant int. It must be clamped to
// to the range [0, 12].
ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[2]);
assert(ArgCI &&
"Third arg to xxinsertw intrinsic must be constant integer");
const int64_t MaxIndex = 12;
int64_t Index = clamp(ArgCI->getSExtValue(), 0, MaxIndex);
// The builtin semantics don't exactly match the xxinsertw instructions
// semantics (which ppc_vsx_xxinsertw follows). The builtin extracts the
// word from the first argument, and inserts it in the second argument. The
// instruction extracts the word from its second input register and inserts
// it into its first input register, so swap the first and second arguments.
std::swap(Ops[0], Ops[1]);
// Need to cast the second argument from a vector of unsigned int to a
// vector of long long.
Ops[1] =
Builder.CreateBitCast(Ops[1], llvm::FixedVectorType::get(Int64Ty, 2));
if (getTarget().isLittleEndian()) {
// Reverse the double words in the vector we will extract from.
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int64Ty, 2));
Ops[0] = Builder.CreateShuffleVector(Ops[0], Ops[0], ArrayRef<int>{1, 0});
// Reverse the index.
Index = MaxIndex - Index;
}
// Intrinsic expects the first arg to be a vector of int.
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int32Ty, 4));
Ops[2] = ConstantInt::getSigned(Int32Ty, Index);
return Builder.CreateCall(F, Ops);
}
case PPC::BI__builtin_vsx_extractuword: {
llvm::Function *F = CGM.getIntrinsic(Intrinsic::ppc_vsx_xxextractuw);
// Intrinsic expects the first argument to be a vector of doublewords.
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int64Ty, 2));
// The second argument is a compile time constant int that needs to
// be clamped to the range [0, 12].
ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[1]);
assert(ArgCI &&
"Second Arg to xxextractuw intrinsic must be a constant integer!");
const int64_t MaxIndex = 12;
int64_t Index = clamp(ArgCI->getSExtValue(), 0, MaxIndex);
if (getTarget().isLittleEndian()) {
// Reverse the index.
Index = MaxIndex - Index;
Ops[1] = ConstantInt::getSigned(Int32Ty, Index);
// Emit the call, then reverse the double words of the results vector.
Value *Call = Builder.CreateCall(F, Ops);
Value *ShuffleCall =
Builder.CreateShuffleVector(Call, Call, ArrayRef<int>{1, 0});
return ShuffleCall;
} else {
Ops[1] = ConstantInt::getSigned(Int32Ty, Index);
return Builder.CreateCall(F, Ops);
}
}
case PPC::BI__builtin_vsx_xxpermdi: {
ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[2]);
assert(ArgCI && "Third arg must be constant integer!");
unsigned Index = ArgCI->getZExtValue();
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int64Ty, 2));
Ops[1] =
Builder.CreateBitCast(Ops[1], llvm::FixedVectorType::get(Int64Ty, 2));
// Account for endianness by treating this as just a shuffle. So we use the
// same indices for both LE and BE in order to produce expected results in
// both cases.
int ElemIdx0 = (Index & 2) >> 1;
int ElemIdx1 = 2 + (Index & 1);
int ShuffleElts[2] = {ElemIdx0, ElemIdx1};
Value *ShuffleCall =
Builder.CreateShuffleVector(Ops[0], Ops[1], ShuffleElts);
QualType BIRetType = E->getType();
auto RetTy = ConvertType(BIRetType);
return Builder.CreateBitCast(ShuffleCall, RetTy);
}
case PPC::BI__builtin_vsx_xxsldwi: {
ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[2]);
assert(ArgCI && "Third argument must be a compile time constant");
unsigned Index = ArgCI->getZExtValue() & 0x3;
Ops[0] =
Builder.CreateBitCast(Ops[0], llvm::FixedVectorType::get(Int32Ty, 4));
Ops[1] =
Builder.CreateBitCast(Ops[1], llvm::FixedVectorType::get(Int32Ty, 4));
// Create a shuffle mask
int ElemIdx0;
int ElemIdx1;
int ElemIdx2;
int ElemIdx3;
if (getTarget().isLittleEndian()) {
// Little endian element N comes from element 8+N-Index of the
// concatenated wide vector (of course, using modulo arithmetic on
// the total number of elements).
ElemIdx0 = (8 - Index) % 8;
ElemIdx1 = (9 - Index) % 8;
ElemIdx2 = (10 - Index) % 8;
ElemIdx3 = (11 - Index) % 8;
} else {
// Big endian ElemIdx<N> = Index + N
ElemIdx0 = Index;
ElemIdx1 = Index + 1;
ElemIdx2 = Index + 2;
ElemIdx3 = Index + 3;
}
int ShuffleElts[4] = {ElemIdx0, ElemIdx1, ElemIdx2, ElemIdx3};
Value *ShuffleCall =
Builder.CreateShuffleVector(Ops[0], Ops[1], ShuffleElts);
QualType BIRetType = E->getType();
auto RetTy = ConvertType(BIRetType);
return Builder.CreateBitCast(ShuffleCall, RetTy);
}
case PPC::BI__builtin_pack_vector_int128: {
bool isLittleEndian = getTarget().isLittleEndian();
Value *UndefValue =
llvm::UndefValue::get(llvm::FixedVectorType::get(Ops[0]->getType(), 2));
Value *Res = Builder.CreateInsertElement(
UndefValue, Ops[0], (uint64_t)(isLittleEndian ? 1 : 0));
Res = Builder.CreateInsertElement(Res, Ops[1],
(uint64_t)(isLittleEndian ? 0 : 1));
return Builder.CreateBitCast(Res, ConvertType(E->getType()));
}
case PPC::BI__builtin_unpack_vector_int128: {
ConstantInt *Index = cast<ConstantInt>(Ops[1]);
Value *Unpacked = Builder.CreateBitCast(
Ops[0], llvm::FixedVectorType::get(ConvertType(E->getType()), 2));
if (getTarget().isLittleEndian())
Index = ConstantInt::get(Index->getType(), 1 - Index->getZExtValue());
return Builder.CreateExtractElement(Unpacked, Index);
}
// The PPC MMA builtins take a pointer to a __vector_quad as an argument.
// Some of the MMA instructions accumulate their result into an existing
// accumulator whereas the others generate a new accumulator. So we need to
// use custom code generation to expand a builtin call with a pointer to a
// load (if the corresponding instruction accumulates its result) followed by
// the call to the intrinsic and a store of the result.
#define CUSTOM_BUILTIN(Name, Types, Accumulate) \
case PPC::BI__builtin_##Name:
#include "clang/Basic/BuiltinsPPC.def"
{
// The first argument of these two builtins is a pointer used to store their
// result. However, the llvm intrinsics return their result in multiple
// return values. So, here we emit code extracting these values from the
// intrinsic results and storing them using that pointer.
if (BuiltinID == PPC::BI__builtin_mma_disassemble_acc ||
BuiltinID == PPC::BI__builtin_vsx_disassemble_pair) {
unsigned NumVecs = 2;
auto Intrinsic = Intrinsic::ppc_vsx_disassemble_pair;
if (BuiltinID == PPC::BI__builtin_mma_disassemble_acc) {
NumVecs = 4;
Intrinsic = Intrinsic::ppc_mma_disassemble_acc;
}
llvm::Function *F = CGM.getIntrinsic(Intrinsic);
Address Addr = EmitPointerWithAlignment(E->getArg(1));
Value *Vec = Builder.CreateLoad(Addr);
Value *Call = Builder.CreateCall(F, {Vec});
llvm::Type *VTy = llvm::FixedVectorType::get(Int8Ty, 16);
Value *Ptr = Builder.CreateBitCast(Ops[0], VTy->getPointerTo());
for (unsigned i=0; i<NumVecs; i++) {
Value *Vec = Builder.CreateExtractValue(Call, i);
llvm::ConstantInt* Index = llvm::ConstantInt::get(IntTy, i);
Value *GEP = Builder.CreateInBoundsGEP(Ptr, Index);
Builder.CreateAlignedStore(Vec, GEP, MaybeAlign(16));
}
return Call;
}
bool Accumulate;
switch (BuiltinID) {
#define CUSTOM_BUILTIN(Name, Types, Acc) \
case PPC::BI__builtin_##Name: \
ID = Intrinsic::ppc_##Name; \
Accumulate = Acc; \
break;
#include "clang/Basic/BuiltinsPPC.def"
}
if (BuiltinID == PPC::BI__builtin_vsx_lxvp ||
BuiltinID == PPC::BI__builtin_vsx_stxvp) {
if (BuiltinID == PPC::BI__builtin_vsx_lxvp) {
Ops[1] = Builder.CreateBitCast(Ops[1], Int8PtrTy);
Ops[0] = Builder.CreateGEP(Ops[1], Ops[0]);
} else {
Ops[2] = Builder.CreateBitCast(Ops[2], Int8PtrTy);
Ops[1] = Builder.CreateGEP(Ops[2], Ops[1]);
}
Ops.pop_back();
llvm::Function *F = CGM.getIntrinsic(ID);
return Builder.CreateCall(F, Ops, "");
}
SmallVector<Value*, 4> CallOps;
if (Accumulate) {
Address Addr = EmitPointerWithAlignment(E->getArg(0));
Value *Acc = Builder.CreateLoad(Addr);
CallOps.push_back(Acc);
}
for (unsigned i=1; i<Ops.size(); i++)
CallOps.push_back(Ops[i]);
llvm::Function *F = CGM.getIntrinsic(ID);
Value *Call = Builder.CreateCall(F, CallOps);
return Builder.CreateAlignedStore(Call, Ops[0], MaybeAlign(64));
}
}
}
namespace {
// If \p E is not null pointer, insert address space cast to match return
// type of \p E if necessary.
Value *EmitAMDGPUDispatchPtr(CodeGenFunction &CGF,
const CallExpr *E = nullptr) {
auto *F = CGF.CGM.getIntrinsic(Intrinsic::amdgcn_dispatch_ptr);
auto *Call = CGF.Builder.CreateCall(F);
Call->addAttribute(
AttributeList::ReturnIndex,
Attribute::getWithDereferenceableBytes(Call->getContext(), 64));
Call->addAttribute(AttributeList::ReturnIndex,
Attribute::getWithAlignment(Call->getContext(), Align(4)));
if (!E)
return Call;
QualType BuiltinRetType = E->getType();
auto *RetTy = cast<llvm::PointerType>(CGF.ConvertType(BuiltinRetType));
if (RetTy == Call->getType())
return Call;
return CGF.Builder.CreateAddrSpaceCast(Call, RetTy);
}
// \p Index is 0, 1, and 2 for x, y, and z dimension, respectively.
Value *EmitAMDGPUWorkGroupSize(CodeGenFunction &CGF, unsigned Index) {
const unsigned XOffset = 4;
auto *DP = EmitAMDGPUDispatchPtr(CGF);
// Indexing the HSA kernel_dispatch_packet struct.
auto *Offset = llvm::ConstantInt::get(CGF.Int32Ty, XOffset + Index * 2);
auto *GEP = CGF.Builder.CreateGEP(DP, Offset);
auto *DstTy =
CGF.Int16Ty->getPointerTo(GEP->getType()->getPointerAddressSpace());
auto *Cast = CGF.Builder.CreateBitCast(GEP, DstTy);
auto *LD = CGF.Builder.CreateLoad(Address(Cast, CharUnits::fromQuantity(2)));
llvm::MDBuilder MDHelper(CGF.getLLVMContext());
llvm::MDNode *RNode = MDHelper.createRange(APInt(16, 1),
APInt(16, CGF.getTarget().getMaxOpenCLWorkGroupSize() + 1));
LD->setMetadata(llvm::LLVMContext::MD_range, RNode);
LD->setMetadata(llvm::LLVMContext::MD_invariant_load,
llvm::MDNode::get(CGF.getLLVMContext(), None));
return LD;
}
// \p Index is 0, 1, and 2 for x, y, and z dimension, respectively.
Value *EmitAMDGPUGridSize(CodeGenFunction &CGF, unsigned Index) {
const unsigned XOffset = 12;
auto *DP = EmitAMDGPUDispatchPtr(CGF);
// Indexing the HSA kernel_dispatch_packet struct.
auto *Offset = llvm::ConstantInt::get(CGF.Int32Ty, XOffset + Index * 4);
auto *GEP = CGF.Builder.CreateGEP(DP, Offset);
auto *DstTy =
CGF.Int32Ty->getPointerTo(GEP->getType()->getPointerAddressSpace());
auto *Cast = CGF.Builder.CreateBitCast(GEP, DstTy);
auto *LD = CGF.Builder.CreateLoad(Address(Cast, CharUnits::fromQuantity(4)));
LD->setMetadata(llvm::LLVMContext::MD_invariant_load,
llvm::MDNode::get(CGF.getLLVMContext(), None));
return LD;
}
} // namespace
// For processing memory ordering and memory scope arguments of various
// amdgcn builtins.
// \p Order takes a C++11 comptabile memory-ordering specifier and converts
// it into LLVM's memory ordering specifier using atomic C ABI, and writes
// to \p AO. \p Scope takes a const char * and converts it into AMDGCN
// specific SyncScopeID and writes it to \p SSID.
bool CodeGenFunction::ProcessOrderScopeAMDGCN(Value *Order, Value *Scope,
llvm::AtomicOrdering &AO,
llvm::SyncScope::ID &SSID) {
if (isa<llvm::ConstantInt>(Order)) {
int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
// Map C11/C++11 memory ordering to LLVM memory ordering
switch (static_cast<llvm::AtomicOrderingCABI>(ord)) {
case llvm::AtomicOrderingCABI::acquire:
AO = llvm::AtomicOrdering::Acquire;
break;
case llvm::AtomicOrderingCABI::release:
AO = llvm::AtomicOrdering::Release;
break;
case llvm::AtomicOrderingCABI::acq_rel:
AO = llvm::AtomicOrdering::AcquireRelease;
break;
case llvm::AtomicOrderingCABI::seq_cst:
AO = llvm::AtomicOrdering::SequentiallyConsistent;
break;
case llvm::AtomicOrderingCABI::consume:
case llvm::AtomicOrderingCABI::relaxed:
break;
}
StringRef scp;
llvm::getConstantStringInfo(Scope, scp);
SSID = getLLVMContext().getOrInsertSyncScopeID(scp);
return true;
}
return false;
}
Value *CodeGenFunction::EmitAMDGPUBuiltinExpr(unsigned BuiltinID,
const CallExpr *E) {
llvm::AtomicOrdering AO = llvm::AtomicOrdering::SequentiallyConsistent;
llvm::SyncScope::ID SSID;
switch (BuiltinID) {
case AMDGPU::BI__builtin_amdgcn_div_scale:
case AMDGPU::BI__builtin_amdgcn_div_scalef: {
// Translate from the intrinsics's struct return to the builtin's out
// argument.
Address FlagOutPtr = EmitPointerWithAlignment(E->getArg(3));
llvm::Value *X = EmitScalarExpr(E->getArg(0));
llvm::Value *Y = EmitScalarExpr(E->getArg(1));
llvm::Value *Z = EmitScalarExpr(E->getArg(2));
llvm::Function *Callee = CGM.getIntrinsic(Intrinsic::amdgcn_div_scale,
X->getType());
llvm::Value *Tmp = Builder.CreateCall(Callee, {X, Y, Z});
llvm::Value *Result = Builder.CreateExtractValue(Tmp, 0);
llvm::Value *Flag = Builder.CreateExtractValue(Tmp, 1);
llvm::Type *RealFlagType
= FlagOutPtr.getPointer()->getType()->getPointerElementType();
llvm::Value *FlagExt = Builder.CreateZExt(Flag, RealFlagType);
Builder.CreateStore(FlagExt, FlagOutPtr);
return Result;
}
case AMDGPU::BI__builtin_amdgcn_div_fmas:
case AMDGPU::BI__builtin_amdgcn_div_fmasf: {
llvm::Value *Src0 = EmitScalarExpr(E->getArg(0));
llvm::Value *Src1 = EmitScalarExpr(E->getArg(1));
llvm::Value *Src2 = EmitScalarExpr(E->getArg(2));
llvm::Value *Src3 = EmitScalarExpr(E->getArg(3));
llvm::Function *F = CGM.getIntrinsic(Intrinsic::amdgcn_div_fmas,
Src0->getType());
llvm::Value *Src3ToBool = Builder.CreateIsNotNull(Src3);
return Builder.CreateCall(F, {Src0, Src1, Src2, Src3ToBool});
}
case AMDGPU::BI__builtin_amdgcn_ds_swizzle:
return emitBinaryBuiltin(*this, E, Intrinsic::amdgcn_ds_swizzle);
case AMDGPU::BI__builtin_amdgcn_mov_dpp8:
return emitBinaryBuiltin(*this, E, Intrinsic::amdgcn_mov_dpp8);
case AMDGPU::BI__builtin_amdgcn_mov_dpp:
case AMDGPU::BI__builtin_amdgcn_update_dpp: {
llvm::SmallVector<llvm::Value *, 6> Args;
for (unsigned I = 0; I != E->getNumArgs(); ++I)
Args.push_back(EmitScalarExpr(E->getArg(I)));
assert(Args.size() == 5 || Args.size() == 6);
if (Args.size() == 5)
Args.insert(Args.begin(), llvm::UndefValue::get(Args[0]->getType()));
Function *F =
CGM.getIntrinsic(Intrinsic::amdgcn_update_dpp, Args[0]->getType());
return Builder.CreateCall(F, Args);
}
case AMDGPU::BI__builtin_amdgcn_div_fixup:
case AMDGPU::BI__builtin_amdgcn_div_fixupf:
case AMDGPU::BI__builtin_amdgcn_div_fixuph:
return emitTernaryBuiltin(*this, E, Intrinsic::amdgcn_div_fixup);
case AMDGPU::BI__builtin_amdgcn_trig_preop:
case AMDGPU::BI__builtin_amdgcn_trig_preopf:
return emitFPIntBuiltin(*this, E, Intrinsic::amdgcn_trig_preop);
case AMDGPU::BI__builtin_amdgcn_rcp:
case AMDGPU::BI__builtin_amdgcn_rcpf:
case AMDGPU::BI__builtin_amdgcn_rcph:
return emitUnaryBuiltin(*this, E, Intrinsic::amdgcn_rcp);
case AMDGPU::BI__builtin_amdgcn_sqrt:
case AMDGPU::BI__builtin_amdgcn_sqrtf:
case AMDGPU::BI__builtin_amdgcn_sqrth:
return emitUnaryBuiltin(*this, E, Intrinsic::amdgcn_sqrt);
case AMDGPU::BI__builtin_amdgcn_rsq:
case AMDGPU::BI__builtin_amdgcn_rsqf:
case AMDGPU::BI__builtin_amdgcn_rsqh:
return emitUnaryBuiltin(*this, E, Intrinsic::amdgcn_rsq);
case AMDGPU::BI__builtin_amdgcn_rsq_clamp:
case AMDGPU::BI__builtin_amdgcn_rsq_clampf:
return emitUnaryBuiltin(*this, E, Intrinsic::amdgcn_rsq_clamp);
case AMDGPU::BI__builtin_amdgcn_sinf:
case AMDGPU::BI__builtin_amdgcn_sinh:
return emitUnaryBuiltin(*this, E, Intrinsic::amdgcn_sin);
case AMDGPU::BI__builtin_amdgcn_cosf:
case AMDGPU::BI__builtin_amdgcn_cosh:
return emitUnaryBuiltin(*this, E, Intrinsic::amdgcn_cos);
case AMDGPU::BI__builtin_amdgcn_dispatch_ptr:
return EmitAMDGPUDispatchPtr(*this, E);
case AMDGPU::BI__builtin_amdgcn_log_clampf:
return emitUnaryBuiltin(*this, E, Intrinsic::amdgcn_log_clamp);
case AMDGPU::BI__builtin_amdgcn_ldexp:
case AMDGPU::BI__builtin_amdgcn_ldexpf:
case AMDGPU::BI__builtin_amdgcn_ldexph:
return emitFPIntBuiltin(*this, E, Intrinsic::amdgcn_ldexp);
case AMDGPU::BI__builtin_amdgcn_frexp_mant:
case AMDGPU::BI__builtin_amdgcn_frexp_mantf:
case AMDGPU::BI__builtin_amdgcn_frexp_manth:
return emitUnaryBuiltin(*this, E, Intrinsic::amdgcn_frexp_mant);
case AMDGPU::BI__builtin_amdgcn_frexp_exp:
case AMDGPU::BI__builtin_amdgcn_frexp_expf: {
Value *Src0 = EmitScalarExpr(E->getArg(0));
Function *F = CGM.getIntrinsic(Intrinsic::amdgcn_frexp_exp,
{ Builder.getInt32Ty(), Src0->getType() });
return Builder.CreateCall(F, Src0);
}
case AMDGPU::BI__builtin_amdgcn_frexp_exph: {
Value *Src0 = EmitScalarExpr(E->getArg(0));
Function *F = CGM.getIntrinsic(Intrinsic::amdgcn_frexp_exp,
{ Builder.getInt16Ty(), Src0->getType() });
return Builder.CreateCall(F, Src0);
}
case AMDGPU::BI__builtin_amdgcn_fract:
case AMDGPU::BI__builtin_amdgcn_fractf:
case AMDGPU::BI__builtin_amdgcn_fracth:
return emitUnaryBuiltin(*this, E, Intrinsic::amdgcn_fract);
case AMDGPU::BI__builtin_amdgcn_lerp:
return emitTernaryBuiltin(*this, E, Intrinsic::amdgcn_lerp);
case AMDGPU::BI__builtin_amdgcn_ubfe:
return emitTernaryBuiltin(*this, E, Intrinsic::amdgcn_ubfe);
case AMDGPU::BI__builtin_amdgcn_sbfe:
return emitTernaryBuiltin(*this, E, Intrinsic::amdgcn_sbfe);
case AMDGPU::BI__builtin_amdgcn_uicmp:
case AMDGPU::BI__builtin_amdgcn_uicmpl:
case AMDGPU::BI__builtin_amdgcn_sicmp:
case AMDGPU::BI__builtin_amdgcn_sicmpl: {
llvm::Value *Src0 = EmitScalarExpr(E->getArg(0));
llvm::Value *Src1 = EmitScalarExpr(E->getArg(1));
llvm::Value *Src2 = EmitScalarExpr(E->getArg(2));
// FIXME-GFX10: How should 32 bit mask be handled?
Function *F = CGM.getIntrinsic(Intrinsic::amdgcn_icmp,
{ Builder.getInt64Ty(), Src0->getType() });
return Builder.CreateCall(F, { Src0, Src1, Src2 });
}
case AMDGPU::BI__builtin_amdgcn_fcmp:
case AMDGPU::BI__builtin_amdgcn_fcmpf: {
llvm::Value *Src0 = EmitScalarExpr(E->getArg(0));
llvm::Value *Src1 = EmitScalarExpr(E->getArg(1));
llvm::Value *Src2 = EmitScalarExpr(E->getArg(2));
// FIXME-GFX10: How should 32 bit mask be handled?
Function *F = CGM.getIntrinsic(Intrinsic::amdgcn_fcmp,
{ Builder.getInt64Ty(), Src0->getType() });
return Builder.CreateCall(F, { Src0, Src1, Src2 });
}
case AMDGPU::BI__builtin_amdgcn_class:
case AMDGPU::BI__builtin_amdgcn_classf:
case AMDGPU::BI__builtin_amdgcn_classh:
return emitFPIntBuiltin(*this, E, Intrinsic::amdgcn_class);
case AMDGPU::BI__builtin_amdgcn_fmed3f:
case AMDGPU::BI__builtin_amdgcn_fmed3h:
return emitTernaryBuiltin(*this, E, Intrinsic::amdgcn_fmed3);
case AMDGPU::BI__builtin_amdgcn_ds_append:
case AMDGPU::BI__builtin_amdgcn_ds_consume: {
Intrinsic::ID Intrin = BuiltinID == AMDGPU::BI__builtin_amdgcn_ds_append ?
Intrinsic::amdgcn_ds_append : Intrinsic::amdgcn_ds_consume;
Value *Src0 = EmitScalarExpr(E->getArg(0));
Function *F = CGM.getIntrinsic(Intrin, { Src0->getType() });
return Builder.CreateCall(F, { Src0, Builder.getFalse() });
}
case AMDGPU::BI__builtin_amdgcn_ds_faddf:
case AMDGPU::BI__builtin_amdgcn_ds_fminf:
case AMDGPU::BI__builtin_amdgcn_ds_fmaxf: {
Intrinsic::ID Intrin;
switch (BuiltinID) {
case AMDGPU::BI__builtin_amdgcn_ds_faddf:
Intrin = Intrinsic::amdgcn_ds_fadd;
break;
case AMDGPU::BI__builtin_amdgcn_ds_fminf:
Intrin = Intrinsic::amdgcn_ds_fmin;
break;
case AMDGPU::BI__builtin_amdgcn_ds_fmaxf:
Intrin = Intrinsic::amdgcn_ds_fmax;
break;
}
llvm::Value *Src0 = EmitScalarExpr(E->getArg(0));
llvm::Value *Src1 = EmitScalarExpr(E->getArg(1));
llvm::Value *Src2 = EmitScalarExpr(E->getArg(2));
llvm::Value *Src3 = EmitScalarExpr(E->getArg(3));
llvm::Value *Src4 = EmitScalarExpr(E->getArg(4));
llvm::Function *F = CGM.getIntrinsic(Intrin, { Src1->getType() });
llvm::FunctionType *FTy = F->getFunctionType();
llvm::Type *PTy = FTy->getParamType(0);
Src0 = Builder.CreatePointerBitCastOrAddrSpaceCast(Src0, PTy);
return Builder.CreateCall(F, { Src0, Src1, Src2, Src3, Src4 });
}
case AMDGPU::BI__builtin_amdgcn_read_exec: {
CallInst *CI = cast<CallInst>(
EmitSpecialRegisterBuiltin(*this, E, Int64Ty, Int64Ty, NormalRead, "exec"));
CI->setConvergent();
return CI;
}
case AMDGPU::BI__builtin_amdgcn_read_exec_lo:
case AMDGPU::BI__builtin_amdgcn_read_exec_hi: {
StringRef RegName = BuiltinID == AMDGPU::BI__builtin_amdgcn_read_exec_lo ?
"exec_lo" : "exec_hi";
CallInst *CI = cast<CallInst>(
EmitSpecialRegisterBuiltin(*this, E, Int32Ty, Int32Ty, NormalRead, RegName));
CI->setConvergent();
return CI;
}
// amdgcn workitem
case AMDGPU::BI__builtin_amdgcn_workitem_id_x:
return emitRangedBuiltin(*this, Intrinsic::amdgcn_workitem_id_x, 0, 1024);
case AMDGPU::BI__builtin_amdgcn_workitem_id_y:
return emitRangedBuiltin(*this, Intrinsic::amdgcn_workitem_id_y, 0, 1024);
case AMDGPU::BI__builtin_amdgcn_workitem_id_z:
return emitRangedBuiltin(*this, Intrinsic::amdgcn_workitem_id_z, 0, 1024);
// amdgcn workgroup size
case AMDGPU::BI__builtin_amdgcn_workgroup_size_x:
return EmitAMDGPUWorkGroupSize(*this, 0);
case AMDGPU::BI__builtin_amdgcn_workgroup_size_y:
return EmitAMDGPUWorkGroupSize(*this, 1);
case AMDGPU::BI__builtin_amdgcn_workgroup_size_z:
return EmitAMDGPUWorkGroupSize(*this, 2);
// amdgcn grid size
case AMDGPU::BI__builtin_amdgcn_grid_size_x:
return EmitAMDGPUGridSize(*this, 0);
case AMDGPU::BI__builtin_amdgcn_grid_size_y:
return EmitAMDGPUGridSize(*this, 1);
case AMDGPU::BI__builtin_amdgcn_grid_size_z:
return EmitAMDGPUGridSize(*this, 2);
// r600 intrinsics
case AMDGPU::BI__builtin_r600_recipsqrt_ieee:
case AMDGPU::BI__builtin_r600_recipsqrt_ieeef:
return emitUnaryBuiltin(*this, E, Intrinsic::r600_recipsqrt_ieee);
case AMDGPU::BI__builtin_r600_read_tidig_x:
return emitRangedBuiltin(*this, Intrinsic::r600_read_tidig_x, 0, 1024);
case AMDGPU::BI__builtin_r600_read_tidig_y:
return emitRangedBuiltin(*this, Intrinsic::r600_read_tidig_y, 0, 1024);
case AMDGPU::BI__builtin_r600_read_tidig_z:
return emitRangedBuiltin(*this, Intrinsic::r600_read_tidig_z, 0, 1024);
case AMDGPU::BI__builtin_amdgcn_alignbit: {
llvm::Value *Src0 = EmitScalarExpr(E->getArg(0));
llvm::Value *Src1 = EmitScalarExpr(E->getArg(1));
llvm::Value *Src2 = EmitScalarExpr(E->getArg(2));
Function *F = CGM.getIntrinsic(Intrinsic::fshr, Src0->getType());
return Builder.CreateCall(F, { Src0, Src1, Src2 });
}
case AMDGPU::BI__builtin_amdgcn_fence: {
if (ProcessOrderScopeAMDGCN(EmitScalarExpr(E->getArg(0)),
EmitScalarExpr(E->getArg(1)), AO, SSID))
return Builder.CreateFence(AO, SSID);
LLVM_FALLTHROUGH;
}
case AMDGPU::BI__builtin_amdgcn_atomic_inc32:
case AMDGPU::BI__builtin_amdgcn_atomic_inc64:
case AMDGPU::BI__builtin_amdgcn_atomic_dec32:
case AMDGPU::BI__builtin_amdgcn_atomic_dec64: {
unsigned BuiltinAtomicOp;
llvm::Type *ResultType = ConvertType(E->getType());
switch (BuiltinID) {
case AMDGPU::BI__builtin_amdgcn_atomic_inc32:
case AMDGPU::BI__builtin_amdgcn_atomic_inc64:
BuiltinAtomicOp = Intrinsic::amdgcn_atomic_inc;
break;
case AMDGPU::BI__builtin_amdgcn_atomic_dec32:
case AMDGPU::BI__builtin_amdgcn_atomic_dec64:
BuiltinAtomicOp = Intrinsic::amdgcn_atomic_dec;
break;
}
Value *Ptr = EmitScalarExpr(E->getArg(0));
Value *Val = EmitScalarExpr(E->getArg(1));
llvm::Function *F =
CGM.getIntrinsic(BuiltinAtomicOp, {ResultType, Ptr->getType()});
if (ProcessOrderScopeAMDGCN(EmitScalarExpr(E->getArg(2)),
EmitScalarExpr(E->getArg(3)), AO, SSID)) {
// llvm.amdgcn.atomic.inc and llvm.amdgcn.atomic.dec expects ordering and
// scope as unsigned values
Value *MemOrder = Builder.getInt32(static_cast<int>(AO));
Value *MemScope = Builder.getInt32(static_cast<int>(SSID));
QualType PtrTy = E->getArg(0)->IgnoreImpCasts()->getType();
bool Volatile =
PtrTy->castAs<PointerType>()->getPointeeType().isVolatileQualified();
Value *IsVolatile = Builder.getInt1(static_cast<bool>(Volatile));
return Builder.CreateCall(F, {Ptr, Val, MemOrder, MemScope, IsVolatile});
}
LLVM_FALLTHROUGH;
}
default:
return nullptr;
}
}
/// Handle a SystemZ function in which the final argument is a pointer
/// to an int that receives the post-instruction CC value. At the LLVM level
/// this is represented as a function that returns a {result, cc} pair.
static Value *EmitSystemZIntrinsicWithCC(CodeGenFunction &CGF,
unsigned IntrinsicID,
const CallExpr *E) {
unsigned NumArgs = E->getNumArgs() - 1;
SmallVector<Value *, 8> Args(NumArgs);
for (unsigned I = 0; I < NumArgs; ++I)
Args[I] = CGF.EmitScalarExpr(E->getArg(I));
Address CCPtr = CGF.EmitPointerWithAlignment(E->getArg(NumArgs));
Function *F = CGF.CGM.getIntrinsic(IntrinsicID);
Value *Call = CGF.Builder.CreateCall(F, Args);
Value *CC = CGF.Builder.CreateExtractValue(Call, 1);
CGF.Builder.CreateStore(CC, CCPtr);
return CGF.Builder.CreateExtractValue(Call, 0);
}
Value *CodeGenFunction::EmitSystemZBuiltinExpr(unsigned BuiltinID,
const CallExpr *E) {
switch (BuiltinID) {
case SystemZ::BI__builtin_tbegin: {
Value *TDB = EmitScalarExpr(E->getArg(0));
Value *Control = llvm::ConstantInt::get(Int32Ty, 0xff0c);
Function *F = CGM.getIntrinsic(Intrinsic::s390_tbegin);
return Builder.CreateCall(F, {TDB, Control});
}
case SystemZ::BI__builtin_tbegin_nofloat: {
Value *TDB = EmitScalarExpr(E->getArg(0));
Value *Control = llvm::ConstantInt::get(Int32Ty, 0xff0c);
Function *F = CGM.getIntrinsic(Intrinsic::s390_tbegin_nofloat);
return Builder.CreateCall(F, {TDB, Control});
}
case SystemZ::BI__builtin_tbeginc: {
Value *TDB = llvm::ConstantPointerNull::get(Int8PtrTy);
Value *Control = llvm::ConstantInt::get(Int32Ty, 0xff08);
Function *F = CGM.getIntrinsic(Intrinsic::s390_tbeginc);
return Builder.CreateCall(F, {TDB, Control});
}
case SystemZ::BI__builtin_tabort: {
Value *Data = EmitScalarExpr(E->getArg(0));
Function *F = CGM.getIntrinsic(Intrinsic::s390_tabort);
return Builder.CreateCall(F, Builder.CreateSExt(Data, Int64Ty, "tabort"));
}
case SystemZ::BI__builtin_non_tx_store: {
Value *Address = EmitScalarExpr(E->getArg(0));
Value *Data = EmitScalarExpr(E->getArg(1));
Function *F = CGM.getIntrinsic(Intrinsic::s390_ntstg);
return Builder.CreateCall(F, {Data, Address});
}
// Vector builtins. Note that most vector builtins are mapped automatically
// to target-specific LLVM intrinsics. The ones handled specially here can
// be represented via standard LLVM IR, which is preferable to enable common
// LLVM optimizations.
case SystemZ::BI__builtin_s390_vpopctb:
case SystemZ::BI__builtin_s390_vpopcth:
case SystemZ::BI__builtin_s390_vpopctf:
case SystemZ::BI__builtin_s390_vpopctg: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Function *F = CGM.getIntrinsic(Intrinsic::ctpop, ResultType);
return Builder.CreateCall(F, X);
}
case SystemZ::BI__builtin_s390_vclzb:
case SystemZ::BI__builtin_s390_vclzh:
case SystemZ::BI__builtin_s390_vclzf:
case SystemZ::BI__builtin_s390_vclzg: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ResultType);
return Builder.CreateCall(F, {X, Undef});
}
case SystemZ::BI__builtin_s390_vctzb:
case SystemZ::BI__builtin_s390_vctzh:
case SystemZ::BI__builtin_s390_vctzf:
case SystemZ::BI__builtin_s390_vctzg: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
Function *F = CGM.getIntrinsic(Intrinsic::cttz, ResultType);
return Builder.CreateCall(F, {X, Undef});
}
case SystemZ::BI__builtin_s390_vfsqsb:
case SystemZ::BI__builtin_s390_vfsqdb: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
if (Builder.getIsFPConstrained()) {
Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_sqrt, ResultType);
return Builder.CreateConstrainedFPCall(F, { X });
} else {
Function *F = CGM.getIntrinsic(Intrinsic::sqrt, ResultType);
return Builder.CreateCall(F, X);
}
}
case SystemZ::BI__builtin_s390_vfmasb:
case SystemZ::BI__builtin_s390_vfmadb: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Y = EmitScalarExpr(E->getArg(1));
Value *Z = EmitScalarExpr(E->getArg(2));
if (Builder.getIsFPConstrained()) {
Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, ResultType);
return Builder.CreateConstrainedFPCall(F, {X, Y, Z});
} else {
Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
return Builder.CreateCall(F, {X, Y, Z});
}
}
case SystemZ::BI__builtin_s390_vfmssb:
case SystemZ::BI__builtin_s390_vfmsdb: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Y = EmitScalarExpr(E->getArg(1));
Value *Z = EmitScalarExpr(E->getArg(2));
if (Builder.getIsFPConstrained()) {
Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, ResultType);
return Builder.CreateConstrainedFPCall(F, {X, Y, Builder.CreateFNeg(Z, "neg")});
} else {
Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
return Builder.CreateCall(F, {X, Y, Builder.CreateFNeg(Z, "neg")});
}
}
case SystemZ::BI__builtin_s390_vfnmasb:
case SystemZ::BI__builtin_s390_vfnmadb: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Y = EmitScalarExpr(E->getArg(1));
Value *Z = EmitScalarExpr(E->getArg(2));
if (Builder.getIsFPConstrained()) {
Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, ResultType);
return Builder.CreateFNeg(Builder.CreateConstrainedFPCall(F, {X, Y, Z}), "neg");
} else {
Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
return Builder.CreateFNeg(Builder.CreateCall(F, {X, Y, Z}), "neg");
}
}
case SystemZ::BI__builtin_s390_vfnmssb:
case SystemZ::BI__builtin_s390_vfnmsdb: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Y = EmitScalarExpr(E->getArg(1));
Value *Z = EmitScalarExpr(E->getArg(2));
if (Builder.getIsFPConstrained()) {
Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, ResultType);
Value *NegZ = Builder.CreateFNeg(Z, "sub");
return Builder.CreateFNeg(Builder.CreateConstrainedFPCall(F, {X, Y, NegZ}));
} else {
Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
Value *NegZ = Builder.CreateFNeg(Z, "neg");
return Builder.CreateFNeg(Builder.CreateCall(F, {X, Y, NegZ}));
}
}
case SystemZ::BI__builtin_s390_vflpsb:
case SystemZ::BI__builtin_s390_vflpdb: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Function *F = CGM.getIntrinsic(Intrinsic::fabs, ResultType);
return Builder.CreateCall(F, X);
}
case SystemZ::BI__builtin_s390_vflnsb:
case SystemZ::BI__builtin_s390_vflndb: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Function *F = CGM.getIntrinsic(Intrinsic::fabs, ResultType);
return Builder.CreateFNeg(Builder.CreateCall(F, X), "neg");
}
case SystemZ::BI__builtin_s390_vfisb:
case SystemZ::BI__builtin_s390_vfidb: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
// Constant-fold the M4 and M5 mask arguments.
llvm::APSInt M4 = *E->getArg(1)->getIntegerConstantExpr(getContext());
llvm::APSInt M5 = *E->getArg(2)->getIntegerConstantExpr(getContext());
// Check whether this instance can be represented via a LLVM standard
// intrinsic. We only support some combinations of M4 and M5.
Intrinsic::ID ID = Intrinsic::not_intrinsic;
Intrinsic::ID CI;
switch (M4.getZExtValue()) {
default: break;
case 0: // IEEE-inexact exception allowed
switch (M5.getZExtValue()) {
default: break;
case 0: ID = Intrinsic::rint;
CI = Intrinsic::experimental_constrained_rint; break;
}
break;
case 4: // IEEE-inexact exception suppressed
switch (M5.getZExtValue()) {
default: break;
case 0: ID = Intrinsic::nearbyint;
CI = Intrinsic::experimental_constrained_nearbyint; break;
case 1: ID = Intrinsic::round;
CI = Intrinsic::experimental_constrained_round; break;
case 5: ID = Intrinsic::trunc;
CI = Intrinsic::experimental_constrained_trunc; break;
case 6: ID = Intrinsic::ceil;
CI = Intrinsic::experimental_constrained_ceil; break;
case 7: ID = Intrinsic::floor;
CI = Intrinsic::experimental_constrained_floor; break;
}
break;
}
if (ID != Intrinsic::not_intrinsic) {
if (Builder.getIsFPConstrained()) {
Function *F = CGM.getIntrinsic(CI, ResultType);
return Builder.CreateConstrainedFPCall(F, X);
} else {
Function *F = CGM.getIntrinsic(ID, ResultType);
return Builder.CreateCall(F, X);
}
}
switch (BuiltinID) { // FIXME: constrained version?
case SystemZ::BI__builtin_s390_vfisb: ID = Intrinsic::s390_vfisb; break;
case SystemZ::BI__builtin_s390_vfidb: ID = Intrinsic::s390_vfidb; break;
default: llvm_unreachable("Unknown BuiltinID");
}
Function *F = CGM.getIntrinsic(ID);
Value *M4Value = llvm::ConstantInt::get(getLLVMContext(), M4);
Value *M5Value = llvm::ConstantInt::get(getLLVMContext(), M5);
return Builder.CreateCall(F, {X, M4Value, M5Value});
}
case SystemZ::BI__builtin_s390_vfmaxsb:
case SystemZ::BI__builtin_s390_vfmaxdb: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Y = EmitScalarExpr(E->getArg(1));
// Constant-fold the M4 mask argument.
llvm::APSInt M4 = *E->getArg(2)->getIntegerConstantExpr(getContext());
// Check whether this instance can be represented via a LLVM standard
// intrinsic. We only support some values of M4.
Intrinsic::ID ID = Intrinsic::not_intrinsic;
Intrinsic::ID CI;
switch (M4.getZExtValue()) {
default: break;
case 4: ID = Intrinsic::maxnum;
CI = Intrinsic::experimental_constrained_maxnum; break;
}
if (ID != Intrinsic::not_intrinsic) {
if (Builder.getIsFPConstrained()) {
Function *F = CGM.getIntrinsic(CI, ResultType);
return Builder.CreateConstrainedFPCall(F, {X, Y});
} else {
Function *F = CGM.getIntrinsic(ID, ResultType);
return Builder.CreateCall(F, {X, Y});
}
}
switch (BuiltinID) {
case SystemZ::BI__builtin_s390_vfmaxsb: ID = Intrinsic::s390_vfmaxsb; break;
case SystemZ::BI__builtin_s390_vfmaxdb: ID = Intrinsic::s390_vfmaxdb; break;
default: llvm_unreachable("Unknown BuiltinID");
}
Function *F = CGM.getIntrinsic(ID);
Value *M4Value = llvm::ConstantInt::get(getLLVMContext(), M4);
return Builder.CreateCall(F, {X, Y, M4Value});
}
case SystemZ::BI__builtin_s390_vfminsb:
case SystemZ::BI__builtin_s390_vfmindb: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Value *Y = EmitScalarExpr(E->getArg(1));
// Constant-fold the M4 mask argument.
llvm::APSInt M4 = *E->getArg(2)->getIntegerConstantExpr(getContext());
// Check whether this instance can be represented via a LLVM standard
// intrinsic. We only support some values of M4.
Intrinsic::ID ID = Intrinsic::not_intrinsic;
Intrinsic::ID CI;
switch (M4.getZExtValue()) {
default: break;
case 4: ID = Intrinsic::minnum;
CI = Intrinsic::experimental_constrained_minnum; break;
}
if (ID != Intrinsic::not_intrinsic) {
if (Builder.getIsFPConstrained()) {
Function *F = CGM.getIntrinsic(CI, ResultType);
return Builder.CreateConstrainedFPCall(F, {X, Y});
} else {
Function *F = CGM.getIntrinsic(ID, ResultType);
return Builder.CreateCall(F, {X, Y});
}
}
switch (BuiltinID) {
case SystemZ::BI__builtin_s390_vfminsb: ID = Intrinsic::s390_vfminsb; break;
case SystemZ::BI__builtin_s390_vfmindb: ID = Intrinsic::s390_vfmindb; break;
default: llvm_unreachable("Unknown BuiltinID");
}
Function *F = CGM.getIntrinsic(ID);
Value *M4Value = llvm::ConstantInt::get(getLLVMContext(), M4);
return Builder.CreateCall(F, {X, Y, M4Value});
}
case SystemZ::BI__builtin_s390_vlbrh:
case SystemZ::BI__builtin_s390_vlbrf:
case SystemZ::BI__builtin_s390_vlbrg: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0));
Function *F = CGM.getIntrinsic(Intrinsic::bswap, ResultType);
return Builder.CreateCall(F, X);
}
// Vector intrinsics that output the post-instruction CC value.
#define INTRINSIC_WITH_CC(NAME) \
case SystemZ::BI__builtin_##NAME: \
return EmitSystemZIntrinsicWithCC(*this, Intrinsic::NAME, E)
INTRINSIC_WITH_CC(s390_vpkshs);
INTRINSIC_WITH_CC(s390_vpksfs);
INTRINSIC_WITH_CC(s390_vpksgs);
INTRINSIC_WITH_CC(s390_vpklshs);
INTRINSIC_WITH_CC(s390_vpklsfs);
INTRINSIC_WITH_CC(s390_vpklsgs);
INTRINSIC_WITH_CC(s390_vceqbs);
INTRINSIC_WITH_CC(s390_vceqhs);
INTRINSIC_WITH_CC(s390_vceqfs);
INTRINSIC_WITH_CC(s390_vceqgs);
INTRINSIC_WITH_CC(s390_vchbs);
INTRINSIC_WITH_CC(s390_vchhs);
INTRINSIC_WITH_CC(s390_vchfs);
INTRINSIC_WITH_CC(s390_vchgs);
INTRINSIC_WITH_CC(s390_vchlbs);
INTRINSIC_WITH_CC(s390_vchlhs);
INTRINSIC_WITH_CC(s390_vchlfs);
INTRINSIC_WITH_CC(s390_vchlgs);
INTRINSIC_WITH_CC(s390_vfaebs);
INTRINSIC_WITH_CC(s390_vfaehs);
INTRINSIC_WITH_CC(s390_vfaefs);
INTRINSIC_WITH_CC(s390_vfaezbs);
INTRINSIC_WITH_CC(s390_vfaezhs);
INTRINSIC_WITH_CC(s390_vfaezfs);
INTRINSIC_WITH_CC(s390_vfeebs);
INTRINSIC_WITH_CC(s390_vfeehs);
INTRINSIC_WITH_CC(s390_vfeefs);
INTRINSIC_WITH_CC(s390_vfeezbs);
INTRINSIC_WITH_CC(s390_vfeezhs);
INTRINSIC_WITH_CC(s390_vfeezfs);
INTRINSIC_WITH_CC(s390_vfenebs);
INTRINSIC_WITH_CC(s390_vfenehs);
INTRINSIC_WITH_CC(s390_vfenefs);
INTRINSIC_WITH_CC(s390_vfenezbs);
INTRINSIC_WITH_CC(s390_vfenezhs);
INTRINSIC_WITH_CC(s390_vfenezfs);
INTRINSIC_WITH_CC(s390_vistrbs);
INTRINSIC_WITH_CC(s390_vistrhs);
INTRINSIC_WITH_CC(s390_vistrfs);
INTRINSIC_WITH_CC(s390_vstrcbs);
INTRINSIC_WITH_CC(s390_vstrchs);
INTRINSIC_WITH_CC(s390_vstrcfs);
INTRINSIC_WITH_CC(s390_vstrczbs);
INTRINSIC_WITH_CC(s390_vstrczhs);
INTRINSIC_WITH_CC(s390_vstrczfs);
INTRINSIC_WITH_CC(s390_vfcesbs);
INTRINSIC_WITH_CC(s390_vfcedbs);
INTRINSIC_WITH_CC(s390_vfchsbs);
INTRINSIC_WITH_CC(s390_vfchdbs);
INTRINSIC_WITH_CC(s390_vfchesbs);
INTRINSIC_WITH_CC(s390_vfchedbs);
INTRINSIC_WITH_CC(s390_vftcisb);
INTRINSIC_WITH_CC(s390_vftcidb);
INTRINSIC_WITH_CC(s390_vstrsb);
INTRINSIC_WITH_CC(s390_vstrsh);
INTRINSIC_WITH_CC(s390_vstrsf);
INTRINSIC_WITH_CC(s390_vstrszb);
INTRINSIC_WITH_CC(s390_vstrszh);
INTRINSIC_WITH_CC(s390_vstrszf);
#undef INTRINSIC_WITH_CC
default:
return nullptr;
}
}
namespace {
// Helper classes for mapping MMA builtins to particular LLVM intrinsic variant.
struct NVPTXMmaLdstInfo {
unsigned NumResults; // Number of elements to load/store
// Intrinsic IDs for row/col variants. 0 if particular layout is unsupported.
unsigned IID_col;
unsigned IID_row;
};
#define MMA_INTR(geom_op_type, layout) \
Intrinsic::nvvm_wmma_##geom_op_type##_##layout##_stride
#define MMA_LDST(n, geom_op_type) \
{ n, MMA_INTR(geom_op_type, col), MMA_INTR(geom_op_type, row) }
static NVPTXMmaLdstInfo getNVPTXMmaLdstInfo(unsigned BuiltinID) {
switch (BuiltinID) {
// FP MMA loads
case NVPTX::BI__hmma_m16n16k16_ld_a:
return MMA_LDST(8, m16n16k16_load_a_f16);
case NVPTX::BI__hmma_m16n16k16_ld_b:
return MMA_LDST(8, m16n16k16_load_b_f16);
case NVPTX::BI__hmma_m16n16k16_ld_c_f16:
return MMA_LDST(4, m16n16k16_load_c_f16);
case NVPTX::BI__hmma_m16n16k16_ld_c_f32:
return MMA_LDST(8, m16n16k16_load_c_f32);
case NVPTX::BI__hmma_m32n8k16_ld_a:
return MMA_LDST(8, m32n8k16_load_a_f16);
case NVPTX::BI__hmma_m32n8k16_ld_b:
return MMA_LDST(8, m32n8k16_load_b_f16);
case NVPTX::BI__hmma_m32n8k16_ld_c_f16:
return MMA_LDST(4, m32n8k16_load_c_f16);
case NVPTX::BI__hmma_m32n8k16_ld_c_f32:
return MMA_LDST(8, m32n8k16_load_c_f32);
case NVPTX::BI__hmma_m8n32k16_ld_a:
return MMA_LDST(8, m8n32k16_load_a_f16);
case NVPTX::BI__hmma_m8n32k16_ld_b:
return MMA_LDST(8, m8n32k16_load_b_f16);
case NVPTX::BI__hmma_m8n32k16_ld_c_f16:
return MMA_LDST(4, m8n32k16_load_c_f16);
case NVPTX::BI__hmma_m8n32k16_ld_c_f32:
return MMA_LDST(8, m8n32k16_load_c_f32);
// Integer MMA loads
case NVPTX::BI__imma_m16n16k16_ld_a_s8:
return MMA_LDST(2, m16n16k16_load_a_s8);
case NVPTX::BI__imma_m16n16k16_ld_a_u8:
return MMA_LDST(2, m16n16k16_load_a_u8);
case NVPTX::BI__imma_m16n16k16_ld_b_s8:
return MMA_LDST(2, m16n16k16_load_b_s8);
case NVPTX::BI__imma_m16n16k16_ld_b_u8:
return MMA_LDST(2, m16n16k16_load_b_u8);
case NVPTX::BI__imma_m16n16k16_ld_c:
return MMA_LDST(8, m16n16k16_load_c_s32);
case NVPTX::BI__imma_m32n8k16_ld_a_s8:
return MMA_LDST(4, m32n8k16_load_a_s8);
case NVPTX::BI__imma_m32n8k16_ld_a_u8:
return MMA_LDST(4, m32n8k16_load_a_u8);
case NVPTX::BI__imma_m32n8k16_ld_b_s8:
return MMA_LDST(1, m32n8k16_load_b_s8);
case NVPTX::BI__imma_m32n8k16_ld_b_u8:
return MMA_LDST(1, m32n8k16_load_b_u8);
case NVPTX::BI__imma_m32n8k16_ld_c:
return MMA_LDST(8, m32n8k16_load_c_s32);
case NVPTX::BI__imma_m8n32k16_ld_a_s8:
return MMA_LDST(1, m8n32k16_load_a_s8);
case NVPTX::BI__imma_m8n32k16_ld_a_u8:
return MMA_LDST(1, m8n32k16_load_a_u8);
case NVPTX::BI__imma_m8n32k16_ld_b_s8:
return MMA_LDST(4, m8n32k16_load_b_s8);
case NVPTX::BI__imma_m8n32k16_ld_b_u8:
return MMA_LDST(4, m8n32k16_load_b_u8);
case NVPTX::BI__imma_m8n32k16_ld_c:
return MMA_LDST(8, m8n32k16_load_c_s32);
// Sub-integer MMA loads.
// Only row/col layout is supported by A/B fragments.
case NVPTX::BI__imma_m8n8k32_ld_a_s4:
return {1, 0, MMA_INTR(m8n8k32_load_a_s4, row)};
case NVPTX::BI__imma_m8n8k32_ld_a_u4:
return {1, 0, MMA_INTR(m8n8k32_load_a_u4, row)};
case NVPTX::BI__imma_m8n8k32_ld_b_s4:
return {1, MMA_INTR(m8n8k32_load_b_s4, col), 0};
case NVPTX::BI__imma_m8n8k32_ld_b_u4:
return {1, MMA_INTR(m8n8k32_load_b_u4, col), 0};
case NVPTX::BI__imma_m8n8k32_ld_c:
return MMA_LDST(2, m8n8k32_load_c_s32);
case NVPTX::BI__bmma_m8n8k128_ld_a_b1:
return {1, 0, MMA_INTR(m8n8k128_load_a_b1, row)};
case NVPTX::BI__bmma_m8n8k128_ld_b_b1:
return {1, MMA_INTR(m8n8k128_load_b_b1, col), 0};
case NVPTX::BI__bmma_m8n8k128_ld_c:
return MMA_LDST(2, m8n8k128_load_c_s32);
// NOTE: We need to follow inconsitent naming scheme used by NVCC. Unlike
// PTX and LLVM IR where stores always use fragment D, NVCC builtins always
// use fragment C for both loads and stores.
// FP MMA stores.
case NVPTX::BI__hmma_m16n16k16_st_c_f16:
return MMA_LDST(4, m16n16k16_store_d_f16);
case NVPTX::BI__hmma_m16n16k16_st_c_f32:
return MMA_LDST(8, m16n16k16_store_d_f32);
case NVPTX::BI__hmma_m32n8k16_st_c_f16:
return MMA_LDST(4, m32n8k16_store_d_f16);
case NVPTX::BI__hmma_m32n8k16_st_c_f32:
return MMA_LDST(8, m32n8k16_store_d_f32);
case NVPTX::BI__hmma_m8n32k16_st_c_f16:
return MMA_LDST(4, m8n32k16_store_d_f16);
case NVPTX::BI__hmma_m8n32k16_st_c_f32:
return MMA_LDST(8, m8n32k16_store_d_f32);
// Integer and sub-integer MMA stores.
// Another naming quirk. Unlike other MMA builtins that use PTX types in the
// name, integer loads/stores use LLVM's i32.
case NVPTX::BI__imma_m16n16k16_st_c_i32:
return MMA_LDST(8, m16n16k16_store_d_s32);
case NVPTX::BI__imma_m32n8k16_st_c_i32:
return MMA_LDST(8, m32n8k16_store_d_s32);
case NVPTX::BI__imma_m8n32k16_st_c_i32:
return MMA_LDST(8, m8n32k16_store_d_s32);
case NVPTX::BI__imma_m8n8k32_st_c_i32:
return MMA_LDST(2, m8n8k32_store_d_s32);
case NVPTX::BI__bmma_m8n8k128_st_c_i32:
return MMA_LDST(2, m8n8k128_store_d_s32);
default:
llvm_unreachable("Unknown MMA builtin");
}
}
#undef MMA_LDST
#undef MMA_INTR
struct NVPTXMmaInfo {
unsigned NumEltsA;
unsigned NumEltsB;
unsigned NumEltsC;
unsigned NumEltsD;
std::array<unsigned, 8> Variants;
unsigned getMMAIntrinsic(int Layout, bool Satf) {
unsigned Index = Layout * 2 + Satf;
if (Index >= Variants.size())
return 0;
return Variants[Index];
}
};
// Returns an intrinsic that matches Layout and Satf for valid combinations of
// Layout and Satf, 0 otherwise.
static NVPTXMmaInfo getNVPTXMmaInfo(unsigned BuiltinID) {
// clang-format off
#define MMA_VARIANTS(geom, type) {{ \
Intrinsic::nvvm_wmma_##geom##_mma_row_row_##type, \
Intrinsic::nvvm_wmma_##geom##_mma_row_row_##type##_satfinite, \
Intrinsic::nvvm_wmma_##geom##_mma_row_col_##type, \
Intrinsic::nvvm_wmma_##geom##_mma_row_col_##type##_satfinite, \
Intrinsic::nvvm_wmma_##geom##_mma_col_row_##type, \
Intrinsic::nvvm_wmma_##geom##_mma_col_row_##type##_satfinite, \
Intrinsic::nvvm_wmma_##geom##_mma_col_col_##type, \
Intrinsic::nvvm_wmma_##geom##_mma_col_col_##type##_satfinite \
}}
// Sub-integer MMA only supports row.col layout.
#define MMA_VARIANTS_I4(geom, type) {{ \
0, \
0, \
Intrinsic::nvvm_wmma_##geom##_mma_row_col_##type, \
Intrinsic::nvvm_wmma_##geom##_mma_row_col_##type##_satfinite, \
0, \
0, \
0, \
0 \
}}
// b1 MMA does not support .satfinite.
#define MMA_VARIANTS_B1(geom, type) {{ \
0, \
0, \
Intrinsic::nvvm_wmma_##geom##_mma_row_col_##type, \
0, \
0, \
0, \
0, \
0 \
}}
// clang-format on
switch (BuiltinID) {
// FP MMA
// Note that 'type' argument of MMA_VARIANT uses D_C notation, while
// NumEltsN of return value are ordered as A,B,C,D.
case NVPTX::BI__hmma_m16n16k16_mma_f16f16:
return {8, 8, 4, 4, MMA_VARIANTS(m16n16k16, f16_f16)};
case NVPTX::BI__hmma_m16n16k16_mma_f32f16:
return {8, 8, 4, 8, MMA_VARIANTS(m16n16k16, f32_f16)};
case NVPTX::BI__hmma_m16n16k16_mma_f16f32:
return {8, 8, 8, 4, MMA_VARIANTS(m16n16k16, f16_f32)};
case NVPTX::BI__hmma_m16n16k16_mma_f32f32:
return {8, 8, 8, 8, MMA_VARIANTS(m16n16k16, f32_f32)};
case NVPTX::BI__hmma_m32n8k16_mma_f16f16:
return {8, 8, 4, 4, MMA_VARIANTS(m32n8k16, f16_f16)};
case NVPTX::BI__hmma_m32n8k16_mma_f32f16:
return {8, 8, 4, 8, MMA_VARIANTS(m32n8k16, f32_f16)};
case NVPTX::BI__hmma_m32n8k16_mma_f16f32:
return {8, 8, 8, 4, MMA_VARIANTS(m32n8k16, f16_f32)};
case NVPTX::BI__hmma_m32n8k16_mma_f32f32:
return {8, 8, 8, 8, MMA_VARIANTS(m32n8k16, f32_f32)};
case NVPTX::BI__hmma_m8n32k16_mma_f16f16:
return {8, 8, 4, 4, MMA_VARIANTS(m8n32k16, f16_f16)};
case NVPTX::BI__hmma_m8n32k16_mma_f32f16:
return {8, 8, 4, 8, MMA_VARIANTS(m8n32k16, f32_f16)};
case NVPTX::BI__hmma_m8n32k16_mma_f16f32:
return {8, 8, 8, 4, MMA_VARIANTS(m8n32k16, f16_f32)};
case NVPTX::BI__hmma_m8n32k16_mma_f32f32:
return {8, 8, 8, 8, MMA_VARIANTS(m8n32k16, f32_f32)};
// Integer MMA
case NVPTX::BI__imma_m16n16k16_mma_s8:
return {2, 2, 8, 8, MMA_VARIANTS(m16n16k16, s8)};
case NVPTX::BI__imma_m16n16k16_mma_u8:
return {2, 2, 8, 8, MMA_VARIANTS(m16n16k16, u8)};
case NVPTX::BI__imma_m32n8k16_mma_s8:
return {4, 1, 8, 8, MMA_VARIANTS(m32n8k16, s8)};
case NVPTX::BI__imma_m32n8k16_mma_u8:
return {4, 1, 8, 8, MMA_VARIANTS(m32n8k16, u8)};
case NVPTX::BI__imma_m8n32k16_mma_s8:
return {1, 4, 8, 8, MMA_VARIANTS(m8n32k16, s8)};
case NVPTX::BI__imma_m8n32k16_mma_u8:
return {1, 4, 8, 8, MMA_VARIANTS(m8n32k16, u8)};
// Sub-integer MMA
case NVPTX::BI__imma_m8n8k32_mma_s4:
return {1, 1, 2, 2, MMA_VARIANTS_I4(m8n8k32, s4)};
case NVPTX::BI__imma_m8n8k32_mma_u4:
return {1, 1, 2, 2, MMA_VARIANTS_I4(m8n8k32, u4)};
case NVPTX::BI__bmma_m8n8k128_mma_xor_popc_b1:
return {1, 1, 2, 2, MMA_VARIANTS_B1(m8n8k128, b1)};
default:
llvm_unreachable("Unexpected builtin ID.");
}
#undef MMA_VARIANTS
#undef MMA_VARIANTS_I4
#undef MMA_VARIANTS_B1
}
} // namespace
Value *
CodeGenFunction::EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E) {
auto MakeLdg = [&](unsigned IntrinsicID) {
Value *Ptr = EmitScalarExpr(E->getArg(0));
clang::CharUnits Align =
CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
return Builder.CreateCall(
CGM.getIntrinsic(IntrinsicID, {Ptr->getType()->getPointerElementType(),
Ptr->getType()}),
{Ptr, ConstantInt::get(Builder.getInt32Ty(), Align.getQuantity())});
};
auto MakeScopedAtomic = [&](unsigned IntrinsicID) {
Value *Ptr = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(
CGM.getIntrinsic(IntrinsicID, {Ptr->getType()->getPointerElementType(),
Ptr->getType()}),
{Ptr, EmitScalarExpr(E->getArg(1))});
};
switch (BuiltinID) {
case NVPTX::BI__nvvm_atom_add_gen_i:
case NVPTX::BI__nvvm_atom_add_gen_l:
case NVPTX::BI__nvvm_atom_add_gen_ll:
return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Add, E);
case NVPTX::BI__nvvm_atom_sub_gen_i:
case NVPTX::BI__nvvm_atom_sub_gen_l:
case NVPTX::BI__nvvm_atom_sub_gen_ll:
return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Sub, E);
case NVPTX::BI__nvvm_atom_and_gen_i:
case NVPTX::BI__nvvm_atom_and_gen_l:
case NVPTX::BI__nvvm_atom_and_gen_ll:
return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::And, E);
case NVPTX::BI__nvvm_atom_or_gen_i:
case NVPTX::BI__nvvm_atom_or_gen_l:
case NVPTX::BI__nvvm_atom_or_gen_ll:
return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Or, E);
case NVPTX::BI__nvvm_atom_xor_gen_i:
case NVPTX::BI__nvvm_atom_xor_gen_l:
case NVPTX::BI__nvvm_atom_xor_gen_ll:
return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Xor, E);
case NVPTX::BI__nvvm_atom_xchg_gen_i:
case NVPTX::BI__nvvm_atom_xchg_gen_l:
case NVPTX::BI__nvvm_atom_xchg_gen_ll:
return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Xchg, E);
case NVPTX::BI__nvvm_atom_max_gen_i:
case NVPTX::BI__nvvm_atom_max_gen_l:
case NVPTX::BI__nvvm_atom_max_gen_ll:
return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Max, E);
case NVPTX::BI__nvvm_atom_max_gen_ui:
case NVPTX::BI__nvvm_atom_max_gen_ul:
case NVPTX::BI__nvvm_atom_max_gen_ull:
return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::UMax, E);
case NVPTX::BI__nvvm_atom_min_gen_i:
case NVPTX::BI__nvvm_atom_min_gen_l:
case NVPTX::BI__nvvm_atom_min_gen_ll:
return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::Min, E);
case NVPTX::BI__nvvm_atom_min_gen_ui:
case NVPTX::BI__nvvm_atom_min_gen_ul:
case NVPTX::BI__nvvm_atom_min_gen_ull:
return MakeBinaryAtomicValue(*this, llvm::AtomicRMWInst::UMin, E);
case NVPTX::BI__nvvm_atom_cas_gen_i:
case NVPTX::BI__nvvm_atom_cas_gen_l:
case NVPTX::BI__nvvm_atom_cas_gen_ll:
// __nvvm_atom_cas_gen_* should return the old value rather than the
// success flag.
return MakeAtomicCmpXchgValue(*this, E, /*ReturnBool=*/false);
case NVPTX::BI__nvvm_atom_add_gen_f:
case NVPTX::BI__nvvm_atom_add_gen_d: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
Value *Val = EmitScalarExpr(E->getArg(1));
return Builder.CreateAtomicRMW(llvm::AtomicRMWInst::FAdd, Ptr, Val,
AtomicOrdering::SequentiallyConsistent);
}
case NVPTX::BI__nvvm_atom_inc_gen_ui: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
Value *Val = EmitScalarExpr(E->getArg(1));
Function *FnALI32 =
CGM.getIntrinsic(Intrinsic::nvvm_atomic_load_inc_32, Ptr->getType());
return Builder.CreateCall(FnALI32, {Ptr, Val});
}
case NVPTX::BI__nvvm_atom_dec_gen_ui: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
Value *Val = EmitScalarExpr(E->getArg(1));
Function *FnALD32 =
CGM.getIntrinsic(Intrinsic::nvvm_atomic_load_dec_32, Ptr->getType());
return Builder.CreateCall(FnALD32, {Ptr, Val});
}
case NVPTX::BI__nvvm_ldg_c:
case NVPTX::BI__nvvm_ldg_c2:
case NVPTX::BI__nvvm_ldg_c4:
case NVPTX::BI__nvvm_ldg_s:
case NVPTX::BI__nvvm_ldg_s2:
case NVPTX::BI__nvvm_ldg_s4:
case NVPTX::BI__nvvm_ldg_i:
case NVPTX::BI__nvvm_ldg_i2:
case NVPTX::BI__nvvm_ldg_i4:
case NVPTX::BI__nvvm_ldg_l:
case NVPTX::BI__nvvm_ldg_ll:
case NVPTX::BI__nvvm_ldg_ll2:
case NVPTX::BI__nvvm_ldg_uc:
case NVPTX::BI__nvvm_ldg_uc2:
case NVPTX::BI__nvvm_ldg_uc4:
case NVPTX::BI__nvvm_ldg_us:
case NVPTX::BI__nvvm_ldg_us2:
case NVPTX::BI__nvvm_ldg_us4:
case NVPTX::BI__nvvm_ldg_ui:
case NVPTX::BI__nvvm_ldg_ui2:
case NVPTX::BI__nvvm_ldg_ui4:
case NVPTX::BI__nvvm_ldg_ul:
case NVPTX::BI__nvvm_ldg_ull:
case NVPTX::BI__nvvm_ldg_ull2:
// PTX Interoperability section 2.2: "For a vector with an even number of
// elements, its alignment is set to number of elements times the alignment
// of its member: n*alignof(t)."
return MakeLdg(Intrinsic::nvvm_ldg_global_i);
case NVPTX::BI__nvvm_ldg_f:
case NVPTX::BI__nvvm_ldg_f2:
case NVPTX::BI__nvvm_ldg_f4:
case NVPTX::BI__nvvm_ldg_d:
case NVPTX::BI__nvvm_ldg_d2:
return MakeLdg(Intrinsic::nvvm_ldg_global_f);
case NVPTX::BI__nvvm_atom_cta_add_gen_i:
case NVPTX::BI__nvvm_atom_cta_add_gen_l:
case NVPTX::BI__nvvm_atom_cta_add_gen_ll:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_add_gen_i_cta);
case NVPTX::BI__nvvm_atom_sys_add_gen_i:
case NVPTX::BI__nvvm_atom_sys_add_gen_l:
case NVPTX::BI__nvvm_atom_sys_add_gen_ll:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_add_gen_i_sys);
case NVPTX::BI__nvvm_atom_cta_add_gen_f:
case NVPTX::BI__nvvm_atom_cta_add_gen_d:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_add_gen_f_cta);
case NVPTX::BI__nvvm_atom_sys_add_gen_f:
case NVPTX::BI__nvvm_atom_sys_add_gen_d:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_add_gen_f_sys);
case NVPTX::BI__nvvm_atom_cta_xchg_gen_i:
case NVPTX::BI__nvvm_atom_cta_xchg_gen_l:
case NVPTX::BI__nvvm_atom_cta_xchg_gen_ll:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_exch_gen_i_cta);
case NVPTX::BI__nvvm_atom_sys_xchg_gen_i:
case NVPTX::BI__nvvm_atom_sys_xchg_gen_l:
case NVPTX::BI__nvvm_atom_sys_xchg_gen_ll:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_exch_gen_i_sys);
case NVPTX::BI__nvvm_atom_cta_max_gen_i:
case NVPTX::BI__nvvm_atom_cta_max_gen_ui:
case NVPTX::BI__nvvm_atom_cta_max_gen_l:
case NVPTX::BI__nvvm_atom_cta_max_gen_ul:
case NVPTX::BI__nvvm_atom_cta_max_gen_ll:
case NVPTX::BI__nvvm_atom_cta_max_gen_ull:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_max_gen_i_cta);
case NVPTX::BI__nvvm_atom_sys_max_gen_i:
case NVPTX::BI__nvvm_atom_sys_max_gen_ui:
case NVPTX::BI__nvvm_atom_sys_max_gen_l:
case NVPTX::BI__nvvm_atom_sys_max_gen_ul:
case NVPTX::BI__nvvm_atom_sys_max_gen_ll:
case NVPTX::BI__nvvm_atom_sys_max_gen_ull:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_max_gen_i_sys);
case NVPTX::BI__nvvm_atom_cta_min_gen_i:
case NVPTX::BI__nvvm_atom_cta_min_gen_ui:
case NVPTX::BI__nvvm_atom_cta_min_gen_l:
case NVPTX::BI__nvvm_atom_cta_min_gen_ul:
case NVPTX::BI__nvvm_atom_cta_min_gen_ll:
case NVPTX::BI__nvvm_atom_cta_min_gen_ull:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_min_gen_i_cta);
case NVPTX::BI__nvvm_atom_sys_min_gen_i:
case NVPTX::BI__nvvm_atom_sys_min_gen_ui:
case NVPTX::BI__nvvm_atom_sys_min_gen_l:
case NVPTX::BI__nvvm_atom_sys_min_gen_ul:
case NVPTX::BI__nvvm_atom_sys_min_gen_ll:
case NVPTX::BI__nvvm_atom_sys_min_gen_ull:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_min_gen_i_sys);
case NVPTX::BI__nvvm_atom_cta_inc_gen_ui:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_inc_gen_i_cta);
case NVPTX::BI__nvvm_atom_cta_dec_gen_ui:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_dec_gen_i_cta);
case NVPTX::BI__nvvm_atom_sys_inc_gen_ui:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_inc_gen_i_sys);
case NVPTX::BI__nvvm_atom_sys_dec_gen_ui:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_dec_gen_i_sys);
case NVPTX::BI__nvvm_atom_cta_and_gen_i:
case NVPTX::BI__nvvm_atom_cta_and_gen_l:
case NVPTX::BI__nvvm_atom_cta_and_gen_ll:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_and_gen_i_cta);
case NVPTX::BI__nvvm_atom_sys_and_gen_i:
case NVPTX::BI__nvvm_atom_sys_and_gen_l:
case NVPTX::BI__nvvm_atom_sys_and_gen_ll:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_and_gen_i_sys);
case NVPTX::BI__nvvm_atom_cta_or_gen_i:
case NVPTX::BI__nvvm_atom_cta_or_gen_l:
case NVPTX::BI__nvvm_atom_cta_or_gen_ll:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_or_gen_i_cta);
case NVPTX::BI__nvvm_atom_sys_or_gen_i:
case NVPTX::BI__nvvm_atom_sys_or_gen_l:
case NVPTX::BI__nvvm_atom_sys_or_gen_ll:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_or_gen_i_sys);
case NVPTX::BI__nvvm_atom_cta_xor_gen_i:
case NVPTX::BI__nvvm_atom_cta_xor_gen_l:
case NVPTX::BI__nvvm_atom_cta_xor_gen_ll:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_xor_gen_i_cta);
case NVPTX::BI__nvvm_atom_sys_xor_gen_i:
case NVPTX::BI__nvvm_atom_sys_xor_gen_l:
case NVPTX::BI__nvvm_atom_sys_xor_gen_ll:
return MakeScopedAtomic(Intrinsic::nvvm_atomic_xor_gen_i_sys);
case NVPTX::BI__nvvm_atom_cta_cas_gen_i:
case NVPTX::BI__nvvm_atom_cta_cas_gen_l:
case NVPTX::BI__nvvm_atom_cta_cas_gen_ll: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(
CGM.getIntrinsic(
Intrinsic::nvvm_atomic_cas_gen_i_cta,
{Ptr->getType()->getPointerElementType(), Ptr->getType()}),
{Ptr, EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2))});
}
case NVPTX::BI__nvvm_atom_sys_cas_gen_i:
case NVPTX::BI__nvvm_atom_sys_cas_gen_l:
case NVPTX::BI__nvvm_atom_sys_cas_gen_ll: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
return Builder.CreateCall(
CGM.getIntrinsic(
Intrinsic::nvvm_atomic_cas_gen_i_sys,
{Ptr->getType()->getPointerElementType(), Ptr->getType()}),
{Ptr, EmitScalarExpr(E->getArg(1)), EmitScalarExpr(E->getArg(2))});
}
case NVPTX::BI__nvvm_match_all_sync_i32p:
case NVPTX::BI__nvvm_match_all_sync_i64p: {
Value *Mask = EmitScalarExpr(E->getArg(0));
Value *Val = EmitScalarExpr(E->getArg(1));
Address PredOutPtr = EmitPointerWithAlignment(E->getArg(2));
Value *ResultPair = Builder.CreateCall(
CGM.getIntrinsic(BuiltinID == NVPTX::BI__nvvm_match_all_sync_i32p
? Intrinsic::nvvm_match_all_sync_i32p
: Intrinsic::nvvm_match_all_sync_i64p),
{Mask, Val});
Value *Pred = Builder.CreateZExt(Builder.CreateExtractValue(ResultPair, 1),
PredOutPtr.getElementType());
Builder.CreateStore(Pred, PredOutPtr);
return Builder.CreateExtractValue(ResultPair, 0);
}
// FP MMA loads
case NVPTX::BI__hmma_m16n16k16_ld_a:
case NVPTX::BI__hmma_m16n16k16_ld_b:
case NVPTX::BI__hmma_m16n16k16_ld_c_f16:
case NVPTX::BI__hmma_m16n16k16_ld_c_f32:
case NVPTX::BI__hmma_m32n8k16_ld_a:
case NVPTX::BI__hmma_m32n8k16_ld_b:
case NVPTX::BI__hmma_m32n8k16_ld_c_f16:
case NVPTX::BI__hmma_m32n8k16_ld_c_f32:
case NVPTX::BI__hmma_m8n32k16_ld_a:
case NVPTX::BI__hmma_m8n32k16_ld_b:
case NVPTX::BI__hmma_m8n32k16_ld_c_f16:
case NVPTX::BI__hmma_m8n32k16_ld_c_f32:
// Integer MMA loads.
case NVPTX::BI__imma_m16n16k16_ld_a_s8:
case NVPTX::BI__imma_m16n16k16_ld_a_u8:
case NVPTX::BI__imma_m16n16k16_ld_b_s8:
case NVPTX::BI__imma_m16n16k16_ld_b_u8:
case NVPTX::BI__imma_m16n16k16_ld_c:
case NVPTX::BI__imma_m32n8k16_ld_a_s8:
case NVPTX::BI__imma_m32n8k16_ld_a_u8:
case NVPTX::BI__imma_m32n8k16_ld_b_s8:
case NVPTX::BI__imma_m32n8k16_ld_b_u8:
case NVPTX::BI__imma_m32n8k16_ld_c:
case NVPTX::BI__imma_m8n32k16_ld_a_s8:
case NVPTX::BI__imma_m8n32k16_ld_a_u8:
case NVPTX::BI__imma_m8n32k16_ld_b_s8:
case NVPTX::BI__imma_m8n32k16_ld_b_u8:
case NVPTX::BI__imma_m8n32k16_ld_c:
// Sub-integer MMA loads.
case NVPTX::BI__imma_m8n8k32_ld_a_s4:
case NVPTX::BI__imma_m8n8k32_ld_a_u4:
case NVPTX::BI__imma_m8n8k32_ld_b_s4:
case NVPTX::BI__imma_m8n8k32_ld_b_u4:
case NVPTX::BI__imma_m8n8k32_ld_c:
case NVPTX::BI__bmma_m8n8k128_ld_a_b1:
case NVPTX::BI__bmma_m8n8k128_ld_b_b1:
case NVPTX::BI__bmma_m8n8k128_ld_c:
{
Address Dst = EmitPointerWithAlignment(E->getArg(0));
Value *Src = EmitScalarExpr(E->getArg(1));
Value *Ldm = EmitScalarExpr(E->getArg(2));
Optional<llvm::APSInt> isColMajorArg =
E->getArg(3)->getIntegerConstantExpr(getContext());
if (!isColMajorArg)
return nullptr;
bool isColMajor = isColMajorArg->getSExtValue();
NVPTXMmaLdstInfo II = getNVPTXMmaLdstInfo(BuiltinID);
unsigned IID = isColMajor ? II.IID_col : II.IID_row;
if (IID == 0)
return nullptr;
Value *Result =
Builder.CreateCall(CGM.getIntrinsic(IID, Src->getType()), {Src, Ldm});
// Save returned values.
assert(II.NumResults);
if (II.NumResults == 1) {
Builder.CreateAlignedStore(Result, Dst.getPointer(),
CharUnits::fromQuantity(4));
} else {
for (unsigned i = 0; i < II.NumResults; ++i) {
Builder.CreateAlignedStore(
Builder.CreateBitCast(Builder.CreateExtractValue(Result, i),
Dst.getElementType()),
Builder.CreateGEP(Dst.getPointer(),
llvm::ConstantInt::get(IntTy, i)),
CharUnits::fromQuantity(4));
}
}
return Result;
}
case NVPTX::BI__hmma_m16n16k16_st_c_f16:
case NVPTX::BI__hmma_m16n16k16_st_c_f32:
case NVPTX::BI__hmma_m32n8k16_st_c_f16:
case NVPTX::BI__hmma_m32n8k16_st_c_f32:
case NVPTX::BI__hmma_m8n32k16_st_c_f16:
case NVPTX::BI__hmma_m8n32k16_st_c_f32:
case NVPTX::BI__imma_m16n16k16_st_c_i32:
case NVPTX::BI__imma_m32n8k16_st_c_i32:
case NVPTX::BI__imma_m8n32k16_st_c_i32:
case NVPTX::BI__imma_m8n8k32_st_c_i32:
case NVPTX::BI__bmma_m8n8k128_st_c_i32: {
Value *Dst = EmitScalarExpr(E->getArg(0));
Address Src = EmitPointerWithAlignment(E->getArg(1));
Value *Ldm = EmitScalarExpr(E->getArg(2));
Optional<llvm::APSInt> isColMajorArg =
E->getArg(3)->getIntegerConstantExpr(getContext());
if (!isColMajorArg)
return nullptr;
bool isColMajor = isColMajorArg->getSExtValue();
NVPTXMmaLdstInfo II = getNVPTXMmaLdstInfo(BuiltinID);
unsigned IID = isColMajor ? II.IID_col : II.IID_row;
if (IID == 0)
return nullptr;
Function *Intrinsic =
CGM.getIntrinsic(IID, Dst->getType());
llvm::Type *ParamType = Intrinsic->getFunctionType()->getParamType(1);
SmallVector<Value *, 10> Values = {Dst};
for (unsigned i = 0; i < II.NumResults; ++i) {
Value *V = Builder.CreateAlignedLoad(
Builder.CreateGEP(Src.getPointer(), llvm::ConstantInt::get(IntTy, i)),
CharUnits::fromQuantity(4));
Values.push_back(Builder.CreateBitCast(V, ParamType));
}
Values.push_back(Ldm);
Value *Result = Builder.CreateCall(Intrinsic, Values);
return Result;
}
// BI__hmma_m16n16k16_mma_<Dtype><CType>(d, a, b, c, layout, satf) -->
// Intrinsic::nvvm_wmma_m16n16k16_mma_sync<layout A,B><DType><CType><Satf>
case NVPTX::BI__hmma_m16n16k16_mma_f16f16:
case NVPTX::BI__hmma_m16n16k16_mma_f32f16:
case NVPTX::BI__hmma_m16n16k16_mma_f32f32:
case NVPTX::BI__hmma_m16n16k16_mma_f16f32:
case NVPTX::BI__hmma_m32n8k16_mma_f16f16:
case NVPTX::BI__hmma_m32n8k16_mma_f32f16:
case NVPTX::BI__hmma_m32n8k16_mma_f32f32:
case NVPTX::BI__hmma_m32n8k16_mma_f16f32:
case NVPTX::BI__hmma_m8n32k16_mma_f16f16:
case NVPTX::BI__hmma_m8n32k16_mma_f32f16:
case NVPTX::BI__hmma_m8n32k16_mma_f32f32:
case NVPTX::BI__hmma_m8n32k16_mma_f16f32:
case NVPTX::BI__imma_m16n16k16_mma_s8:
case NVPTX::BI__imma_m16n16k16_mma_u8:
case NVPTX::BI__imma_m32n8k16_mma_s8:
case NVPTX::BI__imma_m32n8k16_mma_u8:
case NVPTX::BI__imma_m8n32k16_mma_s8:
case NVPTX::BI__imma_m8n32k16_mma_u8:
case NVPTX::BI__imma_m8n8k32_mma_s4:
case NVPTX::BI__imma_m8n8k32_mma_u4:
case NVPTX::BI__bmma_m8n8k128_mma_xor_popc_b1: {
Address Dst = EmitPointerWithAlignment(E->getArg(0));
Address SrcA = EmitPointerWithAlignment(E->getArg(1));
Address SrcB = EmitPointerWithAlignment(E->getArg(2));
Address SrcC = EmitPointerWithAlignment(E->getArg(3));
Optional<llvm::APSInt> LayoutArg =
E->getArg(4)->getIntegerConstantExpr(getContext());
if (!LayoutArg)
return nullptr;
int Layout = LayoutArg->getSExtValue();
if (Layout < 0 || Layout > 3)
return nullptr;
llvm::APSInt SatfArg;
if (BuiltinID == NVPTX::BI__bmma_m8n8k128_mma_xor_popc_b1)
SatfArg = 0; // .b1 does not have satf argument.
else if (Optional<llvm::APSInt> OptSatfArg =
E->getArg(5)->getIntegerConstantExpr(getContext()))
SatfArg = *OptSatfArg;
else
return nullptr;
bool Satf = SatfArg.getSExtValue();
NVPTXMmaInfo MI = getNVPTXMmaInfo(BuiltinID);
unsigned IID = MI.getMMAIntrinsic(Layout, Satf);
if (IID == 0) // Unsupported combination of Layout/Satf.
return nullptr;
SmallVector<Value *, 24> Values;
Function *Intrinsic = CGM.getIntrinsic(IID);
llvm::Type *AType = Intrinsic->getFunctionType()->getParamType(0);
// Load A
for (unsigned i = 0; i < MI.NumEltsA; ++i) {
Value *V = Builder.CreateAlignedLoad(
Builder.CreateGEP(SrcA.getPointer(),
llvm::ConstantInt::get(IntTy, i)),
CharUnits::fromQuantity(4));
Values.push_back(Builder.CreateBitCast(V, AType));
}
// Load B
llvm::Type *BType = Intrinsic->getFunctionType()->getParamType(MI.NumEltsA);
for (unsigned i = 0; i < MI.NumEltsB; ++i) {
Value *V = Builder.CreateAlignedLoad(
Builder.CreateGEP(SrcB.getPointer(),
llvm::ConstantInt::get(IntTy, i)),
CharUnits::fromQuantity(4));
Values.push_back(Builder.CreateBitCast(V, BType));
}
// Load C
llvm::Type *CType =
Intrinsic->getFunctionType()->getParamType(MI.NumEltsA + MI.NumEltsB);
for (unsigned i = 0; i < MI.NumEltsC; ++i) {
Value *V = Builder.CreateAlignedLoad(
Builder.CreateGEP(SrcC.getPointer(),
llvm::ConstantInt::get(IntTy, i)),
CharUnits::fromQuantity(4));
Values.push_back(Builder.CreateBitCast(V, CType));
}
Value *Result = Builder.CreateCall(Intrinsic, Values);
llvm::Type *DType = Dst.getElementType();
for (unsigned i = 0; i < MI.NumEltsD; ++i)
Builder.CreateAlignedStore(
Builder.CreateBitCast(Builder.CreateExtractValue(Result, i), DType),
Builder.CreateGEP(Dst.getPointer(), llvm::ConstantInt::get(IntTy, i)),
CharUnits::fromQuantity(4));
return Result;
}
default:
return nullptr;
}
}
namespace {
struct BuiltinAlignArgs {
llvm::Value *Src = nullptr;
llvm::Type *SrcType = nullptr;
llvm::Value *Alignment = nullptr;
llvm::Value *Mask = nullptr;
llvm::IntegerType *IntType = nullptr;
BuiltinAlignArgs(const CallExpr *E, CodeGenFunction &CGF) {
QualType AstType = E->getArg(0)->getType();
if (AstType->isArrayType())
Src = CGF.EmitArrayToPointerDecay(E->getArg(0)).getPointer();
else
Src = CGF.EmitScalarExpr(E->getArg(0));
SrcType = Src->getType();
if (SrcType->isPointerTy()) {
IntType = IntegerType::get(
CGF.getLLVMContext(),
CGF.CGM.getDataLayout().getIndexTypeSizeInBits(SrcType));
} else {
assert(SrcType->isIntegerTy());
IntType = cast<llvm::IntegerType>(SrcType);
}
Alignment = CGF.EmitScalarExpr(E->getArg(1));
Alignment = CGF.Builder.CreateZExtOrTrunc(Alignment, IntType, "alignment");
auto *One = llvm::ConstantInt::get(IntType, 1);
Mask = CGF.Builder.CreateSub(Alignment, One, "mask");
}
};
} // namespace
/// Generate (x & (y-1)) == 0.
RValue CodeGenFunction::EmitBuiltinIsAligned(const CallExpr *E) {
BuiltinAlignArgs Args(E, *this);
llvm::Value *SrcAddress = Args.Src;
if (Args.SrcType->isPointerTy())
SrcAddress =
Builder.CreateBitOrPointerCast(Args.Src, Args.IntType, "src_addr");
return RValue::get(Builder.CreateICmpEQ(
Builder.CreateAnd(SrcAddress, Args.Mask, "set_bits"),
llvm::Constant::getNullValue(Args.IntType), "is_aligned"));
}
/// Generate (x & ~(y-1)) to align down or ((x+(y-1)) & ~(y-1)) to align up.
/// Note: For pointer types we can avoid ptrtoint/inttoptr pairs by using the
/// llvm.ptrmask instrinsic (with a GEP before in the align_up case).
/// TODO: actually use ptrmask once most optimization passes know about it.
RValue CodeGenFunction::EmitBuiltinAlignTo(const CallExpr *E, bool AlignUp) {
BuiltinAlignArgs Args(E, *this);
llvm::Value *SrcAddr = Args.Src;
if (Args.Src->getType()->isPointerTy())
SrcAddr = Builder.CreatePtrToInt(Args.Src, Args.IntType, "intptr");
llvm::Value *SrcForMask = SrcAddr;
if (AlignUp) {
// When aligning up we have to first add the mask to ensure we go over the
// next alignment value and then align down to the next valid multiple.
// By adding the mask, we ensure that align_up on an already aligned
// value will not change the value.
SrcForMask = Builder.CreateAdd(SrcForMask, Args.Mask, "over_boundary");
}
// Invert the mask to only clear the lower bits.
llvm::Value *InvertedMask = Builder.CreateNot(Args.Mask, "inverted_mask");
llvm::Value *Result =
Builder.CreateAnd(SrcForMask, InvertedMask, "aligned_result");
if (Args.Src->getType()->isPointerTy()) {
/// TODO: Use ptrmask instead of ptrtoint+gep once it is optimized well.
// Result = Builder.CreateIntrinsic(
// Intrinsic::ptrmask, {Args.SrcType, SrcForMask->getType(), Args.IntType},
// {SrcForMask, NegatedMask}, nullptr, "aligned_result");
Result->setName("aligned_intptr");
llvm::Value *Difference = Builder.CreateSub(Result, SrcAddr, "diff");
// The result must point to the same underlying allocation. This means we
// can use an inbounds GEP to enable better optimization.
Value *Base = EmitCastToVoidPtr(Args.Src);
if (getLangOpts().isSignedOverflowDefined())
Result = Builder.CreateGEP(Base, Difference, "aligned_result");
else
Result = EmitCheckedInBoundsGEP(Base, Difference,
/*SignedIndices=*/true,
/*isSubtraction=*/!AlignUp,
E->getExprLoc(), "aligned_result");
Result = Builder.CreatePointerCast(Result, Args.SrcType);
// Emit an alignment assumption to ensure that the new alignment is
// propagated to loads/stores, etc.
emitAlignmentAssumption(Result, E, E->getExprLoc(), Args.Alignment);
}
assert(Result->getType() == Args.SrcType);
return RValue::get(Result);
}
Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
const CallExpr *E) {
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_memory_size: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *I = EmitScalarExpr(E->getArg(0));
Function *Callee =
CGM.getIntrinsic(Intrinsic::wasm_memory_size, ResultType);
return Builder.CreateCall(Callee, I);
}
case WebAssembly::BI__builtin_wasm_memory_grow: {
llvm::Type *ResultType = ConvertType(E->getType());
Value *Args[] = {EmitScalarExpr(E->getArg(0)),
EmitScalarExpr(E->getArg(1))};
Function *Callee =
CGM.getIntrinsic(Intrinsic::wasm_memory_grow, ResultType);
return Builder.CreateCall(Callee, Args);
}
case WebAssembly::BI__builtin_wasm_tls_size: {
llvm::Type *ResultType = ConvertType(E->getType());
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_tls_size, ResultType);
return Builder.CreateCall(Callee);
}
case WebAssembly::BI__builtin_wasm_tls_align: {
llvm::Type *ResultType = ConvertType(E->getType());
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_tls_align, ResultType);
return Builder.CreateCall(Callee);
}
case WebAssembly::BI__builtin_wasm_tls_base: {
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_tls_base);
return Builder.CreateCall(Callee);
}
case WebAssembly::BI__builtin_wasm_throw: {
Value *Tag = EmitScalarExpr(E->getArg(0));
Value *Obj = EmitScalarExpr(E->getArg(1));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_throw);
return Builder.CreateCall(Callee, {Tag, Obj});
}
case WebAssembly::BI__builtin_wasm_rethrow_in_catch: {
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_rethrow_in_catch);
return Builder.CreateCall(Callee);
}
case WebAssembly::BI__builtin_wasm_memory_atomic_wait32: {
Value *Addr = EmitScalarExpr(E->getArg(0));
Value *Expected = EmitScalarExpr(E->getArg(1));
Value *Timeout = EmitScalarExpr(E->getArg(2));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_atomic_wait32);
return Builder.CreateCall(Callee, {Addr, Expected, Timeout});
}
case WebAssembly::BI__builtin_wasm_memory_atomic_wait64: {
Value *Addr = EmitScalarExpr(E->getArg(0));
Value *Expected = EmitScalarExpr(E->getArg(1));
Value *Timeout = EmitScalarExpr(E->getArg(2));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_atomic_wait64);
return Builder.CreateCall(Callee, {Addr, Expected, Timeout});
}
case WebAssembly::BI__builtin_wasm_memory_atomic_notify: {
Value *Addr = EmitScalarExpr(E->getArg(0));
Value *Count = EmitScalarExpr(E->getArg(1));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_atomic_notify);
return Builder.CreateCall(Callee, {Addr, Count});
}
case WebAssembly::BI__builtin_wasm_trunc_s_i32_f32:
case WebAssembly::BI__builtin_wasm_trunc_s_i32_f64:
case WebAssembly::BI__builtin_wasm_trunc_s_i64_f32:
case WebAssembly::BI__builtin_wasm_trunc_s_i64_f64: {
Value *Src = EmitScalarExpr(E->getArg(0));
llvm::Type *ResT = ConvertType(E->getType());
Function *Callee =
CGM.getIntrinsic(Intrinsic::wasm_trunc_signed, {ResT, Src->getType()});
return Builder.CreateCall(Callee, {Src});
}
case WebAssembly::BI__builtin_wasm_trunc_u_i32_f32:
case WebAssembly::BI__builtin_wasm_trunc_u_i32_f64:
case WebAssembly::BI__builtin_wasm_trunc_u_i64_f32:
case WebAssembly::BI__builtin_wasm_trunc_u_i64_f64: {
Value *Src = EmitScalarExpr(E->getArg(0));
llvm::Type *ResT = ConvertType(E->getType());
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_trunc_unsigned,
{ResT, Src->getType()});
return Builder.CreateCall(Callee, {Src});
}
case WebAssembly::BI__builtin_wasm_trunc_saturate_s_i32_f32:
case WebAssembly::BI__builtin_wasm_trunc_saturate_s_i32_f64:
case WebAssembly::BI__builtin_wasm_trunc_saturate_s_i64_f32:
case WebAssembly::BI__builtin_wasm_trunc_saturate_s_i64_f64:
case WebAssembly::BI__builtin_wasm_trunc_saturate_s_i32x4_f32x4: {
Value *Src = EmitScalarExpr(E->getArg(0));
llvm::Type *ResT = ConvertType(E->getType());
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_trunc_saturate_signed,
{ResT, Src->getType()});
return Builder.CreateCall(Callee, {Src});
}
case WebAssembly::BI__builtin_wasm_trunc_saturate_u_i32_f32:
case WebAssembly::BI__builtin_wasm_trunc_saturate_u_i32_f64:
case WebAssembly::BI__builtin_wasm_trunc_saturate_u_i64_f32:
case WebAssembly::BI__builtin_wasm_trunc_saturate_u_i64_f64:
case WebAssembly::BI__builtin_wasm_trunc_saturate_u_i32x4_f32x4: {
Value *Src = EmitScalarExpr(E->getArg(0));
llvm::Type *ResT = ConvertType(E->getType());
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_trunc_saturate_unsigned,
{ResT, Src->getType()});
return Builder.CreateCall(Callee, {Src});
}
case WebAssembly::BI__builtin_wasm_min_f32:
case WebAssembly::BI__builtin_wasm_min_f64:
case WebAssembly::BI__builtin_wasm_min_f32x4:
case WebAssembly::BI__builtin_wasm_min_f64x2: {
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
Function *Callee =
CGM.getIntrinsic(Intrinsic::minimum, ConvertType(E->getType()));
return Builder.CreateCall(Callee, {LHS, RHS});
}
case WebAssembly::BI__builtin_wasm_max_f32:
case WebAssembly::BI__builtin_wasm_max_f64:
case WebAssembly::BI__builtin_wasm_max_f32x4:
case WebAssembly::BI__builtin_wasm_max_f64x2: {
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
Function *Callee =
CGM.getIntrinsic(Intrinsic::maximum, ConvertType(E->getType()));
return Builder.CreateCall(Callee, {LHS, RHS});
}
case WebAssembly::BI__builtin_wasm_pmin_f32x4:
case WebAssembly::BI__builtin_wasm_pmin_f64x2: {
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
Function *Callee =
CGM.getIntrinsic(Intrinsic::wasm_pmin, ConvertType(E->getType()));
return Builder.CreateCall(Callee, {LHS, RHS});
}
case WebAssembly::BI__builtin_wasm_pmax_f32x4:
case WebAssembly::BI__builtin_wasm_pmax_f64x2: {
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
Function *Callee =
CGM.getIntrinsic(Intrinsic::wasm_pmax, ConvertType(E->getType()));
return Builder.CreateCall(Callee, {LHS, RHS});
}
case WebAssembly::BI__builtin_wasm_ceil_f32x4:
case WebAssembly::BI__builtin_wasm_floor_f32x4:
case WebAssembly::BI__builtin_wasm_trunc_f32x4:
case WebAssembly::BI__builtin_wasm_nearest_f32x4:
case WebAssembly::BI__builtin_wasm_ceil_f64x2:
case WebAssembly::BI__builtin_wasm_floor_f64x2:
case WebAssembly::BI__builtin_wasm_trunc_f64x2:
case WebAssembly::BI__builtin_wasm_nearest_f64x2: {
unsigned IntNo;
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_ceil_f32x4:
case WebAssembly::BI__builtin_wasm_ceil_f64x2:
IntNo = Intrinsic::wasm_ceil;
break;
case WebAssembly::BI__builtin_wasm_floor_f32x4:
case WebAssembly::BI__builtin_wasm_floor_f64x2:
IntNo = Intrinsic::wasm_floor;
break;
case WebAssembly::BI__builtin_wasm_trunc_f32x4:
case WebAssembly::BI__builtin_wasm_trunc_f64x2:
IntNo = Intrinsic::wasm_trunc;
break;
case WebAssembly::BI__builtin_wasm_nearest_f32x4:
case WebAssembly::BI__builtin_wasm_nearest_f64x2:
IntNo = Intrinsic::wasm_nearest;
break;
default:
llvm_unreachable("unexpected builtin ID");
}
Value *Value = EmitScalarExpr(E->getArg(0));
Function *Callee = CGM.getIntrinsic(IntNo, ConvertType(E->getType()));
return Builder.CreateCall(Callee, Value);
}
case WebAssembly::BI__builtin_wasm_swizzle_v8x16: {
Value *Src = EmitScalarExpr(E->getArg(0));
Value *Indices = EmitScalarExpr(E->getArg(1));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_swizzle);
return Builder.CreateCall(Callee, {Src, Indices});
}
case WebAssembly::BI__builtin_wasm_extract_lane_s_i8x16:
case WebAssembly::BI__builtin_wasm_extract_lane_u_i8x16:
case WebAssembly::BI__builtin_wasm_extract_lane_s_i16x8:
case WebAssembly::BI__builtin_wasm_extract_lane_u_i16x8:
case WebAssembly::BI__builtin_wasm_extract_lane_i32x4:
case WebAssembly::BI__builtin_wasm_extract_lane_i64x2:
case WebAssembly::BI__builtin_wasm_extract_lane_f32x4:
case WebAssembly::BI__builtin_wasm_extract_lane_f64x2: {
llvm::APSInt LaneConst =
*E->getArg(1)->getIntegerConstantExpr(getContext());
Value *Vec = EmitScalarExpr(E->getArg(0));
Value *Lane = llvm::ConstantInt::get(getLLVMContext(), LaneConst);
Value *Extract = Builder.CreateExtractElement(Vec, Lane);
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_extract_lane_s_i8x16:
case WebAssembly::BI__builtin_wasm_extract_lane_s_i16x8:
return Builder.CreateSExt(Extract, ConvertType(E->getType()));
case WebAssembly::BI__builtin_wasm_extract_lane_u_i8x16:
case WebAssembly::BI__builtin_wasm_extract_lane_u_i16x8:
return Builder.CreateZExt(Extract, ConvertType(E->getType()));
case WebAssembly::BI__builtin_wasm_extract_lane_i32x4:
case WebAssembly::BI__builtin_wasm_extract_lane_i64x2:
case WebAssembly::BI__builtin_wasm_extract_lane_f32x4:
case WebAssembly::BI__builtin_wasm_extract_lane_f64x2:
return Extract;
default:
llvm_unreachable("unexpected builtin ID");
}
}
case WebAssembly::BI__builtin_wasm_replace_lane_i8x16:
case WebAssembly::BI__builtin_wasm_replace_lane_i16x8:
case WebAssembly::BI__builtin_wasm_replace_lane_i32x4:
case WebAssembly::BI__builtin_wasm_replace_lane_i64x2:
case WebAssembly::BI__builtin_wasm_replace_lane_f32x4:
case WebAssembly::BI__builtin_wasm_replace_lane_f64x2: {
llvm::APSInt LaneConst =
*E->getArg(1)->getIntegerConstantExpr(getContext());
Value *Vec = EmitScalarExpr(E->getArg(0));
Value *Lane = llvm::ConstantInt::get(getLLVMContext(), LaneConst);
Value *Val = EmitScalarExpr(E->getArg(2));
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_replace_lane_i8x16:
case WebAssembly::BI__builtin_wasm_replace_lane_i16x8: {
llvm::Type *ElemType =
cast<llvm::VectorType>(ConvertType(E->getType()))->getElementType();
Value *Trunc = Builder.CreateTrunc(Val, ElemType);
return Builder.CreateInsertElement(Vec, Trunc, Lane);
}
case WebAssembly::BI__builtin_wasm_replace_lane_i32x4:
case WebAssembly::BI__builtin_wasm_replace_lane_i64x2:
case WebAssembly::BI__builtin_wasm_replace_lane_f32x4:
case WebAssembly::BI__builtin_wasm_replace_lane_f64x2:
return Builder.CreateInsertElement(Vec, Val, Lane);
default:
llvm_unreachable("unexpected builtin ID");
}
}
case WebAssembly::BI__builtin_wasm_add_saturate_s_i8x16:
case WebAssembly::BI__builtin_wasm_add_saturate_u_i8x16:
case WebAssembly::BI__builtin_wasm_add_saturate_s_i16x8:
case WebAssembly::BI__builtin_wasm_add_saturate_u_i16x8:
case WebAssembly::BI__builtin_wasm_sub_saturate_s_i8x16:
case WebAssembly::BI__builtin_wasm_sub_saturate_u_i8x16:
case WebAssembly::BI__builtin_wasm_sub_saturate_s_i16x8:
case WebAssembly::BI__builtin_wasm_sub_saturate_u_i16x8: {
unsigned IntNo;
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_add_saturate_s_i8x16:
case WebAssembly::BI__builtin_wasm_add_saturate_s_i16x8:
IntNo = Intrinsic::sadd_sat;
break;
case WebAssembly::BI__builtin_wasm_add_saturate_u_i8x16:
case WebAssembly::BI__builtin_wasm_add_saturate_u_i16x8:
IntNo = Intrinsic::uadd_sat;
break;
case WebAssembly::BI__builtin_wasm_sub_saturate_s_i8x16:
case WebAssembly::BI__builtin_wasm_sub_saturate_s_i16x8:
IntNo = Intrinsic::wasm_sub_saturate_signed;
break;
case WebAssembly::BI__builtin_wasm_sub_saturate_u_i8x16:
case WebAssembly::BI__builtin_wasm_sub_saturate_u_i16x8:
IntNo = Intrinsic::wasm_sub_saturate_unsigned;
break;
default:
llvm_unreachable("unexpected builtin ID");
}
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
Function *Callee = CGM.getIntrinsic(IntNo, ConvertType(E->getType()));
return Builder.CreateCall(Callee, {LHS, RHS});
}
case WebAssembly::BI__builtin_wasm_abs_i8x16:
case WebAssembly::BI__builtin_wasm_abs_i16x8:
case WebAssembly::BI__builtin_wasm_abs_i32x4: {
Value *Vec = EmitScalarExpr(E->getArg(0));
Value *Neg = Builder.CreateNeg(Vec, "neg");
Constant *Zero = llvm::Constant::getNullValue(Vec->getType());
Value *ICmp = Builder.CreateICmpSLT(Vec, Zero, "abscond");
return Builder.CreateSelect(ICmp, Neg, Vec, "abs");
}
case WebAssembly::BI__builtin_wasm_min_s_i8x16:
case WebAssembly::BI__builtin_wasm_min_u_i8x16:
case WebAssembly::BI__builtin_wasm_max_s_i8x16:
case WebAssembly::BI__builtin_wasm_max_u_i8x16:
case WebAssembly::BI__builtin_wasm_min_s_i16x8:
case WebAssembly::BI__builtin_wasm_min_u_i16x8:
case WebAssembly::BI__builtin_wasm_max_s_i16x8:
case WebAssembly::BI__builtin_wasm_max_u_i16x8:
case WebAssembly::BI__builtin_wasm_min_s_i32x4:
case WebAssembly::BI__builtin_wasm_min_u_i32x4:
case WebAssembly::BI__builtin_wasm_max_s_i32x4:
case WebAssembly::BI__builtin_wasm_max_u_i32x4: {
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
Value *ICmp;
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_min_s_i8x16:
case WebAssembly::BI__builtin_wasm_min_s_i16x8:
case WebAssembly::BI__builtin_wasm_min_s_i32x4:
ICmp = Builder.CreateICmpSLT(LHS, RHS);
break;
case WebAssembly::BI__builtin_wasm_min_u_i8x16:
case WebAssembly::BI__builtin_wasm_min_u_i16x8:
case WebAssembly::BI__builtin_wasm_min_u_i32x4:
ICmp = Builder.CreateICmpULT(LHS, RHS);
break;
case WebAssembly::BI__builtin_wasm_max_s_i8x16:
case WebAssembly::BI__builtin_wasm_max_s_i16x8:
case WebAssembly::BI__builtin_wasm_max_s_i32x4:
ICmp = Builder.CreateICmpSGT(LHS, RHS);
break;
case WebAssembly::BI__builtin_wasm_max_u_i8x16:
case WebAssembly::BI__builtin_wasm_max_u_i16x8:
case WebAssembly::BI__builtin_wasm_max_u_i32x4:
ICmp = Builder.CreateICmpUGT(LHS, RHS);
break;
default:
llvm_unreachable("unexpected builtin ID");
}
return Builder.CreateSelect(ICmp, LHS, RHS);
}
case WebAssembly::BI__builtin_wasm_avgr_u_i8x16:
case WebAssembly::BI__builtin_wasm_avgr_u_i16x8: {
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_avgr_unsigned,
ConvertType(E->getType()));
return Builder.CreateCall(Callee, {LHS, RHS});
}
case WebAssembly::BI__builtin_wasm_q15mulr_saturate_s_i16x8: {
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
Function *Callee =
CGM.getIntrinsic(Intrinsic::wasm_q15mulr_saturate_signed);
return Builder.CreateCall(Callee, {LHS, RHS});
}
case WebAssembly::BI__builtin_wasm_extmul_low_i8x16_s_i16x8:
case WebAssembly::BI__builtin_wasm_extmul_high_i8x16_s_i16x8:
case WebAssembly::BI__builtin_wasm_extmul_low_i8x16_u_i16x8:
case WebAssembly::BI__builtin_wasm_extmul_high_i8x16_u_i16x8:
case WebAssembly::BI__builtin_wasm_extmul_low_i16x8_s_i32x4:
case WebAssembly::BI__builtin_wasm_extmul_high_i16x8_s_i32x4:
case WebAssembly::BI__builtin_wasm_extmul_low_i16x8_u_i32x4:
case WebAssembly::BI__builtin_wasm_extmul_high_i16x8_u_i32x4:
case WebAssembly::BI__builtin_wasm_extmul_low_i32x4_s_i64x2:
case WebAssembly::BI__builtin_wasm_extmul_high_i32x4_s_i64x2:
case WebAssembly::BI__builtin_wasm_extmul_low_i32x4_u_i64x2:
case WebAssembly::BI__builtin_wasm_extmul_high_i32x4_u_i64x2: {
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
unsigned IntNo;
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_extmul_low_i8x16_s_i16x8:
case WebAssembly::BI__builtin_wasm_extmul_low_i16x8_s_i32x4:
case WebAssembly::BI__builtin_wasm_extmul_low_i32x4_s_i64x2:
IntNo = Intrinsic::wasm_extmul_low_signed;
break;
case WebAssembly::BI__builtin_wasm_extmul_low_i8x16_u_i16x8:
case WebAssembly::BI__builtin_wasm_extmul_low_i16x8_u_i32x4:
case WebAssembly::BI__builtin_wasm_extmul_low_i32x4_u_i64x2:
IntNo = Intrinsic::wasm_extmul_low_unsigned;
break;
case WebAssembly::BI__builtin_wasm_extmul_high_i8x16_s_i16x8:
case WebAssembly::BI__builtin_wasm_extmul_high_i16x8_s_i32x4:
case WebAssembly::BI__builtin_wasm_extmul_high_i32x4_s_i64x2:
IntNo = Intrinsic::wasm_extmul_high_signed;
break;
case WebAssembly::BI__builtin_wasm_extmul_high_i8x16_u_i16x8:
case WebAssembly::BI__builtin_wasm_extmul_high_i16x8_u_i32x4:
case WebAssembly::BI__builtin_wasm_extmul_high_i32x4_u_i64x2:
IntNo = Intrinsic::wasm_extmul_high_unsigned;
break;
default:
llvm_unreachable("unexptected builtin ID");
}
Function *Callee = CGM.getIntrinsic(IntNo, ConvertType(E->getType()));
return Builder.CreateCall(Callee, {LHS, RHS});
}
case WebAssembly::BI__builtin_wasm_extadd_pairwise_i8x16_s_i16x8:
case WebAssembly::BI__builtin_wasm_extadd_pairwise_i8x16_u_i16x8:
case WebAssembly::BI__builtin_wasm_extadd_pairwise_i16x8_s_i32x4:
case WebAssembly::BI__builtin_wasm_extadd_pairwise_i16x8_u_i32x4: {
Value *Vec = EmitScalarExpr(E->getArg(0));
unsigned IntNo;
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_extadd_pairwise_i8x16_s_i16x8:
case WebAssembly::BI__builtin_wasm_extadd_pairwise_i16x8_s_i32x4:
IntNo = Intrinsic::wasm_extadd_pairwise_signed;
break;
case WebAssembly::BI__builtin_wasm_extadd_pairwise_i8x16_u_i16x8:
case WebAssembly::BI__builtin_wasm_extadd_pairwise_i16x8_u_i32x4:
IntNo = Intrinsic::wasm_extadd_pairwise_unsigned;
break;
default:
llvm_unreachable("unexptected builtin ID");
}
Function *Callee = CGM.getIntrinsic(IntNo, ConvertType(E->getType()));
return Builder.CreateCall(Callee, Vec);
}
case WebAssembly::BI__builtin_wasm_bitselect: {
Value *V1 = EmitScalarExpr(E->getArg(0));
Value *V2 = EmitScalarExpr(E->getArg(1));
Value *C = EmitScalarExpr(E->getArg(2));
Function *Callee =
CGM.getIntrinsic(Intrinsic::wasm_bitselect, ConvertType(E->getType()));
return Builder.CreateCall(Callee, {V1, V2, C});
}
case WebAssembly::BI__builtin_wasm_signselect_i8x16:
case WebAssembly::BI__builtin_wasm_signselect_i16x8:
case WebAssembly::BI__builtin_wasm_signselect_i32x4:
case WebAssembly::BI__builtin_wasm_signselect_i64x2: {
Value *V1 = EmitScalarExpr(E->getArg(0));
Value *V2 = EmitScalarExpr(E->getArg(1));
Value *C = EmitScalarExpr(E->getArg(2));
Function *Callee =
CGM.getIntrinsic(Intrinsic::wasm_signselect, ConvertType(E->getType()));
return Builder.CreateCall(Callee, {V1, V2, C});
}
case WebAssembly::BI__builtin_wasm_dot_s_i32x4_i16x8: {
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_dot);
return Builder.CreateCall(Callee, {LHS, RHS});
}
case WebAssembly::BI__builtin_wasm_popcnt_i8x16: {
Value *Vec = EmitScalarExpr(E->getArg(0));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_popcnt);
return Builder.CreateCall(Callee, {Vec});
}
case WebAssembly::BI__builtin_wasm_eq_i64x2: {
Value *LHS = EmitScalarExpr(E->getArg(0));
Value *RHS = EmitScalarExpr(E->getArg(1));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_eq);
return Builder.CreateCall(Callee, {LHS, RHS});
}
case WebAssembly::BI__builtin_wasm_any_true_i8x16:
case WebAssembly::BI__builtin_wasm_any_true_i16x8:
case WebAssembly::BI__builtin_wasm_any_true_i32x4:
case WebAssembly::BI__builtin_wasm_any_true_i64x2:
case WebAssembly::BI__builtin_wasm_all_true_i8x16:
case WebAssembly::BI__builtin_wasm_all_true_i16x8:
case WebAssembly::BI__builtin_wasm_all_true_i32x4:
case WebAssembly::BI__builtin_wasm_all_true_i64x2: {
unsigned IntNo;
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_any_true_i8x16:
case WebAssembly::BI__builtin_wasm_any_true_i16x8:
case WebAssembly::BI__builtin_wasm_any_true_i32x4:
case WebAssembly::BI__builtin_wasm_any_true_i64x2:
IntNo = Intrinsic::wasm_anytrue;
break;
case WebAssembly::BI__builtin_wasm_all_true_i8x16:
case WebAssembly::BI__builtin_wasm_all_true_i16x8:
case WebAssembly::BI__builtin_wasm_all_true_i32x4:
case WebAssembly::BI__builtin_wasm_all_true_i64x2:
IntNo = Intrinsic::wasm_alltrue;
break;
default:
llvm_unreachable("unexpected builtin ID");
}
Value *Vec = EmitScalarExpr(E->getArg(0));
Function *Callee = CGM.getIntrinsic(IntNo, Vec->getType());
return Builder.CreateCall(Callee, {Vec});
}
case WebAssembly::BI__builtin_wasm_bitmask_i8x16:
case WebAssembly::BI__builtin_wasm_bitmask_i16x8:
case WebAssembly::BI__builtin_wasm_bitmask_i32x4:
case WebAssembly::BI__builtin_wasm_bitmask_i64x2: {
Value *Vec = EmitScalarExpr(E->getArg(0));
Function *Callee =
CGM.getIntrinsic(Intrinsic::wasm_bitmask, Vec->getType());
return Builder.CreateCall(Callee, {Vec});
}
case WebAssembly::BI__builtin_wasm_abs_f32x4:
case WebAssembly::BI__builtin_wasm_abs_f64x2: {
Value *Vec = EmitScalarExpr(E->getArg(0));
Function *Callee = CGM.getIntrinsic(Intrinsic::fabs, Vec->getType());
return Builder.CreateCall(Callee, {Vec});
}
case WebAssembly::BI__builtin_wasm_sqrt_f32x4:
case WebAssembly::BI__builtin_wasm_sqrt_f64x2: {
Value *Vec = EmitScalarExpr(E->getArg(0));
Function *Callee = CGM.getIntrinsic(Intrinsic::sqrt, Vec->getType());
return Builder.CreateCall(Callee, {Vec});
}
case WebAssembly::BI__builtin_wasm_qfma_f32x4:
case WebAssembly::BI__builtin_wasm_qfms_f32x4:
case WebAssembly::BI__builtin_wasm_qfma_f64x2:
case WebAssembly::BI__builtin_wasm_qfms_f64x2: {
Value *A = EmitScalarExpr(E->getArg(0));
Value *B = EmitScalarExpr(E->getArg(1));
Value *C = EmitScalarExpr(E->getArg(2));
unsigned IntNo;
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_qfma_f32x4:
case WebAssembly::BI__builtin_wasm_qfma_f64x2:
IntNo = Intrinsic::wasm_qfma;
break;
case WebAssembly::BI__builtin_wasm_qfms_f32x4:
case WebAssembly::BI__builtin_wasm_qfms_f64x2:
IntNo = Intrinsic::wasm_qfms;
break;
default:
llvm_unreachable("unexpected builtin ID");
}
Function *Callee = CGM.getIntrinsic(IntNo, A->getType());
return Builder.CreateCall(Callee, {A, B, C});
}
case WebAssembly::BI__builtin_wasm_narrow_s_i8x16_i16x8:
case WebAssembly::BI__builtin_wasm_narrow_u_i8x16_i16x8:
case WebAssembly::BI__builtin_wasm_narrow_s_i16x8_i32x4:
case WebAssembly::BI__builtin_wasm_narrow_u_i16x8_i32x4: {
Value *Low = EmitScalarExpr(E->getArg(0));
Value *High = EmitScalarExpr(E->getArg(1));
unsigned IntNo;
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_narrow_s_i8x16_i16x8:
case WebAssembly::BI__builtin_wasm_narrow_s_i16x8_i32x4:
IntNo = Intrinsic::wasm_narrow_signed;
break;
case WebAssembly::BI__builtin_wasm_narrow_u_i8x16_i16x8:
case WebAssembly::BI__builtin_wasm_narrow_u_i16x8_i32x4:
IntNo = Intrinsic::wasm_narrow_unsigned;
break;
default:
llvm_unreachable("unexpected builtin ID");
}
Function *Callee =
CGM.getIntrinsic(IntNo, {ConvertType(E->getType()), Low->getType()});
return Builder.CreateCall(Callee, {Low, High});
}
case WebAssembly::BI__builtin_wasm_widen_low_s_i32x4_i64x2:
case WebAssembly::BI__builtin_wasm_widen_high_s_i32x4_i64x2:
case WebAssembly::BI__builtin_wasm_widen_low_u_i32x4_i64x2:
case WebAssembly::BI__builtin_wasm_widen_high_u_i32x4_i64x2: {
Value *Vec = EmitScalarExpr(E->getArg(0));
unsigned IntNo;
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_widen_low_s_i32x4_i64x2:
IntNo = Intrinsic::wasm_widen_low_signed;
break;
case WebAssembly::BI__builtin_wasm_widen_high_s_i32x4_i64x2:
IntNo = Intrinsic::wasm_widen_high_signed;
break;
case WebAssembly::BI__builtin_wasm_widen_low_u_i32x4_i64x2:
IntNo = Intrinsic::wasm_widen_low_unsigned;
break;
case WebAssembly::BI__builtin_wasm_widen_high_u_i32x4_i64x2:
IntNo = Intrinsic::wasm_widen_high_unsigned;
break;
}
Function *Callee = CGM.getIntrinsic(IntNo);
return Builder.CreateCall(Callee, Vec);
}
case WebAssembly::BI__builtin_wasm_load32_zero: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_load32_zero);
return Builder.CreateCall(Callee, {Ptr});
}
case WebAssembly::BI__builtin_wasm_load64_zero: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_load64_zero);
return Builder.CreateCall(Callee, {Ptr});
}
case WebAssembly::BI__builtin_wasm_load8_lane:
case WebAssembly::BI__builtin_wasm_load16_lane:
case WebAssembly::BI__builtin_wasm_load32_lane:
case WebAssembly::BI__builtin_wasm_load64_lane:
case WebAssembly::BI__builtin_wasm_store8_lane:
case WebAssembly::BI__builtin_wasm_store16_lane:
case WebAssembly::BI__builtin_wasm_store32_lane:
case WebAssembly::BI__builtin_wasm_store64_lane: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
Value *Vec = EmitScalarExpr(E->getArg(1));
Optional<llvm::APSInt> LaneIdxConst =
E->getArg(2)->getIntegerConstantExpr(getContext());
assert(LaneIdxConst && "Constant arg isn't actually constant?");
Value *LaneIdx = llvm::ConstantInt::get(getLLVMContext(), *LaneIdxConst);
unsigned IntNo;
switch (BuiltinID) {
case WebAssembly::BI__builtin_wasm_load8_lane:
IntNo = Intrinsic::wasm_load8_lane;
break;
case WebAssembly::BI__builtin_wasm_load16_lane:
IntNo = Intrinsic::wasm_load16_lane;
break;
case WebAssembly::BI__builtin_wasm_load32_lane:
IntNo = Intrinsic::wasm_load32_lane;
break;
case WebAssembly::BI__builtin_wasm_load64_lane:
IntNo = Intrinsic::wasm_load64_lane;
break;
case WebAssembly::BI__builtin_wasm_store8_lane:
IntNo = Intrinsic::wasm_store8_lane;
break;
case WebAssembly::BI__builtin_wasm_store16_lane:
IntNo = Intrinsic::wasm_store16_lane;
break;
case WebAssembly::BI__builtin_wasm_store32_lane:
IntNo = Intrinsic::wasm_store32_lane;
break;
case WebAssembly::BI__builtin_wasm_store64_lane:
IntNo = Intrinsic::wasm_store64_lane;
break;
default:
llvm_unreachable("unexpected builtin ID");
}
Function *Callee = CGM.getIntrinsic(IntNo);
return Builder.CreateCall(Callee, {Ptr, Vec, LaneIdx});
}
case WebAssembly::BI__builtin_wasm_shuffle_v8x16: {
Value *Ops[18];
size_t OpIdx = 0;
Ops[OpIdx++] = EmitScalarExpr(E->getArg(0));
Ops[OpIdx++] = EmitScalarExpr(E->getArg(1));
while (OpIdx < 18) {
Optional<llvm::APSInt> LaneConst =
E->getArg(OpIdx)->getIntegerConstantExpr(getContext());
assert(LaneConst && "Constant arg isn't actually constant?");
Ops[OpIdx++] = llvm::ConstantInt::get(getLLVMContext(), *LaneConst);
}
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_shuffle);
return Builder.CreateCall(Callee, Ops);
}
case WebAssembly::BI__builtin_wasm_prefetch_t: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_prefetch_t);
return Builder.CreateCall(Callee, Ptr);
}
case WebAssembly::BI__builtin_wasm_prefetch_nt: {
Value *Ptr = EmitScalarExpr(E->getArg(0));
Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_prefetch_nt);
return Builder.CreateCall(Callee, Ptr);
}
default:
return nullptr;
}
}
static std::pair<Intrinsic::ID, unsigned>
getIntrinsicForHexagonNonGCCBuiltin(unsigned BuiltinID) {
struct Info {
unsigned BuiltinID;
Intrinsic::ID IntrinsicID;
unsigned VecLen;
};
Info Infos[] = {
#define CUSTOM_BUILTIN_MAPPING(x,s) \
{ Hexagon::BI__builtin_HEXAGON_##x, Intrinsic::hexagon_##x, s },
CUSTOM_BUILTIN_MAPPING(L2_loadrub_pci, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadrb_pci, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadruh_pci, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadrh_pci, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadri_pci, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadrd_pci, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadrub_pcr, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadrb_pcr, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadruh_pcr, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadrh_pcr, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadri_pcr, 0)
CUSTOM_BUILTIN_MAPPING(L2_loadrd_pcr, 0)
CUSTOM_BUILTIN_MAPPING(S2_storerb_pci, 0)
CUSTOM_BUILTIN_MAPPING(S2_storerh_pci, 0)
CUSTOM_BUILTIN_MAPPING(S2_storerf_pci, 0)
CUSTOM_BUILTIN_MAPPING(S2_storeri_pci, 0)
CUSTOM_BUILTIN_MAPPING(S2_storerd_pci, 0)
CUSTOM_BUILTIN_MAPPING(S2_storerb_pcr, 0)
CUSTOM_BUILTIN_MAPPING(S2_storerh_pcr, 0)
CUSTOM_BUILTIN_MAPPING(S2_storerf_pcr, 0)
CUSTOM_BUILTIN_MAPPING(S2_storeri_pcr, 0)
CUSTOM_BUILTIN_MAPPING(S2_storerd_pcr, 0)
CUSTOM_BUILTIN_MAPPING(V6_vmaskedstoreq, 64)
CUSTOM_BUILTIN_MAPPING(V6_vmaskedstorenq, 64)
CUSTOM_BUILTIN_MAPPING(V6_vmaskedstorentq, 64)
CUSTOM_BUILTIN_MAPPING(V6_vmaskedstorentnq, 64)
CUSTOM_BUILTIN_MAPPING(V6_vmaskedstoreq_128B, 128)
CUSTOM_BUILTIN_MAPPING(V6_vmaskedstorenq_128B, 128)
CUSTOM_BUILTIN_MAPPING(V6_vmaskedstorentq_128B, 128)
CUSTOM_BUILTIN_MAPPING(V6_vmaskedstorentnq_128B, 128)
#include "clang/Basic/BuiltinsHexagonMapCustomDep.def"
#undef CUSTOM_BUILTIN_MAPPING
};
auto CmpInfo = [] (Info A, Info B) { return A.BuiltinID < B.BuiltinID; };
static const bool SortOnce = (llvm::sort(Infos, CmpInfo), true);
(void)SortOnce;
const Info *F = std::lower_bound(std::begin(Infos), std::end(Infos),
Info{BuiltinID, 0, 0}, CmpInfo);
if (F == std::end(Infos) || F->BuiltinID != BuiltinID)
return {Intrinsic::not_intrinsic, 0};
return {F->IntrinsicID, F->VecLen};
}
Value *CodeGenFunction::EmitHexagonBuiltinExpr(unsigned BuiltinID,
const CallExpr *E) {
Intrinsic::ID ID;
unsigned VecLen;
std::tie(ID, VecLen) = getIntrinsicForHexagonNonGCCBuiltin(BuiltinID);
auto MakeCircOp = [this, E](unsigned IntID, bool IsLoad) {
// The base pointer is passed by address, so it needs to be loaded.
Address A = EmitPointerWithAlignment(E->getArg(0));
Address BP = Address(
Builder.CreateBitCast(A.getPointer(), Int8PtrPtrTy), A.getAlignment());
llvm::Value *Base = Builder.CreateLoad(BP);
// The treatment of both loads and stores is the same: the arguments for
// the builtin are the same as the arguments for the intrinsic.
// Load:
// builtin(Base, Inc, Mod, Start) -> intr(Base, Inc, Mod, Start)
// builtin(Base, Mod, Start) -> intr(Base, Mod, Start)
// Store:
// builtin(Base, Inc, Mod, Val, Start) -> intr(Base, Inc, Mod, Val, Start)
// builtin(Base, Mod, Val, Start) -> intr(Base, Mod, Val, Start)
SmallVector<llvm::Value*,5> Ops = { Base };
for (unsigned i = 1, e = E->getNumArgs(); i != e; ++i)
Ops.push_back(EmitScalarExpr(E->getArg(i)));
llvm::Value *Result = Builder.CreateCall(CGM.getIntrinsic(IntID), Ops);
// The load intrinsics generate two results (Value, NewBase), stores
// generate one (NewBase). The new base address needs to be stored.
llvm::Value *NewBase = IsLoad ? Builder.CreateExtractValue(Result, 1)
: Result;
llvm::Value *LV = Builder.CreateBitCast(
EmitScalarExpr(E->getArg(0)), NewBase->getType()->getPointerTo());
Address Dest = EmitPointerWithAlignment(E->getArg(0));
llvm::Value *RetVal =
Builder.CreateAlignedStore(NewBase, LV, Dest.getAlignment());
if (IsLoad)
RetVal = Builder.CreateExtractValue(Result, 0);
return RetVal;
};
// Handle the conversion of bit-reverse load intrinsics to bit code.
// The intrinsic call after this function only reads from memory and the
// write to memory is dealt by the store instruction.
auto MakeBrevLd = [this, E](unsigned IntID, llvm::Type *DestTy) {
// The intrinsic generates one result, which is the new value for the base
// pointer. It needs to be returned. The result of the load instruction is
// passed to intrinsic by address, so the value needs to be stored.
llvm::Value *BaseAddress =
Builder.CreateBitCast(EmitScalarExpr(E->getArg(0)), Int8PtrTy);
// Expressions like &(*pt++) will be incremented per evaluation.
// EmitPointerWithAlignment and EmitScalarExpr evaluates the expression
// per call.
Address DestAddr = EmitPointerWithAlignment(E->getArg(1));
DestAddr = Address(Builder.CreateBitCast(DestAddr.getPointer(), Int8PtrTy),
DestAddr.getAlignment());
llvm::Value *DestAddress = DestAddr.getPointer();
// Operands are Base, Dest, Modifier.
// The intrinsic format in LLVM IR is defined as
// { ValueType, i8* } (i8*, i32).
llvm::Value *Result = Builder.CreateCall(
CGM.getIntrinsic(IntID), {BaseAddress, EmitScalarExpr(E->getArg(2))});
// The value needs to be stored as the variable is passed by reference.
llvm::Value *DestVal = Builder.CreateExtractValue(Result, 0);
// The store needs to be truncated to fit the destination type.
// While i32 and i64 are natively supported on Hexagon, i8 and i16 needs
// to be handled with stores of respective destination type.
DestVal = Builder.CreateTrunc(DestVal, DestTy);
llvm::Value *DestForStore =
Builder.CreateBitCast(DestAddress, DestVal->getType()->getPointerTo());
Builder.CreateAlignedStore(DestVal, DestForStore, DestAddr.getAlignment());
// The updated value of the base pointer is returned.
return Builder.CreateExtractValue(Result, 1);
};
auto V2Q = [this, VecLen] (llvm::Value *Vec) {
Intrinsic::ID ID = VecLen == 128 ? Intrinsic::hexagon_V6_vandvrt_128B
: Intrinsic::hexagon_V6_vandvrt;
return Builder.CreateCall(CGM.getIntrinsic(ID),
{Vec, Builder.getInt32(-1)});
};
auto Q2V = [this, VecLen] (llvm::Value *Pred) {
Intrinsic::ID ID = VecLen == 128 ? Intrinsic::hexagon_V6_vandqrt_128B
: Intrinsic::hexagon_V6_vandqrt;
return Builder.CreateCall(CGM.getIntrinsic(ID),
{Pred, Builder.getInt32(-1)});
};
switch (BuiltinID) {
// These intrinsics return a tuple {Vector, VectorPred} in LLVM IR,
// and the corresponding C/C++ builtins use loads/stores to update
// the predicate.
case Hexagon::BI__builtin_HEXAGON_V6_vaddcarry:
case Hexagon::BI__builtin_HEXAGON_V6_vaddcarry_128B:
case Hexagon::BI__builtin_HEXAGON_V6_vsubcarry:
case Hexagon::BI__builtin_HEXAGON_V6_vsubcarry_128B: {
// Get the type from the 0-th argument.
llvm::Type *VecType = ConvertType(E->getArg(0)->getType());
Address PredAddr = Builder.CreateBitCast(
EmitPointerWithAlignment(E->getArg(2)), VecType->getPointerTo(0));
llvm::Value *PredIn = V2Q(Builder.CreateLoad(PredAddr));
llvm::Value *Result = Builder.CreateCall(CGM.getIntrinsic(ID),
{EmitScalarExpr(E->getArg(0)), EmitScalarExpr(E->getArg(1)), PredIn});
llvm::Value *PredOut = Builder.CreateExtractValue(Result, 1);
Builder.CreateAlignedStore(Q2V(PredOut), PredAddr.getPointer(),
PredAddr.getAlignment());
return Builder.CreateExtractValue(Result, 0);
}
case Hexagon::BI__builtin_HEXAGON_L2_loadrub_pci:
case Hexagon::BI__builtin_HEXAGON_L2_loadrb_pci:
case Hexagon::BI__builtin_HEXAGON_L2_loadruh_pci:
case Hexagon::BI__builtin_HEXAGON_L2_loadrh_pci:
case Hexagon::BI__builtin_HEXAGON_L2_loadri_pci:
case Hexagon::BI__builtin_HEXAGON_L2_loadrd_pci:
case Hexagon::BI__builtin_HEXAGON_L2_loadrub_pcr:
case Hexagon::BI__builtin_HEXAGON_L2_loadrb_pcr:
case Hexagon::BI__builtin_HEXAGON_L2_loadruh_pcr:
case Hexagon::BI__builtin_HEXAGON_L2_loadrh_pcr:
case Hexagon::BI__builtin_HEXAGON_L2_loadri_pcr:
case Hexagon::BI__builtin_HEXAGON_L2_loadrd_pcr:
return MakeCircOp(ID, /*IsLoad=*/true);
case Hexagon::BI__builtin_HEXAGON_S2_storerb_pci:
case Hexagon::BI__builtin_HEXAGON_S2_storerh_pci:
case Hexagon::BI__builtin_HEXAGON_S2_storerf_pci:
case Hexagon::BI__builtin_HEXAGON_S2_storeri_pci:
case Hexagon::BI__builtin_HEXAGON_S2_storerd_pci:
case Hexagon::BI__builtin_HEXAGON_S2_storerb_pcr:
case Hexagon::BI__builtin_HEXAGON_S2_storerh_pcr:
case Hexagon::BI__builtin_HEXAGON_S2_storerf_pcr:
case Hexagon::BI__builtin_HEXAGON_S2_storeri_pcr:
case Hexagon::BI__builtin_HEXAGON_S2_storerd_pcr:
return MakeCircOp(ID, /*IsLoad=*/false);
case Hexagon::BI__builtin_brev_ldub:
return MakeBrevLd(Intrinsic::hexagon_L2_loadrub_pbr, Int8Ty);
case Hexagon::BI__builtin_brev_ldb:
return MakeBrevLd(Intrinsic::hexagon_L2_loadrb_pbr, Int8Ty);
case Hexagon::BI__builtin_brev_lduh:
return MakeBrevLd(Intrinsic::hexagon_L2_loadruh_pbr, Int16Ty);
case Hexagon::BI__builtin_brev_ldh:
return MakeBrevLd(Intrinsic::hexagon_L2_loadrh_pbr, Int16Ty);
case Hexagon::BI__builtin_brev_ldw:
return MakeBrevLd(Intrinsic::hexagon_L2_loadri_pbr, Int32Ty);
case Hexagon::BI__builtin_brev_ldd:
return MakeBrevLd(Intrinsic::hexagon_L2_loadrd_pbr, Int64Ty);
default: {
if (ID == Intrinsic::not_intrinsic)
return nullptr;
auto IsVectorPredTy = [](llvm::Type *T) {
return T->isVectorTy() &&
cast<llvm::VectorType>(T)->getElementType()->isIntegerTy(1);
};
llvm::Function *IntrFn = CGM.getIntrinsic(ID);
llvm::FunctionType *IntrTy = IntrFn->getFunctionType();
SmallVector<llvm::Value*,4> Ops;
for (unsigned i = 0, e = IntrTy->getNumParams(); i != e; ++i) {
llvm::Type *T = IntrTy->getParamType(i);
const Expr *A = E->getArg(i);
if (IsVectorPredTy(T)) {
// There will be an implicit cast to a boolean vector. Strip it.
if (auto *Cast = dyn_cast<ImplicitCastExpr>(A)) {
if (Cast->getCastKind() == CK_BitCast)
A = Cast->getSubExpr();
}
Ops.push_back(V2Q(EmitScalarExpr(A)));
} else {
Ops.push_back(EmitScalarExpr(A));
}
}
llvm::Value *Call = Builder.CreateCall(IntrFn, Ops);
if (IsVectorPredTy(IntrTy->getReturnType()))
Call = Q2V(Call);
return Call;
} // default
} // switch
return nullptr;
}
| [
"wangyankun@ishumei.com"
] | wangyankun@ishumei.com |
28cc16c8099a8d7f64ec8e5981961c6f566dbe56 | 5b5aee48a2d65e6246642d399de32c47fd24d00d | /codes/6. Music/buzzer.ino | 70d9bd02c453e8ae0ced2decfda66617001343e3 | [
"MIT"
] | permissive | khudegobeshok/arduino-learning-kit | 3e393995e7a37847bdfbececbf3e229eb480b972 | fcb714e478e95a2c8d5d235d4218bb280a9f9cd2 | refs/heads/master | 2022-11-22T08:38:03.494561 | 2020-07-16T16:04:10 | 2020-07-16T16:04:10 | 280,191,249 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,001 | ino | /* Melody
*
* This example uses a piezo speaker to play melodies. It sends
* a square wave of the appropriate frequency to the piezo, generating
* the corresponding tone.
*
* The calculation of the tones is made following the mathematical
* operation:
*
* timeHigh = period / 2 = 1 / (2 * toneFrequency)
*
* where the different tones are described as in the table:
*
* note frequency period timeHigh
* c 261 Hz 3830 1915
* d 294 Hz 3400 1700
* e 329 Hz 3038 1519
* f 349 Hz 2864 1432
* g 392 Hz 2550 1275
* a 440 Hz 2272 1136
* b 493 Hz 2028 1014
* C 523 Hz 1912 956
*
* http://www.arduino.cc/en/Tutorial/Melody
*/
int speakerPin = 9;
int length = 15; // the number of notes
char notes[] = "ccggaagffeeddc "; // a space represents a rest
int beats[] = {1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4};
int tempo = 300;
void playTone(int tone, int duration)
{
for (long i = 0; i < duration * 1000L; i += tone * 2)
{
digitalWrite(speakerPin, HIGH);
delayMicroseconds(tone);
digitalWrite(speakerPin, LOW);
delayMicroseconds(tone);
}
}
void playNote(char note, int duration)
{
char names[] = {'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C'};
int tones[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956};
// play the tone corresponding to the note name
for (int i = 0; i < 8; i++)
{
if (names[i] == note)
{
playTone(tones[i], duration);
}
}
}
void setup()
{
pinMode(speakerPin, OUTPUT);
}
void loop()
{
for (int i = 0; i < length; i++)
{
if (notes[i] == ' ')
{
delay(beats[i] * tempo); // rest
}
else
{
playNote(notes[i], beats[i] * tempo);
}
// pause between notes
delay(tempo / 2);
}
} | [
"alamin.ece.ku@gmail.com"
] | alamin.ece.ku@gmail.com |
9d8bb50f29494f4885d51c279255fccf7cb17737 | 82807ca4a9e755782778f02695461f6a083fdfdf | /cloudwalk2/main.cpp | 5ccabf16db59d5eb9fdf9f4d1c48c42c92e3c701 | [] | no_license | hanny-liu/offer | b267e3ae32151d8d4d24f4eb30ab3f5b5a6742c7 | 62eac9d37ad10cb16925324fa8337ba098f225be | refs/heads/master | 2020-07-24T06:51:03.676844 | 2019-09-11T14:45:05 | 2019-09-11T14:45:05 | 207,835,048 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,647 | cpp | #include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
using namespace std;
int main() {
int n,m;
vector<int> si;
string line;
int num(0);
while(num<2)
{
getline(cin,line);
istringstream is(line);
string word;
if(num==0)
{
string t1,t2;
is>>t1>>t2;
n=stoi(t1);
m=stoi(t2);
} else
{
while(is>>word)
{
si.push_back(stoi(word));
}
}
num++;
}
sort(si.begin(),si.end());
vector<int> result;
result.push_back(si[0]);
for(int i=1;i<m;++i)
{
int max(0);
int id;
for(int j=i;j<n;++j)
{
if(result.size()==1)
{
if(max<abs(result[0]-si[j]))
{
max=abs(result[0]-si[j]);
id=j;
}
} else
{
int t=1;
for(int k=0;k<result.size();++k)
{
t*=abs(result[k]-si[j]);
}
if(t>max)
{
max=t;
id=j;
}
}
}
result.push_back(si[id]);
swap(si[id],si[i]);
}
int min=abs(result[1]-result[0]);
for(int i=0;i<result.size();++i)
{
for(int j=i+1;j<result.size();j++)
{
if(abs(result[i]-result[j])<min)
min=abs(result[i]-result[j]);
}
}
cout<<min<<endl;
return 0;
} | [
"1299250637@qq.com"
] | 1299250637@qq.com |
4767c94fa75d0ccb4ff3843798cb9e2f3a2b062e | dd80a584130ef1a0333429ba76c1cee0eb40df73 | /external/chromium_org/third_party/skia/src/core/SkScan_Antihair.cpp | a6a0869f224b663ae26dd65467be35135b43e3c0 | [
"BSD-3-Clause",
"MIT",
"GPL-1.0-or-later",
"LGPL-2.0-or-later",
"Apache-2.0"
] | permissive | karunmatharu/Android-4.4-Pay-by-Data | 466f4e169ede13c5835424c78e8c30ce58f885c1 | fcb778e92d4aad525ef7a995660580f948d40bc9 | refs/heads/master | 2021-03-24T13:33:01.721868 | 2017-02-18T17:48:49 | 2017-02-18T17:48:49 | 81,847,777 | 0 | 2 | MIT | 2020-03-09T00:02:12 | 2017-02-13T16:47:00 | null | UTF-8 | C++ | false | false | 32,577 | cpp |
/*
* Copyright 2011 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkScan.h"
#include "SkBlitter.h"
#include "SkColorPriv.h"
#include "SkLineClipper.h"
#include "SkRasterClip.h"
#include "SkFDot6.h"
/* Our attempt to compute the worst case "bounds" for the horizontal and
vertical cases has some numerical bug in it, and we sometimes undervalue
our extends. The bug is that when this happens, we will set the clip to
NULL (for speed), and thus draw outside of the clip by a pixel, which might
only look bad, but it might also access memory outside of the valid range
allcoated for the device bitmap.
This define enables our fix to outset our "bounds" by 1, thus avoiding the
chance of the bug, but at the cost of sometimes taking the rectblitter
case (i.e. not setting the clip to NULL) when we might not actually need
to. If we can improve/fix the actual calculations, then we can remove this
step.
*/
#define OUTSET_BEFORE_CLIP_TEST true
#define HLINE_STACK_BUFFER 100
static inline int SmallDot6Scale(int value, int dot6) {
SkASSERT((int16_t)value == value);
SkASSERT((unsigned)dot6 <= 64);
return SkMulS16(value, dot6) >> 6;
}
//#define TEST_GAMMA
#ifdef TEST_GAMMA
static uint8_t gGammaTable[256];
#define ApplyGamma(table, alpha) (table)[alpha]
static void build_gamma_table() {
static bool gInit = false;
if (gInit == false) {
for (int i = 0; i < 256; i++) {
SkFixed n = i * 257;
n += n >> 15;
SkASSERT(n >= 0 && n <= SK_Fixed1);
n = SkFixedSqrt(n);
n = n * 255 >> 16;
// SkDebugf("morph %d -> %d\n", i, n);
gGammaTable[i] = SkToU8(n);
}
gInit = true;
}
}
#else
#define ApplyGamma(table, alpha) SkToU8(alpha)
#endif
///////////////////////////////////////////////////////////////////////////////
static void call_hline_blitter(SkBlitter* blitter, int x, int y, int count,
U8CPU alpha) {
SkASSERT(count > 0);
int16_t runs[HLINE_STACK_BUFFER + 1];
uint8_t aa[HLINE_STACK_BUFFER];
aa[0] = ApplyGamma(gGammaTable, alpha);
do {
int n = count;
if (n > HLINE_STACK_BUFFER) {
n = HLINE_STACK_BUFFER;
}
runs[0] = SkToS16(n);
runs[n] = 0;
blitter->blitAntiH(x, y, aa, runs);
x += n;
count -= n;
} while (count > 0);
}
class SkAntiHairBlitter {
public:
SkAntiHairBlitter() : fBlitter(NULL) {}
virtual ~SkAntiHairBlitter() {}
SkBlitter* getBlitter() const { return fBlitter; }
void setup(SkBlitter* blitter) {
fBlitter = blitter;
}
virtual SkFixed drawCap(int x, SkFixed fy, SkFixed slope, int mod64) = 0;
virtual SkFixed drawLine(int x, int stopx, SkFixed fy, SkFixed slope) = 0;
private:
SkBlitter* fBlitter;
};
class HLine_SkAntiHairBlitter : public SkAntiHairBlitter {
public:
virtual SkFixed drawCap(int x, SkFixed fy, SkFixed slope, int mod64) SK_OVERRIDE {
fy += SK_Fixed1/2;
int y = fy >> 16;
uint8_t a = (uint8_t)(fy >> 8);
// lower line
unsigned ma = SmallDot6Scale(a, mod64);
if (ma) {
call_hline_blitter(this->getBlitter(), x, y, 1, ma);
}
// upper line
ma = SmallDot6Scale(255 - a, mod64);
if (ma) {
call_hline_blitter(this->getBlitter(), x, y - 1, 1, ma);
}
return fy - SK_Fixed1/2;
}
virtual SkFixed drawLine(int x, int stopx, SkFixed fy,
SkFixed slope) SK_OVERRIDE {
SkASSERT(x < stopx);
int count = stopx - x;
fy += SK_Fixed1/2;
int y = fy >> 16;
uint8_t a = (uint8_t)(fy >> 8);
// lower line
if (a) {
call_hline_blitter(this->getBlitter(), x, y, count, a);
}
// upper line
a = 255 - a;
if (a) {
call_hline_blitter(this->getBlitter(), x, y - 1, count, a);
}
return fy - SK_Fixed1/2;
}
};
class Horish_SkAntiHairBlitter : public SkAntiHairBlitter {
public:
virtual SkFixed drawCap(int x, SkFixed fy, SkFixed dy, int mod64) SK_OVERRIDE {
int16_t runs[2];
uint8_t aa[1];
runs[0] = 1;
runs[1] = 0;
fy += SK_Fixed1/2;
SkBlitter* blitter = this->getBlitter();
int lower_y = fy >> 16;
uint8_t a = (uint8_t)(fy >> 8);
unsigned ma = SmallDot6Scale(a, mod64);
if (ma) {
aa[0] = ApplyGamma(gamma, ma);
blitter->blitAntiH(x, lower_y, aa, runs);
// the clipping blitters might edit runs, but should not affect us
SkASSERT(runs[0] == 1);
SkASSERT(runs[1] == 0);
}
ma = SmallDot6Scale(255 - a, mod64);
if (ma) {
aa[0] = ApplyGamma(gamma, ma);
blitter->blitAntiH(x, lower_y - 1, aa, runs);
// the clipping blitters might edit runs, but should not affect us
SkASSERT(runs[0] == 1);
SkASSERT(runs[1] == 0);
}
fy += dy;
return fy - SK_Fixed1/2;
}
virtual SkFixed drawLine(int x, int stopx, SkFixed fy, SkFixed dy) SK_OVERRIDE {
SkASSERT(x < stopx);
int16_t runs[2];
uint8_t aa[1];
runs[0] = 1;
runs[1] = 0;
fy += SK_Fixed1/2;
SkBlitter* blitter = this->getBlitter();
do {
int lower_y = fy >> 16;
uint8_t a = (uint8_t)(fy >> 8);
if (a) {
aa[0] = a;
blitter->blitAntiH(x, lower_y, aa, runs);
// the clipping blitters might edit runs, but should not affect us
SkASSERT(runs[0] == 1);
SkASSERT(runs[1] == 0);
}
a = 255 - a;
if (a) {
aa[0] = a;
blitter->blitAntiH(x, lower_y - 1, aa, runs);
// the clipping blitters might edit runs, but should not affect us
SkASSERT(runs[0] == 1);
SkASSERT(runs[1] == 0);
}
fy += dy;
} while (++x < stopx);
return fy - SK_Fixed1/2;
}
};
class VLine_SkAntiHairBlitter : public SkAntiHairBlitter {
public:
virtual SkFixed drawCap(int y, SkFixed fx, SkFixed dx, int mod64) SK_OVERRIDE {
SkASSERT(0 == dx);
fx += SK_Fixed1/2;
int x = fx >> 16;
int a = (uint8_t)(fx >> 8);
unsigned ma = SmallDot6Scale(a, mod64);
if (ma) {
this->getBlitter()->blitV(x, y, 1, ma);
}
ma = SmallDot6Scale(255 - a, mod64);
if (ma) {
this->getBlitter()->blitV(x - 1, y, 1, ma);
}
return fx - SK_Fixed1/2;
}
virtual SkFixed drawLine(int y, int stopy, SkFixed fx, SkFixed dx) SK_OVERRIDE {
SkASSERT(y < stopy);
SkASSERT(0 == dx);
fx += SK_Fixed1/2;
int x = fx >> 16;
int a = (uint8_t)(fx >> 8);
if (a) {
this->getBlitter()->blitV(x, y, stopy - y, a);
}
a = 255 - a;
if (a) {
this->getBlitter()->blitV(x - 1, y, stopy - y, a);
}
return fx - SK_Fixed1/2;
}
};
class Vertish_SkAntiHairBlitter : public SkAntiHairBlitter {
public:
virtual SkFixed drawCap(int y, SkFixed fx, SkFixed dx, int mod64) SK_OVERRIDE {
int16_t runs[3];
uint8_t aa[2];
runs[0] = 1;
runs[2] = 0;
fx += SK_Fixed1/2;
int x = fx >> 16;
uint8_t a = (uint8_t)(fx >> 8);
aa[0] = SmallDot6Scale(255 - a, mod64);
aa[1] = SmallDot6Scale(a, mod64);
// the clippng blitters might overwrite this guy, so we have to reset it each time
runs[1] = 1;
this->getBlitter()->blitAntiH(x - 1, y, aa, runs);
// the clipping blitters might edit runs, but should not affect us
SkASSERT(runs[0] == 1);
SkASSERT(runs[2] == 0);
fx += dx;
return fx - SK_Fixed1/2;
}
virtual SkFixed drawLine(int y, int stopy, SkFixed fx, SkFixed dx) SK_OVERRIDE {
SkASSERT(y < stopy);
int16_t runs[3];
uint8_t aa[2];
runs[0] = 1;
runs[2] = 0;
fx += SK_Fixed1/2;
do {
int x = fx >> 16;
uint8_t a = (uint8_t)(fx >> 8);
aa[0] = 255 - a;
aa[1] = a;
// the clippng blitters might overwrite this guy, so we have to reset it each time
runs[1] = 1;
this->getBlitter()->blitAntiH(x - 1, y, aa, runs);
// the clipping blitters might edit runs, but should not affect us
SkASSERT(runs[0] == 1);
SkASSERT(runs[2] == 0);
fx += dx;
} while (++y < stopy);
return fx - SK_Fixed1/2;
}
};
static inline SkFixed fastfixdiv(SkFDot6 a, SkFDot6 b) {
SkASSERT((a << 16 >> 16) == a);
SkASSERT(b != 0);
return (a << 16) / b;
}
#define SkBITCOUNT(x) (sizeof(x) << 3)
#if 1
// returns high-bit set iff x==0x8000...
static inline int bad_int(int x) {
return x & -x;
}
static int any_bad_ints(int a, int b, int c, int d) {
return (bad_int(a) | bad_int(b) | bad_int(c) | bad_int(d)) >> (SkBITCOUNT(int) - 1);
}
#else
static inline int good_int(int x) {
return x ^ (1 << (SkBITCOUNT(x) - 1));
}
static int any_bad_ints(int a, int b, int c, int d) {
return !(good_int(a) & good_int(b) & good_int(c) & good_int(d));
}
#endif
#ifdef SK_DEBUG
static bool canConvertFDot6ToFixed(SkFDot6 x) {
const int maxDot6 = SK_MaxS32 >> (16 - 6);
return SkAbs32(x) <= maxDot6;
}
#endif
/*
* We want the fractional part of ordinate, but we want multiples of 64 to
* return 64, not 0, so we can't just say (ordinate & 63).
* We basically want to compute those bits, and if they're 0, return 64.
* We can do that w/o a branch with an extra sub and add.
*/
static int contribution_64(SkFDot6 ordinate) {
#if 0
int result = ordinate & 63;
if (0 == result) {
result = 64;
}
#else
int result = ((ordinate - 1) & 63) + 1;
#endif
SkASSERT(result > 0 && result <= 64);
return result;
}
static void do_anti_hairline(SkFDot6 x0, SkFDot6 y0, SkFDot6 x1, SkFDot6 y1,
const SkIRect* clip, SkBlitter* blitter) {
// check for integer NaN (0x80000000) which we can't handle (can't negate it)
// It appears typically from a huge float (inf or nan) being converted to int.
// If we see it, just don't draw.
if (any_bad_ints(x0, y0, x1, y1)) {
return;
}
// The caller must clip the line to [-32767.0 ... 32767.0] ahead of time
// (in dot6 format)
SkASSERT(canConvertFDot6ToFixed(x0));
SkASSERT(canConvertFDot6ToFixed(y0));
SkASSERT(canConvertFDot6ToFixed(x1));
SkASSERT(canConvertFDot6ToFixed(y1));
if (SkAbs32(x1 - x0) > SkIntToFDot6(511) || SkAbs32(y1 - y0) > SkIntToFDot6(511)) {
/* instead of (x0 + x1) >> 1, we shift each separately. This is less
precise, but avoids overflowing the intermediate result if the
values are huge. A better fix might be to clip the original pts
directly (i.e. do the divide), so we don't spend time subdividing
huge lines at all.
*/
int hx = (x0 >> 1) + (x1 >> 1);
int hy = (y0 >> 1) + (y1 >> 1);
do_anti_hairline(x0, y0, hx, hy, clip, blitter);
do_anti_hairline(hx, hy, x1, y1, clip, blitter);
return;
}
int scaleStart, scaleStop;
int istart, istop;
SkFixed fstart, slope;
HLine_SkAntiHairBlitter hline_blitter;
Horish_SkAntiHairBlitter horish_blitter;
VLine_SkAntiHairBlitter vline_blitter;
Vertish_SkAntiHairBlitter vertish_blitter;
SkAntiHairBlitter* hairBlitter = NULL;
if (SkAbs32(x1 - x0) > SkAbs32(y1 - y0)) { // mostly horizontal
if (x0 > x1) { // we want to go left-to-right
SkTSwap<SkFDot6>(x0, x1);
SkTSwap<SkFDot6>(y0, y1);
}
istart = SkFDot6Floor(x0);
istop = SkFDot6Ceil(x1);
fstart = SkFDot6ToFixed(y0);
if (y0 == y1) { // completely horizontal, take fast case
slope = 0;
hairBlitter = &hline_blitter;
} else {
slope = fastfixdiv(y1 - y0, x1 - x0);
SkASSERT(slope >= -SK_Fixed1 && slope <= SK_Fixed1);
fstart += (slope * (32 - (x0 & 63)) + 32) >> 6;
hairBlitter = &horish_blitter;
}
SkASSERT(istop > istart);
if (istop - istart == 1) {
// we are within a single pixel
scaleStart = x1 - x0;
SkASSERT(scaleStart >= 0 && scaleStart <= 64);
scaleStop = 0;
} else {
scaleStart = 64 - (x0 & 63);
scaleStop = x1 & 63;
}
if (clip){
if (istart >= clip->fRight || istop <= clip->fLeft) {
return;
}
if (istart < clip->fLeft) {
fstart += slope * (clip->fLeft - istart);
istart = clip->fLeft;
scaleStart = 64;
if (istop - istart == 1) {
// we are within a single pixel
scaleStart = contribution_64(x1);
scaleStop = 0;
}
}
if (istop > clip->fRight) {
istop = clip->fRight;
scaleStop = 0; // so we don't draw this last column
}
SkASSERT(istart <= istop);
if (istart == istop) {
return;
}
// now test if our Y values are completely inside the clip
int top, bottom;
if (slope >= 0) { // T2B
top = SkFixedFloor(fstart - SK_FixedHalf);
bottom = SkFixedCeil(fstart + (istop - istart - 1) * slope + SK_FixedHalf);
} else { // B2T
bottom = SkFixedCeil(fstart + SK_FixedHalf);
top = SkFixedFloor(fstart + (istop - istart - 1) * slope - SK_FixedHalf);
}
#ifdef OUTSET_BEFORE_CLIP_TEST
top -= 1;
bottom += 1;
#endif
if (top >= clip->fBottom || bottom <= clip->fTop) {
return;
}
if (clip->fTop <= top && clip->fBottom >= bottom) {
clip = NULL;
}
}
} else { // mostly vertical
if (y0 > y1) { // we want to go top-to-bottom
SkTSwap<SkFDot6>(x0, x1);
SkTSwap<SkFDot6>(y0, y1);
}
istart = SkFDot6Floor(y0);
istop = SkFDot6Ceil(y1);
fstart = SkFDot6ToFixed(x0);
if (x0 == x1) {
if (y0 == y1) { // are we zero length?
return; // nothing to do
}
slope = 0;
hairBlitter = &vline_blitter;
} else {
slope = fastfixdiv(x1 - x0, y1 - y0);
SkASSERT(slope <= SK_Fixed1 && slope >= -SK_Fixed1);
fstart += (slope * (32 - (y0 & 63)) + 32) >> 6;
hairBlitter = &vertish_blitter;
}
SkASSERT(istop > istart);
if (istop - istart == 1) {
// we are within a single pixel
scaleStart = y1 - y0;
SkASSERT(scaleStart >= 0 && scaleStart <= 64);
scaleStop = 0;
} else {
scaleStart = 64 - (y0 & 63);
scaleStop = y1 & 63;
}
if (clip) {
if (istart >= clip->fBottom || istop <= clip->fTop) {
return;
}
if (istart < clip->fTop) {
fstart += slope * (clip->fTop - istart);
istart = clip->fTop;
scaleStart = 64;
if (istop - istart == 1) {
// we are within a single pixel
scaleStart = contribution_64(y1);
scaleStop = 0;
}
}
if (istop > clip->fBottom) {
istop = clip->fBottom;
scaleStop = 0; // so we don't draw this last row
}
SkASSERT(istart <= istop);
if (istart == istop)
return;
// now test if our X values are completely inside the clip
int left, right;
if (slope >= 0) { // L2R
left = SkFixedFloor(fstart - SK_FixedHalf);
right = SkFixedCeil(fstart + (istop - istart - 1) * slope + SK_FixedHalf);
} else { // R2L
right = SkFixedCeil(fstart + SK_FixedHalf);
left = SkFixedFloor(fstart + (istop - istart - 1) * slope - SK_FixedHalf);
}
#ifdef OUTSET_BEFORE_CLIP_TEST
left -= 1;
right += 1;
#endif
if (left >= clip->fRight || right <= clip->fLeft) {
return;
}
if (clip->fLeft <= left && clip->fRight >= right) {
clip = NULL;
}
}
}
SkRectClipBlitter rectClipper;
if (clip) {
rectClipper.init(blitter, *clip);
blitter = &rectClipper;
}
SkASSERT(hairBlitter);
hairBlitter->setup(blitter);
#ifdef SK_DEBUG
if (scaleStart > 0 && scaleStop > 0) {
// be sure we don't draw twice in the same pixel
SkASSERT(istart < istop - 1);
}
#endif
fstart = hairBlitter->drawCap(istart, fstart, slope, scaleStart);
istart += 1;
int fullSpans = istop - istart - (scaleStop > 0);
if (fullSpans > 0) {
fstart = hairBlitter->drawLine(istart, istart + fullSpans, fstart, slope);
}
if (scaleStop > 0) {
hairBlitter->drawCap(istop - 1, fstart, slope, scaleStop);
}
}
void SkScan::AntiHairLineRgn(const SkPoint& pt0, const SkPoint& pt1,
const SkRegion* clip, SkBlitter* blitter) {
if (clip && clip->isEmpty()) {
return;
}
SkASSERT(clip == NULL || !clip->getBounds().isEmpty());
#ifdef TEST_GAMMA
build_gamma_table();
#endif
SkPoint pts[2] = { pt0, pt1 };
#ifdef SK_SCALAR_IS_FLOAT
// We have to pre-clip the line to fit in a SkFixed, so we just chop
// the line. TODO find a way to actually draw beyond that range.
{
SkRect fixedBounds;
const SkScalar max = SkIntToScalar(32767);
fixedBounds.set(-max, -max, max, max);
if (!SkLineClipper::IntersectLine(pts, fixedBounds, pts)) {
return;
}
}
#endif
if (clip) {
SkRect clipBounds;
clipBounds.set(clip->getBounds());
/* We perform integral clipping later on, but we do a scalar clip first
to ensure that our coordinates are expressible in fixed/integers.
antialiased hairlines can draw up to 1/2 of a pixel outside of
their bounds, so we need to outset the clip before calling the
clipper. To make the numerics safer, we outset by a whole pixel,
since the 1/2 pixel boundary is important to the antihair blitter,
we don't want to risk numerical fate by chopping on that edge.
*/
clipBounds.inset(-SK_Scalar1, -SK_Scalar1);
if (!SkLineClipper::IntersectLine(pts, clipBounds, pts)) {
return;
}
}
SkFDot6 x0 = SkScalarToFDot6(pts[0].fX);
SkFDot6 y0 = SkScalarToFDot6(pts[0].fY);
SkFDot6 x1 = SkScalarToFDot6(pts[1].fX);
SkFDot6 y1 = SkScalarToFDot6(pts[1].fY);
if (clip) {
SkFDot6 left = SkMin32(x0, x1);
SkFDot6 top = SkMin32(y0, y1);
SkFDot6 right = SkMax32(x0, x1);
SkFDot6 bottom = SkMax32(y0, y1);
SkIRect ir;
ir.set( SkFDot6Floor(left) - 1,
SkFDot6Floor(top) - 1,
SkFDot6Ceil(right) + 1,
SkFDot6Ceil(bottom) + 1);
if (clip->quickReject(ir)) {
return;
}
if (!clip->quickContains(ir)) {
SkRegion::Cliperator iter(*clip, ir);
const SkIRect* r = &iter.rect();
while (!iter.done()) {
do_anti_hairline(x0, y0, x1, y1, r, blitter);
iter.next();
}
return;
}
// fall through to no-clip case
}
do_anti_hairline(x0, y0, x1, y1, NULL, blitter);
}
void SkScan::AntiHairRect(const SkRect& rect, const SkRasterClip& clip,
SkBlitter* blitter) {
SkPoint p0, p1;
p0.set(rect.fLeft, rect.fTop);
p1.set(rect.fRight, rect.fTop);
SkScan::AntiHairLine(p0, p1, clip, blitter);
p0.set(rect.fRight, rect.fBottom);
SkScan::AntiHairLine(p0, p1, clip, blitter);
p1.set(rect.fLeft, rect.fBottom);
SkScan::AntiHairLine(p0, p1, clip, blitter);
p0.set(rect.fLeft, rect.fTop);
SkScan::AntiHairLine(p0, p1, clip, blitter);
}
///////////////////////////////////////////////////////////////////////////////
typedef int FDot8; // 24.8 integer fixed point
static inline FDot8 SkFixedToFDot8(SkFixed x) {
return (x + 0x80) >> 8;
}
static void do_scanline(FDot8 L, int top, FDot8 R, U8CPU alpha,
SkBlitter* blitter) {
SkASSERT(L < R);
if ((L >> 8) == ((R - 1) >> 8)) { // 1x1 pixel
blitter->blitV(L >> 8, top, 1, SkAlphaMul(alpha, R - L));
return;
}
int left = L >> 8;
if (L & 0xFF) {
blitter->blitV(left, top, 1, SkAlphaMul(alpha, 256 - (L & 0xFF)));
left += 1;
}
int rite = R >> 8;
int width = rite - left;
if (width > 0) {
call_hline_blitter(blitter, left, top, width, alpha);
}
if (R & 0xFF) {
blitter->blitV(rite, top, 1, SkAlphaMul(alpha, R & 0xFF));
}
}
static void antifilldot8(FDot8 L, FDot8 T, FDot8 R, FDot8 B, SkBlitter* blitter,
bool fillInner) {
// check for empty now that we're in our reduced precision space
if (L >= R || T >= B) {
return;
}
int top = T >> 8;
if (top == ((B - 1) >> 8)) { // just one scanline high
do_scanline(L, top, R, B - T - 1, blitter);
return;
}
if (T & 0xFF) {
do_scanline(L, top, R, 256 - (T & 0xFF), blitter);
top += 1;
}
int bot = B >> 8;
int height = bot - top;
if (height > 0) {
int left = L >> 8;
if (left == ((R - 1) >> 8)) { // just 1-pixel wide
blitter->blitV(left, top, height, R - L - 1);
} else {
if (L & 0xFF) {
blitter->blitV(left, top, height, 256 - (L & 0xFF));
left += 1;
}
int rite = R >> 8;
int width = rite - left;
if (width > 0 && fillInner) {
blitter->blitRect(left, top, width, height);
}
if (R & 0xFF) {
blitter->blitV(rite, top, height, R & 0xFF);
}
}
}
if (B & 0xFF) {
do_scanline(L, bot, R, B & 0xFF, blitter);
}
}
static void antifillrect(const SkXRect& xr, SkBlitter* blitter) {
antifilldot8(SkFixedToFDot8(xr.fLeft), SkFixedToFDot8(xr.fTop),
SkFixedToFDot8(xr.fRight), SkFixedToFDot8(xr.fBottom),
blitter, true);
}
///////////////////////////////////////////////////////////////////////////////
void SkScan::AntiFillXRect(const SkXRect& xr, const SkRegion* clip,
SkBlitter* blitter) {
if (NULL == clip) {
antifillrect(xr, blitter);
} else {
SkIRect outerBounds;
XRect_roundOut(xr, &outerBounds);
if (clip->isRect()) {
const SkIRect& clipBounds = clip->getBounds();
if (clipBounds.contains(outerBounds)) {
antifillrect(xr, blitter);
} else {
SkXRect tmpR;
// this keeps our original edges fractional
XRect_set(&tmpR, clipBounds);
if (tmpR.intersect(xr)) {
antifillrect(tmpR, blitter);
}
}
} else {
SkRegion::Cliperator clipper(*clip, outerBounds);
const SkIRect& rr = clipper.rect();
while (!clipper.done()) {
SkXRect tmpR;
// this keeps our original edges fractional
XRect_set(&tmpR, rr);
if (tmpR.intersect(xr)) {
antifillrect(tmpR, blitter);
}
clipper.next();
}
}
}
}
void SkScan::AntiFillXRect(const SkXRect& xr, const SkRasterClip& clip,
SkBlitter* blitter) {
if (clip.isBW()) {
AntiFillXRect(xr, &clip.bwRgn(), blitter);
} else {
SkIRect outerBounds;
XRect_roundOut(xr, &outerBounds);
if (clip.quickContains(outerBounds)) {
AntiFillXRect(xr, NULL, blitter);
} else {
SkAAClipBlitterWrapper wrapper(clip, blitter);
blitter = wrapper.getBlitter();
AntiFillXRect(xr, &wrapper.getRgn(), wrapper.getBlitter());
}
}
}
#ifdef SK_SCALAR_IS_FLOAT
/* This guy takes a float-rect, but with the key improvement that it has
already been clipped, so we know that it is safe to convert it into a
XRect (fixedpoint), as it won't overflow.
*/
static void antifillrect(const SkRect& r, SkBlitter* blitter) {
SkXRect xr;
XRect_set(&xr, r);
antifillrect(xr, blitter);
}
/* We repeat the clipping logic of AntiFillXRect because the float rect might
overflow if we blindly converted it to an XRect. This sucks that we have to
repeat the clipping logic, but I don't see how to share the code/logic.
We clip r (as needed) into one or more (smaller) float rects, and then pass
those to our version of antifillrect, which converts it into an XRect and
then calls the blit.
*/
void SkScan::AntiFillRect(const SkRect& origR, const SkRegion* clip,
SkBlitter* blitter) {
if (clip) {
SkRect newR;
newR.set(clip->getBounds());
if (!newR.intersect(origR)) {
return;
}
SkIRect outerBounds;
newR.roundOut(&outerBounds);
if (clip->isRect()) {
antifillrect(newR, blitter);
} else {
SkRegion::Cliperator clipper(*clip, outerBounds);
while (!clipper.done()) {
newR.set(clipper.rect());
if (newR.intersect(origR)) {
antifillrect(newR, blitter);
}
clipper.next();
}
}
} else {
antifillrect(origR, blitter);
}
}
void SkScan::AntiFillRect(const SkRect& r, const SkRasterClip& clip,
SkBlitter* blitter) {
if (clip.isBW()) {
AntiFillRect(r, &clip.bwRgn(), blitter);
} else {
SkAAClipBlitterWrapper wrap(clip, blitter);
AntiFillRect(r, &wrap.getRgn(), wrap.getBlitter());
}
}
#endif // SK_SCALAR_IS_FLOAT
///////////////////////////////////////////////////////////////////////////////
#define SkAlphaMulRound(a, b) SkMulDiv255Round(a, b)
// calls blitRect() if the rectangle is non-empty
static void fillcheckrect(int L, int T, int R, int B, SkBlitter* blitter) {
if (L < R && T < B) {
blitter->blitRect(L, T, R - L, B - T);
}
}
static inline FDot8 SkScalarToFDot8(SkScalar x) {
#ifdef SK_SCALAR_IS_FLOAT
return (int)(x * 256);
#else
return x >> 8;
#endif
}
static inline int FDot8Floor(FDot8 x) {
return x >> 8;
}
static inline int FDot8Ceil(FDot8 x) {
return (x + 0xFF) >> 8;
}
// 1 - (1 - a)*(1 - b)
static inline U8CPU InvAlphaMul(U8CPU a, U8CPU b) {
// need precise rounding (not just SkAlphaMul) so that values like
// a=228, b=252 don't overflow the result
return SkToU8(a + b - SkAlphaMulRound(a, b));
}
static void inner_scanline(FDot8 L, int top, FDot8 R, U8CPU alpha,
SkBlitter* blitter) {
SkASSERT(L < R);
if ((L >> 8) == ((R - 1) >> 8)) { // 1x1 pixel
blitter->blitV(L >> 8, top, 1, InvAlphaMul(alpha, R - L));
return;
}
int left = L >> 8;
if (L & 0xFF) {
blitter->blitV(left, top, 1, InvAlphaMul(alpha, L & 0xFF));
left += 1;
}
int rite = R >> 8;
int width = rite - left;
if (width > 0) {
call_hline_blitter(blitter, left, top, width, alpha);
}
if (R & 0xFF) {
blitter->blitV(rite, top, 1, InvAlphaMul(alpha, ~R & 0xFF));
}
}
static void innerstrokedot8(FDot8 L, FDot8 T, FDot8 R, FDot8 B,
SkBlitter* blitter) {
SkASSERT(L < R && T < B);
int top = T >> 8;
if (top == ((B - 1) >> 8)) { // just one scanline high
// We want the inverse of B-T, since we're the inner-stroke
int alpha = 256 - (B - T);
if (alpha) {
inner_scanline(L, top, R, alpha, blitter);
}
return;
}
if (T & 0xFF) {
inner_scanline(L, top, R, T & 0xFF, blitter);
top += 1;
}
int bot = B >> 8;
int height = bot - top;
if (height > 0) {
if (L & 0xFF) {
blitter->blitV(L >> 8, top, height, L & 0xFF);
}
if (R & 0xFF) {
blitter->blitV(R >> 8, top, height, ~R & 0xFF);
}
}
if (B & 0xFF) {
inner_scanline(L, bot, R, ~B & 0xFF, blitter);
}
}
void SkScan::AntiFrameRect(const SkRect& r, const SkPoint& strokeSize,
const SkRegion* clip, SkBlitter* blitter) {
SkASSERT(strokeSize.fX >= 0 && strokeSize.fY >= 0);
SkScalar rx = SkScalarHalf(strokeSize.fX);
SkScalar ry = SkScalarHalf(strokeSize.fY);
// outset by the radius
FDot8 L = SkScalarToFDot8(r.fLeft - rx);
FDot8 T = SkScalarToFDot8(r.fTop - ry);
FDot8 R = SkScalarToFDot8(r.fRight + rx);
FDot8 B = SkScalarToFDot8(r.fBottom + ry);
SkIRect outer;
// set outer to the outer rect of the outer section
outer.set(FDot8Floor(L), FDot8Floor(T), FDot8Ceil(R), FDot8Ceil(B));
SkBlitterClipper clipper;
if (clip) {
if (clip->quickReject(outer)) {
return;
}
if (!clip->contains(outer)) {
blitter = clipper.apply(blitter, clip, &outer);
}
// now we can ignore clip for the rest of the function
}
// stroke the outer hull
antifilldot8(L, T, R, B, blitter, false);
// set outer to the outer rect of the middle section
outer.set(FDot8Ceil(L), FDot8Ceil(T), FDot8Floor(R), FDot8Floor(B));
// in case we lost a bit with diameter/2
rx = strokeSize.fX - rx;
ry = strokeSize.fY - ry;
// inset by the radius
L = SkScalarToFDot8(r.fLeft + rx);
T = SkScalarToFDot8(r.fTop + ry);
R = SkScalarToFDot8(r.fRight - rx);
B = SkScalarToFDot8(r.fBottom - ry);
if (L >= R || T >= B) {
fillcheckrect(outer.fLeft, outer.fTop, outer.fRight, outer.fBottom,
blitter);
} else {
SkIRect inner;
// set inner to the inner rect of the middle section
inner.set(FDot8Floor(L), FDot8Floor(T), FDot8Ceil(R), FDot8Ceil(B));
// draw the frame in 4 pieces
fillcheckrect(outer.fLeft, outer.fTop, outer.fRight, inner.fTop,
blitter);
fillcheckrect(outer.fLeft, inner.fTop, inner.fLeft, inner.fBottom,
blitter);
fillcheckrect(inner.fRight, inner.fTop, outer.fRight, inner.fBottom,
blitter);
fillcheckrect(outer.fLeft, inner.fBottom, outer.fRight, outer.fBottom,
blitter);
// now stroke the inner rect, which is similar to antifilldot8() except that
// it treats the fractional coordinates with the inverse bias (since its
// inner).
innerstrokedot8(L, T, R, B, blitter);
}
}
void SkScan::AntiFrameRect(const SkRect& r, const SkPoint& strokeSize,
const SkRasterClip& clip, SkBlitter* blitter) {
if (clip.isBW()) {
AntiFrameRect(r, strokeSize, &clip.bwRgn(), blitter);
} else {
SkAAClipBlitterWrapper wrap(clip, blitter);
AntiFrameRect(r, strokeSize, &wrap.getRgn(), wrap.getBlitter());
}
}
| [
"karun.matharu@gmail.com"
] | karun.matharu@gmail.com |
175f66511faa873bb8038180b5bb288d4a5cfc62 | 3df13471039bee96dbb9aa03334b2fe494cd1790 | /CoreCLRProfiler/native/coreclr_headers/src/pal/tests/palsuite/c_runtime/_vsnwprintf_s/test3/test3.cpp | e238a35194d0d280a80d95bdb9dc115a8a7482bb | [
"MIT"
] | permissive | microsoft/BPerf | 9bb8e9d9157f0b0a55adce4f2abd00ecac541c3d | 0acd0efe734628d7e198fd58e35b9038501bfbe5 | refs/heads/dev | 2023-06-07T23:45:45.236017 | 2022-09-23T03:29:26 | 2022-09-23T03:29:26 | 66,505,813 | 25 | 15 | MIT | 2022-12-07T21:25:35 | 2016-08-24T23:01:44 | C++ | UTF-8 | C++ | false | false | 1,777 | cpp | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/*=====================================================================
**
** Source: test3.c
**
** Purpose: Test #3 for the _vsnwprintf_s function.
**
**
**===================================================================*/
#include <palsuite.h>
#include "../_vsnwprintf_s.h"
/* memcmp is used to verify the results, so this test is dependent on it. */
/* ditto with wcslen */
int __cdecl main(int argc, char *argv[])
{
if (PAL_Initialize(argc, argv) != 0)
return(FAIL);
DoStrTest(convert("foo %S"), "bar", convert("foo bar"));
DoStrTest(convert("foo %hS"), "bar", convert("foo bar"));
DoWStrTest(convert("foo %lS"), convert("bar"), convert("foo bar"));
DoWStrTest(convert("foo %wS"), convert("bar"), convert("foo bar"));
DoStrTest(convert("foo %LS"), "bar", convert("foo bar"));
DoStrTest(convert("foo %I64S"), "bar", convert("foo bar"));
DoStrTest(convert("foo %5S"), "bar", convert("foo bar"));
DoStrTest(convert("foo %.2S"), "bar", convert("foo ba"));
DoStrTest(convert("foo %5.2S"), "bar", convert("foo ba"));
DoStrTest(convert("foo %-5S"), "bar", convert("foo bar "));
DoStrTest(convert("foo %05S"), "bar", convert("foo 00bar"));
DoStrTest(convert("foo %S"), NULL, convert("foo (null)"));
DoStrTest(convert("foo %hS"), NULL, convert("foo (null)"));
DoWStrTest(convert("foo %lS"), NULL, convert("foo (null)"));
DoWStrTest(convert("foo %wS"), NULL, convert("foo (null)"));
DoStrTest(convert("foo %LS"), NULL, convert("foo (null)"));
DoStrTest(convert("foo %I64S"), NULL, convert("foo (null)"));
PAL_Terminate();
return PASS;
}
| [
"muks@microsoft.com"
] | muks@microsoft.com |
0330a8afaec677e9d1ecdf0f87797b6abaf9bddb | 98a0ac4a9c67ae2e767f6220e1adcdaab8fb97d0 | /个人赛2/G/26413365_3018216309_G.cpp | 3fd4905e173e41b9ad06cc17f2987b44869d12f7 | [] | no_license | neverac/2020summer | 8fdc0e6a4c7047d754bf48d9e7f9822d7853fb5f | 673a493dbf736f1d33f791a254448e061ccd0b6b | refs/heads/master | 2022-12-04T21:54:24.688278 | 2020-08-25T09:37:55 | 2020-08-25T09:37:55 | 280,410,524 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 700 | cpp | #include <bits/stdc++.h>
using namespace std;
int const maxn=100001;
int a[maxn],interval[maxn];
bool flag[maxn];
int main(){
int n,k;
cin>>n>>k;
memset(flag,0,sizeof(flag));
flag[0]=true;
flag[1]=true;
a[0]=1;
for(int i=1; i<k; i++) {
interval[i] = n - i;
}
interval[k] = 1;
int t=1;
for(int i=1; i<n; i++){
int t1=a[i-1]-interval[t],t2=a[i-1]+interval[t];
if(t1>0&&!flag[t1]) {
a[i] =t1;
flag[t1] =true;
}
else{
a[i] = t2;
flag[t2] = true;
}
if(t<k) t++;
}
cout<<a[0];
for(int i=1;i<n;++i){
cout<<" "<<a[i];
}
}
| [
"3015218126@tju.edu.cn"
] | 3015218126@tju.edu.cn |
fed512727800a7fddbd02b73019311a6cdb80e0f | d20cf7de868dfb2c53578a70d0dda21306167d72 | /data/preprocessed/test/student_76/sources/PlantsMonitor.cpp | 1d70108f504cfaeb89f8131be8f49f01cdbffa55 | [] | no_license | bulacu-magda/Alemia | 905a84ca79157fb657eb424e337b0303fd3323bd | 0fd019c4517064d300399feb94dbcb0f467e8d48 | refs/heads/main | 2023-03-01T17:41:08.788500 | 2021-02-05T08:00:35 | 2021-02-05T08:00:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,219 | cpp | #include "PlantsMonitor.h"
#include "CSunflower.h"
#include "CPeashooter.h"
#include "CUtils.h"
bool PlantsMonitor::VerifyP(CPoint Pt,int Case)
{
for (auto it = StartPos.begin(); it != StartPos.end(); it++)
{
if (Pt.GetX() >= (*it).first->GetX() && Pt.GetX() <= (*it).first->GetX()+4 && Pt.GetY() >= (*it).first->GetY() && Pt.GetY() <= (*it).first->GetY() + 4)
{
if (Case == 0)
{
LastPoint = *(*it).first;
}
if (Case == 1)
(*it).second = false;
return true;
}
}
return false;
}
CPoint* PlantsMonitor::SearchForNewPos(CPoint Pt)
{
for (auto it = GroundPos.begin(); it != GroundPos.end(); it++)
{
if (Pt.GetX() >= (*it).first->GetX() && Pt.GetX() <= (*it).first->GetX() + 4 && Pt.GetY() >= (*it).first->GetY() && Pt.GetY() <= (*it).first->GetY() + 4 && (*it).second == false)
{
(*it).second = true;
return (*it).first;
}
}
return nullptr;
}
void PlantsMonitor::SpawnPlant()
{
if (TimeVer == nullptr)
this->TimeVer = &CTimeVerifier::GetInstance();
for (auto it = StartPos.begin(); it != StartPos.end(); it++)
{
if ((*it).second == false)
{
int random = rand() % 2;
if (random == 1 && SunFlowerD == true)
{
if (TimeVer->SunFlower() == true)
{
SunFlowerD = false;
IEntity* Ent = new CSunflower(*(*it).first);
this->Entities.push_back(Ent);
(*it).second = true;
}
}
else if (random == 0 && PeaShooterD == true) {
if (TimeVer->Peashooter() == true)
{
PeaShooterD = false;
IEntity* Ent = new CPeashooter(*(*it).first);
this->Entities.push_back(Ent);
(*it).second = true;
}
}
break;
}
}
}
void PlantsMonitor::MoveP(CPoint P,CPlayer* Player)
{
for (int i=0;i<Entities.size();i++)
{
CAEntity* Ent = (CAEntity*)Entities[i];
if (Ent->VerifyPos(LastPoint) == true)
{
if (Ent->GetCost() <= Player->GetResources())
{
CPoint* Pt = SearchForNewPos(P);
if (Pt != nullptr)
{
CUtils::ClearMatrix(LastPoint, conOut);
Ent->SetPoint(*Pt);
Ent->Draw();
if (Ent->Shoot() == false)
{
SunFlowerD = true;
TimeVer->SunFlower(true);
TimeVer->SunSpeed(-1);
}
else {
PeaShooterD = true;
TimeVer->Peashooter(true);
}
Player->GiveRes(Ent->GetCost());
Player->Add_Points(Ent->GetReward());
VerifyP(LastPoint, 1);
}
(*conOut)(43, 2) << " ";
}
else { (*conOut)(43, 2) << "No resources"; }
}
}
}
void PlantsMonitor::ShootPlants(std::vector<int> Places)
{
for (int i = 0; i < Entities.size(); i++)
{
CAEntity* Ent = (CAEntity*)Entities[i];
if (VerifyP(Ent->GetPoint(), 2) == false)
if (std::find(Places.begin(), Places.end(), Ent->GetPoint().GetX()) != Places.end())
Entities[i]->Shoot();
(*conOut)(Ent->GetPoint().GetX() + 2, Ent->GetPoint().GetY() + 2) << '|';
}
}
PlantsMonitor::PlantsMonitor(std::vector<CPoint*> Points)
{
int k = 1;
for (int i = 1; i <= 5; i++)
{
CPoint* p = new CPoint(2+(7*k),2);
k++;
StartPos[p] = false;
}
for (int i = 0; i < Points.size(); i++)
{
GroundPos[Points[i]] = false;
}
this->conOut = &(ConsoleOutput::getInstance());
this->TimeVer = nullptr;
SunFlowerD = true;
PeaShooterD = true;
}
| [
"ionutm.bajan@yahoo.com"
] | ionutm.bajan@yahoo.com |
ad1f72407607ea701064c4c02647db576485a69d | baf38a5c0e75d54255959ee4d13bddde41f6763a | /mount_player/assemble/assemble/assemble_module.cpp | d5dd85a8f61e5129905c0a6067317a3fdcd9af84 | [
"MIT"
] | permissive | lfyos/MountPlayer | 5326259c44119a836a97a30b68f57decce59607e | 0794bc24e3ff0ba1a85492708c8530b6d5fb70d2 | refs/heads/master | 2020-04-22T20:44:37.349199 | 2019-03-09T05:02:14 | 2019-03-09T05:02:14 | 170,650,676 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 383 | cpp | // assemble.cpp : Implementation of DLL Exports.
#include "stdafx.h"
#include "resource.h"
// The module attribute causes DllMain, DllRegisterServer and DllUnregisterServer to be automatically implemented for you
[ module(dll, uuid = "{54B0978C-EA63-4F80-861E-5D43E81ABB7B}",
name = "assemble",
helpstring = "assemble 1.0 Type Library",
resource_name = "IDR_SAMPLE") ];
| [
"lfy@shu.edu.cn"
] | lfy@shu.edu.cn |
e135e5adc5b68ef8935f4e8d49eed1bcdb11de97 | c371a718c3330e2f5b8d00945c64ba8ffabf8d19 | /operator/{{cookiecutter.class}}/{{cookiecutter.class_file}}.cpp | 90cce82996ea0bc6af880051b7dff1b1429716b8 | [] | no_license | Mahlet-Inc/hobbits-cookiecutters | 2f1c087d314ca6eb7b052dc0649f89d3a1d73f68 | 5a2f1f81c6e7384440208c3b89d36bea9fe141ee | refs/heads/main | 2023-05-07T17:27:55.729061 | 2021-05-29T20:57:07 | 2021-05-29T20:57:07 | 369,937,553 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,247 | cpp | #include "{{cookiecutter.class|lower}}.h"
#include "{{cookiecutter.editor_class|lower}}.h"
{{cookiecutter.class}}::{{cookiecutter.class}}()
{
QList<ParameterDelegate::ParameterInfo> infos = {
// TODO: add parameters like {"myparametername", ParameterDelegate::ParameterType::Decimal}
};
m_delegate = ParameterDelegate::create(
infos,
[this](const Parameters ¶meters) {
// TODO: use parameters to describe action better
return QString("Apply %1").arg(this->name());
},
[](QSharedPointer<ParameterDelegate> delegate, QSize size) {
Q_UNUSED(size)
return new {{cookiecutter.editor_class}}(delegate);
});
}
OperatorInterface* {{cookiecutter.class}}::createDefaultOperator()
{
return new {{cookiecutter.class}}();
}
QString {{cookiecutter.class}}::name()
{
return "{{cookiecutter.class}}";
}
QString {{cookiecutter.class}}::description()
{
// TODO: create actual description
return "Describes what {{cookiecutter.class}} does";
}
QStringList {{cookiecutter.class}}::tags()
{
// TODO: add relevant tags
return {"Generic"};
}
QSharedPointer<ParameterDelegate> {{cookiecutter.class}}::parameterDelegate()
{
return m_delegate;
}
int {{cookiecutter.class}}::getMinInputContainers(const Parameters ¶meters)
{
Q_UNUSED(parameters)
return 1;
}
int {{cookiecutter.class}}::getMaxInputContainers(const Parameters ¶meters)
{
Q_UNUSED(parameters)
return 1;
}
QSharedPointer<const OperatorResult> {{cookiecutter.class}}::operateOnBits(
QList<QSharedPointer<const BitContainer> > inputContainers,
const Parameters ¶meters,
QSharedPointer<PluginActionProgress> progress)
{
QStringList invalidations = m_delegate->validate(parameters);
if (!invalidations.isEmpty()) {
return OperatorResult::error(QString("Invalid parameters passed to %1:\n%2").arg(name()).arg(invalidations.join("\n")));
}
// TODO: Perform analysis and return result with OperatorResult::result
return OperatorResult::error("Plugin operate action not implemented");
}
| [
"adam.t.nash@gmail.com"
] | adam.t.nash@gmail.com |
1538dbfd815b3405c2baf0999f853bc0b3e62737 | 045ff9569ddca5a7b644b251b6c9fc279733fec2 | /Arduino Code/Xbee_API/Xbee_API_Receiver/Xbee_API_Receiver.ino | 180f44288fcd4bec7de1f71ea697bc674e63eb3f | [] | no_license | jzhu1234/SmartParking | 5362ada4ea6b662f805f687f772ebb89dd68e45a | f8848e5ae7a325b275c8bdc8558027ea5512b0e8 | refs/heads/master | 2021-05-03T23:29:36.256820 | 2017-02-27T22:53:07 | 2017-02-27T22:53:07 | 71,738,240 | 0 | 2 | null | 2016-10-25T19:00:09 | 2016-10-24T00:28:02 | nesC | UTF-8 | C++ | false | false | 3,515 | ino | /**
* Copyright (c) 2009 Andrew Rapp. All rights reserved.
*
* This file is part of XBee-Arduino.
*
* XBee-Arduino 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 3 of the License, or
* (at your option) any later version.
*
* XBee-Arduino 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with XBee-Arduino. If not, see <http://www.gnu.org/licenses/>.
*/
#include <XBee.h>
/*
This example is for Series 2 XBee
Receives a ZB RX packet and sets a PWM value based on packet data.
Error led is flashed if an unexpected packet is received
*/
XBee xbee = XBee();
XBeeResponse response = XBeeResponse();
// create reusable response objects for responses we expect to handle
ZBRxResponse rx = ZBRxResponse();
ModemStatusResponse msr = ModemStatusResponse();
int statusLed = 13;
int errorLed = 13;
int dataLed = 13;
void flashLed(int pin, int times, int wait) {
for (int i = 0; i < times; i++) {
digitalWrite(pin, HIGH);
delay(wait);
digitalWrite(pin, LOW);
if (i + 1 < times) {
delay(wait);
}
}
}
void setup() {
pinMode(statusLed, OUTPUT);
pinMode(errorLed, OUTPUT);
pinMode(dataLed, OUTPUT);
// start serial
Serial.begin(9600);
Serial.println("Started");
xbee.begin(Serial);
flashLed(statusLed, 3, 50);
}
// continuously reads packets, looking for ZB Receive or Modem Status
void loop() {
xbee.readPacket();
if (xbee.getResponse().isAvailable()) {
Serial.println("Response Available");
// got something
if (xbee.getResponse().getApiId() == ZB_RX_RESPONSE) {
// got a zb rx packet
Serial.println("Got a zb rx packet");
// now fill our zb rx class
xbee.getResponse().getZBRxResponse(rx);
if (rx.getOption() == ZB_PACKET_ACKNOWLEDGED) {
// the sender got an ACK
flashLed(statusLed, 10, 10);
Serial.println("Packet Acknowledged");
} else {
// we got it (obviously) but sender didn't get an ACK
flashLed(errorLed, 2, 20);
Serial.println("Error");
}
// set dataLed PWM to value of the first byte in the data
analogWrite(dataLed, rx.getData(0));
} else if (xbee.getResponse().getApiId() == MODEM_STATUS_RESPONSE) {
xbee.getResponse().getModemStatusResponse(msr);
// the local XBee sends this response on certain events, like association/dissociation
if (msr.getStatus() == ASSOCIATED) {
// yay this is great. flash led
flashLed(statusLed, 10, 10);
} else if (msr.getStatus() == DISASSOCIATED) {
// this is awful.. flash led to show our discontent
flashLed(errorLed, 10, 10);
} else {
// another status
flashLed(statusLed, 5, 10);
}
} else {
// not something we were expecting
flashLed(errorLed, 1, 25);
}
} else if (xbee.getResponse().isError()) {
//nss.print("Error reading packet. Error code: ");
//nss.println(xbee.getResponse().getErrorCode());
}
}
| [
"zhujohn64@gmail.com"
] | zhujohn64@gmail.com |
c0bac18b2149345b320930e64ce2b65ddefa6305 | 233a8c65e2936cb9323802764c62f4c5a1742389 | /cpp/pscpp/src/ch01/0109.cpp | 389a3f874ec4bf7ae12f2bf1542cbf53c47d7ff9 | [
"BSD-3-Clause-Clear"
] | permissive | newnix/Forge | 83a83bee28e6741ba42ad2e1f4a1488762f6b0ac | 6d18105460fabc20592ed3c29813173cdb57d512 | refs/heads/master | 2021-05-25T09:08:59.814337 | 2020-10-06T22:04:44 | 2020-10-06T22:04:44 | 44,290,739 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,887 | cpp | // Practice program 09 from chapter 01
// Found on page 37
// Calculates the drop distance of an object based on drop time
#include <iostream>
double dm (float); // Metric conversion
double du (float); // Empirical conversion
int main()
{
// set up the one variable we need
float s; // Seconds falling
// Set selection variables
char pic; // empirical or metric selection
char go; // new calculation
// Let the user know what we're doing
std::cout << "Hello, I'll calcuate the drop distance of an object given a time it's falling!\n";
do
{
std::cout << "First, we'll need to determine if we're calculating things in metric units or empirical units.";
std::cout << "\nFor metric units press \'m\', for empirical or US customary, press \'u\': ";
std::cin >> pic;
if (toupper(pic) == 'M')
{
std::cout << "\nEnter the time the object was falling: ";
std::cin >> s;
std::cout << "\nThe distance this object fell was " << dm(s) << " meters.\n";
}
else if (toupper(pic) == 'U')
{
std::cout << "\nEnter the time the object was falling: ";
std::cin >> s;
std::cout << "\nThe distance this object fell was " << du(s) << " feet.\n";
}
else
{
std::cout << "\nThat was not a valid entry, do you want to leave? [Y/N]";
std::cin >> go;
}
std::cout << "\nWould you like to run another calculation? [Y/N] ";
std::cin >> go;
}while(toupper(go) == 'Y');
return 0;
}
// Calculate the distance dropped in meters
double dm(float sec)
{
float acc = 9.8;
return ((acc * sec * sec) / 2);
}
// Calculate the distance dropped in feet
double du(float sec)
{
float acc = 32;
return ((acc * sec * sec) / 2);
}
| [
"deux3x@protonmail.ch"
] | deux3x@protonmail.ch |
aa51531bac6c7c92ee96587e00b4b7b1afd4173e | 9552a49c5290687837c271bf0b99a6d9e5da0d94 | /practice/classes/area.cpp | 1179363d463dccbac4726c3c1ea5ecd1a341d7ce | [] | no_license | danyollee/cs162 | 18710d5befdcf5ac762264e652de381345a49ec1 | f5f1a7779b1a846ceb0cdf13d5d983e4cdee3a1c | refs/heads/master | 2020-12-24T07:55:36.284944 | 2016-09-07T21:31:56 | 2016-09-07T21:31:56 | 57,331,914 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 456 | cpp | #include <iostream>
using namespace std;
class Rectangle{
private:
int length, width;
public:
Rectangle(int, int);
int area(int, int);
};
Rectangle::Rectangle(int x, int y){
length=x;
width=y;
}
int area(int length, int width){
int areas;
areas=length*width;
return areas;
}
int main(){
Rectangle rect1, rect2;
cout << "area of rect1: " << rect1.area(3, 4) << endl;
cout << "area of rect2: " << rect2.area(10, 10) << endl;
return 0;
} | [
"leed3@oregonstate.edu"
] | leed3@oregonstate.edu |
d505bcbc76e4d4bc240ee8c4034f0942a919bdda | 7a0b989e8e3d7be473b8432d712d8578e4a264e4 | /chrome/browser/android/vr/arcore_device/arcore_java_utils.cc | 126e3da0bea871026011ffe39954539eb63bd337 | [
"BSD-3-Clause"
] | permissive | kbingham/chromium | 0a737138e49e639ed04f6a61855f5c69dcc1e07b | be47e50d6ea194e0d17f9c5b5b3f952b8b192bcf | refs/heads/master | 2022-12-26T13:21:31.584462 | 2020-10-15T14:41:51 | 2020-10-15T14:41:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,397 | 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 "chrome/browser/android/vr/arcore_device/arcore_java_utils.h"
#include <memory>
#include <utility>
#include "base/android/jni_string.h"
#include "chrome/browser/android/vr/ar_jni_headers/ArCoreJavaUtils_jni.h"
#include "components/webxr/android/webxr_utils.h"
#include "device/vr/android/arcore/arcore_shim.h"
using base::android::AttachCurrentThread;
using base::android::ScopedJavaLocalRef;
namespace vr {
ArCoreJavaUtils::ArCoreJavaUtils() {
JNIEnv* env = AttachCurrentThread();
if (!env)
return;
ScopedJavaLocalRef<jobject> j_arcore_java_utils =
Java_ArCoreJavaUtils_create(env, (jlong)this);
if (j_arcore_java_utils.is_null())
return;
j_arcore_java_utils_.Reset(j_arcore_java_utils);
}
ArCoreJavaUtils::~ArCoreJavaUtils() {
JNIEnv* env = AttachCurrentThread();
Java_ArCoreJavaUtils_onNativeDestroy(env, j_arcore_java_utils_);
}
void ArCoreJavaUtils::RequestArSession(
int render_process_id,
int render_frame_id,
bool use_overlay,
SurfaceReadyCallback ready_callback,
SurfaceTouchCallback touch_callback,
SurfaceDestroyedCallback destroyed_callback) {
DVLOG(1) << __func__;
JNIEnv* env = AttachCurrentThread();
surface_ready_callback_ = std::move(ready_callback);
surface_touch_callback_ = std::move(touch_callback);
surface_destroyed_callback_ = std::move(destroyed_callback);
Java_ArCoreJavaUtils_startSession(
env, j_arcore_java_utils_,
webxr::GetJavaWebContents(render_process_id, render_frame_id),
use_overlay);
}
void ArCoreJavaUtils::EndSession() {
DVLOG(1) << __func__;
JNIEnv* env = AttachCurrentThread();
Java_ArCoreJavaUtils_endSession(env, j_arcore_java_utils_);
}
void ArCoreJavaUtils::OnDrawingSurfaceReady(
JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj,
const base::android::JavaParamRef<jobject>& surface,
int rotation,
int width,
int height) {
DVLOG(1) << __func__ << ": width=" << width << " height=" << height
<< " rotation=" << rotation;
gfx::AcceleratedWidget window =
ANativeWindow_fromSurface(base::android::AttachCurrentThread(), surface);
display::Display::Rotation display_rotation =
static_cast<display::Display::Rotation>(rotation);
surface_ready_callback_.Run(window, display_rotation, {width, height});
}
void ArCoreJavaUtils::OnDrawingSurfaceTouch(
JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj,
bool primary,
bool touching,
int32_t pointer_id,
float x,
float y) {
DVLOG(3) << __func__ << ": pointer_id=" << pointer_id
<< " primary=" << primary << " touching=" << touching;
surface_touch_callback_.Run(primary, touching, pointer_id, {x, y});
}
void ArCoreJavaUtils::OnDrawingSurfaceDestroyed(
JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj) {
DVLOG(1) << __func__ << ":::";
if (surface_destroyed_callback_) {
std::move(surface_destroyed_callback_).Run();
}
}
bool ArCoreJavaUtils::EnsureLoaded() {
DCHECK(vr::IsArCoreSupported());
JNIEnv* env = AttachCurrentThread();
// TODO(crbug.com/884780): Allow loading the ARCore shim by name instead of by
// absolute path.
ScopedJavaLocalRef<jstring> java_path =
Java_ArCoreJavaUtils_getArCoreShimLibraryPath(env);
// Crash in debug builds if `java_path` is a null pointer but handle this
// situation in release builds. This is done by design - the `java_path` will
// be null only if there was a regression introduced to our gn/gni files w/o
// causing a build break. In release builds, this approach will result in the
// site not being able to request an AR session.
DCHECK(java_path)
<< "Unable to find path to ARCore SDK library - please ensure that "
"loadable_modules and secondary_abi_loadable_modules are set "
"correctly when building";
if (!java_path) {
LOG(ERROR) << "Unable to find path to ARCore SDK library";
return false;
}
return LoadArCoreSdk(base::android::ConvertJavaStringToUTF8(env, java_path));
}
ScopedJavaLocalRef<jobject> ArCoreJavaUtils::GetApplicationContext() {
JNIEnv* env = AttachCurrentThread();
return Java_ArCoreJavaUtils_getApplicationContext(env);
}
} // namespace vr
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
2ec79bb1633f500460e4f86176e65d08e6a3e416 | c8b39acfd4a857dc15ed3375e0d93e75fa3f1f64 | /Engine/Source/Runtime/Core/Public/Math/Quat.h | 174ccc968aef1682f8c76cc4fc723a4098814123 | [
"MIT",
"LicenseRef-scancode-proprietary-license"
] | permissive | windystrife/UnrealEngine_NVIDIAGameWorks | c3c7863083653caf1bc67d3ef104fb4b9f302e2a | b50e6338a7c5b26374d66306ebc7807541ff815e | refs/heads/4.18-GameWorks | 2023-03-11T02:50:08.471040 | 2022-01-13T20:50:29 | 2022-01-13T20:50:29 | 124,100,479 | 262 | 179 | MIT | 2022-12-16T05:36:38 | 2018-03-06T15:44:09 | C++ | UTF-8 | C++ | false | false | 31,375 | h | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "Math/UnrealMathUtility.h"
#include "Containers/UnrealString.h"
#include "Logging/LogMacros.h"
#include "Math/Vector.h"
#include "Math/VectorRegister.h"
#include "Math/Rotator.h"
#include "Math/Matrix.h"
class Error;
/**
* Floating point quaternion that can represent a rotation about an axis in 3-D space.
* The X, Y, Z, W components also double as the Axis/Angle format.
*
* Order matters when composing quaternions: C = A * B will yield a quaternion C that logically
* first applies B then A to any subsequent transformation (right first, then left).
* Note that this is the opposite order of FTransform multiplication.
*
* Example: LocalToWorld = (LocalToWorld * DeltaRotation) will change rotation in local space by DeltaRotation.
* Example: LocalToWorld = (DeltaRotation * LocalToWorld) will change rotation in world space by DeltaRotation.
*/
MS_ALIGN(16) struct FQuat
{
public:
/** The quaternion's X-component. */
float X;
/** The quaternion's Y-component. */
float Y;
/** The quaternion's Z-component. */
float Z;
/** The quaternion's W-component. */
float W;
public:
/** Identity quaternion. */
static CORE_API const FQuat Identity;
public:
/** Default constructor (no initialization). */
FORCEINLINE FQuat() { }
/**
* Creates and initializes a new quaternion, with the W component either 0 or 1.
*
* @param EForceInit Force init enum: if equal to ForceInitToZero then W is 0, otherwise W = 1 (creating an identity transform)
*/
explicit FORCEINLINE FQuat(EForceInit);
/**
* Constructor.
*
* @param InX X component of the quaternion
* @param InY Y component of the quaternion
* @param InZ Z component of the quaternion
* @param InW W component of the quaternion
*/
FORCEINLINE FQuat(float InX, float InY, float InZ, float InW);
/**
* Copy constructor.
*
* @param Q A FQuat object to use to create new quaternion from.
*/
FORCEINLINE FQuat(const FQuat& Q);
/**
* Creates and initializes a new quaternion from the given matrix.
*
* @param M The rotation matrix to initialize from.
*/
explicit FQuat(const FMatrix& M);
/**
* Creates and initializes a new quaternion from the given rotator.
*
* @param R The rotator to initialize from.
*/
explicit FQuat(const FRotator& R);
/**
* Creates and initializes a new quaternion from the a rotation around the given axis.
*
* @param Axis assumed to be a normalized vector
* @param Angle angle to rotate above the given axis (in radians)
*/
FQuat(FVector Axis, float AngleRad);
public:
#ifdef IMPLEMENT_ASSIGNMENT_OPERATOR_MANUALLY
/**
* Copy another FQuat into this one
*
* @return reference to this FQuat
*/
FORCEINLINE FQuat& operator=(const FQuat& Other);
#endif
/**
* Gets the result of adding a Quaternion to this.
* This is a component-wise addition; composing quaternions should be done via multiplication.
*
* @param Q The Quaternion to add.
* @return The result of addition.
*/
FORCEINLINE FQuat operator+(const FQuat& Q) const;
/**
* Adds to this quaternion.
* This is a component-wise addition; composing quaternions should be done via multiplication.
*
* @param Other The quaternion to add to this.
* @return Result after addition.
*/
FORCEINLINE FQuat operator+=(const FQuat& Q);
/**
* Gets the result of subtracting a Quaternion to this.
* This is a component-wise subtraction; composing quaternions should be done via multiplication.
*
* @param Q The Quaternion to subtract.
* @return The result of subtraction.
*/
FORCEINLINE FQuat operator-(const FQuat& Q) const;
/**
* Checks whether another Quaternion is equal to this, within specified tolerance.
*
* @param Q The other Quaternion.
* @param Tolerance Error tolerance for comparison with other Quaternion.
* @return true if two Quaternions are equal, within specified tolerance, otherwise false.
*/
FORCEINLINE bool Equals(const FQuat& Q, float Tolerance=KINDA_SMALL_NUMBER) const;
/**
* Checks whether this Quaternion is an Identity Quaternion.
* Assumes Quaternion tested is normalized.
*
* @param Tolerance Error tolerance for comparison with Identity Quaternion.
* @return true if Quaternion is a normalized Identity Quaternion.
*/
FORCEINLINE bool IsIdentity(float Tolerance=SMALL_NUMBER) const;
/**
* Subtracts another quaternion from this.
* This is a component-wise subtraction; composing quaternions should be done via multiplication.
*
* @param Q The other quaternion.
* @return reference to this after subtraction.
*/
FORCEINLINE FQuat operator-=(const FQuat& Q);
/**
* Gets the result of multiplying this by another quaternion (this * Q).
*
* Order matters when composing quaternions: C = A * B will yield a quaternion C that logically
* first applies B then A to any subsequent transformation (right first, then left).
*
* @param Q The Quaternion to multiply this by.
* @return The result of multiplication (this * Q).
*/
FORCEINLINE FQuat operator*(const FQuat& Q) const;
/**
* Multiply this by a quaternion (this = this * Q).
*
* Order matters when composing quaternions: C = A * B will yield a quaternion C that logically
* first applies B then A to any subsequent transformation (right first, then left).
*
* @param Q the quaternion to multiply this by.
* @return The result of multiplication (this * Q).
*/
FORCEINLINE FQuat operator*=(const FQuat& Q);
/**
* Rotate a vector by this quaternion.
*
* @param V the vector to be rotated
* @return vector after rotation
* @see RotateVector
*/
FVector operator*(const FVector& V) const;
/**
* Multiply this by a matrix.
* This matrix conversion came from
* http://www.m-hikari.com/ija/ija-password-2008/ija-password17-20-2008/aristidouIJA17-20-2008.pdf
* used for non-uniform scaling transform.
*
* @param M Matrix to multiply by.
* @return Matrix result after multiplication.
*/
FMatrix operator*(const FMatrix& M) const;
/**
* Multiply this quaternion by a scaling factor.
*
* @param Scale The scaling factor.
* @return a reference to this after scaling.
*/
FORCEINLINE FQuat operator*=(const float Scale);
/**
* Get the result of scaling this quaternion.
*
* @param Scale The scaling factor.
* @return The result of scaling.
*/
FORCEINLINE FQuat operator*(const float Scale) const;
/**
* Divide this quaternion by scale.
*
* @param Scale What to divide by.
* @return a reference to this after scaling.
*/
FORCEINLINE FQuat operator/=(const float Scale);
/**
* Divide this quaternion by scale.
*
* @param Scale What to divide by.
* @return new Quaternion of this after division by scale.
*/
FORCEINLINE FQuat operator/(const float Scale) const;
/**
* Checks whether two quaternions are identical.
* This is an exact comparison per-component;see Equals() for a comparison
* that allows for a small error tolerance and flipped axes of rotation.
*
* @param Q The other quaternion.
* @return true if two quaternion are identical, otherwise false.
* @see Equals
*/
bool operator==(const FQuat& Q) const;
/**
* Checks whether two quaternions are not identical.
*
* @param Q The other quaternion.
* @return true if two quaternion are not identical, otherwise false.
*/
bool operator!=(const FQuat& Q) const;
/**
* Calculates dot product of two quaternions.
*
* @param Q The other quaternions.
* @return The dot product.
*/
float operator|(const FQuat& Q) const;
public:
/**
* Convert a vector of floating-point Euler angles (in degrees) into a Quaternion.
*
* @param Euler the Euler angles
* @return constructed FQuat
*/
static CORE_API FQuat MakeFromEuler(const FVector& Euler);
/** Convert a Quaternion into floating-point Euler angles (in degrees). */
CORE_API FVector Euler() const;
/**
* Normalize this quaternion if it is large enough.
* If it is too small, returns an identity quaternion.
*
* @param Tolerance Minimum squared length of quaternion for normalization.
*/
FORCEINLINE void Normalize(float Tolerance = SMALL_NUMBER);
/**
* Get a normalized copy of this quaternion.
* If it is too small, returns an identity quaternion.
*
* @param Tolerance Minimum squared length of quaternion for normalization.
*/
FORCEINLINE FQuat GetNormalized(float Tolerance = SMALL_NUMBER) const;
// Return true if this quaternion is normalized
bool IsNormalized() const;
/**
* Get the length of this quaternion.
*
* @return The length of this quaternion.
*/
FORCEINLINE float Size() const;
/**
* Get the length squared of this quaternion.
*
* @return The length of this quaternion.
*/
FORCEINLINE float SizeSquared() const;
/** Get the angle of this quaternion */
FORCEINLINE float GetAngle() const;
/**
* get the axis and angle of rotation of this quaternion
*
* @param Axis{out] vector of axis of the quaternion
* @param Angle{out] angle of the quaternion
* @warning : assumes normalized quaternions.
*/
void ToAxisAndAngle(FVector& Axis, float& Angle) const;
/**
* Get the swing and twist decomposition for a specified axis
*
* @param InTwistAxis Axis to use for decomposition
* @param OutSwing swing component quaternion
* @param OutTwist Twist component quaternion
* @warning assumes normalised quaternion and twist axis
*/
CORE_API void ToSwingTwist(const FVector& InTwistAxis, FQuat& OutSwing, FQuat& OutTwist) const;
/**
* Rotate a vector by this quaternion.
*
* @param V the vector to be rotated
* @return vector after rotation
*/
FVector RotateVector(FVector V) const;
/**
* Rotate a vector by the inverse of this quaternion.
*
* @param V the vector to be rotated
* @return vector after rotation by the inverse of this quaternion.
*/
FVector UnrotateVector(FVector V) const;
/**
* @return quaternion with W=0 and V=theta*v.
*/
CORE_API FQuat Log() const;
/**
* @note Exp should really only be used after Log.
* Assumes a quaternion with W=0 and V=theta*v (where |v| = 1).
* Exp(q) = (sin(theta)*v, cos(theta))
*/
CORE_API FQuat Exp() const;
/**
* @return inverse of this quaternion
*/
FORCEINLINE FQuat Inverse() const;
/**
* Enforce that the delta between this Quaternion and another one represents
* the shortest possible rotation angle
*/
void EnforceShortestArcWith(const FQuat& OtherQuat);
/** Get the forward direction (X axis) after it has been rotated by this Quaternion. */
FORCEINLINE FVector GetAxisX() const;
/** Get the right direction (Y axis) after it has been rotated by this Quaternion. */
FORCEINLINE FVector GetAxisY() const;
/** Get the up direction (Z axis) after it has been rotated by this Quaternion. */
FORCEINLINE FVector GetAxisZ() const;
/** Get the forward direction (X axis) after it has been rotated by this Quaternion. */
FORCEINLINE FVector GetForwardVector() const;
/** Get the right direction (Y axis) after it has been rotated by this Quaternion. */
FORCEINLINE FVector GetRightVector() const;
/** Get the up direction (Z axis) after it has been rotated by this Quaternion. */
FORCEINLINE FVector GetUpVector() const;
/** Convert a rotation into a unit vector facing in its direction. Equivalent to GetForwardVector(). */
FORCEINLINE FVector Vector() const;
/** Get the FRotator representation of this Quaternion. */
CORE_API FRotator Rotator() const;
/**
* Get the axis of rotation of the Quaternion.
* This is the axis around which rotation occurs to transform the canonical coordinate system to the target orientation.
* For the identity Quaternion which has no such rotation, FVector(1,0,0) is returned.
*/
FORCEINLINE FVector GetRotationAxis() const;
/** Find the angular distance between two rotation quaternions (in radians) */
FORCEINLINE float AngularDistance(const FQuat& Q) const;
/**
* Serializes the vector compressed for e.g. network transmission.
* @param Ar Archive to serialize to/ from.
* @return false to allow the ordinary struct code to run (this never happens).
*/
CORE_API bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess);
/**
* Utility to check if there are any non-finite values (NaN or Inf) in this Quat.
*
* @return true if there are any non-finite values in this Quaternion, otherwise false.
*/
bool ContainsNaN() const;
/**
* Get a textual representation of the vector.
*
* @return Text describing the vector.
*/
FString ToString() const;
/**
* Initialize this FQuat from a FString.
* The string is expected to contain X=, Y=, Z=, W=, otherwise
* this FQuat will have indeterminate (invalid) values.
*
* @param InSourceString FString containing the quaternion values.
* @return true if the FQuat was initialized; false otherwise.
*/
bool InitFromString(const FString& InSourceString);
public:
#if ENABLE_NAN_DIAGNOSTIC
FORCEINLINE void DiagnosticCheckNaN() const
{
if (ContainsNaN())
{
logOrEnsureNanError(TEXT("FQuat contains NaN: %s"), *ToString());
*const_cast<FQuat*>(this) = FQuat::Identity;
}
}
FORCEINLINE void DiagnosticCheckNaN(const TCHAR* Message) const
{
if (ContainsNaN())
{
logOrEnsureNanError(TEXT("%s: FQuat contains NaN: %s"), Message, *ToString());
*const_cast<FQuat*>(this) = FQuat::Identity;
}
}
#else
FORCEINLINE void DiagnosticCheckNaN() const {}
FORCEINLINE void DiagnosticCheckNaN(const TCHAR* Message) const {}
#endif
public:
/**
* Generates the 'smallest' (geodesic) rotation between two vectors of arbitrary length.
*/
static FORCEINLINE FQuat FindBetween(const FVector& Vector1, const FVector& Vector2)
{
return FindBetweenVectors(Vector1, Vector2);
}
/**
* Generates the 'smallest' (geodesic) rotation between two normals (assumed to be unit length).
*/
static CORE_API FQuat FindBetweenNormals(const FVector& Normal1, const FVector& Normal2);
/**
* Generates the 'smallest' (geodesic) rotation between two vectors of arbitrary length.
*/
static CORE_API FQuat FindBetweenVectors(const FVector& Vector1, const FVector& Vector2);
/**
* Error measure (angle) between two quaternions, ranged [0..1].
* Returns the hypersphere-angle between two quaternions; alignment shouldn't matter, though
* @note normalized input is expected.
*/
static FORCEINLINE float Error(const FQuat& Q1, const FQuat& Q2);
/**
* FQuat::Error with auto-normalization.
*/
static FORCEINLINE float ErrorAutoNormalize(const FQuat& A, const FQuat& B);
/**
* Fast Linear Quaternion Interpolation.
* Result is NOT normalized.
*/
static FORCEINLINE FQuat FastLerp(const FQuat& A, const FQuat& B, const float Alpha);
/**
* Bi-Linear Quaternion interpolation.
* Result is NOT normalized.
*/
static FORCEINLINE FQuat FastBilerp(const FQuat& P00, const FQuat& P10, const FQuat& P01, const FQuat& P11, float FracX, float FracY);
/** Spherical interpolation. Will correct alignment. Result is NOT normalized. */
static CORE_API FQuat Slerp_NotNormalized(const FQuat &Quat1, const FQuat &Quat2, float Slerp);
/** Spherical interpolation. Will correct alignment. Result is normalized. */
static FORCEINLINE FQuat Slerp(const FQuat &Quat1, const FQuat &Quat2, float Slerp)
{
return Slerp_NotNormalized(Quat1, Quat2, Slerp).GetNormalized();
}
/**
* Simpler Slerp that doesn't do any checks for 'shortest distance' etc.
* We need this for the cubic interpolation stuff so that the multiple Slerps dont go in different directions.
* Result is NOT normalized.
*/
static CORE_API FQuat SlerpFullPath_NotNormalized(const FQuat &quat1, const FQuat &quat2, float Alpha);
/**
* Simpler Slerp that doesn't do any checks for 'shortest distance' etc.
* We need this for the cubic interpolation stuff so that the multiple Slerps dont go in different directions.
* Result is normalized.
*/
static FORCEINLINE FQuat SlerpFullPath(const FQuat &quat1, const FQuat &quat2, float Alpha)
{
return SlerpFullPath_NotNormalized(quat1, quat2, Alpha).GetNormalized();
}
/**
* Given start and end quaternions of quat1 and quat2, and tangents at those points tang1 and tang2, calculate the point at Alpha (between 0 and 1) between them. Result is normalized.
* This will correct alignment by ensuring that the shortest path is taken.
*/
static CORE_API FQuat Squad(const FQuat& quat1, const FQuat& tang1, const FQuat& quat2, const FQuat& tang2, float Alpha);
/**
* Simpler Squad that doesn't do any checks for 'shortest distance' etc.
* Given start and end quaternions of quat1 and quat2, and tangents at those points tang1 and tang2, calculate the point at Alpha (between 0 and 1) between them. Result is normalized.
*/
static CORE_API FQuat SquadFullPath(const FQuat& quat1, const FQuat& tang1, const FQuat& quat2, const FQuat& tang2, float Alpha);
/**
* Calculate tangents between given points
*
* @param PrevP quaternion at P-1
* @param P quaternion to return the tangent
* @param NextP quaternion P+1
* @param Tension @todo document
* @param OutTan Out control point
*/
static CORE_API void CalcTangents(const FQuat& PrevP, const FQuat& P, const FQuat& NextP, float Tension, FQuat& OutTan);
public:
/**
* Serializes the quaternion.
*
* @param Ar Reference to the serialization archive.
* @param F Reference to the quaternion being serialized.
* @return Reference to the Archive after serialization.
*/
friend FArchive& operator<<(FArchive& Ar, FQuat& F)
{
return Ar << F.X << F.Y << F.Z << F.W;
}
bool Serialize(FArchive& Ar)
{
Ar << *this;
return true;
}
} GCC_ALIGN(16);
/* FQuat inline functions
*****************************************************************************/
inline FQuat::FQuat(const FMatrix& M)
{
// If Matrix is NULL, return Identity quaternion. If any of them is 0, you won't be able to construct rotation
// if you have two plane at least, we can reconstruct the frame using cross product, but that's a bit expensive op to do here
// for now, if you convert to matrix from 0 scale and convert back, you'll lose rotation. Don't do that.
if (M.GetScaledAxis(EAxis::X).IsNearlyZero() || M.GetScaledAxis(EAxis::Y).IsNearlyZero() || M.GetScaledAxis(EAxis::Z).IsNearlyZero())
{
*this = FQuat::Identity;
return;
}
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
// Make sure the Rotation part of the Matrix is unit length.
// Changed to this (same as RemoveScaling) from RotDeterminant as using two different ways of checking unit length matrix caused inconsistency.
if (!ensure((FMath::Abs(1.f - M.GetScaledAxis(EAxis::X).SizeSquared()) <= KINDA_SMALL_NUMBER) && (FMath::Abs(1.f - M.GetScaledAxis(EAxis::Y).SizeSquared()) <= KINDA_SMALL_NUMBER) && (FMath::Abs(1.f - M.GetScaledAxis(EAxis::Z).SizeSquared()) <= KINDA_SMALL_NUMBER)))
{
*this = FQuat::Identity;
return;
}
#endif
//const MeReal *const t = (MeReal *) tm;
float s;
// Check diagonal (trace)
const float tr = M.M[0][0] + M.M[1][1] + M.M[2][2];
if (tr > 0.0f)
{
float InvS = FMath::InvSqrt(tr + 1.f);
this->W = 0.5f * (1.f / InvS);
s = 0.5f * InvS;
this->X = (M.M[1][2] - M.M[2][1]) * s;
this->Y = (M.M[2][0] - M.M[0][2]) * s;
this->Z = (M.M[0][1] - M.M[1][0]) * s;
}
else
{
// diagonal is negative
int32 i = 0;
if (M.M[1][1] > M.M[0][0])
i = 1;
if (M.M[2][2] > M.M[i][i])
i = 2;
static const int32 nxt[3] = { 1, 2, 0 };
const int32 j = nxt[i];
const int32 k = nxt[j];
s = M.M[i][i] - M.M[j][j] - M.M[k][k] + 1.0f;
float InvS = FMath::InvSqrt(s);
float qt[4];
qt[i] = 0.5f * (1.f / InvS);
s = 0.5f * InvS;
qt[3] = (M.M[j][k] - M.M[k][j]) * s;
qt[j] = (M.M[i][j] + M.M[j][i]) * s;
qt[k] = (M.M[i][k] + M.M[k][i]) * s;
this->X = qt[0];
this->Y = qt[1];
this->Z = qt[2];
this->W = qt[3];
DiagnosticCheckNaN();
}
}
FORCEINLINE FQuat::FQuat(const FRotator& R)
{
*this = R.Quaternion();
DiagnosticCheckNaN();
}
FORCEINLINE FVector FQuat::operator*(const FVector& V) const
{
return RotateVector(V);
}
inline FMatrix FQuat::operator*(const FMatrix& M) const
{
FMatrix Result;
FQuat VT, VR;
FQuat Inv = Inverse();
for (int32 I=0; I<4; ++I)
{
FQuat VQ(M.M[I][0], M.M[I][1], M.M[I][2], M.M[I][3]);
VectorQuaternionMultiply(&VT, this, &VQ);
VectorQuaternionMultiply(&VR, &VT, &Inv);
Result.M[I][0] = VR.X;
Result.M[I][1] = VR.Y;
Result.M[I][2] = VR.Z;
Result.M[I][3] = VR.W;
}
return Result;
}
/* FQuat inline functions
*****************************************************************************/
FORCEINLINE FQuat::FQuat(EForceInit ZeroOrNot)
: X(0), Y(0), Z(0), W(ZeroOrNot == ForceInitToZero ? 0.0f : 1.0f)
{ }
FORCEINLINE FQuat::FQuat(float InX, float InY, float InZ, float InW)
: X(InX)
, Y(InY)
, Z(InZ)
, W(InW)
{
DiagnosticCheckNaN();
}
FORCEINLINE FQuat::FQuat(const FQuat& Q)
: X(Q.X)
, Y(Q.Y)
, Z(Q.Z)
, W(Q.W)
{ }
FORCEINLINE FString FQuat::ToString() const
{
return FString::Printf(TEXT("X=%.9f Y=%.9f Z=%.9f W=%.9f"), X, Y, Z, W);
}
inline bool FQuat::InitFromString(const FString& InSourceString)
{
X = Y = Z = 0.f;
W = 1.f;
const bool bSuccess
= FParse::Value(*InSourceString, TEXT("X="), X)
&& FParse::Value(*InSourceString, TEXT("Y="), Y)
&& FParse::Value(*InSourceString, TEXT("Z="), Z)
&& FParse::Value(*InSourceString, TEXT("W="), W);
DiagnosticCheckNaN();
return bSuccess;
}
#ifdef IMPLEMENT_ASSIGNMENT_OPERATOR_MANUALLY
FORCEINLINE FQuat& FQuat::operator=(const FQuat& Other)
{
this->X = Other.X;
this->Y = Other.Y;
this->Z = Other.Z;
this->W = Other.W;
return *this;
}
#endif
FORCEINLINE FQuat::FQuat(FVector Axis, float AngleRad)
{
const float half_a = 0.5f * AngleRad;
float s, c;
FMath::SinCos(&s, &c, half_a);
X = s * Axis.X;
Y = s * Axis.Y;
Z = s * Axis.Z;
W = c;
DiagnosticCheckNaN();
}
FORCEINLINE FQuat FQuat::operator+(const FQuat& Q) const
{
return FQuat(X + Q.X, Y + Q.Y, Z + Q.Z, W + Q.W);
}
FORCEINLINE FQuat FQuat::operator+=(const FQuat& Q)
{
this->X += Q.X;
this->Y += Q.Y;
this->Z += Q.Z;
this->W += Q.W;
DiagnosticCheckNaN();
return *this;
}
FORCEINLINE FQuat FQuat::operator-(const FQuat& Q) const
{
return FQuat(X - Q.X, Y - Q.Y, Z - Q.Z, W - Q.W);
}
FORCEINLINE bool FQuat::Equals(const FQuat& Q, float Tolerance) const
{
#if PLATFORM_ENABLE_VECTORINTRINSICS
const VectorRegister ToleranceV = VectorLoadFloat1(&Tolerance);
const VectorRegister A = VectorLoadAligned(this);
const VectorRegister B = VectorLoadAligned(&Q);
const VectorRegister RotationSub = VectorAbs(VectorSubtract(A, B));
const VectorRegister RotationAdd = VectorAbs(VectorAdd(A, B));
return !VectorAnyGreaterThan(RotationSub, ToleranceV) || !VectorAnyGreaterThan(RotationAdd, ToleranceV);
#else
return (FMath::Abs(X - Q.X) <= Tolerance && FMath::Abs(Y - Q.Y) <= Tolerance && FMath::Abs(Z - Q.Z) <= Tolerance && FMath::Abs(W - Q.W) <= Tolerance)
|| (FMath::Abs(X + Q.X) <= Tolerance && FMath::Abs(Y + Q.Y) <= Tolerance && FMath::Abs(Z + Q.Z) <= Tolerance && FMath::Abs(W + Q.W) <= Tolerance);
#endif // PLATFORM_ENABLE_VECTORINTRINSICS
}
FORCEINLINE bool FQuat::IsIdentity(float Tolerance) const
{
return Equals(FQuat::Identity, Tolerance);
}
FORCEINLINE FQuat FQuat::operator-=(const FQuat& Q)
{
this->X -= Q.X;
this->Y -= Q.Y;
this->Z -= Q.Z;
this->W -= Q.W;
DiagnosticCheckNaN();
return *this;
}
FORCEINLINE FQuat FQuat::operator*(const FQuat& Q) const
{
FQuat Result;
VectorQuaternionMultiply(&Result, this, &Q);
Result.DiagnosticCheckNaN();
return Result;
}
FORCEINLINE FQuat FQuat::operator*=(const FQuat& Q)
{
VectorRegister A = VectorLoadAligned(this);
VectorRegister B = VectorLoadAligned(&Q);
VectorRegister Result;
VectorQuaternionMultiply(&Result, &A, &B);
VectorStoreAligned(Result, this);
DiagnosticCheckNaN();
return *this;
}
FORCEINLINE FQuat FQuat::operator*=(const float Scale)
{
X *= Scale;
Y *= Scale;
Z *= Scale;
W *= Scale;
DiagnosticCheckNaN();
return *this;
}
FORCEINLINE FQuat FQuat::operator*(const float Scale) const
{
return FQuat(Scale * X, Scale * Y, Scale * Z, Scale * W);
}
FORCEINLINE FQuat FQuat::operator/=(const float Scale)
{
const float Recip = 1.0f / Scale;
X *= Recip;
Y *= Recip;
Z *= Recip;
W *= Recip;
DiagnosticCheckNaN();
return *this;
}
FORCEINLINE FQuat FQuat::operator/(const float Scale) const
{
const float Recip = 1.0f / Scale;
return FQuat(X * Recip, Y * Recip, Z * Recip, W * Recip);
}
FORCEINLINE bool FQuat::operator==(const FQuat& Q) const
{
#if PLATFORM_ENABLE_VECTORINTRINSICS
const VectorRegister A = VectorLoadAligned(this);
const VectorRegister B = VectorLoadAligned(&Q);
return VectorMaskBits(VectorCompareEQ(A, B)) == 0x0F;
#else
return X == Q.X && Y == Q.Y && Z == Q.Z && W == Q.W;
#endif // PLATFORM_ENABLE_VECTORINTRINSICS
}
FORCEINLINE bool FQuat::operator!=(const FQuat& Q) const
{
#if PLATFORM_ENABLE_VECTORINTRINSICS
const VectorRegister A = VectorLoadAligned(this);
const VectorRegister B = VectorLoadAligned(&Q);
return VectorMaskBits(VectorCompareNE(A, B)) != 0x00;
#else
return X != Q.X || Y != Q.Y || Z != Q.Z || W != Q.W;
#endif // PLATFORM_ENABLE_VECTORINTRINSICS
}
FORCEINLINE float FQuat::operator|(const FQuat& Q) const
{
return X * Q.X + Y * Q.Y + Z * Q.Z + W * Q.W;
}
FORCEINLINE void FQuat::Normalize(float Tolerance)
{
#if PLATFORM_ENABLE_VECTORINTRINSICS
const VectorRegister Vector = VectorLoadAligned(this);
const VectorRegister SquareSum = VectorDot4(Vector, Vector);
const VectorRegister NonZeroMask = VectorCompareGE(SquareSum, VectorLoadFloat1(&Tolerance));
const VectorRegister InvLength = VectorReciprocalSqrtAccurate(SquareSum);
const VectorRegister NormalizedVector = VectorMultiply(InvLength, Vector);
VectorRegister Result = VectorSelect(NonZeroMask, NormalizedVector, GlobalVectorConstants::Float0001);
VectorStoreAligned(Result, this);
#else
const float SquareSum = X * X + Y * Y + Z * Z + W * W;
if (SquareSum >= Tolerance)
{
const float Scale = FMath::InvSqrt(SquareSum);
X *= Scale;
Y *= Scale;
Z *= Scale;
W *= Scale;
}
else
{
*this = FQuat::Identity;
}
#endif // PLATFORM_ENABLE_VECTORINTRINSICS
}
FORCEINLINE FQuat FQuat::GetNormalized(float Tolerance) const
{
FQuat Result(*this);
Result.Normalize(Tolerance);
return Result;
}
FORCEINLINE bool FQuat::IsNormalized() const
{
return (FMath::Abs(1.f - SizeSquared()) < THRESH_QUAT_NORMALIZED);
}
FORCEINLINE float FQuat::Size() const
{
return FMath::Sqrt(X * X + Y * Y + Z * Z + W * W);
}
FORCEINLINE float FQuat::SizeSquared() const
{
return (X * X + Y * Y + Z * Z + W * W);
}
FORCEINLINE float FQuat::GetAngle() const
{
return 2.f * FMath::Acos(W);
}
FORCEINLINE void FQuat::ToAxisAndAngle(FVector& Axis, float& Angle) const
{
Angle = GetAngle();
Axis = GetRotationAxis();
}
FORCEINLINE FVector FQuat::GetRotationAxis() const
{
// Ensure we never try to sqrt a neg number
const float S = FMath::Sqrt(FMath::Max(1.f - (W * W), 0.f));
if (S >= 0.0001f)
{
return FVector(X / S, Y / S, Z / S);
}
return FVector(1.f, 0.f, 0.f);
}
float FQuat::AngularDistance(const FQuat& Q) const
{
float InnerProd = X*Q.X + Y*Q.Y + Z*Q.Z + W*Q.W;
return FMath::Acos((2 * InnerProd * InnerProd) - 1.f);
}
FORCEINLINE FVector FQuat::RotateVector(FVector V) const
{
#if WITH_DIRECTXMATH
FVector Result;
VectorQuaternionVector3Rotate(&Result, &V, this);
return Result;
#else
// http://people.csail.mit.edu/bkph/articles/Quaternions.pdf
// V' = V + 2w(Q x V) + (2Q x (Q x V))
// refactor:
// V' = V + w(2(Q x V)) + (Q x (2(Q x V)))
// T = 2(Q x V);
// V' = V + w*(T) + (Q x T)
const FVector Q(X, Y, Z);
const FVector T = 2.f * FVector::CrossProduct(Q, V);
const FVector Result = V + (W * T) + FVector::CrossProduct(Q, T);
return Result;
#endif
}
FORCEINLINE FVector FQuat::UnrotateVector(FVector V) const
{
#if WITH_DIRECTXMATH
FVector Result;
VectorQuaternionVector3InverseRotate(&Result, &V, this);
return Result;
#else
//return Inverse().RotateVector(V);
const FVector Q(-X, -Y, -Z); // Inverse
const FVector T = 2.f * FVector::CrossProduct(Q, V);
const FVector Result = V + (W * T) + FVector::CrossProduct(Q, T);
return Result;
#endif
}
FORCEINLINE FQuat FQuat::Inverse() const
{
checkSlow(IsNormalized());
return FQuat(-X, -Y, -Z, W);
}
FORCEINLINE void FQuat::EnforceShortestArcWith(const FQuat& OtherQuat)
{
const float DotResult = (OtherQuat | *this);
const float Bias = FMath::FloatSelect(DotResult, 1.0f, -1.0f);
X *= Bias;
Y *= Bias;
Z *= Bias;
W *= Bias;
}
FORCEINLINE FVector FQuat::GetAxisX() const
{
return RotateVector(FVector(1.f, 0.f, 0.f));
}
FORCEINLINE FVector FQuat::GetAxisY() const
{
return RotateVector(FVector(0.f, 1.f, 0.f));
}
FORCEINLINE FVector FQuat::GetAxisZ() const
{
return RotateVector(FVector(0.f, 0.f, 1.f));
}
FORCEINLINE FVector FQuat::GetForwardVector() const
{
return GetAxisX();
}
FORCEINLINE FVector FQuat::GetRightVector() const
{
return GetAxisY();
}
FORCEINLINE FVector FQuat::GetUpVector() const
{
return GetAxisZ();
}
FORCEINLINE FVector FQuat::Vector() const
{
return GetAxisX();
}
FORCEINLINE float FQuat::Error(const FQuat& Q1, const FQuat& Q2)
{
const float cosom = FMath::Abs(Q1.X * Q2.X + Q1.Y * Q2.Y + Q1.Z * Q2.Z + Q1.W * Q2.W);
return (FMath::Abs(cosom) < 0.9999999f) ? FMath::Acos(cosom)*(1.f / PI) : 0.0f;
}
FORCEINLINE float FQuat::ErrorAutoNormalize(const FQuat& A, const FQuat& B)
{
FQuat Q1 = A;
Q1.Normalize();
FQuat Q2 = B;
Q2.Normalize();
return FQuat::Error(Q1, Q2);
}
/**
* Fast Linear Quaternion Interpolation.
* Result is NOT normalized.
*/
FORCEINLINE FQuat FQuat::FastLerp(const FQuat& A, const FQuat& B, const float Alpha)
{
// To ensure the 'shortest route', we make sure the dot product between the both rotations is positive.
const float DotResult = (A | B);
const float Bias = FMath::FloatSelect(DotResult, 1.0f, -1.0f);
return (B * Alpha) + (A * (Bias * (1.f - Alpha)));
}
FORCEINLINE FQuat FQuat::FastBilerp(const FQuat& P00, const FQuat& P10, const FQuat& P01, const FQuat& P11, float FracX, float FracY)
{
return FQuat::FastLerp(
FQuat::FastLerp(P00,P10,FracX),
FQuat::FastLerp(P01,P11,FracX),
FracY
);
}
FORCEINLINE bool FQuat::ContainsNaN() const
{
return (!FMath::IsFinite(X) ||
!FMath::IsFinite(Y) ||
!FMath::IsFinite(Z) ||
!FMath::IsFinite(W)
);
}
template<> struct TIsPODType<FQuat> { enum { Value = true }; };
/* FMath inline functions
*****************************************************************************/
template<class U>
FORCEINLINE_DEBUGGABLE FQuat FMath::Lerp( const FQuat& A, const FQuat& B, const U& Alpha)
{
return FQuat::Slerp(A, B, Alpha);
}
template<class U>
FORCEINLINE_DEBUGGABLE FQuat FMath::BiLerp(const FQuat& P00, const FQuat& P10, const FQuat& P01, const FQuat& P11, float FracX, float FracY)
{
FQuat Result;
Result = Lerp(
FQuat::Slerp_NotNormalized(P00,P10,FracX),
FQuat::Slerp_NotNormalized(P01,P11,FracX),
FracY
);
return Result;
}
template<class U>
FORCEINLINE_DEBUGGABLE FQuat FMath::CubicInterp( const FQuat& P0, const FQuat& T0, const FQuat& P1, const FQuat& T1, const U& A)
{
return FQuat::Squad(P0, T0, P1, T1, A);
}
| [
"tungnt.rec@gmail.com"
] | tungnt.rec@gmail.com |
5b345146829bfaaa1b863725ac1f6115829c0733 | 84de54b0b9d73202b4136a6de8c3ae05b8259b2d | /src/scanner.cpp | ec6ca9427e0c661ac51201b1a4b784324c98d841 | [] | no_license | Naoki-Kameyama/turtlebot_cpp | 9bae99db2ef0cc05f6f898852348c93a91e7c582 | 8f82b2698eb8e16716483e76bab5bc18ab2bdbda | refs/heads/master | 2021-01-11T14:10:38.025580 | 2017-06-21T10:22:54 | 2017-06-21T10:22:54 | 94,991,692 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,803 | cpp | #include <ros/ros.h>
#include <nav_msgs/OccupancyGrid.h>
#include <geometry_msgs/Point.h>
#include <geometry_msgs/Twist.h>
#include <map_based_navigation/frontier.h>
#include "std_msgs/String.h"
#include <sstream>
#include <sensor_msgs/LaserScan.h>
//フロンティアを検索する関数//
void scanner(const nav_msgs::OccupancyGrid::ConstPtr& msg){
//地図データを配列に格納//
int fro_num;
std::vector<float> fro_x;//見つけたフロンティアのx座標
std::vector<float> fro_y;//見つけたフロンティアのy座標
nav_msgs::MapMetaData info = msg->info;//地図の設定を取得
std::vector<int8_t> data = msg->data;//地図の値を取得
int x = info.width;//地図の横サイズ
int y = info.height;//地図の縦サイズ
int8_t map_array[x][y];//地図を行列に格納
int frontier_flag[x][y];//探査済みと未探査の境界を判定するフラグ
int i,j;//for文
int k = 0;//for文
ros::NodeHandle nnh ;
ros::Publisher frontier_pub = nnh.advertise<map_based_navigation::frontier>("frontier", 1000);
map_based_navigation::frontier frontier;
std::cout << "start:地図データを配列に格納" << std::endl;
for(i=0;i<y;i++){
for(j=0;j<x;j++){
map_array[j][i] = data[k];
if(map_array[j][i]!=0 && map_array[j][i]!=100 && map_array[j][i]!=-1){
std::cout << "exception:" << map_array[j][i] << std::endl;
}
frontier_flag[j][i] = 0;
k++;
}
}
std::cout << "end :地図データを配列に格納" << std::endl;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//横方向で未探査と探査済の境界を探す//
std::cout << "start:横方向で境界を検索" << std::endl;
for(i=0;i<y;i++){
for(j=0;j<(x-1);j++){
if(map_array[j][i] == 0 && map_array[j+1][i] == -1){
frontier_flag[j][i] = 1;
}
else if(map_array[j][i] == -1 && map_array[j+1][i] == 0){
frontier_flag[j+1][i] = 1;
}
}
}
std::cout << "end :横方向で境界を検索" << std::endl;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//縦方向で未探査と探査済の境界を探す/////////////////////////////////////////////////////////////////////////////
std::cout << "start:縦方向で境界を検索" << std::endl;
for(j=0;j<x;j++){
for(i=0;i<(y-1);i++){
if(map_array[j][i] == 0 && map_array[j][i+1] == -1){
frontier_flag[j][i] = 1;
}
else if(map_array[j][i] == -1 && map_array[j][i+1] == 0){
frontier_flag[j][i+1] = 1;
}
}
}
std::cout << "end :縦方向で境界を検索" << std::endl;
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//横方向にフラグが8マス続いてる場所を探す////////////////////////////////////////////////////////////////////////
float m_per_cell = info.resolution;//[m/cell]
float robot_diameter = 0.4; //ロボットの直径[m]
int robot_cellsize = robot_diameter / m_per_cell;//セル換算したロボットサイズ
int frontier_sum;//フラグが続いているかの判定用
float frontier_center;//フロンティア境界の中点
float low_left_x = info.origin.position.x;//地図の左下のx座標
float low_left_y = info.origin.position.y;//地図の左下のy座標
fro_num = 0;//フロンティアの個数を初期化
std::cout << "start:横方向で境界が連続している場所を検索" << std::endl;
for(i=1;i<(y-1);i++){
for(j=0;j<(x-robot_cellsize);j++){
frontier_sum = 0;
for(k=j;k<(j+robot_cellsize);k++){
frontier_sum=frontier_sum+frontier_flag[k][i];
if(frontier_flag[k][i] == 0 && (frontier_flag[k][i-1] || frontier_flag[k][i+1])){
frontier_sum++;
}
}
if(frontier_sum == robot_cellsize){
frontier_center = (j+robot_cellsize-1)-(robot_cellsize/2);
fro_x.push_back(frontier_center * m_per_cell + low_left_x);
fro_y.push_back(low_left_y + (m_per_cell * i));
fro_num++;
}
}
}
std::cout << "end :横方向で境界が連続している場所を検索" << std::endl;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//縦方向にフラグが8マス続いてる場所を探す////////////////////////////////////////////////////////////////////////
std::cout << "start:縦方向で境界が連続している場所を検索" << std::endl;
for(j=1;j<(x-1);j++){
for(i=0;i<(y-robot_cellsize);i++){
frontier_sum = 0;
for(k=i;k<(i+robot_cellsize);k++){
frontier_sum=frontier_sum+frontier_flag[j][k];
if(frontier_flag[j][k] == 0 && (frontier_flag[j-1][k] || frontier_flag[j+1][k])){
frontier_sum++;
}
}
if(frontier_sum == robot_cellsize){
frontier_center = (i+robot_cellsize -1)-(robot_cellsize/2);
fro_x.push_back(low_left_x + (m_per_cell * j));
fro_y.push_back(frontier_center * m_per_cell + low_left_y);
fro_num++;
}
}
}
std::cout << "end :縦方向で境界が連続している場所を検索" << std::endl;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//見つけた領域をパブリッシュ///////////////////////////////////////////////////////////////////////////////////////
frontier.fro_x = fro_x;
frontier.fro_y = fro_y;
frontier.fro_num = fro_num;
frontier_pub.publish(frontier);
std::cout << "＊＊＊＊＊＊＊＊＊＊見つけた領域を配信＊＊＊＊＊＊＊＊＊＊\n" << std::endl;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//360[deg]回転////////////////////////////////////////////////////////////////////////////////////////////////
void robot_rotate(){
ros::NodeHandle nhhh ;
ros::Publisher vel_pub = nhhh.advertise<geometry_msgs::Twist>("/mobile_base/commands/velocity", 10);
geometry_msgs::Twist vel;
vel.angular.z = 0.5;
ros::Duration timeout(16.8);
ros::Time start_time = ros::Time::now();
while(ros::Time::now() - start_time < timeout){
ros::Rate rate(10.0);
vel_pub.publish(vel);
rate.sleep();
}
}
int main(int argc, char** argv){
ros::init(argc, argv, "scanner"); //ノード名を定義しノードの初初期化を行う
ros::NodeHandle nh ; //ノードハンドラのインスタンスを生成
ros::Rate rate(1);
while(ros::ok()) {
std::cout << "start" << std::endl;
ros::Subscriber sub = nh.subscribe("/scan",1000,scanner);
rate.sleep();
}
return 0;
}
| [
"16kmj15@ms.dendai.ac.jp"
] | 16kmj15@ms.dendai.ac.jp |
4b7e918ca06c299e1a0f8a9b8205dac57ad17a9b | e27f9d4c48355b5ea6d562aae35b7ca46ed3fc1c | /src/projects/compiler-rt/lib/asan/asan_interface_internal.h | 58bde224329000c309cc6c012655bf3e76969959 | [
"NCSA",
"MIT"
] | permissive | dongAxis/clang-700.0.72 | 67c4bb38b77e63da966e5dbd4e6ea7b6725b2484 | 513e64095d87e15954b41a22da367552a1c4dcc4 | refs/heads/master | 2021-01-10T12:17:26.230788 | 2016-02-04T04:29:53 | 2016-02-04T04:29:53 | 51,051,978 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,502 | h | //===-- asan_interface_internal.h -------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file is a part of AddressSanitizer, an address sanity checker.
//
// This header can be included by the instrumented program to fetch
// data (mostly allocator statistics) from ASan runtime library.
//===----------------------------------------------------------------------===//
#ifndef ASAN_INTERFACE_INTERNAL_H
#define ASAN_INTERFACE_INTERNAL_H
#include "sanitizer_common/sanitizer_internal_defs.h"
#include "asan_init_version.h"
using __sanitizer::uptr;
extern "C" {
// This function should be called at the very beginning of the process,
// before any instrumented code is executed and before any call to malloc.
SANITIZER_INTERFACE_ATTRIBUTE void __asan_init();
// This function exists purely to get a linker/loader error when using
// incompatible versions of instrumentation and runtime library. Please note
// that __asan_version_mismatch_check is a macro that is replaced with
// __asan_version_mismatch_check_vXXX at compile-time.
SANITIZER_INTERFACE_ATTRIBUTE void __asan_version_mismatch_check();
// This structure is used to describe the source location of a place where
// global was defined.
struct __asan_global_source_location {
const char *filename;
int line_no;
int column_no;
};
// This structure describes an instrumented global variable.
struct __asan_global {
uptr beg; // The address of the global.
uptr size; // The original size of the global.
uptr size_with_redzone; // The size with the redzone.
const char *name; // Name as a C string.
const char *module_name; // Module name as a C string. This pointer is a
// unique identifier of a module.
uptr has_dynamic_init; // Non-zero if the global has dynamic initializer.
__asan_global_source_location *location; // Source location of a global,
// or NULL if it is unknown.
};
// These two functions should be called by the instrumented code.
// 'globals' is an array of structures describing 'n' globals.
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_register_globals(__asan_global *globals, uptr n);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_unregister_globals(__asan_global *globals, uptr n);
// These two functions should be called before and after dynamic initializers
// of a single module run, respectively.
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_before_dynamic_init(const char *module_name);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_after_dynamic_init();
// These two functions are used by instrumented code in the
// use-after-scope mode. They mark memory for local variables as
// unaddressable when they leave scope and addressable before the
// function exits.
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_poison_stack_memory(uptr addr, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_unpoison_stack_memory(uptr addr, uptr size);
// Performs cleanup before a NoReturn function. Must be called before things
// like _exit and execl to avoid false positives on stack.
SANITIZER_INTERFACE_ATTRIBUTE void __asan_handle_no_return();
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_poison_memory_region(void const volatile *addr, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_unpoison_memory_region(void const volatile *addr, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE
int __asan_address_is_poisoned(void const volatile *addr);
SANITIZER_INTERFACE_ATTRIBUTE
uptr __asan_region_is_poisoned(uptr beg, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_describe_address(uptr addr);
SANITIZER_INTERFACE_ATTRIBUTE
int __asan_report_present();
SANITIZER_INTERFACE_ATTRIBUTE
uptr __asan_get_report_pc();
SANITIZER_INTERFACE_ATTRIBUTE
uptr __asan_get_report_bp();
SANITIZER_INTERFACE_ATTRIBUTE
uptr __asan_get_report_sp();
SANITIZER_INTERFACE_ATTRIBUTE
uptr __asan_get_report_address();
SANITIZER_INTERFACE_ATTRIBUTE
int __asan_get_report_access_type();
SANITIZER_INTERFACE_ATTRIBUTE
uptr __asan_get_report_access_size();
SANITIZER_INTERFACE_ATTRIBUTE
const char * __asan_get_report_description();
SANITIZER_INTERFACE_ATTRIBUTE
const char * __asan_locate_address(uptr addr, char *name, uptr name_size,
uptr *region_address, uptr *region_size);
SANITIZER_INTERFACE_ATTRIBUTE
uptr __asan_get_alloc_stack(uptr addr, uptr *trace, uptr size,
u32 *thread_id);
SANITIZER_INTERFACE_ATTRIBUTE
uptr __asan_get_free_stack(uptr addr, uptr *trace, uptr size,
u32 *thread_id);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_get_shadow_mapping(uptr *shadow_scale, uptr *shadow_offset);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_report_error(uptr pc, uptr bp, uptr sp,
uptr addr, int is_write, uptr access_size);
SANITIZER_INTERFACE_ATTRIBUTE
int __asan_set_error_exit_code(int exit_code);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_set_death_callback(void (*callback)(void));
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_set_error_report_callback(void (*callback)(const char*));
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
/* OPTIONAL */ void __asan_on_error();
SANITIZER_INTERFACE_ATTRIBUTE void __asan_print_accumulated_stats();
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
/* OPTIONAL */ const char* __asan_default_options();
// Global flag, copy of ASAN_OPTIONS=detect_stack_use_after_return
SANITIZER_INTERFACE_ATTRIBUTE
extern int __asan_option_detect_stack_use_after_return;
SANITIZER_INTERFACE_ATTRIBUTE
extern uptr *__asan_test_only_reported_buggy_pointer;
SANITIZER_INTERFACE_ATTRIBUTE void __asan_load1(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_load2(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_load4(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_load8(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_load16(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_store1(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_store2(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_store4(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_store8(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_store16(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_loadN(uptr p, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE void __asan_storeN(uptr p, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE
void* __asan_memcpy(void *dst, const void *src, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE
void* __asan_memset(void *s, int c, uptr n);
SANITIZER_INTERFACE_ATTRIBUTE
void* __asan_memmove(void* dest, const void* src, uptr n);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_poison_cxx_array_cookie(uptr p);
SANITIZER_INTERFACE_ATTRIBUTE
uptr __asan_load_cxx_array_cookie(uptr *p);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_poison_intra_object_redzone(uptr p, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE
void __asan_unpoison_intra_object_redzone(uptr p, uptr size);
} // extern "C"
#endif // ASAN_INTERFACE_INTERNAL_H
| [
"amo260@gmail.com"
] | amo260@gmail.com |
afb74d5120004df23902bdac58448b54e64911a0 | 2195aa79fbd3cf2f048ad5a9ee3a1ef948ff6601 | /q3/qm/src/model/filter.cpp | ce9e5fab94d394a92a7752712e1a0ede859ba3e8 | [
"MIT"
] | permissive | snakamura/q3 | d3601503df4ebb08f051332a9669cd71dc5256b2 | 6ab405b61deec8bb3fc0f35057dd880efd96b87f | refs/heads/master | 2016-09-02T00:33:43.224628 | 2014-07-22T23:38:22 | 2014-07-22T23:38:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,704 | cpp | /*
* $Id$
*
* Copyright(C) 1998-2008 Satoshi Nakamura
*
*/
#pragma warning(disable:4786)
#include <qmmacro.h>
#include <qsconv.h>
#include <qsfile.h>
#include <qsosutil.h>
#include <qsstl.h>
#include <algorithm>
#include "filter.h"
using namespace qm;
using namespace qs;
/****************************************************************************
*
* FilterManager
*
*/
qm::FilterManager::FilterManager(const WCHAR* pwszPath) :
helper_(pwszPath)
{
}
qm::FilterManager::~FilterManager()
{
clear();
}
const FilterManager::FilterList& qm::FilterManager::getFilters()
{
return getFilters(true);
}
const FilterManager::FilterList& qm::FilterManager::getFilters(bool bReload)
{
if (bReload)
load();
return listFilter_;
}
const Filter* qm::FilterManager::getFilter(const WCHAR* pwszName)
{
load();
FilterList::const_iterator it = std::find_if(
listFilter_.begin(), listFilter_.end(),
boost::bind(string_equal<WCHAR>(),
boost::bind(&Filter::getName, _1), pwszName));
return it != listFilter_.end() ? *it : 0;
}
void qm::FilterManager::setFilters(FilterList& listFilter)
{
clear();
listFilter_.swap(listFilter);
}
bool qm::FilterManager::save() const
{
return helper_.save(this);
}
void qm::FilterManager::clear()
{
std::for_each(listFilter_.begin(), listFilter_.end(),
boost::checked_deleter<Filter>());
listFilter_.clear();
}
bool qm::FilterManager::load()
{
FilterContentHandler handler(&listFilter_);
return helper_.load(this, &handler);
}
/****************************************************************************
*
* Filter
*
*/
qm::Filter::Filter()
{
wstrName_ = allocWString(L"");
pCondition_ = MacroParser().parse(L"@True()");
assert(pCondition_.get());
}
qm::Filter::Filter(const WCHAR* pwszName,
std::auto_ptr<Macro> pCondition) :
pCondition_(pCondition)
{
wstrName_ = allocWString(pwszName);
}
qm::Filter::Filter(const Filter& filter)
{
wstrName_ = allocWString(filter.wstrName_.get());
wstring_ptr wstrCondition(filter.pCondition_->getString());
pCondition_ = MacroParser().parse(wstrCondition.get());
assert(pCondition_.get());
}
qm::Filter::~Filter()
{
}
const WCHAR* qm::Filter::getName() const
{
assert(wstrName_.get());
return wstrName_.get();
}
void qm::Filter::setName(const WCHAR* pwszName)
{
assert(pwszName);
wstrName_ = allocWString(pwszName);
}
const Macro* qm::Filter::getCondition() const
{
assert(pCondition_.get());
return pCondition_.get();
}
void qm::Filter::setCondition(std::auto_ptr<Macro> pCondition)
{
assert(pCondition.get());
pCondition_ = pCondition;
}
bool qm::Filter::match(MacroContext* pContext) const
{
assert(pContext);
MacroValuePtr pValue(pCondition_->value(pContext));
return pValue.get() && pValue->boolean();
}
/****************************************************************************
*
* FilterContentHandler
*
*/
qm::FilterContentHandler::FilterContentHandler(FilterList* pListFilter) :
pListFilter_(pListFilter),
state_(STATE_ROOT)
{
}
qm::FilterContentHandler::~FilterContentHandler()
{
}
bool qm::FilterContentHandler::startElement(const WCHAR* pwszNamespaceURI,
const WCHAR* pwszLocalName,
const WCHAR* pwszQName,
const Attributes& attributes)
{
if (wcscmp(pwszLocalName, L"filters") == 0) {
if (state_ != STATE_ROOT)
return false;
if (attributes.getLength() != 0)
return false;
state_ = STATE_FILTERS;
}
else if (wcscmp(pwszLocalName, L"filter") == 0) {
if (state_ != STATE_FILTERS)
return false;
const WCHAR* pwszName = 0;
for (int n = 0; n < attributes.getLength(); ++n) {
const WCHAR* pwszAttrName = attributes.getLocalName(n);
if (wcscmp(pwszAttrName, L"name") == 0)
pwszName = attributes.getValue(n);
else
return false;
}
if (!pwszName)
return false;
assert(!wstrName_.get());
wstrName_ = allocWString(pwszName);
state_ = STATE_FILTER;
}
else {
return false;
}
return true;
}
bool qm::FilterContentHandler::endElement(const WCHAR* pwszNamespaceURI,
const WCHAR* pwszLocalName,
const WCHAR* pwszQName)
{
if (wcscmp(pwszLocalName, L"filters") == 0) {
assert(state_ == STATE_FILTERS);
state_ = STATE_ROOT;
}
else if (wcscmp(pwszLocalName, L"filter") == 0) {
assert(state_ == STATE_FILTER);
const WCHAR* pwszMacro = buffer_.getCharArray();
std::auto_ptr<Macro> pMacro(MacroParser().parse(pwszMacro));
if (!pMacro.get())
return false;
std::auto_ptr<Filter> pFilter(new Filter(wstrName_.get(), pMacro));
pListFilter_->push_back(pFilter.get());
pFilter.release();
wstrName_.reset(0);
buffer_.remove();
state_ = STATE_FILTERS;
}
else {
return false;
}
return true;
}
bool qm::FilterContentHandler::characters(const WCHAR* pwsz,
size_t nStart,
size_t nLength)
{
if (state_ == STATE_FILTER) {
buffer_.append(pwsz + nStart, nLength);
}
else {
const WCHAR* p = pwsz + nStart;
for (size_t n = 0; n < nLength; ++n, ++p) {
if (*p != L' ' && *p != L'\t' && *p != '\n')
return false;
}
}
return true;
}
/****************************************************************************
*
* FilterWriter
*
*/
qm::FilterWriter::FilterWriter(Writer* pWriter,
const WCHAR* pwszEncoding) :
handler_(pWriter, pwszEncoding)
{
}
qm::FilterWriter::~FilterWriter()
{
}
bool qm::FilterWriter::write(const FilterManager* pManager)
{
if (!handler_.startDocument())
return false;
if (!handler_.startElement(0, 0, L"filters", DefaultAttributes()))
return false;
const FilterManager::FilterList& l = const_cast<FilterManager*>(pManager)->getFilters(false);
for (FilterManager::FilterList::const_iterator it = l.begin(); it != l.end(); ++it) {
const Filter* pFilter = *it;
if (!write(pFilter))
return false;
}
if (!handler_.endElement(0, 0, L"filters"))
return false;
if (!handler_.endDocument())
return false;
return true;
}
bool qm::FilterWriter::write(const Filter* pFilter)
{
SimpleAttributes attrs(L"name", pFilter->getName());
if (!handler_.startElement(0, 0, L"filter", attrs))
return false;
const Macro* pCondition = pFilter->getCondition();
wstring_ptr wstrCondition(pCondition->getString());
if (!handler_.characters(wstrCondition.get(), 0, wcslen(wstrCondition.get())))
return false;
if (!handler_.endElement(0, 0, L"filter"))
return false;
return true;
}
| [
"snakamura@8af8166b-12a6-a448-a533-9086ace3f9f6"
] | snakamura@8af8166b-12a6-a448-a533-9086ace3f9f6 |
6899bd9c153759cae7aa021644c9d16a16ef87d8 | 056279e49d2e7d856f8357f0a10c77f26829ad04 | /TransformationMatrices.cpp | 0e1275cbadc6cf707c6662e796d2336b1b9eaa70 | [] | no_license | MichalZelechowski/zvlk | 23c72110db0753b0f66fac3ffabf995f2313c38a | 705ac56650333fba92c07aa407bb25e6a2b2ac28 | refs/heads/master | 2022-11-21T15:34:17.152624 | 2020-07-26T20:23:23 | 2020-07-26T20:23:23 | 274,253,073 | 0 | 0 | null | 2020-07-03T22:38:11 | 2020-06-22T22:13:11 | C | UTF-8 | C++ | false | false | 1,380 | cpp | /*
* File: TransformationMatrices.cpp
* Author: Michał Żelechowski <MichalZelechowski@github.com>
*
* Created on 18 czerwca 2020, 17:41
*/
#include "TransformationMatrices.h"
#include <glm/gtc/matrix_transform.hpp>
namespace zvlk {
TransformationMatrices::~TransformationMatrices() {
}
TransformationMatrices::TransformationMatrices(zvlk::Device* device, std::shared_ptr<zvlk::Frame> frame) : UniformBuffer(device, sizeof (TransformationMatricesUBO), frame) {
this->ubos.resize(frame->getImagesNumber());
this->current = glm::mat4(1.0f);
}
void* TransformationMatrices::update(uint32_t index, float time) {
this->ubos[index].model = glm::mat4(this->current);
return &this->ubos[index];
}
TransformationMatrices& TransformationMatrices::rotate(float angleDegrees, glm::vec3 direction) {
this->current = glm::rotate(glm::mat4(1.0f), glm::radians(angleDegrees), direction) * this->current;
return *this;
}
TransformationMatrices& TransformationMatrices::translate(glm::vec3 vector) {
this->current = glm::translate(glm::mat4(1.0f), vector) * this->current;
return *this;
}
TransformationMatrices& TransformationMatrices::scale(glm::vec3 vector) {
this->current = glm::scale(glm::mat4(1.0f), vector)* this->current;
return *this;
}
}
| [
"michal@bastion"
] | michal@bastion |
580ea1746fbed27030f62238448ec16af8300491 | f29f5302d70b388515bb0ba31a2c7ed45ccb71de | /15/main.cpp | 8e8da67300d56ed64872e3841a474ab497d7fad3 | [] | no_license | michellibera/Cplusplus | 28becadc6f06b8d11d9b96c52d56fe1696bc3a85 | 8163b51913122e914531f3f944d37d224582306f | refs/heads/master | 2023-01-30T20:20:08.225373 | 2020-12-08T13:41:37 | 2020-12-08T13:41:37 | 319,426,210 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,369 | cpp |
#include<iostream>
#include<fstream>
using namespace std;
void wczytaj(fstream &dane);
void srednia(fstream &dane,float &sr);
void zapis(fstream &rezultat,float &sr);
int main()
{
float sr;
fstream dane;
fstream rezultat;
wczytaj(dane);
srednia(dane,sr);
dane.close();
cout<<sr<<endl;
zapis(rezultat,sr);
}
void wczytaj(fstream &dane)
{
int i;
int l;
float bufor;
cout<<"Ilosc pomiarow ";
cin>>l;
dane.open("dane.bin", ios::binary|ios::out);
if(dane.good())
{
for(i=0; i<l; i++)
{
cout<<"Pomiar "<<i+1<<": ";
cin >> bufor;
dane.write((char*)&bufor,sizeof(float));
}
dane.close();
}
else
cout<<"Blad"<<endl;
}
void srednia(fstream &dane,float &sr)
{
int l=0;
float bufor;
float suma = 0;
dane.open("dane.bin", ios::binary|ios::in);
while(!dane.eof())
{
dane.read((char*)&bufor,sizeof(bufor));
if(!dane.eof())
{
suma+=bufor;
l++;
cout<<"bufor= "<<bufor<<", suma= "<<suma<<", l= "<<l<<endl;
}
}
sr = suma/l;
dane.close();
}
void zapis(fstream &rezultat, float &sr)
{
rezultat.open("wyniki.txt",ios::out);
rezultat<<sr;
rezultat.close();
}
| [
"michel.libera@gmail.com"
] | michel.libera@gmail.com |
7a526654ace6b7e6662dc0b9d2767a2e87f1f0fc | 2b6b09c2b5adf548043910c1f67d0d90df3bd3db | /DataStructureFoundation/week4/q3.cpp | 6e9523497aeb94355a688cf5d9f9346c9c20f774 | [] | no_license | wzx140/ProgramDesign-Algorithm | e08e5969bae034b908158e2d5041b9758d4d1703 | 3e047d6ef15e09041ad73177ce70821e68b23275 | refs/heads/master | 2020-08-23T09:03:02.079053 | 2020-01-11T04:11:20 | 2020-01-11T04:11:20 | 216,582,358 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 769 | cpp | #include <iostream>
#include <string>
using namespace std;
// 3. 前缀中的周期
int nex[1000010];
void initNext(int len, string a) {
nex[0] = 0;
int k;
for (int i = 1; i < len; i++) {
k = nex[i - 1];
while (a[i] != a[k] && k > 0) {
k = nex[k - 1];
}
if (a[i] == a[k]) {
nex[i] = k + 1;
} else {
nex[i] = 0;
}
}
}
int main(int argc, char *argv[]) {
string a;
int len;
int index = 1;
while (cin >> len && len != 0) {
cin.get(); // 丢弃换行符
getline(cin, a);
initNext(len, a);
cout << "Test case #" << index++ << endl;
for (int i = 1; i < len; i++) {
if ((i + 1) % (i + 1 - nex[i]) == 0 && nex[i] != 0) {
cout << i + 1 << " " << (i + 1) / (i + 1 - nex[i]) << endl;
}
}
cout << endl;
}
return 0;
} | [
"masterwangzx@gmail.com"
] | masterwangzx@gmail.com |
14e99939f55b2dc607bba0bd05ac189d863e93a2 | dd681dd7874c80c2804ca8d66cdbfdf2abec537e | /Python/venv/Lib/site-packages/tensorflow/include/Eigen/src/Core/arch/SSE/PacketMath.h | d7b8bc8ac161a0a58439d50e81f51b9b11817e8b | [] | no_license | khaled147/Koneked | cbbaec78cf3828575e835445f45b9dd72c39d808 | 98bdc701a3d126c742e076ee3ad34719a0ac5309 | refs/heads/main | 2023-04-03T11:37:07.941179 | 2021-04-14T02:09:35 | 2021-04-14T02:09:35 | 345,202,202 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 64,470 | h | // This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_PACKET_MATH_SSE_H
#define EIGEN_PACKET_MATH_SSE_H
namespace Eigen {
namespace internal {
#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
#endif
#if !defined(EIGEN_VECTORIZE_AVX) && !defined(EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS)
// 32 bits => 8 registers
// 64 bits => 16 registers
#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS (2*sizeof(void*))
#endif
#ifdef EIGEN_VECTORIZE_FMA
#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
#endif
#endif
#if ((defined EIGEN_VECTORIZE_AVX) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_MINGW) && (__GXX_ABI_VERSION < 1004)) || EIGEN_OS_QNX
// With GCC's default ABI version, a __m128 or __m256 are the same types and therefore we cannot
// have overloads for both types without linking error.
// One solution is to increase ABI version using -fabi-version=4 (or greater).
// Otherwise, we workaround this inconvenience by wrapping 128bit types into the following helper
// structure:
typedef eigen_packet_wrapper<__m128> Packet4f;
typedef eigen_packet_wrapper<__m128d> Packet2d;
#else
typedef __m128 Packet4f;
typedef __m128d Packet2d;
#endif
typedef eigen_packet_wrapper<__m128i, 0> Packet4i;
typedef eigen_packet_wrapper<__m128i, 1> Packet16b;
template<> struct is_arithmetic<__m128> { enum { value = true }; };
template<> struct is_arithmetic<__m128i> { enum { value = true }; };
template<> struct is_arithmetic<__m128d> { enum { value = true }; };
template<> struct is_arithmetic<Packet4i> { enum { value = true }; };
template<> struct is_arithmetic<Packet16b> { enum { value = true }; };
template<int p, int q, int r, int s>
struct shuffle_mask{
enum { mask = (s)<<6|(r)<<4|(q)<<2|(p) };
};
// TODO: change the implementation of all swizzle* ops from macro to template,
#define vec4f_swizzle1(v,p,q,r,s) \
Packet4f(_mm_castsi128_ps(_mm_shuffle_epi32( _mm_castps_si128(v), (shuffle_mask<p,q,r,s>::mask))))
#define vec4i_swizzle1(v,p,q,r,s) \
Packet4i(_mm_shuffle_epi32( v, (shuffle_mask<p,q,r,s>::mask)))
#define vec2d_swizzle1(v,p,q) \
Packet2d(_mm_castsi128_pd(_mm_shuffle_epi32( _mm_castpd_si128(v), (shuffle_mask<2*p,2*p+1,2*q,2*q+1>::mask))))
#define vec4f_swizzle2(a,b,p,q,r,s) \
Packet4f(_mm_shuffle_ps( (a), (b), (shuffle_mask<p,q,r,s>::mask)))
#define vec4i_swizzle2(a,b,p,q,r,s) \
Packet4i(_mm_castps_si128( (_mm_shuffle_ps( _mm_castsi128_ps(a), _mm_castsi128_ps(b), (shuffle_mask<p,q,r,s>::mask)))))
EIGEN_STRONG_INLINE Packet4f vec4f_movelh(const Packet4f& a, const Packet4f& b)
{
return Packet4f(_mm_movelh_ps(a,b));
}
EIGEN_STRONG_INLINE Packet4f vec4f_movehl(const Packet4f& a, const Packet4f& b)
{
return Packet4f(_mm_movehl_ps(a,b));
}
EIGEN_STRONG_INLINE Packet4f vec4f_unpacklo(const Packet4f& a, const Packet4f& b)
{
return Packet4f(_mm_unpacklo_ps(a,b));
}
EIGEN_STRONG_INLINE Packet4f vec4f_unpackhi(const Packet4f& a, const Packet4f& b)
{
return Packet4f(_mm_unpackhi_ps(a,b));
}
#define vec4f_duplane(a,p) \
vec4f_swizzle2(a,a,p,p,p,p)
#define vec2d_swizzle2(a,b,mask) \
Packet2d(_mm_shuffle_pd(a,b,mask))
EIGEN_STRONG_INLINE Packet2d vec2d_unpacklo(const Packet2d& a, const Packet2d& b)
{
return Packet2d(_mm_unpacklo_pd(a,b));
}
EIGEN_STRONG_INLINE Packet2d vec2d_unpackhi(const Packet2d& a, const Packet2d& b)
{
return Packet2d(_mm_unpackhi_pd(a,b));
}
#define vec2d_duplane(a,p) \
vec2d_swizzle2(a,a,(p<<1)|p)
#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
const Packet4f p4f_##NAME = pset1<Packet4f>(X)
#define _EIGEN_DECLARE_CONST_Packet2d(NAME,X) \
const Packet2d p2d_##NAME = pset1<Packet2d>(X)
#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
const Packet4f p4f_##NAME = pset1frombits<Packet4f>(X)
#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
const Packet4i p4i_##NAME = pset1<Packet4i>(X)
// Use the packet_traits defined in AVX/PacketMath.h instead if we're going
// to leverage AVX instructions.
#ifndef EIGEN_VECTORIZE_AVX
template <>
struct packet_traits<float> : default_packet_traits {
typedef Packet4f type;
typedef Packet4f half;
enum {
Vectorizable = 1,
AlignedOnScalar = 1,
size = 4,
HasHalfPacket = 0,
HasCmp = 1,
HasDiv = 1,
HasSin = EIGEN_FAST_MATH,
HasCos = EIGEN_FAST_MATH,
HasLog = 1,
HasLog1p = 1,
HasExpm1 = 1,
HasNdtri = 1,
HasExp = 1,
HasBessel = 1,
HasSqrt = 1,
HasRsqrt = 1,
HasTanh = EIGEN_FAST_MATH,
HasErf = EIGEN_FAST_MATH,
HasBlend = 1,
HasCeil = 1,
HasFloor = 1,
HasRint = 1,
#ifdef EIGEN_VECTORIZE_SSE4_1
HasRound = 1,
#endif
};
};
template <>
struct packet_traits<double> : default_packet_traits {
typedef Packet2d type;
typedef Packet2d half;
enum {
Vectorizable = 1,
AlignedOnScalar = 1,
size=2,
HasHalfPacket = 0,
HasCmp = 1,
HasDiv = 1,
HasLog = 1,
HasExp = 1,
HasSqrt = 1,
HasRsqrt = 1,
HasBlend = 1,
HasFloor = 1,
HasCeil = 1,
HasRint = 1,
#ifdef EIGEN_VECTORIZE_SSE4_1
HasRound = 1,
#endif
};
};
#endif
template<> struct packet_traits<int> : default_packet_traits
{
typedef Packet4i type;
typedef Packet4i half;
enum {
Vectorizable = 1,
AlignedOnScalar = 1,
size=4,
HasShift = 1,
HasBlend = 1
};
};
template<> struct packet_traits<bool> : default_packet_traits
{
typedef Packet16b type;
typedef Packet16b half;
enum {
Vectorizable = 1,
AlignedOnScalar = 1,
HasHalfPacket = 0,
size=16,
HasAdd = 1,
HasSub = 1,
HasShift = 0,
HasMul = 1,
HasNegate = 1,
HasAbs = 0,
HasAbs2 = 0,
HasMin = 0,
HasMax = 0,
HasConj = 0,
HasSqrt = 1
};
};
template<> struct unpacket_traits<Packet4f> {
typedef float type;
typedef Packet4f half;
typedef Packet4i integer_packet;
enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
};
template<> struct unpacket_traits<Packet2d> {
typedef double type;
typedef Packet2d half;
enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
};
template<> struct unpacket_traits<Packet4i> {
typedef int type;
typedef Packet4i half;
enum {size=4, alignment=Aligned16, vectorizable=false, masked_load_available=false, masked_store_available=false};
};
template<> struct unpacket_traits<Packet16b> {
typedef bool type;
typedef Packet16b half;
enum {size=16, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
};
#ifndef EIGEN_VECTORIZE_AVX
template<> struct scalar_div_cost<float,true> { enum { value = 7 }; };
template<> struct scalar_div_cost<double,true> { enum { value = 8 }; };
#endif
#if EIGEN_COMP_MSVC==1500
// Workaround MSVC 9 internal compiler error.
// TODO: It has been detected with win64 builds (amd64), so let's check whether it also happens in 32bits+SSE mode
// TODO: let's check whether there does not exist a better fix, like adding a pset0() function. (it crashed on pset1(0)).
template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) { return _mm_set_ps(from,from,from,from); }
template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set_pd(from,from); }
template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int& from) { return _mm_set_epi32(from,from,from,from); }
#else
template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) { return _mm_set_ps1(from); }
template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set1_pd(from); }
template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int& from) { return _mm_set1_epi32(from); }
#endif
template<> EIGEN_STRONG_INLINE Packet16b pset1<Packet16b>(const bool& from) { return _mm_set1_epi8(static_cast<char>(from)); }
template<> EIGEN_STRONG_INLINE Packet4f pset1frombits<Packet4f>(unsigned int from) { return _mm_castsi128_ps(pset1<Packet4i>(from)); }
template<> EIGEN_STRONG_INLINE Packet2d pset1frombits<Packet2d>(uint64_t from) { return _mm_castsi128_pd(_mm_set1_epi64x(from)); }
template<> EIGEN_STRONG_INLINE Packet4f peven_mask(const Packet4f& /*a*/) { return _mm_castsi128_ps(_mm_set_epi32(0, -1, 0, -1)); }
template<> EIGEN_STRONG_INLINE Packet4i peven_mask(const Packet4i& /*a*/) { return _mm_set_epi32(0, -1, 0, -1); }
template<> EIGEN_STRONG_INLINE Packet2d peven_mask(const Packet2d& /*a*/) { return _mm_castsi128_pd(_mm_set_epi32(0, 0, -1, -1)); }
template<> EIGEN_STRONG_INLINE Packet4f pzero(const Packet4f& /*a*/) { return _mm_setzero_ps(); }
template<> EIGEN_STRONG_INLINE Packet2d pzero(const Packet2d& /*a*/) { return _mm_setzero_pd(); }
template<> EIGEN_STRONG_INLINE Packet4i pzero(const Packet4i& /*a*/) { return _mm_setzero_si128(); }
// GCC generates a shufps instruction for _mm_set1_ps/_mm_load1_ps instead of the more efficient pshufd instruction.
// However, using inrinsics for pset1 makes gcc to generate crappy code in some cases (see bug 203)
// Using inline assembly is also not an option because then gcc fails to reorder properly the instructions.
// Therefore, we introduced the pload1 functions to be used in product kernels for which bug 203 does not apply.
// Also note that with AVX, we want it to generate a vbroadcastss.
#if EIGEN_COMP_GNUC_STRICT && (!defined __AVX__)
template<> EIGEN_STRONG_INLINE Packet4f pload1<Packet4f>(const float *from) {
return vec4f_swizzle1(_mm_load_ss(from),0,0,0,0);
}
#endif
template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a) { return _mm_add_ps(pset1<Packet4f>(a), _mm_set_ps(3,2,1,0)); }
template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) { return _mm_add_pd(pset1<Packet2d>(a),_mm_set_pd(1,0)); }
template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int& a) { return _mm_add_epi32(pset1<Packet4i>(a),_mm_set_epi32(3,2,1,0)); }
template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_add_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_add_pd(a,b); }
template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_add_epi32(a,b); }
template<> EIGEN_STRONG_INLINE Packet16b padd<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_or_si128(a,b); }
template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_sub_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_sub_pd(a,b); }
template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_sub_epi32(a,b); }
template<> EIGEN_STRONG_INLINE Packet16b psub<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_xor_si128(a,b); }
template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b);
template<> EIGEN_STRONG_INLINE Packet4f paddsub<Packet4f>(const Packet4f& a, const Packet4f& b)
{
#ifdef EIGEN_VECTORIZE_SSE3
return _mm_addsub_ps(a,b);
#else
const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x0,0x80000000,0x0));
return padd(a, pxor(mask, b));
#endif
}
template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& , const Packet2d& );
template<> EIGEN_STRONG_INLINE Packet2d paddsub<Packet2d>(const Packet2d& a, const Packet2d& b)
{
#ifdef EIGEN_VECTORIZE_SSE3
return _mm_addsub_pd(a,b);
#else
const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x80000000,0x0,0x0));
return padd(a, pxor(mask, b));
#endif
}
template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a)
{
const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000));
return _mm_xor_ps(a,mask);
}
template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a)
{
const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x80000000,0x0,0x80000000));
return _mm_xor_pd(a,mask);
}
template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a)
{
return psub(Packet4i(_mm_setr_epi32(0,0,0,0)), a);
}
template<> EIGEN_STRONG_INLINE Packet16b pnegate(const Packet16b& a)
{
return psub(pset1<Packet16b>(false), a);
}
template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_mul_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_mul_pd(a,b); }
template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b)
{
#ifdef EIGEN_VECTORIZE_SSE4_1
return _mm_mullo_epi32(a,b);
#else
// this version is slightly faster than 4 scalar products
return vec4i_swizzle1(
vec4i_swizzle2(
_mm_mul_epu32(a,b),
_mm_mul_epu32(vec4i_swizzle1(a,1,0,3,2),
vec4i_swizzle1(b,1,0,3,2)),
0,2,0,2),
0,2,1,3);
#endif
}
template<> EIGEN_STRONG_INLINE Packet16b pmul<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_and_si128(a,b); }
template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_div_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_div_pd(a,b); }
// for some weird raisons, it has to be overloaded for packet of integers
template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd(pmul(a,b), c); }
#ifdef EIGEN_VECTORIZE_FMA
template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) { return _mm_fmadd_ps(a,b,c); }
template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return _mm_fmadd_pd(a,b,c); }
#endif
#ifdef EIGEN_VECTORIZE_SSE4_1
template<> EIGEN_DEVICE_FUNC inline Packet4f pselect(const Packet4f& mask, const Packet4f& a, const Packet4f& b) {
return _mm_blendv_ps(b,a,mask);
}
template<> EIGEN_DEVICE_FUNC inline Packet4i pselect(const Packet4i& mask, const Packet4i& a, const Packet4i& b) {
return _mm_castps_si128(_mm_blendv_ps(_mm_castsi128_ps(b),_mm_castsi128_ps(a),_mm_castsi128_ps(mask)));
}
template<> EIGEN_DEVICE_FUNC inline Packet2d pselect(const Packet2d& mask, const Packet2d& a, const Packet2d& b) { return _mm_blendv_pd(b,a,mask); }
template<> EIGEN_DEVICE_FUNC inline Packet16b pselect(const Packet16b& mask, const Packet16b& a, const Packet16b& b) {
return _mm_blendv_epi8(b,a,mask);
}
#else
template<> EIGEN_DEVICE_FUNC inline Packet16b pselect(const Packet16b& mask, const Packet16b& a, const Packet16b& b) {
Packet16b a_part = _mm_and_si128(mask, a);
Packet16b b_part = _mm_andnot_si128(mask, b);
return _mm_or_si128(a_part, b_part);
}
#endif
template<> EIGEN_STRONG_INLINE Packet4i ptrue<Packet4i>(const Packet4i& a) { return _mm_cmpeq_epi32(a, a); }
template<> EIGEN_STRONG_INLINE Packet16b ptrue<Packet16b>(const Packet16b& a) { return _mm_cmpeq_epi8(a, a); }
template<> EIGEN_STRONG_INLINE Packet4f
ptrue<Packet4f>(const Packet4f& a) {
Packet4i b = _mm_castps_si128(a);
return _mm_castsi128_ps(_mm_cmpeq_epi32(b, b));
}
template<> EIGEN_STRONG_INLINE Packet2d
ptrue<Packet2d>(const Packet2d& a) {
Packet4i b = _mm_castpd_si128(a);
return _mm_castsi128_pd(_mm_cmpeq_epi32(b, b));
}
template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_and_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_and_pd(a,b); }
template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_and_si128(a,b); }
template<> EIGEN_STRONG_INLINE Packet16b pand<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_and_si128(a,b); }
template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_or_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_or_pd(a,b); }
template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_or_si128(a,b); }
template<> EIGEN_STRONG_INLINE Packet16b por<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_or_si128(a,b); }
template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_xor_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_xor_pd(a,b); }
template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_xor_si128(a,b); }
template<> EIGEN_STRONG_INLINE Packet16b pxor<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_xor_si128(a,b); }
template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_andnot_ps(b,a); }
template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_andnot_pd(b,a); }
template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_andnot_si128(b,a); }
template<> EIGEN_STRONG_INLINE Packet4f pcmp_le(const Packet4f& a, const Packet4f& b) { return _mm_cmple_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt(const Packet4f& a, const Packet4f& b) { return _mm_cmplt_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan(const Packet4f& a, const Packet4f& b) { return _mm_cmpnge_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet4f pcmp_eq(const Packet4f& a, const Packet4f& b) { return _mm_cmpeq_ps(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d pcmp_le(const Packet2d& a, const Packet2d& b) { return _mm_cmple_pd(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt(const Packet2d& a, const Packet2d& b) { return _mm_cmplt_pd(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan(const Packet2d& a, const Packet2d& b) { return _mm_cmpnge_pd(a,b); }
template<> EIGEN_STRONG_INLINE Packet2d pcmp_eq(const Packet2d& a, const Packet2d& b) { return _mm_cmpeq_pd(a,b); }
template<> EIGEN_STRONG_INLINE Packet4i pcmp_lt(const Packet4i& a, const Packet4i& b) { return _mm_cmplt_epi32(a,b); }
template<> EIGEN_STRONG_INLINE Packet4i pcmp_eq(const Packet4i& a, const Packet4i& b) { return _mm_cmpeq_epi32(a,b); }
template<> EIGEN_STRONG_INLINE Packet16b pcmp_eq(const Packet16b& a, const Packet16b& b) { return _mm_cmpeq_epi8(a,b); }
template<> EIGEN_STRONG_INLINE Packet4i pcmp_le(const Packet4i& a, const Packet4i& b) { return por(pcmp_lt(a,b), pcmp_eq(a,b)); }
template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) {
#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
// There appears to be a bug in GCC, by which the optimizer may
// flip the argument order in calls to _mm_min_ps, so we have to
// resort to inline ASM here. This is supposed to be fixed in gcc6.3,
// see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
#ifdef EIGEN_VECTORIZE_AVX
Packet4f res;
asm("vminps %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
#else
Packet4f res = b;
asm("minps %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
#endif
return res;
#else
// Arguments are reversed to match NaN propagation behavior of std::min.
return _mm_min_ps(b, a);
#endif
}
template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) {
#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
// There appears to be a bug in GCC, by which the optimizer may
// flip the argument order in calls to _mm_min_pd, so we have to
// resort to inline ASM here. This is supposed to be fixed in gcc6.3,
// see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
#ifdef EIGEN_VECTORIZE_AVX
Packet2d res;
asm("vminpd %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
#else
Packet2d res = b;
asm("minpd %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
#endif
return res;
#else
// Arguments are reversed to match NaN propagation behavior of std::min.
return _mm_min_pd(b, a);
#endif
}
template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b)
{
#ifdef EIGEN_VECTORIZE_SSE4_1
return _mm_min_epi32(a,b);
#else
// after some bench, this version *is* faster than a scalar implementation
Packet4i mask = _mm_cmplt_epi32(a,b);
return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b));
#endif
}
template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) {
#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
// There appears to be a bug in GCC, by which the optimizer may
// flip the argument order in calls to _mm_max_ps, so we have to
// resort to inline ASM here. This is supposed to be fixed in gcc6.3,
// see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
#ifdef EIGEN_VECTORIZE_AVX
Packet4f res;
asm("vmaxps %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
#else
Packet4f res = b;
asm("maxps %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
#endif
return res;
#else
// Arguments are reversed to match NaN propagation behavior of std::max.
return _mm_max_ps(b, a);
#endif
}
template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) {
#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
// There appears to be a bug in GCC, by which the optimizer may
// flip the argument order in calls to _mm_max_pd, so we have to
// resort to inline ASM here. This is supposed to be fixed in gcc6.3,
// see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
#ifdef EIGEN_VECTORIZE_AVX
Packet2d res;
asm("vmaxpd %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
#else
Packet2d res = b;
asm("maxpd %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
#endif
return res;
#else
// Arguments are reversed to match NaN propagation behavior of std::max.
return _mm_max_pd(b, a);
#endif
}
template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b)
{
#ifdef EIGEN_VECTORIZE_SSE4_1
return _mm_max_epi32(a,b);
#else
// after some bench, this version *is* faster than a scalar implementation
Packet4i mask = _mm_cmpgt_epi32(a,b);
return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b));
#endif
}
template <typename Packet, typename Op>
EIGEN_STRONG_INLINE Packet pminmax_propagate_numbers(const Packet& a, const Packet& b, Op op) {
// In this implementation, we take advantage of the fact that pmin/pmax for SSE
// always return a if either a or b is NaN.
Packet not_nan_mask_a = pcmp_eq(a, a);
Packet m = op(a, b);
return pselect<Packet>(not_nan_mask_a, m, b);
}
template <typename Packet, typename Op>
EIGEN_STRONG_INLINE Packet pminmax_propagate_nan(const Packet& a, const Packet& b, Op op) {
// In this implementation, we take advantage of the fact that pmin/pmax for SSE
// always return a if either a or b is NaN.
Packet not_nan_mask_a = pcmp_eq(a, a);
Packet m = op(b, a);
return pselect<Packet>(not_nan_mask_a, m, a);
}
// Add specializations for min/max with prescribed NaN progation.
template<>
EIGEN_STRONG_INLINE Packet4f pmin<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) {
return pminmax_propagate_numbers(a, b, pmin<Packet4f>);
}
template<>
EIGEN_STRONG_INLINE Packet2d pmin<PropagateNumbers, Packet2d>(const Packet2d& a, const Packet2d& b) {
return pminmax_propagate_numbers(a, b, pmin<Packet2d>);
}
template<>
EIGEN_STRONG_INLINE Packet4f pmax<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) {
return pminmax_propagate_numbers(a, b, pmax<Packet4f>);
}
template<>
EIGEN_STRONG_INLINE Packet2d pmax<PropagateNumbers, Packet2d>(const Packet2d& a, const Packet2d& b) {
return pminmax_propagate_numbers(a, b, pmax<Packet2d>);
}
template<>
EIGEN_STRONG_INLINE Packet4f pmin<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) {
return pminmax_propagate_nan(a, b, pmin<Packet4f>);
}
template<>
EIGEN_STRONG_INLINE Packet2d pmin<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) {
return pminmax_propagate_nan(a, b, pmin<Packet2d>);
}
template<>
EIGEN_STRONG_INLINE Packet4f pmax<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) {
return pminmax_propagate_nan(a, b, pmax<Packet4f>);
}
template<>
EIGEN_STRONG_INLINE Packet2d pmax<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) {
return pminmax_propagate_nan(a, b, pmax<Packet2d>);
}
template<int N> EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(const Packet4i& a) { return _mm_srai_epi32(a,N); }
template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_right (const Packet4i& a) { return _mm_srli_epi32(a,N); }
template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_left (const Packet4i& a) { return _mm_slli_epi32(a,N); }
template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a)
{
const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF));
return _mm_and_ps(a,mask);
}
template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a)
{
const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF));
return _mm_and_pd(a,mask);
}
template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a)
{
#ifdef EIGEN_VECTORIZE_SSSE3
return _mm_abs_epi32(a);
#else
Packet4i aux = _mm_srai_epi32(a,31);
return _mm_sub_epi32(_mm_xor_si128(a,aux),aux);
#endif
}
#ifdef EIGEN_VECTORIZE_SSE4_1
template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a)
{
// Unfortunatly _mm_round_ps doesn't have a rounding mode to implement numext::round.
const Packet4f mask = pset1frombits<Packet4f>(0x80000000u);
const Packet4f prev0dot5 = pset1frombits<Packet4f>(0x3EFFFFFFu);
return _mm_round_ps(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
}
template<> EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a)
{
const Packet2d mask = _mm_castsi128_pd(_mm_set_epi64x(0x8000000000000000ull, 0x8000000000000000ull));
const Packet2d prev0dot5 = _mm_castsi128_pd(_mm_set_epi64x(0x3FDFFFFFFFFFFFFFull, 0x3FDFFFFFFFFFFFFFull));
return _mm_round_pd(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
}
template<> EIGEN_STRONG_INLINE Packet4f print<Packet4f>(const Packet4f& a) { return _mm_round_ps(a, _MM_FROUND_CUR_DIRECTION); }
template<> EIGEN_STRONG_INLINE Packet2d print<Packet2d>(const Packet2d& a) { return _mm_round_pd(a, _MM_FROUND_CUR_DIRECTION); }
template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a) { return _mm_ceil_ps(a); }
template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a) { return _mm_ceil_pd(a); }
template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a) { return _mm_floor_ps(a); }
template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) { return _mm_floor_pd(a); }
#else
template<> EIGEN_STRONG_INLINE Packet4f print(const Packet4f& a) {
// Adds and subtracts signum(a) * 2^23 to force rounding.
const Packet4f limit = pset1<Packet4f>(static_cast<float>(1<<23));
const Packet4f abs_a = pabs(a);
Packet4f r = padd(abs_a, limit);
// Don't compile-away addition and subtraction.
EIGEN_OPTIMIZATION_BARRIER(r);
r = psub(r, limit);
// If greater than limit, simply return a. Otherwise, account for sign.
r = pselect(pcmp_lt(abs_a, limit),
pselect(pcmp_lt(a, pzero(a)), pnegate(r), r), a);
return r;
}
template<> EIGEN_STRONG_INLINE Packet2d print(const Packet2d& a) {
// Adds and subtracts signum(a) * 2^52 to force rounding.
const Packet2d limit = pset1<Packet2d>(static_cast<double>(1ull<<52));
const Packet2d abs_a = pabs(a);
Packet2d r = padd(abs_a, limit);
// Don't compile-away addition and subtraction.
EIGEN_OPTIMIZATION_BARRIER(r);
r = psub(r, limit);
// If greater than limit, simply return a. Otherwise, account for sign.
r = pselect(pcmp_lt(abs_a, limit),
pselect(pcmp_lt(a, pzero(a)), pnegate(r), r), a);
return r;
}
template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a)
{
const Packet4f cst_1 = pset1<Packet4f>(1.0f);
Packet4f tmp = print<Packet4f>(a);
// If greater, subtract one.
Packet4f mask = _mm_cmpgt_ps(tmp, a);
mask = pand(mask, cst_1);
return psub(tmp, mask);
}
template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a)
{
const Packet2d cst_1 = pset1<Packet2d>(1.0);
Packet2d tmp = print<Packet2d>(a);
// If greater, subtract one.
Packet2d mask = _mm_cmpgt_pd(tmp, a);
mask = pand(mask, cst_1);
return psub(tmp, mask);
}
template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a)
{
const Packet4f cst_1 = pset1<Packet4f>(1.0f);
Packet4f tmp = print<Packet4f>(a);
// If smaller, add one.
Packet4f mask = _mm_cmplt_ps(tmp, a);
mask = pand(mask, cst_1);
return padd(tmp, mask);
}
template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a)
{
const Packet2d cst_1 = pset1<Packet2d>(1.0);
Packet2d tmp = print<Packet2d>(a);
// If smaller, add one.
Packet2d mask = _mm_cmplt_pd(tmp, a);
mask = pand(mask, cst_1);
return padd(tmp, mask);
}
#endif
template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_ps(from); }
template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_pd(from); }
template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast<const __m128i*>(from)); }
template<> EIGEN_STRONG_INLINE Packet16b pload<Packet16b>(const bool* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast<const __m128i*>(from)); }
#if EIGEN_COMP_MSVC
template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from) {
EIGEN_DEBUG_UNALIGNED_LOAD
#if (EIGEN_COMP_MSVC==1600)
// NOTE Some version of MSVC10 generates bad code when using _mm_loadu_ps
// (i.e., it does not generate an unaligned load!!
__m128 res = _mm_loadl_pi(_mm_set1_ps(0.0f), (const __m64*)(from));
res = _mm_loadh_pi(res, (const __m64*)(from+2));
return res;
#else
return _mm_loadu_ps(from);
#endif
}
#else
// NOTE: with the code below, MSVC's compiler crashes!
template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from)
{
EIGEN_DEBUG_UNALIGNED_LOAD
return _mm_loadu_ps(from);
}
#endif
template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
{
EIGEN_DEBUG_UNALIGNED_LOAD
return _mm_loadu_pd(from);
}
template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from)
{
EIGEN_DEBUG_UNALIGNED_LOAD
return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
}
template<> EIGEN_STRONG_INLINE Packet16b ploadu<Packet16b>(const bool* from) {
EIGEN_DEBUG_UNALIGNED_LOAD
return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
}
template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float* from)
{
return vec4f_swizzle1(_mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(from))), 0, 0, 1, 1);
}
template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double* from)
{ return pset1<Packet2d>(from[0]); }
template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int* from)
{
Packet4i tmp;
tmp = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(from));
return vec4i_swizzle1(tmp, 0, 0, 1, 1);
}
// Loads 8 bools from memory and returns the packet
// {b0, b0, b1, b1, b2, b2, b3, b3, b4, b4, b5, b5, b6, b6, b7, b7}
template<> EIGEN_STRONG_INLINE Packet16b ploaddup<Packet16b>(const bool* from)
{
__m128i tmp = _mm_castpd_si128(pload1<Packet2d>(reinterpret_cast<const double*>(from)));
return _mm_unpacklo_epi8(tmp, tmp);
}
// Loads 4 bools from memory and returns the packet
// {b0, b0 b0, b0, b1, b1, b1, b1, b2, b2, b2, b2, b3, b3, b3, b3}
template<> EIGEN_STRONG_INLINE Packet16b
ploadquad<Packet16b>(const bool* from) {
__m128i tmp = _mm_castps_si128(pload1<Packet4f>(reinterpret_cast<const float*>(from)));
tmp = _mm_unpacklo_epi8(tmp, tmp);
return _mm_unpacklo_epi16(tmp, tmp);
}
template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_ps(to, from); }
template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet2d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd(to, from); }
template<> EIGEN_STRONG_INLINE void pstore<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast<__m128i*>(to), from); }
template<> EIGEN_STRONG_INLINE void pstore<bool>(bool* to, const Packet16b& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast<__m128i*>(to), from); }
template<> EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet2d& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_pd(to, from); }
template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_ps(to, from); }
template<> EIGEN_STRONG_INLINE void pstoreu<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from); }
template<> EIGEN_STRONG_INLINE void pstoreu<bool>(bool* to, const Packet16b& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from); }
template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
{
return _mm_set_ps(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
}
template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
{
return _mm_set_pd(from[1*stride], from[0*stride]);
}
template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int, Packet4i>(const int* from, Index stride)
{
return _mm_set_epi32(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
}
template<> EIGEN_DEVICE_FUNC inline Packet16b pgather<bool, Packet16b>(const bool* from, Index stride)
{
return _mm_set_epi8(from[15*stride], from[14*stride], from[13*stride], from[12*stride],
from[11*stride], from[10*stride], from[9*stride], from[8*stride],
from[7*stride], from[6*stride], from[5*stride], from[4*stride],
from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
}
template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
{
to[stride*0] = _mm_cvtss_f32(from);
to[stride*1] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 1));
to[stride*2] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 2));
to[stride*3] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 3));
}
template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
{
to[stride*0] = _mm_cvtsd_f64(from);
to[stride*1] = _mm_cvtsd_f64(_mm_shuffle_pd(from, from, 1));
}
template<> EIGEN_DEVICE_FUNC inline void pscatter<int, Packet4i>(int* to, const Packet4i& from, Index stride)
{
to[stride*0] = _mm_cvtsi128_si32(from);
to[stride*1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 1));
to[stride*2] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 2));
to[stride*3] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 3));
}
template<> EIGEN_DEVICE_FUNC inline void pscatter<bool, Packet16b>(bool* to, const Packet16b& from, Index stride)
{
to[4*stride*0] = _mm_cvtsi128_si32(from);
to[4*stride*1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 1));
to[4*stride*2] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 2));
to[4*stride*3] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 3));
}
// some compilers might be tempted to perform multiple moves instead of using a vector path.
template<> EIGEN_STRONG_INLINE void pstore1<Packet4f>(float* to, const float& a)
{
Packet4f pa = _mm_set_ss(a);
pstore(to, Packet4f(vec4f_swizzle1(pa,0,0,0,0)));
}
// some compilers might be tempted to perform multiple moves instead of using a vector path.
template<> EIGEN_STRONG_INLINE void pstore1<Packet2d>(double* to, const double& a)
{
Packet2d pa = _mm_set_sd(a);
pstore(to, Packet2d(vec2d_swizzle1(pa,0,0)));
}
#if EIGEN_COMP_PGI && EIGEN_COMP_PGI < 1900
typedef const void * SsePrefetchPtrType;
#else
typedef const char * SsePrefetchPtrType;
#endif
#ifndef EIGEN_VECTORIZE_AVX
template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
template<> EIGEN_STRONG_INLINE void prefetch<int>(const int* addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
#endif
#if EIGEN_COMP_MSVC_STRICT && EIGEN_OS_WIN64
// The temporary variable fixes an internal compilation error in vs <= 2008 and a wrong-result bug in vs 2010
// Direct of the struct members fixed bug #62.
template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { return a.m128_f32[0]; }
template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return a.m128d_f64[0]; }
template<> EIGEN_STRONG_INLINE int pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; }
#elif EIGEN_COMP_MSVC_STRICT
// The temporary variable fixes an internal compilation error in vs <= 2008 and a wrong-result bug in vs 2010
template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { float x = _mm_cvtss_f32(a); return x; }
template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { double x = _mm_cvtsd_f64(a); return x; }
template<> EIGEN_STRONG_INLINE int pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; }
#else
template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { return _mm_cvtss_f32(a); }
template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return _mm_cvtsd_f64(a); }
template<> EIGEN_STRONG_INLINE int pfirst<Packet4i>(const Packet4i& a) { return _mm_cvtsi128_si32(a); }
#endif
template<> EIGEN_STRONG_INLINE bool pfirst<Packet16b>(const Packet16b& a) { int x = _mm_cvtsi128_si32(a); return static_cast<bool>(x & 1); }
template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a) { return _mm_shuffle_ps(a,a,0x1B); }
template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a) { return _mm_shuffle_pd(a,a,0x1); }
template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a) { return _mm_shuffle_epi32(a,0x1B); }
template<> EIGEN_STRONG_INLINE Packet16b preverse(const Packet16b& a) {
#ifdef EIGEN_VECTORIZE_SSSE3
__m128i mask = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
return _mm_shuffle_epi8(a, mask);
#else
Packet16b tmp = _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3));
tmp = _mm_shufflehi_epi16(_mm_shufflelo_epi16(tmp, _MM_SHUFFLE(2, 3, 0, 1)), _MM_SHUFFLE(2, 3, 0, 1));
return _mm_or_si128(_mm_slli_epi16(tmp, 8), _mm_srli_epi16(tmp, 8));
#endif
}
template<> EIGEN_STRONG_INLINE Packet4f pfrexp<Packet4f>(const Packet4f& a, Packet4f& exponent) {
return pfrexp_generic(a,exponent);
}
// Extract exponent without existence of Packet2l.
template<>
EIGEN_STRONG_INLINE
Packet2d pfrexp_generic_get_biased_exponent(const Packet2d& a) {
const Packet2d cst_exp_mask = pset1frombits<Packet2d>(static_cast<uint64_t>(0x7ff0000000000000ull));
__m128i a_expo = _mm_srli_epi64(_mm_castpd_si128(pand(a, cst_exp_mask)), 52);
return _mm_cvtepi32_pd(vec4i_swizzle1(a_expo, 0, 2, 1, 3));
}
template<> EIGEN_STRONG_INLINE Packet2d pfrexp<Packet2d>(const Packet2d& a, Packet2d& exponent) {
return pfrexp_generic(a, exponent);
}
template<> EIGEN_STRONG_INLINE Packet4f pldexp<Packet4f>(const Packet4f& a, const Packet4f& exponent) {
return pldexp_generic(a,exponent);
}
// We specialize pldexp here, since the generic implementation uses Packet2l, which is not well
// supported by SSE, and has more range than is needed for exponents.
template<> EIGEN_STRONG_INLINE Packet2d pldexp<Packet2d>(const Packet2d& a, const Packet2d& exponent) {
// Clamp exponent to [-2099, 2099]
const Packet2d max_exponent = pset1<Packet2d>(2099.0);
const Packet2d e = pmin(pmax(exponent, pnegate(max_exponent)), max_exponent);
// Convert e to integer and swizzle to low-order bits.
const Packet4i ei = vec4i_swizzle1(_mm_cvtpd_epi32(e), 0, 3, 1, 3);
// Split 2^e into four factors and multiply:
const Packet4i bias = _mm_set_epi32(0, 1023, 0, 1023);
Packet4i b = parithmetic_shift_right<2>(ei); // floor(e/4)
Packet2d c = _mm_castsi128_pd(_mm_slli_epi64(padd(b, bias), 52)); // 2^b
Packet2d out = pmul(pmul(pmul(a, c), c), c); // a * 2^(3b)
b = psub(psub(psub(ei, b), b), b); // e - 3b
c = _mm_castsi128_pd(_mm_slli_epi64(padd(b, bias), 52)); // 2^(e - 3b)
out = pmul(out, c); // a * 2^e
return out;
}
// with AVX, the default implementations based on pload1 are faster
#ifndef __AVX__
template<> EIGEN_STRONG_INLINE void
pbroadcast4<Packet4f>(const float *a,
Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
{
a3 = pload<Packet4f>(a);
a0 = vec4f_swizzle1(a3, 0,0,0,0);
a1 = vec4f_swizzle1(a3, 1,1,1,1);
a2 = vec4f_swizzle1(a3, 2,2,2,2);
a3 = vec4f_swizzle1(a3, 3,3,3,3);
}
template<> EIGEN_STRONG_INLINE void
pbroadcast4<Packet2d>(const double *a,
Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
{
#ifdef EIGEN_VECTORIZE_SSE3
a0 = _mm_loaddup_pd(a+0);
a1 = _mm_loaddup_pd(a+1);
a2 = _mm_loaddup_pd(a+2);
a3 = _mm_loaddup_pd(a+3);
#else
a1 = pload<Packet2d>(a);
a0 = vec2d_swizzle1(a1, 0,0);
a1 = vec2d_swizzle1(a1, 1,1);
a3 = pload<Packet2d>(a+2);
a2 = vec2d_swizzle1(a3, 0,0);
a3 = vec2d_swizzle1(a3, 1,1);
#endif
}
#endif
EIGEN_STRONG_INLINE void punpackp(Packet4f* vecs)
{
vecs[1] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x55));
vecs[2] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xAA));
vecs[3] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xFF));
vecs[0] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x00));
}
template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
{
// Disable SSE3 _mm_hadd_pd that is extremely slow on all existing Intel's architectures
// (from Nehalem to Haswell)
// #ifdef EIGEN_VECTORIZE_SSE3
// Packet4f tmp = _mm_add_ps(a, vec4f_swizzle1(a,2,3,2,3));
// return pfirst<Packet4f>(_mm_hadd_ps(tmp, tmp));
// #else
Packet4f tmp = _mm_add_ps(a, _mm_movehl_ps(a,a));
return pfirst<Packet4f>(_mm_add_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
// #endif
}
template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
{
// Disable SSE3 _mm_hadd_pd that is extremely slow on all existing Intel's architectures
// (from Nehalem to Haswell)
// #ifdef EIGEN_VECTORIZE_SSE3
// return pfirst<Packet2d>(_mm_hadd_pd(a, a));
// #else
return pfirst<Packet2d>(_mm_add_sd(a, _mm_unpackhi_pd(a,a)));
// #endif
}
#ifdef EIGEN_VECTORIZE_SSSE3
template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
{
Packet4i tmp0 = _mm_hadd_epi32(a,a);
return pfirst<Packet4i>(_mm_hadd_epi32(tmp0,tmp0));
}
#else
template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
{
Packet4i tmp = _mm_add_epi32(a, _mm_unpackhi_epi64(a,a));
return pfirst(tmp) + pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1));
}
#endif
template<> EIGEN_STRONG_INLINE bool predux<Packet16b>(const Packet16b& a) {
Packet4i tmp = _mm_or_si128(a, _mm_unpackhi_epi64(a,a));
return (pfirst(tmp) != 0) || (pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1)) != 0);
}
// Other reduction functions:
// mul
template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
{
Packet4f tmp = _mm_mul_ps(a, _mm_movehl_ps(a,a));
return pfirst<Packet4f>(_mm_mul_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
}
template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
{
return pfirst<Packet2d>(_mm_mul_sd(a, _mm_unpackhi_pd(a,a)));
}
template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
{
// after some experiments, it is seems this is the fastest way to implement it
// for GCC (eg., reusing pmul is very slow !)
// TODO try to call _mm_mul_epu32 directly
EIGEN_ALIGN16 int aux[4];
pstore(aux, a);
return (aux[0] * aux[1]) * (aux[2] * aux[3]);
}
template<> EIGEN_STRONG_INLINE bool predux_mul<Packet16b>(const Packet16b& a) {
Packet4i tmp = _mm_and_si128(a, _mm_unpackhi_epi64(a,a));
return ((pfirst<Packet4i>(tmp) == 0x01010101) &&
(pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1)) == 0x01010101));
}
// min
template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
{
Packet4f tmp = _mm_min_ps(a, _mm_movehl_ps(a,a));
return pfirst<Packet4f>(_mm_min_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
}
template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
{
return pfirst<Packet2d>(_mm_min_sd(a, _mm_unpackhi_pd(a,a)));
}
template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
{
#ifdef EIGEN_VECTORIZE_SSE4_1
Packet4i tmp = _mm_min_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0,0,3,2)));
return pfirst<Packet4i>(_mm_min_epi32(tmp,_mm_shuffle_epi32(tmp, 1)));
#else
// after some experiments, it is seems this is the fastest way to implement it
// for GCC (eg., it does not like using std::min after the pstore !!)
EIGEN_ALIGN16 int aux[4];
pstore(aux, a);
int aux0 = aux[0]<aux[1] ? aux[0] : aux[1];
int aux2 = aux[2]<aux[3] ? aux[2] : aux[3];
return aux0<aux2 ? aux0 : aux2;
#endif // EIGEN_VECTORIZE_SSE4_1
}
// max
template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
{
Packet4f tmp = _mm_max_ps(a, _mm_movehl_ps(a,a));
return pfirst<Packet4f>(_mm_max_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
}
template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
{
return pfirst<Packet2d>(_mm_max_sd(a, _mm_unpackhi_pd(a,a)));
}
template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
{
#ifdef EIGEN_VECTORIZE_SSE4_1
Packet4i tmp = _mm_max_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0,0,3,2)));
return pfirst<Packet4i>(_mm_max_epi32(tmp,_mm_shuffle_epi32(tmp, 1)));
#else
// after some experiments, it is seems this is the fastest way to implement it
// for GCC (eg., it does not like using std::min after the pstore !!)
EIGEN_ALIGN16 int aux[4];
pstore(aux, a);
int aux0 = aux[0]>aux[1] ? aux[0] : aux[1];
int aux2 = aux[2]>aux[3] ? aux[2] : aux[3];
return aux0>aux2 ? aux0 : aux2;
#endif // EIGEN_VECTORIZE_SSE4_1
}
// not needed yet
// template<> EIGEN_STRONG_INLINE bool predux_all(const Packet4f& x)
// {
// return _mm_movemask_ps(x) == 0xF;
// }
template<> EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x)
{
return _mm_movemask_ps(x) != 0x0;
}
EIGEN_DEVICE_FUNC inline void
ptranspose(PacketBlock<Packet4f,4>& kernel) {
_MM_TRANSPOSE4_PS(kernel.packet[0], kernel.packet[1], kernel.packet[2], kernel.packet[3]);
}
EIGEN_DEVICE_FUNC inline void
ptranspose(PacketBlock<Packet2d,2>& kernel) {
__m128d tmp = _mm_unpackhi_pd(kernel.packet[0], kernel.packet[1]);
kernel.packet[0] = _mm_unpacklo_pd(kernel.packet[0], kernel.packet[1]);
kernel.packet[1] = tmp;
}
EIGEN_DEVICE_FUNC inline void
ptranspose(PacketBlock<Packet4i,4>& kernel) {
__m128i T0 = _mm_unpacklo_epi32(kernel.packet[0], kernel.packet[1]);
__m128i T1 = _mm_unpacklo_epi32(kernel.packet[2], kernel.packet[3]);
__m128i T2 = _mm_unpackhi_epi32(kernel.packet[0], kernel.packet[1]);
__m128i T3 = _mm_unpackhi_epi32(kernel.packet[2], kernel.packet[3]);
kernel.packet[0] = _mm_unpacklo_epi64(T0, T1);
kernel.packet[1] = _mm_unpackhi_epi64(T0, T1);
kernel.packet[2] = _mm_unpacklo_epi64(T2, T3);
kernel.packet[3] = _mm_unpackhi_epi64(T2, T3);
}
EIGEN_DEVICE_FUNC inline void
ptranspose(PacketBlock<Packet16b,4>& kernel) {
__m128i T0 = _mm_unpacklo_epi8(kernel.packet[0], kernel.packet[1]);
__m128i T1 = _mm_unpackhi_epi8(kernel.packet[0], kernel.packet[1]);
__m128i T2 = _mm_unpacklo_epi8(kernel.packet[2], kernel.packet[3]);
__m128i T3 = _mm_unpackhi_epi8(kernel.packet[2], kernel.packet[3]);
kernel.packet[0] = _mm_unpacklo_epi16(T0, T2);
kernel.packet[1] = _mm_unpackhi_epi16(T0, T2);
kernel.packet[2] = _mm_unpacklo_epi16(T1, T3);
kernel.packet[3] = _mm_unpackhi_epi16(T1, T3);
}
EIGEN_DEVICE_FUNC inline void
ptranspose(PacketBlock<Packet16b,16>& kernel) {
// If we number the elements in the input thus:
// kernel.packet[ 0] = {00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 0a, 0b, 0c, 0d, 0e, 0f}
// kernel.packet[ 1] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1a, 1b, 1c, 1d, 1e, 1f}
// ...
// kernel.packet[15] = {f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, fa, fb, fc, fd, fe, ff},
//
// the desired output is:
// kernel.packet[ 0] = {00, 10, 20, 30, 40, 50, 60, 70, 80, 90, a0, b0, c0, d0, e0, f0}
// kernel.packet[ 1] = {01, 11, 21, 31, 41, 51, 61, 71, 81, 91, a1, b1, c1, d1, e1, f1}
// ...
// kernel.packet[15] = {0f, 1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f, 9f, af, bf, cf, df, ef, ff},
__m128i t0 = _mm_unpacklo_epi8(kernel.packet[0], kernel.packet[1]); // 00 10 01 11 02 12 03 13 04 14 05 15 06 16 07 17
__m128i t1 = _mm_unpackhi_epi8(kernel.packet[0], kernel.packet[1]); // 08 18 09 19 0a 1a 0b 1b 0c 1c 0d 1d 0e 1e 0f 1f
__m128i t2 = _mm_unpacklo_epi8(kernel.packet[2], kernel.packet[3]); // 20 30 21 31 22 32 ... 27 37
__m128i t3 = _mm_unpackhi_epi8(kernel.packet[2], kernel.packet[3]); // 28 38 29 39 2a 3a ... 2f 3f
__m128i t4 = _mm_unpacklo_epi8(kernel.packet[4], kernel.packet[5]); // 40 50 41 51 42 52 47 57
__m128i t5 = _mm_unpackhi_epi8(kernel.packet[4], kernel.packet[5]); // 48 58 49 59 4a 5a
__m128i t6 = _mm_unpacklo_epi8(kernel.packet[6], kernel.packet[7]);
__m128i t7 = _mm_unpackhi_epi8(kernel.packet[6], kernel.packet[7]);
__m128i t8 = _mm_unpacklo_epi8(kernel.packet[8], kernel.packet[9]);
__m128i t9 = _mm_unpackhi_epi8(kernel.packet[8], kernel.packet[9]);
__m128i ta = _mm_unpacklo_epi8(kernel.packet[10], kernel.packet[11]);
__m128i tb = _mm_unpackhi_epi8(kernel.packet[10], kernel.packet[11]);
__m128i tc = _mm_unpacklo_epi8(kernel.packet[12], kernel.packet[13]);
__m128i td = _mm_unpackhi_epi8(kernel.packet[12], kernel.packet[13]);
__m128i te = _mm_unpacklo_epi8(kernel.packet[14], kernel.packet[15]);
__m128i tf = _mm_unpackhi_epi8(kernel.packet[14], kernel.packet[15]);
__m128i s0 = _mm_unpacklo_epi16(t0, t2); // 00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
__m128i s1 = _mm_unpackhi_epi16(t0, t2); // 04 14 24 34
__m128i s2 = _mm_unpacklo_epi16(t1, t3); // 08 18 28 38 ...
__m128i s3 = _mm_unpackhi_epi16(t1, t3); // 0c 1c 2c 3c ...
__m128i s4 = _mm_unpacklo_epi16(t4, t6); // 40 50 60 70 41 51 61 71 42 52 62 72 43 53 63 73
__m128i s5 = _mm_unpackhi_epi16(t4, t6); // 44 54 64 74 ...
__m128i s6 = _mm_unpacklo_epi16(t5, t7);
__m128i s7 = _mm_unpackhi_epi16(t5, t7);
__m128i s8 = _mm_unpacklo_epi16(t8, ta);
__m128i s9 = _mm_unpackhi_epi16(t8, ta);
__m128i sa = _mm_unpacklo_epi16(t9, tb);
__m128i sb = _mm_unpackhi_epi16(t9, tb);
__m128i sc = _mm_unpacklo_epi16(tc, te);
__m128i sd = _mm_unpackhi_epi16(tc, te);
__m128i se = _mm_unpacklo_epi16(td, tf);
__m128i sf = _mm_unpackhi_epi16(td, tf);
__m128i u0 = _mm_unpacklo_epi32(s0, s4); // 00 10 20 30 40 50 60 70 01 11 21 31 41 51 61 71
__m128i u1 = _mm_unpackhi_epi32(s0, s4); // 02 12 22 32 42 52 62 72 03 13 23 33 43 53 63 73
__m128i u2 = _mm_unpacklo_epi32(s1, s5);
__m128i u3 = _mm_unpackhi_epi32(s1, s5);
__m128i u4 = _mm_unpacklo_epi32(s2, s6);
__m128i u5 = _mm_unpackhi_epi32(s2, s6);
__m128i u6 = _mm_unpacklo_epi32(s3, s7);
__m128i u7 = _mm_unpackhi_epi32(s3, s7);
__m128i u8 = _mm_unpacklo_epi32(s8, sc);
__m128i u9 = _mm_unpackhi_epi32(s8, sc);
__m128i ua = _mm_unpacklo_epi32(s9, sd);
__m128i ub = _mm_unpackhi_epi32(s9, sd);
__m128i uc = _mm_unpacklo_epi32(sa, se);
__m128i ud = _mm_unpackhi_epi32(sa, se);
__m128i ue = _mm_unpacklo_epi32(sb, sf);
__m128i uf = _mm_unpackhi_epi32(sb, sf);
kernel.packet[0] = _mm_unpacklo_epi64(u0, u8);
kernel.packet[1] = _mm_unpackhi_epi64(u0, u8);
kernel.packet[2] = _mm_unpacklo_epi64(u1, u9);
kernel.packet[3] = _mm_unpackhi_epi64(u1, u9);
kernel.packet[4] = _mm_unpacklo_epi64(u2, ua);
kernel.packet[5] = _mm_unpackhi_epi64(u2, ua);
kernel.packet[6] = _mm_unpacklo_epi64(u3, ub);
kernel.packet[7] = _mm_unpackhi_epi64(u3, ub);
kernel.packet[8] = _mm_unpacklo_epi64(u4, uc);
kernel.packet[9] = _mm_unpackhi_epi64(u4, uc);
kernel.packet[10] = _mm_unpacklo_epi64(u5, ud);
kernel.packet[11] = _mm_unpackhi_epi64(u5, ud);
kernel.packet[12] = _mm_unpacklo_epi64(u6, ue);
kernel.packet[13] = _mm_unpackhi_epi64(u6, ue);
kernel.packet[14] = _mm_unpacklo_epi64(u7, uf);
kernel.packet[15] = _mm_unpackhi_epi64(u7, uf);
}
template<> EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket) {
const __m128i zero = _mm_setzero_si128();
const __m128i select = _mm_set_epi32(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
__m128i false_mask = _mm_cmpeq_epi32(select, zero);
#ifdef EIGEN_VECTORIZE_SSE4_1
return _mm_blendv_epi8(thenPacket, elsePacket, false_mask);
#else
return _mm_or_si128(_mm_andnot_si128(false_mask, thenPacket), _mm_and_si128(false_mask, elsePacket));
#endif
}
template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
const __m128 zero = _mm_setzero_ps();
const __m128 select = _mm_set_ps(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
__m128 false_mask = _mm_cmpeq_ps(select, zero);
#ifdef EIGEN_VECTORIZE_SSE4_1
return _mm_blendv_ps(thenPacket, elsePacket, false_mask);
#else
return _mm_or_ps(_mm_andnot_ps(false_mask, thenPacket), _mm_and_ps(false_mask, elsePacket));
#endif
}
template<> EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket) {
const __m128d zero = _mm_setzero_pd();
const __m128d select = _mm_set_pd(ifPacket.select[1], ifPacket.select[0]);
__m128d false_mask = _mm_cmpeq_pd(select, zero);
#ifdef EIGEN_VECTORIZE_SSE4_1
return _mm_blendv_pd(thenPacket, elsePacket, false_mask);
#else
return _mm_or_pd(_mm_andnot_pd(false_mask, thenPacket), _mm_and_pd(false_mask, elsePacket));
#endif
}
// Scalar path for pmadd with FMA to ensure consistency with vectorized path.
#ifdef EIGEN_VECTORIZE_FMA
template<> EIGEN_STRONG_INLINE float pmadd(const float& a, const float& b, const float& c) {
return ::fmaf(a,b,c);
}
template<> EIGEN_STRONG_INLINE double pmadd(const double& a, const double& b, const double& c) {
return ::fma(a,b,c);
}
#endif
// Packet math for Eigen::half
// Disable the following code since it's broken on too many platforms / compilers.
//#elif defined(EIGEN_VECTORIZE_SSE) && (!EIGEN_ARCH_x86_64) && (!EIGEN_COMP_MSVC)
#if 0
typedef struct {
__m64 x;
} Packet4h;
template<> struct is_arithmetic<Packet4h> { enum { value = true }; };
template <>
struct packet_traits<Eigen::half> : default_packet_traits {
typedef Packet4h type;
// There is no half-size packet for Packet4h.
typedef Packet4h half;
enum {
Vectorizable = 1,
AlignedOnScalar = 1,
size = 4,
HasHalfPacket = 0,
HasAdd = 1,
HasSub = 1,
HasMul = 1,
HasDiv = 1,
HasNegate = 0,
HasAbs = 0,
HasAbs2 = 0,
HasMin = 0,
HasMax = 0,
HasConj = 0,
HasSetLinear = 0,
HasSqrt = 0,
HasRsqrt = 0,
HasExp = 0,
HasLog = 0,
HasBlend = 0
};
};
template<> struct unpacket_traits<Packet4h> { typedef Eigen::half type; enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet4h half; };
template<> EIGEN_STRONG_INLINE Packet4h pset1<Packet4h>(const Eigen::half& from) {
Packet4h result;
result.x = _mm_set1_pi16(from.x);
return result;
}
template<> EIGEN_STRONG_INLINE Eigen::half pfirst<Packet4h>(const Packet4h& from) {
return half_impl::raw_uint16_to_half(static_cast<unsigned short>(_mm_cvtsi64_si32(from.x)));
}
template<> EIGEN_STRONG_INLINE Packet4h pconj(const Packet4h& a) { return a; }
template<> EIGEN_STRONG_INLINE Packet4h padd<Packet4h>(const Packet4h& a, const Packet4h& b) {
__int64_t a64 = _mm_cvtm64_si64(a.x);
__int64_t b64 = _mm_cvtm64_si64(b.x);
Eigen::half h[4];
Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
h[0] = ha + hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
h[1] = ha + hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
h[2] = ha + hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
h[3] = ha + hb;
Packet4h result;
result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
return result;
}
template<> EIGEN_STRONG_INLINE Packet4h psub<Packet4h>(const Packet4h& a, const Packet4h& b) {
__int64_t a64 = _mm_cvtm64_si64(a.x);
__int64_t b64 = _mm_cvtm64_si64(b.x);
Eigen::half h[4];
Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
h[0] = ha - hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
h[1] = ha - hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
h[2] = ha - hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
h[3] = ha - hb;
Packet4h result;
result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
return result;
}
template<> EIGEN_STRONG_INLINE Packet4h pmul<Packet4h>(const Packet4h& a, const Packet4h& b) {
__int64_t a64 = _mm_cvtm64_si64(a.x);
__int64_t b64 = _mm_cvtm64_si64(b.x);
Eigen::half h[4];
Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
h[0] = ha * hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
h[1] = ha * hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
h[2] = ha * hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
h[3] = ha * hb;
Packet4h result;
result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
return result;
}
template<> EIGEN_STRONG_INLINE Packet4h pdiv<Packet4h>(const Packet4h& a, const Packet4h& b) {
__int64_t a64 = _mm_cvtm64_si64(a.x);
__int64_t b64 = _mm_cvtm64_si64(b.x);
Eigen::half h[4];
Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
h[0] = ha / hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
h[1] = ha / hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
h[2] = ha / hb;
ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
h[3] = ha / hb;
Packet4h result;
result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
return result;
}
template<> EIGEN_STRONG_INLINE Packet4h pload<Packet4h>(const Eigen::half* from) {
Packet4h result;
result.x = _mm_cvtsi64_m64(*reinterpret_cast<const __int64_t*>(from));
return result;
}
template<> EIGEN_STRONG_INLINE Packet4h ploadu<Packet4h>(const Eigen::half* from) {
Packet4h result;
result.x = _mm_cvtsi64_m64(*reinterpret_cast<const __int64_t*>(from));
return result;
}
template<> EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet4h& from) {
__int64_t r = _mm_cvtm64_si64(from.x);
*(reinterpret_cast<__int64_t*>(to)) = r;
}
template<> EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet4h& from) {
__int64_t r = _mm_cvtm64_si64(from.x);
*(reinterpret_cast<__int64_t*>(to)) = r;
}
template<> EIGEN_STRONG_INLINE Packet4h
ploadquad<Packet4h>(const Eigen::half* from) {
return pset1<Packet4h>(*from);
}
template<> EIGEN_STRONG_INLINE Packet4h pgather<Eigen::half, Packet4h>(const Eigen::half* from, Index stride)
{
Packet4h result;
result.x = _mm_set_pi16(from[3*stride].x, from[2*stride].x, from[1*stride].x, from[0*stride].x);
return result;
}
template<> EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet4h>(Eigen::half* to, const Packet4h& from, Index stride)
{
__int64_t a = _mm_cvtm64_si64(from.x);
to[stride*0].x = static_cast<unsigned short>(a);
to[stride*1].x = static_cast<unsigned short>(a >> 16);
to[stride*2].x = static_cast<unsigned short>(a >> 32);
to[stride*3].x = static_cast<unsigned short>(a >> 48);
}
EIGEN_STRONG_INLINE void
ptranspose(PacketBlock<Packet4h,4>& kernel) {
__m64 T0 = _mm_unpacklo_pi16(kernel.packet[0].x, kernel.packet[1].x);
__m64 T1 = _mm_unpacklo_pi16(kernel.packet[2].x, kernel.packet[3].x);
__m64 T2 = _mm_unpackhi_pi16(kernel.packet[0].x, kernel.packet[1].x);
__m64 T3 = _mm_unpackhi_pi16(kernel.packet[2].x, kernel.packet[3].x);
kernel.packet[0].x = _mm_unpacklo_pi32(T0, T1);
kernel.packet[1].x = _mm_unpackhi_pi32(T0, T1);
kernel.packet[2].x = _mm_unpacklo_pi32(T2, T3);
kernel.packet[3].x = _mm_unpackhi_pi32(T2, T3);
}
#endif
} // end namespace internal
} // end namespace Eigen
#if EIGEN_COMP_PGI && EIGEN_COMP_PGI < 1900
// PGI++ does not define the following intrinsics in C++ mode.
static inline __m128 _mm_castpd_ps (__m128d x) { return reinterpret_cast<__m128&>(x); }
static inline __m128i _mm_castpd_si128(__m128d x) { return reinterpret_cast<__m128i&>(x); }
static inline __m128d _mm_castps_pd (__m128 x) { return reinterpret_cast<__m128d&>(x); }
static inline __m128i _mm_castps_si128(__m128 x) { return reinterpret_cast<__m128i&>(x); }
static inline __m128 _mm_castsi128_ps(__m128i x) { return reinterpret_cast<__m128&>(x); }
static inline __m128d _mm_castsi128_pd(__m128i x) { return reinterpret_cast<__m128d&>(x); }
#endif
#endif // EIGEN_PACKET_MATH_SSE_H
| [
"elmalawanykhaled@gmail.com"
] | elmalawanykhaled@gmail.com |
dd4ec2239d701d253748bd98b6df397b3f684617 | ee19e56bb8806906917ddfef150b752b971b310b | /sources/utils/http.cpp | 49404d56e976647cde62affe26dd76346292f6cd | [
"BSD-2-Clause"
] | permissive | RustyShackleforth/dhyara | 19ec93a3279b88d2292b5032866f960491eaeaa2 | 9f7dc956011f5aca542eca46cee4a27c463835a1 | refs/heads/main | 2023-04-12T16:50:56.522005 | 2021-05-11T21:25:00 | 2021-05-11T21:25:00 | 382,931,781 | 1 | 0 | BSD-2-Clause | 2021-07-04T19:21:44 | 2021-07-04T19:21:44 | null | UTF-8 | C++ | false | false | 25,078 | cpp | /*
* Copyright (c) 2020, Sunanda Bose (a.k.a. Neel Basu)
* 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.
*/
#include "dhyara/utils/http.h"
#include <sstream>
#include "dhyara/assets.h"
#include <cstring>
#include "esp_wifi.h"
#include <dhyara/dhyara.h>
#include <iterator>
namespace fragments{
static const char sidebar[] =
"<div class='sidebar'>"
"<div class='logo'>Dhyara</div>"
"<ul id='menu' class='contents'>"
"<li data-label='Home' class='home' data-href='/' />"
"<li data-label='Routing' class='routing' data-href='/routing' />"
"<li data-label='Peers' class='neighbourhood' data-href='/peers' />"
"</ul>"
"</div>";
static const char banner[] =
"<div class='full-w'>"
"<div class='board banner'>"
"<div id='info-iface' class='groups'>"
"<div class='group'>"
"<div class='cell' data-key='ssid'></div>"
"<div class='cell' data-key='mac'></div>"
"</div>"
"<div class='group'>"
"<div class='cell' data-key='channel'></div>"
"<div class='cell' data-key='frequency'></div>"
"</div>"
"<div class='group'>"
"<div class='cell' data-key='power saving'></div>"
"<div class='cell' data-key='max power'></div>"
"</div>"
"<div class='group'>"
"<div class='cell' data-key='authentication'></div>"
"<div class='cell' data-key='max clients'></div>"
"</div>"
"</div>"
"</div>"
"</div>";
static const char home[] =
"<div class='full-flex-hz'>"
"<div class='board cluster'>"
"<div class='heading'>Dhyara Configuration</div>"
"<div class='groups' id='info-dhyara'>"
"<div class='group'>"
"<div class='cell' data-key='send queueing'></div>"
"<div class='cell' data-key='queue size'></div>"
"<div class='cell' data-key='sync queue size'></div>"
"<div class='cell' data-key='broadcast channel'></div>"
"<div class='cell' data-key='peer channel'></div>"
"</div>"
"<div class='group'>"
"<div class='cell' data-key='beacon interval'></div>"
"<div class='cell' data-key='delay tolerance'></div>"
"<div class='cell' data-key='depreciation coefficient'></div>"
"<div class='cell' data-key='advertisement expiry'></div>"
"<div class='cell' data-key='route expiry'></div>"
"</div>"
"</div>"
"</div>"
"<div class='board cluster'>"
"<div class='heading'>Counters</div>"
"<div class='groups' id='counter'>"
"<div class='group'>"
"<div class='cell' data-key='beacon'><span class='value' /></div>"
"<div class='cell' data-key='acknowledgement'><span class='value' /></div>"
"<div class='cell' data-key='advertisement'><span class='value' /></div>"
"<div class='cell' data-key='chunk'><span class='value' /></div>"
"<div class='cell' data-key='delivered'><span class='value' /></div>"
"</div>"
"<div class='group'>"
"<div class='cell' data-key='echo request'><span class='value' /></div>"
"<div class='cell' data-key='echo reply'><span class='value' /></div>"
"<div class='cell' data-key='echo lost'><span class='value' /></div>"
"</div>"
"</div>"
"</div>"
"</div>";
static const char routing[] =
"<div class='full-flex-hz'>"
"<div class='board cluster-full'>"
"<div class='heading'>Routing Table</div>"
"<table>"
"<thead>"
"<tr>"
"<th>Destination</th>"
"<th>Intermediate</th>"
"<th>Delay</th>"
"<th>Updated</th>"
"</tr>"
"</thead>"
"<tbody id='routes-body'></tbody>"
"</table>"
"</div>"
"</div>"
"<div class='full-flex-hz'>"
"<div class='board cluster-full'>"
"<div class='heading'>Best Route</div>"
"<table>"
"<thead>"
"<tr>"
"<th>Destination</th>"
"<th>Intermediate</th>"
"<th>Delay</th>"
"</tr>"
"</thead>"
"<tbody id='next-body'></tbody>"
"</table>"
"</div>"
"</div>";
static const char peers[] =
"<div class='full-flex-hz'>"
"<div class='board cluster-full'>"
"<div class='heading'>Neighbours</div>"
"<table>"
"<thead>"
"<tr>"
"<th>Address</th>"
"<th>Name</th>"
"<th>Channel</th>"
"<th>RSSI</th>"
"</tr>"
"</thead>"
"<tbody id='neighbours-body'></tbody>"
"</table>"
"</div>"
"</div>"
"<div class='full-flex-hz'>"
"<div class='board cluster-full'>"
"<div class='heading'>Universe</div>"
"<table>"
"<thead>"
"<tr>"
"<th>Address</th>"
"<th>Name</th>"
"</tr>"
"</thead>"
"<tbody id='universe-body'></tbody>"
"</table>"
"</div>"
"</div>";
}
static const char* html_open =
"<!DOCTYPE html>"
"<html>";
static const char* wrapper_open =
"<body>"
"<div class='wrapper'>";
static const char* central_open =
"<div class='main'>"
"<div class='central'>";
static const char* central_close =
"</div>"
"</div>";
// wrapper close will be different for each html pages, so defined inside respective functions
static const char* html_close =
"</html>";
dhyara::utils::http::http(dhyara::link& link): _link(link), _config(HTTPD_DEFAULT_CONFIG()), _server(0x0),
_index_html (httpd_uri_t{"/", HTTP_GET, dhyara::utils::http::index_html_handler, this}),
_routes_html (httpd_uri_t{"/routing", HTTP_GET, dhyara::utils::http::routes_html_handler, this}),
_peers_html (httpd_uri_t{"/peers", HTTP_GET, dhyara::utils::http::peers_html_handler, this}),
_style (httpd_uri_t{"/dhyara.css", HTTP_GET, dhyara::utils::http::style_handler, this}),
_icons (httpd_uri_t{"/icons", HTTP_GET, dhyara::utils::http::icons_handler, this}),
_info (httpd_uri_t{"/info.json", HTTP_GET, dhyara::utils::http::info_handler, this}),
_counter (httpd_uri_t{"/counter.json", HTTP_GET, dhyara::utils::http::counter_handler, this}),
_routes (httpd_uri_t{"/routes.json", HTTP_GET, dhyara::utils::http::routes_handler, this}),
_peers (httpd_uri_t{"/peers.json", HTTP_GET, dhyara::utils::http::peers_handler, this})
{
_config.max_uri_handlers = 10;
}
esp_err_t dhyara::utils::http::start(){
esp_err_t res = httpd_start(&_server, &_config);
if (res != ESP_OK) return res; else res = httpd_register_uri_handler(_server, &_index_html);
if (res != ESP_OK) return res; else res = httpd_register_uri_handler(_server, &_routes_html);
if (res != ESP_OK) return res; else res = httpd_register_uri_handler(_server, &_peers_html);
if (res != ESP_OK) return res; else res = httpd_register_uri_handler(_server, &_style);
if (res != ESP_OK) return res; else res = httpd_register_uri_handler(_server, &_icons);
if (res != ESP_OK) return res; else res = httpd_register_uri_handler(_server, &_info);
if (res != ESP_OK) return res; else res = httpd_register_uri_handler(_server, &_counter);
if (res != ESP_OK) return res; else res = httpd_register_uri_handler(_server, &_routes);
if (res != ESP_OK) return res; else res = httpd_register_uri_handler(_server, &_peers);
return res;
}
esp_err_t dhyara::utils::http::index_html_handler(httpd_req_t* req){
dhyara::utils::http* self = static_cast<dhyara::utils::http*>(req->user_ctx);
return self->index_html(req);
}
esp_err_t dhyara::utils::http::style_handler(httpd_req_t* req){
dhyara::utils::http* self = static_cast<dhyara::utils::http*>(req->user_ctx);
return self->style(req);
}
esp_err_t dhyara::utils::http::peers_html_handler(httpd_req_t* req){
dhyara::utils::http* self = static_cast<dhyara::utils::http*>(req->user_ctx);
return self->peers_html(req);
}
esp_err_t dhyara::utils::http::icons_handler(httpd_req_t* req){
dhyara::utils::http* self = static_cast<dhyara::utils::http*>(req->user_ctx);
return self->icons(req);
}
esp_err_t dhyara::utils::http::info_handler(httpd_req_t* req){
dhyara::utils::http* self = static_cast<dhyara::utils::http*>(req->user_ctx);
return self->info(req);
}
esp_err_t dhyara::utils::http::counter_handler(httpd_req_t* req){
dhyara::utils::http* self = static_cast<dhyara::utils::http*>(req->user_ctx);
return self->counter(req);
}
esp_err_t dhyara::utils::http::routes_html_handler(httpd_req_t* req){
dhyara::utils::http* self = static_cast<dhyara::utils::http*>(req->user_ctx);
return self->routes_html(req);
}
esp_err_t dhyara::utils::http::routes_handler(httpd_req_t* req){
dhyara::utils::http* self = static_cast<dhyara::utils::http*>(req->user_ctx);
return self->routes(req);
}
esp_err_t dhyara::utils::http::peers_handler(httpd_req_t* req){
dhyara::utils::http* self = static_cast<dhyara::utils::http*>(req->user_ctx);
return self->peers(req);
}
esp_err_t dhyara::utils::http::index_html(httpd_req_t* req){
static const char* wrapper_close =
"</div>"
"<script>"
"setTimeout(() => {"
"fetch_banner();"
"fetch_dhyara();"
"poll_counters();"
"}, 500);"
"</script>"
"</body>";
httpd_resp_set_type(req, "text/html");
httpd_resp_sendstr_chunk(req, html_open);
httpd_resp_sendstr_chunk(req, (const char*)dhyara::assets::head_html_start);
httpd_resp_sendstr_chunk(req, wrapper_open);
httpd_resp_sendstr_chunk(req, fragments::sidebar);
httpd_resp_sendstr_chunk(req, central_open);
httpd_resp_sendstr_chunk(req, fragments::banner);
httpd_resp_sendstr_chunk(req, fragments::home);
httpd_resp_sendstr_chunk(req, central_close);
httpd_resp_sendstr_chunk(req, wrapper_close);
httpd_resp_sendstr_chunk(req, html_close);
httpd_resp_sendstr_chunk(req, 0x0);
return ESP_OK;
}
esp_err_t dhyara::utils::http::icons(httpd_req_t* req){
const auto length = std::distance(dhyara::assets::icons_gif_start, dhyara::assets::icons_gif_end);
httpd_resp_set_type(req, "image/gif");
httpd_resp_send(req, (const char*)dhyara::assets::icons_gif_start, length);
return ESP_OK;
}
esp_err_t dhyara::utils::http::style(httpd_req_t* req){
const auto length = std::distance(dhyara::assets::dhyara_css_start, dhyara::assets::dhyara_css_end);
httpd_resp_set_type(req, "text/css");
httpd_resp_send(req, (const char*)dhyara::assets::dhyara_css_start, length);
return ESP_OK;
}
esp_err_t dhyara::utils::http::info(httpd_req_t* req){
std::stringstream response_json;
response_json << "{";
wifi_config_t config;
std::memset(&config, 0, sizeof(wifi_config_t));
esp_err_t err = esp_wifi_get_config(WIFI_IF_AP, &config);
if(err == ESP_OK){
std::string ssid((const char*)config.ap.ssid, config.ap.ssid_len);
std::uint8_t protocol;
esp_wifi_get_protocol(WIFI_IF_AP, &protocol);
wifi_bandwidth_t bandwidth;
esp_wifi_get_bandwidth(WIFI_IF_AP, &bandwidth);
std::string protocol_str;
if(protocol & WIFI_PROTOCOL_11B) protocol_str += "b";
if(protocol & WIFI_PROTOCOL_11G) protocol_str += "g";
if(protocol & WIFI_PROTOCOL_11N) protocol_str += "n";
if(protocol & WIFI_PROTOCOL_LR) protocol_str += "lr";
std::uint32_t channel_freq_begin = 2401 + 5*(config.ap.channel -1),
channel_freq_end = channel_freq_begin + ((bandwidth == WIFI_BW_HT20) ? 20 : 40),
channel_freq_mean = (channel_freq_begin + channel_freq_end) / 2;
std::string auth_str;
switch(config.ap.authmode){
case WIFI_AUTH_OPEN:
auth_str = "WIFI_AUTH_OPEN";
break;
case WIFI_AUTH_WEP:
auth_str = "WIFI_AUTH_WEP";
break;
case WIFI_AUTH_WPA_PSK:
auth_str = "WIFI_AUTH_WPA_PSK";
break;
case WIFI_AUTH_WPA2_PSK:
auth_str = "WIFI_AUTH_WPA2_PSK";
break;
case WIFI_AUTH_WPA_WPA2_PSK:
auth_str = "WIFI_AUTH_WPA_WPA2_PSK";
break;
case WIFI_AUTH_WPA2_ENTERPRISE:
auth_str = "WIFI_AUTH_WPA2_ENTERPRISE";
break;
case WIFI_AUTH_WPA3_PSK:
auth_str = "WIFI_AUTH_WPA3_PSK";
break;
case WIFI_AUTH_WPA2_WPA3_PSK:
auth_str = "WIFI_AUTH_WPA2_WPA3_PSK";
break;
case WIFI_AUTH_WAPI_PSK:
auth_str = "WIFI_AUTH_WAPI_PSK";
break;
case WIFI_AUTH_MAX:
auth_str = "WIFI_AUTH_MAX";
break;
default:
auth_str = "Unknown";
}
std::stringstream ap_json;
ap_json << "{";
ap_json << "\"ssid\":" << '"' << ssid << '"' << ",";
ap_json << "\"address\":" << '"' << dhyara_local().to_string() << '"' << ",";
ap_json << "\"hidden\":" << std::boolalpha << (bool) config.ap.ssid_hidden << ",";
ap_json << "\"channel\":" << (int)config.ap.channel << ",";
ap_json << "\"frequency\":" << "{";
ap_json << "\"begin\":" << channel_freq_begin << ",";
ap_json << "\"end\":" << channel_freq_end << ",";
ap_json << "\"mean\":" << channel_freq_mean;
ap_json << "},";
ap_json << "\"protocol\":" << '"' << "802.11" << protocol_str << '"' << ",";
ap_json << "\"bandwidth\":" << ((bandwidth == WIFI_BW_HT20) ? 20 : 40) << ",";
ap_json << "\"authentication\":" << '"' << auth_str << '"' << ",";
ap_json << "\"max_connections\":" << (int)config.ap.max_connection;
ap_json << "}";
response_json << "\"ap\":" << ap_json.str();
}
response_json << ",";
{
wifi_ps_type_t type;
err = esp_wifi_get_ps(&type);
std::string ps_str;
switch(type){
case WIFI_PS_NONE:
ps_str = "None";
break;
case WIFI_PS_MIN_MODEM:
ps_str = "Min";
break;
case WIFI_PS_MAX_MODEM:
ps_str = "Max";
break;
default:
ps_str = "Unknown";
}
std::int8_t max_power;
err = esp_wifi_get_max_tx_power(&max_power);
std::stringstream power_json;
power_json << "{";
power_json << "\"saving\":" << '"' << ps_str << '"' << ",";
power_json << "\"max\":" << (int) max_power;
power_json << "}";
response_json << "\"power\":" << power_json.str();
}
response_json << ",";
{
std::stringstream dhyara_json;
dhyara_json << "{";
dhyara_json << "\"send_queueing\":" << std::boolalpha << (bool)DHYARA_ENABLED_SEND_QUEUEING << ",";
dhyara_json << "\"queue_size\":" << dhyara::queue_size << ",";
dhyara_json << "\"sync_queue_size\":" << dhyara::sync_queue_size << ",";
dhyara_json << "\"espnow_broadcast_channel\":" << (int) dhyara::espnow_broadcast_channel << ",";
dhyara_json << "\"espnow_peer_channel\":" << (int) dhyara::espnow_peer_channel << ",";
dhyara_json << "\"beacon_interval\":" << dhyara::beacon_interval << ",";
dhyara_json << "\"delay_tolerance\":" << dhyara::delay_tolerance << ",";
dhyara_json << "\"depreciation_coefficient\":" << (int) dhyara::depreciation_coefficient << ",";
dhyara_json << "\"advertisement_expiry\":" << (dhyara::advertisement_expiry / 1000) << ",";
dhyara_json << "\"route_expiry\":" << (dhyara::route_expiry / 1000);
dhyara_json << "}";
response_json << "\"dhyara\":" << dhyara_json.str();
}
response_json << "}";
std::string response = response_json.str();
httpd_resp_set_type(req, "application/json");
httpd_resp_send(req, response.c_str(), response.length());
return ESP_OK;
}
esp_err_t dhyara::utils::http::counter(httpd_req_t* req){
std::stringstream response_json;
response_json << "{";
response_json << "\"beacon\":" << "{" "\"tx\":" << _link.tx(dhyara::packets::type::beacon) << "," "\"rx\":" << _link.rx(dhyara::packets::type::beacon) << "}" ",";
response_json << "\"acknowledgement\":" << "{" "\"tx\":" << _link.tx(dhyara::packets::type::acknowledgement) << "," "\"rx\":" << _link.rx(dhyara::packets::type::acknowledgement) << "}" ",";
response_json << "\"advertisement\":" << "{" "\"tx\":" << _link.tx(dhyara::packets::type::advertisement) << "," "\"rx\":" << _link.rx(dhyara::packets::type::advertisement) << "}" ",";
response_json << "\"chunk\":" << "{" "\"tx\":" << _link.tx(dhyara::packets::type::chunk) << "," "\"rx\":" << _link.rx(dhyara::packets::type::chunk) << "}" ",";
response_json << "\"delivered\":" << "{" "\"tx\":" << _link.tx(dhyara::packets::type::delivered) << "," "\"rx\":" << _link.rx(dhyara::packets::type::delivered) << "}" ",";
response_json << "\"echo_request\":" << "{" "\"tx\":" << _link.tx(dhyara::packets::type::echo_request) << "," "\"rx\":" << _link.rx(dhyara::packets::type::echo_request) << "}" ",";
response_json << "\"echo_reply\":" << "{" "\"tx\":" << _link.tx(dhyara::packets::type::echo_reply) << "," "\"rx\":" << _link.rx(dhyara::packets::type::echo_reply) << "}" ",";
response_json << "\"echo_lost\":" << "{" "\"tx\":" << _link.tx(dhyara::packets::type::echo_lost) << "," "\"rx\":" << _link.rx(dhyara::packets::type::echo_lost) << "}";
response_json << "}";
std::string response = response_json.str();
httpd_resp_set_type(req, "application/json");
httpd_resp_send(req, response.c_str(), response.length());
return ESP_OK;
}
esp_err_t dhyara::utils::http::routes_html(httpd_req_t* req){
static const char* wrapper_close =
"</div>"
"<script>"
"setTimeout(() => {"
"fetch_banner();"
"poll_routing();"
"}, 500);"
"</script>"
"</body>";
httpd_resp_set_type(req, "text/html");
httpd_resp_sendstr_chunk(req, html_open);
httpd_resp_sendstr_chunk(req, (const char*)dhyara::assets::head_html_start);
httpd_resp_sendstr_chunk(req, wrapper_open);
httpd_resp_sendstr_chunk(req, fragments::sidebar);
httpd_resp_sendstr_chunk(req, central_open);
httpd_resp_sendstr_chunk(req, fragments::banner);
httpd_resp_sendstr_chunk(req, fragments::routing);
httpd_resp_sendstr_chunk(req, central_close);
httpd_resp_sendstr_chunk(req, wrapper_close);
httpd_resp_sendstr_chunk(req, html_close);
httpd_resp_sendstr_chunk(req, 0x0);
return ESP_OK;
}
esp_err_t dhyara::utils::http::routes(httpd_req_t* req){
std::stringstream response_json;
response_json << "{";
{
std::stringstream routes_json;
routes_json << "[";
for(auto it = _link.routes().route_begin(); it != _link.routes().route_end(); ++it){
if(it != _link.routes().route_begin()){
routes_json << ",";
}
routes_json << "{";
routes_json << "\"dst\":" << '"' << it->first.dst().to_string() << '"' << ",";
routes_json << "\"via\":" << '"' << it->first.via().to_string() << '"' << ",";
routes_json << "\"delay\":" << (double)it->second.delay()/1000.0 << ",";
routes_json << "\"updated\":" << it->second.updated();
routes_json << "}";
}
routes_json << "]";
response_json << "\"routes\":" << routes_json.str();
}
response_json << ",";
{
std::stringstream next_json;
next_json << "[";
for(auto it = _link.routes().next_begin(); it != _link.routes().next_end(); ++it){
if(it != _link.routes().next_begin()){
next_json << ",";
}
next_json << "{";
next_json << "\"dst\":" << '"' << it->first.to_string() << '"' << ",";
next_json << "\"via\":" << '"' << it->second.via().to_string() << '"' << ",";
next_json << "\"delay\":" << (double)it->second.delay()/1000.0;
next_json << "}";
}
next_json << "]";
response_json << "\"next\":" << next_json.str();
}
response_json << "}";
std::string response = response_json.str();
httpd_resp_set_type(req, "application/json");
httpd_resp_send(req, response.c_str(), response.length());
return ESP_OK;
}
esp_err_t dhyara::utils::http::peers_html(httpd_req_t* req){
static const char* wrapper_close =
"</div>"
"<script>"
"setTimeout(() => {"
"fetch_banner();"
"poll_peers();"
"}, 500);"
"</script>"
"</body>";
httpd_resp_set_type(req, "text/html");
httpd_resp_sendstr_chunk(req, html_open);
httpd_resp_sendstr_chunk(req, (const char*)dhyara::assets::head_html_start);
httpd_resp_sendstr_chunk(req, wrapper_open);
httpd_resp_sendstr_chunk(req, fragments::sidebar);
httpd_resp_sendstr_chunk(req, central_open);
httpd_resp_sendstr_chunk(req, fragments::banner);
httpd_resp_sendstr_chunk(req, fragments::peers);
httpd_resp_sendstr_chunk(req, central_close);
httpd_resp_sendstr_chunk(req, wrapper_close);
httpd_resp_sendstr_chunk(req, html_close);
httpd_resp_sendstr_chunk(req, 0x0);
return ESP_OK;
}
esp_err_t dhyara::utils::http::peers(httpd_req_t* req){
std::stringstream response_json;
response_json << "{";
{
std::stringstream neighbours_json;
neighbours_json << "[";
for(auto it = _link.neighbours().begin(); it != _link.neighbours().end(); ++it){
if(it != _link.neighbours().begin()){
neighbours_json << ",";
}
const dhyara::neighbour& neighbour = it->second;
neighbours_json << "{";
neighbours_json << "\"mac\":" << '"' << neighbour.addr().to_string() << '"' << ",";
neighbours_json << "\"name\":" << '"' << neighbour.name() << '"' << ",";
neighbours_json << "\"channel\":" << (int)neighbour.channel() << ",";
neighbours_json << "\"rssi\":" << (int)neighbour.rssi() << ",";
neighbours_json << "\"encrypt\":" << std::boolalpha << neighbour.encrypt();
neighbours_json << "}";
}
neighbours_json << "]";
response_json << "\"neighbours\":" << neighbours_json.str();
}
response_json << ",";
{
std::stringstream universe_json;
universe_json << "[";
for(auto it = _link.universe().begin(); it != _link.universe().end(); ++it){
if(it != _link.universe().begin()){
universe_json << ",";
}
const dhyara::peer& peer = it->second;
universe_json << "{";
universe_json << "\"mac\":" << '"' << peer.addr().to_string() << '"' << ",";
universe_json << "\"name\":" << '"' << peer.name() << '"';
universe_json << "}";
}
universe_json << "]";
response_json << "\"universe\":" << universe_json.str();
}
response_json << "}";
std::string response = response_json.str();
httpd_resp_set_type(req, "application/json");
httpd_resp_send(req, response.c_str(), response.length());
return ESP_OK;
}
| [
"neel.basu.z@gmail.com"
] | neel.basu.z@gmail.com |
d4a86c5e7dde56f724dd777380b9c79260c3d5aa | f8c987b8a3733c7f16bd2a349920393726e2d5a2 | /Win32Project1/GE/math/Mat3.h | c26084ab86568fefce3f757152528afb9711816f | [] | no_license | yuqangy123/OGLGE | bdc579de65dbe776c2010e1d6632605b4c84646c | 06e8737164e46075c02358cd0744afe57406c672 | refs/heads/master | 2021-01-19T12:45:44.711601 | 2018-04-12T15:18:50 | 2018-04-12T15:18:50 | 100,806,404 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 208 | h | #pragma once
class Mat3
{
public:
Mat3();
Mat3(float f00, float f01, float f02, float f10, float f11, float f12, float f20, float f21, float f22);
~Mat3();
void zero();
public:
float m[3][3];
};
| [
"yuqangy@qq.com"
] | yuqangy@qq.com |
8e5f27e38b88900bf997e73177c1b9a4236ef924 | 40e1027a911cfbdea24d933d90d7038d3242b8f7 | /third/INHEREI.CPP | 159dd486b0460a4c63ad6d24a6b13bea049186c1 | [] | no_license | vinodkotiya/Basics-of-C-for-Beginners | 3f8154fa59f34e480480e9d4d0d391339ef41faa | d4be50ab9796c789e76bbffaa79475838b1316e0 | refs/heads/main | 2023-06-03T06:44:32.426242 | 2021-06-19T05:39:27 | 2021-06-19T05:39:27 | 378,332,591 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,686 | cpp | #include<iostream.h>
#include<conio.h>
#include<stdlib.h>
//char s;
void creators();
int total = 0;
class student
{protected:
char name[20];
int roll;
public:
void getdata();
void showdata();
};
void student::getdata()
{
cout<<"\nEnter the name of the student "<<"\n";
cin>>name;
cout<<"Enter the roll number of the student"<<"\n";
cin>>roll;
}
void student::showdata()
{
//if(s!='j')
// exit(0);
cout<<"Name of the student is "<<name<<"\n";
cout<<"Roll number is "<<roll<<"\n";
}
class test:public student
{protected:
float p,c,m;
public:
void getmarks(float, float ,float);
void showdata(void);
};
void test::getmarks(float a,float b,float d)
{
p=a;
c=b;
m=d;
}
void test::showdata(void)
{
student::showdata();
cout<<"\nMarks in Physics ," <<p<<" Chemistry ,"<<c<< " Maths "<<m<<"\n";
}
class result : public test
{public:
void display(void);
};
void result :: display(void)
{
total = p+c+m;
showdata();
cout<<"Total Marks Are " <<total;
}
void main()
{
clrscr();
creators();
float m,n,o;
int number;
result t[10];
cout<<"Enter The Number Of Students ";
cin>>number;
for(int i=0;i<number;i++)
{
cout<<"Student "<<i+1<<"\n";
t[i].getdata();
cout<<"Enter the marks in Physics, Chemistry, Maths "<<"\n";
cin>>m>>n>>o;
t[i].getmarks(m,n,o);
}
for(i=0;i<number;i++)
{
t[i].display();
}
getch();
}
void creators()
{
cout<<"****************************************************************************";
char n1[7] = {"Vinod,"},n2[10] = {"Digvijay,"},n3[8] = {"Sameer,"},n4[9] = {"Peeyush,"},n5[8] = {"Vishwas"};
cout<<"\nCreated by "<<n1<<n2<<n3<<n4<<n5;
cout<<"\n****************************************************************************\n";
// return n2[5];
} | [
"vinodkotiya@gmail.com"
] | vinodkotiya@gmail.com |
9bc4190cc3c219ffd94bbb868604d74d02952aa9 | 8cf2bafa6150751e072fda8abf735b780bb44668 | /Classes/entities/llumas/ivory/ivory_lluma.hxx | 283052c54b955c13f4981704c3da9395953dcb0b | [
"MIT"
] | permissive | yull2310/evermaze | 80cdb711c2fe15a68f87d39561e36418e3b676d7 | 733bfa00c635be9df2fa635bb68af8dba480f315 | refs/heads/master | 2023-04-02T17:21:13.851204 | 2021-04-10T19:13:48 | 2021-04-10T19:13:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,022 | hxx | /** Copyright (c) 2018 Mozart Alexander Louis. All rights reserved. */
#ifndef __IVORY_HXX__
#define __IVORY_HXX__
/**
* Entity File for Ivory
*/
#define __IVORY_ENTITY_FILE__ "entities/llumas/ivory.plist"
/**
* Includes
*/
#include "entities/llumas/base_lluma.hxx"
class Ivory : public BaseLluma {
public:
/**
* Constructor.
*
* @param scene ~ Pointer to the active game layer.
* @param id ~ The id of the lluma to load.
* @param gesture ~ Pointer to the active swipe gesture pointer on the game scene.
* @param tmx_layer ~ The layer to set as a current layer for walls and traversal
*/
explicit Ivory(BaseGameScene* scene, SwipeGesture* gesture, const string& id, const string& tmx_layer);
/**
* Destructor
*/
~Ivory();
protected:
/**
* @link BaseLluma::generateStats();
*/
ValueMap generateStats(const string& id) override;
private:
/**
* __DISALLOW_COPY_AND_ASSIGN__
*/
__DISALLOW_COPY_AND_ASSIGN__(Ivory)
};
#endif // __IVORY_HXX__
| [
"prodbymozart@gmail.com"
] | prodbymozart@gmail.com |
13f880dd5ec057a80d9863357d36e3a62c0b529f | fbc2dafc8cc9ef49e5b77a1661d7e064f1584e73 | /include/SLUtils.h | c6fa942246b174febcbfd094e03004b37f22796e | [] | no_license | liguangzheng/slproject | 673151376c94552dcbe1b7b1f40263c92ff5283e | 977ae8296e6494a8de7a43082f05c43014077f8d | refs/heads/master | 2020-05-17T05:08:43.204773 | 2015-05-30T08:10:13 | 2015-05-30T08:10:13 | 34,549,262 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,145 | h | //#############################################################################
// File: SL/SLUtils.h
// Author: Marcus Hudritsch
// Date: July 2014
// Codestyle: https://github.com/cpvrlab/SLProject/wiki/Coding-Style-Guidelines
// Copyright: Marcus Hudritsch
// This software is provide under the GNU General Public License
// Please visit: http://opensource.org/licenses/GPL-3.0
//#############################################################################
#include <stdafx.h>
#include <dirent.h>
#ifndef SLUTILS_H
#define SLUTILS_H
//-----------------------------------------------------------------------------
//! SLUtils provides static utility functions string handling
class SLUtils
{
public:
//! SLUtils::toString returns a string from a float with max. one trailing zero
static SLstring toString(float f)
{ char cstr[32];
sprintf(cstr, "%f", f);
for (SLint i = (SLint)strlen(cstr); i > 0; i--)
if (cstr[i]=='0' && cstr[i-1]>='0' && cstr[i-1]<='9') cstr[i] = 0;
SLstring num = cstr;
if (num == "-0.0") num = "0.0";
return num;
}
//! SLUtils::toString returns a string from a double with max. one trailing zero
static SLstring toString(double d)
{ char cstr[32];
sprintf(cstr, "%f", d);
for (SLint i = (SLint)strlen(cstr); i > 0; i--)
if (cstr[i]=='0' && cstr[i-1]>='0' && cstr[i-1]<='9') cstr[i] = 0;
SLstring num = cstr;
if (num == "-0.0") num = "0.0";
return num;
}
//! SLUtils::toLower returns a string in lower case
static SLstring toLower(SLstring s)
{ SLstring cpy(s);
transform(cpy.begin(), cpy.end(), cpy.begin(),::tolower);
return cpy;
}
//! SLUtils::toUpper returns a string in upper case
static SLstring toUpper(SLstring s)
{ SLstring cpy(s);
transform(cpy.begin(), cpy.end(), cpy.begin(),::toupper);
return cpy;
}
//! SLUtils::getPath returns the path w. '\\' of path-filename string
static SLstring getPath(const SLstring& pathFilename)
{
size_t i;
i = pathFilename.rfind('\\', pathFilename.length( ));
if (i != string::npos)
{ return(pathFilename.substr(0, i+1));
}
i = pathFilename.rfind('/', pathFilename.length( ));
if (i != string::npos)
{ return(pathFilename.substr(0, i+1));
}
return pathFilename;
}
//! SLUtils::getFileName returns the filename of path-filename string
static SLstring getFileName(const SLstring& pathFilename)
{
size_t i;
i = pathFilename.rfind('\\', pathFilename.length( ));
if (i != string::npos)
return(pathFilename.substr(i+1, pathFilename.length( ) - i));
i = pathFilename.rfind('/', pathFilename.length( ));
if (i != string::npos)
return(pathFilename.substr(i+1, pathFilename.length( ) - i));
return pathFilename;
}
//! SLUtils::getFileNameWOExt returns the filename without extension
static SLstring getFileNameWOExt(const SLstring& pathFilename)
{
SLstring filename = getFileName(pathFilename);
size_t i;
i = filename.rfind('.', filename.length( ));
if (i != string::npos)
{ return(filename.substr(0, i));
}
return(filename);
}
//! SLUtils::getFileExt returns the file extension without dot in lower case
static SLstring getFileExt(SLstring filename)
{
size_t i;
i = filename.rfind('.', filename.length( ));
if (i != string::npos)
return toLower(filename.substr(i+1, filename.length() - i));
return("");
}
//! SLUtils::getFileNamesinDir returns a vector of storted filesname with path within a directory
static SLVstring getFileNamesInDir(SLstring dirName)
{
SLVstring fileNames;
DIR* dir;
struct dirent *dirContent;
int i=0;
dir = opendir(dirName.c_str());
if (dir)
{ while ((dirContent = readdir(dir)) != NULL)
{ i++;
SLstring name(dirContent->d_name);
if(name != "." && name != "..")
fileNames.push_back(dirName+"/"+name);
}
closedir(dir);
}
return fileNames;
}
//! SLUtils::trims a string at the end
static SLstring trim(SLstring& s, const SLstring& drop = " ")
{ SLstring r=s.erase(s.find_last_not_of(drop)+1);
return r.erase(0,r.find_first_not_of(drop));
}
//! SLUtils::splits an input string at a delimeter character into a string vector
static void split(const string& s, char delimiter, vector<string>& splits)
{ string::size_type i = 0;
string::size_type j = s.find(delimiter);
while (j != string::npos)
{ splits.push_back(s.substr(i, j - i));
i = ++j;
j = s.find(delimiter, j);
if (j == string::npos)
splits.push_back(s.substr(i, s.length()));
}
}
//! Replaces in the subject string the search string by the replace string
static void replaceString(SLstring& subject,
const SLstring& search,
const SLstring& replace)
{ size_t pos = 0;
while ((pos = subject.find(search, pos)) != std::string::npos)
{ subject.replace(pos, search.length(), replace);
pos += replace.length();
}
}
//! SLUtils::removeComments for C/C++ comments removal from shader code
static SLstring removeComments(SLstring src)
{
SLstring dst;
SLint len = (SLint)src.length();
SLint i = 0;
while (i < len)
{ if (src[i]=='/' && src[i+1]=='/')
{ dst += '\n';
while (i<len && src[i] != '\n') i++;
i++;
}
else if (src[i]=='/' && src[i+1]=='*')
{ while (i<len && !(src[i]=='*' && src[i+1]=='/'))
{
if (src[i]=='\n') dst += '\n';
i++;
}
i+=2;
}
else
{ dst += src[i++];
}
}
//cout << dst << "|" << endl;
return dst;
}
};
//-----------------------------------------------------------------------------
#endif
| [
"liguangzhenghi@163.com"
] | liguangzhenghi@163.com |
dabe86242dca2e63555a373685a9856e78ee8619 | 008353c31e3d3806b249ffb3ab12bbbdd3d054cb | /src/main/validation/include/nodeValidator.h | c000729d4a7c9935fe0efb419db9927e81d60418 | [
"MIT"
] | permissive | alhowaidi/ns3-lxc | 8ea6ac930971d7e76acaf8523032a69f16918142 | 323ab15f3a08407d89c91e9a68de8c10e5a0e5eb | refs/heads/master | 2020-03-13T23:46:17.023428 | 2017-06-27T23:40:43 | 2017-06-27T23:40:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 179 | h | #ifndef __NODE_VALIDATOR_H_INCLUDED__
#define __NODE_VALIDATOR_H_INCLUDED__
#include <memory>
#include "node.h"
void validateNode(std::shared_ptr<ns3lxc::Node> nodePtr);
#endif | [
"mda5893@rit.edu"
] | mda5893@rit.edu |
6f70c03affabc0d17e02d77c9eb6735ad8cef03e | c6a98b8e273e69533009e5073a505508e3a0c2c5 | /Problems/ICPC/HelpCupid.cpp | 6b9822c4a2a10d9670c07e6e928f6b84f26a8c3d | [] | no_license | BenjaminRubio/CompetitiveProgramming | 5c72a9b803e66e194fd7fe8a26d0d81d14a7fc5c | 33ba1125a2eb5ba4d6f9cbc8522c92432bc92b0d | refs/heads/master | 2023-06-08T19:43:44.069793 | 2023-05-27T18:53:32 | 2023-05-27T18:53:32 | 176,643,093 | 16 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 558 | cpp | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
int N;
vector<int> T;
int dist(int i, int j)
{
return min(abs(i - j), 24 - abs(i - j));
}
int main()
{
while (cin >> N)
{
T.resize(N);
rep(i, N) cin >> T[i];
sort(T.begin(), T.end());
int ans1 = 0;
rep(i, N / 2) ans1 += dist(T[2 * i], T[(2 * i + 1) % N]);
int ans2 = 0;
rep(i, N / 2) ans2 += dist(T[(2 * i + 1) % N], T[(2 * i + 2) % N]);
cout << min(ans1, ans2) << '\n';
}
} | [
"berubio@uc.cl"
] | berubio@uc.cl |
840502efcdbb534f7e04167b104c1dfe89b3a948 | 6651dcac19c17e30388e2004f65465297e6952a5 | /LBEP/Demo/Demo14.cpp | ae427b0b11f11d38c6c6429b1f0385688f3bc616 | [] | no_license | arthursnv/AnhNVTH1904015 | d1cfbefdcb050a704c3d1d78d5a34199e94a6365 | f806996f473d58a4d3c8c1afda6600d5679ea1ac | refs/heads/master | 2022-02-27T00:31:57.142919 | 2019-09-06T08:40:43 | 2019-09-06T08:40:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,829 | cpp | #include<stdio.h>
#include<string.h>
void inrachuoidainhat(char s[][20], int n){
int vi_tri = 0;
long int max = strlen(s[0]);
for (int i = 0; i < n; ++i)
{
if(max < strlen(s[i])){
max = strlen(s[i]);
vi_tri=i;
}
}
printf("chuoi dai nhat: %s\n",s[vi_tri]);
}
int main(){
/* Mang 1 chieu:
char s1[20], s2[20];
printf("Nhap chuoi 1: ");
scanf("%s", s1);
printf("Nhap chuoi 2: ");
scanf("%s", s2);
printf("\nChuoi 1 vua nhap la: \n%s\n", s1);
// ham strcmp dung de so sanh 2 chuoi;
// dung ham chuoi thi phai khai bao thu vien string.h;
int ss = strcmp(s1, s2);
printf("\nKet qua: %d", ss);
if(ss < 0){
printf("\nChuoi 1 nho hon chuoi 2.\n");
} else if(ss > 0){
printf("\nChuoi 1 lon hon chuoi 2.\n");
} else {
printf("\nChuoi 1 giong chuoi 2.\n");
}
// ham strchar(str1, chr) dung de tim vi tri cua chr trong chuoi str1;
printf("\nVi tri cua ky tu 'h' trong chuoi 1 la: %ld\n", strchr(s1, 'h')-s1);
// ham strcpy(str1, str2) dung de copy chuoi str2 cho str1;
strcpy(s1, s2);
printf("\nChuoi 1 sau khi dung ham strcpy: \n%s", s1);
// ham strcat(str1, str2) dung de noi chuoi s1 + s2;
strcat(s1, s2);
printf("\nChuoi 1 sau khi dung ham strcat: \n%s", s1);
// ham strlen(str1) dung de tinh kich thuoc chuoi;
printf("\nKich thuoc cua chuoi 1 sau khi dung ham strcat: \n%ld\n", strlen(s1));
// in ra chuoi in hoa
for (int i = 0; i < strlen(s1); ++i)
{
if(s1[i] >=97 && s1[i]<=122){
printf("%c",s1[i]-32);
}
}
printf("\n");
// In ra chuoi dao nguoc;
for(int i = strlen(s1) - 1; i >= 0; i--){
printf("%c", s1[i]);
}
*/
/*
Mang 2 chieu
*/
char s3[4][20];
for(int i = 0; i < 4; i++){
printf("Nhap vao chuoi thu %d:", i);
scanf("%s", s3[i]);
}
for(int i = 0; i < 4; i++){
printf("Chuoi thu %d vua nhap la: %s\n", i, s3[i]);
}
inrachuoidainhat(s3, 4);
}
| [
"38343906+thienan0789@users.noreply.github.com"
] | 38343906+thienan0789@users.noreply.github.com |
e165d91d3aaf46150590dc5c0a414515518ef6b3 | 35750813219921d4a4e7869424689356c5e48f03 | /antiva/src/main/cpp/syscalls.h | 3f166a5492b1c5e77a5312478c2176da62ddfcda | [] | no_license | qtfreet00/AntiVirtualApp | 5363b6bd0735aa48e269a2e64e61f9c9e39bb612 | 9edc8d35363c1ff2084886c3d7587613788926ec | refs/heads/master | 2020-03-24T17:21:06.546079 | 2018-08-14T08:00:24 | 2018-08-14T08:00:24 | 142,856,783 | 3 | 2 | null | 2018-08-14T08:00:25 | 2018-07-30T09:49:10 | C++ | UTF-8 | C++ | false | false | 438 | h | //
// Created by qtfreet00 on 2018/1/22.
//
#ifndef VADETECT_SVC_H
#define VADETECT_SVC_H
#include <fcntl.h>
#include <unistd.h>
#include <sys/syscall.h>
class Sys {
public:
static pid_t wrap_getpid(void);
static int wrap_open(const char *path, int flags);
static int wrap_close(int fd);
static ssize_t wrap_read(int fd, void *buf, size_t count);
static uid_t wrap_getuid(void);
};
#endif //VADETECT_SVC_H
| [
"812298893@qq.com"
] | 812298893@qq.com |
964cca663cf27ba464061700ebf4901fe156e176 | 63b6f4cf0ff68b27f6766646ecf86a54ebe0de96 | /UVA/Mathematics/Combinatorics/11401.cpp | a6707b33ffe9f9384203cfebfe77747231e453f2 | [] | no_license | javarmgar/Competitive_Programming_Training_00 | f7589720f78884a7486480e2299c80b9244715dc | d3d40631ea6a5b1fb6d097656ca28e352ec2702f | refs/heads/master | 2023-01-21T14:02:08.829442 | 2020-06-07T18:13:21 | 2020-06-07T18:13:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 576 | cpp | /*
Encontrar el patron es de lo mas dificil
3 0
4 1
5 3
6 7
7 13
8 22
donde
0 = 0
1 = 0 + 1*1
3 = 1 + 1*2
7 = 3 + 2*2
13 7 + 2*3
22 13 + 3*3
... 22 + 3*4
es geometrica
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define SIZE 1000001
ll a[SIZE];
void precalc(){
a[0] = a[1] = a[2] = a[3] = 0;
ll m = 0;
for(int i = 4; i < SIZE; i++){
if(i&1)
a[i] = a[i - 1] + m*(m+1);
else{
m++;
a[i] = a[i-1] + m*m;
}
}
}
int main(){
precalc();
int n;
while(cin >> n && n > 2 ){
cout << a[n] <<"\n";
}
} | [
"javarmgar@gmail.com"
] | javarmgar@gmail.com |
2ba57a1d88abf700abfde474dc77e9af08ff2ba7 | c6e054fa29e63c799a8200d9af43b7e0af154626 | /release_16Jan2013/UnbinnedDataSet.hh | 3cd235070c790820d3c9788a60135d08299c8a7e | [] | no_license | GooFit/GooTorial | 5ff90b2a82cfcdce21fcf514c5fe0678df9f23d4 | 2f88e7c7fd0f295e00e8a3b1ab076bce934709b9 | refs/heads/master | 2020-05-19T11:15:11.006500 | 2013-04-03T13:41:03 | 2013-04-03T13:41:03 | 9,107,328 | 5 | 2 | null | 2019-11-26T19:06:21 | 2013-03-29T21:49:59 | C++ | UTF-8 | C++ | false | false | 655 | hh | #ifndef UNBINNED_DATASET_HH
#define UNBINNED_DATASET_HH
#include "DataSet.hh"
class UnbinnedDataSet : public DataSet {
// Class for unbinned datasets.
public:
UnbinnedDataSet (Variable* var);
UnbinnedDataSet (std::vector<Variable*>& vars);
UnbinnedDataSet (std::set<Variable*>& vars);
~UnbinnedDataSet ();
virtual void addEventVector (std::vector<fptype>& vals, fptype weight = 1);
int getNumEvents () const {return data.size();}
fptype getValue (Variable* var, int idx) const;
void loadEvent (int idx);
void setValueForAllEvents (Variable* var);
private:
std::vector<std::map<Variable*, fptype> > data;
};
#endif
| [
"rolfa@slac.stanford.edu"
] | rolfa@slac.stanford.edu |
4fa8039ae16519ec3ed4ccea9584b218ce395463 | c6c546178ef107140007a8bdf3daf4038ecc4d58 | /Source/SIMPLib/CoreFilters/MultiThresholdObjects2.h | d2fa542c9b2cd179d78e373069a9e4ddcc3177b9 | [
"BSD-3-Clause"
] | permissive | jmcclure93/SIMPL | a786b1f24f627ee4d6878cedf4058c3a43e4563a | ba3e619799a0c00ab83e18a3eafc899b35f0061d | refs/heads/develop | 2020-03-22T05:58:15.586206 | 2018-07-03T17:42:49 | 2018-07-03T17:42:49 | 139,603,178 | 0 | 0 | null | 2018-07-03T17:42:50 | 2018-07-03T15:26:23 | C++ | UTF-8 | C++ | false | false | 9,561 | h | /* ============================================================================
* Copyright (c) 2009-2016 BlueQuartz Software, LLC
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* Neither the name of BlueQuartz Software, the US Air Force, nor the names of its
* contributors may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* The code contained herein was partially funded by the followig contracts:
* United States Air Force Prime Contract FA8650-07-D-5800
* United States Air Force Prime Contract FA8650-10-D-5210
* United States Prime Contract Navy N00173-07-C-2068
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
#ifndef _multithresholdobjects2_h_
#define _multithresholdobjects2_h_
#include "SIMPLib/Common/SIMPLibSetGetMacros.h"
#include "SIMPLib/Filtering/AbstractFilter.h"
#include "SIMPLib/Filtering/ComparisonInputsAdvanced.h"
#include "SIMPLib/Filtering/ComparisonSet.h"
#include "SIMPLib/Filtering/ComparisonValue.h"
#include "SIMPLib/SIMPLib.h"
/**
* @brief The MultiThresholdObjects2 class. See [Filter documentation](@ref multithresholdobjects2) for details.
*/
class SIMPLib_EXPORT MultiThresholdObjects2 : public AbstractFilter
{
Q_OBJECT
PYB11_CREATE_BINDINGS(MultiThresholdObjects2 SUPERCLASS AbstractFilter)
PYB11_PROPERTY(QString DestinationArrayName READ getDestinationArrayName WRITE setDestinationArrayName)
PYB11_PROPERTY(ComparisonInputsAdvanced SelectedThresholds READ getSelectedThresholds WRITE setSelectedThresholds)
public:
SIMPL_SHARED_POINTERS(MultiThresholdObjects2)
SIMPL_FILTER_NEW_MACRO(MultiThresholdObjects2)
SIMPL_TYPE_MACRO_SUPER_OVERRIDE(MultiThresholdObjects2, AbstractFilter)
~MultiThresholdObjects2() override;
SIMPL_FILTER_PARAMETER(QString, DestinationArrayName)
Q_PROPERTY(QString DestinationArrayName READ getDestinationArrayName WRITE setDestinationArrayName)
SIMPL_FILTER_PARAMETER(ComparisonInputsAdvanced, SelectedThresholds)
Q_PROPERTY(ComparisonInputsAdvanced SelectedThresholds READ getSelectedThresholds WRITE setSelectedThresholds)
/**
* @brief getCompiledLibraryName Reimplemented from @see AbstractFilter class
*/
const QString getCompiledLibraryName() const override;
/**
* @brief getBrandingString Returns the branding string for the filter, which is a tag
* used to denote the filter's association with specific plugins
* @return Branding string
*/
const QString getBrandingString() const override;
/**
* @brief getFilterVersion Returns a version string for this filter. Default
* value is an empty string.
* @return
*/
const QString getFilterVersion() const override;
/**
* @brief newFilterInstance Reimplemented from @see AbstractFilter class
*/
AbstractFilter::Pointer newFilterInstance(bool copyFilterParameters) const override;
/**
* @brief getGroupName Reimplemented from @see AbstractFilter class
*/
const QString getGroupName() const override;
/**
* @brief getSubGroupName Reimplemented from @see AbstractFilter class
*/
const QString getSubGroupName() const override;
/**
* @brief getUuid Return the unique identifier for this filter.
* @return A QUuid object.
*/
const QUuid getUuid() override;
/**
* @brief getHumanLabel Reimplemented from @see AbstractFilter class
*/
const QString getHumanLabel() const override;
/**
* @brief setupFilterParameters Reimplemented from @see AbstractFilter class
*/
void setupFilterParameters() override;
/**
* @brief readFilterParameters Reimplemented from @see AbstractFilter class
*/
void readFilterParameters(AbstractFilterParametersReader* reader, int index) override;
/**
* @brief execute Reimplemented from @see AbstractFilter class
*/
void execute() override;
/**
* @brief preflight Reimplemented from @see AbstractFilter class
*/
void preflight() override;
signals:
/**
* @brief updateFilterParameters Emitted when the Filter requests all the latest Filter parameters
* be pushed from a user-facing control (such as a widget)
* @param filter Filter instance pointer
*/
void updateFilterParameters(AbstractFilter* filter);
/**
* @brief parametersChanged Emitted when any Filter parameter is changed internally
*/
void parametersChanged();
/**
* @brief preflightAboutToExecute Emitted just before calling dataCheck()
*/
void preflightAboutToExecute();
/**
* @brief preflightExecuted Emitted just after calling dataCheck()
*/
void preflightExecuted();
protected:
MultiThresholdObjects2();
/**
* @brief dataCheck Checks for the appropriate parameter values and availability of arrays
*/
void dataCheck();
/**
* @brief Initializes all the private instance variables.
*/
void initialize();
/**
* @brief Creates and returns a DataArray<bool> for the given AttributeMatrix and the number of tuples
*/
void createBoolArray(int64_t& numItems, BoolArrayType::Pointer& thresholdArrayPtr);
/**
* @brief Merges two DataArray<bool>s of a given size using a union operator AND / OR and inverts the second DataArray if requested
* @param numItems Number of values in both DataArrays
* @param currentArray DataArray<bool> to merge values into
* @param unionOperator Union operator used to merge into currentArray
* @param newArray DataArray<bool> of values to merge into the currentArray
* @param inverse Should newArray have its boolean values flipped before being merged in
*/
void insertThreshold(int64_t numItems, BoolArrayType::Pointer currentArray, int unionOperator, const BoolArrayType::Pointer newArray, bool inverse);
/**
* @brief Flips the boolean values for a DataArray<bool>
* @param numItems Number of tuples in the DataArray
* @param thresholdArray DataArray to invert
*/
void invertThreshold(int64_t numItems, BoolArrayType::Pointer thresholdArray);
/**
* @brief Performs a check on a ComparisonSet and either merges the result into the DataArray passed in or replaces the DataArray
* @param comparisonSet The set of comparisons used for setting the threshold
* @param inputThreshold DataArray<bool> merged into or replaced after finding the ComparisonSet's threshould output
* @param err Return any error code given
* @param replaceInput Specifies whether or not the result gets merged into inputThreshold or replaces it
* @param inverse Specifies whether or not the results need to be flipped before merging or replacing inputThreshold
*/
void thresholdSet(ComparisonSet::Pointer comparisonSet, BoolArrayType::Pointer& inputThreshold, int32_t& err, bool replaceInput = false, bool inverse = false);
/**
* @brief Performs a check on a single ComparisonValue and either merges the result into the DataArray passed in or replaces the DataArray
* @param comparisonValue The comparison operator and value used for caluculating the threshold
* @param inputThreshold DataArray<bool> merged into or replaced after finding the ComparisonSet's threshould output
* @param err Return any error code given
* @param replaceInput Specifies whether or not the result gets merged into inputThreshold or replaces it
* @param inverse Specifies whether or not the results need to be flipped before merging or replacing inputThreshold
*/
void thresholdValue(ComparisonValue::Pointer comparisonValue, BoolArrayType::Pointer& inputThreshold, int32_t& err, bool replaceInput = false, bool inverse = false);
private:
DEFINE_DATAARRAY_VARIABLE(bool, Destination)
public:
MultiThresholdObjects2(const MultiThresholdObjects2&) = delete; // Copy Constructor Not Implemented
MultiThresholdObjects2(MultiThresholdObjects2&&) = delete; // Move Constructor
MultiThresholdObjects2& operator=(const MultiThresholdObjects2&) = delete; // Copy Assignment Not Implemented
MultiThresholdObjects2& operator=(MultiThresholdObjects2&&) = delete; // Move Assignment
};
#endif /* _MultiThresholdObjects_H_ */
| [
"mike.jackson@bluequartz.net"
] | mike.jackson@bluequartz.net |
aebc235f28bd41fe719025bf03f9c1ed85b07611 | 80716d408715377e88de1fc736c9204b87a12376 | /TspLib3/Src/Serialize.cpp | ccff9197c53978b83a9ea725dc730aefa2a790a5 | [] | no_license | junction/jn-tapi | b5cf4b1bb010d696473cabcc3d5950b756ef37e9 | a2ef6c91c9ffa60739ecee75d6d58928f4a5ffd4 | refs/heads/master | 2021-03-12T23:38:01.037779 | 2011-03-10T01:08:40 | 2011-03-10T01:08:40 | 199,317 | 2 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 8,063 | cpp | /******************************************************************************/
//
// SERIALIZE.CPP - Serialization (persistant) data support
//
// Copyright (C) 1994-2004 JulMar Entertainment Technology, Inc.
// All rights reserved
//
// This file contains the serialization support for the TSP-side of the
// TSP++ library. It allows us to read/write the information which was stored into
// the registry by the v3.0 extensions of TSPUI.LIB
//
// This source code is intended only as a supplement to the
// TSP++ Class Library product documentation. This source code cannot
// be used in part or whole in any form outside the TSP++ library.
//
/******************************************************************************/
/*---------------------------------------------------------------------------*/
// INCLUDE FILES
/*---------------------------------------------------------------------------*/
#include "stdafx.h"
#include <ctype.h>
#include <regstream.h>
/*-----------------------------------------------------------------------------*/
// GLOBALS and CONSTANTS
/*-----------------------------------------------------------------------------*/
static const TCHAR * const gszUseTspUI = _T("UseTspUI");
static const TCHAR * const gszTotalLines = _T("LineCount");
static const TCHAR * const gszTotalPhones = _T("PhoneCount");
static const TCHAR * const gszTotalAgentActivities = _T("AgentActivityCount");
static const TCHAR * const gszTotalAgentGroups = _T("AgentGroupCount");
///////////////////////////////////////////////////////////////////////////////
// CServiceProvider::ReadDeviceCount
//
// Reads the count of devices from the registry
//
bool CServiceProvider::ReadDeviceCount(DWORD dwProviderID,
LPDWORD lpdwNumLines, LPDWORD lpdwNumPhones,
LPDWORD lpdwNumAct, LPDWORD lpdwNumGroups)
{
if (ReadProfileDWord(0, gszUseTspUI, 0) == 1)
{
if (lpdwNumLines != NULL)
*lpdwNumLines = ReadProfileDWord(dwProviderID, gszTotalLines, 0);
if (lpdwNumPhones != NULL)
*lpdwNumPhones = ReadProfileDWord(dwProviderID, gszTotalPhones, 0);
if (lpdwNumAct != NULL)
*lpdwNumAct = ReadProfileDWord(dwProviderID, gszTotalAgentActivities, 0);
if (lpdwNumGroups != NULL)
*lpdwNumGroups = ReadProfileDWord(dwProviderID, gszTotalAgentGroups);
return true;
}
return false;
}// CServiceProvider::ReadDeviceCount
///////////////////////////////////////////////////////////////////////////////
// CTSPIDevice::AllocStream
//
// Allocates a stream to read persistant data from
//
TStream* CTSPIDevice::AllocStream()
{
return (GetSP()->ReadProfileDWord(0, gszUseTspUI, 0)) ?
new tsplib::TRegstream(GetProviderID(), GetSP()->GetProviderInfo()) : NULL;
}// CTSPIDevice::AllocStream
///////////////////////////////////////////////////////////////////////////////
// CTSPIDevice::LoadObjects
//
// This function loads all the objects stored in the registry section for
// this service provider.
//
void CTSPIDevice::LoadObjects(TStream& rs)
{
// Read the agent activities
unsigned int iCount = static_cast<unsigned int>(GetSP()->ReadProfileDWord(GetProviderID(), gszTotalAgentActivities, 0));
if (iCount > 0)
{
// Read each activity into a structure
for (unsigned int i = 0; i < iCount; i++)
{
// Read our information from the registry
TAgentActivity* pAct = ReadAgentActivity(rs);
_TSP_ASSERT (pAct != NULL);
if (pAct != NULL)
{
_TSP_DTRACE(_T("Added agent activity #%d: [0x%lx] %s\n"), i+1,
pAct->dwID, pAct->strName.c_str());
_TSP_ASSERT (DoesAgentActivityExist(pAct->dwID) == NULL);
m_arrAgentActivities.push_back(pAct);
}
}
}
// Read the agent groups
iCount = static_cast<unsigned int>(GetSP()->ReadProfileDWord(GetProviderID(), gszTotalAgentGroups, 0));
if (iCount > 0)
{
// Read each group into a structure
for (unsigned int i = 0; i < iCount; i++)
{
// Read our information from the registry
TAgentGroup* pGroup = ReadAgentGroup(rs);
_TSP_ASSERT (pGroup != NULL);
if (pGroup != NULL)
{
_TSP_DTRACE(_T("Added agent group #%d: [0x%lx 0x%lx 0x%lx 0x%lx] %s\n"), i+1,
pGroup->GroupID.dwGroupID1, pGroup->GroupID.dwGroupID2, pGroup->GroupID.dwGroupID3, pGroup->GroupID.dwGroupID4,
pGroup->strName.c_str());
_TSP_ASSERT (DoesAgentGroupExist(pGroup->GroupID.dwGroupID1, pGroup->GroupID.dwGroupID2, pGroup->GroupID.dwGroupID3, pGroup->GroupID.dwGroupID4) == NULL);
m_arrAgentGroups.push_back(pGroup);
}
}
}
}// CTSPIDevice::LoadObjects
///////////////////////////////////////////////////////////////////////////////
// CTSPIDevice::SaveObjects
//
// This function saves all the objects into the registry section for
// this service provider.
//
void CTSPIDevice::SaveObjects(TStream& ostm)
{
// Write the agent activities
int nCount = static_cast<int>(m_arrAgentActivities.size());
GetSP()->WriteProfileDWord(GetProviderID(), gszTotalAgentActivities, nCount);
if (nCount > 0)
{
for (int i = 0; i < nCount; i++)
WriteAgentActivity(m_arrAgentActivities[i], ostm);
}
// Write the agent groups
nCount = static_cast<int>(m_arrAgentGroups.size());
GetSP()->WriteProfileDWord(GetProviderID(), gszTotalAgentGroups, nCount);
if (nCount > 0)
{
for (int i = 0; i < nCount; i++)
WriteAgentGroup(m_arrAgentGroups[i], ostm);
}
}// CTSPIDevice::SaveObjects
///////////////////////////////////////////////////////////////////////////////
// CTSPIDevice::ReadAgentActivity
//
// Stream in an agent activity. Since the activity is a simple structure
// it doesn't have the stream associated with it.
//
TAgentActivity* CTSPIDevice::ReadAgentActivity(TStream& istm)
{
TAgentActivity* pAct = new TAgentActivity;
try
{
istm >> pAct->dwID >> pAct->strName;
}
catch (...)
{
delete pAct;
throw;
}
return pAct;
}// CTSPIDevice::ReadAgentActivity
///////////////////////////////////////////////////////////////////////////////
// CTSPIDevice::WriteAgentActivity
//
// Serialize out an agent activity structure into a registry stream
//
void CTSPIDevice::WriteAgentActivity(const TAgentActivity* pAct, TStream& ostm) const
{
_TSP_ASSERT (pAct != NULL);
if (pAct == NULL)
return;
try
{
ostm << pAct->dwID << pAct->strName;
}
catch (...)
{
_TSP_ASSERT (FALSE);
}
}// CTSPIDevice::WriteAgentActivity
///////////////////////////////////////////////////////////////////////////////
// CTSPIDevice::ReadAgentGroup
//
// Stream in an agent group. Since the group is a simple structure
// it doesn't have the stream associated with it.
//
TAgentGroup* CTSPIDevice::ReadAgentGroup(TStream& istm)
{
TAgentGroup* pGroup = new TAgentGroup;
try
{
istm >> pGroup->GroupID.dwGroupID1 >>
pGroup->GroupID.dwGroupID2 >>
pGroup->GroupID.dwGroupID3 >>
pGroup->GroupID.dwGroupID4 >>
pGroup->strName;
}
catch (...)
{
delete pGroup;
throw;
}
return pGroup;
}// CTSPIDevice::ReadAgentGroup
///////////////////////////////////////////////////////////////////////////////
// CTSPIDevice::WriteAgentGroup
//
// Serialize out an agent group structure into a registry stream
//
void CTSPIDevice::WriteAgentGroup(const TAgentGroup* pGroup, TStream& ostm) const
{
_TSP_ASSERT (pGroup != NULL);
if (pGroup == NULL)
return;
try
{
ostm << pGroup->GroupID.dwGroupID1 <<
pGroup->GroupID.dwGroupID2 <<
pGroup->GroupID.dwGroupID3 <<
pGroup->GroupID.dwGroupID4 <<
pGroup->strName;
}
catch (...)
{
_TSP_ASSERT (FALSE);
}
}// CTSPIDevice::WriteAgentGroup
| [
"Owner@.(none)"
] | Owner@.(none) |
6bae40f80f141c184f23a59e742e7ff5ead5edeb | 450c2ff22346e254532562b2e26574a67bf29e63 | /src/Graph.cpp | 7569f42662f9bb3e3944e8b76c3cf429fedcbf9e | [] | no_license | Lucas-CG/GraphOtim | 1b7b2a6c2663e31ec3be6d367b733fb0d0017781 | 12127e5074d3b29d89a8208092b61f2f007c522c | refs/heads/master | 2021-08-20T07:09:58.642189 | 2017-11-28T13:37:59 | 2017-11-28T13:37:59 | 109,828,703 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,595 | cpp | #include "Graph.hpp"
#include <fstream> //std::ifstream
#include <iterator> //std::back_inserter
#include <string> //std::string, std::stoi
#include <unordered_set> //std::unordered_set
#include <iostream> //std::cout, std::endl
/*
template<typename Out>
void split(const std::string &s, char delim, Out result)
{
std::stringstream ss;
ss.str(s);
std::string item;
while ( std::getline(ss, item, delim) )
{
*(result++) = item;
}
}
*/
Graph::Graph(int size)
{
numVertices = size;
std::unordered_set<int> nullFreqs;
std::pair<bool, std::unordered_set<int> > pair(false, nullFreqs);
std::vector< std::pair< bool, std::unordered_set<int> > > pairVector(size, pair);
std::vector< std::vector< std::pair< bool, std::unordered_set<int> > > > mat(size, pairVector);
matrix = mat;
}
void Graph::addEdge(int a, int b)
{
matrix[a][b].first = true;
matrix[b][a].first = true;
numEdges++;
}
void Graph::addFrequency(int a, int b, int f)
{
matrix[a][b].second.emplace(f);
matrix[b][a].second.emplace(f);
}
void Graph::print()
{
for(int i = 0; i < numVertices; i++)
{
std::cout << "[";
for(int j = 0; j < numVertices; j++)
{
std::cout << matrix[i][j].first << " ";
}
std::cout << "]" << std::endl;
}
}
bool doPathsHaveCollision(Path &path1, Path &path2)
{
//o conjunto de arestas reúne um par (aresta, frequência)
//uma aresta é um par de vértices
std::vector< std::pair<int, int> > path1Edges, path2Edges;
//recuperar as arestas dos dois caminhos
for(int i = 0; i < path1.nodeList.size(); i++)
{
if( i + 1 < path1.nodeList.size() )
{
std::pair<int, int> edge(path1.nodeList[i], path1.nodeList[i+1]);
std::pair<int, int> reverseEdge(path1.nodeList[i+1], path1.nodeList[i]);
path1Edges.push_back(edge);
path1Edges.push_back(reverseEdge);
}
}
for(int i = 0; i < path2.nodeList.size(); i++)
{
if( i + 1 < path2.nodeList.size() )
{
std::pair<int, int> edge(path2.nodeList[i], path2.nodeList[i+1]);
std::pair<int, int> reverseEdge(path2.nodeList[i+1], path2.nodeList[i]);
path2Edges.push_back(edge);
path2Edges.push_back(reverseEdge);
}
}
//comparar as arestas dos dois caminhos
for(auto & it1: path1Edges)
{
for(auto & it2: path2Edges)
{
if(it1 == it2) return true;
}
}
return false;
}
bool doPathsHaveFrequencyCollision(Path &path1, Path &path2)
{
if(path1.frequency != path2.frequency) return false;
else return doPathsHaveCollision(path1, path2);
}
| [
"lucas.gomes@poli.ufrj.br"
] | lucas.gomes@poli.ufrj.br |
cf21978cc14932f6ca9e473264a120e6993170bd | 1791461e6740f81c2dd6704ae6a899a6707ee6b1 | /Vijos/1906.cpp | e2548cbc668b648f98aac014df9f134c12a95751 | [
"MIT"
] | permissive | HeRaNO/OI-ICPC-Codes | b12569caa94828c4bedda99d88303eb6344f5d6e | 4f542bb921914abd4e2ee7e17d8d93c1c91495e4 | refs/heads/master | 2023-08-06T10:46:32.714133 | 2023-07-26T08:10:44 | 2023-07-26T08:10:44 | 163,658,110 | 22 | 6 | null | null | null | null | UTF-8 | C++ | false | false | 1,162 | cpp | #include <cstdio>
#include <cstring>
#define MAXN 2001000
#define MOD 10007
using namespace std;
struct link
{
int to;
int nxt;
};
link e[2 * MAXN];
int edge_num[MAXN], cnt;
int n, u, v;
int val[MAXN];
int ans, amt;
int dp[MAXN], dp_sum[MAXN];
int mymax(int a, int b)
{
return a > b ? a : b;
}
void add(int u, int v)
{
e[cnt] = (link)
{
v, edge_num[u]
};
edge_num[u] = cnt++;
e[cnt] = (link)
{
u, edge_num[v]
};
edge_num[v] = cnt++;
}
void dfs(int node, int father)
{
dp[node] = dp_sum[node] = 0;
for (int i = edge_num[node]; ~i; i = e[i].nxt)
if (e[i].to != father)
{
dfs(e[i].to, node);
ans = mymax(mymax(ans, val[node] * dp[e[i].to]), val[e[i].to] * dp[node]);
amt = (amt + val[node] * dp_sum[e[i].to] + val[e[i].to] * dp_sum[node]) % MOD;
dp_sum[node] = (dp_sum[node] + val[e[i].to]) % MOD;
dp[node] = mymax(dp[node], val[e[i].to]);
}
}
int main()
{
memset(edge_num, -1, sizeof(edge_num));
scanf("%d", &n);
for (int i = 1; i < n; i++)
{
scanf("%d %d", &u, &v);
add(u, v);
}
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
dfs(1, -1);
amt *= 2;
amt %= MOD;
printf("%d %d\n", ans, amt);
return 0;
} | [
"heran55@126.com"
] | heran55@126.com |
6ae9f980ee7d7552f614ffdab8bbb221015666bb | dd20fdcc226f7cec298546152ac64c14aa4ec9db | /test/firstC.cpp | b0017a5a5b2c222015923938615fd6f42a7d6844 | [] | no_license | jimbo07/openBBlib | e7caed66ce80afe4e2de7c529d3cbe087a231e10 | df1c5a93ab507e8334d78ca79d929d3714ef3b8c | refs/heads/master | 2022-08-22T15:26:23.654354 | 2020-02-06T12:46:28 | 2020-02-06T12:46:28 | 137,645,514 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 136 | cpp | #include <iostream>
i
nt main(int argc, const char * argv[]) {
std::cout << "hello Visual Studio Code! :)" << '\n';
return 0;
} | [
"jimbo.boss.1990@gmail.com"
] | jimbo.boss.1990@gmail.com |
794d9e9040e0a920f5db4cbbc991a7ee2c57de15 | f41d9b72ea80ec3520ee245b95c0c5f140826fd2 | /src/Collider.cpp | 5a03395a926c0154ef44368e2c320416e77c5677 | [] | no_license | cross28/FlappyBird | 0cfc5ff1729815e8aba36a1f1103d666dffcc999 | 6b069ffcd53499b618a47ef30829656b9096ae16 | refs/heads/master | 2021-07-10T19:42:07.404096 | 2020-07-30T03:25:05 | 2020-07-30T03:25:05 | 180,929,664 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,770 | cpp | #include "../include/Collider.h"
Collider::Collider(sf::RectangleShape& body) :
body(body)
{
}
Collider::~Collider()
{
}
bool Collider::checkCollision(Collider& other, sf::Vector2f& direction, float push)
{
sf::Vector2f otherPosition = other.getPosition();
sf::Vector2f otherHalfSize = other.getHalfSize();
sf::Vector2f thisPosition = getPosition();
sf::Vector2f thisHalfSize = getHalfSize();
float deltaX = otherPosition.x - thisPosition.x;
float deltaY = otherPosition.y - thisPosition.y;
float intersectX = abs(deltaX) - (otherHalfSize.x + thisHalfSize.x);
float intersectY = abs(deltaY) - (otherHalfSize.y + thisHalfSize.y);
if (intersectX < 0.0f && intersectY < 0.0f) {
push = std::min(std::max(push, 0.0f), 1.0f);
if (intersectX > intersectY) {
if (deltaX > 0.0f) {
move(intersectX * (1.0f - push), 0.0f);
other.move(-intersectX * push, 0.0f);
direction.x = 1.0f;
direction.y = 0.0f;
} else {
move(-intersectX * (1.0f - push), 0.0f);
other.move(intersectX * push, 0.0f);
direction.x = -1.0f;
direction.y = 0.0f;
}
}
else {
if (deltaY > 0.0f) {
move(0.0f, intersectY * (1.0f - push));
other.move(0.0f, -intersectY * push);
direction.x = 0.0f;
direction.y = 1.0f;
} else {
move(0.0f, -intersectY * (1.0f - push));
other.move(0.0f, intersectY * push);
direction.x = 0.0f;
direction.y = -1.0f;
}
}
return true;
}
return false;
}
| [
"icross@lc.edu"
] | icross@lc.edu |
8d0de4d0776f80ae9acc7f03d40380f55d0191c0 | 012b80a455fd4ed27074bae373217c226ad2dbae | /Reversi/Resersi1/chiose2.h | 59abff429500444611141da7f36d0075b527b42b | [] | no_license | lingyunyun/Reversi | f549eac77edd45907732e8a77fce069da7288603 | 4232eeebb35ca2f7b0833acdd9c832339e0edd97 | refs/heads/master | 2020-08-21T10:49:40.352679 | 2019-10-19T04:23:58 | 2019-10-19T04:23:58 | 216,143,795 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 274 | h | #ifndef CHIOSE2_H
#define CHIOSE2_H
#include <QWidget>
//选择对战模式界面
class chiose2 : public QWidget
{
Q_OBJECT
public:
explicit chiose2(QWidget *parent = nullptr);
signals:
void mysignal2();
public slots:
};
#endif // CHIOSE2_H
| [
"lingyun98765@163.com"
] | lingyun98765@163.com |
ca24a9b3deeb06e38a2d35b2d3739811e4b7ed3c | f5d68814c86415478442b6274ac9dc1fd4480987 | /QtClient/QtClient/SINClass.h | 642c765a12b98018da09da8f96370f04d48bcf9f | [] | no_license | StanCostin/SCDCA | 877916fc814b38d294a7e7c3fb1b417ef61ef4b2 | 8d3b67d81f5628d63bffdbe514720f1e7399557c | refs/heads/master | 2023-04-17T20:10:36.661324 | 2021-04-28T09:41:14 | 2021-04-28T09:41:14 | 362,410,743 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 318 | h | #pragma once
#include <QWidget>
#include "ui_SINClass.h"
#include "Client.h"
class SINClass : public QWidget, public Ui::SINClass
{
Q_OBJECT
public:
SINClass(Client *client, QWidget *parent = Q_NULLPTR);
~SINClass();
Client *CLIENT;
private:
Ui::SINClass ui;
private slots:
void button();
};
| [
"adrian.costin41@yahoo.com"
] | adrian.costin41@yahoo.com |
5c322b739eeb69e653ef9ae27ed91aa382acb0ed | 10fa6f7a5a1b3e678f76929b5a62e2c72f61bd1f | /XianLGame/Classes/GameTable/ErMahjong/ErMahjongGameTableUICallback.h | dafcf6911fcad26ffef20de6ed549aaede15e756 | [
"MIT"
] | permissive | aexleader/XianLaiGame | bb7f7442ed686e6b6e4fdeda619b1459ad988cc8 | 554359aca125cb1aee8f87ebbf99f479e040c351 | refs/heads/master | 2020-07-31T21:28:07.054742 | 2017-03-14T03:12:23 | 2017-03-14T03:12:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,885 | h | #ifndef __ErMahjong_Game_Table_UI_Callback_H__
#define __ErMahjong_Game_Table_UI_Callback_H__
#include "YZNetExport.h"
#include "ErMahjongMessageHead.h"
namespace ErMahjong
{
class GameTableUICallback
{
public:
virtual void addUser(BYTE seatNo, bool bMe) = 0;
virtual void removeUser(BYTE seatNo, bool bMe) = 0;
virtual void setUserName(BYTE seatNo, const std::string& name) = 0;
virtual void showUserMoney(BYTE seatNo, bool visible) = 0;
virtual void setUserMoney(BYTE seatNo, INT money) = 0;
virtual void setUserHead(BYTE seatNo) = 0;
virtual void showUserReady(BYTE seatNo,bool visible) = 0;
virtual void setBanker(BYTE seatNo,bool visible)=0;
virtual void showTingCard(BYTE seatNo,bool visible)=0;
virtual void showReadyBtn( bool visible)=0;
virtual void showActionBtn(BYTE seatNo ,BYTE actionWik , BYTE card)=0;
virtual void showActionCard(MJActionData data,ActionType actionType) = 0;
virtual void showMahjongLayout(BYTE card , bool visible) = 0;
virtual void setTureCaiShenCard(BYTE card) = 0;
virtual void setWaitTime(BYTE seatNo, BYTE time, bool visible,int statues)=0;
virtual void showAutoOutCardBtn(bool visible) = 0;
virtual void setAutoOutCardBtn(bool visible) = 0;
virtual void showCAutoOutCardBtn(bool visible) = 0;
virtual void setUpCardList(BYTE seatNo, const std::vector<BYTE>& upCards) = 0;
virtual void getUpCardList(BYTE seatNo, std::vector<BYTE>* upCards) = 0;
virtual void showBtnType(int actCount,BYTE statues)=0;
virtual void hideBtnType()=0;
virtual void setChiPaiLayout(int type,BYTE cardValues)=0;
//virtual void showUserReslutInfor(bool iWin,BYTE seatNo,bool iBanker,char name[61],LLONG iDiFen,int iLianZhuang,WzType wzType,WzHuType wzHuType, tagMaiDing::MdInfo iDiPoint,LLONG iTotalPoint)=0;
virtual void showThinkAct(int type)=0;
virtual void showActionResult(USHORT type,BYTE count,BYTE cardValues,bool iVisible)=0;
virtual void showOutCard(BYTE seatNo,BYTE cardValues)=0;
virtual void showUserHandCard(BYTE seatNo, const std::vector<BYTE> values)=0;
virtual void showUserHandCardOut(BYTE seatNo)=0;
virtual void showUserVoice(BYTE seatNo, std::string voiceName , int voiceTime) =0;
virtual void onGameDisConnected()=0;
virtual void showPlayerGetCard(BYTE seatNo , BYTE value) = 0;
virtual void setGameBanker(BYTE seatNo) = 0;
virtual void showUserAskDisbandRoom(bool isShow) = 0;
virtual void setGamePlayerPoint(BYTE seatNo) = 0; //设置游戏的庄家
virtual void setGameZMCount(int zmCount) = 0; //设置游戏的扎码数
virtual void outCardResultError(BYTE seatNo) = 0;
virtual void showAllUserCard(BYTE seatNo,std::vector<BYTE> values , BYTE bankerCard) = 0;
virtual void playerBackGame(BackGameData data)= 0;
virtual void showGameEnd() = 0;
virtual void clearDesk() = 0;
virtual void leaveDesk() = 0;
virtual void showUserTrustee(BYTE seatNo , bool bTrustee)=0;
virtual void isLastGame(int nowGameCount , int totalGameCount) = 0;
virtual void doGameEndResp(MJGameEndData data , std::map<BYTE, std::vector<BYTE>> actionCardInfoMap , std::map<BYTE , std::vector<BYTE>> cardInfoMap) = 0;
virtual void showListenerCard(bool isShow, std::vector<BYTE> cards) = 0;
//=================================================//
virtual void showGameShaiZi(BYTE cbSiceCount[2])=0;
virtual void showUserChatFaceAnimate(BYTE seatNo, int _faceId) = 0;
virtual void showUserChatTalkMsg(BYTE seatNo, std::string msg) = 0;
virtual BYTE getPlayerGuangCard(BYTE seatNO) = 0;
};
}
#endif | [
"xialiguo@aliyun.com"
] | xialiguo@aliyun.com |
0e8fb92b9fa409d6e64be16042f94a6c65c2c9e7 | 2610560ec784f56e08b24e5591230d41c79ee012 | /zpc/helper.hpp | 3b639a9660e8388cf5443a654037c976a283315f | [] | no_license | zerolfx/small-compiler | 184c1113983229b0d54a1a8a96d7d6055a88eb2a | b106559b27d438e6795a056576d8ed15a0c73e19 | refs/heads/main | 2023-01-21T11:02:27.059745 | 2020-11-23T12:56:51 | 2020-11-23T12:56:51 | 311,884,561 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 118 | hpp | #ifndef ZPC_HELPER_HPP
#define ZPC_HELPER_HPP
#include <utility>
#include "parser.hpp"
#endif //ZPC_HELPER_HPP
| [
"fangxin.lin@tusimple.ai"
] | fangxin.lin@tusimple.ai |
bdc54d2917a5da202b72a361962a331ba563ad63 | baf160e8fc1b76d02a5db1d184cc35e4182a7b41 | /include/openmp.hpp | b15e9408cb64e593abe99954b0676635b7695c73 | [] | no_license | SoftwareOutlook/GPU | ffdd17fd599174b3403be2559936ac50810cb83b | ed790868473ff116449dcd75a087382c3cc21bb9 | refs/heads/master | 2020-04-16T14:55:49.659806 | 2019-06-21T14:03:13 | 2019-06-21T14:03:13 | 165,684,923 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 654 | hpp | #ifndef OPENMP_HPP
#define OPENMP_HPP
#include <multiarray.hpp>
#include <omp.h>
template <class T, class U, class V> int openmp_product_cpu(const multiarray<T>& a, const multiarray<U>& b, multiarray<V>& ab){
#pragma omp parallel for
for(typename multiarray<T>::size_t i; i<a.size(); ++i){
ab.set(i, a.get(i)*b.get(i));
}
return 0;
}
template<class T, class U, class V> void openmp_product_gpu(const multiarray<T>& a, const multiarray<U>& b, multiarray<V>& ab){
#pragma omp target map(to:a, b) map(from:ab)
#pragma omp teams distribute parallel for simd
for(size_t i=0; i<a.size(); ++i){
ab.set(i, a.get(i)*b.get(i));
}
}
#endif
| [
"philippe.gambron@stfc.ac.uk"
] | philippe.gambron@stfc.ac.uk |
bcdcd5dbaf5fa2172a9456deacbd63c62fd87aae | 1de331d068456cedbd2a5b4d4a6b16145646f97d | /src/libv/algo/pack_rect_bin.hpp | c21098a5d9a5c5724935853bc42f3a232b38b638 | [
"Zlib"
] | permissive | sheerluck/libv | ed37015aeeb49ea8504d7b3aa48a69bde754708f | 293e382f459f0acbc540de8ef6283782b38d2e63 | refs/heads/master | 2023-05-26T01:18:50.817268 | 2021-04-18T01:06:51 | 2021-04-27T03:20:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,489 | hpp | // Project: libv.algo, File: src/libv/algo/pack_rect_bin.hpp, Author: Császár Mátyás [Vader]
#pragma once
// libv
#include <libv/math/vec.hpp>
// std
#include <memory>
// =================================================================================================
//
// Source: https://blackpawn.com/texts/lightmaps/
// Original implementation: https://github.com/juj/RectangleBinPack/tree/master/old
// For more information, see
// - Rectangle packing: http://www.gamedev.net/community/forums/topic.asp?topic_id=392413
// - Packing lightmaps: http://www.blackpawn.com/texts/lightmaps/default.html
//
// TODO P3: Adopt and implement better packing algorithms https://github.com/juj/RectangleBinPack
//
// =================================================================================================
namespace libv {
// -------------------------------------------------------------------------------------------------
// Performs 'discrete online rectangle packing into a rectangular bin' by maintaining
// a binary tree of used and free rectangles of the bin. There are several variants
// of bin packing problems, and this packer is characterized by:
// - We're solving the 'online' version of the problem, which means that when we're adding
// a rectangle, we have no information of the sizes of the rectangles that are going to
// be packed after this one.
// - We are packing rectangles that are not rotated. I.e. the algorithm will not flip
// a rectangle of (w,h) to be stored if it were a rectangle of size (h, w). There is no
// restriction conserning UV mapping why this couldn't be done to achieve better
// occupancy, but it's more work. Feel free to try it out.
// - The packing is done in discrete integer coordinates and not in rational/real numbers (floats).
// Internal memory usage is linear to the number of rectangles we've already packed.
//
// Idea: Instead of just picking the first free rectangle to insert the new rect into,
// check all free ones (or maintain a sorted order) and pick the one that minimizes
// the resulting leftover area. There is no real reason to maintain a tree - in fact
// it's just redundant structuring. We could as well have two lists - one for free
// rectangles and one for used rectangles. This method would be faster and might
// even achieve a considerably better occupancy rate.
class pack_rect_bin {
private:
/// A node of a binary tree. Each node represents a rectangular area of the texture
/// we surface. Internal nodes store rectangles of used data, whereas leaf nodes track
/// rectangles of free space. All the rectangles stored in the tree are disjoint.
struct Node {
std::unique_ptr<Node> left;
std::unique_ptr<Node> right;
libv::vec2i position;
libv::vec2i size;
};
private:
Node root;
libv::vec2i bin_size; /// The total size of the bin we started with.
public:
/// Starts a new packing process to a bin of the given dimension.
[[nodiscard]] explicit pack_rect_bin(libv::vec2i size) noexcept;
[[nodiscard]] inline pack_rect_bin(int32_t width, int32_t height) noexcept :
pack_rect_bin(libv::vec2i(width, height)) {}
/// Inserts a new rectangle of the given size into the bin.
/// Running time is linear to the number of rectangles that have been already packed.
/// @return A pointer to the node that stores the newly added rectangle, or nullptr if it didn't fit.
[[nodiscard]] inline Node* insert(int32_t width, int32_t height) {
return insert(root, width, height);
}
[[nodiscard]] inline Node* insert(libv::vec2i size) {
return insert(root, size.x, size.y);
}
[[nodiscard]] inline size_t used_area() const {
return used_area(root);
}
[[nodiscard]] inline size_t total_area() const {
return bin_size.x * bin_size.y;
}
/// Computes the ratio of used surface area.
/// @return A value [0, 1] denoting the ratio of total surface area that is in use.
/// 0.0f - the bin is totally empty, 1.0f - the bin is full.
[[nodiscard]] inline float occupancy() const {
return static_cast<float>(used_area()) / static_cast<float>(total_area());
}
private:
/// @return The surface area used by the subtree rooted at node.
[[nodiscard]] size_t used_area(const Node& node) const;
/// Inserts a new rectangle in the subtree rooted at the given node.
Node* insert(Node& node, int32_t width, int32_t height);
};
// -------------------------------------------------------------------------------------------------
} // namespace libv
| [
"vaderhun@gmail.com"
] | vaderhun@gmail.com |
3d1d5a3f1f5d73becd5b4c457cf5cef1be95cfd3 | e5f4bfe7041a45590ef83260b36cb8704b5bd427 | /mareks del/Programering/PlatformProjekt/Source/Player.cpp | e851d6a95331bcb35db6fb97df56ff3254f4d94a | [] | no_license | luben93/Projektkursen1 | c25fdbb768f084412111a86c243179b464f60249 | 84b83ae2c05a565c5a527e0fe5396ccdc3aca18c | refs/heads/master | 2021-01-25T06:36:52.144016 | 2013-04-25T09:47:11 | 2013-04-25T09:47:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,104 | cpp | #include "Player.h"
#include <GL/gl.h>
float Player::getX(void)
{
return x;
}
float Player::getY(void)
{
return y;
}
void Player::stop(void)
{
movingLeft = false;
movingRight = false;
}
void Player::moveLeft(void)
{
movingLeft = true;
}
void Player::moveRight(void)
{
movingRight = true;
}
void Player::setSpeed(float speed)
{
this->speed = speed;
}
void Player::jump(void)
{
if(canJump && standing)
{
jumping = true;
standing = false;
}
}
void Player::collisionWithFloor(int collision_y)
{
canJump = true;
standing = true;
y = collision_y+0.01f;
}
void Player::update()
{
if(movingLeft)
x -= speed;
if(movingRight)
x += speed;
y += gravity/100.0f;
if(standing)
gravity = 0.0f;
if(jumping)
{
gravity = 20.0f;
jumping = false;
}
if(gravity > -20.0f && !standing)
gravity -= 0.3f;
}
void Player::draw()
{
glBegin(GL_QUADS);
glVertex3f(0.0f+x, 0.0f+y, 0.0f);
glVertex3f(1.0f+x, 0.0f+y, 0.0f);
glVertex3f(1.0f+x, 1.0f+y, 0.0f);
glVertex3f(0.0f+x, 1.0f+y, 0.0f);
glEnd();
} | [
"luben93@gmail.com"
] | luben93@gmail.com |
eace330aa23a383cee6b642a0765a62acecabcc7 | e383b5c3dd2cd69595ae6bb47b8a951dceb9b737 | /src/instruction/sra.cpp | c289c3b1433b12a0b3eb5799004642afda08fe2f | [] | no_license | syouhei2/felis-simulator | d1f0e8c89e5ac02d045551131ffddc07fa9306ad | 1769bd5618c6845eec197247c8c4d7c505dfd2c6 | refs/heads/master | 2021-05-04T01:12:53.585886 | 2016-10-17T15:54:54 | 2016-10-17T15:54:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 322 | cpp | #include "simulator.hpp"
Simulator::State Simulator::sra(Instruction inst, StateIter state_iter)
{
auto now_state = *state_iter;
auto new_state = now_state;
auto op = decodeR(inst);
new_state.pc += 4;
new_state.reg.at(op.rd) = signExt5(now_state.reg.at(op.rs)) >> op.shamt;
return new_state;
}
| [
"hdht.ybuc@gmail.com"
] | hdht.ybuc@gmail.com |
45709e07519359c302d56fb6307ceea6c1206600 | e50b5f066628ef65fd7f79078b4b1088f9d11e87 | /llvm/tools/clang/test/Modules/Inputs/submodules/hash_map.h | d63e1fe87e2c4bc2263252bcb86b65ec06146c10 | [
"NCSA"
] | permissive | uzleo/coast | 1471e03b2a1ffc9883392bf80711e6159917dca1 | 04bd688ac9a18d2327c59ea0c90f72e9b49df0f4 | refs/heads/master | 2020-05-16T11:46:24.870750 | 2019-04-23T13:57:53 | 2019-04-23T13:57:53 | 183,025,687 | 0 | 0 | null | 2019-04-23T13:52:28 | 2019-04-23T13:52:27 | null | UTF-8 | C++ | false | false | 86 | h | template<typename Key, typename Data> class hash_map { };
#define HAVE_HASH_MAP
| [
"jeffrey.goeders@gmail.com"
] | jeffrey.goeders@gmail.com |
34896f39cfeec17334912eebeae1d0bf38e437c2 | 6f90fcb6e3769225fd0a0fb78b8f7347b9f9ca05 | /examples_oldgl_glfw/609_DefLaplacian/main.cpp | 913228ee2f0bb4a31e82815bc3665a3bf446e4ff | [
"MIT"
] | permissive | huminzheng/delfem2 | 3fd759c49e427d1a0c46d7a24bf2f2f449df9b4b | 8ca4923a7a9abb6f264d7bf364304c0730b47636 | refs/heads/master | 2023-02-17T22:33:33.346479 | 2021-01-17T05:47:58 | 2021-01-17T05:47:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,481 | cpp | /*
* Copyright (c) 2020 Nobuyuki Umetani
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include "delfem2/opengl/glfw/viewer_glfw.h"
#include "delfem2/opengl/old/funcs.h"
#include "delfem2/opengl/old/mshuni.h"
#include "delfem2/deflap.h"
#include "delfem2/mat4.h"
#include "delfem2/mshmisc.h"
#include "delfem2/mshprimitive.h"
#include <GLFW/glfw3.h>
#include <cmath>
namespace dfm2 = delfem2;
// --------------------------------------------------
void SetPositionAtFixedBoundary(
std::vector<double>& aRhs,
unsigned int iframe,
const std::vector<double>& aXYZ0,
const std::vector<int>& aBCFlag)
{
double A[16];
{
dfm2::Mat4_Identity(A);
const double trans0[3] = {0, -0.8, 0};
dfm2::Translate_Mat4Affine(A,
trans0);
const double axis0[3] = {0, +2.0*sin(0.03*iframe), 1.0*sin(0.07*iframe)};
dfm2::Rotate_Mat4AffineRodriguez(A,
axis0);
const double trans1[3] = {0.2*sin(0.03*iframe), +0.6+0.2*cos(0.05*iframe), 0};
dfm2::Translate_Mat4Affine(A,
trans1);
}
const unsigned int np = aRhs.size()/3;
for(unsigned int ip=0;ip<np;++ip){
if( aBCFlag[ip*3+0] == 0 ){ continue; }
if( aBCFlag[ip*3+0] == 1 ){
aRhs[ip*3+0] = aXYZ0[ip*3+0];
aRhs[ip*3+1] = aXYZ0[ip*3+1];
aRhs[ip*3+2] = aXYZ0[ip*3+2];
}
if( aBCFlag[ip*3+0] == 2 ) {
dfm2::Vec3_Mat4Vec3_AffineProjection(aRhs.data()+ip*3, A, aXYZ0.data()+ip*3);
}
}
}
// ==================================
void myGlutDisplay(
const std::vector<double>& aXYZ0,
const std::vector<double>& aXYZ1,
const std::vector<unsigned int>& aTri,
const std::vector<int>& aBCFlag)
{
::glDisable(GL_LIGHTING);
::glColor3d(1,0,0);
dfm2::opengl::DrawMeshTri3D_FaceNorm(aXYZ1,aTri);
::glColor3d(0.8,0.8,0.8);
dfm2::opengl::DrawMeshTri3D_Edge(aXYZ0.data(),aXYZ0.size()/3,
aTri.data(),aTri.size()/3);
::glColor3d(0,0,0);
dfm2::opengl::DrawMeshTri3D_Edge(aXYZ1.data(),aXYZ1.size()/3,
aTri.data(),aTri.size()/3);
{ // draw bc as a point
::glPointSize(10);
::glBegin(GL_POINTS);
for(unsigned int ip=0;ip<aXYZ0.size()/3;++ip){
if( aBCFlag[ip*3+0] == 0 ){ continue; }
if( aBCFlag[ip*3+0] == 1 ){ ::glColor3d(0,0,1); }
if( aBCFlag[ip*3+0] == 2 ){ ::glColor3d(0,1,0); }
::glVertex3dv(aXYZ1.data()+ip*3);
}
::glEnd();
}
}
int main(int argc,char* argv[])
{
std::vector<int> aBCFlag;
std::vector<unsigned int> aTri;
std::vector<double> aXYZ0;
{ // set problem
dfm2::MeshTri3D_CylinderClosed(aXYZ0, aTri,
0.2, 1.6,
24, 24);
aBCFlag.assign(aXYZ0.size(), 0);
for(unsigned int ip=0;ip<aXYZ0.size()/3;++ip) {
double y0 = aXYZ0[ip*3+1];
if( y0 < -0.65 ){
aBCFlag[ip*3+0] = 1;
aBCFlag[ip*3+1] = 1;
aBCFlag[ip*3+2] = 1;
}
if( y0 > +0.65 ){
aBCFlag[ip*3+0] = 2;
aBCFlag[ip*3+1] = 2;
aBCFlag[ip*3+2] = 2;
}
}
}
std::vector<double> aXYZ1 = aXYZ0;
// ------------------------
dfm2::opengl::CViewer_GLFW viewer;
viewer.Init_oldGL();
viewer.camera.view_height = 1.0;
viewer.camera.camera_rot_mode = delfem2::CCam3_OnAxisZplusLookOrigin<double>::CAMERA_ROT_MODE::TBALL;
delfem2::opengl::setSomeLighting();
for(unsigned int itr=0;itr<3;++itr)
{
int iframe = 0;
{
glfwSetWindowTitle(viewer.window, "(1) Def_LaplacianLinearDegenrate without preconditioner");
dfm2::CDef_LaplacianLinearDegenerate def;
def.Init(aXYZ0, aTri, false);
def.aBCFlag = aBCFlag;
for(;iframe<100;++iframe){
SetPositionAtFixedBoundary(aXYZ1,
iframe, aXYZ0, aBCFlag);
def.Deform(aXYZ1,
aXYZ0);
std::cout << " laplacian linear degenerate without preconditioner : " << def.aConvHist.size() << std::endl;
// -----
viewer.DrawBegin_oldGL();
myGlutDisplay(aXYZ0,aXYZ1,aTri,aBCFlag);
viewer.SwapBuffers();
glfwPollEvents();
viewer.ExitIfClosed();
}
}
{
glfwSetWindowTitle(viewer.window, "(2) Def_LaplacianLinearDegenrate with preconditioner");
dfm2::CDef_LaplacianLinearDegenerate def;
def.Init(aXYZ0, aTri, true);
def.aBCFlag = aBCFlag;
def.SetBoundaryConditionToPreconditioner();
for(;iframe<200;++iframe){
SetPositionAtFixedBoundary(aXYZ1,
iframe, aXYZ0, aBCFlag);
def.Deform(aXYZ1,
aXYZ0);
std::cout << " laplacian linear degenerate with preconditioner: " << def.aConvHist.size() << std::endl;
// -----
viewer.DrawBegin_oldGL();
myGlutDisplay(aXYZ0,aXYZ1,aTri,aBCFlag);
viewer.SwapBuffers();
glfwPollEvents();
viewer.ExitIfClosed();
}
}
{
glfwSetWindowTitle(viewer.window, "(3) Def_LaplacianLinearGram without Preconditioner");
dfm2::CDef_LaplacianLinearGram def;
def.Init(aXYZ0, aTri, false);
def.aBCFlag = aBCFlag;
for(;iframe<300;++iframe){
SetPositionAtFixedBoundary(aXYZ1,
iframe, aXYZ0, aBCFlag);
def.Deform(aXYZ1,
aXYZ0);
std::cout << " cg nitr:" << def.aConvHist.size() << std::endl;
// -------
viewer.DrawBegin_oldGL();
myGlutDisplay(aXYZ0,aXYZ1,aTri,aBCFlag);
viewer.SwapBuffers();
glfwPollEvents();
viewer.ExitIfClosed();
}
}
{
dfm2::CDef_LaplacianLinearGram def;
def.Init(aXYZ0, aTri, true);
def.aBCFlag = aBCFlag;
def.SetBoundaryConditionToPreconditioner();
glfwSetWindowTitle(viewer.window, "(4) Def_LaplacianLinearGram with Preconditioner");
for(;iframe<400;++iframe){
SetPositionAtFixedBoundary(
aXYZ1,
iframe, aXYZ0, aBCFlag);
def.Deform(
aXYZ1,
aXYZ0);
std::cout << " pcg nitr:" << def.aConvHist.size() << std::endl;
// -------
viewer.DrawBegin_oldGL();
myGlutDisplay(aXYZ0,aXYZ1,aTri,aBCFlag);
viewer.SwapBuffers();
glfwPollEvents();
viewer.ExitIfClosed();
}
}
{
glfwSetWindowTitle(viewer.window, "(5) Def_LaplacianLinear without Preconditioner");
dfm2::CDef_LaplacianLinear def;
def.Init(aXYZ0, aTri, false);
def.aBCFlag = aBCFlag;
def.SetValueToPreconditioner();
for(;iframe<500;++iframe){
SetPositionAtFixedBoundary(
aXYZ1,
iframe, aXYZ0, aBCFlag);
def.Deform(
aXYZ1,
aXYZ0);
std::cout << " cg nitr:" << def.aConvHist.size() << std::endl;
// -------
viewer.DrawBegin_oldGL();
myGlutDisplay(aXYZ0,aXYZ1,aTri,aBCFlag);
viewer.SwapBuffers();
glfwPollEvents();
viewer.ExitIfClosed();
}
}
{
glfwSetWindowTitle(viewer.window, "(6) Def_LaplacianLinear with Preconditioner");
dfm2::CDef_LaplacianLinear def;
def.Init(aXYZ0, aTri, true);
def.aBCFlag = aBCFlag;
def.SetValueToPreconditioner();
for(;iframe<600;++iframe){
SetPositionAtFixedBoundary(
aXYZ1,
iframe, aXYZ0, aBCFlag);
def.Deform(
aXYZ1,
aXYZ0);
std::cout << " pcg nitr:" << def.aConvHist.size() << std::endl;
// -------
viewer.DrawBegin_oldGL();
myGlutDisplay(aXYZ0,aXYZ1,aTri,aBCFlag);
viewer.SwapBuffers();
glfwPollEvents();
viewer.ExitIfClosed();
}
}
{
glfwSetWindowTitle(viewer.window, "(7) Direct Constraint");
dfm2::CDef_LaplacianLinearAsym def;
def.Init(aXYZ0, aTri);
for(;iframe<700;++iframe){
SetPositionAtFixedBoundary(aXYZ1,
iframe, aXYZ0, aBCFlag);
def.Deform(aXYZ1,
aXYZ0, aBCFlag);
std::cout << " bicgstab" << def.aHistConv.size() << std::endl;
// -----
viewer.DrawBegin_oldGL();
myGlutDisplay(aXYZ0,aXYZ1,aTri,aBCFlag);
viewer.SwapBuffers();
glfwPollEvents();
viewer.ExitIfClosed();
}
}
}
}
| [
"n.umetani@gmail.com"
] | n.umetani@gmail.com |
d18e66fffac33611ca6f1c384a7851d4fd62e64e | 0570750c6d8e28d837f9e4f7dc825c968c874fb4 | /build/Android/Preview1/app/src/main/include/Fuse.Text.Edit.CaretContext.h | 26b0667821037609b1ac3ece3e7f914430f44791 | [] | no_license | theaustinthompson/maryjane | b3671d950aad58fd2ed490bda8aa1113aedf5a97 | b4ddf76aa2a2caae77765435d0315cf9111d6626 | refs/heads/master | 2021-04-12T08:37:47.311922 | 2018-03-27T23:06:47 | 2018-03-27T23:06:47 | 126,034,050 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,266 | h | // This file was generated based on C:/Users/borde_000/AppData/Local/Fusetools/Packages/Fuse.Text/1.8.1/Edit.uno.
// WARNING: Changes might be lost if you edit this file directly.
#pragma once
#include <Fuse.Text.Edit.Caret.h>
#include <Uno.Object.h>
namespace g{namespace Fuse{namespace Text{namespace Edit{struct CaretContext;}}}}
namespace g{namespace Fuse{namespace Text{struct PositionedRun;}}}
namespace g{namespace Uno{namespace Collections{struct List;}}}
namespace g{namespace Uno{struct Float2;}}
namespace g{namespace Uno{struct Rect;}}
namespace g{
namespace Fuse{
namespace Text{
namespace Edit{
// public struct CaretContext :25
// {
uStructType* CaretContext_typeof();
void CaretContext__ctor__fn(CaretContext* __this, ::g::Uno::Collections::List* pruns, uString* source);
void CaretContext__Backspace_fn(CaretContext* __this, int32_t* i, uString** __retval);
void CaretContext__Clamp_fn(CaretContext* __this, int32_t* i, int32_t* __retval);
void CaretContext__ClosestCaretOnLine_fn(CaretContext* __this, ::g::Uno::Float2* pos, int32_t* desiredLine, int32_t* def, int32_t* __retval);
void CaretContext__Delete_fn(CaretContext* __this, int32_t* i, uString** __retval);
void CaretContext__DeleteSpan_fn(CaretContext* __this, int32_t* start, int32_t* caret, uString** __retval);
void CaretContext__GetClosest_fn(CaretContext* __this, ::g::Uno::Float2* pos, float* lineHeight, int32_t* __retval);
void CaretContext__GetVisualPosition_fn(CaretContext* __this, int32_t* i, ::g::Uno::Float2* __retval);
void CaretContext__GetVisualRects_fn(CaretContext* __this, int32_t* i1, int32_t* i2, float* lineHeight, ::g::Uno::Collections::List** __retval);
void CaretContext__Insert_fn(CaretContext* __this, char16_t* c, int32_t* i, uString** __retval);
void CaretContext__LeftMost_fn(CaretContext* __this, int32_t* __retval);
void CaretContext__LeftToRight_fn(CaretContext* __this, int32_t* i, bool* __retval);
void CaretContext__LerpClustersLTR_fn(uString* source, int32_t* cluster1, ::g::Uno::Float2* pos1, int32_t* cluster2, ::g::Uno::Float2* pos2, int32_t* lineIndex, int32_t* runIndex, ::g::Uno::Collections::List* result);
void CaretContext__LerpClustersRTL_fn(uString* source, int32_t* cluster1, ::g::Uno::Float2* pos1, int32_t* cluster2, ::g::Uno::Float2* pos2, int32_t* lineIndex, int32_t* runIndex, ::g::Uno::Collections::List* result);
void CaretContext__MoveDown_fn(CaretContext* __this, int32_t* currentIndex, int32_t* __retval);
void CaretContext__MoveLeft_fn(CaretContext* __this, int32_t* i, int32_t* __retval);
void CaretContext__MoveRight_fn(CaretContext* __this, int32_t* i, int32_t* __retval);
void CaretContext__MoveUp_fn(CaretContext* __this, int32_t* currentIndex, int32_t* __retval);
void CaretContext__New1_fn(::g::Uno::Collections::List* pruns, uString* source, CaretContext* __retval);
void CaretContext__PossibleCaretPositions_fn(::g::Uno::Collections::List* lines, uString* source, ::g::Uno::Collections::List** __retval);
void CaretContext__RightMost_fn(CaretContext* __this, int32_t* __retval);
void CaretContext__SquaredDist_fn(::g::Uno::Float2* p, ::g::Uno::Float2* q, float* __retval);
void CaretContext__StringRangeLength_fn(uString* source, int32_t* cluster1, int32_t* cluster2, int32_t* __retval);
void CaretContext__WeightedSquaredDist_fn(::g::Uno::Float2* p, ::g::Uno::Float2* q, float* yweight, float* __retval);
struct CaretContext
{
uStrong< ::g::Uno::Collections::List*> _runs;
uStrong<uString*> _source;
uStrong< ::g::Uno::Collections::List*> _carets;
uStrong<uArray*> _runIndices;
void ctor_(::g::Uno::Collections::List* pruns, uString* source);
uString* Backspace(int32_t* i);
int32_t Clamp(int32_t i);
int32_t ClosestCaretOnLine(::g::Uno::Float2 pos, int32_t desiredLine, int32_t def);
uString* Delete(int32_t* i);
uString* DeleteSpan(int32_t start, int32_t* caret);
int32_t GetClosest(::g::Uno::Float2 pos, float lineHeight);
::g::Uno::Float2 GetVisualPosition(int32_t i);
::g::Uno::Collections::List* GetVisualRects(int32_t i1, int32_t i2, float lineHeight);
uString* Insert(char16_t c, int32_t* i);
int32_t LeftMost();
bool LeftToRight(int32_t i);
int32_t MoveDown(int32_t currentIndex);
int32_t MoveLeft(int32_t i);
int32_t MoveRight(int32_t i);
int32_t MoveUp(int32_t currentIndex);
int32_t RightMost();
static ::g::Uno::Collections::List* PossibleCaretPositions(::g::Uno::Collections::List* lines, uString* source);
static int32_t StringRangeLength(uString* source, int32_t cluster1, int32_t cluster2);
};
void CaretContext__LerpClustersLTR(uString* source, int32_t cluster1, ::g::Uno::Float2 pos1, int32_t cluster2, ::g::Uno::Float2 pos2, int32_t lineIndex, int32_t runIndex, ::g::Uno::Collections::List* result);
void CaretContext__LerpClustersRTL(uString* source, int32_t cluster1, ::g::Uno::Float2 pos1, int32_t cluster2, ::g::Uno::Float2 pos2, int32_t lineIndex, int32_t runIndex, ::g::Uno::Collections::List* result);
CaretContext CaretContext__New1(::g::Uno::Collections::List* pruns, uString* source);
float CaretContext__SquaredDist(::g::Uno::Float2 p, ::g::Uno::Float2 q);
float CaretContext__WeightedSquaredDist(::g::Uno::Float2 p, ::g::Uno::Float2 q, float yweight);
// }
}}}} // ::g::Fuse::Text::Edit
| [
"austin@believeinthompson.com"
] | austin@believeinthompson.com |
8526f1974dd120286bdf57f5428a4e4448d76313 | 5bc04daeef5284871264a7446aadf7552ec0d195 | /lib/percy/cryptominisat/src/compfinder.cpp | 007af23276305764e4c36b5e51d3e3a4b4a45bf0 | [
"MIT",
"GPL-1.0-or-later",
"GPL-2.0-only"
] | permissive | Ace-Ma/LSOracle | a8fd7efe8927f8154ea37407bac727e409098ed5 | 6e940906303ef6c2c6b96352f44206567fdd50d3 | refs/heads/master | 2020-07-23T15:36:18.224385 | 2019-08-16T15:58:33 | 2019-08-16T15:58:33 | 207,612,130 | 0 | 0 | MIT | 2019-09-10T16:42:43 | 2019-09-10T16:42:43 | null | UTF-8 | C++ | false | false | 9,194 | cpp | /******************************************
Copyright (c) 2016, Mate Soos
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 <set>
#include <map>
#include <iomanip>
#include <iostream>
#include "compfinder.h"
#include "time_mem.h"
#include "cloffset.h"
#include "solver.h"
#include "varreplacer.h"
#include "clausecleaner.h"
#include "clauseallocator.h"
#include "sqlstats.h"
using namespace CMSat;
using std::set;
using std::map;
using std::cout;
using std::endl;
//#define VERBOSE_DEBUG
//#define PART_FINDING
CompFinder::CompFinder(Solver* _solver) :
timedout(false)
, seen(_solver->seen)
, solver(_solver)
{
}
void CompFinder::print_found_components() const
{
size_t notPrinted = 0;
size_t totalSmallSize = 0;
size_t i = 0;
size_t print_limit = 300;
for(map<uint32_t, vector<uint32_t> >::const_iterator
it = reverseTable.begin(), end = reverseTable.end()
; it != end
; ++it, i++
) {
if (it->second.size() < print_limit || solver->conf.verbosity >= 3) {
totalSmallSize += it->second.size();
notPrinted++;
} else {
cout
<< "c [comp] large component " << std::setw(5) << i
<< " size: " << std::setw(10) << it->second.size()
<< endl;
}
}
if (solver->conf.verbosity < 3 && notPrinted > 0) {
cout
<< "c [comp] Unprinted small (<" << print_limit << " var) components:" << notPrinted
<< " vars: " << totalSmallSize
<< endl;
}
}
bool CompFinder::reverse_table_is_correct() const
{
for (map<uint32_t, vector<uint32_t> >::const_iterator
it = reverseTable.begin()
; it != reverseTable.end()
; ++it
) {
for (size_t i2 = 0; i2 < it->second.size(); i2++) {
assert(table[(it->second)[i2]] == it->first);
}
}
return true;
}
void CompFinder::find_components()
{
assert(solver->okay());
const double myTime = cpuTime();
table.clear();
table.resize(solver->nVars(), std::numeric_limits<uint32_t>::max());
reverseTable.clear();
comp_no = 0;
used_comp_no = 0;
solver->clauseCleaner->remove_and_clean_all();
//Add the clauses to the sets
bogoprops_remain =
solver->conf.comp_find_time_limitM*1000ULL*1000ULL
*solver->conf.global_timeout_multiplier;
orig_bogoprops = bogoprops_remain;
timedout = false;
add_clauses_to_component(solver->longIrredCls);
addToCompImplicits();
if (timedout) {
reverseTable.clear();
}
print_and_add_to_sql_result(myTime);
assert(solver->okay());
}
void CompFinder::print_and_add_to_sql_result(const double myTime) const
{
const double time_used = cpuTime() - myTime;
const double time_remain = float_div(bogoprops_remain, orig_bogoprops);
assert(reverse_table_is_correct());
if (solver->conf.verbosity) {
cout
<< "c [comp] Found component(s): " << reverseTable.size()
<< " BP: "
<< std::setprecision(2) << std::fixed
<< (double)(orig_bogoprops-bogoprops_remain)/(1000.0*1000.0)<< "M"
<< solver->conf.print_times(time_used, timedout, time_remain)
<< endl;
if (reverseTable.size() > 1) {
print_found_components();
}
}
if (solver->sqlStats) {
solver->sqlStats->time_passed(
solver
, "compfinder"
, time_used
, timedout
, time_remain
);
}
}
void CompFinder::add_clauses_to_component(const vector<ClOffset>& cs)
{
for (ClOffset offset: cs) {
if (bogoprops_remain <= 0) {
timedout = true;
break;
}
bogoprops_remain -= 10;
Clause* cl = solver->cl_alloc.ptr(offset);
add_clause_to_component(*cl);
}
}
void CompFinder::addToCompImplicits()
{
vector<Lit> lits;
for (size_t var = 0; var < solver->nVars(); var++) {
if (bogoprops_remain <= 0) {
timedout = true;
break;
}
bogoprops_remain -= 2;
Lit lit(var, false);
lits.clear();
lits.push_back(lit);
for(int sign = 0; sign < 2; sign++) {
lit = Lit(var, sign);
watch_subarray ws = solver->watches[lit];
//If empty, skip
if (ws.empty())
continue;
bogoprops_remain -= (int64_t)ws.size() + 10;
for(const Watched *it2 = ws.begin(), *end2 = ws.end()
; it2 != end2
; it2++
) {
if (it2->isBin()
//Only irred
&& !it2->red()
//Only do each binary once
&& lit < it2->lit2()
) {
if (!seen[it2->lit2().var()]) {
lits.push_back(it2->lit2());
seen[it2->lit2().var()] = 1;
}
}
}
}
if (lits.size() > 1) {
//Clear seen
for(vector<Lit>::const_iterator
it = lits.begin(), end = lits.end()
; it != end
; ++it
) {
seen[it->var()] = 0;
}
add_clause_to_component(lits);
}
}
}
template<class T>
bool CompFinder::belong_to_same_component(const T& cl)
{
if (table[cl[0].var()] != std::numeric_limits<uint32_t>::max()) {
bogoprops_remain -= (int64_t)cl.size()/2 + 1;
const uint32_t comp = table[cl[0].var()];
for (const Lit l: cl) {
if (table[l.var()] != comp) {
return false;
}
}
return true;
}
return false;
}
template<class T>
void CompFinder::fill_newset_and_tomerge(const T& cl)
{
bogoprops_remain -= (int64_t)cl.size()*2;
for (const Lit lit: cl) {
if (table[lit.var()] != std::numeric_limits<uint32_t>::max()
) {
if (!seen[table[lit.var()]]) {
tomerge.push_back(table[lit.var()]);
seen[table[lit.var()]] = 1;
}
} else {
newSet.push_back(lit.var());
}
}
}
void CompFinder::merge_newset_into_single_component()
{
const uint32_t into = tomerge[0];
seen[into] = 0;
map<uint32_t, vector<uint32_t> >::iterator intoReverse
= reverseTable.find(into);
//Put the new lits into this set
for (const uint32_t v: newSet) {
intoReverse->second.push_back(v);
table[v] = into;
}
}
template<class T>
void CompFinder::add_clause_to_component(const T& cl)
{
assert(cl.size() > 1);
tomerge.clear();
newSet.clear();
if (belong_to_same_component(cl)) {
return;
}
fill_newset_and_tomerge(cl);
//no sets to merge, only merge the clause into one tree
if (tomerge.size() == 1) {
merge_newset_into_single_component();
return;
}
//Expensive merging coming up
bogoprops_remain -= 20;
//Delete tables to merge and put their elements into newSet
for (const uint32_t merge: tomerge) {
//Clear seen
seen[merge] = 0;
//Find in reverseTable
bogoprops_remain -= (int64_t)reverseTable.size()*2;
map<uint32_t, vector<uint32_t> >::iterator it2 = reverseTable.find(merge);
assert(it2 != reverseTable.end());
//Add them all
bogoprops_remain -= (int64_t)it2->second.size();
newSet.insert(
newSet.end()
, it2->second.begin()
, it2->second.end()
);
//Delete this comp
bogoprops_remain -= (int64_t)reverseTable.size();
reverseTable.erase(it2);
used_comp_no--;
}
//No literals lie outside of already seen components
if (newSet.empty())
return;
//Mark all lits not belonging to seen components as belonging to comp_no
bogoprops_remain -= (int64_t)newSet.size();
for (const uint32_t v: newSet) {
table[v] = comp_no;
}
reverseTable[comp_no] = newSet;
comp_no++;
used_comp_no++;
}
| [
"u1219556@lnissrv4.eng.utah.edu"
] | u1219556@lnissrv4.eng.utah.edu |
a4a5a1ab865dcd834e9ba3ca4b6b60bb4238aa7b | 97efb82073f6d5a820a31474bbace3e8bcd87a7b | /ticpp/ch4_ex3_struct_suite/struct_suite.h | 6fefb84e0101eb93b2dab698e8016f09b7f9f1f4 | [] | no_license | chmieleslav/workspace | 0252fe6148eb2efe848030ba5f015f47cbe3b119 | 18761df56f5b9c24b2e2e2417ddfef2c6bc0ab65 | refs/heads/master | 2021-01-17T06:27:33.967640 | 2016-07-31T21:05:44 | 2016-07-31T21:05:44 | 36,605,765 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 350 | h | /*
Change your solution to Exercise 2 so the struct is
declared in a properly “guarded” header file, with the
definition in one cpp file and your main( ) in another.
*/
#include <iostream>
#include <string>
using namespace std;
struct id_card {
string first_name;
string last_name;
int age;
void changeLastName(string new_last_name);
};
| [
"chmieleslav@gmail.com"
] | chmieleslav@gmail.com |
74d6ce365307b283419c769ad12795c03ec46fa2 | 6ae520fd118f910c1f5f822fb99123bdc804929a | /SFML-Santorini_Engine/Scripts/Game/Buttons/PlayButton.h | a341feb2f400d33a946e4ac21abcb700bb2f8edb | [] | no_license | rolalzebub/SFML-Santorini_Engine | f4e94450477c2050e70a83aebf23099910c72ad5 | 96817561ddfb3c5d42db73ed14149fe59d826ce7 | refs/heads/master | 2021-01-04T14:54:41.253565 | 2020-05-27T21:51:44 | 2020-05-27T21:51:44 | 240,595,703 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 136 | h | #pragma once
#include "Core/Button.h"
class PlayButton :
public Button
{
public:
void Start() override;
void OnClick() override;
};
| [
"rohit.lalwani1996@hotmail.com"
] | rohit.lalwani1996@hotmail.com |
ebc743def82bb276de5cf47ca33b3853358152cf | 1308471fe0f886625cb058dcaf163a589f97c770 | /PC/HSMApp/SerialPort.cpp | 2f3d8acd8a09515ade6b7bc1d863a793256f6726 | [
"MIT"
] | permissive | DiogoParrinha/HSM | a27dd7d5fa9352a1c2e51128fb1ca369a71fcdd7 | f7e1eed4413ab7b1d56694c9b71a9ea5aa3d7b82 | refs/heads/master | 2021-07-20T07:56:40.501047 | 2017-10-28T14:52:31 | 2017-10-28T14:52:31 | 82,184,115 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,328 | cpp | /*
MIT License
Copyright (c) 2017 Diogo Parrinha
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 "stdafx.h"
#include "SerialPort.h"
FILE *fpOut, *fpIn;
SerialPort::SerialPort() {
serialPortHandle = INVALID_HANDLE_VALUE;
}
SerialPort::~SerialPort() {
if (serialPortHandle!=INVALID_HANDLE_VALUE)
CloseHandle(serialPortHandle);
serialPortHandle = INVALID_HANDLE_VALUE;
}
int SerialPort::connect() {
fopen_s(&fpOut, "./logOut.txt", "w+");
fopen_s(&fpIn, "./logIn.txt", "w+");
return connect(L"COM3");
}
int SerialPort::connect( wchar_t* device) {
int error=0;
DCB dcb;
memset(&dcb,0,sizeof(dcb));
dcb.DCBlength = sizeof(dcb);
dcb.BaudRate = 57600;
dcb.Parity = NOPARITY;
dcb.fParity = 0;
dcb.StopBits = ONESTOPBIT;
dcb.ByteSize = 8;
serialPortHandle = CreateFile(device, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, NULL, NULL);
if (serialPortHandle != INVALID_HANDLE_VALUE) {
if(!SetCommState(serialPortHandle,&dcb))
error=2;
}
else {
error=1;
}
if (error!=0) {
disconnect();
}
else {
clear();
}
// Non-blocking
COMMTIMEOUTS cto;
GetCommTimeouts(serialPortHandle, &cto);
// Set the new timeouts
cto.ReadIntervalTimeout = MAXDWORD;
cto.ReadTotalTimeoutConstant = 0;
cto.ReadTotalTimeoutMultiplier = 0;
SetCommTimeouts(serialPortHandle, &cto);
return error;
}
void SerialPort::disconnect(void) {
fclose(fpIn);
fclose(fpOut);
CloseHandle(serialPortHandle);
serialPortHandle = INVALID_HANDLE_VALUE;
//printf("Port 1 has been CLOSED and %d is the file descriptionn", fileDescriptor);
}
int SerialPort::sendArray(unsigned char *buffer, int len) {
unsigned long result;
if (serialPortHandle!=INVALID_HANDLE_VALUE)
WriteFile(serialPortHandle, buffer, len, &result, NULL);
fwrite("\n", sizeof(char), 1, fpOut);
fwrite(buffer, sizeof(char), len, fpOut);
return result;
}
int SerialPort::getArray (unsigned char *buffer, int len) {
unsigned long read_nbr;
memset(buffer, 0, sizeof(buffer));
read_nbr = 0;
if (serialPortHandle!=INVALID_HANDLE_VALUE)
{
ReadFile(serialPortHandle, buffer, len, &read_nbr, NULL);
}
fwrite("\n", sizeof(char), 1, fpIn);
fwrite(buffer, sizeof(char), read_nbr, fpIn);
return((int) read_nbr);
}
void SerialPort::clear() {
PurgeComm (serialPortHandle, PURGE_RXCLEAR | PURGE_TXCLEAR);
} | [
"piratanervo@gmail.com"
] | piratanervo@gmail.com |
bc8ba18782bf9fda099d728f4bc32a1250044293 | 0fccd1748ee7be55039e7bbfb4820197b5a85f0b | /2D Game Engine/2D Game Engine/BabyMaw.h | 6494c5e97181ac84ececcade06535d1d84fddf11 | [] | no_license | AustinChayka/C-Game | 11d297ac5fd38a280da4701ec16c5e18f8680c58 | 56bd96fddc38cb4bfca6f69c37748b1417a51d8a | refs/heads/master | 2022-02-13T02:39:14.724679 | 2019-05-30T22:10:43 | 2019-05-30T22:10:43 | 167,856,869 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 577 | h | #ifndef BabyMaw_h
#define BabyMaw_h
#include "Item.h"
class BabyMaw : public Item {
public:
BabyMaw();
~BabyMaw();
void OnPickup(LevelManager * game, Player * p);
void UpdateMaw(LevelManager * game, Player * p);
void Update(LevelManager * game, Player * p);
void Render();
private:
float x, y, vX = 0, vY = 0, width, height, tileX = 0;
SDL_Texture * texture;
SDL_Rect srcRect, destRect;
int shotDelay = 20, chargeDelay = 120, shots = 3;
GameObject * target;
float GetXCenter();
float GetYCenter();
float DistanceToSquared(GameObject * go);
};
#endif | [
"austinchayka@gmail.com"
] | austinchayka@gmail.com |
7bef19257f6304f7ab5406a0d9a4d564cc97feb7 | 33a82980352cf366b9c288cf8a74d2740272d90b | /nfp/net/driver/Connection.cpp | 1aed9008dff8747939c4ff878ee10373e46123d0 | [
"MS-PL"
] | permissive | microkatz/Windows-driver-samples | d249ecb8ab1be5a05bf8644ebeaca0bf13db1dad | 98a43841cb18b034c7808bc570c47556e332df2f | refs/heads/master | 2022-05-09T17:42:10.796047 | 2022-04-20T20:47:03 | 2022-04-20T20:47:03 | 161,238,613 | 2 | 0 | MS-PL | 2022-04-20T20:47:03 | 2018-12-10T21:28:00 | C | UTF-8 | C++ | false | false | 7,658 | cpp | /*++
Copyright (c) Microsoft Corporation. All rights reserved.
Author:
Travis Martin (TravM) 06-24-2010
--*/
#include "internal.h"
#include "Connection.tmh"
HRESULT SetSocketIpv6Only(_In_ SOCKET socket, _In_ BOOL Ipv6Only);
HRESULT SynchronousReadSocket(_In_ SOCKET Socket, _In_reads_bytes_(cbBuffer) PVOID pBuffer, _In_ DWORD cbBuffer)
{
HRESULT hr = S_OK;
DWORD dwIgnore;
OVERLAPPED Overlapped;
ZeroMemory(&Overlapped, sizeof(Overlapped));
if (!ReadFile((HANDLE)Socket, pBuffer, cbBuffer, &dwIgnore, &Overlapped))
{
hr = HRESULT_FROM_WIN32(GetLastError());
if (hr == HRESULT_FROM_WIN32(ERROR_IO_PENDING))
{
if (!GetOverlappedResult((HANDLE)Socket, &Overlapped, &dwIgnore, TRUE))
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
else
{
hr = S_OK;
}
}
}
return hr;
}
//CConnection
// static
HRESULT CConnection::Create(_In_ IConnectionCallback* pCallback, _Outptr_ CConnection** ppConnection)
{
CConnection* pConnection;
pConnection = new CConnection(pCallback);
HRESULT hr = (pConnection != NULL ? S_OK : E_OUTOFMEMORY);
if (SUCCEEDED(hr))
{
*ppConnection = pConnection;
}
return hr;
}
void CConnection::Terminate()
{
MethodEntry("void");
// Only want to terminate once
STATE PriorState = (STATE)(InterlockedExchange((long*)&_State, (long)TERMINATED));
if (PriorState != TERMINATED)
{
// Graceful shutdown
shutdown(_Socket, SD_SEND);
// Don't wait for threadpool callbacks when this thread is actually the threadpool callback
if (_ThreadpoolThreadId != GetCurrentThreadId())
{
// Let the ReceiveThreadProc gracefully shutdown
WaitForThreadpoolWorkCallbacks(_ThreadpoolWork, false);
}
SOCKET Socket = (SOCKET)InterlockedExchangePointer((PVOID*)&_Socket, (PVOID)INVALID_SOCKET);
if (Socket != INVALID_SOCKET)
{
closesocket(Socket);
}
}
MethodReturnVoid();
}
/* 9C7D2C68-5AD8-4A14-BE20-F8741D60D100 */
const GUID MAGIC_PACKET =
{0x9C7D2C68, 0x5AD8, 0x4A14, {0xBE, 0x20, 0xF8, 0x74, 0x1D, 0x60, 0xD1, 0x00}};
HRESULT CConnection::InitializeAsClient(_In_ BEGIN_PROXIMITY_ARGS* pArgs)
{
pArgs->szName[MAX_PATH-1] = L'\0';
MethodEntry("pArgs->szName = '%S'",
pArgs->szName);
// Open a TCP/IP Socket to the remote Network NearFieldProximity device
HRESULT hr = S_OK;
_Socket = socket(AF_INET6, SOCK_STREAM, 0);
if (_Socket == INVALID_SOCKET)
{
hr = HRESULT_FROM_WIN32(WSAGetLastError());
}
if (SUCCEEDED(hr))
{
hr = SetSocketIpv6Only(_Socket, FALSE);
}
if (SUCCEEDED(hr))
{
SOCKADDR_STORAGE LocalAddress = {};
SOCKADDR_STORAGE RemoteAddress = {};
DWORD cbLocalAddress = sizeof(LocalAddress);
DWORD cbRemoteAddress = sizeof(RemoteAddress);
timeval Timeout = {8, 0};
if (!WSAConnectByName(_Socket, pArgs->szName, L"9299",
&cbLocalAddress, (SOCKADDR*)&LocalAddress,
&cbRemoteAddress, (SOCKADDR*)&RemoteAddress, &Timeout, NULL))
{
hr = HRESULT_FROM_WIN32(WSAGetLastError());
TraceErrorHR(hr, L"WSAConnectByName FAILED");
}
}
if (SUCCEEDED(hr))
{
if (setsockopt(_Socket, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, NULL, 0) == SOCKET_ERROR)
{
hr = HRESULT_FROM_WIN32(WSAGetLastError());
}
}
if (SUCCEEDED(hr))
{
// Send the Magic Packet
if (send(_Socket, (char*)&MAGIC_PACKET, sizeof(MAGIC_PACKET), 0) == SOCKET_ERROR)
{
hr = HRESULT_FROM_WIN32(WSAGetLastError());
}
if (SUCCEEDED(hr))
{
GUID MagicPacket = {};
hr = SynchronousReadSocket(_Socket, &MagicPacket, sizeof(MagicPacket));
if (SUCCEEDED(hr))
{
if (memcmp(&MagicPacket, &MAGIC_PACKET, sizeof(MAGIC_PACKET)) != 0)
{
hr = E_FAIL;
}
}
}
if (SUCCEEDED(hr))
{
// This doesn't take the socket, because we're the client and already
// have the socket in _Socket.
hr = FinalizeEstablish(INVALID_SOCKET);
}
}
if (FAILED(hr))
{
if (_Socket != INVALID_SOCKET)
{
// Abortive shutdown of the socket
closesocket(_Socket);
_Socket = INVALID_SOCKET;
}
}
MethodReturnHR(hr);
}
void CConnection::ValidateAccept(_In_ SOCKET Socket, _In_ GUID* pMagicPacket)
{
MethodEntry("...");
TraceASSERT(Socket != INVALID_SOCKET);
HRESULT hr = S_OK;
if (memcmp(pMagicPacket, &MAGIC_PACKET, sizeof(MAGIC_PACKET)) != 0)
{
hr = E_FAIL;
}
if (SUCCEEDED(hr))
{
// Send the MAGIC_PACKET
if (send(Socket, (char*)&MAGIC_PACKET, sizeof(MAGIC_PACKET), 0) == SOCKET_ERROR)
{
hr = HRESULT_FROM_WIN32(WSAGetLastError());
}
}
if (SUCCEEDED(hr))
{
hr = FinalizeEstablish(Socket);
}
if (FAILED(hr))
{
// Abortive shutdown of the socket
closesocket(Socket);
}
MethodReturnVoid();
}
HRESULT CConnection::FinalizeEstablish(_In_ SOCKET Socket)
{
MethodEntry("...");
HRESULT hr = S_OK;
STATE PriorState = (STATE)(InterlockedCompareExchange((long*)&_State, (long)ESTABLISHED, (long)INITIAL));
if (PriorState != INITIAL)
{
// Already established (or terminated), drop this
hr = HRESULT_FROM_WIN32(ERROR_ALREADY_INITIALIZED);
}
if (SUCCEEDED(hr))
{
// Init Threadpool work item for the receieve thread proc.
_ThreadpoolWork = CreateThreadpoolWork(s_ReceiveThreadProc, this, NULL);
if (_ThreadpoolWork == NULL)
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
else
{
if (Socket != INVALID_SOCKET)
{
// Take ownership of the socket
_Socket = Socket;
}
SubmitThreadpoolWork(_ThreadpoolWork);
_pCallback->ConnectionEstablished(this);
}
}
MethodReturnHR(hr);
}
BOOL CConnection::ReceiveThreadProc()
{
MethodEntry("void");
MESSAGE* pMessage = new MESSAGE();
if (pMessage == NULL)
{
Terminate();
}
else
{
while (_Socket != INVALID_SOCKET)
{
if (recv(_Socket, (char*)pMessage, sizeof(*pMessage), MSG_WAITALL) == sizeof(*pMessage))
{
_pCallback->HandleReceivedMessage(pMessage);
}
else
{
Terminate();
break;
}
}
delete pMessage;
}
// The connection is now terminated
BOOL fConnectionDeleted = _pCallback->ConnectionTerminated(this);
MethodReturnBool(fConnectionDeleted);
}
HRESULT CConnection::TransmitMessage(_In_ MESSAGE* pMessage)
{
HRESULT hr = S_OK;
if (_Socket == INVALID_SOCKET)
{
hr = HRESULT_FROM_WIN32(WSAENOTSOCK);
}
else
{
if (send(_Socket, (char*)pMessage, sizeof(*pMessage), 0) == SOCKET_ERROR)
{
hr = HRESULT_FROM_WIN32(WSAGetLastError());
Terminate();
}
}
return hr;
}
| [
"cdwilsonjr@gmail.com"
] | cdwilsonjr@gmail.com |
e41aa7a04d209434e27fcbb829e56e7b23264e2e | 3e9912d4af85452287b0ed610273c9b0b2d6a8ec | /CPSC121/Lab1/Problem1.cpp | 146239a1b141614a714cf6fd004da1edd802c4c9 | [] | no_license | alexmasluk/CPPDev | d584862a395a1a354bb14bbd4d80c4c168119fba | 7208f61ddb6154a00371c958744ee0781c988278 | refs/heads/master | 2021-05-02T05:50:35.851165 | 2019-03-12T02:25:54 | 2019-03-12T02:25:54 | 23,196,067 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,337 | cpp | //-----------------------------------------------------------------------
// Name: Alex Masluk
// Proj: Lab 1 Problem 1
// Due: Sep 2, 2014
// Class: CPSC 121
// Prof: Mr. Ahmadnia
// Description: Calculate interest based on A=Pe^(rt)
//-----------------------------------------------------------------------
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main()
{
//declarations
double initDeposit, interestRate, finalAmount;
int years;
//get user input
cout << "\tEnter the money you want to deposit now(P): ";
cin >> initDeposit;
cout << "\tEnter the interest rate: ";
cin >> interestRate;
cout << "\tEnter the duration in years(t): ";
cin >> years;
//calculate and display final balance
finalAmount = initDeposit * exp(interestRate*finalAmount);
cout << fixed << showpoint << setprecision(2);
cout << "\t\tYour balance after 5 years is " << finalAmount << "\n";
system("pause");
return 0;
}
/*------------------------------OUTPUT------------------------------------
Enter the money you want to deposit now(P): 20000
Enter the interest rate: .05
Enter the duration in years(t): 5
Your balance after 5 years is 25680.51
Press any key to continue . . .
-------------------------------------------------------------------------*/
| [
"alex.masluk@gmail.com"
] | alex.masluk@gmail.com |
4e05a37defbf4254283f41263ae9554d58755987 | 49b878b65e9eb00232490243ccb9aea9760a4a6d | /third_party/blink/renderer/modules/media_capabilities/media_capabilities.cc | 5d4422feea14fe80f51f9cf72c44397f1c6c00cc | [
"LGPL-2.0-or-later",
"LicenseRef-scancode-warranty-disclaimer",
"LGPL-2.1-only",
"GPL-1.0-or-later",
"GPL-2.0-only",
"LGPL-2.0-only",
"BSD-2-Clause",
"LicenseRef-scancode-other-copyleft",
"MIT",
"Apache-2.0",
"BSD-3-Clause"
] | permissive | romanzes/chromium | 5a46f234a233b3e113891a5d643a79667eaf2ffb | 12893215d9efc3b0b4d427fc60f5369c6bf6b938 | refs/heads/master | 2022-12-28T00:20:03.524839 | 2020-10-08T21:01:52 | 2020-10-08T21:01:52 | 302,470,347 | 0 | 0 | BSD-3-Clause | 2020-10-08T22:10:22 | 2020-10-08T21:54:38 | null | UTF-8 | C++ | false | false | 53,995 | cc | // Copyright 2017 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 "third_party/blink/renderer/modules/media_capabilities/media_capabilities.h"
#include <memory>
#include <sstream>
#include <utility>
#include "base/feature_list.h"
#include "base/metrics/field_trial_params.h"
#include "base/metrics/histogram_macros.h"
#include "base/optional.h"
#include "media/base/media_switches.h"
#include "media/base/media_util.h"
#include "media/base/mime_util.h"
#include "media/base/supported_types.h"
#include "media/base/video_decoder_config.h"
#include "media/filters/stream_parser_factory.h"
#include "media/learning/common/media_learning_tasks.h"
#include "media/learning/common/target_histogram.h"
#include "media/learning/mojo/public/mojom/learning_task_controller.mojom-blink.h"
#include "media/mojo/mojom/media_metrics_provider.mojom-blink.h"
#include "media/mojo/mojom/media_types.mojom-blink.h"
#include "media/video/gpu_video_accelerator_factories.h"
#include "media/video/supported_video_decoder_config.h"
#include "third_party/blink/public/common/browser_interface_broker_proxy.h"
#include "third_party/blink/public/mojom/feature_policy/feature_policy.mojom-blink.h"
#include "third_party/blink/public/mojom/web_feature/web_feature.mojom-blink.h"
#include "third_party/blink/public/platform/platform.h"
#include "third_party/blink/public/platform/task_type.h"
#include "third_party/blink/public/platform/web_encrypted_media_client.h"
#include "third_party/blink/public/platform/web_encrypted_media_request.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_audio_configuration.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_key_system_track_configuration.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_media_capabilities_decoding_info.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_media_capabilities_info.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_media_capabilities_key_system_configuration.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_media_configuration.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_media_decoding_configuration.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_media_encoding_configuration.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_media_key_system_configuration.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_media_key_system_media_capability.h"
#include "third_party/blink/renderer/core/dom/dom_exception.h"
#include "third_party/blink/renderer/core/execution_context/execution_context.h"
#include "third_party/blink/renderer/core/frame/local_dom_window.h"
#include "third_party/blink/renderer/core/html/parser/html_parser_idioms.h"
#include "third_party/blink/renderer/core/inspector/console_message.h"
#include "third_party/blink/renderer/modules/encryptedmedia/encrypted_media_utils.h"
#include "third_party/blink/renderer/modules/encryptedmedia/media_key_system_access.h"
#include "third_party/blink/renderer/modules/encryptedmedia/media_key_system_access_initializer_base.h"
#include "third_party/blink/renderer/modules/encryptedmedia/media_keys_controller.h"
#include "third_party/blink/renderer/modules/mediarecorder/media_recorder_handler.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
#include "third_party/blink/renderer/platform/bindings/script_state.h"
#include "third_party/blink/renderer/platform/bindings/to_v8.h"
#include "third_party/blink/renderer/platform/bindings/v8_throw_exception.h"
#include "third_party/blink/renderer/platform/heap/heap.h"
#include "third_party/blink/renderer/platform/heap/heap_allocator.h"
#include "third_party/blink/renderer/platform/heap/member.h"
#include "third_party/blink/renderer/platform/heap/persistent.h"
#include "third_party/blink/renderer/platform/instrumentation/use_counter.h"
#include "third_party/blink/renderer/platform/media_capabilities/web_media_capabilities_info.h"
#include "third_party/blink/renderer/platform/media_capabilities/web_media_configuration.h"
#include "third_party/blink/renderer/platform/network/parsed_content_type.h"
#include "third_party/blink/renderer/platform/peerconnection/transmission_encoding_info_handler.h"
#include "third_party/blink/renderer/platform/wtf/functional.h"
#include "third_party/blink/renderer/platform/wtf/vector.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
namespace blink {
namespace {
const double kLearningBadWindowThresholdDefault = 2;
const double kLearningNnrThresholdDefault = 3;
constexpr const char* kApplicationMimeTypePrefix = "application/";
constexpr const char* kAudioMimeTypePrefix = "audio/";
constexpr const char* kVideoMimeTypePrefix = "video/";
constexpr const char* kCodecsMimeTypeParam = "codecs";
constexpr const char* kSmpteSt2086HdrMetadataType = "smpteSt2086";
constexpr const char* kSmpteSt209410HdrMetadataType = "smpteSt2094-10";
constexpr const char* kSmpteSt209440HdrMetadataType = "smpteSt2094-40";
constexpr const char* kSrgbColorGamut = "srgb";
constexpr const char* kP3ColorGamut = "p3";
constexpr const char* kRec2020ColorGamut = "rec2020";
constexpr const char* kSrgbTransferFunction = "srgb";
constexpr const char* kPqTransferFunction = "pq";
constexpr const char* kHlgTransferFunction = "hlg";
// Gets parameters for kMediaLearningSmoothnessExperiment field trial. Will
// provide sane defaults when field trial not enabled. Values of -1 indicate
// predictions from a given task should be ignored.
// static
double GetLearningBadWindowThreshold() {
return base::GetFieldTrialParamByFeatureAsDouble(
media::kMediaLearningSmoothnessExperiment,
MediaCapabilities::kLearningBadWindowThresholdParamName,
kLearningBadWindowThresholdDefault);
}
// static
double GetLearningNnrThreshold() {
return base::GetFieldTrialParamByFeatureAsDouble(
media::kMediaLearningSmoothnessExperiment,
MediaCapabilities::kLearningNnrThresholdParamName,
kLearningNnrThresholdDefault);
}
// static
bool UseGpuFactoriesForPowerEfficient(
ExecutionContext* execution_context,
const MediaKeySystemAccess* key_system_access) {
// TODO(1105258): GpuFactories isn't available in worker scope yet.
if (!execution_context || execution_context->IsWorkerGlobalScope())
return false;
// TODO(1105258): Decoding w/ EME often means we can't use the GPU accelerated
// path. Add additional logic to detect when GPU acceleration is really
// available.
if (key_system_access)
return false;
return base::FeatureList::IsEnabled(
media::kMediaCapabilitiesQueryGpuFactories);
}
// Utility function that will create a MediaCapabilitiesDecodingInfo object with
// all the values set to either true or false.
MediaCapabilitiesDecodingInfo* CreateDecodingInfoWith(bool value) {
MediaCapabilitiesDecodingInfo* info = MediaCapabilitiesDecodingInfo::Create();
info->setSupported(value);
info->setSmooth(value);
info->setPowerEfficient(value);
return info;
}
MediaCapabilitiesDecodingInfo* CreateEncryptedDecodingInfoWith(
bool value,
MediaKeySystemAccess* access) {
MediaCapabilitiesDecodingInfo* info = CreateDecodingInfoWith(value);
info->setKeySystemAccess(access);
return info;
}
class MediaCapabilitiesKeySystemAccessInitializer final
: public MediaKeySystemAccessInitializerBase {
public:
using GetPerfCallback =
base::OnceCallback<void(ScriptPromiseResolver*, MediaKeySystemAccess*)>;
MediaCapabilitiesKeySystemAccessInitializer(
ScriptState* script_state,
const String& key_system,
const HeapVector<Member<MediaKeySystemConfiguration>>&
supported_configurations,
GetPerfCallback get_perf_callback)
: MediaKeySystemAccessInitializerBase(script_state,
key_system,
supported_configurations),
get_perf_callback_(std::move(get_perf_callback)) {}
~MediaCapabilitiesKeySystemAccessInitializer() override = default;
void RequestSucceeded(
std::unique_ptr<WebContentDecryptionModuleAccess> access) override {
DVLOG(3) << __func__;
if (!IsExecutionContextValid())
return;
// Query the client for smoothness and power efficiency of the video. It
// will resolve the promise.
std::move(get_perf_callback_)
.Run(resolver_.Get(), MakeGarbageCollected<MediaKeySystemAccess>(
KeySystem(), std::move(access)));
}
void RequestNotSupported(const WebString& error_message) override {
DVLOG(3) << __func__ << " error: " << error_message.Ascii();
if (!IsExecutionContextValid())
return;
MediaCapabilitiesDecodingInfo* info =
CreateEncryptedDecodingInfoWith(false, nullptr);
resolver_->Resolve(info);
}
void Trace(Visitor* visitor) const override {
MediaKeySystemAccessInitializerBase::Trace(visitor);
}
private:
GetPerfCallback get_perf_callback_;
DISALLOW_COPY_AND_ASSIGN(MediaCapabilitiesKeySystemAccessInitializer);
};
bool IsValidFrameRate(double framerate) {
return std::isfinite(framerate) && framerate > 0;
}
bool IsValidMimeType(const String& content_type, const String& prefix) {
ParsedContentType parsed_content_type(content_type);
if (!parsed_content_type.IsValid())
return false;
// Valid ParsedContentType implies we have a mime type.
DCHECK(parsed_content_type.MimeType());
if (!parsed_content_type.MimeType().StartsWith(prefix) &&
!parsed_content_type.MimeType().StartsWith(kApplicationMimeTypePrefix)) {
return false;
}
const auto& parameters = parsed_content_type.GetParameters();
if (parameters.ParameterCount() > 1)
return false;
if (parameters.ParameterCount() == 0)
return true;
return parameters.begin()->name.LowerASCII() == kCodecsMimeTypeParam;
}
bool IsValidMediaConfiguration(const MediaConfiguration* configuration) {
return configuration->hasAudio() || configuration->hasVideo();
}
bool IsValidMediaDecodingConfiguration(
const MediaDecodingConfiguration* configuration,
String* message) {
if (!IsValidMediaConfiguration(configuration)) {
*message =
"The configuration dictionary has neither |video| nor |audio| "
"specified and needs at least one of them.";
return false;
}
if (configuration->hasKeySystemConfiguration()) {
if (configuration->keySystemConfiguration()->hasAudio() &&
!configuration->hasAudio()) {
*message =
"The keySystemConfiguration object contains an audio property but "
"the root configuration has no audio configuration.";
return false;
}
if (configuration->keySystemConfiguration()->hasVideo() &&
!configuration->hasVideo()) {
*message =
"The keySystemConfiguration object contains a video property but the "
"root configuration has no video configuration.";
return false;
}
}
return true;
}
bool IsValidVideoConfiguration(const VideoConfiguration* configuration) {
DCHECK(configuration->hasContentType());
if (!IsValidMimeType(configuration->contentType(), kVideoMimeTypePrefix))
return false;
DCHECK(configuration->hasFramerate());
if (!IsValidFrameRate(configuration->framerate()))
return false;
return true;
}
bool IsValidAudioConfiguration(const AudioConfiguration* configuration) {
DCHECK(configuration->hasContentType());
if (!IsValidMimeType(configuration->contentType(), kAudioMimeTypePrefix))
return false;
return true;
}
WebAudioConfiguration ToWebAudioConfiguration(
const AudioConfiguration* configuration) {
WebAudioConfiguration web_configuration;
// |contentType| is mandatory.
DCHECK(configuration->hasContentType());
ParsedContentType parsed_content_type(configuration->contentType());
DCHECK(parsed_content_type.IsValid());
DCHECK(!parsed_content_type.GetParameters().HasDuplicatedNames());
DEFINE_THREAD_SAFE_STATIC_LOCAL(const String, codecs, ("codecs"));
web_configuration.mime_type = parsed_content_type.MimeType().LowerASCII();
web_configuration.codec = parsed_content_type.ParameterValueForName(codecs);
// |channels| is optional and will be set to a null WebString if not present.
web_configuration.channels = configuration->hasChannels()
? WebString(configuration->channels())
: WebString();
if (configuration->hasBitrate())
web_configuration.bitrate = configuration->bitrate();
if (configuration->hasSamplerate())
web_configuration.samplerate = configuration->samplerate();
return web_configuration;
}
WebVideoConfiguration ToWebVideoConfiguration(
const VideoConfiguration* configuration) {
WebVideoConfiguration web_configuration;
// All the properties are mandatory.
DCHECK(configuration->hasContentType());
ParsedContentType parsed_content_type(configuration->contentType());
DCHECK(parsed_content_type.IsValid());
DCHECK(!parsed_content_type.GetParameters().HasDuplicatedNames());
DEFINE_THREAD_SAFE_STATIC_LOCAL(const String, codecs, ("codecs"));
web_configuration.mime_type = parsed_content_type.MimeType().LowerASCII();
web_configuration.codec = parsed_content_type.ParameterValueForName(codecs);
DCHECK(configuration->hasWidth());
web_configuration.width = configuration->width();
DCHECK(configuration->hasHeight());
web_configuration.height = configuration->height();
DCHECK(configuration->hasBitrate());
web_configuration.bitrate = configuration->bitrate();
DCHECK(configuration->hasFramerate());
web_configuration.framerate = configuration->framerate();
return web_configuration;
}
WebMediaConfiguration ToWebMediaConfiguration(
const MediaEncodingConfiguration* configuration) {
WebMediaConfiguration web_configuration;
// |type| is required.
DCHECK(configuration->hasType());
if (configuration->type() == "record")
web_configuration.type = MediaConfigurationType::kRecord;
else if (configuration->type() == "transmission")
web_configuration.type = MediaConfigurationType::kTransmission;
else
NOTREACHED();
if (configuration->hasAudio()) {
web_configuration.audio_configuration =
ToWebAudioConfiguration(configuration->audio());
}
if (configuration->hasVideo()) {
web_configuration.video_configuration =
ToWebVideoConfiguration(configuration->video());
}
return web_configuration;
}
bool CheckMseSupport(const String& mime_type, const String& codec) {
// For MSE queries, we assume the queried audio and video streams will be
// placed into separate source buffers.
// TODO(chcunningham): Clarify this assumption in the spec.
// Media MIME API expects a vector of codec strings. We query audio and video
// separately, so |codec_string|.size() should always be 1 or 0 (when no
// codecs parameter is required for the given mime type).
std::vector<std::string> codec_vector;
if (!codec.Ascii().empty())
codec_vector.push_back(codec.Ascii());
if (media::IsSupported != media::StreamParserFactory::IsTypeSupported(
mime_type.Ascii(), codec_vector)) {
DVLOG(2) << __func__
<< " MSE does not support the content type: " << mime_type.Ascii()
<< " " << (codec_vector.empty() ? "" : codec_vector[1]);
return false;
}
return true;
}
void ParseDynamicRangeConfigurations(
const blink::VideoConfiguration* video_config,
media::VideoColorSpace* color_space,
gl::HdrMetadataType* hdr_metadata) {
DCHECK(color_space);
DCHECK(hdr_metadata);
// TODO(1066628): Follow up on MediaCapabilities spec regarding reconciling
// discrepancies between mime type and colorGamut/transferFunction; for now,
// give precedence to the latter.
if (video_config->hasHdrMetadataType()) {
const auto& hdr_metadata_type = video_config->hdrMetadataType();
// TODO(crbug.com/1092328): Switch by V8HdrMetadataType::Enum.
if (hdr_metadata_type == kSmpteSt2086HdrMetadataType) {
*hdr_metadata = gl::HdrMetadataType::kSmpteSt2086;
} else if (hdr_metadata_type == kSmpteSt209410HdrMetadataType) {
*hdr_metadata = gl::HdrMetadataType::kSmpteSt2094_10;
} else if (hdr_metadata_type == kSmpteSt209440HdrMetadataType) {
*hdr_metadata = gl::HdrMetadataType::kSmpteSt2094_40;
} else {
NOTREACHED();
}
} else {
*hdr_metadata = gl::HdrMetadataType::kNone;
}
if (video_config->hasColorGamut()) {
const auto& color_gamut = video_config->colorGamut();
// TODO(crbug.com/1092328): Switch by V8ColorGamut::Enum.
if (color_gamut == kSrgbColorGamut) {
color_space->primaries = media::VideoColorSpace::PrimaryID::BT709;
} else if (color_gamut == kP3ColorGamut) {
color_space->primaries = media::VideoColorSpace::PrimaryID::SMPTEST431_2;
} else if (color_gamut == kRec2020ColorGamut) {
color_space->primaries = media::VideoColorSpace::PrimaryID::BT2020;
} else {
NOTREACHED();
}
}
if (video_config->hasTransferFunction()) {
const auto& transfer_function = video_config->transferFunction();
// TODO(crbug.com/1092328): Switch by V8TransferFunction::Enum.
if (transfer_function == kSrgbTransferFunction) {
color_space->transfer = media::VideoColorSpace::TransferID::BT709;
} else if (transfer_function == kPqTransferFunction) {
color_space->transfer = media::VideoColorSpace::TransferID::SMPTEST2084;
} else if (transfer_function == kHlgTransferFunction) {
color_space->transfer = media::VideoColorSpace::TransferID::ARIB_STD_B67;
} else {
NOTREACHED();
}
}
}
// Returns whether the audio codec associated with the audio configuration is
// valid and non-ambiguous.
// |console_warning| is an out param containing a message to be printed in the
// console.
bool IsAudioCodecValid(const String& mime_type,
const String& codec,
String* console_warning) {
media::AudioCodec audio_codec = media::kUnknownAudioCodec;
bool is_audio_codec_ambiguous = true;
if (!media::ParseAudioCodecString(mime_type.Ascii(), codec.Ascii(),
&is_audio_codec_ambiguous, &audio_codec)) {
*console_warning = StringView("Failed to parse audio contentType: ") +
String{mime_type} + StringView("; codecs=") +
String{codec};
return false;
}
if (is_audio_codec_ambiguous) {
*console_warning = StringView("Invalid (ambiguous) audio codec string: ") +
String{mime_type} + StringView("; codecs=") +
String{codec};
return false;
}
return true;
}
// Returns whether the video codec associated with the video configuration is
// valid and non-ambiguous.
// |out_video_profile| is an out param containing the video codec profile if the
// codec is valid.
// |console_warning| is an out param containing a message to be printed in the
// console.
bool IsVideoCodecValid(const String& mime_type,
const String& codec,
media::VideoCodec* out_video_codec,
media::VideoCodecProfile* out_video_profile,
String* console_warning) {
uint8_t video_level = 0;
media::VideoColorSpace video_color_space;
bool is_video_codec_ambiguous = true;
if (!media::ParseVideoCodecString(mime_type.Ascii(), codec.Ascii(),
&is_video_codec_ambiguous, out_video_codec,
out_video_profile, &video_level,
&video_color_space)) {
*console_warning = StringView("Failed to parse video contentType: ") +
String{mime_type} + StringView("; codecs=") +
String{codec};
return false;
}
if (is_video_codec_ambiguous) {
*console_warning = StringView("Invalid (ambiguous) video codec string: ") +
String{mime_type} + StringView("; codecs=") +
String{codec};
return false;
}
return true;
}
// Returns whether the AudioConfiguration is supported.
// IsAudioCodecValid() MUST be called before.
bool IsAudioConfigurationSupported(
const blink::AudioConfiguration* audio_config,
const String& mime_type,
const String& codec) {
media::AudioCodec audio_codec = media::kUnknownAudioCodec;
media::AudioCodecProfile audio_profile = media::AudioCodecProfile::kUnknown;
bool is_audio_codec_ambiguous = true;
bool is_spatial_rendering = false;
// Must succeed as IsAudioCodecValid() should have been called before.
bool parsed =
media::ParseAudioCodecString(mime_type.Ascii(), codec.Ascii(),
&is_audio_codec_ambiguous, &audio_codec);
DCHECK(parsed && !is_audio_codec_ambiguous);
if (audio_config->hasSpatialRendering())
is_spatial_rendering = audio_config->spatialRendering();
return media::IsSupportedAudioType(
{audio_codec, audio_profile, is_spatial_rendering});
}
// Returns whether the VideoConfiguration is supported.
// IsVideoCodecValid() MUST be called before.
bool IsVideoConfigurationSupported(const String& mime_type,
const String& codec,
media::VideoColorSpace video_color_space,
gl::HdrMetadataType hdr_metadata_type) {
media::VideoCodec video_codec = media::kUnknownVideoCodec;
media::VideoCodecProfile video_profile;
uint8_t video_level = 0;
bool is_video_codec_ambiguous = true;
// Must succeed as IsVideoCodecValid() should have been called before.
bool parsed = media::ParseVideoCodecString(
mime_type.Ascii(), codec.Ascii(), &is_video_codec_ambiguous, &video_codec,
&video_profile, &video_level, &video_color_space);
DCHECK(parsed && !is_video_codec_ambiguous);
return media::IsSupportedVideoType({video_codec, video_profile, video_level,
video_color_space, hdr_metadata_type});
}
void OnMediaCapabilitiesEncodingInfo(
ScriptPromiseResolver* resolver,
std::unique_ptr<WebMediaCapabilitiesInfo> result) {
if (!resolver->GetExecutionContext() ||
resolver->GetExecutionContext()->IsContextDestroyed()) {
return;
}
Persistent<MediaCapabilitiesInfo> info(MediaCapabilitiesInfo::Create());
info->setSupported(result->supported);
info->setSmooth(result->smooth);
info->setPowerEfficient(result->power_efficient);
resolver->Resolve(std::move(info));
}
bool ParseContentType(const String& content_type,
String* mime_type,
String* codec) {
DCHECK(mime_type);
DCHECK(codec);
ParsedContentType parsed_content_type(content_type);
if (!parsed_content_type.IsValid() ||
parsed_content_type.GetParameters().HasDuplicatedNames()) {
return false;
}
DEFINE_THREAD_SAFE_STATIC_LOCAL(const String, codecs, ("codecs"));
*mime_type = parsed_content_type.MimeType().LowerASCII();
*codec = parsed_content_type.ParameterValueForName(codecs);
return true;
}
} // anonymous namespace
const char MediaCapabilities::kLearningBadWindowThresholdParamName[] =
"bad_window_threshold";
const char MediaCapabilities::kLearningNnrThresholdParamName[] =
"nnr_threshold";
MediaCapabilities::MediaCapabilities(ExecutionContext* context)
: decode_history_service_(context),
bad_window_predictor_(context),
nnr_predictor_(context) {}
void MediaCapabilities::Trace(blink::Visitor* visitor) const {
visitor->Trace(decode_history_service_);
visitor->Trace(bad_window_predictor_);
visitor->Trace(nnr_predictor_);
visitor->Trace(pending_cb_map_);
ScriptWrappable::Trace(visitor);
}
MediaCapabilities::PendingCallbackState::PendingCallbackState(
ScriptPromiseResolver* resolver,
MediaKeySystemAccess* access,
const base::TimeTicks& request_time)
: resolver(resolver),
key_system_access(access),
request_time(request_time) {}
void MediaCapabilities::PendingCallbackState::Trace(
blink::Visitor* visitor) const {
visitor->Trace(key_system_access);
visitor->Trace(resolver);
}
ScriptPromise MediaCapabilities::decodingInfo(
ScriptState* script_state,
const MediaDecodingConfiguration* config,
ExceptionState& exception_state) {
const base::TimeTicks request_time = base::TimeTicks::Now();
if (config->hasKeySystemConfiguration()) {
UseCounter::Count(
ExecutionContext::From(script_state),
WebFeature::kMediaCapabilitiesDecodingInfoWithKeySystemConfig);
}
String message;
if (!IsValidMediaDecodingConfiguration(config, &message)) {
exception_state.ThrowTypeError(message);
return ScriptPromise();
}
if (config->hasVideo() && !IsValidVideoConfiguration(config->video())) {
exception_state.ThrowTypeError(
"The video configuration dictionary is not valid.");
return ScriptPromise();
}
if (config->hasAudio() && !IsValidAudioConfiguration(config->audio())) {
exception_state.ThrowTypeError(
"The audio configuration dictionary is not valid.");
return ScriptPromise();
}
// Validation errors should return above.
DCHECK(message.IsEmpty());
String audio_mime_str;
String audio_codec_str;
if (config->hasAudio()) {
DCHECK(config->audio()->hasContentType());
bool valid_content_type = ParseContentType(
config->audio()->contentType(), &audio_mime_str, &audio_codec_str);
DCHECK(valid_content_type);
}
String video_mime_str;
String video_codec_str;
if (config->hasVideo()) {
DCHECK(config->video()->hasContentType());
bool valid_content_type = ParseContentType(
config->video()->contentType(), &video_mime_str, &video_codec_str);
DCHECK(valid_content_type);
}
// MSE support is cheap to check (regex matching). Do it first. Also, note
// that MSE support is not implied by EME support, so do it irrespective of
// whether we have a KeySystem configuration.
if (config->type() == "media-source") {
if ((config->hasAudio() &&
!CheckMseSupport(audio_mime_str, audio_codec_str)) ||
(config->hasVideo() &&
!CheckMseSupport(video_mime_str, video_codec_str))) {
// Unsupported EME queries should resolve with a null
// MediaKeySystemAccess.
return ScriptPromise::Cast(
script_state,
ToV8(CreateEncryptedDecodingInfoWith(false, nullptr), script_state));
}
}
media::VideoCodec video_codec = media::kUnknownVideoCodec;
media::VideoCodecProfile video_profile = media::VIDEO_CODEC_PROFILE_UNKNOWN;
if ((config->hasAudio() &&
!IsAudioCodecValid(audio_mime_str, audio_codec_str, &message)) ||
(config->hasVideo() &&
!IsVideoCodecValid(video_mime_str, video_codec_str, &video_codec,
&video_profile, &message))) {
DCHECK(!message.IsEmpty());
if (ExecutionContext* execution_context =
ExecutionContext::From(script_state)) {
execution_context->AddConsoleMessage(mojom::ConsoleMessageSource::kOther,
mojom::ConsoleMessageLevel::kWarning,
message);
}
return ScriptPromise::Cast(
script_state, ToV8(CreateDecodingInfoWith(false), script_state));
}
// Validation errors should return above.
DCHECK(message.IsEmpty());
media::VideoColorSpace video_color_space;
gl::HdrMetadataType hdr_metadata_type = gl::HdrMetadataType::kNone;
if (config->hasVideo()) {
ParseDynamicRangeConfigurations(config->video(), &video_color_space,
&hdr_metadata_type);
}
if (config->hasKeySystemConfiguration()) {
// GetEmeSupport() will call the VideoDecodePerfHistory service after
// receiving info about support for the configuration for encrypted content.
return GetEmeSupport(script_state, video_codec, video_profile,
video_color_space, config, request_time,
exception_state);
}
bool audio_supported = true;
if (config->hasAudio()) {
audio_supported = IsAudioConfigurationSupported(
config->audio(), audio_mime_str, audio_codec_str);
}
// No need to check video capabilities if video not included in configuration
// or when audio is already known to be unsupported.
if (!audio_supported || !config->hasVideo()) {
return ScriptPromise::Cast(
script_state,
ToV8(CreateDecodingInfoWith(audio_supported), script_state));
}
DCHECK(message.IsEmpty());
DCHECK(config->hasVideo());
// Return early for unsupported configurations.
if (!IsVideoConfigurationSupported(video_mime_str, video_codec_str,
video_color_space, hdr_metadata_type)) {
return ScriptPromise::Cast(
script_state, ToV8(CreateDecodingInfoWith(false), script_state));
}
auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
// IMPORTANT: Acquire the promise before potentially synchronously resolving
// it in the code that follows. Otherwise the promise returned to JS will be
// undefined. See comment above Promise() in script_promise_resolver.h
ScriptPromise promise = resolver->Promise();
GetPerfInfo(video_codec, video_profile, video_color_space, config,
request_time, resolver, nullptr /* access */);
return promise;
}
ScriptPromise MediaCapabilities::encodingInfo(
ScriptState* script_state,
const MediaEncodingConfiguration* configuration) {
auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
// IMPORTANT: Acquire the promise before potentially synchronously resolving
// it in the code that follows. Otherwise the promise returned to JS will be
// undefined. See comment above Promise() in script_promise_resolver.h
ScriptPromise promise = resolver->Promise();
if (!IsValidMediaConfiguration(configuration)) {
resolver->Reject(V8ThrowException::CreateTypeError(
script_state->GetIsolate(),
"The configuration dictionary has neither |video| nor |audio| "
"specified and needs at least one of them."));
return promise;
}
if (configuration->hasVideo() &&
!IsValidVideoConfiguration(configuration->video())) {
resolver->Reject(V8ThrowException::CreateTypeError(
script_state->GetIsolate(),
"The video configuration dictionary is not valid."));
return promise;
}
if (configuration->hasAudio() &&
!IsValidAudioConfiguration(configuration->audio())) {
resolver->Reject(V8ThrowException::CreateTypeError(
script_state->GetIsolate(),
"The audio configuration dictionary is not valid."));
return promise;
}
if (configuration->type() == "transmission") {
if (auto* handler = TransmissionEncodingInfoHandler::Instance()) {
handler->EncodingInfo(ToWebMediaConfiguration(configuration),
WTF::Bind(&OnMediaCapabilitiesEncodingInfo,
WrapPersistent(resolver)));
return promise;
}
resolver->Reject(MakeGarbageCollected<DOMException>(
DOMExceptionCode::kInvalidStateError,
"Platform error: could not get EncodingInfoHandler."));
return promise;
}
if (configuration->type() == "record") {
if (auto* handler = MakeGarbageCollected<MediaRecorderHandler>(
ExecutionContext::From(script_state)
->GetTaskRunner(TaskType::kInternalMediaRealTime))) {
handler->EncodingInfo(ToWebMediaConfiguration(configuration),
WTF::Bind(&OnMediaCapabilitiesEncodingInfo,
WrapPersistent(resolver)));
return promise;
}
resolver->Reject(MakeGarbageCollected<DOMException>(
DOMExceptionCode::kInvalidStateError,
"Platform error: could not create MediaRecorderHandler."));
return promise;
}
resolver->Reject(V8ThrowException::CreateTypeError(
script_state->GetIsolate(),
"Valid configuration |type| should be either 'transmission' or "
"'record'."));
return promise;
}
bool MediaCapabilities::EnsureLearningPredictors(
ExecutionContext* execution_context) {
DCHECK(execution_context && !execution_context->IsContextDestroyed());
// One or both of these will have been bound in an earlier pass.
if (bad_window_predictor_.is_bound() || nnr_predictor_.is_bound())
return true;
// MediaMetricsProvider currently only exposed via render frame.
// TODO(chcunningham): Expose in worker contexts pending outcome of
// media-learning experiments.
if (execution_context->IsWorkerGlobalScope())
return false;
scoped_refptr<base::SingleThreadTaskRunner> task_runner =
execution_context->GetTaskRunner(TaskType::kMediaElementEvent);
mojo::Remote<media::mojom::blink::MediaMetricsProvider> metrics_provider;
execution_context->GetBrowserInterfaceBroker().GetInterface(
metrics_provider.BindNewPipeAndPassReceiver(task_runner));
if (!metrics_provider)
return false;
if (GetLearningBadWindowThreshold() != -1.0) {
DCHECK_GE(GetLearningBadWindowThreshold(), 0);
metrics_provider->AcquireLearningTaskController(
media::learning::tasknames::kConsecutiveBadWindows,
bad_window_predictor_.BindNewPipeAndPassReceiver(task_runner));
}
if (GetLearningNnrThreshold() != -1.0) {
DCHECK_GE(GetLearningNnrThreshold(), 0);
metrics_provider->AcquireLearningTaskController(
media::learning::tasknames::kConsecutiveNNRs,
nnr_predictor_.BindNewPipeAndPassReceiver(task_runner));
}
return bad_window_predictor_.is_bound() || nnr_predictor_.is_bound();
}
bool MediaCapabilities::EnsurePerfHistoryService(
ExecutionContext* execution_context) {
if (decode_history_service_.is_bound())
return true;
if (!execution_context)
return false;
scoped_refptr<base::SingleThreadTaskRunner> task_runner =
execution_context->GetTaskRunner(TaskType::kMediaElementEvent);
execution_context->GetBrowserInterfaceBroker().GetInterface(
decode_history_service_.BindNewPipeAndPassReceiver(task_runner));
return true;
}
ScriptPromise MediaCapabilities::GetEmeSupport(
ScriptState* script_state,
media::VideoCodec video_codec,
media::VideoCodecProfile video_profile,
media::VideoColorSpace video_color_space,
const MediaDecodingConfiguration* configuration,
const base::TimeTicks& request_time,
ExceptionState& exception_state) {
DVLOG(3) << __func__;
DCHECK(configuration->hasKeySystemConfiguration());
// Calling context must have a real window bound to a Page. This check is
// ported from rMKSA (see http://crbug.com/456720).
if (!script_state->ContextIsValid()) {
exception_state.ThrowDOMException(
DOMExceptionCode::kInvalidStateError,
"The context provided is not associated with a page.");
return ScriptPromise();
}
ExecutionContext* execution_context = ExecutionContext::From(script_state);
DCHECK(execution_context);
// See context here:
// https://sites.google.com/a/chromium.org/dev/Home/chromium-security/deprecating-permissions-in-cross-origin-iframes
if (!execution_context->IsFeatureEnabled(
mojom::blink::FeaturePolicyFeature::kEncryptedMedia,
ReportOptions::kReportOnFailure)) {
UseCounter::Count(execution_context,
WebFeature::kEncryptedMediaDisabledByFeaturePolicy);
execution_context->AddConsoleMessage(MakeGarbageCollected<ConsoleMessage>(
mojom::ConsoleMessageSource::kJavaScript,
mojom::ConsoleMessageLevel::kWarning,
kEncryptedMediaFeaturePolicyConsoleWarning));
exception_state.ThrowSecurityError(
"decodingInfo(): Creating MediaKeySystemAccess is disabled by feature "
"policy.");
return ScriptPromise();
}
if (execution_context->IsWorkerGlobalScope()) {
exception_state.ThrowDOMException(
DOMExceptionCode::kInvalidStateError,
"Encrypted Media decoding info not available in Worker context.");
return ScriptPromise();
}
if (!execution_context->IsSecureContext()) {
exception_state.ThrowSecurityError(
"Encrypted Media decoding info can only be queried in a secure"
" context.");
return ScriptPromise();
}
const MediaCapabilitiesKeySystemConfiguration* key_system_config =
configuration->keySystemConfiguration();
if (!key_system_config->hasKeySystem() ||
key_system_config->keySystem().IsEmpty()) {
exception_state.ThrowTypeError("The key system String is not valid.");
return ScriptPromise();
}
MediaKeySystemConfiguration* eme_config =
MediaKeySystemConfiguration::Create();
// Set the initDataTypes attribute to a sequence containing
// config.keySystemConfiguration.initDataType.
// TODO(chcunningham): double check that this default is idiomatic. Here we
// can't check hasInitDataType() because the default ("") makes that always
// true. The default in EME is an empty list.
if (!key_system_config->initDataType().IsEmpty()) {
eme_config->setInitDataTypes(
Vector<String>(1, key_system_config->initDataType()));
}
// Set the distinctiveIdentifier attribute to
// config.keySystemConfiguration.distinctiveIdentifier.
eme_config->setDistinctiveIdentifier(
key_system_config->distinctiveIdentifier());
// Set the persistentState attribute to
// config.keySystemConfiguration.persistentState.
eme_config->setPersistentState(key_system_config->persistentState());
// Set the sessionTypes attribute to
// config.keySystemConfiguration.sessionTypes.
if (key_system_config->hasSessionTypes())
eme_config->setSessionTypes(key_system_config->sessionTypes());
// If an audio is present in config...
if (configuration->hasAudio()) {
// set the audioCapabilities attribute to a sequence containing a single
// MediaKeySystemMediaCapability, initialized as follows:
MediaKeySystemMediaCapability* audio_capability =
MediaKeySystemMediaCapability::Create();
// Set the contentType attribute to config.audio.contentType.
audio_capability->setContentType(configuration->audio()->contentType());
// If config.keySystemConfiguration.audio is present, set the robustness
// attribute to config.keySystemConfiguration.audio.robustness.
if (key_system_config->hasAudio())
audio_capability->setRobustness(key_system_config->audio()->robustness());
eme_config->setAudioCapabilities(
HeapVector<Member<MediaKeySystemMediaCapability>>(1, audio_capability));
}
// If a video is present in config...
if (configuration->hasVideo()) {
// set the videoCapabilities attribute to a sequence containing a single
// MediaKeySystemMediaCapability, initialized as follows:
MediaKeySystemMediaCapability* video_capability =
MediaKeySystemMediaCapability::Create();
// Set the contentType attribute to config.video.contentType.
video_capability->setContentType(configuration->video()->contentType());
// If config.keySystemConfiguration.video is present, set the robustness
// attribute to config.keySystemConfiguration.video.robustness.
if (key_system_config->hasVideo())
video_capability->setRobustness(key_system_config->video()->robustness());
eme_config->setVideoCapabilities(
HeapVector<Member<MediaKeySystemMediaCapability>>(1, video_capability));
}
HeapVector<Member<MediaKeySystemConfiguration>> config_vector(1, eme_config);
MediaCapabilitiesKeySystemAccessInitializer* initializer =
MakeGarbageCollected<MediaCapabilitiesKeySystemAccessInitializer>(
script_state, key_system_config->keySystem(), config_vector,
WTF::Bind(&MediaCapabilities::GetPerfInfo, WrapPersistent(this),
video_codec, video_profile, video_color_space,
WrapPersistent(configuration), request_time));
// IMPORTANT: Acquire the promise before potentially synchronously resolving
// it in the code that follows. Otherwise the promise returned to JS will be
// undefined. See comment above Promise() in script_promise_resolver.h
ScriptPromise promise = initializer->Promise();
Page* page = To<LocalDOMWindow>(execution_context)->GetFrame()->GetPage();
MediaKeysController::From(page)
->EncryptedMediaClient(execution_context)
->RequestMediaKeySystemAccess(WebEncryptedMediaRequest(initializer));
return promise;
}
void MediaCapabilities::GetPerfInfo(
media::VideoCodec video_codec,
media::VideoCodecProfile video_profile,
media::VideoColorSpace video_color_space,
const MediaDecodingConfiguration* decoding_config,
const base::TimeTicks& request_time,
ScriptPromiseResolver* resolver,
MediaKeySystemAccess* access) {
ExecutionContext* execution_context = resolver->GetExecutionContext();
if (!execution_context || execution_context->IsContextDestroyed())
return;
if (!decoding_config->hasVideo()) {
// Audio-only is always smooth and power efficient.
MediaCapabilitiesDecodingInfo* info = CreateDecodingInfoWith(true);
info->setKeySystemAccess(access);
resolver->Resolve(info);
return;
}
const VideoConfiguration* video_config = decoding_config->video();
String key_system = "";
bool use_hw_secure_codecs = false;
if (access) {
key_system = access->keySystem();
use_hw_secure_codecs = access->UseHardwareSecureCodecs();
}
if (!EnsurePerfHistoryService(execution_context)) {
resolver->Resolve(WrapPersistent(CreateDecodingInfoWith(true)));
return;
}
const int callback_id = CreateCallbackId();
pending_cb_map_.insert(
callback_id,
MakeGarbageCollected<MediaCapabilities::PendingCallbackState>(
resolver, access, request_time));
if (base::FeatureList::IsEnabled(media::kMediaLearningSmoothnessExperiment)) {
GetPerfInfo_ML(execution_context, callback_id, video_codec, video_profile,
video_config->width(), video_config->framerate());
}
media::mojom::blink::PredictionFeaturesPtr features =
media::mojom::blink::PredictionFeatures::New(
static_cast<media::mojom::blink::VideoCodecProfile>(video_profile),
gfx::Size(video_config->width(), video_config->height()),
video_config->framerate(), key_system, use_hw_secure_codecs);
decode_history_service_->GetPerfInfo(
std::move(features), WTF::Bind(&MediaCapabilities::OnPerfHistoryInfo,
WrapPersistent(this), callback_id));
if (UseGpuFactoriesForPowerEfficient(execution_context, access)) {
GetGpuFactoriesSupport(callback_id, video_codec, video_profile,
video_color_space, decoding_config);
}
}
void MediaCapabilities::GetPerfInfo_ML(ExecutionContext* execution_context,
int callback_id,
media::VideoCodec video_codec,
media::VideoCodecProfile video_profile,
int width,
double framerate) {
DCHECK(execution_context && !execution_context->IsContextDestroyed());
DCHECK(pending_cb_map_.Contains(callback_id));
if (!EnsureLearningPredictors(execution_context)) {
return;
}
// FRAGILE: Order here MUST match order in
// WebMediaPlayerImpl::UpdateSmoothnessHelper().
// TODO(chcunningham): refactor into something more robust.
Vector<media::learning::FeatureValue> ml_features(
{media::learning::FeatureValue(video_codec),
media::learning::FeatureValue(video_profile),
media::learning::FeatureValue(width),
media::learning::FeatureValue(framerate)});
if (bad_window_predictor_.is_bound()) {
bad_window_predictor_->PredictDistribution(
ml_features, WTF::Bind(&MediaCapabilities::OnBadWindowPrediction,
WrapPersistent(this), callback_id));
}
if (nnr_predictor_.is_bound()) {
nnr_predictor_->PredictDistribution(
ml_features, WTF::Bind(&MediaCapabilities::OnNnrPrediction,
WrapPersistent(this), callback_id));
}
}
void MediaCapabilities::GetGpuFactoriesSupport(
int callback_id,
media::VideoCodec video_codec,
media::VideoCodecProfile video_profile,
media::VideoColorSpace video_color_space,
const MediaDecodingConfiguration* decoding_config) {
DCHECK(decoding_config->hasVideo());
DCHECK(pending_cb_map_.Contains(callback_id));
PendingCallbackState* pending_cb = pending_cb_map_.at(callback_id);
if (!pending_cb) {
// TODO(crbug.com/1125956): Determine how this can happen and prevent it.
return;
}
ExecutionContext* execution_context =
pending_cb->resolver->GetExecutionContext();
DCHECK(UseGpuFactoriesForPowerEfficient(execution_context,
pending_cb->key_system_access));
// Frame may become detached in the time it takes us to get callback for
// NotifyDecoderSupportKnown. In this case, report false as a means of clean
// shutdown.
if (!execution_context || execution_context->IsContextDestroyed()) {
OnGpuFactoriesSupport(callback_id, false);
return;
}
media::GpuVideoAcceleratorFactories* gpu_factories =
Platform::Current()->GetGpuFactories();
if (!gpu_factories) {
OnGpuFactoriesSupport(callback_id, false);
return;
}
if (!gpu_factories->IsDecoderSupportKnown()) {
gpu_factories->NotifyDecoderSupportKnown(
WTF::Bind(&MediaCapabilities::GetGpuFactoriesSupport,
WrapPersistent(this), callback_id, video_codec, video_profile,
video_color_space, WrapPersistent(decoding_config)));
return;
}
// TODO(chcunningham): Get the actual scheme and alpha mode from
// |decoding_config| once implemented (its already spec'ed).
media::EncryptionScheme encryption_scheme =
decoding_config->hasKeySystemConfiguration()
? media::EncryptionScheme::kCenc
: media::EncryptionScheme::kUnencrypted;
media::VideoDecoderConfig::AlphaMode alpha_mode =
media::VideoDecoderConfig::AlphaMode::kIsOpaque;
// A few things aren't known until demuxing time. These include: coded size,
// visible rect, and extra data. Make reasonable guesses below. Ideally the
// differences won't be make/break GPU acceleration support.
const VideoConfiguration* video_config = decoding_config->video();
gfx::Size natural_size(video_config->width(), video_config->height());
media::VideoDecoderConfig config(
video_codec, video_profile, alpha_mode, video_color_space,
media::VideoTransformation(), natural_size /* coded_size */,
gfx::Rect(natural_size) /* visible_rect */, natural_size,
media::EmptyExtraData(), encryption_scheme);
static_assert(media::VideoDecoderImplementation::kAlternate ==
media::VideoDecoderImplementation::kMaxValue,
"Keep the array below in sync.");
media::VideoDecoderImplementation decoder_impls[] = {
media::VideoDecoderImplementation::kDefault,
media::VideoDecoderImplementation::kAlternate};
media::GpuVideoAcceleratorFactories::Supported supported =
media::GpuVideoAcceleratorFactories::Supported::kUnknown;
for (const auto& impl : decoder_impls) {
supported = gpu_factories->IsDecoderConfigSupported(impl, config);
DCHECK_NE(supported,
media::GpuVideoAcceleratorFactories::Supported::kUnknown);
if (supported == media::GpuVideoAcceleratorFactories::Supported::kTrue)
break;
}
OnGpuFactoriesSupport(
callback_id,
supported == media::GpuVideoAcceleratorFactories::Supported::kTrue);
}
void MediaCapabilities::ResolveCallbackIfReady(int callback_id) {
DCHECK(pending_cb_map_.Contains(callback_id));
PendingCallbackState* pending_cb = pending_cb_map_.at(callback_id);
ExecutionContext* execution_context =
pending_cb_map_.at(callback_id)->resolver->GetExecutionContext();
if (!pending_cb->db_is_power_efficient.has_value())
return;
// Both db_* fields should be set simultaneously by the DB callback.
DCHECK(pending_cb->db_is_smooth.has_value());
if (nnr_predictor_.is_bound() &&
!pending_cb->is_nnr_prediction_smooth.has_value())
return;
if (bad_window_predictor_.is_bound() &&
!pending_cb->is_bad_window_prediction_smooth.has_value())
return;
if (UseGpuFactoriesForPowerEfficient(execution_context,
pending_cb->key_system_access) &&
!pending_cb->is_gpu_factories_supported.has_value()) {
return;
}
if (!pending_cb->resolver->GetExecutionContext() ||
pending_cb->resolver->GetExecutionContext()->IsContextDestroyed()) {
// We're too late! Now that all the callbacks have provided state, its safe
// to erase the entry in the map.
pending_cb_map_.erase(callback_id);
return;
}
Persistent<MediaCapabilitiesDecodingInfo> info(
MediaCapabilitiesDecodingInfo::Create());
info->setSupported(true);
info->setKeySystemAccess(pending_cb->key_system_access);
if (UseGpuFactoriesForPowerEfficient(execution_context,
pending_cb->key_system_access)) {
info->setPowerEfficient(*pending_cb->is_gpu_factories_supported);
} else {
info->setPowerEfficient(*pending_cb->db_is_power_efficient);
}
// If ML experiment is running: AND available ML signals.
if (pending_cb->is_bad_window_prediction_smooth.has_value() ||
pending_cb->is_nnr_prediction_smooth.has_value()) {
info->setSmooth(
pending_cb->is_bad_window_prediction_smooth.value_or(true) &&
pending_cb->is_nnr_prediction_smooth.value_or(true));
} else {
// Use DB when ML experiment not running.
info->setSmooth(*pending_cb->db_is_smooth);
}
const base::TimeDelta process_time =
base::TimeTicks::Now() - pending_cb->request_time;
UMA_HISTOGRAM_TIMES("Media.Capabilities.DecodingInfo.Time.Video",
process_time);
// Record another time in the appropriate subset, either clear or encrypted
// content.
if (pending_cb->key_system_access) {
UMA_HISTOGRAM_TIMES("Media.Capabilities.DecodingInfo.Time.Video.Encrypted",
process_time);
} else {
UMA_HISTOGRAM_TIMES("Media.Capabilities.DecodingInfo.Time.Video.Clear",
process_time);
}
pending_cb->resolver->Resolve(std::move(info));
pending_cb_map_.erase(callback_id);
}
void MediaCapabilities::OnBadWindowPrediction(
int callback_id,
const base::Optional<::media::learning::TargetHistogram>& histogram) {
DCHECK(pending_cb_map_.Contains(callback_id));
PendingCallbackState* pending_cb = pending_cb_map_.at(callback_id);
std::stringstream histogram_log;
if (!histogram) {
// No data, so optimistically assume zero bad windows.
pending_cb->is_bad_window_prediction_smooth = true;
histogram_log << "none";
} else {
double histogram_average = histogram->Average();
pending_cb->is_bad_window_prediction_smooth =
histogram_average < GetLearningBadWindowThreshold();
histogram_log << histogram_average;
}
DVLOG(2) << __func__ << " bad_win_avg:" << histogram_log.str()
<< " smooth_threshold (<):" << GetLearningBadWindowThreshold();
ResolveCallbackIfReady(callback_id);
}
void MediaCapabilities::OnNnrPrediction(
int callback_id,
const base::Optional<::media::learning::TargetHistogram>& histogram) {
DCHECK(pending_cb_map_.Contains(callback_id));
PendingCallbackState* pending_cb = pending_cb_map_.at(callback_id);
std::stringstream histogram_log;
if (!histogram) {
// No data, so optimistically assume zero NNRs
pending_cb->is_nnr_prediction_smooth = true;
histogram_log << "none";
} else {
double histogram_average = histogram->Average();
pending_cb->is_nnr_prediction_smooth =
histogram_average < GetLearningNnrThreshold();
histogram_log << histogram_average;
}
DVLOG(2) << __func__ << " nnr_avg:" << histogram_log.str()
<< " smooth_threshold (<):" << GetLearningNnrThreshold();
ResolveCallbackIfReady(callback_id);
}
void MediaCapabilities::OnPerfHistoryInfo(int callback_id,
bool is_smooth,
bool is_power_efficient) {
DCHECK(pending_cb_map_.Contains(callback_id));
PendingCallbackState* pending_cb = pending_cb_map_.at(callback_id);
pending_cb->db_is_smooth = is_smooth;
pending_cb->db_is_power_efficient = is_power_efficient;
ResolveCallbackIfReady(callback_id);
}
void MediaCapabilities::OnGpuFactoriesSupport(int callback_id,
bool is_supported) {
DVLOG(2) << __func__ << " is_supported:" << is_supported;
DCHECK(pending_cb_map_.Contains(callback_id));
PendingCallbackState* pending_cb = pending_cb_map_.at(callback_id);
pending_cb->is_gpu_factories_supported = is_supported;
ResolveCallbackIfReady(callback_id);
}
int MediaCapabilities::CreateCallbackId() {
// Search for the next available callback ID. 0 and -1 are reserved by
// wtf::HashMap (meaning "empty" and "deleted").
do {
++last_callback_id_;
} while (last_callback_id_ == 0 || last_callback_id_ == -1 ||
pending_cb_map_.Contains(last_callback_id_));
return last_callback_id_;
}
} // namespace blink
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
f1d4579f27554292425a51253157b069a4d48888 | ff224fbbf41b4fa23adeca9208a7f386e5eaf890 | /packages/2HDMC-1.7.0/src/Demo.cpp | 5701fcb6a3ad2dc6f8dd5d7ba578c2edae061d66 | [] | no_license | hep-magellan/THDM_T3PS_scanner | 90774baa6f6897503042c770c338f78bb1d1349c | 766c7fde94e351c1d8616aae1fc0bf5fa631cb26 | refs/heads/master | 2021-06-24T02:54:47.259633 | 2020-12-30T20:52:44 | 2020-12-30T20:52:44 | 182,444,947 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,430 | cpp | /*******************************************************************************
2HDMC - two-Higgs-doublet model calculator
Demo program
http://2hdmc.hepforge.org
*******************************************************************************/
#include "THDM.h"
#include "SM.h"
#include "HBHS.h"
#include "Constraints.h"
#include "DecayTable.h"
#include <iostream>
using namespace std;
int main(int argc, char* argv[]) {
// Reference SM Higgs mass for EW precision observables
double mh_ref = 125.;
// Create SM and set parameters
SM sm;
sm.set_qmass_pole(6, 172.5);
sm.set_qmass_pole(5, 4.75);
sm.set_qmass_pole(4, 1.42);
sm.set_lmass_pole(3, 1.77684);
sm.set_alpha(1./127.934);
sm.set_alpha0(1./137.0359997);
sm.set_alpha_s(0.119);
sm.set_MZ(91.15349);
sm.set_MW(80.36951);
sm.set_gamma_Z(2.49581);
sm.set_gamma_W(2.08856);
sm.set_GF(1.16637E-5);
// Create 2HDM and set SM parameters
THDM model;
model.set_SM(sm);
// Set parameters of the 2HDM in the 'physical' basis
double mh = 125.;
double mH = 400.;
double mA = 500.;
double mC = 550.;
double sba = 0.999;
double lambda_6 = 0.;
double lambda_7 = 0.;
double m12_2 = 15800.;
double tb = 10.;
bool pset = model.set_param_phys(mh,mH,mA,mC,sba,lambda_6,lambda_7,m12_2,tb);
if (!pset) {
cerr << "The specified parameters are not valid\n";
return -1;
}
#if defined HiggsBounds
HB_init();
HS_init();
#endif
// Set Yukawa couplings to type II
model.set_yukawas_type(2);
// Print the parameters in different parametrizations
model.print_param_phys();
model.print_param_gen();
model.print_param_higgs();
model.print_param_hybrid();
// Prepare to calculate observables
Constraints constr(model);
double S,T,U,V,W,X;
constr.oblique_param(mh_ref,S,T,U,V,W,X);
printf("\nConstraints:\n");
printf(" Potential stability: %s\n",
(constr.check_stability() ? "OK" : "Not OK"));
printf(" Tree-level unitarity: %s\n",
(constr.check_unitarity() ? "OK" : "Not OK"));
printf(" Perturbativity: %s\n",
(constr.check_perturbativity() ? "OK" : "Not OK"));
printf("\n");
printf(" Oblique S: %12.5e\n", S);
printf(" Oblique T: %12.5e\n", T);
printf(" Oblique U: %12.5e\n", U);
printf(" Oblique V: %12.5e\n", V);
printf(" Oblique W: %12.5e\n", W);
printf(" Oblique X: %12.5e\n", X);
printf(" Delta_rho: %12.5e\n", constr.delta_rho(mh_ref));
printf("\n");
printf(" Delta_amu: %12.5e\n\n", constr.delta_amu());
#if defined HiggsBounds
// See HiggsSignals manual for more information
int mass_pdf = 2;
HS_set_pdf(mass_pdf);
HS_setup_assignment_range_massobservables(2.);
HS_set_output_level(0);
// Share couplings of 2HDM model with HiggsBounds/HiggsSignals
HB_set_input_effC(model);
// Arrays hold the HiggsBounds results
int hbres[6];
double hbobs[6];
int hbchan[6];
int hbcomb[6];
// Run HiggsBounds 'full', i.e. with each Higgs result separately
HB_run_full(hbres, hbchan, hbobs, hbcomb);
printf("\nHiggsBounds results (full):\n");
printf(" Higgs res chan ratio ncomb\n");
for (int i=1;i<=4;i++) {
printf("%5d %5d %6d %16.8E %5d %s\n", i, hbres[i],hbchan[i],hbobs[i],hbcomb[i],hbobs[i]<1 ? "Allowed" : "Excluded");
}
printf("------------------------------------------------------------\n");
printf(" TOT %5d %6d %16.8E %5d %s\n", hbres[0],hbchan[0],hbobs[0],hbcomb[0],hbobs[0]<1 ? "ALLOWED" : "EXCLUDED");
double csqmu;
double csqmh;
double csqtot;
int nobs;
double pval;
double dMh[3]={0., 0., 0.,};
HS_set_mass_uncertainties(dMh);
HS_run(&csqmu, &csqmh, &csqtot, &nobs, &pval);
printf("\nHiggsSignals results:\n");
printf(" Chi^2 from rates: %16.8E\n", csqmu);
printf(" Chi^2 from mass: %16.8E\n", csqmh);
printf(" Total chi^2: %16.8E\n", csqtot);
printf(" # observables: %16d\n\n", nobs);
#endif
// Prepare to calculate decay widths
DecayTable table(model);
// Print total widths of Higgs bosons
table.print_width(1);
table.print_width(2);
table.print_width(3);
table.print_width(4);
table.print_decays(1);
table.print_decays(2);
table.print_decays(3);
table.print_decays(4);
// Write output to LesHouches file
model.write_LesHouches("Demo_out.lha", 1, 0, 1, 1);
#if defined HiggsBounds
HB_finish();
HS_finish();
#endif
}
| [
"englert.david@gmail.com"
] | englert.david@gmail.com |
b45e8f7df0572c7f8d73c0ee4c79e58fbe6609a2 | f9e3d7b4e0fcd6b7bd9437a2c7774fbff86879ca | /helios/core/scene.cpp | 64ec895483b49d1a05dbbdf3322d4ec38c215567 | [
"MIT"
] | permissive | filipecn/helios | ac41c1277c6cf952f1359804cd24ffd3cf37767e | 5c64c36485c403858279f66870f5d31f8722edb9 | refs/heads/main | 2023-08-27T04:27:11.382349 | 2021-11-02T23:16:51 | 2021-11-02T23:16:51 | 353,388,522 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,022 | cpp | /// Copyright (c) 2021, FilipeCN.
///
/// The MIT License (MIT)
///
/// 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.
///
///\file scene.cpp
///\author FilipeCN (filipedecn@gmail.com)
///\date 2021-08-12
///
///\brief
#include <helios/core/scene.h>
#include <helios/accelerators/list.h>
#include <hermes/common/cuda_utils.h>
namespace helios {
HERMES_DEVICE_CALLABLE const bounds3 &Scene::View::worldBound() const {
if (aggregate_.type == AggregateType::LIST)
return aggregate_.data_ptr.get<ListAggregate::View>()->worldBound();
return {};
}
HERMES_DEVICE_CALLABLE ShapeIntersectionReturn Scene::View::intersect(const Ray &ray) const {
// TODO check ray direction not null
if (aggregate_.type == AggregateType::LIST)
return aggregate_.data_ptr.get<ListAggregate::View>()->intersect(ray);
return {};
}
HERMES_DEVICE_CALLABLE bool Scene::View::intersectP(const Ray &ray) const {
// TODO check ray direction not null
if (aggregate_.type == AggregateType::LIST)
return aggregate_.data_ptr.get<ListAggregate::View>()->intersectP(ray);
return false;
}
Scene::Scene() = default;
Scene::~Scene() = default;
HERMES_CUDA_KERNEL(updatePointers)(hermes::ArrayView<Light> a, hermes::StackAllocatorView m) {
HERMES_CUDA_THREAD_INDEX_I
a[i].data_ptr.update(m);
}
HERMES_CUDA_KERNEL(updatePointers)(hermes::ArrayView<Shape> a, hermes::StackAllocatorView m) {
HERMES_CUDA_THREAD_INDEX_I
a[i].data_ptr.update(m);
}
HERMES_CUDA_KERNEL(updatePointers)(hermes::ArrayView<Primitive> a, hermes::StackAllocatorView m) {
HERMES_CUDA_THREAD_INDEX_I
a[i].data_ptr.update(m);
CAST_PRIMITIVE(a[i], ptr,
ptr->shape.data_ptr.update(m);)
}
HeResult Scene::prepare() {
// chose default struct if none
if (!aggregate_) {
aggregate_ = {
.data_ptr = mem::allocate<ListAggregate>(),
.type = AggregateType::LIST
};
aggregate_view_ = {
.data_ptr = mem::allocate<ListAggregate::View>(),
.type = AggregateType::LIST
};
}
// send data to gpu
d_lights_ = lights_;
d_shapes_ = shapes_;
d_primitives_ = primitives_;
// setup acceleration structure
aggregate_.data_ptr.get<ListAggregate>()->init(primitives_, d_primitives_.constView());
*aggregate_view_.data_ptr.get<ListAggregate::View>() = aggregate_.data_ptr.get<ListAggregate>()->view();
// send resources memory to gpu
mem::sendToGPU();
// update pointers
HERMES_CUDA_LAUNCH_AND_SYNC((d_lights_.size()), updatePointers_k, d_lights_.view(), mem::gpuView());
HERMES_CUDA_LAUNCH_AND_SYNC((d_shapes_.size()), updatePointers_k, d_shapes_.view(), mem::gpuView());
HERMES_CUDA_LAUNCH_AND_SYNC((d_primitives_.size()), updatePointers_k, d_primitives_.view(), mem::gpuView());
aggregate_.data_ptr.update(mem::gpuView());
aggregate_view_.data_ptr.update(mem::gpuView());
return HeResult::SUCCESS;
}
Scene::View Scene::view() const {
return View(aggregate_view_, d_lights_.view(), d_primitives_.view(), d_shapes_.view());
}
} | [
"fuiripecn@gmail.com"
] | fuiripecn@gmail.com |
a0ba5464bfa60537560bb8a885d5502d6a12858f | 61a92aea1fde3a07db7704551b935a46e7bd8acf | /src/Cpl/Text/atob.h | 39c5da4ec7aa67e8ab5923f4440148f7945f76bd | [] | no_license | mraitman/colony.core | c657b67cf934aba8919fef7f01a088989854503c | 24abdba49f820d9f516b28afa1e160cd8c241f8a | refs/heads/master | 2020-06-28T02:32:49.087022 | 2019-05-27T15:59:11 | 2019-05-27T15:59:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,023 | h | #ifndef Cpl_Text_atob_h_
#define Cpl_Text_atob_h_
/*-----------------------------------------------------------------------------
* This file is part of the Colony.Core Project. The Colony.Core Project is an
* open source project with a BSD type of licensing agreement. See the license
* agreement (license.txt) in the top/ directory or on the Internet at
* http://integerfox.com/colony.core/license.txt
*
* Copyright (c) 2014-2019 John T. Taylor
*
* Redistributions of the source code must retain the above copyright notice.
*----------------------------------------------------------------------------*/
/** @file
This file contains a collection of methods that wrap the standard C
library functions for converting text/string to binary values.
*/
#include <stdlib.h>
#include "colony_map.h"
///
namespace Cpl {
///
namespace Text {
/** This method converts the specified string to an integer. The method returns
true if the conversion was successful. When false is returned, the
'convertedValue' argument is NOT updated. By default the conversion assumes
a base 10 number and that the 'end-of-number' is end-of-string. If endptr
is specified and the conversation was successful, a pointer to the first
character 'after' the number is returned.
*/
bool a2i( int& convertedValue, const char* string, int base=10, const char* validStopChars=0, const char** endptr=0 );
/** This method is the same as a2i() except that it converts unsigned integer.
*/
bool a2ui( unsigned& convertedValue, const char* string, int base=10, const char* validStopChars=0, const char** endptr=0 );
/** This method is the same as a2i() except that it converts long integer.
*/
bool a2l( long& convertedValue, const char* string, int base=10, const char* validStopChars=0, const char** endptr=0 );
/** This method is the same as a2i() except that it converts unsigned long
integer.
*/
bool a2ul( unsigned long& convertedValue, const char* string, int base=10, const char* validStopChars=0, const char** endptr=0 );
/** This method is the same as a2i() except that it converts long long
integer.
*/
bool a2ll( long long& convertedValue, const char* string, int base=10, const char* validStopChars=0, const char** endptr=0 );
/** This method is the same as a2i() except that it converts unsigned long long
integer.
*/
bool a2ull( unsigned long long& convertedValue, const char* string, int base=10, const char* validStopChars=0, const char** endptr=0 );
/** This method converts the specified string to an double. The method returns
true if the conversion was successful. When false is returned, the
'convertedValue' argument is NOT updated. By default the conversion assumes
that the 'end-of-number' is end-of-string. If endptr is specified and the
method returns true, a pointer to the first character 'after' the number is
returned.
*/
bool a2d( double& convertedValue, const char* string, const char* validStopChars=0, const char** endptr=0 );
/** This method convert the specified string to an boolean. The method returns
true if the conversion was successful. When false is returned, the
'convertedValue' argument is NOT updated. If the first N characters of
'string' match the specified boolean token - the conversion is consider
successful (i.e. there is no required separator/terminator character for
a boolean token). If endptr is specified and the method returns true, a
pointer to the first character 'after' the boolean token is returned.
*/
bool a2b( bool& convertedValue, const char* string, const char* trueToken="T", const char* falseToken="F", const char** endptr=0 );
/** This method will convert an 'ASCII HEX' string to an equivalent binary
buffer, i.e. the reverse of bufferToAsciiHex() in format.h. If the entire
string was not able to be converted then -1 is returned, else the number
of converted bytes are returned.
*/
long asciiHexToBuffer( void* dstBinary, const char* srcString, size_t dstMaxLen );
}; // end namespaces
};
#endif // end header latch
| [
"john.t.taylor@gmail.com"
] | john.t.taylor@gmail.com |
028f07116fa03b42cdff6a7a054edbfc7285bd3c | d9c77dfdfa7532b520e855c3ed6bc749cf852f93 | /codechef/XOR_Equal.cpp | e1136d5f83e65f8edb7ebf0a14f003c57da5da50 | [] | no_license | yash56244/CP-Contest-Problems-and-templates | 4e9f93e594efe0102c010753221a5712451b2b63 | 58b150aa85af6efb065991b520dc693c316fd1e1 | refs/heads/main | 2023-07-30T02:42:16.122273 | 2021-09-11T04:19:20 | 2021-09-11T04:19:20 | 328,662,531 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,265 | cpp | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define yes cout << "YES" << endl
#define no cout << "NO" << endl
#define FOR(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FORL(i, a, n) for (int(i) = (a); (i) <= (n); (i)++)
#define FORR(i, a, n) for (int(i) = (a); (i) >= (n); (i)--)
#define FORSQ(i, a, n) for (int(i) = (a); (i) * (i) <= (n); ++(i))
#define FOREACH(a, b) for (auto &(a) : (b))
#define all(v) v.begin(), v.end()
#define SORT(v) sort(ALL(v))
#define log(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
#define logcontainer(container) \
for (auto &(e) : (container)) \
cout << (e) << " "; \
cout << endl;
void err(istream_iterator<string> it)
{
}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args)
{
cout << *it << " = " << a << endl;
err(++it, args...);
}
typedef long long int ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> pll;
typedef vector<pll> vll;
typedef vector<bool> vb;
typedef priority_queue<ll> maxheap;
typedef priority_queue<ll, vl, greater<ll>> minheap;
typedef map<ll, ll> mapll;
const ll inf = 1e18;
const ll mod = 1e9 + 7;
const ll maxn = 2e6 + 5;
ll Mod(ll a, ll b)
{
return (b + a % b) % b;
}
void yash56244()
{
ll n, x;
cin >> n >> x;
ll arr[n];
mapll mp1, mp2;
FOR(i, n)
{
cin >> arr[i];
mp1[arr[i]]++;
mp2[arr[i]] = 1;
}
ll a = 0, b = inf;
FOREACH(e, mp1)
{
a = max(a, e.second);
}
FOREACH(e, mp1)
{
if (mp2.find(e.first ^ x) != mp2.end())
{
a = max(a, e.second + mp1[e.first ^ x]);
b = min(b, min(e.second, mp1[e.first ^ x]));
}
}
cout << a << " " << b << endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--)
{
yash56244();
}
return 0;
} | [
"yash56244@gmail.com"
] | yash56244@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.